projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net_sched: fix estimator lock selection for mq child qdiscs
[linux-2.6-block.git] / drivers / net / netxen / netxen_nic_main.c
CommitLineData
3d396eb1 1/*
5d242f1c 2 * Copyright (C) 2003 - 2009 NetXen, Inc.
3d396eb1 3 * All rights reserved.
80922fbc 4 *
3d396eb1
AK		 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.
80922fbc 9 *
3d396eb1
AK		 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.
80922fbc 14 *
3d396eb1
AK		 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.
80922fbc 19 *
3d396eb1
AK		 20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
80922fbc 22 *
3d396eb1
AK		 23 * Contact Information:
24 * info@netxen.com
5d242f1c
DP		 25 * NetXen Inc,
26 * 18922 Forge Drive
27 * Cupertino, CA 95014-0701
3d396eb1
AK		 28 *
29 */
30
cb8011ad 31#include <linux/vmalloc.h>
e98e3350 32#include <linux/interrupt.h>
3d396eb1
AK		 33#include "netxen_nic_hw.h"
34
35#include "netxen_nic.h"
3d396eb1 36
1494a814 37#include <linux/dma-mapping.h>
391587c3 38#include <linux/if_vlan.h>
c9bdd4b5 39#include <net/ip.h>
00977784 40#include <linux/ipv6.h>
6598b169 41#include <linux/inetdevice.h>
1494a814 42
3d396eb1
AK		 43MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
44MODULE_LICENSE("GPL");
45MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
46
ceded32f 47char netxen_nic_driver_name[] = "netxen_nic";
3d396eb1 48static char netxen_nic_driver_string[] = "NetXen Network Driver version "
cb8011ad 49 NETXEN_NIC_LINUX_VERSIONID;
3d396eb1 50
2956640d
DP		 51static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
52
53/* Default to restricted 1G auto-neg mode */
54static int wol_port_mode = 5;
55
56static int use_msi = 1;
57
58static int use_msi_x = 1;
59
3d396eb1
AK		 60/* Local functions to NetXen NIC driver */
61static int __devinit netxen_nic_probe(struct pci_dev *pdev,
2956640d 62 const struct pci_device_id *ent);
3d396eb1
AK		 63static void __devexit netxen_nic_remove(struct pci_dev *pdev);
64static int netxen_nic_open(struct net_device *netdev);
65static int netxen_nic_close(struct net_device *netdev);
61357325
SH		 66static netdev_tx_t netxen_nic_xmit_frame(struct sk_buff *,
67 struct net_device *);
3d396eb1 68static void netxen_tx_timeout(struct net_device *netdev);
f17443f4 69static void netxen_reset_task(struct work_struct *work);
6a581e93
DP		 70static void netxen_fw_poll_work(struct work_struct *work);
71static void netxen_schedule_work(struct netxen_adapter *adapter,
72 work_func_t func, int delay);
73static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
bea3348e 74static int netxen_nic_poll(struct napi_struct *napi, int budget);
3d396eb1
AK		 75#ifdef CONFIG_NET_POLL_CONTROLLER
76static void netxen_nic_poll_controller(struct net_device *netdev);
77#endif
fa3ce355
NK		 78
79static void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
80static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
81
6a581e93
DP		 82static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
83static int netxen_can_start_firmware(struct netxen_adapter *adapter);
84
1494a814 85static irqreturn_t netxen_intr(int irq, void *data);
05aaa02d 86static irqreturn_t netxen_msi_intr(int irq, void *data);
b3df68f8 87static irqreturn_t netxen_msix_intr(int irq, void *data);
3d396eb1 88
d0725e4d
AKS		 89static void netxen_config_indev_addr(struct net_device *dev, unsigned long);
90
3d396eb1 91/* PCI Device ID Table */
70081ac5 92#define ENTRY(device) \
040dec3b 93 {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
70081ac5
AV		 94 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
95
3d396eb1 96static struct pci_device_id netxen_pci_tbl[] __devinitdata = {
040dec3b
DP		 97 ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
98 ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
99 ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
100 ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
101 ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
102 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
103 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
104 ENTRY(PCI_DEVICE_ID_NX3031),
3d396eb1
AK		 105 {0,}
106};
107
108MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
109
7830b22c
DP		 110static uint32_t crb_cmd_producer[4] = {
111 CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
112 CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
113};
114
c9fc891f 115void
3ce06a32 116netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
cb2107be 117 struct nx_host_tx_ring *tx_ring)
3176ff3e 118{
195c5f98 119 NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
cb2107be
DP		 120
121 if (netxen_tx_avail(tx_ring) <= TX_STOP_THRESH) {
122 netif_stop_queue(adapter->netdev);
123 smp_mb();
124 }
3176ff3e
MT		 125}
126
7830b22c
DP		 127static uint32_t crb_cmd_consumer[4] = {
128 CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
129 CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
130};
131
3ce06a32
DP		 132static inline void
133netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
cb2107be 134 struct nx_host_tx_ring *tx_ring)
3176ff3e 135{
195c5f98 136 NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
3176ff3e
MT		 137}
138
2956640d 139static uint32_t msi_tgt_status[8] = {
443be796 140 ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
2956640d
DP		 141 ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
142 ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
143 ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
443be796
DP		 144};
145
2956640d
DP		 146static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
147
d8b100c5 148static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
4638aef1 149{
d8b100c5
DP		 150 struct netxen_adapter *adapter = sds_ring->adapter;
151
195c5f98 152 NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
4638aef1
SH		 153}
154
d8b100c5 155static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
4638aef1 156{
d8b100c5
DP		 157 struct netxen_adapter *adapter = sds_ring->adapter;
158
195c5f98 159 NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
4638aef1 160
092bc571 161 if (!NETXEN_IS_MSI_FAMILY(adapter))
195c5f98 162 NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
4638aef1
SH		 163}
164
71dcddbd
DP		 165static int
166netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
167{
168 int size = sizeof(struct nx_host_sds_ring) * count;
169
170 recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
171
172 return (recv_ctx->sds_rings == NULL);
173}
174
d8b100c5 175static void
71dcddbd
DP		 176netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
177{
178 if (recv_ctx->sds_rings != NULL)
179 kfree(recv_ctx->sds_rings);
232e7d68
DP		 180
181 recv_ctx->sds_rings = NULL;
71dcddbd
DP		 182}
183
184static int
d8b100c5
DP		 185netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
186{
187 int ring;
188 struct nx_host_sds_ring *sds_ring;
189 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
190
71dcddbd 191 if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
f17443f4 192 return -ENOMEM;
71dcddbd 193
d8b100c5
DP		 194 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
195 sds_ring = &recv_ctx->sds_rings[ring];
196 netif_napi_add(netdev, &sds_ring->napi,
197 netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
198 }
71dcddbd
DP		 199
200 return 0;
d8b100c5
DP		 201}
202
232e7d68
DP		 203static void
204netxen_napi_del(struct netxen_adapter *adapter)
205{
206 int ring;
207 struct nx_host_sds_ring *sds_ring;
208 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
209
210 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
211 sds_ring = &recv_ctx->sds_rings[ring];
212 netif_napi_del(&sds_ring->napi);
213 }
214
215 netxen_free_sds_rings(&adapter->recv_ctx);
216}
217
d8b100c5
DP		 218static void
219netxen_napi_enable(struct netxen_adapter *adapter)
220{
221 int ring;
222 struct nx_host_sds_ring *sds_ring;
223 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
224
225 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
226 sds_ring = &recv_ctx->sds_rings[ring];
227 napi_enable(&sds_ring->napi);
228 netxen_nic_enable_int(sds_ring);
229 }
230}
231
232static void
233netxen_napi_disable(struct netxen_adapter *adapter)
234{
235 int ring;
236 struct nx_host_sds_ring *sds_ring;
237 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
238
239 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
240 sds_ring = &recv_ctx->sds_rings[ring];
be339aee 241 netxen_nic_disable_int(sds_ring);
b2af9cb0
DP		 242 napi_synchronize(&sds_ring->napi);
243 napi_disable(&sds_ring->napi);
d8b100c5
DP		 244 }
245}
246
50c643e7 247static int nx_set_dma_mask(struct netxen_adapter *adapter)
2956640d
DP		 248{
249 struct pci_dev *pdev = adapter->pdev;
1f434f63
DP		 250 uint64_t mask, cmask;
251
252 adapter->pci_using_dac = 0;
2956640d 253
6afd142f 254 mask = DMA_BIT_MASK(32);
6afd142f 255 cmask = DMA_BIT_MASK(32);
1f434f63 256
50c643e7 257 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1f434f63 258#ifndef CONFIG_IA64
6afd142f 259 mask = DMA_BIT_MASK(35);
1f434f63 260#endif
50c643e7
DP		 261 } else {
262 mask = DMA_BIT_MASK(39);
263 cmask = mask;
264 }
265
2956640d 266 if (pci_set_dma_mask(pdev, mask) == 0 &&
1f434f63 267 pci_set_consistent_dma_mask(pdev, cmask) == 0) {
2956640d
DP		 268 adapter->pci_using_dac = 1;
269 return 0;
270 }
2956640d 271
1f434f63
DP		 272 return -EIO;
273}
274
275/* Update addressable range if firmware supports it */
276static int
277nx_update_dma_mask(struct netxen_adapter *adapter)
278{
279 int change, shift, err;
50c643e7 280 uint64_t mask, old_mask, old_cmask;
1f434f63
DP		 281 struct pci_dev *pdev = adapter->pdev;
282
283 change = 0;
284
f98a9f69 285 shift = NXRD32(adapter, CRB_DMA_SHIFT);
f60f7856 286 if (shift > 32)
1f434f63
DP		 287 return 0;
288
289 if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
290 change = 1;
291 else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
292 change = 1;
293
294 if (change) {
295 old_mask = pdev->dma_mask;
50c643e7
DP		 296 old_cmask = pdev->dev.coherent_dma_mask;
297
f60f7856 298 mask = DMA_BIT_MASK(32+shift);
1f434f63
DP		 299
300 err = pci_set_dma_mask(pdev, mask);
301 if (err)
50c643e7
DP		 302 goto err_out;
303
304 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
305
306 err = pci_set_consistent_dma_mask(pdev, mask);
307 if (err)
308 goto err_out;
309 }
310 dev_info(&pdev->dev, "using %d-bit dma mask\n", 32+shift);
2956640d
DP		 311 }
312
2956640d 313 return 0;
50c643e7
DP		 314
315err_out:
316 pci_set_dma_mask(pdev, old_mask);
317 pci_set_consistent_dma_mask(pdev, old_cmask);
318 return err;
2956640d
DP		 319}
320
2956640d
DP		 321static int
322netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
323{
27c915a4 324 u32 val, timeout;
2956640d
DP		 325
326 if (first_boot == 0x55555555) {
327 /* This is the first boot after power up */
f98a9f69 328 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
27c915a4
DP		 329
330 if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
331 return 0;
2956640d
DP		 332
333 /* PCI bus master workaround */
f98a9f69 334 first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
2956640d
DP		 335 if (!(first_boot & 0x4)) {
336 first_boot |= 0x4;
f98a9f69
DP		 337 NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
338 first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
2956640d
DP		 339 }
340
341 /* This is the first boot after power up */
f98a9f69 342 first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
2956640d
DP		 343 if (first_boot != 0x80000f) {
344 /* clear the register for future unloads/loads */
f98a9f69 345 NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
27c915a4 346 return -EIO;
2956640d
DP		 347 }
348
27c915a4 349 /* Start P2 boot loader */
f98a9f69
DP		 350 val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
351 NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
27c915a4
DP		 352 timeout = 0;
353 do {
354 msleep(1);
f98a9f69 355 val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
27c915a4
DP		 356
357 if (++timeout > 5000)
358 return -EIO;
359
360 } while (val == NETXEN_BDINFO_MAGIC);
2956640d 361 }
27c915a4 362 return 0;
2956640d
DP		 363}
364
365static void netxen_set_port_mode(struct netxen_adapter *adapter)
366{
367 u32 val, data;
368
1e2d0059 369 val = adapter->ahw.board_type;
2956640d
DP		 370 if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
371 (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
372 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
373 data = NETXEN_PORT_MODE_802_3_AP;
f98a9f69 374 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
2956640d
DP		 375 } else if (port_mode == NETXEN_PORT_MODE_XG) {
376 data = NETXEN_PORT_MODE_XG;
f98a9f69 377 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
2956640d
DP		 378 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
379 data = NETXEN_PORT_MODE_AUTO_NEG_1G;
f98a9f69 380 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
2956640d
DP		 381 } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
382 data = NETXEN_PORT_MODE_AUTO_NEG_XG;
f98a9f69 383 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
2956640d
DP		 384 } else {
385 data = NETXEN_PORT_MODE_AUTO_NEG;
f98a9f69 386 NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
2956640d
DP		 387 }
388
389 if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
390 (wol_port_mode != NETXEN_PORT_MODE_XG) &&
391 (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
392 (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
393 wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
394 }
f98a9f69 395 NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
2956640d
DP		 396 }
397}
398
2956640d
DP		 399static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
400{
401 u32 control;
402 int pos;
403
404 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
405 if (pos) {
406 pci_read_config_dword(pdev, pos, &control);
407 if (enable)
408 control |= PCI_MSIX_FLAGS_ENABLE;
409 else
410 control = 0;
411 pci_write_config_dword(pdev, pos, control);
412 }
413}
414
be339aee 415static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
2956640d
DP		 416{
417 int i;
418
be339aee 419 for (i = 0; i < count; i++)
2956640d
DP		 420 adapter->msix_entries[i].entry = i;
421}
422
9dc28efe
DP		 423static int
424netxen_read_mac_addr(struct netxen_adapter *adapter)
425{
426 int i;
427 unsigned char *p;
428 __le64 mac_addr;
9dc28efe
DP		 429 struct net_device *netdev = adapter->netdev;
430 struct pci_dev *pdev = adapter->pdev;
431
9dc28efe
DP		 432 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
433 if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
434 return -EIO;
435 } else {
436 if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
437 return -EIO;
438 }
439
440 p = (unsigned char *)&mac_addr;
441 for (i = 0; i < 6; i++)
442 netdev->dev_addr[i] = *(p + 5 - i);
443
444 memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
445
446 /* set station address */
447
e174961c
JB		 448 if (!is_valid_ether_addr(netdev->perm_addr))
449 dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
9dc28efe
DP		 450
451 return 0;
452}
453
3d0a3cc9
DP		 454int netxen_nic_set_mac(struct net_device *netdev, void *p)
455{
456 struct netxen_adapter *adapter = netdev_priv(netdev);
457 struct sockaddr *addr = p;
458
459 if (!is_valid_ether_addr(addr->sa_data))
460 return -EINVAL;
461
462 if (netif_running(netdev)) {
463 netif_device_detach(netdev);
464 netxen_napi_disable(adapter);
465 }
466
467 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
468 adapter->macaddr_set(adapter, addr->sa_data);
469
470 if (netif_running(netdev)) {
471 netif_device_attach(netdev);
472 netxen_napi_enable(adapter);
473 }
474 return 0;
475}
476
1abd266f
SH		 477static void netxen_set_multicast_list(struct net_device *dev)
478{
479 struct netxen_adapter *adapter = netdev_priv(dev);
480
3d0a3cc9 481 adapter->set_multi(dev);
1abd266f
SH		 482}
483
484static const struct net_device_ops netxen_netdev_ops = {
485 .ndo_open = netxen_nic_open,
486 .ndo_stop = netxen_nic_close,
487 .ndo_start_xmit = netxen_nic_xmit_frame,
488 .ndo_get_stats = netxen_nic_get_stats,
489 .ndo_validate_addr = eth_validate_addr,
490 .ndo_set_multicast_list = netxen_set_multicast_list,
491 .ndo_set_mac_address = netxen_nic_set_mac,
492 .ndo_change_mtu = netxen_nic_change_mtu,
493 .ndo_tx_timeout = netxen_tx_timeout,
494#ifdef CONFIG_NET_POLL_CONTROLLER
495 .ndo_poll_controller = netxen_nic_poll_controller,
496#endif
497};
498
97daee83
DP		 499static void
500netxen_setup_intr(struct netxen_adapter *adapter)
501{
502 struct netxen_legacy_intr_set *legacy_intrp;
503 struct pci_dev *pdev = adapter->pdev;
be339aee
DP		 504 int err, num_msix;
505
506 if (adapter->rss_supported) {
507 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
508 MSIX_ENTRIES_PER_ADAPTER : 2;
509 } else
510 num_msix = 1;
511
512 adapter->max_sds_rings = 1;
97daee83
DP		 513
514 adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
97daee83
DP		 515
516 if (adapter->ahw.revision_id >= NX_P3_B0)
517 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
518 else
519 legacy_intrp = &legacy_intr[0];
195c5f98
AKS		 520
521 adapter->int_vec_bit = legacy_intrp->int_vec_bit;
522 adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
523 legacy_intrp->tgt_status_reg);
524 adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
525 legacy_intrp->tgt_mask_reg);
526 adapter->pci_int_reg = netxen_get_ioaddr(adapter,
527 legacy_intrp->pci_int_reg);
528 adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
529
530 if (adapter->ahw.revision_id >= NX_P3_B1)
531 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
532 ISR_INT_STATE_REG);
533 else
534 adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
535 CRB_INT_VECTOR);
97daee83
DP		 536
537 netxen_set_msix_bit(pdev, 0);
538
539 if (adapter->msix_supported) {
540
be339aee
DP		 541 netxen_init_msix_entries(adapter, num_msix);
542 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
543 if (err == 0) {
544 adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
545 netxen_set_msix_bit(pdev, 1);
97daee83 546
be339aee
DP		 547 if (adapter->rss_supported)
548 adapter->max_sds_rings = num_msix;
97daee83 549
be339aee
DP		 550 dev_info(&pdev->dev, "using msi-x interrupts\n");
551 return;
552 }
553
554 if (err > 0)
555 pci_disable_msix(pdev);
556
557 /* fall through for msi */
97daee83 558 }
be339aee
DP		 559
560 if (use_msi && !pci_enable_msi(pdev)) {
561 adapter->flags |= NETXEN_NIC_MSI_ENABLED;
195c5f98
AKS		 562 adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
563 msi_tgt_status[adapter->ahw.pci_func]);
be339aee 564 dev_info(&pdev->dev, "using msi interrupts\n");
f67f3408 565 adapter->msix_entries[0].vector = pdev->irq;
be339aee
DP		 566 return;
567 }
568
569 dev_info(&pdev->dev, "using legacy interrupts\n");
570 adapter->msix_entries[0].vector = pdev->irq;
97daee83
DP		 571}
572
573static void
574netxen_teardown_intr(struct netxen_adapter *adapter)
575{
576 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
577 pci_disable_msix(adapter->pdev);
578 if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
579 pci_disable_msi(adapter->pdev);
580}
581
582static void
583netxen_cleanup_pci_map(struct netxen_adapter *adapter)
584{
585 if (adapter->ahw.db_base != NULL)
586 iounmap(adapter->ahw.db_base);
587 if (adapter->ahw.pci_base0 != NULL)
588 iounmap(adapter->ahw.pci_base0);
589 if (adapter->ahw.pci_base1 != NULL)
590 iounmap(adapter->ahw.pci_base1);
591 if (adapter->ahw.pci_base2 != NULL)
592 iounmap(adapter->ahw.pci_base2);
593}
594
595static int
596netxen_setup_pci_map(struct netxen_adapter *adapter)
597{
598 void __iomem *mem_ptr0 = NULL;
599 void __iomem *mem_ptr1 = NULL;
600 void __iomem *mem_ptr2 = NULL;
601 void __iomem *db_ptr = NULL;
602
97daee83
DP		 603 unsigned long mem_base, mem_len, db_base, db_len = 0, pci_len0 = 0;
604
605 struct pci_dev *pdev = adapter->pdev;
606 int pci_func = adapter->ahw.pci_func;
607
608 int err = 0;
609
610 /*
611 * Set the CRB window to invalid. If any register in window 0 is
612 * accessed it should set the window to 0 and then reset it to 1.
613 */
614 adapter->curr_window = 255;
615 adapter->ahw.qdr_sn_window = -1;
616 adapter->ahw.ddr_mn_window = -1;
617
618 /* remap phys address */
619 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
620 mem_len = pci_resource_len(pdev, 0);
621 pci_len0 = 0;
622
97daee83
DP		 623 /* 128 Meg of memory */
624 if (mem_len == NETXEN_PCI_128MB_SIZE) {
625 mem_ptr0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
626 mem_ptr1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
627 SECOND_PAGE_GROUP_SIZE);
628 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
629 THIRD_PAGE_GROUP_SIZE);
97daee83
DP		 630 } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
631 mem_ptr1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
632 mem_ptr2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
633 SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
97daee83 634 } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
97daee83
DP		 635
636 mem_ptr0 = pci_ioremap_bar(pdev, 0);
637 if (mem_ptr0 == NULL) {
638 dev_err(&pdev->dev, "failed to map PCI bar 0\n");
639 return -EIO;
640 }
641 pci_len0 = mem_len;
97daee83
DP		 642
643 adapter->ahw.ddr_mn_window = 0;
644 adapter->ahw.qdr_sn_window = 0;
645
646 adapter->ahw.mn_win_crb = 0x100000 + PCIX_MN_WINDOW +
647 (pci_func * 0x20);
648 adapter->ahw.ms_win_crb = 0x100000 + PCIX_SN_WINDOW;
649 if (pci_func < 4)
650 adapter->ahw.ms_win_crb += (pci_func * 0x20);
651 else
652 adapter->ahw.ms_win_crb +=
653 0xA0 + ((pci_func - 4) * 0x10);
654 } else {
655 return -EIO;
656 }
657
195c5f98
AKS		 658 netxen_setup_hwops(adapter);
659
97daee83
DP		 660 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
661
662 adapter->ahw.pci_base0 = mem_ptr0;
663 adapter->ahw.pci_len0 = pci_len0;
97daee83
DP		 664 adapter->ahw.pci_base1 = mem_ptr1;
665 adapter->ahw.pci_base2 = mem_ptr2;
666
667 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
668 goto skip_doorbell;
669
670 db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */
671 db_len = pci_resource_len(pdev, 4);
672
673 if (db_len == 0) {
674 printk(KERN_ERR "%s: doorbell is disabled\n",
675 netxen_nic_driver_name);
676 err = -EIO;
677 goto err_out;
678 }
679
680 db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
681 if (!db_ptr) {
682 printk(KERN_ERR "%s: Failed to allocate doorbell map.",
683 netxen_nic_driver_name);
684 err = -EIO;
685 goto err_out;
686 }
687
688skip_doorbell:
689 adapter->ahw.db_base = db_ptr;
690 adapter->ahw.db_len = db_len;
691 return 0;
692
693err_out:
694 netxen_cleanup_pci_map(adapter);
695 return err;
696}
697
2b9e62ee
DP		 698static void
699netxen_check_options(struct netxen_adapter *adapter)
700{
701 u32 fw_major, fw_minor, fw_build;
702 char brd_name[NETXEN_MAX_SHORT_NAME];
703 char serial_num[32];
704 int i, offset, val;
705 int *ptr32;
706 struct pci_dev *pdev = adapter->pdev;
707
708 adapter->driver_mismatch = 0;
709
710 ptr32 = (int *)&serial_num;
711 offset = NX_FW_SERIAL_NUM_OFFSET;
712 for (i = 0; i < 8; i++) {
713 if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
714 dev_err(&pdev->dev, "error reading board info\n");
715 adapter->driver_mismatch = 1;
716 return;
717 }
718 ptr32[i] = cpu_to_le32(val);
719 offset += sizeof(u32);
720 }
721
722 fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
723 fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
724 fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
725
726 adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
727
728 if (adapter->portnum == 0) {
729 get_brd_name_by_type(adapter->ahw.board_type, brd_name);
730
731 printk(KERN_INFO "NetXen %s Board S/N %s Chip rev 0x%x\n",
732 brd_name, serial_num, adapter->ahw.revision_id);
733 }
734
735 if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
736 adapter->driver_mismatch = 1;
737 dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
738 fw_major, fw_minor, fw_build);
739 return;
740 }
741
742 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
743 i = NXRD32(adapter, NETXEN_SRE_MISC);
744 adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
745 }
746
747 dev_info(&pdev->dev, "firmware v%d.%d.%d [%s]\n",
748 fw_major, fw_minor, fw_build,
749 adapter->ahw.cut_through ? "cut-through" : "legacy");
750
751 if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
752 adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
753
754 adapter->flags &= ~NETXEN_NIC_LRO_ENABLED;
755
756 if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
757 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
758 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
759 } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
760 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
761 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
762 }
763
764 adapter->msix_supported = 0;
765 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
766 adapter->msix_supported = !!use_msi_x;
767 adapter->rss_supported = !!use_msi_x;
768 } else if (adapter->fw_version >= NETXEN_VERSION_CODE(3, 4, 336)) {
769 switch (adapter->ahw.board_type) {
770 case NETXEN_BRDTYPE_P2_SB31_10G:
771 case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
772 adapter->msix_supported = !!use_msi_x;
773 adapter->rss_supported = !!use_msi_x;
774 break;
775 default:
776 break;
777 }
778 }
779
780 adapter->num_txd = MAX_CMD_DESCRIPTORS;
781
782 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
783 adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
784 adapter->max_rds_rings = 3;
785 } else {
786 adapter->num_lro_rxd = 0;
787 adapter->max_rds_rings = 2;
788 }
789}
790
ba599d4f 791static int
6a581e93 792netxen_start_firmware(struct netxen_adapter *adapter)
ba599d4f
DP		 793{
794 int val, err, first_boot;
795 struct pci_dev *pdev = adapter->pdev;
796
2b9e62ee
DP		 797 /* required for NX2031 dummy dma */
798 err = nx_set_dma_mask(adapter);
799 if (err)
800 return err;
801
6a581e93 802 if (!netxen_can_start_firmware(adapter))
96f2ebd2 803 goto wait_init;
0b72e659 804
f98a9f69 805 first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
ba599d4f
DP		 806
807 err = netxen_check_hw_init(adapter, first_boot);
808 if (err) {
809 dev_err(&pdev->dev, "error in init HW init sequence\n");
810 return err;
811 }
812
6a581e93 813 netxen_request_firmware(adapter);
f7185c71 814
67c38fc6 815 err = netxen_need_fw_reset(adapter);
1dbc84a7 816 if (err < 0)
db4cfd8a 817 goto err_out;
1dbc84a7
DP		 818 if (err == 0)
819 goto wait_init;
67c38fc6 820
ba599d4f 821 if (first_boot != 0x55555555) {
f98a9f69 822 NXWR32(adapter, CRB_CMDPEG_STATE, 0);
ba599d4f
DP		 823 netxen_pinit_from_rom(adapter, 0);
824 msleep(1);
825 }
567c6c4e 826
f98a9f69 827 NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
6a581e93
DP		 828 NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
829 NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
830
567c6c4e
DP		 831 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
832 netxen_set_port_mode(adapter);
833
db4cfd8a
DP		 834 err = netxen_load_firmware(adapter);
835 if (err)
836 goto err_out;
ba599d4f 837
6a581e93
DP		 838 netxen_release_firmware(adapter);
839
ba599d4f
DP		 840 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
841
842 /* Initialize multicast addr pool owners */
843 val = 0x7654;
1e2d0059 844 if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
ba599d4f 845 val |= 0x0f000000;
f98a9f69 846 NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
ba599d4f
DP		 847
848 }
849
83ac51fa 850 err = netxen_init_dummy_dma(adapter);
ba599d4f 851 if (err)
db4cfd8a 852 goto err_out;
ba599d4f
DP		 853
854 /*
855 * Tell the hardware our version number.
856 */
857 val = (_NETXEN_NIC_LINUX_MAJOR << 16)
858 | ((_NETXEN_NIC_LINUX_MINOR << 8))
859 | (_NETXEN_NIC_LINUX_SUBVERSION);
f98a9f69 860 NXWR32(adapter, CRB_DRIVER_VERSION, val);
ba599d4f 861
6a581e93
DP		 862 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
863
96f2ebd2 864wait_init:
ba599d4f
DP		 865 /* Handshake with the card before we register the devices. */
866 err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
867 if (err) {
83ac51fa 868 netxen_free_dummy_dma(adapter);
db4cfd8a 869 goto err_out;
ba599d4f
DP		 870 }
871
68b3cae0
DP		 872 nx_update_dma_mask(adapter);
873
6a581e93 874 netxen_check_options(adapter);
68b3cae0 875
ba599d4f 876 return 0;
db4cfd8a
DP		 877
878err_out:
879 netxen_release_firmware(adapter);
880 return err;
ba599d4f
DP		 881}
882
9f5bc7f1
DP		 883static int
884netxen_nic_request_irq(struct netxen_adapter *adapter)
885{
886 irq_handler_t handler;
d8b100c5
DP		 887 struct nx_host_sds_ring *sds_ring;
888 int err, ring;
889
9f5bc7f1
DP		 890 unsigned long flags = IRQF_SAMPLE_RANDOM;
891 struct net_device *netdev = adapter->netdev;
d8b100c5 892 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
9f5bc7f1 893
9f5bc7f1
DP		 894 if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
895 handler = netxen_msix_intr;
896 else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
897 handler = netxen_msi_intr;
898 else {
899 flags |= IRQF_SHARED;
900 handler = netxen_intr;
901 }
902 adapter->irq = netdev->irq;
903
d8b100c5
DP		 904 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
905 sds_ring = &recv_ctx->sds_rings[ring];
be339aee 906 sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
d8b100c5
DP		 907 err = request_irq(sds_ring->irq, handler,
908 flags, sds_ring->name, sds_ring);
909 if (err)
910 return err;
911 }
912
913 return 0;
914}
915
916static void
917netxen_nic_free_irq(struct netxen_adapter *adapter)
918{
919 int ring;
920 struct nx_host_sds_ring *sds_ring;
921
922 struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
923
924 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
925 sds_ring = &recv_ctx->sds_rings[ring];
926 free_irq(sds_ring->irq, sds_ring);
927 }
9f5bc7f1
DP		 928}
929
ca2ef330
DP		 930static void
931netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
932{
933 adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
934 adapter->coal.normal.data.rx_time_us =
935 NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
936 adapter->coal.normal.data.rx_packets =
937 NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
938 adapter->coal.normal.data.tx_time_us =
939 NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
940 adapter->coal.normal.data.tx_packets =
941 NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
942}
943
9f5bc7f1
DP		 944static int
945netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
946{
947 int err;
948
db4cfd8a
DP		 949 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
950 return -EIO;
951
9f5bc7f1
DP		 952 err = adapter->init_port(adapter, adapter->physical_port);
953 if (err) {
954 printk(KERN_ERR "%s: Failed to initialize port %d\n",
955 netxen_nic_driver_name, adapter->portnum);
956 return err;
957 }
3d0a3cc9
DP		 958 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
959 adapter->macaddr_set(adapter, netdev->dev_addr);
9f5bc7f1 960
3d0a3cc9
DP		 961 adapter->set_multi(netdev);
962 adapter->set_mtu(adapter, netdev->mtu);
9f5bc7f1
DP		 963
964 adapter->ahw.linkup = 0;
9f5bc7f1 965
d8b100c5
DP		 966 if (adapter->max_sds_rings > 1)
967 netxen_config_rss(adapter, 1);
9f5bc7f1 968
ca2ef330
DP		 969 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
970 netxen_config_intr_coalesce(adapter);
971
1bb482f8
NK		 972 if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
973 netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_ENABLED);
974
b2af9cb0
DP		 975 netxen_napi_enable(adapter);
976
5103c9f7 977 if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
3bf26ce3 978 netxen_linkevent_request(adapter, 1);
3d0a3cc9
DP		 979 else
980 netxen_nic_set_link_parameters(adapter);
981
6a581e93 982 set_bit(__NX_DEV_UP, &adapter->state);
9f5bc7f1
DP		 983 return 0;
984}
985
986static void
987netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
988{
db4cfd8a
DP		 989 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
990 return;
991
6a581e93
DP		 992 clear_bit(__NX_DEV_UP, &adapter->state);
993
b2af9cb0 994 spin_lock(&adapter->tx_clean_lock);
9f5bc7f1 995 netif_carrier_off(netdev);
b2af9cb0 996 netif_tx_disable(netdev);
9f5bc7f1
DP		 997
998 if (adapter->stop_port)
999 adapter->stop_port(adapter);
1000
5cf4d323
DP		 1001 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1002 netxen_p3_free_mac_list(adapter);
1003
22b5794b
AKS		 1004 adapter->set_promisc(adapter, NETXEN_NIU_NON_PROMISC_MODE);
1005
be339aee
DP		 1006 netxen_napi_disable(adapter);
1007
9f5bc7f1 1008 netxen_release_tx_buffers(adapter);
b2af9cb0 1009 spin_unlock(&adapter->tx_clean_lock);
9f5bc7f1
DP		 1010}
1011
1012
1013static int
1014netxen_nic_attach(struct netxen_adapter *adapter)
1015{
1016 struct net_device *netdev = adapter->netdev;
1017 struct pci_dev *pdev = adapter->pdev;
becf46a0 1018 int err, ring;
d8b100c5 1019 struct nx_host_rds_ring *rds_ring;
d877f1e3 1020 struct nx_host_tx_ring *tx_ring;
9f5bc7f1 1021
7042cd8f
AKS		 1022 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
1023 return 0;
1024
9f5bc7f1 1025 err = netxen_init_firmware(adapter);
232e7d68
DP		 1026 if (err)
1027 return err;
1028
1029 err = netxen_napi_add(adapter, netdev);
1030 if (err)
1031 return err;
9f5bc7f1 1032
9f5bc7f1
DP		 1033 err = netxen_alloc_sw_resources(adapter);
1034 if (err) {
1035 printk(KERN_ERR "%s: Error in setting sw resources\n",
1036 netdev->name);
1037 return err;
1038 }
1039
9f5bc7f1
DP		 1040 err = netxen_alloc_hw_resources(adapter);
1041 if (err) {
1042 printk(KERN_ERR "%s: Error in setting hw resources\n",
1043 netdev->name);
1044 goto err_out_free_sw;
1045 }
1046
4f96b988 1047 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
4ea528a1 1048 tx_ring = adapter->tx_ring;
195c5f98
AKS		 1049 tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
1050 crb_cmd_producer[adapter->portnum]);
1051 tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
1052 crb_cmd_consumer[adapter->portnum]);
9f5bc7f1 1053
cb2107be
DP		 1054 tx_ring->producer = 0;
1055 tx_ring->sw_consumer = 0;
1056
1057 netxen_nic_update_cmd_producer(adapter, tx_ring);
1058 netxen_nic_update_cmd_consumer(adapter, tx_ring);
9f5bc7f1
DP		 1059 }
1060
d8b100c5
DP		 1061 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1062 rds_ring = &adapter->recv_ctx.rds_rings[ring];
1063 netxen_post_rx_buffers(adapter, ring, rds_ring);
1064 }
9f5bc7f1
DP		 1065
1066 err = netxen_nic_request_irq(adapter);
1067 if (err) {
1068 dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
1069 netdev->name);
1070 goto err_out_free_rxbuf;
1071 }
1072
ca2ef330
DP		 1073 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1074 netxen_nic_init_coalesce_defaults(adapter);
1075
fa3ce355
NK		 1076 netxen_create_sysfs_entries(adapter);
1077
9f5bc7f1
DP		 1078 adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
1079 return 0;
1080
1081err_out_free_rxbuf:
1082 netxen_release_rx_buffers(adapter);
1083 netxen_free_hw_resources(adapter);
1084err_out_free_sw:
1085 netxen_free_sw_resources(adapter);
1086 return err;
1087}
1088
1089static void
1090netxen_nic_detach(struct netxen_adapter *adapter)
1091{
7042cd8f
AKS		 1092 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1093 return;
1094
fa3ce355
NK		 1095 netxen_remove_sysfs_entries(adapter);
1096
9f5bc7f1 1097 netxen_free_hw_resources(adapter);
cf981ffb 1098 netxen_release_rx_buffers(adapter);
be339aee 1099 netxen_nic_free_irq(adapter);
232e7d68 1100 netxen_napi_del(adapter);
9f5bc7f1
DP		 1101 netxen_free_sw_resources(adapter);
1102
1103 adapter->is_up = 0;
1104}
1105
7042cd8f
AKS		 1106int
1107netxen_nic_reset_context(struct netxen_adapter *adapter)
1108{
1109 int err = 0;
1110 struct net_device *netdev = adapter->netdev;
1111
6a581e93
DP		 1112 if (test_and_set_bit(__NX_RESETTING, &adapter->state))
1113 return -EBUSY;
1114
7042cd8f
AKS		 1115 if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
1116
6a581e93
DP		 1117 netif_device_detach(netdev);
1118
7042cd8f
AKS		 1119 if (netif_running(netdev))
1120 netxen_nic_down(adapter, netdev);
1121
1122 netxen_nic_detach(adapter);
1123
6a581e93
DP		 1124 if (netif_running(netdev)) {
1125 err = netxen_nic_attach(adapter);
1126 if (!err)
1127 err = netxen_nic_up(adapter, netdev);
7042cd8f 1128
6a581e93
DP		 1129 if (err)
1130 goto done;
1131 }
1132
1133 netif_device_attach(netdev);
7042cd8f 1134 }
6a581e93 1135
7042cd8f 1136done:
6a581e93 1137 clear_bit(__NX_RESETTING, &adapter->state);
7042cd8f
AKS		 1138 return err;
1139}
1140
f17443f4
DP		 1141static int
1142netxen_setup_netdev(struct netxen_adapter *adapter,
1143 struct net_device *netdev)
1144{
1145 int err = 0;
1146 struct pci_dev *pdev = adapter->pdev;
1147
1148 adapter->rx_csum = 1;
1149 adapter->mc_enabled = 0;
1150 if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1151 adapter->max_mc_count = 38;
1152 else
1153 adapter->max_mc_count = 16;
1154
1155 netdev->netdev_ops = &netxen_netdev_ops;
1156 netdev->watchdog_timeo = 2*HZ;
1157
1158 netxen_nic_change_mtu(netdev, netdev->mtu);
1159
1160 SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
1161
1162 netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
1163 netdev->features |= (NETIF_F_GRO);
1164 netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
1165
1166 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
1167 netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
1168 netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
1169 }
1170
1171 if (adapter->pci_using_dac) {
1172 netdev->features |= NETIF_F_HIGHDMA;
1173 netdev->vlan_features |= NETIF_F_HIGHDMA;
1174 }
1175
028afe71
DP		 1176 if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
1177 netdev->features |= (NETIF_F_HW_VLAN_TX);
1178
1bb482f8
NK		 1179 if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
1180 netdev->features |= NETIF_F_LRO;
1181
f17443f4
DP		 1182 netdev->irq = adapter->msix_entries[0].vector;
1183
f17443f4
DP		 1184 INIT_WORK(&adapter->tx_timeout_task, netxen_reset_task);
1185
1186 if (netxen_read_mac_addr(adapter))
1187 dev_warn(&pdev->dev, "failed to read mac addr\n");
1188
1189 netif_carrier_off(netdev);
1190 netif_stop_queue(netdev);
1191
1192 err = register_netdev(netdev);
1193 if (err) {
1194 dev_err(&pdev->dev, "failed to register net device\n");
1195 return err;
1196 }
1197
1198 return 0;
1199}
1200
3d396eb1
AK		 1201static int __devinit
1202netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1203{
1204 struct net_device *netdev = NULL;
1205 struct netxen_adapter *adapter = NULL;
2956640d 1206 int i = 0, err;
3176ff3e 1207 int pci_func_id = PCI_FUNC(pdev->devfn);
2956640d 1208 uint8_t revision_id;
3d396eb1 1209
3176ff3e 1210 if (pdev->class != 0x020000) {
dcd56fdb 1211 printk(KERN_DEBUG "NetXen function %d, class %x will not "
3176ff3e 1212 "be enabled.\n",pci_func_id, pdev->class);
ed25ffa1
AK		 1213 return -ENODEV;
1214 }
2956640d 1215
11d89d63
DP		 1216 if (pdev->revision >= NX_P3_A0 && pdev->revision < NX_P3_B1) {
1217 printk(KERN_WARNING "NetXen chip revisions between 0x%x-0x%x"
1218 "will not be enabled.\n",
1219 NX_P3_A0, NX_P3_B1);
1220 return -ENODEV;
1221 }
1222
3d396eb1
AK		 1223 if ((err = pci_enable_device(pdev)))
1224 return err;
2956640d 1225
3d396eb1
AK		 1226 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1227 err = -ENODEV;
1228 goto err_out_disable_pdev;
1229 }
1230
1231 if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
1232 goto err_out_disable_pdev;
1233
1234 pci_set_master(pdev);
3176ff3e
MT		 1235
1236 netdev = alloc_etherdev(sizeof(struct netxen_adapter));
1237 if(!netdev) {
f17443f4
DP		 1238 dev_err(&pdev->dev, "failed to allocate net_device\n");
1239 err = -ENOMEM;
3176ff3e
MT		 1240 goto err_out_free_res;
1241 }
1242
3176ff3e
MT		 1243 SET_NETDEV_DEV(netdev, &pdev->dev);
1244
4cf1653a 1245 adapter = netdev_priv(netdev);
2956640d
DP		 1246 adapter->netdev = netdev;
1247 adapter->pdev = pdev;
13ba9c77 1248 adapter->ahw.pci_func = pci_func_id;
2956640d
DP		 1249
1250 revision_id = pdev->revision;
1251 adapter->ahw.revision_id = revision_id;
1252
3ce06a32 1253 rwlock_init(&adapter->adapter_lock);
d8b100c5 1254 spin_lock_init(&adapter->tx_clean_lock);
5cf4d323 1255 INIT_LIST_HEAD(&adapter->mac_list);
3ce06a32 1256
97daee83
DP		 1257 err = netxen_setup_pci_map(adapter);
1258 if (err)
6c80b18d 1259 goto err_out_free_netdev;
3d396eb1 1260
2d1a3bbd 1261 /* This will be reset for mezz cards */
3176ff3e 1262 adapter->portnum = pci_func_id;
3176ff3e 1263
f17443f4
DP		 1264 err = netxen_nic_get_board_info(adapter);
1265 if (err) {
1266 dev_err(&pdev->dev, "Error getting board config info.\n");
dcd56fdb
DP		 1267 goto err_out_iounmap;
1268 }
6c80b18d 1269
13ba9c77 1270 /* Mezz cards have PCI function 0,2,3 enabled */
1e2d0059 1271 switch (adapter->ahw.board_type) {
dc515f2e
DP		 1272 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
1273 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
1274 if (pci_func_id >= 2)
13ba9c77 1275 adapter->portnum = pci_func_id - 2;
dc515f2e
DP		 1276 break;
1277 default:
1278 break;
1279 }
13ba9c77 1280
6a581e93 1281 err = netxen_start_firmware(adapter);
0b72e659
DP		 1282 if (err)
1283 goto err_out_iounmap;
f17443f4 1284
3d396eb1 1285 /*
6c80b18d 1286 * See if the firmware gave us a virtual-physical port mapping.
3d396eb1 1287 */
dcd56fdb 1288 adapter->physical_port = adapter->portnum;
4f96b988 1289 if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
f98a9f69 1290 i = NXRD32(adapter, CRB_V2P(adapter->portnum));
044fad0d
DP		 1291 if (i != 0x55555555)
1292 adapter->physical_port = i;
1293 }
6c80b18d 1294
6a581e93 1295 netxen_nic_clear_stats(adapter);
2956640d 1296
97daee83 1297 netxen_setup_intr(adapter);
2956640d 1298
f17443f4 1299 err = netxen_setup_netdev(adapter, netdev);
9dc28efe 1300 if (err)
2956640d 1301 goto err_out_disable_msi;
6c80b18d
MT		 1302
1303 pci_set_drvdata(pdev, adapter);
3d396eb1 1304
6a581e93
DP		 1305 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1306
1e2d0059 1307 switch (adapter->ahw.port_type) {
2956640d
DP		 1308 case NETXEN_NIC_GBE:
1309 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1310 adapter->netdev->name);
1311 break;
1312 case NETXEN_NIC_XGBE:
1313 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1314 adapter->netdev->name);
1315 break;
3d396eb1 1316 }
3d396eb1 1317
2956640d
DP		 1318 return 0;
1319
1320err_out_disable_msi:
97daee83 1321 netxen_teardown_intr(adapter);
6c80b18d 1322
83ac51fa 1323 netxen_free_dummy_dma(adapter);
3d396eb1 1324
6a581e93
DP		 1325 nx_decr_dev_ref_cnt(adapter);
1326
2956640d 1327err_out_iounmap:
97daee83 1328 netxen_cleanup_pci_map(adapter);
cb8011ad 1329
6c80b18d
MT		 1330err_out_free_netdev:
1331 free_netdev(netdev);
1332
1333err_out_free_res:
3d396eb1 1334 pci_release_regions(pdev);
6c80b18d
MT		 1335
1336err_out_disable_pdev:
2956640d 1337 pci_set_drvdata(pdev, NULL);
3d396eb1
AK		 1338 pci_disable_device(pdev);
1339 return err;
1340}
1341
1342static void __devexit netxen_nic_remove(struct pci_dev *pdev)
1343{
1344 struct netxen_adapter *adapter;
3176ff3e 1345 struct net_device *netdev;
3d396eb1 1346
6c80b18d 1347 adapter = pci_get_drvdata(pdev);
3d396eb1
AK		 1348 if (adapter == NULL)
1349 return;
1350
6c80b18d
MT		 1351 netdev = adapter->netdev;
1352
6a581e93
DP		 1353 netxen_cancel_fw_work(adapter);
1354
96acb6eb
DP		 1355 unregister_netdev(netdev);
1356
e424fa9d
AKS		 1357 cancel_work_sync(&adapter->tx_timeout_task);
1358
7042cd8f 1359 netxen_nic_detach(adapter);
3d396eb1 1360
6a581e93
DP		 1361 nx_decr_dev_ref_cnt(adapter);
1362
439b454e 1363 if (adapter->portnum == 0)
83ac51fa 1364 netxen_free_dummy_dma(adapter);
96acb6eb 1365
6a581e93
DP		 1366 clear_bit(__NX_RESETTING, &adapter->state);
1367
97daee83 1368 netxen_teardown_intr(adapter);
3052246c 1369
97daee83 1370 netxen_cleanup_pci_map(adapter);
595e3fb8 1371
f7185c71
DP		 1372 netxen_release_firmware(adapter);
1373
595e3fb8 1374 pci_release_regions(pdev);
3052246c 1375 pci_disable_device(pdev);
595e3fb8
MT		 1376 pci_set_drvdata(pdev, NULL);
1377
6c80b18d 1378 free_netdev(netdev);
3d396eb1 1379}
22b5794b 1380static int __netxen_nic_shutdown(struct pci_dev *pdev)
0b72e659 1381{
0b72e659
DP		 1382 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1383 struct net_device *netdev = adapter->netdev;
22b5794b 1384 int retval;
0b72e659
DP		 1385
1386 netif_device_detach(netdev);
1387
6a581e93
DP		 1388 netxen_cancel_fw_work(adapter);
1389
0b72e659
DP		 1390 if (netif_running(netdev))
1391 netxen_nic_down(adapter, netdev);
1392
e424fa9d
AKS		 1393 cancel_work_sync(&adapter->tx_timeout_task);
1394
7042cd8f 1395 netxen_nic_detach(adapter);
0b72e659 1396
22b5794b
AKS		 1397 if (adapter->portnum == 0)
1398 netxen_free_dummy_dma(adapter);
1399
6a581e93
DP		 1400 nx_decr_dev_ref_cnt(adapter);
1401
1402 clear_bit(__NX_RESETTING, &adapter->state);
1403
22b5794b
AKS		 1404 retval = pci_save_state(pdev);
1405 if (retval)
1406 return retval;
0b72e659
DP		 1407
1408 if (netxen_nic_wol_supported(adapter)) {
1409 pci_enable_wake(pdev, PCI_D3cold, 1);
1410 pci_enable_wake(pdev, PCI_D3hot, 1);
1411 }
1412
1413 pci_disable_device(pdev);
0b72e659
DP		 1414
1415 return 0;
1416}
22b5794b
AKS		 1417static void netxen_nic_shutdown(struct pci_dev *pdev)
1418{
1419 if (__netxen_nic_shutdown(pdev))
1420 return;
1421}
1422#ifdef CONFIG_PM
1423static int
1424netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
1425{
1426 int retval;
1427
1428 retval = __netxen_nic_shutdown(pdev);
1429 if (retval)
1430 return retval;
1431
1432 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1433 return 0;
1434}
0b72e659
DP		 1435
1436static int
1437netxen_nic_resume(struct pci_dev *pdev)
1438{
1439 struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1440 struct net_device *netdev = adapter->netdev;
1441 int err;
1442
1443 pci_set_power_state(pdev, PCI_D0);
1444 pci_restore_state(pdev);
1445
1446 err = pci_enable_device(pdev);
1447 if (err)
1448 return err;
1449
1450 adapter->curr_window = 255;
1451
6a581e93 1452 err = netxen_start_firmware(adapter);
0b72e659
DP		 1453 if (err) {
1454 dev_err(&pdev->dev, "failed to start firmware\n");
1455 return err;
1456 }
1457
1458 if (netif_running(netdev)) {
1459 err = netxen_nic_attach(adapter);
1460 if (err)
6a581e93 1461 goto err_out;
0b72e659
DP		 1462
1463 err = netxen_nic_up(adapter, netdev);
1464 if (err)
6a581e93 1465 goto err_out_detach;
0b72e659
DP		 1466
1467 netif_device_attach(netdev);
d0725e4d
AKS		 1468
1469 netxen_config_indev_addr(netdev, NETDEV_UP);
0b72e659
DP		 1470 }
1471
6a581e93
DP		 1472 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1473
1474err_out_detach:
1475 netxen_nic_detach(adapter);
1476err_out:
1477 nx_decr_dev_ref_cnt(adapter);
1478 return err;
0b72e659 1479}
01542cd1 1480#endif
0b72e659 1481
3d396eb1
AK		 1482static int netxen_nic_open(struct net_device *netdev)
1483{
4cf1653a 1484 struct netxen_adapter *adapter = netdev_priv(netdev);
3d396eb1 1485 int err = 0;
3d396eb1 1486
dcd56fdb
DP		 1487 if (adapter->driver_mismatch)
1488 return -EIO;
1489
7042cd8f
AKS		 1490 err = netxen_nic_attach(adapter);
1491 if (err)
1492 return err;
2956640d 1493
9f5bc7f1
DP		 1494 err = netxen_nic_up(adapter, netdev);
1495 if (err)
1496 goto err_out;
05aaa02d 1497
dcd56fdb 1498 netif_start_queue(netdev);
3d396eb1
AK		 1499
1500 return 0;
2956640d 1501
9f5bc7f1
DP		 1502err_out:
1503 netxen_nic_detach(adapter);
2956640d 1504 return err;
3d396eb1
AK		 1505}
1506
1507/*
1508 * netxen_nic_close - Disables a network interface entry point
1509 */
1510static int netxen_nic_close(struct net_device *netdev)
1511{
3176ff3e 1512 struct netxen_adapter *adapter = netdev_priv(netdev);
3d396eb1 1513
9f5bc7f1 1514 netxen_nic_down(adapter, netdev);
3d396eb1
AK		 1515 return 0;
1516}
1517
1bcfd790
DP		 1518static void
1519netxen_tso_check(struct net_device *netdev,
1520 struct nx_host_tx_ring *tx_ring,
1521 struct cmd_desc_type0 *first_desc,
1522 struct sk_buff *skb)
cd1f8160 1523{
391587c3 1524 u8 opcode = TX_ETHER_PKT;
cdff1036 1525 __be16 protocol = skb->protocol;
028afe71 1526 u16 flags = 0, vid = 0;
1bcfd790 1527 u32 producer;
028afe71 1528 int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
1bcfd790 1529 struct cmd_desc_type0 *hwdesc;
028afe71 1530 struct vlan_ethhdr *vh;
cdff1036 1531
09640e63 1532 if (protocol == cpu_to_be16(ETH_P_8021Q)) {
028afe71
DP		 1533
1534 vh = (struct vlan_ethhdr *)skb->data;
cdff1036
DP		 1535 protocol = vh->h_vlan_encapsulated_proto;
1536 flags = FLAGS_VLAN_TAGGED;
028afe71
DP		 1537
1538 } else if (vlan_tx_tag_present(skb)) {
1539
1540 flags = FLAGS_VLAN_OOB;
1541 vid = vlan_tx_tag_get(skb);
1542 netxen_set_tx_vlan_tci(first_desc, vid);
1543 vlan_oob = 1;
cdff1036 1544 }
cd1f8160 1545
391587c3
DP		 1546 if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1547 skb_shinfo(skb)->gso_size > 0) {
1548
1bcfd790
DP		 1549 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1550
1551 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1552 first_desc->total_hdr_length = hdr_len;
028afe71
DP		 1553 if (vlan_oob) {
1554 first_desc->total_hdr_length += VLAN_HLEN;
1555 first_desc->tcp_hdr_offset = VLAN_HLEN;
1556 first_desc->ip_hdr_offset = VLAN_HLEN;
1557 /* Only in case of TSO on vlan device */
1558 flags |= FLAGS_VLAN_TAGGED;
1559 }
391587c3 1560
09640e63 1561 opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
391587c3 1562 TX_TCP_LSO6 : TX_TCP_LSO;
1bcfd790 1563 tso = 1;
cd1f8160
DP		 1564
1565 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
391587c3
DP		 1566 u8 l4proto;
1567
09640e63 1568 if (protocol == cpu_to_be16(ETH_P_IP)) {
391587c3
DP		 1569 l4proto = ip_hdr(skb)->protocol;
1570
1571 if (l4proto == IPPROTO_TCP)
1572 opcode = TX_TCP_PKT;
1573 else if(l4proto == IPPROTO_UDP)
1574 opcode = TX_UDP_PKT;
09640e63 1575 } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
391587c3
DP		 1576 l4proto = ipv6_hdr(skb)->nexthdr;
1577
1578 if (l4proto == IPPROTO_TCP)
1579 opcode = TX_TCPV6_PKT;
1580 else if(l4proto == IPPROTO_UDP)
1581 opcode = TX_UDPV6_PKT;
1582 }
cd1f8160 1583 }
028afe71
DP		 1584
1585 first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1586 first_desc->ip_hdr_offset += skb_network_offset(skb);
1bcfd790
DP		 1587 netxen_set_tx_flags_opcode(first_desc, flags, opcode);
1588
1589 if (!tso)
1590 return;
1591
1592 /* For LSO, we need to copy the MAC/IP/TCP headers into
1593 * the descriptor ring
1594 */
1595 producer = tx_ring->producer;
1596 copied = 0;
1597 offset = 2;
1598
028afe71
DP		 1599 if (vlan_oob) {
1600 /* Create a TSO vlan header template for firmware */
1601
1602 hwdesc = &tx_ring->desc_head[producer];
1603 tx_ring->cmd_buf_arr[producer].skb = NULL;
1604
1605 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1606 hdr_len + VLAN_HLEN);
1607
1608 vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1609 skb_copy_from_linear_data(skb, vh, 12);
1610 vh->h_vlan_proto = htons(ETH_P_8021Q);
1611 vh->h_vlan_TCI = htons(vid);
1612 skb_copy_from_linear_data_offset(skb, 12,
1613 (char *)vh + 16, copy_len - 16);
1614
545eb370 1615 copied = copy_len - VLAN_HLEN;
028afe71
DP		 1616 offset = 0;
1617
1618 producer = get_next_index(producer, tx_ring->num_desc);
1619 }
1620
1bcfd790
DP		 1621 while (copied < hdr_len) {
1622
1623 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1624 (hdr_len - copied));
1625
1626 hwdesc = &tx_ring->desc_head[producer];
1627 tx_ring->cmd_buf_arr[producer].skb = NULL;
1628
1629 skb_copy_from_linear_data_offset(skb, copied,
1630 (char *)hwdesc + offset, copy_len);
1631
1632 copied += copy_len;
1633 offset = 0;
1634
1635 producer = get_next_index(producer, tx_ring->num_desc);
1636 }
1637
1638 tx_ring->producer = producer;
1639 barrier();
cd1f8160
DP		 1640}
1641
ce644ed4
DP		 1642static int
1643netxen_map_tx_skb(struct pci_dev *pdev,
1644 struct sk_buff *skb, struct netxen_cmd_buffer *pbuf)
6f703406 1645{
ce644ed4
DP		 1646 struct netxen_skb_frag *nf;
1647 struct skb_frag_struct *frag;
1648 int i, nr_frags;
1649 dma_addr_t map;
1650
1651 nr_frags = skb_shinfo(skb)->nr_frags;
1652 nf = &pbuf->frag_array[0];
1653
1654 map = pci_map_single(pdev, skb->data,
1655 skb_headlen(skb), PCI_DMA_TODEVICE);
1656 if (pci_dma_mapping_error(pdev, map))
1657 goto out_err;
6f703406 1658
ce644ed4
DP		 1659 nf->dma = map;
1660 nf->length = skb_headlen(skb);
1661
1662 for (i = 0; i < nr_frags; i++) {
1663 frag = &skb_shinfo(skb)->frags[i];
1664 nf = &pbuf->frag_array[i+1];
1665
1666 map = pci_map_page(pdev, frag->page, frag->page_offset,
1667 frag->size, PCI_DMA_TODEVICE);
1668 if (pci_dma_mapping_error(pdev, map))
1669 goto unwind;
1670
1671 nf->dma = map;
1672 nf->length = frag->size;
1673 }
1674
1675 return 0;
6f703406 1676
ce644ed4 1677unwind:
cf503e8f
DP		 1678 while (--i >= 0) {
1679 nf = &pbuf->frag_array[i+1];
ce644ed4 1680 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
6f703406 1681 }
ce644ed4
DP		 1682
1683 nf = &pbuf->frag_array[0];
1684 pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
1685
1686out_err:
1687 return -ENOMEM;
6f703406
DP		 1688}
1689
d32cc3d2
DP		 1690static inline void
1691netxen_clear_cmddesc(u64 *desc)
1692{
1bcfd790
DP		 1693 desc[0] = 0ULL;
1694 desc[2] = 0ULL;
d32cc3d2
DP		 1695}
1696
61357325 1697static netdev_tx_t
d32cc3d2 1698netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
3d396eb1 1699{
3176ff3e 1700 struct netxen_adapter *adapter = netdev_priv(netdev);
4ea528a1 1701 struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
391587c3 1702 struct netxen_cmd_buffer *pbuf;
3d396eb1 1703 struct netxen_skb_frag *buffrag;
1bcfd790
DP		 1704 struct cmd_desc_type0 *hwdesc, *first_desc;
1705 struct pci_dev *pdev;
391587c3 1706 int i, k;
3d396eb1 1707
cb2107be 1708 u32 producer;
ce644ed4 1709 int frag_count, no_of_desc;
d877f1e3 1710 u32 num_txd = tx_ring->num_desc;
3d396eb1 1711
3d396eb1
AK		 1712 frag_count = skb_shinfo(skb)->nr_frags + 1;
1713
d877f1e3 1714 /* 4 fragments per cmd des */
3d396eb1 1715 no_of_desc = (frag_count + 3) >> 2;
53a01e00 1716
cb2107be 1717 if (unlikely(no_of_desc + 2) > netxen_tx_avail(tx_ring)) {
ba53e6b4 1718 netif_stop_queue(netdev);
ba53e6b4 1719 return NETDEV_TX_BUSY;
53a01e00 1720 }
3d396eb1 1721
cb2107be 1722 producer = tx_ring->producer;
ce644ed4 1723 pbuf = &tx_ring->cmd_buf_arr[producer];
cb2107be 1724
1bcfd790 1725 pdev = adapter->pdev;
391587c3 1726
ce644ed4 1727 if (netxen_map_tx_skb(pdev, skb, pbuf))
1bcfd790 1728 goto drop_packet;
391587c3 1729
3d396eb1 1730 pbuf->skb = skb;
3d396eb1 1731 pbuf->frag_count = frag_count;
6f703406 1732
1bcfd790
DP		 1733 first_desc = hwdesc = &tx_ring->desc_head[producer];
1734 netxen_clear_cmddesc((u64 *)hwdesc);
3d396eb1 1735
ce644ed4
DP		 1736 netxen_set_tx_frags_len(first_desc, frag_count, skb->len);
1737 netxen_set_tx_port(first_desc, adapter->portnum);
3d396eb1 1738
ce644ed4 1739 for (i = 0; i < frag_count; i++) {
3d396eb1 1740
ce644ed4
DP		 1741 k = i % 4;
1742
1743 if ((k == 0) && (i > 0)) {
1744 /* move to next desc.*/
ba53e6b4 1745 producer = get_next_index(producer, num_txd);
d877f1e3 1746 hwdesc = &tx_ring->desc_head[producer];
d32cc3d2 1747 netxen_clear_cmddesc((u64 *)hwdesc);
ce644ed4 1748 tx_ring->cmd_buf_arr[producer].skb = NULL;
6f703406 1749 }
3d396eb1 1750
ce644ed4 1751 buffrag = &pbuf->frag_array[i];
3d396eb1 1752
ce644ed4 1753 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
3d396eb1
AK		 1754 switch (k) {
1755 case 0:
ce644ed4 1756 hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
3d396eb1
AK		 1757 break;
1758 case 1:
ce644ed4 1759 hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
3d396eb1
AK		 1760 break;
1761 case 2:
ce644ed4 1762 hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
3d396eb1
AK		 1763 break;
1764 case 3:
ce644ed4 1765 hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
3d396eb1
AK		 1766 break;
1767 }
3d396eb1 1768 }
ce644ed4 1769
1bcfd790 1770 tx_ring->producer = get_next_index(producer, num_txd);
3d396eb1 1771
1bcfd790 1772 netxen_tso_check(netdev, tx_ring, first_desc, skb);
6c80b18d 1773
cb2107be 1774 netxen_nic_update_cmd_producer(adapter, tx_ring);
3d396eb1 1775
1bcfd790 1776 adapter->stats.txbytes += skb->len;
ba53e6b4 1777 adapter->stats.xmitcalled++;
3d396eb1 1778
3d396eb1 1779 return NETDEV_TX_OK;
6f703406
DP		 1780
1781drop_packet:
1782 adapter->stats.txdropped++;
1783 dev_kfree_skb_any(skb);
1784 return NETDEV_TX_OK;
3d396eb1
AK		 1785}
1786
a97342f9
DP		 1787static int netxen_nic_check_temp(struct netxen_adapter *adapter)
1788{
1789 struct net_device *netdev = adapter->netdev;
1790 uint32_t temp, temp_state, temp_val;
1791 int rv = 0;
1792
f98a9f69 1793 temp = NXRD32(adapter, CRB_TEMP_STATE);
a97342f9
DP		 1794
1795 temp_state = nx_get_temp_state(temp);
1796 temp_val = nx_get_temp_val(temp);
1797
1798 if (temp_state == NX_TEMP_PANIC) {
1799 printk(KERN_ALERT
1800 "%s: Device temperature %d degrees C exceeds"
1801 " maximum allowed. Hardware has been shut down.\n",
e4135c2d 1802 netdev->name, temp_val);
a97342f9
DP		 1803 rv = 1;
1804 } else if (temp_state == NX_TEMP_WARN) {
1805 if (adapter->temp == NX_TEMP_NORMAL) {
1806 printk(KERN_ALERT
1807 "%s: Device temperature %d degrees C "
1808 "exceeds operating range."
1809 " Immediate action needed.\n",
e4135c2d 1810 netdev->name, temp_val);
a97342f9
DP		 1811 }
1812 } else {
1813 if (adapter->temp == NX_TEMP_WARN) {
1814 printk(KERN_INFO
1815 "%s: Device temperature is now %d degrees C"
e4135c2d 1816 " in normal range.\n", netdev->name,
a97342f9
DP		 1817 temp_val);
1818 }
1819 }
1820 adapter->temp = temp_state;
1821 return rv;
1822}
1823
3bf26ce3 1824void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
a97342f9
DP		 1825{
1826 struct net_device *netdev = adapter->netdev;
a97342f9
DP		 1827
1828 if (adapter->ahw.linkup && !linkup) {
1829 printk(KERN_INFO "%s: %s NIC Link is down\n",
1830 netxen_nic_driver_name, netdev->name);
1831 adapter->ahw.linkup = 0;
1832 if (netif_running(netdev)) {
1833 netif_carrier_off(netdev);
1834 netif_stop_queue(netdev);
1835 }
e424fa9d 1836 adapter->link_changed = !adapter->has_link_events;
a97342f9
DP		 1837 } else if (!adapter->ahw.linkup && linkup) {
1838 printk(KERN_INFO "%s: %s NIC Link is up\n",
1839 netxen_nic_driver_name, netdev->name);
1840 adapter->ahw.linkup = 1;
1841 if (netif_running(netdev)) {
1842 netif_carrier_on(netdev);
1843 netif_wake_queue(netdev);
1844 }
e424fa9d 1845 adapter->link_changed = !adapter->has_link_events;
a97342f9
DP		 1846 }
1847}
1848
3bf26ce3
DP		 1849static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
1850{
1851 u32 val, port, linkup;
1852
1853 port = adapter->physical_port;
1854
1855 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
f98a9f69 1856 val = NXRD32(adapter, CRB_XG_STATE_P3);
3bf26ce3
DP		 1857 val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
1858 linkup = (val == XG_LINK_UP_P3);
1859 } else {
f98a9f69 1860 val = NXRD32(adapter, CRB_XG_STATE);
3bf26ce3
DP		 1861 if (adapter->ahw.port_type == NETXEN_NIC_GBE)
1862 linkup = (val >> port) & 1;
1863 else {
1864 val = (val >> port*8) & 0xff;
1865 linkup = (val == XG_LINK_UP);
1866 }
1867 }
1868
1869 netxen_advert_link_change(adapter, linkup);
1870}
1871
3d396eb1
AK		 1872static void netxen_tx_timeout(struct net_device *netdev)
1873{
e424fa9d 1874 struct netxen_adapter *adapter = netdev_priv(netdev);
f17443f4 1875
6a581e93
DP		 1876 if (test_bit(__NX_RESETTING, &adapter->state))
1877 return;
1878
f17443f4 1879 dev_err(&netdev->dev, "transmit timeout, resetting.\n");
e424fa9d 1880 schedule_work(&adapter->tx_timeout_task);
3d396eb1
AK		 1881}
1882
f17443f4 1883static void netxen_reset_task(struct work_struct *work)
3d396eb1 1884{
4790654c 1885 struct netxen_adapter *adapter =
3176ff3e 1886 container_of(work, struct netxen_adapter, tx_timeout_task);
3d396eb1 1887
b2af9cb0
DP		 1888 if (!netif_running(adapter->netdev))
1889 return;
1890
6a581e93
DP		 1891 if (test_bit(__NX_RESETTING, &adapter->state))
1892 return;
1893
d8b100c5 1894 netxen_napi_disable(adapter);
ba53e6b4 1895
6c80b18d 1896 adapter->netdev->trans_start = jiffies;
ba53e6b4 1897
d8b100c5 1898 netxen_napi_enable(adapter);
6c80b18d 1899 netif_wake_queue(adapter->netdev);
3d396eb1
AK		 1900}
1901
a97342f9
DP		 1902struct net_device_stats *netxen_nic_get_stats(struct net_device *netdev)
1903{
1904 struct netxen_adapter *adapter = netdev_priv(netdev);
1905 struct net_device_stats *stats = &adapter->net_stats;
1906
1907 memset(stats, 0, sizeof(*stats));
1908
1bb482f8 1909 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
e98e3350 1910 stats->tx_packets = adapter->stats.xmitfinished;
a97342f9 1911 stats->rx_bytes = adapter->stats.rxbytes;
a97342f9 1912 stats->tx_bytes = adapter->stats.txbytes;
a97342f9 1913 stats->rx_dropped = adapter->stats.rxdropped;
a97342f9
DP		 1914 stats->tx_dropped = adapter->stats.txdropped;
1915
1916 return stats;
1917}
1918
e4c93c81 1919static irqreturn_t netxen_intr(int irq, void *data)
3d396eb1 1920{
d8b100c5
DP		 1921 struct nx_host_sds_ring *sds_ring = data;
1922 struct netxen_adapter *adapter = sds_ring->adapter;
d71e1be8
DP		 1923 u32 status = 0;
1924
195c5f98 1925 status = readl(adapter->isr_int_vec);
d71e1be8 1926
195c5f98 1927 if (!(status & adapter->int_vec_bit))
05aaa02d 1928 return IRQ_NONE;
e01872af 1929
195c5f98 1930 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
d71e1be8 1931 /* check interrupt state machine, to be sure */
195c5f98 1932 status = readl(adapter->crb_int_state_reg);
d71e1be8
DP		 1933 if (!ISR_LEGACY_INT_TRIGGERED(status))
1934 return IRQ_NONE;
1935
092bc571
DP		 1936 } else {
1937 unsigned long our_int = 0;
d71e1be8 1938
195c5f98 1939 our_int = readl(adapter->crb_int_state_reg);
092bc571 1940
d71e1be8 1941 /* not our interrupt */
092bc571 1942 if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
d71e1be8
DP		 1943 return IRQ_NONE;
1944
092bc571 1945 /* claim interrupt */
195c5f98 1946 writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
e01872af 1947
195c5f98 1948 /* clear interrupt */
d8b100c5 1949 netxen_nic_disable_int(sds_ring);
195c5f98 1950 }
092bc571 1951
195c5f98 1952 writel(0xffffffff, adapter->tgt_status_reg);
092bc571 1953 /* read twice to ensure write is flushed */
195c5f98
AKS		 1954 readl(adapter->isr_int_vec);
1955 readl(adapter->isr_int_vec);
092bc571 1956
d8b100c5 1957 napi_schedule(&sds_ring->napi);
3d396eb1
AK		 1958
1959 return IRQ_HANDLED;
1960}
1961
e4c93c81 1962static irqreturn_t netxen_msi_intr(int irq, void *data)
05aaa02d 1963{
d8b100c5
DP		 1964 struct nx_host_sds_ring *sds_ring = data;
1965 struct netxen_adapter *adapter = sds_ring->adapter;
05aaa02d 1966
092bc571 1967 /* clear interrupt */
195c5f98 1968 writel(0xffffffff, adapter->tgt_status_reg);
092bc571 1969
d8b100c5 1970 napi_schedule(&sds_ring->napi);
05aaa02d
DP		 1971 return IRQ_HANDLED;
1972}
1973
b3df68f8
DP		 1974static irqreturn_t netxen_msix_intr(int irq, void *data)
1975{
d8b100c5 1976 struct nx_host_sds_ring *sds_ring = data;
b3df68f8 1977
d8b100c5 1978 napi_schedule(&sds_ring->napi);
b3df68f8
DP		 1979 return IRQ_HANDLED;
1980}
1981
bea3348e 1982static int netxen_nic_poll(struct napi_struct *napi, int budget)
3d396eb1 1983{
d8b100c5
DP		 1984 struct nx_host_sds_ring *sds_ring =
1985 container_of(napi, struct nx_host_sds_ring, napi);
1986
1987 struct netxen_adapter *adapter = sds_ring->adapter;
1988
05aaa02d 1989 int tx_complete;
bea3348e 1990 int work_done;
3d396eb1 1991
05aaa02d 1992 tx_complete = netxen_process_cmd_ring(adapter);
3d396eb1 1993
d8b100c5 1994 work_done = netxen_process_rcv_ring(sds_ring, budget);
3d396eb1 1995
05aaa02d 1996 if ((work_done < budget) && tx_complete) {
d8b100c5 1997 napi_complete(&sds_ring->napi);
b2af9cb0
DP		 1998 if (netif_running(adapter->netdev))
1999 netxen_nic_enable_int(sds_ring);
3d396eb1
AK		 2000 }
2001
bea3348e 2002 return work_done;
3d396eb1
AK		 2003}
2004
2005#ifdef CONFIG_NET_POLL_CONTROLLER
2006static void netxen_nic_poll_controller(struct net_device *netdev)
2007{
3176ff3e 2008 struct netxen_adapter *adapter = netdev_priv(netdev);
3d396eb1 2009 disable_irq(adapter->irq);
1494a814 2010 netxen_intr(adapter->irq, adapter);
3d396eb1
AK		 2011 enable_irq(adapter->irq);
2012}
2013#endif
3d396eb1 2014
6a581e93
DP		 2015static int
2016nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
2017{
2018 int count;
2019 if (netxen_api_lock(adapter))
2020 return -EIO;
2021
2022 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2023
2024 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2025
2026 netxen_api_unlock(adapter);
2027 return count;
2028}
2029
2030static int
2031nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
2032{
2033 int count;
2034 if (netxen_api_lock(adapter))
2035 return -EIO;
2036
2037 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2038 WARN_ON(count == 0);
2039
2040 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2041
2042 if (count == 0)
2043 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2044
2045 netxen_api_unlock(adapter);
2046 return count;
2047}
2048
2049static int
2050netxen_can_start_firmware(struct netxen_adapter *adapter)
2051{
2052 int count;
2053 int can_start = 0;
2054
2055 if (netxen_api_lock(adapter))
2056 return 0;
2057
2058 count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2059
2060 if ((count < 0) || (count >= NX_MAX_PCI_FUNC))
2061 count = 0;
2062
2063 if (count == 0) {
2064 can_start = 1;
2065 NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
2066 }
2067
2068 NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2069
2070 netxen_api_unlock(adapter);
2071
2072 return can_start;
2073}
2074
2075static void
2076netxen_schedule_work(struct netxen_adapter *adapter,
2077 work_func_t func, int delay)
2078{
2079 INIT_DELAYED_WORK(&adapter->fw_work, func);
2080 schedule_delayed_work(&adapter->fw_work, delay);
2081}
2082
2083static void
2084netxen_cancel_fw_work(struct netxen_adapter *adapter)
2085{
2086 while (test_and_set_bit(__NX_RESETTING, &adapter->state))
2087 msleep(10);
2088
2089 cancel_delayed_work_sync(&adapter->fw_work);
2090}
2091
2092static void
2093netxen_attach_work(struct work_struct *work)
2094{
2095 struct netxen_adapter *adapter = container_of(work,
2096 struct netxen_adapter, fw_work.work);
2097 struct net_device *netdev = adapter->netdev;
2098 int err = 0;
2099
2100 if (netif_running(netdev)) {
2101 err = netxen_nic_attach(adapter);
2102 if (err)
2103 goto done;
2104
2105 err = netxen_nic_up(adapter, netdev);
2106 if (err) {
2107 netxen_nic_detach(adapter);
2108 goto done;
2109 }
2110
d0725e4d 2111 netxen_config_indev_addr(netdev, NETDEV_UP);
6a581e93
DP		 2112 }
2113
2114 netif_device_attach(netdev);
2115
2116done:
2117 adapter->fw_fail_cnt = 0;
2118 clear_bit(__NX_RESETTING, &adapter->state);
2119 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2120}
2121
2122static void
2123netxen_fwinit_work(struct work_struct *work)
2124{
2125 struct netxen_adapter *adapter = container_of(work,
2126 struct netxen_adapter, fw_work.work);
2127 int dev_state;
2128
2129 dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
2130
2131 switch (dev_state) {
2132 case NX_DEV_COLD:
2133 case NX_DEV_READY:
2134 netxen_start_firmware(adapter);
2135 netxen_schedule_work(adapter, netxen_attach_work, 0);
2136 return;
2137
2138 case NX_DEV_INITALIZING:
2139 if (++adapter->fw_wait_cnt < FW_POLL_THRESH) {
2140 netxen_schedule_work(adapter,
2141 netxen_fwinit_work, 2 * FW_POLL_DELAY);
2142 return;
2143 }
2144 break;
2145
2146 case NX_DEV_FAILED:
2147 default:
2148 break;
2149 }
2150
2151 nx_incr_dev_ref_cnt(adapter);
2152 clear_bit(__NX_RESETTING, &adapter->state);
2153}
2154
2155static void
2156netxen_detach_work(struct work_struct *work)
2157{
2158 struct netxen_adapter *adapter = container_of(work,
2159 struct netxen_adapter, fw_work.work);
2160 struct net_device *netdev = adapter->netdev;
2161 int ref_cnt, delay;
2162 u32 status;
2163
2164 netif_device_detach(netdev);
2165
2166 if (netif_running(netdev))
2167 netxen_nic_down(adapter, netdev);
2168
2169 netxen_nic_detach(adapter);
2170
2171 status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2172
2173 ref_cnt = nx_decr_dev_ref_cnt(adapter);
2174
2175 if (status & NX_RCODE_FATAL_ERROR)
2176 return;
2177
2178 if (adapter->temp == NX_TEMP_PANIC)
2179 return;
2180
2181 delay = (ref_cnt == 0) ? 0 : (2 * FW_POLL_DELAY);
2182
2183 adapter->fw_wait_cnt = 0;
2184 netxen_schedule_work(adapter, netxen_fwinit_work, delay);
2185}
2186
2187static int
2188netxen_check_health(struct netxen_adapter *adapter)
2189{
2190 u32 state, heartbit;
2191 struct net_device *netdev = adapter->netdev;
2192
2193 if (netxen_nic_check_temp(adapter))
2194 goto detach;
2195
2196 state = NXRD32(adapter, NX_CRB_DEV_STATE);
2197 if (state == NX_DEV_NEED_RESET)
2198 goto detach;
2199
2200 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2201 return 0;
2202
2203 heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
2204 if (heartbit != adapter->heartbit) {
2205 adapter->heartbit = heartbit;
2206 adapter->fw_fail_cnt = 0;
2207 return 0;
2208 }
2209
2210 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2211 return 0;
2212
2213 clear_bit(__NX_FW_ATTACHED, &adapter->state);
2214
2215 dev_info(&netdev->dev, "firmware hang detected\n");
2216
2217detach:
2218 if (!test_and_set_bit(__NX_RESETTING, &adapter->state))
2219 netxen_schedule_work(adapter, netxen_detach_work, 0);
2220 return 1;
2221}
2222
2223static void
2224netxen_fw_poll_work(struct work_struct *work)
2225{
2226 struct netxen_adapter *adapter = container_of(work,
2227 struct netxen_adapter, fw_work.work);
2228
2229 if (test_bit(__NX_RESETTING, &adapter->state))
2230 goto reschedule;
2231
2232 if (test_bit(__NX_DEV_UP, &adapter->state)) {
2233 if (!adapter->has_link_events) {
2234
2235 netxen_nic_handle_phy_intr(adapter);
2236
2237 if (adapter->link_changed)
2238 netxen_nic_set_link_parameters(adapter);
2239 }
2240 }
2241
2242 if (netxen_check_health(adapter))
2243 return;
2244
2245reschedule:
2246 netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2247}
2248
fa3ce355
NK		 2249static ssize_t
2250netxen_store_bridged_mode(struct device *dev,
2251 struct device_attribute *attr, const char *buf, size_t len)
2252{
2253 struct net_device *net = to_net_dev(dev);
2254 struct netxen_adapter *adapter = netdev_priv(net);
2255 unsigned long new;
2256 int ret = -EINVAL;
2257
2258 if (!(adapter->capabilities & NX_FW_CAPABILITY_BDG))
2259 goto err_out;
2260
2261 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2262 goto err_out;
2263
2264 if (strict_strtoul(buf, 2, &new))
2265 goto err_out;
2266
2267 if (!netxen_config_bridged_mode(adapter, !!new))
2268 ret = len;
2269
2270err_out:
2271 return ret;
2272}
2273
2274static ssize_t
2275netxen_show_bridged_mode(struct device *dev,
2276 struct device_attribute *attr, char *buf)
2277{
2278 struct net_device *net = to_net_dev(dev);
2279 struct netxen_adapter *adapter;
2280 int bridged_mode = 0;
2281
2282 adapter = netdev_priv(net);
2283
2284 if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
2285 bridged_mode = !!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED);
2286
2287 return sprintf(buf, "%d\n", bridged_mode);
2288}
2289
2290static struct device_attribute dev_attr_bridged_mode = {
2291 .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
2292 .show = netxen_show_bridged_mode,
2293 .store = netxen_store_bridged_mode,
2294};
2295
2296static void
2297netxen_create_sysfs_entries(struct netxen_adapter *adapter)
2298{
2299 struct net_device *netdev = adapter->netdev;
2300 struct device *dev = &netdev->dev;
2301
2302 if (adapter->capabilities & NX_FW_CAPABILITY_BDG) {
2303 /* bridged_mode control */
2304 if (device_create_file(dev, &dev_attr_bridged_mode)) {
2305 dev_warn(&netdev->dev,
2306 "failed to create bridged_mode sysfs entry\n");
2307 }
2308 }
2309}
2310
2311static void
2312netxen_remove_sysfs_entries(struct netxen_adapter *adapter)
2313{
2314 struct net_device *netdev = adapter->netdev;
2315 struct device *dev = &netdev->dev;
2316
2317 if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
2318 device_remove_file(dev, &dev_attr_bridged_mode);
2319}
2320
044824d9
DP		 2321#ifdef CONFIG_INET
2322
6598b169
DP		 2323#define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
2324
2325static int
2326netxen_destip_supported(struct netxen_adapter *adapter)
2327{
2328 if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2329 return 0;
2330
2331 if (adapter->ahw.cut_through)
2332 return 0;
2333
2334 return 1;
2335}
2336
d0725e4d
AKS		 2337static void
2338netxen_config_indev_addr(struct net_device *dev, unsigned long event)
2339{
2340 struct in_device *indev;
2341 struct netxen_adapter *adapter = netdev_priv(dev);
2342
2343 if (netxen_destip_supported(adapter))
2344 return;
2345
2346 indev = in_dev_get(dev);
2347 if (!indev)
2348 return;
2349
2350 for_ifa(indev) {
2351 switch (event) {
2352 case NETDEV_UP:
2353 netxen_config_ipaddr(adapter,
2354 ifa->ifa_address, NX_IP_UP);
2355 break;
2356 case NETDEV_DOWN:
2357 netxen_config_ipaddr(adapter,
2358 ifa->ifa_address, NX_IP_DOWN);
2359 break;
2360 default:
2361 break;
2362 }
2363 } endfor_ifa(indev);
2364
2365 in_dev_put(indev);
2366 return;
2367}
2368
6598b169
DP		 2369static int netxen_netdev_event(struct notifier_block *this,
2370 unsigned long event, void *ptr)
2371{
2372 struct netxen_adapter *adapter;
2373 struct net_device *dev = (struct net_device *)ptr;
6598b169
DP		 2374
2375recheck:
2376 if (dev == NULL)
2377 goto done;
2378
2379 if (dev->priv_flags & IFF_802_1Q_VLAN) {
2380 dev = vlan_dev_real_dev(dev);
2381 goto recheck;
2382 }
2383
2384 if (!is_netxen_netdev(dev))
2385 goto done;
2386
2387 adapter = netdev_priv(dev);
2388
d0725e4d 2389 if (!adapter)
6598b169
DP		 2390 goto done;
2391
2392 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2393 goto done;
2394
d0725e4d 2395 netxen_config_indev_addr(dev, event);
6598b169
DP		 2396done:
2397 return NOTIFY_DONE;
2398}
2399
2400static int
2401netxen_inetaddr_event(struct notifier_block *this,
2402 unsigned long event, void *ptr)
2403{
2404 struct netxen_adapter *adapter;
2405 struct net_device *dev;
2406
2407 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2408
2409 dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
2410
2411recheck:
2412 if (dev == NULL || !netif_running(dev))
2413 goto done;
2414
2415 if (dev->priv_flags & IFF_802_1Q_VLAN) {
2416 dev = vlan_dev_real_dev(dev);
2417 goto recheck;
2418 }
2419
2420 if (!is_netxen_netdev(dev))
2421 goto done;
2422
2423 adapter = netdev_priv(dev);
2424
2425 if (!adapter || !netxen_destip_supported(adapter))
2426 goto done;
2427
2428 if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2429 goto done;
2430
2431 switch (event) {
2432 case NETDEV_UP:
2433 netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
2434 break;
2435 case NETDEV_DOWN:
2436 netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_DOWN);
2437 break;
2438 default:
2439 break;
2440 }
2441
2442done:
2443 return NOTIFY_DONE;
2444}
2445
2446static struct notifier_block netxen_netdev_cb = {
2447 .notifier_call = netxen_netdev_event,
2448};
2449
2450static struct notifier_block netxen_inetaddr_cb = {
2451 .notifier_call = netxen_inetaddr_event,
2452};
044824d9 2453#endif
6598b169 2454
3d396eb1
AK		 2455static struct pci_driver netxen_driver = {
2456 .name = netxen_nic_driver_name,
2457 .id_table = netxen_pci_tbl,
2458 .probe = netxen_nic_probe,
0b72e659 2459 .remove = __devexit_p(netxen_nic_remove),
01542cd1 2460#ifdef CONFIG_PM
0b72e659 2461 .suspend = netxen_nic_suspend,
22b5794b 2462 .resume = netxen_nic_resume,
01542cd1 2463#endif
22b5794b 2464 .shutdown = netxen_nic_shutdown
3d396eb1
AK		 2465};
2466
3d396eb1
AK		 2467static int __init netxen_init_module(void)
2468{
ff4fbd43
DP		 2469 printk(KERN_INFO "%s\n", netxen_nic_driver_string);
2470
044824d9 2471#ifdef CONFIG_INET
6598b169
DP		 2472 register_netdevice_notifier(&netxen_netdev_cb);
2473 register_inetaddr_notifier(&netxen_inetaddr_cb);
044824d9 2474#endif
6598b169 2475
184231bd 2476 return pci_register_driver(&netxen_driver);
3d396eb1
AK		 2477}
2478
2479module_init(netxen_init_module);
2480
2481static void __exit netxen_exit_module(void)
2482{
3d396eb1 2483 pci_unregister_driver(&netxen_driver);
6598b169 2484
044824d9 2485#ifdef CONFIG_INET
6598b169
DP		 2486 unregister_inetaddr_notifier(&netxen_inetaddr_cb);
2487 unregister_netdevice_notifier(&netxen_netdev_cb);
044824d9 2488#endif
3d396eb1
AK		 2489}
2490
2491module_exit(netxen_exit_module);
Linux 6.x block layer and io_uring tree(s)