]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/infiniband/hw/amso1100/c2.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'exec_rm_compat' of git://git.kernel.org/pub/scm/linux/kernel/git/oleg...
[mirror_ubuntu-bionic-kernel.git] / drivers / infiniband / hw / amso1100 / c2.c
1 /*
2 * Copyright (c) 2005 Ammasso, Inc. All rights reserved.
3 * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33 #include <linux/module.h>
34 #include <linux/moduleparam.h>
35 #include <linux/pci.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/inetdevice.h>
39 #include <linux/delay.h>
40 #include <linux/ethtool.h>
41 #include <linux/mii.h>
42 #include <linux/if_vlan.h>
43 #include <linux/crc32.h>
44 #include <linux/in.h>
45 #include <linux/ip.h>
46 #include <linux/tcp.h>
47 #include <linux/init.h>
48 #include <linux/dma-mapping.h>
49 #include <linux/slab.h>
50 #include <linux/prefetch.h>
51
52 #include <asm/io.h>
53 #include <asm/irq.h>
54 #include <asm/byteorder.h>
55
56 #include <rdma/ib_smi.h>
57 #include "c2.h"
58 #include "c2_provider.h"
59
60 MODULE_AUTHOR("Tom Tucker <tom@opengridcomputing.com>");
61 MODULE_DESCRIPTION("Ammasso AMSO1100 Low-level iWARP Driver");
62 MODULE_LICENSE("Dual BSD/GPL");
63 MODULE_VERSION(DRV_VERSION);
64
65 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
66 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
67
68 static int debug = -1; /* defaults above */
69 module_param(debug, int, 0);
70 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
71
72 static int c2_up(struct net_device *netdev);
73 static int c2_down(struct net_device *netdev);
74 static int c2_xmit_frame(struct sk_buff *skb, struct net_device *netdev);
75 static void c2_tx_interrupt(struct net_device *netdev);
76 static void c2_rx_interrupt(struct net_device *netdev);
77 static irqreturn_t c2_interrupt(int irq, void *dev_id);
78 static void c2_tx_timeout(struct net_device *netdev);
79 static int c2_change_mtu(struct net_device *netdev, int new_mtu);
80 static void c2_reset(struct c2_port *c2_port);
81
82 static struct pci_device_id c2_pci_table[] = {
83 { PCI_DEVICE(0x18b8, 0xb001) },
84 { 0 }
85 };
86
87 MODULE_DEVICE_TABLE(pci, c2_pci_table);
88
89 static void c2_print_macaddr(struct net_device *netdev)
90 {
91 pr_debug("%s: MAC %pM, IRQ %u\n", netdev->name, netdev->dev_addr, netdev->irq);
92 }
93
94 static void c2_set_rxbufsize(struct c2_port *c2_port)
95 {
96 struct net_device *netdev = c2_port->netdev;
97
98 if (netdev->mtu > RX_BUF_SIZE)
99 c2_port->rx_buf_size =
100 netdev->mtu + ETH_HLEN + sizeof(struct c2_rxp_hdr) +
101 NET_IP_ALIGN;
102 else
103 c2_port->rx_buf_size = sizeof(struct c2_rxp_hdr) + RX_BUF_SIZE;
104 }
105
106 /*
107 * Allocate TX ring elements and chain them together.
108 * One-to-one association of adapter descriptors with ring elements.
109 */
110 static int c2_tx_ring_alloc(struct c2_ring *tx_ring, void *vaddr,
111 dma_addr_t base, void __iomem * mmio_txp_ring)
112 {
113 struct c2_tx_desc *tx_desc;
114 struct c2_txp_desc __iomem *txp_desc;
115 struct c2_element *elem;
116 int i;
117
118 tx_ring->start = kmalloc(sizeof(*elem) * tx_ring->count, GFP_KERNEL);
119 if (!tx_ring->start)
120 return -ENOMEM;
121
122 elem = tx_ring->start;
123 tx_desc = vaddr;
124 txp_desc = mmio_txp_ring;
125 for (i = 0; i < tx_ring->count; i++, elem++, tx_desc++, txp_desc++) {
126 tx_desc->len = 0;
127 tx_desc->status = 0;
128
129 /* Set TXP_HTXD_UNINIT */
130 __raw_writeq((__force u64) cpu_to_be64(0x1122334455667788ULL),
131 (void __iomem *) txp_desc + C2_TXP_ADDR);
132 __raw_writew(0, (void __iomem *) txp_desc + C2_TXP_LEN);
133 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_UNINIT),
134 (void __iomem *) txp_desc + C2_TXP_FLAGS);
135
136 elem->skb = NULL;
137 elem->ht_desc = tx_desc;
138 elem->hw_desc = txp_desc;
139
140 if (i == tx_ring->count - 1) {
141 elem->next = tx_ring->start;
142 tx_desc->next_offset = base;
143 } else {
144 elem->next = elem + 1;
145 tx_desc->next_offset =
146 base + (i + 1) * sizeof(*tx_desc);
147 }
148 }
149
150 tx_ring->to_use = tx_ring->to_clean = tx_ring->start;
151
152 return 0;
153 }
154
155 /*
156 * Allocate RX ring elements and chain them together.
157 * One-to-one association of adapter descriptors with ring elements.
158 */
159 static int c2_rx_ring_alloc(struct c2_ring *rx_ring, void *vaddr,
160 dma_addr_t base, void __iomem * mmio_rxp_ring)
161 {
162 struct c2_rx_desc *rx_desc;
163 struct c2_rxp_desc __iomem *rxp_desc;
164 struct c2_element *elem;
165 int i;
166
167 rx_ring->start = kmalloc(sizeof(*elem) * rx_ring->count, GFP_KERNEL);
168 if (!rx_ring->start)
169 return -ENOMEM;
170
171 elem = rx_ring->start;
172 rx_desc = vaddr;
173 rxp_desc = mmio_rxp_ring;
174 for (i = 0; i < rx_ring->count; i++, elem++, rx_desc++, rxp_desc++) {
175 rx_desc->len = 0;
176 rx_desc->status = 0;
177
178 /* Set RXP_HRXD_UNINIT */
179 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_OK),
180 (void __iomem *) rxp_desc + C2_RXP_STATUS);
181 __raw_writew(0, (void __iomem *) rxp_desc + C2_RXP_COUNT);
182 __raw_writew(0, (void __iomem *) rxp_desc + C2_RXP_LEN);
183 __raw_writeq((__force u64) cpu_to_be64(0x99aabbccddeeffULL),
184 (void __iomem *) rxp_desc + C2_RXP_ADDR);
185 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_UNINIT),
186 (void __iomem *) rxp_desc + C2_RXP_FLAGS);
187
188 elem->skb = NULL;
189 elem->ht_desc = rx_desc;
190 elem->hw_desc = rxp_desc;
191
192 if (i == rx_ring->count - 1) {
193 elem->next = rx_ring->start;
194 rx_desc->next_offset = base;
195 } else {
196 elem->next = elem + 1;
197 rx_desc->next_offset =
198 base + (i + 1) * sizeof(*rx_desc);
199 }
200 }
201
202 rx_ring->to_use = rx_ring->to_clean = rx_ring->start;
203
204 return 0;
205 }
206
207 /* Setup buffer for receiving */
208 static inline int c2_rx_alloc(struct c2_port *c2_port, struct c2_element *elem)
209 {
210 struct c2_dev *c2dev = c2_port->c2dev;
211 struct c2_rx_desc *rx_desc = elem->ht_desc;
212 struct sk_buff *skb;
213 dma_addr_t mapaddr;
214 u32 maplen;
215 struct c2_rxp_hdr *rxp_hdr;
216
217 skb = dev_alloc_skb(c2_port->rx_buf_size);
218 if (unlikely(!skb)) {
219 pr_debug("%s: out of memory for receive\n",
220 c2_port->netdev->name);
221 return -ENOMEM;
222 }
223
224 /* Zero out the rxp hdr in the sk_buff */
225 memset(skb->data, 0, sizeof(*rxp_hdr));
226
227 skb->dev = c2_port->netdev;
228
229 maplen = c2_port->rx_buf_size;
230 mapaddr =
231 pci_map_single(c2dev->pcidev, skb->data, maplen,
232 PCI_DMA_FROMDEVICE);
233
234 /* Set the sk_buff RXP_header to RXP_HRXD_READY */
235 rxp_hdr = (struct c2_rxp_hdr *) skb->data;
236 rxp_hdr->flags = RXP_HRXD_READY;
237
238 __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
239 __raw_writew((__force u16) cpu_to_be16((u16) maplen - sizeof(*rxp_hdr)),
240 elem->hw_desc + C2_RXP_LEN);
241 __raw_writeq((__force u64) cpu_to_be64(mapaddr), elem->hw_desc + C2_RXP_ADDR);
242 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
243 elem->hw_desc + C2_RXP_FLAGS);
244
245 elem->skb = skb;
246 elem->mapaddr = mapaddr;
247 elem->maplen = maplen;
248 rx_desc->len = maplen;
249
250 return 0;
251 }
252
253 /*
254 * Allocate buffers for the Rx ring
255 * For receive: rx_ring.to_clean is next received frame
256 */
257 static int c2_rx_fill(struct c2_port *c2_port)
258 {
259 struct c2_ring *rx_ring = &c2_port->rx_ring;
260 struct c2_element *elem;
261 int ret = 0;
262
263 elem = rx_ring->start;
264 do {
265 if (c2_rx_alloc(c2_port, elem)) {
266 ret = 1;
267 break;
268 }
269 } while ((elem = elem->next) != rx_ring->start);
270
271 rx_ring->to_clean = rx_ring->start;
272 return ret;
273 }
274
275 /* Free all buffers in RX ring, assumes receiver stopped */
276 static void c2_rx_clean(struct c2_port *c2_port)
277 {
278 struct c2_dev *c2dev = c2_port->c2dev;
279 struct c2_ring *rx_ring = &c2_port->rx_ring;
280 struct c2_element *elem;
281 struct c2_rx_desc *rx_desc;
282
283 elem = rx_ring->start;
284 do {
285 rx_desc = elem->ht_desc;
286 rx_desc->len = 0;
287
288 __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
289 __raw_writew(0, elem->hw_desc + C2_RXP_COUNT);
290 __raw_writew(0, elem->hw_desc + C2_RXP_LEN);
291 __raw_writeq((__force u64) cpu_to_be64(0x99aabbccddeeffULL),
292 elem->hw_desc + C2_RXP_ADDR);
293 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_UNINIT),
294 elem->hw_desc + C2_RXP_FLAGS);
295
296 if (elem->skb) {
297 pci_unmap_single(c2dev->pcidev, elem->mapaddr,
298 elem->maplen, PCI_DMA_FROMDEVICE);
299 dev_kfree_skb(elem->skb);
300 elem->skb = NULL;
301 }
302 } while ((elem = elem->next) != rx_ring->start);
303 }
304
305 static inline int c2_tx_free(struct c2_dev *c2dev, struct c2_element *elem)
306 {
307 struct c2_tx_desc *tx_desc = elem->ht_desc;
308
309 tx_desc->len = 0;
310
311 pci_unmap_single(c2dev->pcidev, elem->mapaddr, elem->maplen,
312 PCI_DMA_TODEVICE);
313
314 if (elem->skb) {
315 dev_kfree_skb_any(elem->skb);
316 elem->skb = NULL;
317 }
318
319 return 0;
320 }
321
322 /* Free all buffers in TX ring, assumes transmitter stopped */
323 static void c2_tx_clean(struct c2_port *c2_port)
324 {
325 struct c2_ring *tx_ring = &c2_port->tx_ring;
326 struct c2_element *elem;
327 struct c2_txp_desc txp_htxd;
328 int retry;
329 unsigned long flags;
330
331 spin_lock_irqsave(&c2_port->tx_lock, flags);
332
333 elem = tx_ring->start;
334
335 do {
336 retry = 0;
337 do {
338 txp_htxd.flags =
339 readw(elem->hw_desc + C2_TXP_FLAGS);
340
341 if (txp_htxd.flags == TXP_HTXD_READY) {
342 retry = 1;
343 __raw_writew(0,
344 elem->hw_desc + C2_TXP_LEN);
345 __raw_writeq(0,
346 elem->hw_desc + C2_TXP_ADDR);
347 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_DONE),
348 elem->hw_desc + C2_TXP_FLAGS);
349 c2_port->netdev->stats.tx_dropped++;
350 break;
351 } else {
352 __raw_writew(0,
353 elem->hw_desc + C2_TXP_LEN);
354 __raw_writeq((__force u64) cpu_to_be64(0x1122334455667788ULL),
355 elem->hw_desc + C2_TXP_ADDR);
356 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_UNINIT),
357 elem->hw_desc + C2_TXP_FLAGS);
358 }
359
360 c2_tx_free(c2_port->c2dev, elem);
361
362 } while ((elem = elem->next) != tx_ring->start);
363 } while (retry);
364
365 c2_port->tx_avail = c2_port->tx_ring.count - 1;
366 c2_port->c2dev->cur_tx = tx_ring->to_use - tx_ring->start;
367
368 if (c2_port->tx_avail > MAX_SKB_FRAGS + 1)
369 netif_wake_queue(c2_port->netdev);
370
371 spin_unlock_irqrestore(&c2_port->tx_lock, flags);
372 }
373
374 /*
375 * Process transmit descriptors marked 'DONE' by the firmware,
376 * freeing up their unneeded sk_buffs.
377 */
378 static void c2_tx_interrupt(struct net_device *netdev)
379 {
380 struct c2_port *c2_port = netdev_priv(netdev);
381 struct c2_dev *c2dev = c2_port->c2dev;
382 struct c2_ring *tx_ring = &c2_port->tx_ring;
383 struct c2_element *elem;
384 struct c2_txp_desc txp_htxd;
385
386 spin_lock(&c2_port->tx_lock);
387
388 for (elem = tx_ring->to_clean; elem != tx_ring->to_use;
389 elem = elem->next) {
390 txp_htxd.flags =
391 be16_to_cpu((__force __be16) readw(elem->hw_desc + C2_TXP_FLAGS));
392
393 if (txp_htxd.flags != TXP_HTXD_DONE)
394 break;
395
396 if (netif_msg_tx_done(c2_port)) {
397 /* PCI reads are expensive in fast path */
398 txp_htxd.len =
399 be16_to_cpu((__force __be16) readw(elem->hw_desc + C2_TXP_LEN));
400 pr_debug("%s: tx done slot %3Zu status 0x%x len "
401 "%5u bytes\n",
402 netdev->name, elem - tx_ring->start,
403 txp_htxd.flags, txp_htxd.len);
404 }
405
406 c2_tx_free(c2dev, elem);
407 ++(c2_port->tx_avail);
408 }
409
410 tx_ring->to_clean = elem;
411
412 if (netif_queue_stopped(netdev)
413 && c2_port->tx_avail > MAX_SKB_FRAGS + 1)
414 netif_wake_queue(netdev);
415
416 spin_unlock(&c2_port->tx_lock);
417 }
418
419 static void c2_rx_error(struct c2_port *c2_port, struct c2_element *elem)
420 {
421 struct c2_rx_desc *rx_desc = elem->ht_desc;
422 struct c2_rxp_hdr *rxp_hdr = (struct c2_rxp_hdr *) elem->skb->data;
423
424 if (rxp_hdr->status != RXP_HRXD_OK ||
425 rxp_hdr->len > (rx_desc->len - sizeof(*rxp_hdr))) {
426 pr_debug("BAD RXP_HRXD\n");
427 pr_debug(" rx_desc : %p\n", rx_desc);
428 pr_debug(" index : %Zu\n",
429 elem - c2_port->rx_ring.start);
430 pr_debug(" len : %u\n", rx_desc->len);
431 pr_debug(" rxp_hdr : %p [PA %p]\n", rxp_hdr,
432 (void *) __pa((unsigned long) rxp_hdr));
433 pr_debug(" flags : 0x%x\n", rxp_hdr->flags);
434 pr_debug(" status: 0x%x\n", rxp_hdr->status);
435 pr_debug(" len : %u\n", rxp_hdr->len);
436 pr_debug(" rsvd : 0x%x\n", rxp_hdr->rsvd);
437 }
438
439 /* Setup the skb for reuse since we're dropping this pkt */
440 elem->skb->data = elem->skb->head;
441 skb_reset_tail_pointer(elem->skb);
442
443 /* Zero out the rxp hdr in the sk_buff */
444 memset(elem->skb->data, 0, sizeof(*rxp_hdr));
445
446 /* Write the descriptor to the adapter's rx ring */
447 __raw_writew(0, elem->hw_desc + C2_RXP_STATUS);
448 __raw_writew(0, elem->hw_desc + C2_RXP_COUNT);
449 __raw_writew((__force u16) cpu_to_be16((u16) elem->maplen - sizeof(*rxp_hdr)),
450 elem->hw_desc + C2_RXP_LEN);
451 __raw_writeq((__force u64) cpu_to_be64(elem->mapaddr),
452 elem->hw_desc + C2_RXP_ADDR);
453 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
454 elem->hw_desc + C2_RXP_FLAGS);
455
456 pr_debug("packet dropped\n");
457 c2_port->netdev->stats.rx_dropped++;
458 }
459
460 static void c2_rx_interrupt(struct net_device *netdev)
461 {
462 struct c2_port *c2_port = netdev_priv(netdev);
463 struct c2_dev *c2dev = c2_port->c2dev;
464 struct c2_ring *rx_ring = &c2_port->rx_ring;
465 struct c2_element *elem;
466 struct c2_rx_desc *rx_desc;
467 struct c2_rxp_hdr *rxp_hdr;
468 struct sk_buff *skb;
469 dma_addr_t mapaddr;
470 u32 maplen, buflen;
471 unsigned long flags;
472
473 spin_lock_irqsave(&c2dev->lock, flags);
474
475 /* Begin where we left off */
476 rx_ring->to_clean = rx_ring->start + c2dev->cur_rx;
477
478 for (elem = rx_ring->to_clean; elem->next != rx_ring->to_clean;
479 elem = elem->next) {
480 rx_desc = elem->ht_desc;
481 mapaddr = elem->mapaddr;
482 maplen = elem->maplen;
483 skb = elem->skb;
484 rxp_hdr = (struct c2_rxp_hdr *) skb->data;
485
486 if (rxp_hdr->flags != RXP_HRXD_DONE)
487 break;
488 buflen = rxp_hdr->len;
489
490 /* Sanity check the RXP header */
491 if (rxp_hdr->status != RXP_HRXD_OK ||
492 buflen > (rx_desc->len - sizeof(*rxp_hdr))) {
493 c2_rx_error(c2_port, elem);
494 continue;
495 }
496
497 /*
498 * Allocate and map a new skb for replenishing the host
499 * RX desc
500 */
501 if (c2_rx_alloc(c2_port, elem)) {
502 c2_rx_error(c2_port, elem);
503 continue;
504 }
505
506 /* Unmap the old skb */
507 pci_unmap_single(c2dev->pcidev, mapaddr, maplen,
508 PCI_DMA_FROMDEVICE);
509
510 prefetch(skb->data);
511
512 /*
513 * Skip past the leading 8 bytes comprising of the
514 * "struct c2_rxp_hdr", prepended by the adapter
515 * to the usual Ethernet header ("struct ethhdr"),
516 * to the start of the raw Ethernet packet.
517 *
518 * Fix up the various fields in the sk_buff before
519 * passing it up to netif_rx(). The transfer size
520 * (in bytes) specified by the adapter len field of
521 * the "struct rxp_hdr_t" does NOT include the
522 * "sizeof(struct c2_rxp_hdr)".
523 */
524 skb->data += sizeof(*rxp_hdr);
525 skb_set_tail_pointer(skb, buflen);
526 skb->len = buflen;
527 skb->protocol = eth_type_trans(skb, netdev);
528
529 netif_rx(skb);
530
531 netdev->stats.rx_packets++;
532 netdev->stats.rx_bytes += buflen;
533 }
534
535 /* Save where we left off */
536 rx_ring->to_clean = elem;
537 c2dev->cur_rx = elem - rx_ring->start;
538 C2_SET_CUR_RX(c2dev, c2dev->cur_rx);
539
540 spin_unlock_irqrestore(&c2dev->lock, flags);
541 }
542
543 /*
544 * Handle netisr0 TX & RX interrupts.
545 */
546 static irqreturn_t c2_interrupt(int irq, void *dev_id)
547 {
548 unsigned int netisr0, dmaisr;
549 int handled = 0;
550 struct c2_dev *c2dev = (struct c2_dev *) dev_id;
551
552 /* Process CCILNET interrupts */
553 netisr0 = readl(c2dev->regs + C2_NISR0);
554 if (netisr0) {
555
556 /*
557 * There is an issue with the firmware that always
558 * provides the status of RX for both TX & RX
559 * interrupts. So process both queues here.
560 */
561 c2_rx_interrupt(c2dev->netdev);
562 c2_tx_interrupt(c2dev->netdev);
563
564 /* Clear the interrupt */
565 writel(netisr0, c2dev->regs + C2_NISR0);
566 handled++;
567 }
568
569 /* Process RNIC interrupts */
570 dmaisr = readl(c2dev->regs + C2_DISR);
571 if (dmaisr) {
572 writel(dmaisr, c2dev->regs + C2_DISR);
573 c2_rnic_interrupt(c2dev);
574 handled++;
575 }
576
577 if (handled) {
578 return IRQ_HANDLED;
579 } else {
580 return IRQ_NONE;
581 }
582 }
583
584 static int c2_up(struct net_device *netdev)
585 {
586 struct c2_port *c2_port = netdev_priv(netdev);
587 struct c2_dev *c2dev = c2_port->c2dev;
588 struct c2_element *elem;
589 struct c2_rxp_hdr *rxp_hdr;
590 struct in_device *in_dev;
591 size_t rx_size, tx_size;
592 int ret, i;
593 unsigned int netimr0;
594
595 if (netif_msg_ifup(c2_port))
596 pr_debug("%s: enabling interface\n", netdev->name);
597
598 /* Set the Rx buffer size based on MTU */
599 c2_set_rxbufsize(c2_port);
600
601 /* Allocate DMA'able memory for Tx/Rx host descriptor rings */
602 rx_size = c2_port->rx_ring.count * sizeof(struct c2_rx_desc);
603 tx_size = c2_port->tx_ring.count * sizeof(struct c2_tx_desc);
604
605 c2_port->mem_size = tx_size + rx_size;
606 c2_port->mem = pci_alloc_consistent(c2dev->pcidev, c2_port->mem_size,
607 &c2_port->dma);
608 if (c2_port->mem == NULL) {
609 pr_debug("Unable to allocate memory for "
610 "host descriptor rings\n");
611 return -ENOMEM;
612 }
613
614 memset(c2_port->mem, 0, c2_port->mem_size);
615
616 /* Create the Rx host descriptor ring */
617 if ((ret =
618 c2_rx_ring_alloc(&c2_port->rx_ring, c2_port->mem, c2_port->dma,
619 c2dev->mmio_rxp_ring))) {
620 pr_debug("Unable to create RX ring\n");
621 goto bail0;
622 }
623
624 /* Allocate Rx buffers for the host descriptor ring */
625 if (c2_rx_fill(c2_port)) {
626 pr_debug("Unable to fill RX ring\n");
627 goto bail1;
628 }
629
630 /* Create the Tx host descriptor ring */
631 if ((ret = c2_tx_ring_alloc(&c2_port->tx_ring, c2_port->mem + rx_size,
632 c2_port->dma + rx_size,
633 c2dev->mmio_txp_ring))) {
634 pr_debug("Unable to create TX ring\n");
635 goto bail1;
636 }
637
638 /* Set the TX pointer to where we left off */
639 c2_port->tx_avail = c2_port->tx_ring.count - 1;
640 c2_port->tx_ring.to_use = c2_port->tx_ring.to_clean =
641 c2_port->tx_ring.start + c2dev->cur_tx;
642
643 /* missing: Initialize MAC */
644
645 BUG_ON(c2_port->tx_ring.to_use != c2_port->tx_ring.to_clean);
646
647 /* Reset the adapter, ensures the driver is in sync with the RXP */
648 c2_reset(c2_port);
649
650 /* Reset the READY bit in the sk_buff RXP headers & adapter HRXDQ */
651 for (i = 0, elem = c2_port->rx_ring.start; i < c2_port->rx_ring.count;
652 i++, elem++) {
653 rxp_hdr = (struct c2_rxp_hdr *) elem->skb->data;
654 rxp_hdr->flags = 0;
655 __raw_writew((__force u16) cpu_to_be16(RXP_HRXD_READY),
656 elem->hw_desc + C2_RXP_FLAGS);
657 }
658
659 /* Enable network packets */
660 netif_start_queue(netdev);
661
662 /* Enable IRQ */
663 writel(0, c2dev->regs + C2_IDIS);
664 netimr0 = readl(c2dev->regs + C2_NIMR0);
665 netimr0 &= ~(C2_PCI_HTX_INT | C2_PCI_HRX_INT);
666 writel(netimr0, c2dev->regs + C2_NIMR0);
667
668 /* Tell the stack to ignore arp requests for ipaddrs bound to
669 * other interfaces. This is needed to prevent the host stack
670 * from responding to arp requests to the ipaddr bound on the
671 * rdma interface.
672 */
673 in_dev = in_dev_get(netdev);
674 IN_DEV_CONF_SET(in_dev, ARP_IGNORE, 1);
675 in_dev_put(in_dev);
676
677 return 0;
678
679 bail1:
680 c2_rx_clean(c2_port);
681 kfree(c2_port->rx_ring.start);
682
683 bail0:
684 pci_free_consistent(c2dev->pcidev, c2_port->mem_size, c2_port->mem,
685 c2_port->dma);
686
687 return ret;
688 }
689
690 static int c2_down(struct net_device *netdev)
691 {
692 struct c2_port *c2_port = netdev_priv(netdev);
693 struct c2_dev *c2dev = c2_port->c2dev;
694
695 if (netif_msg_ifdown(c2_port))
696 pr_debug("%s: disabling interface\n",
697 netdev->name);
698
699 /* Wait for all the queued packets to get sent */
700 c2_tx_interrupt(netdev);
701
702 /* Disable network packets */
703 netif_stop_queue(netdev);
704
705 /* Disable IRQs by clearing the interrupt mask */
706 writel(1, c2dev->regs + C2_IDIS);
707 writel(0, c2dev->regs + C2_NIMR0);
708
709 /* missing: Stop transmitter */
710
711 /* missing: Stop receiver */
712
713 /* Reset the adapter, ensures the driver is in sync with the RXP */
714 c2_reset(c2_port);
715
716 /* missing: Turn off LEDs here */
717
718 /* Free all buffers in the host descriptor rings */
719 c2_tx_clean(c2_port);
720 c2_rx_clean(c2_port);
721
722 /* Free the host descriptor rings */
723 kfree(c2_port->rx_ring.start);
724 kfree(c2_port->tx_ring.start);
725 pci_free_consistent(c2dev->pcidev, c2_port->mem_size, c2_port->mem,
726 c2_port->dma);
727
728 return 0;
729 }
730
731 static void c2_reset(struct c2_port *c2_port)
732 {
733 struct c2_dev *c2dev = c2_port->c2dev;
734 unsigned int cur_rx = c2dev->cur_rx;
735
736 /* Tell the hardware to quiesce */
737 C2_SET_CUR_RX(c2dev, cur_rx | C2_PCI_HRX_QUI);
738
739 /*
740 * The hardware will reset the C2_PCI_HRX_QUI bit once
741 * the RXP is quiesced. Wait 2 seconds for this.
742 */
743 ssleep(2);
744
745 cur_rx = C2_GET_CUR_RX(c2dev);
746
747 if (cur_rx & C2_PCI_HRX_QUI)
748 pr_debug("c2_reset: failed to quiesce the hardware!\n");
749
750 cur_rx &= ~C2_PCI_HRX_QUI;
751
752 c2dev->cur_rx = cur_rx;
753
754 pr_debug("Current RX: %u\n", c2dev->cur_rx);
755 }
756
757 static int c2_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
758 {
759 struct c2_port *c2_port = netdev_priv(netdev);
760 struct c2_dev *c2dev = c2_port->c2dev;
761 struct c2_ring *tx_ring = &c2_port->tx_ring;
762 struct c2_element *elem;
763 dma_addr_t mapaddr;
764 u32 maplen;
765 unsigned long flags;
766 unsigned int i;
767
768 spin_lock_irqsave(&c2_port->tx_lock, flags);
769
770 if (unlikely(c2_port->tx_avail < (skb_shinfo(skb)->nr_frags + 1))) {
771 netif_stop_queue(netdev);
772 spin_unlock_irqrestore(&c2_port->tx_lock, flags);
773
774 pr_debug("%s: Tx ring full when queue awake!\n",
775 netdev->name);
776 return NETDEV_TX_BUSY;
777 }
778
779 maplen = skb_headlen(skb);
780 mapaddr =
781 pci_map_single(c2dev->pcidev, skb->data, maplen, PCI_DMA_TODEVICE);
782
783 elem = tx_ring->to_use;
784 elem->skb = skb;
785 elem->mapaddr = mapaddr;
786 elem->maplen = maplen;
787
788 /* Tell HW to xmit */
789 __raw_writeq((__force u64) cpu_to_be64(mapaddr),
790 elem->hw_desc + C2_TXP_ADDR);
791 __raw_writew((__force u16) cpu_to_be16(maplen),
792 elem->hw_desc + C2_TXP_LEN);
793 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_READY),
794 elem->hw_desc + C2_TXP_FLAGS);
795
796 netdev->stats.tx_packets++;
797 netdev->stats.tx_bytes += maplen;
798
799 /* Loop thru additional data fragments and queue them */
800 if (skb_shinfo(skb)->nr_frags) {
801 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
802 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
803 maplen = frag->size;
804 mapaddr =
805 pci_map_page(c2dev->pcidev, frag->page,
806 frag->page_offset, maplen,
807 PCI_DMA_TODEVICE);
808
809 elem = elem->next;
810 elem->skb = NULL;
811 elem->mapaddr = mapaddr;
812 elem->maplen = maplen;
813
814 /* Tell HW to xmit */
815 __raw_writeq((__force u64) cpu_to_be64(mapaddr),
816 elem->hw_desc + C2_TXP_ADDR);
817 __raw_writew((__force u16) cpu_to_be16(maplen),
818 elem->hw_desc + C2_TXP_LEN);
819 __raw_writew((__force u16) cpu_to_be16(TXP_HTXD_READY),
820 elem->hw_desc + C2_TXP_FLAGS);
821
822 netdev->stats.tx_packets++;
823 netdev->stats.tx_bytes += maplen;
824 }
825 }
826
827 tx_ring->to_use = elem->next;
828 c2_port->tx_avail -= (skb_shinfo(skb)->nr_frags + 1);
829
830 if (c2_port->tx_avail <= MAX_SKB_FRAGS + 1) {
831 netif_stop_queue(netdev);
832 if (netif_msg_tx_queued(c2_port))
833 pr_debug("%s: transmit queue full\n",
834 netdev->name);
835 }
836
837 spin_unlock_irqrestore(&c2_port->tx_lock, flags);
838
839 netdev->trans_start = jiffies;
840
841 return NETDEV_TX_OK;
842 }
843
844 static void c2_tx_timeout(struct net_device *netdev)
845 {
846 struct c2_port *c2_port = netdev_priv(netdev);
847
848 if (netif_msg_timer(c2_port))
849 pr_debug("%s: tx timeout\n", netdev->name);
850
851 c2_tx_clean(c2_port);
852 }
853
854 static int c2_change_mtu(struct net_device *netdev, int new_mtu)
855 {
856 int ret = 0;
857
858 if (new_mtu < ETH_ZLEN || new_mtu > ETH_JUMBO_MTU)
859 return -EINVAL;
860
861 netdev->mtu = new_mtu;
862
863 if (netif_running(netdev)) {
864 c2_down(netdev);
865
866 c2_up(netdev);
867 }
868
869 return ret;
870 }
871
872 static const struct net_device_ops c2_netdev = {
873 .ndo_open = c2_up,
874 .ndo_stop = c2_down,
875 .ndo_start_xmit = c2_xmit_frame,
876 .ndo_tx_timeout = c2_tx_timeout,
877 .ndo_change_mtu = c2_change_mtu,
878 .ndo_set_mac_address = eth_mac_addr,
879 .ndo_validate_addr = eth_validate_addr,
880 };
881
882 /* Initialize network device */
883 static struct net_device *c2_devinit(struct c2_dev *c2dev,
884 void __iomem * mmio_addr)
885 {
886 struct c2_port *c2_port = NULL;
887 struct net_device *netdev = alloc_etherdev(sizeof(*c2_port));
888
889 if (!netdev) {
890 pr_debug("c2_port etherdev alloc failed");
891 return NULL;
892 }
893
894 SET_NETDEV_DEV(netdev, &c2dev->pcidev->dev);
895
896 netdev->netdev_ops = &c2_netdev;
897 netdev->watchdog_timeo = C2_TX_TIMEOUT;
898 netdev->irq = c2dev->pcidev->irq;
899
900 c2_port = netdev_priv(netdev);
901 c2_port->netdev = netdev;
902 c2_port->c2dev = c2dev;
903 c2_port->msg_enable = netif_msg_init(debug, default_msg);
904 c2_port->tx_ring.count = C2_NUM_TX_DESC;
905 c2_port->rx_ring.count = C2_NUM_RX_DESC;
906
907 spin_lock_init(&c2_port->tx_lock);
908
909 /* Copy our 48-bit ethernet hardware address */
910 memcpy_fromio(netdev->dev_addr, mmio_addr + C2_REGS_ENADDR, 6);
911
912 /* Validate the MAC address */
913 if (!is_valid_ether_addr(netdev->dev_addr)) {
914 pr_debug("Invalid MAC Address\n");
915 c2_print_macaddr(netdev);
916 free_netdev(netdev);
917 return NULL;
918 }
919
920 c2dev->netdev = netdev;
921
922 return netdev;
923 }
924
925 static int __devinit c2_probe(struct pci_dev *pcidev,
926 const struct pci_device_id *ent)
927 {
928 int ret = 0, i;
929 unsigned long reg0_start, reg0_flags, reg0_len;
930 unsigned long reg2_start, reg2_flags, reg2_len;
931 unsigned long reg4_start, reg4_flags, reg4_len;
932 unsigned kva_map_size;
933 struct net_device *netdev = NULL;
934 struct c2_dev *c2dev = NULL;
935 void __iomem *mmio_regs = NULL;
936
937 printk(KERN_INFO PFX "AMSO1100 Gigabit Ethernet driver v%s loaded\n",
938 DRV_VERSION);
939
940 /* Enable PCI device */
941 ret = pci_enable_device(pcidev);
942 if (ret) {
943 printk(KERN_ERR PFX "%s: Unable to enable PCI device\n",
944 pci_name(pcidev));
945 goto bail0;
946 }
947
948 reg0_start = pci_resource_start(pcidev, BAR_0);
949 reg0_len = pci_resource_len(pcidev, BAR_0);
950 reg0_flags = pci_resource_flags(pcidev, BAR_0);
951
952 reg2_start = pci_resource_start(pcidev, BAR_2);
953 reg2_len = pci_resource_len(pcidev, BAR_2);
954 reg2_flags = pci_resource_flags(pcidev, BAR_2);
955
956 reg4_start = pci_resource_start(pcidev, BAR_4);
957 reg4_len = pci_resource_len(pcidev, BAR_4);
958 reg4_flags = pci_resource_flags(pcidev, BAR_4);
959
960 pr_debug("BAR0 size = 0x%lX bytes\n", reg0_len);
961 pr_debug("BAR2 size = 0x%lX bytes\n", reg2_len);
962 pr_debug("BAR4 size = 0x%lX bytes\n", reg4_len);
963
964 /* Make sure PCI base addr are MMIO */
965 if (!(reg0_flags & IORESOURCE_MEM) ||
966 !(reg2_flags & IORESOURCE_MEM) || !(reg4_flags & IORESOURCE_MEM)) {
967 printk(KERN_ERR PFX "PCI regions not an MMIO resource\n");
968 ret = -ENODEV;
969 goto bail1;
970 }
971
972 /* Check for weird/broken PCI region reporting */
973 if ((reg0_len < C2_REG0_SIZE) ||
974 (reg2_len < C2_REG2_SIZE) || (reg4_len < C2_REG4_SIZE)) {
975 printk(KERN_ERR PFX "Invalid PCI region sizes\n");
976 ret = -ENODEV;
977 goto bail1;
978 }
979
980 /* Reserve PCI I/O and memory resources */
981 ret = pci_request_regions(pcidev, DRV_NAME);
982 if (ret) {
983 printk(KERN_ERR PFX "%s: Unable to request regions\n",
984 pci_name(pcidev));
985 goto bail1;
986 }
987
988 if ((sizeof(dma_addr_t) > 4)) {
989 ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
990 if (ret < 0) {
991 printk(KERN_ERR PFX "64b DMA configuration failed\n");
992 goto bail2;
993 }
994 } else {
995 ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
996 if (ret < 0) {
997 printk(KERN_ERR PFX "32b DMA configuration failed\n");
998 goto bail2;
999 }
1000 }
1001
1002 /* Enables bus-mastering on the device */
1003 pci_set_master(pcidev);
1004
1005 /* Remap the adapter PCI registers in BAR4 */
1006 mmio_regs = ioremap_nocache(reg4_start + C2_PCI_REGS_OFFSET,
1007 sizeof(struct c2_adapter_pci_regs));
1008 if (!mmio_regs) {
1009 printk(KERN_ERR PFX
1010 "Unable to remap adapter PCI registers in BAR4\n");
1011 ret = -EIO;
1012 goto bail2;
1013 }
1014
1015 /* Validate PCI regs magic */
1016 for (i = 0; i < sizeof(c2_magic); i++) {
1017 if (c2_magic[i] != readb(mmio_regs + C2_REGS_MAGIC + i)) {
1018 printk(KERN_ERR PFX "Downlevel Firmware boot loader "
1019 "[%d/%Zd: got 0x%x, exp 0x%x]. Use the cc_flash "
1020 "utility to update your boot loader\n",
1021 i + 1, sizeof(c2_magic),
1022 readb(mmio_regs + C2_REGS_MAGIC + i),
1023 c2_magic[i]);
1024 printk(KERN_ERR PFX "Adapter not claimed\n");
1025 iounmap(mmio_regs);
1026 ret = -EIO;
1027 goto bail2;
1028 }
1029 }
1030
1031 /* Validate the adapter version */
1032 if (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_VERS)) != C2_VERSION) {
1033 printk(KERN_ERR PFX "Version mismatch "
1034 "[fw=%u, c2=%u], Adapter not claimed\n",
1035 be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_VERS)),
1036 C2_VERSION);
1037 ret = -EINVAL;
1038 iounmap(mmio_regs);
1039 goto bail2;
1040 }
1041
1042 /* Validate the adapter IVN */
1043 if (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_IVN)) != C2_IVN) {
1044 printk(KERN_ERR PFX "Downlevel FIrmware level. You should be using "
1045 "the OpenIB device support kit. "
1046 "[fw=0x%x, c2=0x%x], Adapter not claimed\n",
1047 be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_IVN)),
1048 C2_IVN);
1049 ret = -EINVAL;
1050 iounmap(mmio_regs);
1051 goto bail2;
1052 }
1053
1054 /* Allocate hardware structure */
1055 c2dev = (struct c2_dev *) ib_alloc_device(sizeof(*c2dev));
1056 if (!c2dev) {
1057 printk(KERN_ERR PFX "%s: Unable to alloc hardware struct\n",
1058 pci_name(pcidev));
1059 ret = -ENOMEM;
1060 iounmap(mmio_regs);
1061 goto bail2;
1062 }
1063
1064 memset(c2dev, 0, sizeof(*c2dev));
1065 spin_lock_init(&c2dev->lock);
1066 c2dev->pcidev = pcidev;
1067 c2dev->cur_tx = 0;
1068
1069 /* Get the last RX index */
1070 c2dev->cur_rx =
1071 (be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_HRX_CUR)) -
1072 0xffffc000) / sizeof(struct c2_rxp_desc);
1073
1074 /* Request an interrupt line for the driver */
1075 ret = request_irq(pcidev->irq, c2_interrupt, IRQF_SHARED, DRV_NAME, c2dev);
1076 if (ret) {
1077 printk(KERN_ERR PFX "%s: requested IRQ %u is busy\n",
1078 pci_name(pcidev), pcidev->irq);
1079 iounmap(mmio_regs);
1080 goto bail3;
1081 }
1082
1083 /* Set driver specific data */
1084 pci_set_drvdata(pcidev, c2dev);
1085
1086 /* Initialize network device */
1087 if ((netdev = c2_devinit(c2dev, mmio_regs)) == NULL) {
1088 iounmap(mmio_regs);
1089 goto bail4;
1090 }
1091
1092 /* Save off the actual size prior to unmapping mmio_regs */
1093 kva_map_size = be32_to_cpu((__force __be32) readl(mmio_regs + C2_REGS_PCI_WINSIZE));
1094
1095 /* Unmap the adapter PCI registers in BAR4 */
1096 iounmap(mmio_regs);
1097
1098 /* Register network device */
1099 ret = register_netdev(netdev);
1100 if (ret) {
1101 printk(KERN_ERR PFX "Unable to register netdev, ret = %d\n",
1102 ret);
1103 goto bail5;
1104 }
1105
1106 /* Disable network packets */
1107 netif_stop_queue(netdev);
1108
1109 /* Remap the adapter HRXDQ PA space to kernel VA space */
1110 c2dev->mmio_rxp_ring = ioremap_nocache(reg4_start + C2_RXP_HRXDQ_OFFSET,
1111 C2_RXP_HRXDQ_SIZE);
1112 if (!c2dev->mmio_rxp_ring) {
1113 printk(KERN_ERR PFX "Unable to remap MMIO HRXDQ region\n");
1114 ret = -EIO;
1115 goto bail6;
1116 }
1117
1118 /* Remap the adapter HTXDQ PA space to kernel VA space */
1119 c2dev->mmio_txp_ring = ioremap_nocache(reg4_start + C2_TXP_HTXDQ_OFFSET,
1120 C2_TXP_HTXDQ_SIZE);
1121 if (!c2dev->mmio_txp_ring) {
1122 printk(KERN_ERR PFX "Unable to remap MMIO HTXDQ region\n");
1123 ret = -EIO;
1124 goto bail7;
1125 }
1126
1127 /* Save off the current RX index in the last 4 bytes of the TXP Ring */
1128 C2_SET_CUR_RX(c2dev, c2dev->cur_rx);
1129
1130 /* Remap the PCI registers in adapter BAR0 to kernel VA space */
1131 c2dev->regs = ioremap_nocache(reg0_start, reg0_len);
1132 if (!c2dev->regs) {
1133 printk(KERN_ERR PFX "Unable to remap BAR0\n");
1134 ret = -EIO;
1135 goto bail8;
1136 }
1137
1138 /* Remap the PCI registers in adapter BAR4 to kernel VA space */
1139 c2dev->pa = reg4_start + C2_PCI_REGS_OFFSET;
1140 c2dev->kva = ioremap_nocache(reg4_start + C2_PCI_REGS_OFFSET,
1141 kva_map_size);
1142 if (!c2dev->kva) {
1143 printk(KERN_ERR PFX "Unable to remap BAR4\n");
1144 ret = -EIO;
1145 goto bail9;
1146 }
1147
1148 /* Print out the MAC address */
1149 c2_print_macaddr(netdev);
1150
1151 ret = c2_rnic_init(c2dev);
1152 if (ret) {
1153 printk(KERN_ERR PFX "c2_rnic_init failed: %d\n", ret);
1154 goto bail10;
1155 }
1156
1157 if (c2_register_device(c2dev))
1158 goto bail10;
1159
1160 return 0;
1161
1162 bail10:
1163 iounmap(c2dev->kva);
1164
1165 bail9:
1166 iounmap(c2dev->regs);
1167
1168 bail8:
1169 iounmap(c2dev->mmio_txp_ring);
1170
1171 bail7:
1172 iounmap(c2dev->mmio_rxp_ring);
1173
1174 bail6:
1175 unregister_netdev(netdev);
1176
1177 bail5:
1178 free_netdev(netdev);
1179
1180 bail4:
1181 free_irq(pcidev->irq, c2dev);
1182
1183 bail3:
1184 ib_dealloc_device(&c2dev->ibdev);
1185
1186 bail2:
1187 pci_release_regions(pcidev);
1188
1189 bail1:
1190 pci_disable_device(pcidev);
1191
1192 bail0:
1193 return ret;
1194 }
1195
1196 static void __devexit c2_remove(struct pci_dev *pcidev)
1197 {
1198 struct c2_dev *c2dev = pci_get_drvdata(pcidev);
1199 struct net_device *netdev = c2dev->netdev;
1200
1201 /* Unregister with OpenIB */
1202 c2_unregister_device(c2dev);
1203
1204 /* Clean up the RNIC resources */
1205 c2_rnic_term(c2dev);
1206
1207 /* Remove network device from the kernel */
1208 unregister_netdev(netdev);
1209
1210 /* Free network device */
1211 free_netdev(netdev);
1212
1213 /* Free the interrupt line */
1214 free_irq(pcidev->irq, c2dev);
1215
1216 /* missing: Turn LEDs off here */
1217
1218 /* Unmap adapter PA space */
1219 iounmap(c2dev->kva);
1220 iounmap(c2dev->regs);
1221 iounmap(c2dev->mmio_txp_ring);
1222 iounmap(c2dev->mmio_rxp_ring);
1223
1224 /* Free the hardware structure */
1225 ib_dealloc_device(&c2dev->ibdev);
1226
1227 /* Release reserved PCI I/O and memory resources */
1228 pci_release_regions(pcidev);
1229
1230 /* Disable PCI device */
1231 pci_disable_device(pcidev);
1232
1233 /* Clear driver specific data */
1234 pci_set_drvdata(pcidev, NULL);
1235 }
1236
1237 static struct pci_driver c2_pci_driver = {
1238 .name = DRV_NAME,
1239 .id_table = c2_pci_table,
1240 .probe = c2_probe,
1241 .remove = __devexit_p(c2_remove),
1242 };
1243
1244 static int __init c2_init_module(void)
1245 {
1246 return pci_register_driver(&c2_pci_driver);
1247 }
1248
1249 static void __exit c2_exit_module(void)
1250 {
1251 pci_unregister_driver(&c2_pci_driver);
1252 }
1253
1254 module_init(c2_init_module);
1255 module_exit(c2_exit_module);
ubuntu-bionic-kernel mirror