?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6/libata-dev.git] / drivers / net / netxen / netxen_nic_main.c
blob98271f962ae465165b247b9d2c4f1810d512492f
1 /*
2 * Copyright (C) 2003 - 2009 NetXen, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 * MA 02111-1307, USA.
19 *
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
22 *
23 * Contact Information:
24 * info@netxen.com
25 * NetXen Inc,
26 * 18922 Forge Drive
27 * Cupertino, CA 95014-0701
28 *
29 */
30
31 #include <linux/vmalloc.h>
32 #include <linux/interrupt.h>
33 #include "netxen_nic_hw.h"
34
35 #include "netxen_nic.h"
36 #include "netxen_nic_phan_reg.h"
37
38 #include <linux/dma-mapping.h>
39 #include <linux/if_vlan.h>
40 #include <net/ip.h>
41 #include <linux/ipv6.h>
42 #include <linux/inetdevice.h>
43
44 MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
45 MODULE_LICENSE("GPL");
46 MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
47
48 char netxen_nic_driver_name[] = "netxen_nic";
49 static char netxen_nic_driver_string[] = "NetXen Network Driver version "
50 NETXEN_NIC_LINUX_VERSIONID;
51
52 static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
53
54 /* Default to restricted 1G auto-neg mode */
55 static int wol_port_mode = 5;
56
57 static int use_msi = 1;
58
59 static int use_msi_x = 1;
60
61 /* Local functions to NetXen NIC driver */
62 static int __devinit netxen_nic_probe(struct pci_dev *pdev,
63 const struct pci_device_id *ent);
64 static void __devexit netxen_nic_remove(struct pci_dev *pdev);
65 static int netxen_nic_open(struct net_device *netdev);
66 static int netxen_nic_close(struct net_device *netdev);
67 static int netxen_nic_xmit_frame(struct sk_buff *, struct net_device *);
68 static void netxen_tx_timeout(struct net_device *netdev);
69 static void netxen_reset_task(struct work_struct *work);
70 static void netxen_watchdog(unsigned long);
71 static int netxen_nic_poll(struct napi_struct *napi, int budget);
72 #ifdef CONFIG_NET_POLL_CONTROLLER
73 static void netxen_nic_poll_controller(struct net_device *netdev);
74 #endif
75 static irqreturn_t netxen_intr(int irq, void *data);
76 static irqreturn_t netxen_msi_intr(int irq, void *data);
77 static irqreturn_t netxen_msix_intr(int irq, void *data);
78
79 /* PCI Device ID Table */
80 #define ENTRY(device) \
81 {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
82 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
83
84 static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
85 ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
86 ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
87 ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
88 ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
89 ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
90 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
91 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
92 ENTRY(PCI_DEVICE_ID_NX3031),
93 {0,}
94 };
95
96 MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
97
98 static struct workqueue_struct *netxen_workq;
99 #define SCHEDULE_WORK(tp) queue_work(netxen_workq, tp)
100 #define FLUSH_SCHEDULED_WORK() flush_workqueue(netxen_workq)
101
102 static void netxen_watchdog(unsigned long);
103
104 static uint32_t crb_cmd_producer[4] = {
105 CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
106 CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
107 };
108
109 void
110 netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
111 struct nx_host_tx_ring *tx_ring)
112 {
113 NXWR32(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
114
115 if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
116 netif_stop_queue(adapter->netdev);
117 smp_mb();
118 }
119 }
120
121 static uint32_t crb_cmd_consumer[4] = {
122 CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
123 CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
124 };
125
126 static inline void
127 netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
128 struct nx_host_tx_ring *tx_ring)
129 {
130 NXWR32(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
131 }
132
133 static uint32_t msi_tgt_status[8] = {
134 ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
135 ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
136 ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
137 ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
138 };
139
140 static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
141
142 static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
143 {
144 struct netxen_adapter *adapter = sds_ring->adapter;
145
146 NXWR32(adapter, sds_ring->crb_intr_mask, 0);
147 }
148
149 static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
150 {
151 struct netxen_adapter *adapter = sds_ring->adapter;
152
153 NXWR32(adapter, sds_ring->crb_intr_mask, 0x1);
154
155 if (!NETXEN_IS_MSI_FAMILY(adapter))
156 adapter->pci_write_immediate(adapter,
157 adapter->legacy_intr.tgt_mask_reg, 0xfbff);
158 }
159
160 static int
161 netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
162 {
163 int size = sizeof(struct nx_host_sds_ring) * count;
164
165 recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
166
167 return (recv_ctx->sds_rings == NULL);
168 }
169
170 static void
171 netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
172 {
173 if (recv_ctx->sds_rings != NULL)
174 kfree(recv_ctx->sds_rings);
175 }
176
177 static int
178 netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
179 {
180 int ring;
181 struct nx_host_sds_ring *sds_ring;
182 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
183
184 if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
185 return -ENOMEM;
186
187 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
188 sds_ring = &recv_ctx->sds_rings[ring];
189 netif_napi_add(netdev, &sds_ring->napi,
190 netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
191 }
192
193 return 0;
194 }
195
196 static void
197 netxen_napi_enable(struct netxen_adapter *adapter)
198 {
199 int ring;
200 struct nx_host_sds_ring *sds_ring;
201 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
202
203 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
204 sds_ring = &recv_ctx->sds_rings[ring];
205 napi_enable(&sds_ring->napi);
206 netxen_nic_enable_int(sds_ring);
207 }
208 }
209
210 static void
211 netxen_napi_disable(struct netxen_adapter *adapter)
212 {
213 int ring;
214 struct nx_host_sds_ring *sds_ring;
215 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
216
217 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
218 sds_ring = &recv_ctx->sds_rings[ring];
219 netxen_nic_disable_int(sds_ring);
220 napi_synchronize(&sds_ring->napi);
221 napi_disable(&sds_ring->napi);
222 }
223 }
224
225 static int nx_set_dma_mask(struct netxen_adapter *adapter)
226 {
227 struct pci_dev *pdev = adapter->pdev;
228 uint64_t mask, cmask;
229
230 adapter->pci_using_dac = 0;
231
232 mask = DMA_BIT_MASK(32);
233 cmask = DMA_BIT_MASK(32);
234
235 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
236 #ifndef CONFIG_IA64
237 mask = DMA_BIT_MASK(35);
238 #endif
239 } else {
240 mask = DMA_BIT_MASK(39);
241 cmask = mask;
242 }
243
244 if (pci_set_dma_mask(pdev, mask) == 0 &&
245 pci_set_consistent_dma_mask(pdev, cmask) == 0) {
246 adapter->pci_using_dac = 1;
247 return 0;
248 }
249
250 return -EIO;
251 }
252
253 /* Update addressable range if firmware supports it */
254 static int
255 nx_update_dma_mask(struct netxen_adapter *adapter)
256 {
257 int change, shift, err;
258 uint64_t mask, old_mask, old_cmask;
259 struct pci_dev *pdev = adapter->pdev;
260
261 change = 0;
262
263 shift = NXRD32(adapter, CRB_DMA_SHIFT);
264 if (shift > 32)
265 return 0;
266
267 if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
268 change = 1;
269 else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
270 change = 1;
271
272 if (change) {
273 old_mask = pdev->dma_mask;
274 old_cmask = pdev->dev.coherent_dma_mask;
275
276 mask = DMA_BIT_MASK(32+shift);
277
278 err = pci_set_dma_mask(pdev, mask);
279 if (err)
280 goto err_out;
281
282 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
283
284 err = pci_set_consistent_dma_mask(pdev, mask);
285 if (err)
286 goto err_out;
287 }
288 dev_info(&pdev->dev, "using %d-bit dma mask\n", 32+shift);
289 }
290
291 return 0;
292
293 err_out:
294 pci_set_dma_mask(pdev, old_mask);
295 pci_set_consistent_dma_mask(pdev, old_cmask);
296 return err;
297 }
298
299 static void
300 netxen_check_options(struct netxen_adapter *adapter)
301 {
302 if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
303 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
304 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
305 } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
306 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
307 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
308 }
309
310 adapter->msix_supported = 0;
311 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
312 adapter->msix_supported = !!use_msi_x;
313 adapter->rss_supported = !!use_msi_x;
314 } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
315 switch (adapter->ahw.board_type) {
316 case NETXEN_BRDTYPE_P2_SB31_10G:
317 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
318 adapter->msix_supported = !!use_msi_x;
319 adapter->rss_supported = !!use_msi_x;
320 break;
321 default:
322 break;
323 }
324 }
325
326 adapter->num_txd = MAX_CMD_DESCRIPTORS;
327
328 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
329 adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
330 adapter->max_rds_rings = 3;
331 } else {
332 adapter->num_lro_rxd = 0;
333 adapter->max_rds_rings = 2;
334 }
335 }
336
337 static int
338 netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
339 {
340 u32 val, timeout;
341
342 if (first_boot == 0x55555555) {
343 /* This is the first boot after power up */
344 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
345
346 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
347 return 0;
348
349 /* PCI bus master workaround */
350 first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
351 if (!(first_boot & 0x4)) {
352 first_boot |= 0x4;
353 NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
354 first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
355 }
356
357 /* This is the first boot after power up */
358 first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
359 if (first_boot != 0x80000f) {
360 /* clear the register for future unloads/loads */
361 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
362 return -EIO;
363 }
364
365 /* Start P2 boot loader */
366 val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
367 NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
368 timeout = 0;
369 do {
370 msleep(1);
371 val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
372
373 if (++timeout > 5000)
374 return -EIO;
375
376 } while (val == NETXEN_BDINFO_MAGIC);
377 }
378 return 0;
379 }
380
381 static void netxen_set_port_mode(struct netxen_adapter *adapter)
382 {
383 u32 val, data;
384
385 val = adapter->ahw.board_type;
386 if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
387 (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
388 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
389 data = NETXEN_PORT_MODE_802_3_AP;
390 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
391 } else if (port_mode == NETXEN_PORT_MODE_XG) {
392 data = NETXEN_PORT_MODE_XG;
393 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
394 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
395 data = NETXEN_PORT_MODE_AUTO_NEG_1G;
396 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
397 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
398 data = NETXEN_PORT_MODE_AUTO_NEG_XG;
399 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
400 } else {
401 data = NETXEN_PORT_MODE_AUTO_NEG;
402 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
403 }
404
405 if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
406 (wol_port_mode != NETXEN_PORT_MODE_XG) &&
407 (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
408 (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
409 wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
410 }
411 NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
412 }
413 }
414
415 static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
416 {
417 u32 control;
418 int pos;
419
420 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
421 if (pos) {
422 pci_read_config_dword(pdev, pos, &control);
423 if (enable)
424 control |= PCI_MSIX_FLAGS_ENABLE;
425 else
426 control = 0;
427 pci_write_config_dword(pdev, pos, control);
428 }
429 }
430
431 static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
432 {
433 int i;
434
435 for (i = 0; i < count; i++)
436 adapter->msix_entries[i].entry = i;
437 }
438
439 static int
440 netxen_read_mac_addr(struct netxen_adapter *adapter)
441 {
442 int i;
443 unsigned char *p;
444 __le64 mac_addr;
445 struct net_device *netdev = adapter->netdev;
446 struct pci_dev *pdev = adapter->pdev;
447
448 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
449 if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
450 return -EIO;
451 } else {
452 if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
453 return -EIO;
454 }
455
456 p = (unsigned char *)&mac_addr;
457 for (i = 0; i < 6; i++)
458 netdev->dev_addr[i] = *(p + 5 - i);
459
460 memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
461
462 /* set station address */
463
464 if (!is_valid_ether_addr(netdev->perm_addr))
465 dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
466
467 return 0;
468 }
469
470 int netxen_nic_set_mac(struct net_device *netdev, void *p)
471 {
472 struct netxen_adapter *adapter = netdev_priv(netdev);
473 struct sockaddr *addr = p;
474
475 if (!is_valid_ether_addr(addr->sa_data))
476 return -EINVAL;
477
478 if (netif_running(netdev)) {
479 netif_device_detach(netdev);
480 netxen_napi_disable(adapter);
481 }
482
483 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
484 adapter->macaddr_set(adapter, addr->sa_data);
485
486 if (netif_running(netdev)) {
487 netif_device_attach(netdev);
488 netxen_napi_enable(adapter);
489 }
490 return 0;
491 }
492
493 static void netxen_set_multicast_list(struct net_device *dev)
494 {
495 struct netxen_adapter *adapter = netdev_priv(dev);
496
497 adapter->set_multi(dev);
498 }
499
500 static const struct net_device_ops netxen_netdev_ops = {
501 .ndo_open = netxen_nic_open,
502 .ndo_stop = netxen_nic_close,
503 .ndo_start_xmit = netxen_nic_xmit_frame,
504 .ndo_get_stats = netxen_nic_get_stats,
505 .ndo_validate_addr = eth_validate_addr,
506 .ndo_set_multicast_list = netxen_set_multicast_list,
507 .ndo_set_mac_address = netxen_nic_set_mac,
508 .ndo_change_mtu = netxen_nic_change_mtu,
509 .ndo_tx_timeout = netxen_tx_timeout,
510 #ifdef CONFIG_NET_POLL_CONTROLLER
511 .ndo_poll_controller = netxen_nic_poll_controller,
512 #endif
513 };
514
515 static void
516 netxen_setup_intr(struct netxen_adapter *adapter)
517 {
518 struct netxen_legacy_intr_set *legacy_intrp;
519 struct pci_dev *pdev = adapter->pdev;
520 int err, num_msix;
521
522 if (adapter->rss_supported) {
523 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
524 MSIX_ENTRIES_PER_ADAPTER : 2;
525 } else
526 num_msix = 1;
527
528 adapter->max_sds_rings = 1;
529
530 adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
531
532 if (adapter->ahw.revision_id >= NX_P3_B0)
533 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
534 else
535 legacy_intrp = &legacy_intr[0];
536 adapter->legacy_intr.int_vec_bit = legacy_intrp->int_vec_bit;
537 adapter->legacy_intr.tgt_status_reg = legacy_intrp->tgt_status_reg;
538 adapter->legacy_intr.tgt_mask_reg = legacy_intrp->tgt_mask_reg;
539 adapter->legacy_intr.pci_int_reg = legacy_intrp->pci_int_reg;
540
541 netxen_set_msix_bit(pdev, 0);
542
543 if (adapter->msix_supported) {
544
545 netxen_init_msix_entries(adapter, num_msix);
546 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
547 if (err == 0) {
548 adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
549 netxen_set_msix_bit(pdev, 1);
550
551 if (adapter->rss_supported)
552 adapter->max_sds_rings = num_msix;
553
554 dev_info(&pdev->dev, "using msi-x interrupts\n");
555 return;
556 }
557
558 if (err > 0)
559 pci_disable_msix(pdev);
560
561 /* fall through for msi */
562 }
563
564 if (use_msi && !pci_enable_msi(pdev)) {
565 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
566 adapter->msi_tgt_status =
567 msi_tgt_status[adapter->ahw.pci_func];
568 dev_info(&pdev->dev, "using msi interrupts\n");
569 adapter->msix_entries[0].vector = pdev->irq;
570 return;
571 }
572
573 dev_info(&pdev->dev, "using legacy interrupts\n");
574 adapter->msix_entries[0].vector = pdev->irq;
575 }
576
577 static void
578 netxen_teardown_intr(struct netxen_adapter *adapter)
579 {
580 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
581 pci_disable_msix(adapter->pdev);
582 if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
583 pci_disable_msi(adapter->pdev);
584 }
585
586 static void
587 netxen_cleanup_pci_map(struct netxen_adapter *adapter)
588 {
589 if (adapter->ahw.db_base != NULL)
590 iounmap(adapter->ahw.db_base);
591 if (adapter->ahw.pci_base0 != NULL)
592 iounmap(adapter->ahw.pci_base0);
593 if (adapter->ahw.pci_base1 != NULL)
594 iounmap(adapter->ahw.pci_base1);
595 if (adapter->ahw.pci_base2 != NULL)
596 iounmap(adapter->ahw.pci_base2);
597 }
598
599 static int
600 netxen_setup_pci_map(struct netxen_adapter *adapter)
601 {
602 void __iomem *mem_ptr0 = NULL;
603 void __iomem *mem_ptr1 = NULL;
604 void __iomem *mem_ptr2 = NULL;
605 void __iomem *db_ptr = NULL;
606
607 unsigned long mem_base, mem_len, db_base, db_len = 0, pci_len0 = 0;
608
609 struct pci_dev *pdev = adapter->pdev;
610 int pci_func = adapter->ahw.pci_func;
611
612 int err = 0;
613
614 /*
615 * Set the CRB window to invalid. If any register in window 0 is
616 * accessed it should set the window to 0 and then reset it to 1.
617 */
618 adapter->curr_window = 255;
619 adapter->ahw.qdr_sn_window = -1;
620 adapter->ahw.ddr_mn_window = -1;
621
622 /* remap phys address */
623 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
624 mem_len = pci_resource_len(pdev, 0);
625 pci_len0 = 0;
626
627 adapter->hw_write_wx = netxen_nic_hw_write_wx_128M;
628 adapter->hw_read_wx = netxen_nic_hw_read_wx_128M;
629 adapter->pci_read_immediate = netxen_nic_pci_read_immediate_128M;
630 adapter->pci_write_immediate = netxen_nic_pci_write_immediate_128M;
631 adapter->pci_set_window = netxen_nic_pci_set_window_128M;
632 adapter->pci_mem_read = netxen_nic_pci_mem_read_128M;
633 adapter->pci_mem_write = netxen_nic_pci_mem_write_128M;
634
635 /* 128 Meg of memory */
636 if (mem_len == NETXEN_PCI_128MB_SIZE) {
637 mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
638 mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
639 SECOND_PAGE_GROUP_SIZE);
640 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
641 THIRD_PAGE_GROUP_SIZE);
642 } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
643 mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
644 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
645 SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
646 } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
647 adapter->hw_write_wx = netxen_nic_hw_write_wx_2M;
648 adapter->hw_read_wx = netxen_nic_hw_read_wx_2M;
649 adapter->pci_read_immediate = netxen_nic_pci_read_immediate_2M;
650 adapter->pci_write_immediate =
651 netxen_nic_pci_write_immediate_2M;
652 adapter->pci_set_window = netxen_nic_pci_set_window_2M;
653 adapter->pci_mem_read = netxen_nic_pci_mem_read_2M;
654 adapter->pci_mem_write = netxen_nic_pci_mem_write_2M;
655
656 mem_ptr0 = pci_ioremap_bar(pdev, 0);
657 if (mem_ptr0 == NULL) {
658 dev_err(&pdev->dev, "failed to map PCI bar 0\n");
659 return -EIO;
660 }
661 pci_len0 = mem_len;
662
663 adapter->ahw.ddr_mn_window = 0;
664 adapter->ahw.qdr_sn_window = 0;
665
666 adapter->ahw.mn_win_crb = 0x100000 + PCIX_MN_WINDOW +
667 (pci_func * 0x20);
668 adapter->ahw.ms_win_crb = 0x100000 + PCIX_SN_WINDOW;
669 if (pci_func < 4)
670 adapter->ahw.ms_win_crb += (pci_func * 0x20);
671 else
672 adapter->ahw.ms_win_crb +=
673 0xA0 + ((pci_func - 4) * 0x10);
674 } else {
675 return -EIO;
676 }
677
678 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
679
680 adapter->ahw.pci_base0 = mem_ptr0;
681 adapter->ahw.pci_len0 = pci_len0;
682 adapter->ahw.pci_base1 = mem_ptr1;
683 adapter->ahw.pci_base2 = mem_ptr2;
684
685 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
686 goto skip_doorbell;
687
688 db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */
689 db_len = pci_resource_len(pdev, 4);
690
691 if (db_len == 0) {
692 printk(KERN_ERR "%s: doorbell is disabled\n",
693 netxen_nic_driver_name);
694 err = -EIO;
695 goto err_out;
696 }
697
698 db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
699 if (!db_ptr) {
700 printk(KERN_ERR "%s: Failed to allocate doorbell map.",
701 netxen_nic_driver_name);
702 err = -EIO;
703 goto err_out;
704 }
705
706 skip_doorbell:
707 adapter->ahw.db_base = db_ptr;
708 adapter->ahw.db_len = db_len;
709 return 0;
710
711 err_out:
712 netxen_cleanup_pci_map(adapter);
713 return err;
714 }
715
716 static int
717 netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
718 {
719 int val, err, first_boot;
720 struct pci_dev *pdev = adapter->pdev;
721
722 int first_driver = 0;
723
724 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
725 first_driver = (adapter->portnum == 0);
726 else
727 first_driver = (adapter->ahw.pci_func == 0);
728
729 if (!first_driver)
730 goto wait_init;
731
732 first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
733
734 err = netxen_check_hw_init(adapter, first_boot);
735 if (err) {
736 dev_err(&pdev->dev, "error in init HW init sequence\n");
737 return err;
738 }
739
740 if (request_fw)
741 netxen_request_firmware(adapter);
742
743 err = netxen_need_fw_reset(adapter);
744 if (err <= 0)
745 return err;
746
747 if (first_boot != 0x55555555) {
748 NXWR32(adapter, CRB_CMDPEG_STATE, 0);
749 netxen_pinit_from_rom(adapter, 0);
750 msleep(1);
751 }
752
753 NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
754 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
755 netxen_set_port_mode(adapter);
756
757 netxen_load_firmware(adapter);
758
759 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
760
761 /* Initialize multicast addr pool owners */
762 val = 0x7654;
763 if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
764 val |= 0x0f000000;
765 NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
766
767 }
768
769 err = netxen_init_dummy_dma(adapter);
770 if (err)
771 return err;
772
773 /*
774 * Tell the hardware our version number.
775 */
776 val = (_NETXEN_NIC_LINUX_MAJOR << 16)
777 | ((_NETXEN_NIC_LINUX_MINOR << 8))
778 | (_NETXEN_NIC_LINUX_SUBVERSION);
779 NXWR32(adapter, CRB_DRIVER_VERSION, val);
780
781 wait_init:
782 /* Handshake with the card before we register the devices. */
783 err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
784 if (err) {
785 netxen_free_dummy_dma(adapter);
786 return err;
787 }
788
789 nx_update_dma_mask(adapter);
790
791 netxen_nic_get_firmware_info(adapter);
792
793 return 0;
794 }
795
796 static int
797 netxen_nic_request_irq(struct netxen_adapter *adapter)
798 {
799 irq_handler_t handler;
800 struct nx_host_sds_ring *sds_ring;
801 int err, ring;
802
803 unsigned long flags = IRQF_SAMPLE_RANDOM;
804 struct net_device *netdev = adapter->netdev;
805 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
806
807 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
808 handler = netxen_msix_intr;
809 else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
810 handler = netxen_msi_intr;
811 else {
812 flags |= IRQF_SHARED;
813 handler = netxen_intr;
814 }
815 adapter->irq = netdev->irq;
816
817 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
818 sds_ring = &recv_ctx->sds_rings[ring];
819 sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
820 err = request_irq(sds_ring->irq, handler,
821 flags, sds_ring->name, sds_ring);
822 if (err)
823 return err;
824 }
825
826 return 0;
827 }
828
829 static void
830 netxen_nic_free_irq(struct netxen_adapter *adapter)
831 {
832 int ring;
833 struct nx_host_sds_ring *sds_ring;
834
835 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
836
837 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
838 sds_ring = &recv_ctx->sds_rings[ring];
839 free_irq(sds_ring->irq, sds_ring);
840 }
841 }
842
843 static void
844 netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
845 {
846 adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
847 adapter->coal.normal.data.rx_time_us =
848 NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
849 adapter->coal.normal.data.rx_packets =
850 NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
851 adapter->coal.normal.data.tx_time_us =
852 NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
853 adapter->coal.normal.data.tx_packets =
854 NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
855 }
856
857 static int
858 netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
859 {
860 int err;
861
862 err = adapter->init_port(adapter, adapter->physical_port);
863 if (err) {
864 printk(KERN_ERR "%s: Failed to initialize port %d\n",
865 netxen_nic_driver_name, adapter->portnum);
866 return err;
867 }
868 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
869 adapter->macaddr_set(adapter, netdev->dev_addr);
870
871 adapter->set_multi(netdev);
872 adapter->set_mtu(adapter, netdev->mtu);
873
874 adapter->ahw.linkup = 0;
875
876 if (adapter->max_sds_rings > 1)
877 netxen_config_rss(adapter, 1);
878
879 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
880 netxen_config_intr_coalesce(adapter);
881
882 netxen_napi_enable(adapter);
883
884 if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
885 netxen_linkevent_request(adapter, 1);
886 else
887 netxen_nic_set_link_parameters(adapter);
888
889 mod_timer(&adapter->watchdog_timer, jiffies);
890
891 return 0;
892 }
893
894 static void
895 netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
896 {
897 spin_lock(&adapter->tx_clean_lock);
898 netif_carrier_off(netdev);
899 netif_tx_disable(netdev);
900
901 if (adapter->stop_port)
902 adapter->stop_port(adapter);
903
904 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
905 netxen_p3_free_mac_list(adapter);
906
907 netxen_napi_disable(adapter);
908
909 netxen_release_tx_buffers(adapter);
910 spin_unlock(&adapter->tx_clean_lock);
911
912 del_timer_sync(&adapter->watchdog_timer);
913 FLUSH_SCHEDULED_WORK();
914 }
915
916
917 static int
918 netxen_nic_attach(struct netxen_adapter *adapter)
919 {
920 struct net_device *netdev = adapter->netdev;
921 struct pci_dev *pdev = adapter->pdev;
922 int err, ring;
923 struct nx_host_rds_ring *rds_ring;
924 struct nx_host_tx_ring *tx_ring;
925
926 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
927 return 0;
928
929 err = netxen_init_firmware(adapter);
930 if (err != 0) {
931 printk(KERN_ERR "Failed to init firmware\n");
932 return -EIO;
933 }
934
935 err = netxen_alloc_sw_resources(adapter);
936 if (err) {
937 printk(KERN_ERR "%s: Error in setting sw resources\n",
938 netdev->name);
939 return err;
940 }
941
942 netxen_nic_clear_stats(adapter);
943
944 err = netxen_alloc_hw_resources(adapter);
945 if (err) {
946 printk(KERN_ERR "%s: Error in setting hw resources\n",
947 netdev->name);
948 goto err_out_free_sw;
949 }
950
951 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
952 tx_ring = adapter->tx_ring;
953 tx_ring->crb_cmd_producer = crb_cmd_producer[adapter->portnum];
954 tx_ring->crb_cmd_consumer = crb_cmd_consumer[adapter->portnum];
955
956 tx_ring->producer = 0;
957 tx_ring->sw_consumer = 0;
958
959 netxen_nic_update_cmd_producer(adapter, tx_ring);
960 netxen_nic_update_cmd_consumer(adapter, tx_ring);
961 }
962
963 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
964 rds_ring = &adapter->recv_ctx.rds_rings[ring];
965 netxen_post_rx_buffers(adapter, ring, rds_ring);
966 }
967
968 err = netxen_nic_request_irq(adapter);
969 if (err) {
970 dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
971 netdev->name);
972 goto err_out_free_rxbuf;
973 }
974
975 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
976 netxen_nic_init_coalesce_defaults(adapter);
977
978 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
979 return 0;
980
981 err_out_free_rxbuf:
982 netxen_release_rx_buffers(adapter);
983 netxen_free_hw_resources(adapter);
984 err_out_free_sw:
985 netxen_free_sw_resources(adapter);
986 return err;
987 }
988
989 static void
990 netxen_nic_detach(struct netxen_adapter *adapter)
991 {
992 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
993 return;
994
995 netxen_free_hw_resources(adapter);
996 netxen_release_rx_buffers(adapter);
997 netxen_nic_free_irq(adapter);
998 netxen_free_sw_resources(adapter);
999
1000 adapter->is_up = 0;
1001 }
1002
1003 int
1004 netxen_nic_reset_context(struct netxen_adapter *adapter)
1005 {
1006 int err = 0;
1007 struct net_device *netdev = adapter->netdev;
1008
1009 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
1010
1011 if (netif_running(netdev))
1012 netxen_nic_down(adapter, netdev);
1013
1014 netxen_nic_detach(adapter);
1015
1016 err = netxen_nic_attach(adapter);
1017 if (err)
1018 goto done;
1019
1020 if (netif_running(netdev))
1021 err = netxen_nic_up(adapter, netdev);
1022 }
1023 done:
1024 return err;
1025 }
1026
1027 static int
1028 netxen_setup_netdev(struct netxen_adapter *adapter,
1029 struct net_device *netdev)
1030 {
1031 int err = 0;
1032 struct pci_dev *pdev = adapter->pdev;
1033
1034 adapter->rx_csum = 1;
1035 adapter->mc_enabled = 0;
1036 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1037 adapter->max_mc_count = 38;
1038 else
1039 adapter->max_mc_count = 16;
1040
1041 netdev->netdev_ops = &netxen_netdev_ops;
1042 netdev->watchdog_timeo = 2*HZ;
1043
1044 netxen_nic_change_mtu(netdev, netdev->mtu);
1045
1046 SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
1047
1048 netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
1049 netdev->features |= (NETIF_F_GRO);
1050 netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
1051
1052 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
1053 netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
1054 netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
1055 }
1056
1057 if (adapter->pci_using_dac) {
1058 netdev->features |= NETIF_F_HIGHDMA;
1059 netdev->vlan_features |= NETIF_F_HIGHDMA;
1060 }
1061
1062 if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
1063 netdev->features |= (NETIF_F_HW_VLAN_TX);
1064
1065 netdev->irq = adapter->msix_entries[0].vector;
1066
1067 err = netxen_napi_add(adapter, netdev);
1068 if (err)
1069 return err;
1070
1071 init_timer(&adapter->watchdog_timer);
1072 adapter->watchdog_timer.function = &netxen_watchdog;
1073 adapter->watchdog_timer.data = (unsigned long)adapter;
1074 INIT_WORK(&adapter->watchdog_task, netxen_watchdog_task);
1075 INIT_WORK(&adapter->tx_timeout_task, netxen_reset_task);
1076
1077 if (netxen_read_mac_addr(adapter))
1078 dev_warn(&pdev->dev, "failed to read mac addr\n");
1079
1080 netif_carrier_off(netdev);
1081 netif_stop_queue(netdev);
1082
1083 err = register_netdev(netdev);
1084 if (err) {
1085 dev_err(&pdev->dev, "failed to register net device\n");
1086 return err;
1087 }
1088
1089 return 0;
1090 }
1091
1092 static int __devinit
1093 netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1094 {
1095 struct net_device *netdev = NULL;
1096 struct netxen_adapter *adapter = NULL;
1097 int i = 0, err;
1098 int pci_func_id = PCI_FUNC(pdev->devfn);
1099 uint8_t revision_id;
1100
1101 if (pdev->class != 0x020000) {
1102 printk(KERN_DEBUG "NetXen function %d, class %x will not "
1103 "be enabled.\n",pci_func_id, pdev->class);
1104 return -ENODEV;
1105 }
1106
1107 if (pdev->revision >= NX_P3_A0 && pdev->revision < NX_P3_B1) {
1108 printk(KERN_WARNING "NetXen chip revisions between 0x%x-0x%x"
1109 "will not be enabled.\n",
1110 NX_P3_A0, NX_P3_B1);
1111 return -ENODEV;
1112 }
1113
1114 if ((err = pci_enable_device(pdev)))
1115 return err;
1116
1117 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1118 err = -ENODEV;
1119 goto err_out_disable_pdev;
1120 }
1121
1122 if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
1123 goto err_out_disable_pdev;
1124
1125 pci_set_master(pdev);
1126
1127 netdev = alloc_etherdev(sizeof(struct netxen_adapter));
1128 if(!netdev) {
1129 dev_err(&pdev->dev, "failed to allocate net_device\n");
1130 err = -ENOMEM;
1131 goto err_out_free_res;
1132 }
1133
1134 SET_NETDEV_DEV(netdev, &pdev->dev);
1135
1136 adapter = netdev_priv(netdev);
1137 adapter->netdev = netdev;
1138 adapter->pdev = pdev;
1139 adapter->ahw.pci_func = pci_func_id;
1140
1141 revision_id = pdev->revision;
1142 adapter->ahw.revision_id = revision_id;
1143
1144 err = nx_set_dma_mask(adapter);
1145 if (err)
1146 goto err_out_free_netdev;
1147
1148 rwlock_init(&adapter->adapter_lock);
1149 spin_lock_init(&adapter->tx_clean_lock);
1150 INIT_LIST_HEAD(&adapter->mac_list);
1151
1152 err = netxen_setup_pci_map(adapter);
1153 if (err)
1154 goto err_out_free_netdev;
1155
1156 /* This will be reset for mezz cards */
1157 adapter->portnum = pci_func_id;
1158
1159 err = netxen_nic_get_board_info(adapter);
1160 if (err) {
1161 dev_err(&pdev->dev, "Error getting board config info.\n");
1162 goto err_out_iounmap;
1163 }
1164
1165 netxen_initialize_adapter_ops(adapter);
1166
1167 /* Mezz cards have PCI function 0,2,3 enabled */
1168 switch (adapter->ahw.board_type) {
1169 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
1170 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
1171 if (pci_func_id >= 2)
1172 adapter->portnum = pci_func_id - 2;
1173 break;
1174 default:
1175 break;
1176 }
1177
1178 err = netxen_start_firmware(adapter, 1);
1179 if (err)
1180 goto err_out_iounmap;
1181
1182 /*
1183 * See if the firmware gave us a virtual-physical port mapping.
1184 */
1185 adapter->physical_port = adapter->portnum;
1186 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1187 i = NXRD32(adapter, CRB_V2P(adapter->portnum));
1188 if (i != 0x55555555)
1189 adapter->physical_port = i;
1190 }
1191
1192 netxen_check_options(adapter);
1193
1194 netxen_setup_intr(adapter);
1195
1196 err = netxen_setup_netdev(adapter, netdev);
1197 if (err)
1198 goto err_out_disable_msi;
1199
1200 pci_set_drvdata(pdev, adapter);
1201
1202 switch (adapter->ahw.port_type) {
1203 case NETXEN_NIC_GBE:
1204 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1205 adapter->netdev->name);
1206 break;
1207 case NETXEN_NIC_XGBE:
1208 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1209 adapter->netdev->name);
1210 break;
1211 }
1212
1213 return 0;
1214
1215 err_out_disable_msi:
1216 netxen_teardown_intr(adapter);
1217
1218 netxen_free_dummy_dma(adapter);
1219
1220 err_out_iounmap:
1221 netxen_cleanup_pci_map(adapter);
1222
1223 err_out_free_netdev:
1224 free_netdev(netdev);
1225
1226 err_out_free_res:
1227 pci_release_regions(pdev);
1228
1229 err_out_disable_pdev:
1230 pci_set_drvdata(pdev, NULL);
1231 pci_disable_device(pdev);
1232 return err;
1233 }
1234
1235 static void __devexit netxen_nic_remove(struct pci_dev *pdev)
1236 {
1237 struct netxen_adapter *adapter;
1238 struct net_device *netdev;
1239
1240 adapter = pci_get_drvdata(pdev);
1241 if (adapter == NULL)
1242 return;
1243
1244 netdev = adapter->netdev;
1245
1246 unregister_netdev(netdev);
1247
1248 netxen_nic_detach(adapter);
1249
1250 if (adapter->portnum == 0)
1251 netxen_free_dummy_dma(adapter);
1252
1253 netxen_teardown_intr(adapter);
1254 netxen_free_sds_rings(&adapter->recv_ctx);
1255
1256 netxen_cleanup_pci_map(adapter);
1257
1258 netxen_release_firmware(adapter);
1259
1260 pci_release_regions(pdev);
1261 pci_disable_device(pdev);
1262 pci_set_drvdata(pdev, NULL);
1263
1264 free_netdev(netdev);
1265 }
1266
1267 #ifdef CONFIG_PM
1268 static int
1269 netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
1270 {
1271
1272 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1273 struct net_device *netdev = adapter->netdev;
1274
1275 netif_device_detach(netdev);
1276
1277 if (netif_running(netdev))
1278 netxen_nic_down(adapter, netdev);
1279
1280 netxen_nic_detach(adapter);
1281
1282 pci_save_state(pdev);
1283
1284 if (netxen_nic_wol_supported(adapter)) {
1285 pci_enable_wake(pdev, PCI_D3cold, 1);
1286 pci_enable_wake(pdev, PCI_D3hot, 1);
1287 }
1288
1289 pci_disable_device(pdev);
1290 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1291
1292 return 0;
1293 }
1294
1295 static int
1296 netxen_nic_resume(struct pci_dev *pdev)
1297 {
1298 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1299 struct net_device *netdev = adapter->netdev;
1300 int err;
1301
1302 pci_set_power_state(pdev, PCI_D0);
1303 pci_restore_state(pdev);
1304
1305 err = pci_enable_device(pdev);
1306 if (err)
1307 return err;
1308
1309 adapter->curr_window = 255;
1310
1311 err = netxen_start_firmware(adapter, 0);
1312 if (err) {
1313 dev_err(&pdev->dev, "failed to start firmware\n");
1314 return err;
1315 }
1316
1317 if (netif_running(netdev)) {
1318 err = netxen_nic_attach(adapter);
1319 if (err)
1320 return err;
1321
1322 err = netxen_nic_up(adapter, netdev);
1323 if (err)
1324 return err;
1325
1326 netif_device_attach(netdev);
1327 }
1328
1329 return 0;
1330 }
1331 #endif
1332
1333 static int netxen_nic_open(struct net_device *netdev)
1334 {
1335 struct netxen_adapter *adapter = netdev_priv(netdev);
1336 int err = 0;
1337
1338 if (adapter->driver_mismatch)
1339 return -EIO;
1340
1341 err = netxen_nic_attach(adapter);
1342 if (err)
1343 return err;
1344
1345 err = netxen_nic_up(adapter, netdev);
1346 if (err)
1347 goto err_out;
1348
1349 netif_start_queue(netdev);
1350
1351 return 0;
1352
1353 err_out:
1354 netxen_nic_detach(adapter);
1355 return err;
1356 }
1357
1358 /*
1359 * netxen_nic_close - Disables a network interface entry point
1360 */
1361 static int netxen_nic_close(struct net_device *netdev)
1362 {
1363 struct netxen_adapter *adapter = netdev_priv(netdev);
1364
1365 netxen_nic_down(adapter, netdev);
1366 return 0;
1367 }
1368
1369 static void
1370 netxen_tso_check(struct net_device *netdev,
1371 struct nx_host_tx_ring *tx_ring,
1372 struct cmd_desc_type0 *first_desc,
1373 struct sk_buff *skb)
1374 {
1375 u8 opcode = TX_ETHER_PKT;
1376 __be16 protocol = skb->protocol;
1377 u16 flags = 0, vid = 0;
1378 u32 producer;
1379 int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
1380 struct cmd_desc_type0 *hwdesc;
1381 struct vlan_ethhdr *vh;
1382
1383 if (protocol == cpu_to_be16(ETH_P_8021Q)) {
1384
1385 vh = (struct vlan_ethhdr *)skb->data;
1386 protocol = vh->h_vlan_encapsulated_proto;
1387 flags = FLAGS_VLAN_TAGGED;
1388
1389 } else if (vlan_tx_tag_present(skb)) {
1390
1391 flags = FLAGS_VLAN_OOB;
1392 vid = vlan_tx_tag_get(skb);
1393 netxen_set_tx_vlan_tci(first_desc, vid);
1394 vlan_oob = 1;
1395 }
1396
1397 if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1398 skb_shinfo(skb)->gso_size > 0) {
1399
1400 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1401
1402 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1403 first_desc->total_hdr_length = hdr_len;
1404 if (vlan_oob) {
1405 first_desc->total_hdr_length += VLAN_HLEN;
1406 first_desc->tcp_hdr_offset = VLAN_HLEN;
1407 first_desc->ip_hdr_offset = VLAN_HLEN;
1408 /* Only in case of TSO on vlan device */
1409 flags |= FLAGS_VLAN_TAGGED;
1410 }
1411
1412 opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
1413 TX_TCP_LSO6 : TX_TCP_LSO;
1414 tso = 1;
1415
1416 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
1417 u8 l4proto;
1418
1419 if (protocol == cpu_to_be16(ETH_P_IP)) {
1420 l4proto = ip_hdr(skb)->protocol;
1421
1422 if (l4proto == IPPROTO_TCP)
1423 opcode = TX_TCP_PKT;
1424 else if(l4proto == IPPROTO_UDP)
1425 opcode = TX_UDP_PKT;
1426 } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
1427 l4proto = ipv6_hdr(skb)->nexthdr;
1428
1429 if (l4proto == IPPROTO_TCP)
1430 opcode = TX_TCPV6_PKT;
1431 else if(l4proto == IPPROTO_UDP)
1432 opcode = TX_UDPV6_PKT;
1433 }
1434 }
1435
1436 first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1437 first_desc->ip_hdr_offset += skb_network_offset(skb);
1438 netxen_set_tx_flags_opcode(first_desc, flags, opcode);
1439
1440 if (!tso)
1441 return;
1442
1443 /* For LSO, we need to copy the MAC/IP/TCP headers into
1444 * the descriptor ring
1445 */
1446 producer = tx_ring->producer;
1447 copied = 0;
1448 offset = 2;
1449
1450 if (vlan_oob) {
1451 /* Create a TSO vlan header template for firmware */
1452
1453 hwdesc = &tx_ring->desc_head[producer];
1454 tx_ring->cmd_buf_arr[producer].skb = NULL;
1455
1456 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1457 hdr_len + VLAN_HLEN);
1458
1459 vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1460 skb_copy_from_linear_data(skb, vh, 12);
1461 vh->h_vlan_proto = htons(ETH_P_8021Q);
1462 vh->h_vlan_TCI = htons(vid);
1463 skb_copy_from_linear_data_offset(skb, 12,
1464 (char *)vh + 16, copy_len - 16);
1465
1466 copied = copy_len - VLAN_HLEN;
1467 offset = 0;
1468
1469 producer = get_next_index(producer, tx_ring->num_desc);
1470 }
1471
1472 while (copied < hdr_len) {
1473
1474 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1475 (hdr_len - copied));
1476
1477 hwdesc = &tx_ring->desc_head[producer];
1478 tx_ring->cmd_buf_arr[producer].skb = NULL;
1479
1480 skb_copy_from_linear_data_offset(skb, copied,
1481 (char *)hwdesc + offset, copy_len);
1482
1483 copied += copy_len;
1484 offset = 0;
1485
1486 producer = get_next_index(producer, tx_ring->num_desc);
1487 }
1488
1489 tx_ring->producer = producer;
1490 barrier();
1491 }
1492
1493 static void
1494 netxen_clean_tx_dma_mapping(struct pci_dev *pdev,
1495 struct netxen_cmd_buffer *pbuf, int last)
1496 {
1497 int k;
1498 struct netxen_skb_frag *buffrag;
1499
1500 buffrag = &pbuf->frag_array[0];
1501 pci_unmap_single(pdev, buffrag->dma,
1502 buffrag->length, PCI_DMA_TODEVICE);
1503
1504 for (k = 1; k < last; k++) {
1505 buffrag = &pbuf->frag_array[k];
1506 pci_unmap_page(pdev, buffrag->dma,
1507 buffrag->length, PCI_DMA_TODEVICE);
1508 }
1509 }
1510
1511 static inline void
1512 netxen_clear_cmddesc(u64 *desc)
1513 {
1514 desc[0] = 0ULL;
1515 desc[2] = 0ULL;
1516 }
1517
1518 static int
1519 netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1520 {
1521 struct netxen_adapter *adapter = netdev_priv(netdev);
1522 struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
1523 struct skb_frag_struct *frag;
1524 struct netxen_cmd_buffer *pbuf;
1525 struct netxen_skb_frag *buffrag;
1526 struct cmd_desc_type0 *hwdesc, *first_desc;
1527 struct pci_dev *pdev;
1528 dma_addr_t temp_dma;
1529 int i, k;
1530 unsigned long offset;
1531
1532 u32 producer;
1533 int len, frag_count, no_of_desc;
1534 u32 num_txd = tx_ring->num_desc;
1535
1536 frag_count = skb_shinfo(skb)->nr_frags + 1;
1537
1538 /* 4 fragments per cmd des */
1539 no_of_desc = (frag_count + 3) >> 2;
1540
1541 if (unlikely(no_of_desc + 2) > netxen_tx_avail(tx_ring)) {
1542 netif_stop_queue(netdev);
1543 return NETDEV_TX_BUSY;
1544 }
1545
1546 producer = tx_ring->producer;
1547
1548 pdev = adapter->pdev;
1549 len = skb->len - skb->data_len;
1550
1551 temp_dma = pci_map_single(pdev, skb->data, len, PCI_DMA_TODEVICE);
1552 if (pci_dma_mapping_error(pdev, temp_dma))
1553 goto drop_packet;
1554
1555 pbuf = &tx_ring->cmd_buf_arr[producer];
1556 pbuf->skb = skb;
1557 pbuf->frag_count = frag_count;
1558
1559 buffrag = &pbuf->frag_array[0];
1560 buffrag->dma = temp_dma;
1561 buffrag->length = len;
1562
1563 first_desc = hwdesc = &tx_ring->desc_head[producer];
1564 netxen_clear_cmddesc((u64 *)hwdesc);
1565 netxen_set_tx_frags_len(hwdesc, frag_count, skb->len);
1566 netxen_set_tx_port(hwdesc, adapter->portnum);
1567
1568 hwdesc->buffer_length[0] = cpu_to_le16(len);
1569 hwdesc->addr_buffer1 = cpu_to_le64(temp_dma);
1570
1571 for (i = 1, k = 1; i < frag_count; i++, k++) {
1572
1573 /* move to next desc. if there is a need */
1574 if ((i & 0x3) == 0) {
1575 k = 0;
1576 producer = get_next_index(producer, num_txd);
1577 hwdesc = &tx_ring->desc_head[producer];
1578 netxen_clear_cmddesc((u64 *)hwdesc);
1579 pbuf = &tx_ring->cmd_buf_arr[producer];
1580 pbuf->skb = NULL;
1581 }
1582 buffrag = &pbuf->frag_array[i];
1583 frag = &skb_shinfo(skb)->frags[i - 1];
1584 len = frag->size;
1585 offset = frag->page_offset;
1586
1587 temp_dma = pci_map_page(pdev, frag->page, offset,
1588 len, PCI_DMA_TODEVICE);
1589 if (pci_dma_mapping_error(pdev, temp_dma)) {
1590 netxen_clean_tx_dma_mapping(pdev, pbuf, i);
1591 goto drop_packet;
1592 }
1593
1594 buffrag->dma = temp_dma;
1595 buffrag->length = len;
1596
1597 hwdesc->buffer_length[k] = cpu_to_le16(len);
1598 switch (k) {
1599 case 0:
1600 hwdesc->addr_buffer1 = cpu_to_le64(temp_dma);
1601 break;
1602 case 1:
1603 hwdesc->addr_buffer2 = cpu_to_le64(temp_dma);
1604 break;
1605 case 2:
1606 hwdesc->addr_buffer3 = cpu_to_le64(temp_dma);
1607 break;
1608 case 3:
1609 hwdesc->addr_buffer4 = cpu_to_le64(temp_dma);
1610 break;
1611 }
1612 }
1613 tx_ring->producer = get_next_index(producer, num_txd);
1614
1615 netxen_tso_check(netdev, tx_ring, first_desc, skb);
1616
1617 netxen_nic_update_cmd_producer(adapter, tx_ring);
1618
1619 adapter->stats.txbytes += skb->len;
1620 adapter->stats.xmitcalled++;
1621
1622 return NETDEV_TX_OK;
1623
1624 drop_packet:
1625 adapter->stats.txdropped++;
1626 dev_kfree_skb_any(skb);
1627 return NETDEV_TX_OK;
1628 }
1629
1630 static int netxen_nic_check_temp(struct netxen_adapter *adapter)
1631 {
1632 struct net_device *netdev = adapter->netdev;
1633 uint32_t temp, temp_state, temp_val;
1634 int rv = 0;
1635
1636 temp = NXRD32(adapter, CRB_TEMP_STATE);
1637
1638 temp_state = nx_get_temp_state(temp);
1639 temp_val = nx_get_temp_val(temp);
1640
1641 if (temp_state == NX_TEMP_PANIC) {
1642 printk(KERN_ALERT
1643 "%s: Device temperature %d degrees C exceeds"
1644 " maximum allowed. Hardware has been shut down.\n",
1645 netdev->name, temp_val);
1646
1647 netif_device_detach(netdev);
1648 netxen_nic_down(adapter, netdev);
1649 netxen_nic_detach(adapter);
1650
1651 rv = 1;
1652 } else if (temp_state == NX_TEMP_WARN) {
1653 if (adapter->temp == NX_TEMP_NORMAL) {
1654 printk(KERN_ALERT
1655 "%s: Device temperature %d degrees C "
1656 "exceeds operating range."
1657 " Immediate action needed.\n",
1658 netdev->name, temp_val);
1659 }
1660 } else {
1661 if (adapter->temp == NX_TEMP_WARN) {
1662 printk(KERN_INFO
1663 "%s: Device temperature is now %d degrees C"
1664 " in normal range.\n", netdev->name,
1665 temp_val);
1666 }
1667 }
1668 adapter->temp = temp_state;
1669 return rv;
1670 }
1671
1672 void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
1673 {
1674 struct net_device *netdev = adapter->netdev;
1675
1676 if (adapter->ahw.linkup && !linkup) {
1677 printk(KERN_INFO "%s: %s NIC Link is down\n",
1678 netxen_nic_driver_name, netdev->name);
1679 adapter->ahw.linkup = 0;
1680 if (netif_running(netdev)) {
1681 netif_carrier_off(netdev);
1682 netif_stop_queue(netdev);
1683 }
1684
1685 if (!adapter->has_link_events)
1686 netxen_nic_set_link_parameters(adapter);
1687
1688 } else if (!adapter->ahw.linkup && linkup) {
1689 printk(KERN_INFO "%s: %s NIC Link is up\n",
1690 netxen_nic_driver_name, netdev->name);
1691 adapter->ahw.linkup = 1;
1692 if (netif_running(netdev)) {
1693 netif_carrier_on(netdev);
1694 netif_wake_queue(netdev);
1695 }
1696
1697 if (!adapter->has_link_events)
1698 netxen_nic_set_link_parameters(adapter);
1699 }
1700 }
1701
1702 static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
1703 {
1704 u32 val, port, linkup;
1705
1706 port = adapter->physical_port;
1707
1708 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
1709 val = NXRD32(adapter, CRB_XG_STATE_P3);
1710 val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
1711 linkup = (val == XG_LINK_UP_P3);
1712 } else {
1713 val = NXRD32(adapter, CRB_XG_STATE);
1714 if (adapter->ahw.port_type == NETXEN_NIC_GBE)
1715 linkup = (val >> port) & 1;
1716 else {
1717 val = (val >> port*8) & 0xff;
1718 linkup = (val == XG_LINK_UP);
1719 }
1720 }
1721
1722 netxen_advert_link_change(adapter, linkup);
1723 }
1724
1725 static void netxen_watchdog(unsigned long v)
1726 {
1727 struct netxen_adapter *adapter = (struct netxen_adapter *)v;
1728
1729 SCHEDULE_WORK(&adapter->watchdog_task);
1730 }
1731
1732 void netxen_watchdog_task(struct work_struct *work)
1733 {
1734 struct netxen_adapter *adapter =
1735 container_of(work, struct netxen_adapter, watchdog_task);
1736
1737 if (netxen_nic_check_temp(adapter))
1738 return;
1739
1740 if (!adapter->has_link_events)
1741 netxen_nic_handle_phy_intr(adapter);
1742
1743 if (netif_running(adapter->netdev))
1744 mod_timer(&adapter->watchdog_timer, jiffies + 2 * HZ);
1745 }
1746
1747 static void netxen_tx_timeout(struct net_device *netdev)
1748 {
1749 struct netxen_adapter *adapter = (struct netxen_adapter *)
1750 netdev_priv(netdev);
1751
1752 dev_err(&netdev->dev, "transmit timeout, resetting.\n");
1753
1754 SCHEDULE_WORK(&adapter->tx_timeout_task);
1755 }
1756
1757 static void netxen_reset_task(struct work_struct *work)
1758 {
1759 struct netxen_adapter *adapter =
1760 container_of(work, struct netxen_adapter, tx_timeout_task);
1761
1762 if (!netif_running(adapter->netdev))
1763 return;
1764
1765 netxen_napi_disable(adapter);
1766
1767 adapter->netdev->trans_start = jiffies;
1768
1769 netxen_napi_enable(adapter);
1770 netif_wake_queue(adapter->netdev);
1771 }
1772
1773 struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
1774 {
1775 struct netxen_adapter *adapter = netdev_priv(netdev);
1776 struct net_device_stats *stats = &adapter->net_stats;
1777
1778 memset(stats, 0, sizeof(*stats));
1779
1780 stats->rx_packets = adapter->stats.no_rcv;
1781 stats->tx_packets = adapter->stats.xmitfinished;
1782 stats->rx_bytes = adapter->stats.rxbytes;
1783 stats->tx_bytes = adapter->stats.txbytes;
1784 stats->rx_dropped = adapter->stats.rxdropped;
1785 stats->tx_dropped = adapter->stats.txdropped;
1786
1787 return stats;
1788 }
1789
1790 static irqreturn_t netxen_intr(int irq, void *data)
1791 {
1792 struct nx_host_sds_ring *sds_ring = data;
1793 struct netxen_adapter *adapter = sds_ring->adapter;
1794 u32 status = 0;
1795
1796 status = adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
1797
1798 if (!(status & adapter->legacy_intr.int_vec_bit))
1799 return IRQ_NONE;
1800
1801 if (adapter->ahw.revision_id >= NX_P3_B1) {
1802 /* check interrupt state machine, to be sure */
1803 status = adapter->pci_read_immediate(adapter,
1804 ISR_INT_STATE_REG);
1805 if (!ISR_LEGACY_INT_TRIGGERED(status))
1806 return IRQ_NONE;
1807
1808 } else {
1809 unsigned long our_int = 0;
1810
1811 our_int = NXRD32(adapter, CRB_INT_VECTOR);
1812
1813 /* not our interrupt */
1814 if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
1815 return IRQ_NONE;
1816
1817 /* claim interrupt */
1818 NXWR32(adapter, CRB_INT_VECTOR, (our_int & 0xffffffff));
1819 }
1820
1821 /* clear interrupt */
1822 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1823 netxen_nic_disable_int(sds_ring);
1824
1825 adapter->pci_write_immediate(adapter,
1826 adapter->legacy_intr.tgt_status_reg,
1827 0xffffffff);
1828 /* read twice to ensure write is flushed */
1829 adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
1830 adapter->pci_read_immediate(adapter, ISR_INT_VECTOR);
1831
1832 napi_schedule(&sds_ring->napi);
1833
1834 return IRQ_HANDLED;
1835 }
1836
1837 static irqreturn_t netxen_msi_intr(int irq, void *data)
1838 {
1839 struct nx_host_sds_ring *sds_ring = data;
1840 struct netxen_adapter *adapter = sds_ring->adapter;
1841
1842 /* clear interrupt */
1843 adapter->pci_write_immediate(adapter,
1844 adapter->msi_tgt_status, 0xffffffff);
1845
1846 napi_schedule(&sds_ring->napi);
1847 return IRQ_HANDLED;
1848 }
1849
1850 static irqreturn_t netxen_msix_intr(int irq, void *data)
1851 {
1852 struct nx_host_sds_ring *sds_ring = data;
1853
1854 napi_schedule(&sds_ring->napi);
1855 return IRQ_HANDLED;
1856 }
1857
1858 static int netxen_nic_poll(struct napi_struct *napi, int budget)
1859 {
1860 struct nx_host_sds_ring *sds_ring =
1861 container_of(napi, struct nx_host_sds_ring, napi);
1862
1863 struct netxen_adapter *adapter = sds_ring->adapter;
1864
1865 int tx_complete;
1866 int work_done;
1867
1868 tx_complete = netxen_process_cmd_ring(adapter);
1869
1870 work_done = netxen_process_rcv_ring(sds_ring, budget);
1871
1872 if ((work_done < budget) && tx_complete) {
1873 napi_complete(&sds_ring->napi);
1874 if (netif_running(adapter->netdev))
1875 netxen_nic_enable_int(sds_ring);
1876 }
1877
1878 return work_done;
1879 }
1880
1881 #ifdef CONFIG_NET_POLL_CONTROLLER
1882 static void netxen_nic_poll_controller(struct net_device *netdev)
1883 {
1884 struct netxen_adapter *adapter = netdev_priv(netdev);
1885 disable_irq(adapter->irq);
1886 netxen_intr(adapter->irq, adapter);
1887 enable_irq(adapter->irq);
1888 }
1889 #endif
1890
1891 #ifdef CONFIG_INET
1892
1893 #define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
1894
1895 static int
1896 netxen_destip_supported(struct netxen_adapter *adapter)
1897 {
1898 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1899 return 0;
1900
1901 if (adapter->ahw.cut_through)
1902 return 0;
1903
1904 return 1;
1905 }
1906
1907 static int netxen_netdev_event(struct notifier_block *this,
1908 unsigned long event, void *ptr)
1909 {
1910 struct netxen_adapter *adapter;
1911 struct net_device *dev = (struct net_device *)ptr;
1912 struct in_device *indev;
1913
1914 recheck:
1915 if (dev == NULL)
1916 goto done;
1917
1918 if (dev->priv_flags & IFF_802_1Q_VLAN) {
1919 dev = vlan_dev_real_dev(dev);
1920 goto recheck;
1921 }
1922
1923 if (!is_netxen_netdev(dev))
1924 goto done;
1925
1926 adapter = netdev_priv(dev);
1927
1928 if (!adapter || !netxen_destip_supported(adapter))
1929 goto done;
1930
1931 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1932 goto done;
1933
1934 indev = in_dev_get(dev);
1935 if (!indev)
1936 goto done;
1937
1938 for_ifa(indev) {
1939 switch (event) {
1940 case NETDEV_UP:
1941 netxen_config_ipaddr(adapter,
1942 ifa->ifa_address, NX_IP_UP);
1943 break;
1944 case NETDEV_DOWN:
1945 netxen_config_ipaddr(adapter,
1946 ifa->ifa_address, NX_IP_DOWN);
1947 break;
1948 default:
1949 break;
1950 }
1951 } endfor_ifa(indev);
1952
1953 in_dev_put(indev);
1954 done:
1955 return NOTIFY_DONE;
1956 }
1957
1958 static int
1959 netxen_inetaddr_event(struct notifier_block *this,
1960 unsigned long event, void *ptr)
1961 {
1962 struct netxen_adapter *adapter;
1963 struct net_device *dev;
1964
1965 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
1966
1967 dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
1968
1969 recheck:
1970 if (dev == NULL || !netif_running(dev))
1971 goto done;
1972
1973 if (dev->priv_flags & IFF_802_1Q_VLAN) {
1974 dev = vlan_dev_real_dev(dev);
1975 goto recheck;
1976 }
1977
1978 if (!is_netxen_netdev(dev))
1979 goto done;
1980
1981 adapter = netdev_priv(dev);
1982
1983 if (!adapter || !netxen_destip_supported(adapter))
1984 goto done;
1985
1986 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1987 goto done;
1988
1989 switch (event) {
1990 case NETDEV_UP:
1991 netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
1992 break;
1993 case NETDEV_DOWN:
1994 netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_DOWN);
1995 break;
1996 default:
1997 break;
1998 }
1999
2000 done:
2001 return NOTIFY_DONE;
2002 }
2003
2004 static struct notifier_block netxen_netdev_cb = {
2005 .notifier_call = netxen_netdev_event,
2006 };
2007
2008 static struct notifier_block netxen_inetaddr_cb = {
2009 .notifier_call = netxen_inetaddr_event,
2010 };
2011 #endif
2012
2013 static struct pci_driver netxen_driver = {
2014 .name = netxen_nic_driver_name,
2015 .id_table = netxen_pci_tbl,
2016 .probe = netxen_nic_probe,
2017 .remove = __devexit_p(netxen_nic_remove),
2018 #ifdef CONFIG_PM
2019 .suspend = netxen_nic_suspend,
2020 .resume = netxen_nic_resume
2021 #endif
2022 };
2023
2024 static int __init netxen_init_module(void)
2025 {
2026 printk(KERN_INFO "%s\n", netxen_nic_driver_string);
2027
2028 if ((netxen_workq = create_singlethread_workqueue("netxen")) == NULL)
2029 return -ENOMEM;
2030
2031 #ifdef CONFIG_INET
2032 register_netdevice_notifier(&netxen_netdev_cb);
2033 register_inetaddr_notifier(&netxen_inetaddr_cb);
2034 #endif
2035
2036 return pci_register_driver(&netxen_driver);
2037 }
2038
2039 module_init(netxen_init_module);
2040
2041 static void __exit netxen_exit_module(void)
2042 {
2043 pci_unregister_driver(&netxen_driver);
2044
2045 #ifdef CONFIG_INET
2046 unregister_inetaddr_notifier(&netxen_inetaddr_cb);
2047 unregister_netdevice_notifier(&netxen_netdev_cb);
2048 #endif
2049 destroy_workqueue(netxen_workq);
2050 }
2051
2052 module_exit(netxen_exit_module);
Linux 2.6 libata-dev (mirror)