← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
 
1
/*
 
2
 * Copyright (C) 2003 - 2009 NetXen, Inc.
 
3
 * Copyright (C) 2009 - QLogic Corporation.
 
4
 * All rights reserved.
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU General Public License
 
8
 * as published by the Free Software Foundation; either version 2
 
9
 * of the License, or (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful, but
 
12
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 
19
 * MA  02111-1307, USA.
 
20
 *
 
21
 * The full GNU General Public License is included in this distribution
 
22
 * in the file called "COPYING".
 
23
 *
 
24
 */
 
25
 
 
26
#include <linux/slab.h>
 
27
#include <linux/vmalloc.h>
 
28
#include <linux/interrupt.h>
 
29
#include "netxen_nic_hw.h"
 
30
 
 
31
#include "netxen_nic.h"
 
32
 
 
33
#include <linux/dma-mapping.h>
 
34
#include <linux/if_vlan.h>
 
35
#include <net/ip.h>
 
36
#include <linux/ipv6.h>
 
37
#include <linux/inetdevice.h>
 
38
#include <linux/sysfs.h>
 
39
#include <linux/aer.h>
 
40
 
 
41
MODULE_DESCRIPTION("QLogic/NetXen (1/10) GbE Intelligent Ethernet Driver");
 
42
MODULE_LICENSE("GPL");
 
43
MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
 
44
MODULE_FIRMWARE(NX_UNIFIED_ROMIMAGE_NAME);
 
45
 
 
46
char netxen_nic_driver_name[] = "netxen_nic";
 
47
static char netxen_nic_driver_string[] = "QLogic/NetXen Network Driver v"
 
48
    NETXEN_NIC_LINUX_VERSIONID;
 
49
 
 
50
static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
 
51
 
 
52
/* Default to restricted 1G auto-neg mode */
 
53
static int wol_port_mode = 5;
 
54
 
 
55
static int use_msi = 1;
 
56
 
 
57
static int use_msi_x = 1;
 
58
 
 
59
static int auto_fw_reset = AUTO_FW_RESET_ENABLED;
 
60
module_param(auto_fw_reset, int, 0644);
 
61
MODULE_PARM_DESC(auto_fw_reset,"Auto firmware reset (0=disabled, 1=enabled");
 
62
 
 
63
static int __devinit netxen_nic_probe(struct pci_dev *pdev,
 
64
                const struct pci_device_id *ent);
 
65
static void __devexit netxen_nic_remove(struct pci_dev *pdev);
 
66
static int netxen_nic_open(struct net_device *netdev);
 
67
static int netxen_nic_close(struct net_device *netdev);
 
68
static netdev_tx_t netxen_nic_xmit_frame(struct sk_buff *,
 
69
                                               struct net_device *);
 
70
static void netxen_tx_timeout(struct net_device *netdev);
 
71
static void netxen_tx_timeout_task(struct work_struct *work);
 
72
static void netxen_fw_poll_work(struct work_struct *work);
 
73
static void netxen_schedule_work(struct netxen_adapter *adapter,
 
74
                work_func_t func, int delay);
 
75
static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
 
76
static int netxen_nic_poll(struct napi_struct *napi, int budget);
 
77
#ifdef CONFIG_NET_POLL_CONTROLLER
 
78
static void netxen_nic_poll_controller(struct net_device *netdev);
 
79
#endif
 
80
 
 
81
static void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
 
82
static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
 
83
static void netxen_create_diag_entries(struct netxen_adapter *adapter);
 
84
static void netxen_remove_diag_entries(struct netxen_adapter *adapter);
 
85
 
 
86
static int nx_dev_request_aer(struct netxen_adapter *adapter);
 
87
static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
 
88
static int netxen_can_start_firmware(struct netxen_adapter *adapter);
 
89
 
 
90
static irqreturn_t netxen_intr(int irq, void *data);
 
91
static irqreturn_t netxen_msi_intr(int irq, void *data);
 
92
static irqreturn_t netxen_msix_intr(int irq, void *data);
 
93
 
 
94
static void netxen_free_vlan_ip_list(struct netxen_adapter *);
 
95
static void netxen_restore_indev_addr(struct net_device *dev, unsigned long);
 
96
static struct rtnl_link_stats64 *netxen_nic_get_stats(struct net_device *dev,
 
97
                                                      struct rtnl_link_stats64 *stats);
 
98
static int netxen_nic_set_mac(struct net_device *netdev, void *p);
 
99
 
 
100
/*  PCI Device ID Table  */
 
101
#define ENTRY(device) \
 
102
        {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
 
103
        .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
 
104
 
 
105
static DEFINE_PCI_DEVICE_TABLE(netxen_pci_tbl) = {
 
106
        ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
 
107
        ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
 
108
        ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
 
109
        ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
 
110
        ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
 
111
        ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
 
112
        ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
 
113
        ENTRY(PCI_DEVICE_ID_NX3031),
 
114
        {0,}
 
115
};
 
116
 
 
117
MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
 
118
 
 
119
static uint32_t crb_cmd_producer[4] = {
 
120
        CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
 
121
        CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
 
122
};
 
123
 
 
124
void
 
125
netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
 
126
                struct nx_host_tx_ring *tx_ring)
 
127
{
 
128
        NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
 
129
}
 
130
 
 
131
static uint32_t crb_cmd_consumer[4] = {
 
132
        CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
 
133
        CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
 
134
};
 
135
 
 
136
static inline void
 
137
netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
 
138
                struct nx_host_tx_ring *tx_ring)
 
139
{
 
140
        NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
 
141
}
 
142
 
 
143
static uint32_t msi_tgt_status[8] = {
 
144
        ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
 
145
        ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
 
146
        ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
 
147
        ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
 
148
};
 
149
 
 
150
static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
 
151
 
 
152
static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
 
153
{
 
154
        struct netxen_adapter *adapter = sds_ring->adapter;
 
155
 
 
156
        NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
 
157
}
 
158
 
 
159
static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
 
160
{
 
161
        struct netxen_adapter *adapter = sds_ring->adapter;
 
162
 
 
163
        NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
 
164
 
 
165
        if (!NETXEN_IS_MSI_FAMILY(adapter))
 
166
                NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
 
167
}
 
168
 
 
169
static int
 
170
netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
 
171
{
 
172
        int size = sizeof(struct nx_host_sds_ring) * count;
 
173
 
 
174
        recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
 
175
 
 
176
        return recv_ctx->sds_rings == NULL;
 
177
}
 
178
 
 
179
static void
 
180
netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
 
181
{
 
182
        if (recv_ctx->sds_rings != NULL)
 
183
                kfree(recv_ctx->sds_rings);
 
184
 
 
185
        recv_ctx->sds_rings = NULL;
 
186
}
 
187
 
 
188
static int
 
189
netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
 
190
{
 
191
        int ring;
 
192
        struct nx_host_sds_ring *sds_ring;
 
193
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
194
 
 
195
        if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
 
196
                return -ENOMEM;
 
197
 
 
198
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
199
                sds_ring = &recv_ctx->sds_rings[ring];
 
200
                netif_napi_add(netdev, &sds_ring->napi,
 
201
                                netxen_nic_poll, NETXEN_NETDEV_WEIGHT);
 
202
        }
 
203
 
 
204
        return 0;
 
205
}
 
206
 
 
207
static void
 
208
netxen_napi_del(struct netxen_adapter *adapter)
 
209
{
 
210
        int ring;
 
211
        struct nx_host_sds_ring *sds_ring;
 
212
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
213
 
 
214
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
215
                sds_ring = &recv_ctx->sds_rings[ring];
 
216
                netif_napi_del(&sds_ring->napi);
 
217
        }
 
218
 
 
219
        netxen_free_sds_rings(&adapter->recv_ctx);
 
220
}
 
221
 
 
222
static void
 
223
netxen_napi_enable(struct netxen_adapter *adapter)
 
224
{
 
225
        int ring;
 
226
        struct nx_host_sds_ring *sds_ring;
 
227
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
228
 
 
229
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
230
                sds_ring = &recv_ctx->sds_rings[ring];
 
231
                napi_enable(&sds_ring->napi);
 
232
                netxen_nic_enable_int(sds_ring);
 
233
        }
 
234
}
 
235
 
 
236
static void
 
237
netxen_napi_disable(struct netxen_adapter *adapter)
 
238
{
 
239
        int ring;
 
240
        struct nx_host_sds_ring *sds_ring;
 
241
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
242
 
 
243
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
244
                sds_ring = &recv_ctx->sds_rings[ring];
 
245
                netxen_nic_disable_int(sds_ring);
 
246
                napi_synchronize(&sds_ring->napi);
 
247
                napi_disable(&sds_ring->napi);
 
248
        }
 
249
}
 
250
 
 
251
static int nx_set_dma_mask(struct netxen_adapter *adapter)
 
252
{
 
253
        struct pci_dev *pdev = adapter->pdev;
 
254
        uint64_t mask, cmask;
 
255
 
 
256
        adapter->pci_using_dac = 0;
 
257
 
 
258
        mask = DMA_BIT_MASK(32);
 
259
        cmask = DMA_BIT_MASK(32);
 
260
 
 
261
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
262
#ifndef CONFIG_IA64
 
263
                mask = DMA_BIT_MASK(35);
 
264
#endif
 
265
        } else {
 
266
                mask = DMA_BIT_MASK(39);
 
267
                cmask = mask;
 
268
        }
 
269
 
 
270
        if (pci_set_dma_mask(pdev, mask) == 0 &&
 
271
                pci_set_consistent_dma_mask(pdev, cmask) == 0) {
 
272
                adapter->pci_using_dac = 1;
 
273
                return 0;
 
274
        }
 
275
 
 
276
        return -EIO;
 
277
}
 
278
 
 
279
/* Update addressable range if firmware supports it */
 
280
static int
 
281
nx_update_dma_mask(struct netxen_adapter *adapter)
 
282
{
 
283
        int change, shift, err;
 
284
        uint64_t mask, old_mask, old_cmask;
 
285
        struct pci_dev *pdev = adapter->pdev;
 
286
 
 
287
        change = 0;
 
288
 
 
289
        shift = NXRD32(adapter, CRB_DMA_SHIFT);
 
290
        if (shift > 32)
 
291
                return 0;
 
292
 
 
293
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
 
294
                change = 1;
 
295
        else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
 
296
                change = 1;
 
297
 
 
298
        if (change) {
 
299
                old_mask = pdev->dma_mask;
 
300
                old_cmask = pdev->dev.coherent_dma_mask;
 
301
 
 
302
                mask = DMA_BIT_MASK(32+shift);
 
303
 
 
304
                err = pci_set_dma_mask(pdev, mask);
 
305
                if (err)
 
306
                        goto err_out;
 
307
 
 
308
                if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
309
 
 
310
                        err = pci_set_consistent_dma_mask(pdev, mask);
 
311
                        if (err)
 
312
                                goto err_out;
 
313
                }
 
314
                dev_info(&pdev->dev, "using %d-bit dma mask\n", 32+shift);
 
315
        }
 
316
 
 
317
        return 0;
 
318
 
 
319
err_out:
 
320
        pci_set_dma_mask(pdev, old_mask);
 
321
        pci_set_consistent_dma_mask(pdev, old_cmask);
 
322
        return err;
 
323
}
 
324
 
 
325
static int
 
326
netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
 
327
{
 
328
        u32 val, timeout;
 
329
 
 
330
        if (first_boot == 0x55555555) {
 
331
                /* This is the first boot after power up */
 
332
                NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
 
333
 
 
334
                if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
335
                        return 0;
 
336
 
 
337
                /* PCI bus master workaround */
 
338
                first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
 
339
                if (!(first_boot & 0x4)) {
 
340
                        first_boot |= 0x4;
 
341
                        NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
 
342
                        NXRD32(adapter, NETXEN_PCIE_REG(0x4));
 
343
                }
 
344
 
 
345
                /* This is the first boot after power up */
 
346
                first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
 
347
                if (first_boot != 0x80000f) {
 
348
                        /* clear the register for future unloads/loads */
 
349
                        NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
 
350
                        return -EIO;
 
351
                }
 
352
 
 
353
                /* Start P2 boot loader */
 
354
                val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
 
355
                NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
 
356
                timeout = 0;
 
357
                do {
 
358
                        msleep(1);
 
359
                        val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
 
360
 
 
361
                        if (++timeout > 5000)
 
362
                                return -EIO;
 
363
 
 
364
                } while (val == NETXEN_BDINFO_MAGIC);
 
365
        }
 
366
        return 0;
 
367
}
 
368
 
 
369
static void netxen_set_port_mode(struct netxen_adapter *adapter)
 
370
{
 
371
        u32 val, data;
 
372
 
 
373
        val = adapter->ahw.board_type;
 
374
        if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
 
375
                (val == NETXEN_BRDTYPE_P3_XG_LOM)) {
 
376
                if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
 
377
                        data = NETXEN_PORT_MODE_802_3_AP;
 
378
                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
 
379
                } else if (port_mode == NETXEN_PORT_MODE_XG) {
 
380
                        data = NETXEN_PORT_MODE_XG;
 
381
                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
 
382
                } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
 
383
                        data = NETXEN_PORT_MODE_AUTO_NEG_1G;
 
384
                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
 
385
                } else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
 
386
                        data = NETXEN_PORT_MODE_AUTO_NEG_XG;
 
387
                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
 
388
                } else {
 
389
                        data = NETXEN_PORT_MODE_AUTO_NEG;
 
390
                        NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
 
391
                }
 
392
 
 
393
                if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
 
394
                        (wol_port_mode != NETXEN_PORT_MODE_XG) &&
 
395
                        (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
 
396
                        (wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
 
397
                        wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
 
398
                }
 
399
                NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
 
400
        }
 
401
}
 
402
 
 
403
#define PCI_CAP_ID_GEN  0x10
 
404
 
 
405
static void netxen_pcie_strap_init(struct netxen_adapter *adapter)
 
406
{
 
407
        u32 pdevfuncsave;
 
408
        u32 c8c9value = 0;
 
409
        u32 chicken = 0;
 
410
        u32 control = 0;
 
411
        int i, pos;
 
412
        struct pci_dev *pdev;
 
413
 
 
414
        pdev = adapter->pdev;
 
415
 
 
416
        chicken = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3));
 
417
        /* clear chicken3.25:24 */
 
418
        chicken &= 0xFCFFFFFF;
 
419
        /*
 
420
         * if gen1 and B0, set F1020 - if gen 2, do nothing
 
421
         * if gen2 set to F1000
 
422
         */
 
423
        pos = pci_find_capability(pdev, PCI_CAP_ID_GEN);
 
424
        if (pos == 0xC0) {
 
425
                pci_read_config_dword(pdev, pos + 0x10, &control);
 
426
                if ((control & 0x000F0000) != 0x00020000) {
 
427
                        /*  set chicken3.24 if gen1 */
 
428
                        chicken |= 0x01000000;
 
429
                }
 
430
                dev_info(&adapter->pdev->dev, "Gen2 strapping detected\n");
 
431
                c8c9value = 0xF1000;
 
432
        } else {
 
433
                /* set chicken3.24 if gen1 */
 
434
                chicken |= 0x01000000;
 
435
                dev_info(&adapter->pdev->dev, "Gen1 strapping detected\n");
 
436
                if (adapter->ahw.revision_id == NX_P3_B0)
 
437
                        c8c9value = 0xF1020;
 
438
                else
 
439
                        c8c9value = 0;
 
440
        }
 
441
 
 
442
        NXWR32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3), chicken);
 
443
 
 
444
        if (!c8c9value)
 
445
                return;
 
446
 
 
447
        pdevfuncsave = pdev->devfn;
 
448
        if (pdevfuncsave & 0x07)
 
449
                return;
 
450
 
 
451
        for (i = 0; i < 8; i++) {
 
452
                pci_read_config_dword(pdev, pos + 8, &control);
 
453
                pci_read_config_dword(pdev, pos + 8, &control);
 
454
                pci_write_config_dword(pdev, pos + 8, c8c9value);
 
455
                pdev->devfn++;
 
456
        }
 
457
        pdev->devfn = pdevfuncsave;
 
458
}
 
459
 
 
460
static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
 
461
{
 
462
        u32 control;
 
463
        int pos;
 
464
 
 
465
        pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
 
466
        if (pos) {
 
467
                pci_read_config_dword(pdev, pos, &control);
 
468
                if (enable)
 
469
                        control |= PCI_MSIX_FLAGS_ENABLE;
 
470
                else
 
471
                        control = 0;
 
472
                pci_write_config_dword(pdev, pos, control);
 
473
        }
 
474
}
 
475
 
 
476
static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
 
477
{
 
478
        int i;
 
479
 
 
480
        for (i = 0; i < count; i++)
 
481
                adapter->msix_entries[i].entry = i;
 
482
}
 
483
 
 
484
static int
 
485
netxen_read_mac_addr(struct netxen_adapter *adapter)
 
486
{
 
487
        int i;
 
488
        unsigned char *p;
 
489
        u64 mac_addr;
 
490
        struct net_device *netdev = adapter->netdev;
 
491
        struct pci_dev *pdev = adapter->pdev;
 
492
 
 
493
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
494
                if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
 
495
                        return -EIO;
 
496
        } else {
 
497
                if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
 
498
                        return -EIO;
 
499
        }
 
500
 
 
501
        p = (unsigned char *)&mac_addr;
 
502
        for (i = 0; i < 6; i++)
 
503
                netdev->dev_addr[i] = *(p + 5 - i);
 
504
 
 
505
        memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
 
506
        memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
 
507
 
 
508
        /* set station address */
 
509
 
 
510
        if (!is_valid_ether_addr(netdev->perm_addr))
 
511
                dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
 
512
 
 
513
        return 0;
 
514
}
 
515
 
 
516
static int netxen_nic_set_mac(struct net_device *netdev, void *p)
 
517
{
 
518
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
519
        struct sockaddr *addr = p;
 
520
 
 
521
        if (!is_valid_ether_addr(addr->sa_data))
 
522
                return -EINVAL;
 
523
 
 
524
        if (netif_running(netdev)) {
 
525
                netif_device_detach(netdev);
 
526
                netxen_napi_disable(adapter);
 
527
        }
 
528
 
 
529
        memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
 
530
        memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
 
531
        adapter->macaddr_set(adapter, addr->sa_data);
 
532
 
 
533
        if (netif_running(netdev)) {
 
534
                netif_device_attach(netdev);
 
535
                netxen_napi_enable(adapter);
 
536
        }
 
537
        return 0;
 
538
}
 
539
 
 
540
static void netxen_set_multicast_list(struct net_device *dev)
 
541
{
 
542
        struct netxen_adapter *adapter = netdev_priv(dev);
 
543
 
 
544
        adapter->set_multi(dev);
 
545
}
 
546
 
 
547
static u32 netxen_fix_features(struct net_device *dev, u32 features)
 
548
{
 
549
        if (!(features & NETIF_F_RXCSUM)) {
 
550
                netdev_info(dev, "disabling LRO as RXCSUM is off\n");
 
551
 
 
552
                features &= ~NETIF_F_LRO;
 
553
        }
 
554
 
 
555
        return features;
 
556
}
 
557
 
 
558
static int netxen_set_features(struct net_device *dev, u32 features)
 
559
{
 
560
        struct netxen_adapter *adapter = netdev_priv(dev);
 
561
        int hw_lro;
 
562
 
 
563
        if (!((dev->features ^ features) & NETIF_F_LRO))
 
564
                return 0;
 
565
 
 
566
        hw_lro = (features & NETIF_F_LRO) ? NETXEN_NIC_LRO_ENABLED
 
567
                 : NETXEN_NIC_LRO_DISABLED;
 
568
 
 
569
        if (netxen_config_hw_lro(adapter, hw_lro))
 
570
                return -EIO;
 
571
 
 
572
        if (!(features & NETIF_F_LRO) && netxen_send_lro_cleanup(adapter))
 
573
                return -EIO;
 
574
 
 
575
        return 0;
 
576
}
 
577
 
 
578
static const struct net_device_ops netxen_netdev_ops = {
 
579
        .ndo_open          = netxen_nic_open,
 
580
        .ndo_stop          = netxen_nic_close,
 
581
        .ndo_start_xmit    = netxen_nic_xmit_frame,
 
582
        .ndo_get_stats64   = netxen_nic_get_stats,
 
583
        .ndo_validate_addr = eth_validate_addr,
 
584
        .ndo_set_rx_mode   = netxen_set_multicast_list,
 
585
        .ndo_set_mac_address    = netxen_nic_set_mac,
 
586
        .ndo_change_mtu    = netxen_nic_change_mtu,
 
587
        .ndo_tx_timeout    = netxen_tx_timeout,
 
588
        .ndo_fix_features = netxen_fix_features,
 
589
        .ndo_set_features = netxen_set_features,
 
590
#ifdef CONFIG_NET_POLL_CONTROLLER
 
591
        .ndo_poll_controller = netxen_nic_poll_controller,
 
592
#endif
 
593
};
 
594
 
 
595
static void
 
596
netxen_setup_intr(struct netxen_adapter *adapter)
 
597
{
 
598
        struct netxen_legacy_intr_set *legacy_intrp;
 
599
        struct pci_dev *pdev = adapter->pdev;
 
600
        int err, num_msix;
 
601
 
 
602
        if (adapter->rss_supported) {
 
603
                num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
 
604
                        MSIX_ENTRIES_PER_ADAPTER : 2;
 
605
        } else
 
606
                num_msix = 1;
 
607
 
 
608
        adapter->max_sds_rings = 1;
 
609
 
 
610
        adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
 
611
 
 
612
        if (adapter->ahw.revision_id >= NX_P3_B0)
 
613
                legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
 
614
        else
 
615
                legacy_intrp = &legacy_intr[0];
 
616
 
 
617
        adapter->int_vec_bit = legacy_intrp->int_vec_bit;
 
618
        adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
 
619
                        legacy_intrp->tgt_status_reg);
 
620
        adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
 
621
                        legacy_intrp->tgt_mask_reg);
 
622
        adapter->pci_int_reg = netxen_get_ioaddr(adapter,
 
623
                        legacy_intrp->pci_int_reg);
 
624
        adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
 
625
 
 
626
        if (adapter->ahw.revision_id >= NX_P3_B1)
 
627
                adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
 
628
                        ISR_INT_STATE_REG);
 
629
        else
 
630
                adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
 
631
                        CRB_INT_VECTOR);
 
632
 
 
633
        netxen_set_msix_bit(pdev, 0);
 
634
 
 
635
        if (adapter->msix_supported) {
 
636
 
 
637
                netxen_init_msix_entries(adapter, num_msix);
 
638
                err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
 
639
                if (err == 0) {
 
640
                        adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
 
641
                        netxen_set_msix_bit(pdev, 1);
 
642
 
 
643
                        if (adapter->rss_supported)
 
644
                                adapter->max_sds_rings = num_msix;
 
645
 
 
646
                        dev_info(&pdev->dev, "using msi-x interrupts\n");
 
647
                        return;
 
648
                }
 
649
 
 
650
                if (err > 0)
 
651
                        pci_disable_msix(pdev);
 
652
 
 
653
                /* fall through for msi */
 
654
        }
 
655
 
 
656
        if (use_msi && !pci_enable_msi(pdev)) {
 
657
                adapter->flags |= NETXEN_NIC_MSI_ENABLED;
 
658
                adapter->tgt_status_reg = netxen_get_ioaddr(adapter,
 
659
                                msi_tgt_status[adapter->ahw.pci_func]);
 
660
                dev_info(&pdev->dev, "using msi interrupts\n");
 
661
                adapter->msix_entries[0].vector = pdev->irq;
 
662
                return;
 
663
        }
 
664
 
 
665
        dev_info(&pdev->dev, "using legacy interrupts\n");
 
666
        adapter->msix_entries[0].vector = pdev->irq;
 
667
}
 
668
 
 
669
static void
 
670
netxen_teardown_intr(struct netxen_adapter *adapter)
 
671
{
 
672
        if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
 
673
                pci_disable_msix(adapter->pdev);
 
674
        if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
 
675
                pci_disable_msi(adapter->pdev);
 
676
}
 
677
 
 
678
static void
 
679
netxen_cleanup_pci_map(struct netxen_adapter *adapter)
 
680
{
 
681
        if (adapter->ahw.db_base != NULL)
 
682
                iounmap(adapter->ahw.db_base);
 
683
        if (adapter->ahw.pci_base0 != NULL)
 
684
                iounmap(adapter->ahw.pci_base0);
 
685
        if (adapter->ahw.pci_base1 != NULL)
 
686
                iounmap(adapter->ahw.pci_base1);
 
687
        if (adapter->ahw.pci_base2 != NULL)
 
688
                iounmap(adapter->ahw.pci_base2);
 
689
}
 
690
 
 
691
static int
 
692
netxen_setup_pci_map(struct netxen_adapter *adapter)
 
693
{
 
694
        void __iomem *db_ptr = NULL;
 
695
 
 
696
        resource_size_t mem_base, db_base;
 
697
        unsigned long mem_len, db_len = 0;
 
698
 
 
699
        struct pci_dev *pdev = adapter->pdev;
 
700
        int pci_func = adapter->ahw.pci_func;
 
701
        struct netxen_hardware_context *ahw = &adapter->ahw;
 
702
 
 
703
        int err = 0;
 
704
 
 
705
        /*
 
706
         * Set the CRB window to invalid. If any register in window 0 is
 
707
         * accessed it should set the window to 0 and then reset it to 1.
 
708
         */
 
709
        adapter->ahw.crb_win = -1;
 
710
        adapter->ahw.ocm_win = -1;
 
711
 
 
712
        /* remap phys address */
 
713
        mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
 
714
        mem_len = pci_resource_len(pdev, 0);
 
715
 
 
716
        /* 128 Meg of memory */
 
717
        if (mem_len == NETXEN_PCI_128MB_SIZE) {
 
718
 
 
719
                ahw->pci_base0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
 
720
                ahw->pci_base1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
 
721
                                SECOND_PAGE_GROUP_SIZE);
 
722
                ahw->pci_base2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
 
723
                                THIRD_PAGE_GROUP_SIZE);
 
724
                if (ahw->pci_base0 == NULL || ahw->pci_base1 == NULL ||
 
725
                                                ahw->pci_base2 == NULL) {
 
726
                        dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 
727
                        err = -EIO;
 
728
                        goto err_out;
 
729
                }
 
730
 
 
731
                ahw->pci_len0 = FIRST_PAGE_GROUP_SIZE;
 
732
 
 
733
        } else if (mem_len == NETXEN_PCI_32MB_SIZE) {
 
734
 
 
735
                ahw->pci_base1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
 
736
                ahw->pci_base2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
 
737
                        SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
 
738
                if (ahw->pci_base1 == NULL || ahw->pci_base2 == NULL) {
 
739
                        dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 
740
                        err = -EIO;
 
741
                        goto err_out;
 
742
                }
 
743
 
 
744
        } else if (mem_len == NETXEN_PCI_2MB_SIZE) {
 
745
 
 
746
                ahw->pci_base0 = pci_ioremap_bar(pdev, 0);
 
747
                if (ahw->pci_base0 == NULL) {
 
748
                        dev_err(&pdev->dev, "failed to map PCI bar 0\n");
 
749
                        return -EIO;
 
750
                }
 
751
                ahw->pci_len0 = mem_len;
 
752
        } else {
 
753
                return -EIO;
 
754
        }
 
755
 
 
756
        netxen_setup_hwops(adapter);
 
757
 
 
758
        dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
 
759
 
 
760
        if (NX_IS_REVISION_P3P(adapter->ahw.revision_id)) {
 
761
                adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
 
762
                        NETXEN_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(pci_func)));
 
763
 
 
764
        } else if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
765
                adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
 
766
                        NETXEN_PCIX_PS_REG(PCIE_MN_WINDOW_REG(pci_func)));
 
767
        }
 
768
 
 
769
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
770
                goto skip_doorbell;
 
771
 
 
772
        db_base = pci_resource_start(pdev, 4);  /* doorbell is on bar 4 */
 
773
        db_len = pci_resource_len(pdev, 4);
 
774
 
 
775
        if (db_len == 0) {
 
776
                printk(KERN_ERR "%s: doorbell is disabled\n",
 
777
                                netxen_nic_driver_name);
 
778
                err = -EIO;
 
779
                goto err_out;
 
780
        }
 
781
 
 
782
        db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
 
783
        if (!db_ptr) {
 
784
                printk(KERN_ERR "%s: Failed to allocate doorbell map.",
 
785
                                netxen_nic_driver_name);
 
786
                err = -EIO;
 
787
                goto err_out;
 
788
        }
 
789
 
 
790
skip_doorbell:
 
791
        adapter->ahw.db_base = db_ptr;
 
792
        adapter->ahw.db_len = db_len;
 
793
        return 0;
 
794
 
 
795
err_out:
 
796
        netxen_cleanup_pci_map(adapter);
 
797
        return err;
 
798
}
 
799
 
 
800
static void
 
801
netxen_check_options(struct netxen_adapter *adapter)
 
802
{
 
803
        u32 fw_major, fw_minor, fw_build;
 
804
        char brd_name[NETXEN_MAX_SHORT_NAME];
 
805
        char serial_num[32];
 
806
        int i, offset, val;
 
807
        int *ptr32;
 
808
        struct pci_dev *pdev = adapter->pdev;
 
809
 
 
810
        adapter->driver_mismatch = 0;
 
811
 
 
812
        ptr32 = (int *)&serial_num;
 
813
        offset = NX_FW_SERIAL_NUM_OFFSET;
 
814
        for (i = 0; i < 8; i++) {
 
815
                if (netxen_rom_fast_read(adapter, offset, &val) == -1) {
 
816
                        dev_err(&pdev->dev, "error reading board info\n");
 
817
                        adapter->driver_mismatch = 1;
 
818
                        return;
 
819
                }
 
820
                ptr32[i] = cpu_to_le32(val);
 
821
                offset += sizeof(u32);
 
822
        }
 
823
 
 
824
        fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
 
825
        fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
 
826
        fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
 
827
 
 
828
        adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
 
829
 
 
830
        if (adapter->portnum == 0) {
 
831
                get_brd_name_by_type(adapter->ahw.board_type, brd_name);
 
832
 
 
833
                pr_info("%s: %s Board S/N %s  Chip rev 0x%x\n",
 
834
                                module_name(THIS_MODULE),
 
835
                                brd_name, serial_num, adapter->ahw.revision_id);
 
836
        }
 
837
 
 
838
        if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
 
839
                adapter->driver_mismatch = 1;
 
840
                dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
 
841
                                fw_major, fw_minor, fw_build);
 
842
                return;
 
843
        }
 
844
 
 
845
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
846
                i = NXRD32(adapter, NETXEN_SRE_MISC);
 
847
                adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
 
848
        }
 
849
 
 
850
        dev_info(&pdev->dev, "firmware v%d.%d.%d [%s]\n",
 
851
                        fw_major, fw_minor, fw_build,
 
852
                        adapter->ahw.cut_through ? "cut-through" : "legacy");
 
853
 
 
854
        if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
 
855
                adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
 
856
 
 
857
        if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
 
858
                adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
 
859
                adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
 
860
        } else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
 
861
                adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
 
862
                adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
 
863
        }
 
864
 
 
865
        adapter->msix_supported = 0;
 
866
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
867
                adapter->msix_supported = !!use_msi_x;
 
868
                adapter->rss_supported = !!use_msi_x;
 
869
        } else {
 
870
                u32 flashed_ver = 0;
 
871
                netxen_rom_fast_read(adapter,
 
872
                                NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
 
873
                flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);
 
874
 
 
875
                if (flashed_ver >= NETXEN_VERSION_CODE(3, 4, 336)) {
 
876
                        switch (adapter->ahw.board_type) {
 
877
                        case NETXEN_BRDTYPE_P2_SB31_10G:
 
878
                        case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
 
879
                                adapter->msix_supported = !!use_msi_x;
 
880
                                adapter->rss_supported = !!use_msi_x;
 
881
                                break;
 
882
                        default:
 
883
                                break;
 
884
                        }
 
885
                }
 
886
        }
 
887
 
 
888
        adapter->num_txd = MAX_CMD_DESCRIPTORS;
 
889
 
 
890
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
891
                adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
 
892
                adapter->max_rds_rings = 3;
 
893
        } else {
 
894
                adapter->num_lro_rxd = 0;
 
895
                adapter->max_rds_rings = 2;
 
896
        }
 
897
}
 
898
 
 
899
static int
 
900
netxen_start_firmware(struct netxen_adapter *adapter)
 
901
{
 
902
        int val, err, first_boot;
 
903
        struct pci_dev *pdev = adapter->pdev;
 
904
 
 
905
        /* required for NX2031 dummy dma */
 
906
        err = nx_set_dma_mask(adapter);
 
907
        if (err)
 
908
                return err;
 
909
 
 
910
        if (!netxen_can_start_firmware(adapter))
 
911
                goto wait_init;
 
912
 
 
913
        first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
 
914
 
 
915
        err = netxen_check_hw_init(adapter, first_boot);
 
916
        if (err) {
 
917
                dev_err(&pdev->dev, "error in init HW init sequence\n");
 
918
                return err;
 
919
        }
 
920
 
 
921
        netxen_request_firmware(adapter);
 
922
 
 
923
        err = netxen_need_fw_reset(adapter);
 
924
        if (err < 0)
 
925
                goto err_out;
 
926
        if (err == 0)
 
927
                goto pcie_strap_init;
 
928
 
 
929
        if (first_boot != 0x55555555) {
 
930
                NXWR32(adapter, CRB_CMDPEG_STATE, 0);
 
931
                netxen_pinit_from_rom(adapter);
 
932
                msleep(1);
 
933
        }
 
934
 
 
935
        NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
 
936
        NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
 
937
        NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
 
938
 
 
939
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
940
                netxen_set_port_mode(adapter);
 
941
 
 
942
        err = netxen_load_firmware(adapter);
 
943
        if (err)
 
944
                goto err_out;
 
945
 
 
946
        netxen_release_firmware(adapter);
 
947
 
 
948
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
949
 
 
950
                /* Initialize multicast addr pool owners */
 
951
                val = 0x7654;
 
952
                if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
 
953
                        val |= 0x0f000000;
 
954
                NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
 
955
 
 
956
        }
 
957
 
 
958
        err = netxen_init_dummy_dma(adapter);
 
959
        if (err)
 
960
                goto err_out;
 
961
 
 
962
        /*
 
963
         * Tell the hardware our version number.
 
964
         */
 
965
        val = (_NETXEN_NIC_LINUX_MAJOR << 16)
 
966
                | ((_NETXEN_NIC_LINUX_MINOR << 8))
 
967
                | (_NETXEN_NIC_LINUX_SUBVERSION);
 
968
        NXWR32(adapter, CRB_DRIVER_VERSION, val);
 
969
 
 
970
pcie_strap_init:
 
971
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
972
                netxen_pcie_strap_init(adapter);
 
973
 
 
974
wait_init:
 
975
        /* Handshake with the card before we register the devices. */
 
976
        err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
 
977
        if (err) {
 
978
                netxen_free_dummy_dma(adapter);
 
979
                goto err_out;
 
980
        }
 
981
 
 
982
        NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
 
983
 
 
984
        nx_update_dma_mask(adapter);
 
985
 
 
986
        netxen_check_options(adapter);
 
987
 
 
988
        adapter->need_fw_reset = 0;
 
989
 
 
990
        /* fall through and release firmware */
 
991
 
 
992
err_out:
 
993
        netxen_release_firmware(adapter);
 
994
        return err;
 
995
}
 
996
 
 
997
static int
 
998
netxen_nic_request_irq(struct netxen_adapter *adapter)
 
999
{
 
1000
        irq_handler_t handler;
 
1001
        struct nx_host_sds_ring *sds_ring;
 
1002
        int err, ring;
 
1003
 
 
1004
        unsigned long flags = 0;
 
1005
        struct net_device *netdev = adapter->netdev;
 
1006
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
1007
 
 
1008
        if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
 
1009
                handler = netxen_msix_intr;
 
1010
        else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
 
1011
                handler = netxen_msi_intr;
 
1012
        else {
 
1013
                flags |= IRQF_SHARED;
 
1014
                handler = netxen_intr;
 
1015
        }
 
1016
        adapter->irq = netdev->irq;
 
1017
 
 
1018
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
1019
                sds_ring = &recv_ctx->sds_rings[ring];
 
1020
                sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
 
1021
                err = request_irq(sds_ring->irq, handler,
 
1022
                                  flags, sds_ring->name, sds_ring);
 
1023
                if (err)
 
1024
                        return err;
 
1025
        }
 
1026
 
 
1027
        return 0;
 
1028
}
 
1029
 
 
1030
static void
 
1031
netxen_nic_free_irq(struct netxen_adapter *adapter)
 
1032
{
 
1033
        int ring;
 
1034
        struct nx_host_sds_ring *sds_ring;
 
1035
 
 
1036
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
1037
 
 
1038
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
1039
                sds_ring = &recv_ctx->sds_rings[ring];
 
1040
                free_irq(sds_ring->irq, sds_ring);
 
1041
        }
 
1042
}
 
1043
 
 
1044
static void
 
1045
netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
 
1046
{
 
1047
        adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
 
1048
        adapter->coal.normal.data.rx_time_us =
 
1049
                NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
 
1050
        adapter->coal.normal.data.rx_packets =
 
1051
                NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
 
1052
        adapter->coal.normal.data.tx_time_us =
 
1053
                NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
 
1054
        adapter->coal.normal.data.tx_packets =
 
1055
                NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
 
1056
}
 
1057
 
 
1058
/* with rtnl_lock */
 
1059
static int
 
1060
__netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
 
1061
{
 
1062
        int err;
 
1063
 
 
1064
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
1065
                return -EIO;
 
1066
 
 
1067
        err = adapter->init_port(adapter, adapter->physical_port);
 
1068
        if (err) {
 
1069
                printk(KERN_ERR "%s: Failed to initialize port %d\n",
 
1070
                                netxen_nic_driver_name, adapter->portnum);
 
1071
                return err;
 
1072
        }
 
1073
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
1074
                adapter->macaddr_set(adapter, adapter->mac_addr);
 
1075
 
 
1076
        adapter->set_multi(netdev);
 
1077
        adapter->set_mtu(adapter, netdev->mtu);
 
1078
 
 
1079
        adapter->ahw.linkup = 0;
 
1080
 
 
1081
        if (adapter->max_sds_rings > 1)
 
1082
                netxen_config_rss(adapter, 1);
 
1083
 
 
1084
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
1085
                netxen_config_intr_coalesce(adapter);
 
1086
 
 
1087
        if (netdev->features & NETIF_F_LRO)
 
1088
                netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_ENABLED);
 
1089
 
 
1090
        netxen_napi_enable(adapter);
 
1091
 
 
1092
        if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
 
1093
                netxen_linkevent_request(adapter, 1);
 
1094
        else
 
1095
                netxen_nic_set_link_parameters(adapter);
 
1096
 
 
1097
        set_bit(__NX_DEV_UP, &adapter->state);
 
1098
        return 0;
 
1099
}
 
1100
 
 
1101
/* Usage: During resume and firmware recovery module.*/
 
1102
 
 
1103
static inline int
 
1104
netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
 
1105
{
 
1106
        int err = 0;
 
1107
 
 
1108
        rtnl_lock();
 
1109
        if (netif_running(netdev))
 
1110
                err = __netxen_nic_up(adapter, netdev);
 
1111
        rtnl_unlock();
 
1112
 
 
1113
        return err;
 
1114
}
 
1115
 
 
1116
/* with rtnl_lock */
 
1117
static void
 
1118
__netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
 
1119
{
 
1120
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
1121
                return;
 
1122
 
 
1123
        if (!test_and_clear_bit(__NX_DEV_UP, &adapter->state))
 
1124
                return;
 
1125
 
 
1126
        smp_mb();
 
1127
        spin_lock(&adapter->tx_clean_lock);
 
1128
        netif_carrier_off(netdev);
 
1129
        netif_tx_disable(netdev);
 
1130
 
 
1131
        if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
 
1132
                netxen_linkevent_request(adapter, 0);
 
1133
 
 
1134
        if (adapter->stop_port)
 
1135
                adapter->stop_port(adapter);
 
1136
 
 
1137
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
1138
                netxen_p3_free_mac_list(adapter);
 
1139
 
 
1140
        adapter->set_promisc(adapter, NETXEN_NIU_NON_PROMISC_MODE);
 
1141
 
 
1142
        netxen_napi_disable(adapter);
 
1143
 
 
1144
        netxen_release_tx_buffers(adapter);
 
1145
        spin_unlock(&adapter->tx_clean_lock);
 
1146
}
 
1147
 
 
1148
/* Usage: During suspend and firmware recovery module */
 
1149
 
 
1150
static inline void
 
1151
netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
 
1152
{
 
1153
        rtnl_lock();
 
1154
        if (netif_running(netdev))
 
1155
                __netxen_nic_down(adapter, netdev);
 
1156
        rtnl_unlock();
 
1157
 
 
1158
}
 
1159
 
 
1160
static int
 
1161
netxen_nic_attach(struct netxen_adapter *adapter)
 
1162
{
 
1163
        struct net_device *netdev = adapter->netdev;
 
1164
        struct pci_dev *pdev = adapter->pdev;
 
1165
        int err, ring;
 
1166
        struct nx_host_rds_ring *rds_ring;
 
1167
        struct nx_host_tx_ring *tx_ring;
 
1168
 
 
1169
        if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
 
1170
                return 0;
 
1171
 
 
1172
        err = netxen_init_firmware(adapter);
 
1173
        if (err)
 
1174
                return err;
 
1175
 
 
1176
        err = netxen_napi_add(adapter, netdev);
 
1177
        if (err)
 
1178
                return err;
 
1179
 
 
1180
        err = netxen_alloc_sw_resources(adapter);
 
1181
        if (err) {
 
1182
                printk(KERN_ERR "%s: Error in setting sw resources\n",
 
1183
                                netdev->name);
 
1184
                return err;
 
1185
        }
 
1186
 
 
1187
        err = netxen_alloc_hw_resources(adapter);
 
1188
        if (err) {
 
1189
                printk(KERN_ERR "%s: Error in setting hw resources\n",
 
1190
                                netdev->name);
 
1191
                goto err_out_free_sw;
 
1192
        }
 
1193
 
 
1194
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
1195
                tx_ring = adapter->tx_ring;
 
1196
                tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
 
1197
                                crb_cmd_producer[adapter->portnum]);
 
1198
                tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
 
1199
                                crb_cmd_consumer[adapter->portnum]);
 
1200
 
 
1201
                tx_ring->producer = 0;
 
1202
                tx_ring->sw_consumer = 0;
 
1203
 
 
1204
                netxen_nic_update_cmd_producer(adapter, tx_ring);
 
1205
                netxen_nic_update_cmd_consumer(adapter, tx_ring);
 
1206
        }
 
1207
 
 
1208
        for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 
1209
                rds_ring = &adapter->recv_ctx.rds_rings[ring];
 
1210
                netxen_post_rx_buffers(adapter, ring, rds_ring);
 
1211
        }
 
1212
 
 
1213
        err = netxen_nic_request_irq(adapter);
 
1214
        if (err) {
 
1215
                dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
 
1216
                                netdev->name);
 
1217
                goto err_out_free_rxbuf;
 
1218
        }
 
1219
 
 
1220
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
1221
                netxen_nic_init_coalesce_defaults(adapter);
 
1222
 
 
1223
        netxen_create_sysfs_entries(adapter);
 
1224
 
 
1225
        adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
 
1226
        return 0;
 
1227
 
 
1228
err_out_free_rxbuf:
 
1229
        netxen_release_rx_buffers(adapter);
 
1230
        netxen_free_hw_resources(adapter);
 
1231
err_out_free_sw:
 
1232
        netxen_free_sw_resources(adapter);
 
1233
        return err;
 
1234
}
 
1235
 
 
1236
static void
 
1237
netxen_nic_detach(struct netxen_adapter *adapter)
 
1238
{
 
1239
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
1240
                return;
 
1241
 
 
1242
        netxen_remove_sysfs_entries(adapter);
 
1243
 
 
1244
        netxen_free_hw_resources(adapter);
 
1245
        netxen_release_rx_buffers(adapter);
 
1246
        netxen_nic_free_irq(adapter);
 
1247
        netxen_napi_del(adapter);
 
1248
        netxen_free_sw_resources(adapter);
 
1249
 
 
1250
        adapter->is_up = 0;
 
1251
}
 
1252
 
 
1253
int
 
1254
netxen_nic_reset_context(struct netxen_adapter *adapter)
 
1255
{
 
1256
        int err = 0;
 
1257
        struct net_device *netdev = adapter->netdev;
 
1258
 
 
1259
        if (test_and_set_bit(__NX_RESETTING, &adapter->state))
 
1260
                return -EBUSY;
 
1261
 
 
1262
        if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
 
1263
 
 
1264
                netif_device_detach(netdev);
 
1265
 
 
1266
                if (netif_running(netdev))
 
1267
                        __netxen_nic_down(adapter, netdev);
 
1268
 
 
1269
                netxen_nic_detach(adapter);
 
1270
 
 
1271
                if (netif_running(netdev)) {
 
1272
                        err = netxen_nic_attach(adapter);
 
1273
                        if (!err)
 
1274
                                err = __netxen_nic_up(adapter, netdev);
 
1275
 
 
1276
                        if (err)
 
1277
                                goto done;
 
1278
                }
 
1279
 
 
1280
                netif_device_attach(netdev);
 
1281
        }
 
1282
 
 
1283
done:
 
1284
        clear_bit(__NX_RESETTING, &adapter->state);
 
1285
        return err;
 
1286
}
 
1287
 
 
1288
static int
 
1289
netxen_setup_netdev(struct netxen_adapter *adapter,
 
1290
                struct net_device *netdev)
 
1291
{
 
1292
        int err = 0;
 
1293
        struct pci_dev *pdev = adapter->pdev;
 
1294
 
 
1295
        adapter->mc_enabled = 0;
 
1296
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
1297
                adapter->max_mc_count = 38;
 
1298
        else
 
1299
                adapter->max_mc_count = 16;
 
1300
 
 
1301
        netdev->netdev_ops         = &netxen_netdev_ops;
 
1302
        netdev->watchdog_timeo     = 5*HZ;
 
1303
 
 
1304
        netxen_nic_change_mtu(netdev, netdev->mtu);
 
1305
 
 
1306
        SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
 
1307
 
 
1308
        netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
 
1309
                              NETIF_F_RXCSUM;
 
1310
 
 
1311
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
 
1312
                netdev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
 
1313
 
 
1314
        netdev->vlan_features |= netdev->hw_features;
 
1315
 
 
1316
        if (adapter->pci_using_dac) {
 
1317
                netdev->features |= NETIF_F_HIGHDMA;
 
1318
                netdev->vlan_features |= NETIF_F_HIGHDMA;
 
1319
        }
 
1320
 
 
1321
        if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
 
1322
                netdev->hw_features |= NETIF_F_HW_VLAN_TX;
 
1323
 
 
1324
        if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
 
1325
                netdev->hw_features |= NETIF_F_LRO;
 
1326
 
 
1327
        netdev->features |= netdev->hw_features;
 
1328
 
 
1329
        netdev->irq = adapter->msix_entries[0].vector;
 
1330
 
 
1331
        INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
 
1332
 
 
1333
        if (netxen_read_mac_addr(adapter))
 
1334
                dev_warn(&pdev->dev, "failed to read mac addr\n");
 
1335
 
 
1336
        netif_carrier_off(netdev);
 
1337
 
 
1338
        err = register_netdev(netdev);
 
1339
        if (err) {
 
1340
                dev_err(&pdev->dev, "failed to register net device\n");
 
1341
                return err;
 
1342
        }
 
1343
 
 
1344
        return 0;
 
1345
}
 
1346
 
 
1347
#ifdef CONFIG_PCIEAER
 
1348
static void netxen_mask_aer_correctable(struct netxen_adapter *adapter)
 
1349
{
 
1350
        struct pci_dev *pdev = adapter->pdev;
 
1351
        struct pci_dev *root = pdev->bus->self;
 
1352
        u32 aer_pos;
 
1353
 
 
1354
        if (adapter->ahw.board_type != NETXEN_BRDTYPE_P3_4_GB_MM &&
 
1355
                adapter->ahw.board_type != NETXEN_BRDTYPE_P3_10G_TP)
 
1356
                return;
 
1357
 
 
1358
        if (root->pcie_type != PCI_EXP_TYPE_ROOT_PORT)
 
1359
                return;
 
1360
 
 
1361
        aer_pos = pci_find_ext_capability(root, PCI_EXT_CAP_ID_ERR);
 
1362
        if (!aer_pos)
 
1363
                return;
 
1364
 
 
1365
        pci_write_config_dword(root, aer_pos + PCI_ERR_COR_MASK, 0xffff);
 
1366
}
 
1367
#endif
 
1368
 
 
1369
static int __devinit
 
1370
netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
1371
{
 
1372
        struct net_device *netdev = NULL;
 
1373
        struct netxen_adapter *adapter = NULL;
 
1374
        int i = 0, err;
 
1375
        int pci_func_id = PCI_FUNC(pdev->devfn);
 
1376
        uint8_t revision_id;
 
1377
        u32 val;
 
1378
 
 
1379
        if (pdev->revision >= NX_P3_A0 && pdev->revision <= NX_P3_B1) {
 
1380
                pr_warning("%s: chip revisions between 0x%x-0x%x "
 
1381
                                "will not be enabled.\n",
 
1382
                                module_name(THIS_MODULE), NX_P3_A0, NX_P3_B1);
 
1383
                return -ENODEV;
 
1384
        }
 
1385
 
 
1386
        if ((err = pci_enable_device(pdev)))
 
1387
                return err;
 
1388
 
 
1389
        if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
 
1390
                err = -ENODEV;
 
1391
                goto err_out_disable_pdev;
 
1392
        }
 
1393
 
 
1394
        if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
 
1395
                goto err_out_disable_pdev;
 
1396
 
 
1397
        if (NX_IS_REVISION_P3(pdev->revision))
 
1398
                pci_enable_pcie_error_reporting(pdev);
 
1399
 
 
1400
        pci_set_master(pdev);
 
1401
 
 
1402
        netdev = alloc_etherdev(sizeof(struct netxen_adapter));
 
1403
        if(!netdev) {
 
1404
                dev_err(&pdev->dev, "failed to allocate net_device\n");
 
1405
                err = -ENOMEM;
 
1406
                goto err_out_free_res;
 
1407
        }
 
1408
 
 
1409
        SET_NETDEV_DEV(netdev, &pdev->dev);
 
1410
 
 
1411
        adapter = netdev_priv(netdev);
 
1412
        adapter->netdev  = netdev;
 
1413
        adapter->pdev    = pdev;
 
1414
        adapter->ahw.pci_func  = pci_func_id;
 
1415
 
 
1416
        revision_id = pdev->revision;
 
1417
        adapter->ahw.revision_id = revision_id;
 
1418
 
 
1419
        rwlock_init(&adapter->ahw.crb_lock);
 
1420
        spin_lock_init(&adapter->ahw.mem_lock);
 
1421
 
 
1422
        spin_lock_init(&adapter->tx_clean_lock);
 
1423
        INIT_LIST_HEAD(&adapter->mac_list);
 
1424
        INIT_LIST_HEAD(&adapter->vlan_ip_list);
 
1425
 
 
1426
        err = netxen_setup_pci_map(adapter);
 
1427
        if (err)
 
1428
                goto err_out_free_netdev;
 
1429
 
 
1430
        /* This will be reset for mezz cards  */
 
1431
        adapter->portnum = pci_func_id;
 
1432
 
 
1433
        err = netxen_nic_get_board_info(adapter);
 
1434
        if (err) {
 
1435
                dev_err(&pdev->dev, "Error getting board config info.\n");
 
1436
                goto err_out_iounmap;
 
1437
        }
 
1438
 
 
1439
#ifdef CONFIG_PCIEAER
 
1440
        netxen_mask_aer_correctable(adapter);
 
1441
#endif
 
1442
 
 
1443
        /* Mezz cards have PCI function 0,2,3 enabled */
 
1444
        switch (adapter->ahw.board_type) {
 
1445
        case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
 
1446
        case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
 
1447
                if (pci_func_id >= 2)
 
1448
                        adapter->portnum = pci_func_id - 2;
 
1449
                break;
 
1450
        default:
 
1451
                break;
 
1452
        }
 
1453
 
 
1454
        err = netxen_check_flash_fw_compatibility(adapter);
 
1455
        if (err)
 
1456
                goto err_out_iounmap;
 
1457
 
 
1458
        if (adapter->portnum == 0) {
 
1459
                val = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
 
1460
                if (val != 0xffffffff && val != 0) {
 
1461
                        NXWR32(adapter, NX_CRB_DEV_REF_COUNT, 0);
 
1462
                        adapter->need_fw_reset = 1;
 
1463
                }
 
1464
        }
 
1465
 
 
1466
        err = netxen_start_firmware(adapter);
 
1467
        if (err)
 
1468
                goto err_out_decr_ref;
 
1469
 
 
1470
        /*
 
1471
         * See if the firmware gave us a virtual-physical port mapping.
 
1472
         */
 
1473
        adapter->physical_port = adapter->portnum;
 
1474
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
1475
                i = NXRD32(adapter, CRB_V2P(adapter->portnum));
 
1476
                if (i != 0x55555555)
 
1477
                        adapter->physical_port = i;
 
1478
        }
 
1479
 
 
1480
        netxen_nic_clear_stats(adapter);
 
1481
 
 
1482
        netxen_setup_intr(adapter);
 
1483
 
 
1484
        err = netxen_setup_netdev(adapter, netdev);
 
1485
        if (err)
 
1486
                goto err_out_disable_msi;
 
1487
 
 
1488
        pci_set_drvdata(pdev, adapter);
 
1489
 
 
1490
        netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
 
1491
 
 
1492
        switch (adapter->ahw.port_type) {
 
1493
        case NETXEN_NIC_GBE:
 
1494
                dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
 
1495
                                adapter->netdev->name);
 
1496
                break;
 
1497
        case NETXEN_NIC_XGBE:
 
1498
                dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
 
1499
                                adapter->netdev->name);
 
1500
                break;
 
1501
        }
 
1502
 
 
1503
        netxen_create_diag_entries(adapter);
 
1504
 
 
1505
        return 0;
 
1506
 
 
1507
err_out_disable_msi:
 
1508
        netxen_teardown_intr(adapter);
 
1509
 
 
1510
        netxen_free_dummy_dma(adapter);
 
1511
 
 
1512
err_out_decr_ref:
 
1513
        nx_decr_dev_ref_cnt(adapter);
 
1514
 
 
1515
err_out_iounmap:
 
1516
        netxen_cleanup_pci_map(adapter);
 
1517
 
 
1518
err_out_free_netdev:
 
1519
        free_netdev(netdev);
 
1520
 
 
1521
err_out_free_res:
 
1522
        pci_release_regions(pdev);
 
1523
 
 
1524
err_out_disable_pdev:
 
1525
        pci_set_drvdata(pdev, NULL);
 
1526
        pci_disable_device(pdev);
 
1527
        return err;
 
1528
}
 
1529
 
 
1530
static void __devexit netxen_nic_remove(struct pci_dev *pdev)
 
1531
{
 
1532
        struct netxen_adapter *adapter;
 
1533
        struct net_device *netdev;
 
1534
 
 
1535
        adapter = pci_get_drvdata(pdev);
 
1536
        if (adapter == NULL)
 
1537
                return;
 
1538
 
 
1539
        netdev = adapter->netdev;
 
1540
 
 
1541
        netxen_cancel_fw_work(adapter);
 
1542
 
 
1543
        unregister_netdev(netdev);
 
1544
 
 
1545
        cancel_work_sync(&adapter->tx_timeout_task);
 
1546
 
 
1547
        netxen_free_vlan_ip_list(adapter);
 
1548
        netxen_nic_detach(adapter);
 
1549
 
 
1550
        nx_decr_dev_ref_cnt(adapter);
 
1551
 
 
1552
        if (adapter->portnum == 0)
 
1553
                netxen_free_dummy_dma(adapter);
 
1554
 
 
1555
        clear_bit(__NX_RESETTING, &adapter->state);
 
1556
 
 
1557
        netxen_teardown_intr(adapter);
 
1558
 
 
1559
        netxen_remove_diag_entries(adapter);
 
1560
 
 
1561
        netxen_cleanup_pci_map(adapter);
 
1562
 
 
1563
        netxen_release_firmware(adapter);
 
1564
 
 
1565
        if (NX_IS_REVISION_P3(pdev->revision))
 
1566
                pci_disable_pcie_error_reporting(pdev);
 
1567
 
 
1568
        pci_release_regions(pdev);
 
1569
        pci_disable_device(pdev);
 
1570
        pci_set_drvdata(pdev, NULL);
 
1571
 
 
1572
        free_netdev(netdev);
 
1573
}
 
1574
 
 
1575
static void netxen_nic_detach_func(struct netxen_adapter *adapter)
 
1576
{
 
1577
        struct net_device *netdev = adapter->netdev;
 
1578
 
 
1579
        netif_device_detach(netdev);
 
1580
 
 
1581
        netxen_cancel_fw_work(adapter);
 
1582
 
 
1583
        if (netif_running(netdev))
 
1584
                netxen_nic_down(adapter, netdev);
 
1585
 
 
1586
        cancel_work_sync(&adapter->tx_timeout_task);
 
1587
 
 
1588
        netxen_nic_detach(adapter);
 
1589
 
 
1590
        if (adapter->portnum == 0)
 
1591
                netxen_free_dummy_dma(adapter);
 
1592
 
 
1593
        nx_decr_dev_ref_cnt(adapter);
 
1594
 
 
1595
        clear_bit(__NX_RESETTING, &adapter->state);
 
1596
}
 
1597
 
 
1598
static int netxen_nic_attach_func(struct pci_dev *pdev)
 
1599
{
 
1600
        struct netxen_adapter *adapter = pci_get_drvdata(pdev);
 
1601
        struct net_device *netdev = adapter->netdev;
 
1602
        int err;
 
1603
 
 
1604
        err = pci_enable_device(pdev);
 
1605
        if (err)
 
1606
                return err;
 
1607
 
 
1608
        pci_set_power_state(pdev, PCI_D0);
 
1609
        pci_set_master(pdev);
 
1610
        pci_restore_state(pdev);
 
1611
 
 
1612
        adapter->ahw.crb_win = -1;
 
1613
        adapter->ahw.ocm_win = -1;
 
1614
 
 
1615
        err = netxen_start_firmware(adapter);
 
1616
        if (err) {
 
1617
                dev_err(&pdev->dev, "failed to start firmware\n");
 
1618
                return err;
 
1619
        }
 
1620
 
 
1621
        if (netif_running(netdev)) {
 
1622
                err = netxen_nic_attach(adapter);
 
1623
                if (err)
 
1624
                        goto err_out;
 
1625
 
 
1626
                err = netxen_nic_up(adapter, netdev);
 
1627
                if (err)
 
1628
                        goto err_out_detach;
 
1629
 
 
1630
                netxen_restore_indev_addr(netdev, NETDEV_UP);
 
1631
        }
 
1632
 
 
1633
        netif_device_attach(netdev);
 
1634
        netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
 
1635
        return 0;
 
1636
 
 
1637
err_out_detach:
 
1638
        netxen_nic_detach(adapter);
 
1639
err_out:
 
1640
        nx_decr_dev_ref_cnt(adapter);
 
1641
        return err;
 
1642
}
 
1643
 
 
1644
static pci_ers_result_t netxen_io_error_detected(struct pci_dev *pdev,
 
1645
                                                pci_channel_state_t state)
 
1646
{
 
1647
        struct netxen_adapter *adapter = pci_get_drvdata(pdev);
 
1648
 
 
1649
        if (state == pci_channel_io_perm_failure)
 
1650
                return PCI_ERS_RESULT_DISCONNECT;
 
1651
 
 
1652
        if (nx_dev_request_aer(adapter))
 
1653
                return PCI_ERS_RESULT_RECOVERED;
 
1654
 
 
1655
        netxen_nic_detach_func(adapter);
 
1656
 
 
1657
        pci_disable_device(pdev);
 
1658
 
 
1659
        return PCI_ERS_RESULT_NEED_RESET;
 
1660
}
 
1661
 
 
1662
static pci_ers_result_t netxen_io_slot_reset(struct pci_dev *pdev)
 
1663
{
 
1664
        int err = 0;
 
1665
 
 
1666
        err = netxen_nic_attach_func(pdev);
 
1667
 
 
1668
        return err ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
 
1669
}
 
1670
 
 
1671
static void netxen_io_resume(struct pci_dev *pdev)
 
1672
{
 
1673
        pci_cleanup_aer_uncorrect_error_status(pdev);
 
1674
}
 
1675
 
 
1676
static void netxen_nic_shutdown(struct pci_dev *pdev)
 
1677
{
 
1678
        struct netxen_adapter *adapter = pci_get_drvdata(pdev);
 
1679
 
 
1680
        netxen_nic_detach_func(adapter);
 
1681
 
 
1682
        if (pci_save_state(pdev))
 
1683
                return;
 
1684
 
 
1685
        if (netxen_nic_wol_supported(adapter)) {
 
1686
                pci_enable_wake(pdev, PCI_D3cold, 1);
 
1687
                pci_enable_wake(pdev, PCI_D3hot, 1);
 
1688
        }
 
1689
 
 
1690
        pci_disable_device(pdev);
 
1691
}
 
1692
 
 
1693
#ifdef CONFIG_PM
 
1694
static int
 
1695
netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
 
1696
{
 
1697
        struct netxen_adapter *adapter = pci_get_drvdata(pdev);
 
1698
        int retval;
 
1699
 
 
1700
        netxen_nic_detach_func(adapter);
 
1701
 
 
1702
        retval = pci_save_state(pdev);
 
1703
        if (retval)
 
1704
                return retval;
 
1705
 
 
1706
        if (netxen_nic_wol_supported(adapter)) {
 
1707
                pci_enable_wake(pdev, PCI_D3cold, 1);
 
1708
                pci_enable_wake(pdev, PCI_D3hot, 1);
 
1709
        }
 
1710
 
 
1711
        pci_disable_device(pdev);
 
1712
        pci_set_power_state(pdev, pci_choose_state(pdev, state));
 
1713
 
 
1714
        return 0;
 
1715
}
 
1716
 
 
1717
static int
 
1718
netxen_nic_resume(struct pci_dev *pdev)
 
1719
{
 
1720
        return netxen_nic_attach_func(pdev);
 
1721
}
 
1722
#endif
 
1723
 
 
1724
static int netxen_nic_open(struct net_device *netdev)
 
1725
{
 
1726
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
1727
        int err = 0;
 
1728
 
 
1729
        if (adapter->driver_mismatch)
 
1730
                return -EIO;
 
1731
 
 
1732
        err = netxen_nic_attach(adapter);
 
1733
        if (err)
 
1734
                return err;
 
1735
 
 
1736
        err = __netxen_nic_up(adapter, netdev);
 
1737
        if (err)
 
1738
                goto err_out;
 
1739
 
 
1740
        netif_start_queue(netdev);
 
1741
 
 
1742
        return 0;
 
1743
 
 
1744
err_out:
 
1745
        netxen_nic_detach(adapter);
 
1746
        return err;
 
1747
}
 
1748
 
 
1749
/*
 
1750
 * netxen_nic_close - Disables a network interface entry point
 
1751
 */
 
1752
static int netxen_nic_close(struct net_device *netdev)
 
1753
{
 
1754
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
1755
 
 
1756
        __netxen_nic_down(adapter, netdev);
 
1757
        return 0;
 
1758
}
 
1759
 
 
1760
static void
 
1761
netxen_tso_check(struct net_device *netdev,
 
1762
                struct nx_host_tx_ring *tx_ring,
 
1763
                struct cmd_desc_type0 *first_desc,
 
1764
                struct sk_buff *skb)
 
1765
{
 
1766
        u8 opcode = TX_ETHER_PKT;
 
1767
        __be16 protocol = skb->protocol;
 
1768
        u16 flags = 0, vid = 0;
 
1769
        u32 producer;
 
1770
        int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
 
1771
        struct cmd_desc_type0 *hwdesc;
 
1772
        struct vlan_ethhdr *vh;
 
1773
 
 
1774
        if (protocol == cpu_to_be16(ETH_P_8021Q)) {
 
1775
 
 
1776
                vh = (struct vlan_ethhdr *)skb->data;
 
1777
                protocol = vh->h_vlan_encapsulated_proto;
 
1778
                flags = FLAGS_VLAN_TAGGED;
 
1779
 
 
1780
        } else if (vlan_tx_tag_present(skb)) {
 
1781
 
 
1782
                flags = FLAGS_VLAN_OOB;
 
1783
                vid = vlan_tx_tag_get(skb);
 
1784
                netxen_set_tx_vlan_tci(first_desc, vid);
 
1785
                vlan_oob = 1;
 
1786
        }
 
1787
 
 
1788
        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
 
1789
                        skb_shinfo(skb)->gso_size > 0) {
 
1790
 
 
1791
                hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
 
1792
 
 
1793
                first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
 
1794
                first_desc->total_hdr_length = hdr_len;
 
1795
                if (vlan_oob) {
 
1796
                        first_desc->total_hdr_length += VLAN_HLEN;
 
1797
                        first_desc->tcp_hdr_offset = VLAN_HLEN;
 
1798
                        first_desc->ip_hdr_offset = VLAN_HLEN;
 
1799
                        /* Only in case of TSO on vlan device */
 
1800
                        flags |= FLAGS_VLAN_TAGGED;
 
1801
                }
 
1802
 
 
1803
                opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
 
1804
                                TX_TCP_LSO6 : TX_TCP_LSO;
 
1805
                tso = 1;
 
1806
 
 
1807
        } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
 
1808
                u8 l4proto;
 
1809
 
 
1810
                if (protocol == cpu_to_be16(ETH_P_IP)) {
 
1811
                        l4proto = ip_hdr(skb)->protocol;
 
1812
 
 
1813
                        if (l4proto == IPPROTO_TCP)
 
1814
                                opcode = TX_TCP_PKT;
 
1815
                        else if(l4proto == IPPROTO_UDP)
 
1816
                                opcode = TX_UDP_PKT;
 
1817
                } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
 
1818
                        l4proto = ipv6_hdr(skb)->nexthdr;
 
1819
 
 
1820
                        if (l4proto == IPPROTO_TCP)
 
1821
                                opcode = TX_TCPV6_PKT;
 
1822
                        else if(l4proto == IPPROTO_UDP)
 
1823
                                opcode = TX_UDPV6_PKT;
 
1824
                }
 
1825
        }
 
1826
 
 
1827
        first_desc->tcp_hdr_offset += skb_transport_offset(skb);
 
1828
        first_desc->ip_hdr_offset += skb_network_offset(skb);
 
1829
        netxen_set_tx_flags_opcode(first_desc, flags, opcode);
 
1830
 
 
1831
        if (!tso)
 
1832
                return;
 
1833
 
 
1834
        /* For LSO, we need to copy the MAC/IP/TCP headers into
 
1835
         * the descriptor ring
 
1836
         */
 
1837
        producer = tx_ring->producer;
 
1838
        copied = 0;
 
1839
        offset = 2;
 
1840
 
 
1841
        if (vlan_oob) {
 
1842
                /* Create a TSO vlan header template for firmware */
 
1843
 
 
1844
                hwdesc = &tx_ring->desc_head[producer];
 
1845
                tx_ring->cmd_buf_arr[producer].skb = NULL;
 
1846
 
 
1847
                copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
 
1848
                                hdr_len + VLAN_HLEN);
 
1849
 
 
1850
                vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
 
1851
                skb_copy_from_linear_data(skb, vh, 12);
 
1852
                vh->h_vlan_proto = htons(ETH_P_8021Q);
 
1853
                vh->h_vlan_TCI = htons(vid);
 
1854
                skb_copy_from_linear_data_offset(skb, 12,
 
1855
                                (char *)vh + 16, copy_len - 16);
 
1856
 
 
1857
                copied = copy_len - VLAN_HLEN;
 
1858
                offset = 0;
 
1859
 
 
1860
                producer = get_next_index(producer, tx_ring->num_desc);
 
1861
        }
 
1862
 
 
1863
        while (copied < hdr_len) {
 
1864
 
 
1865
                copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
 
1866
                                (hdr_len - copied));
 
1867
 
 
1868
                hwdesc = &tx_ring->desc_head[producer];
 
1869
                tx_ring->cmd_buf_arr[producer].skb = NULL;
 
1870
 
 
1871
                skb_copy_from_linear_data_offset(skb, copied,
 
1872
                                 (char *)hwdesc + offset, copy_len);
 
1873
 
 
1874
                copied += copy_len;
 
1875
                offset = 0;
 
1876
 
 
1877
                producer = get_next_index(producer, tx_ring->num_desc);
 
1878
        }
 
1879
 
 
1880
        tx_ring->producer = producer;
 
1881
        barrier();
 
1882
}
 
1883
 
 
1884
static int
 
1885
netxen_map_tx_skb(struct pci_dev *pdev,
 
1886
                struct sk_buff *skb, struct netxen_cmd_buffer *pbuf)
 
1887
{
 
1888
        struct netxen_skb_frag *nf;
 
1889
        struct skb_frag_struct *frag;
 
1890
        int i, nr_frags;
 
1891
        dma_addr_t map;
 
1892
 
 
1893
        nr_frags = skb_shinfo(skb)->nr_frags;
 
1894
        nf = &pbuf->frag_array[0];
 
1895
 
 
1896
        map = pci_map_single(pdev, skb->data,
 
1897
                        skb_headlen(skb), PCI_DMA_TODEVICE);
 
1898
        if (pci_dma_mapping_error(pdev, map))
 
1899
                goto out_err;
 
1900
 
 
1901
        nf->dma = map;
 
1902
        nf->length = skb_headlen(skb);
 
1903
 
 
1904
        for (i = 0; i < nr_frags; i++) {
 
1905
                frag = &skb_shinfo(skb)->frags[i];
 
1906
                nf = &pbuf->frag_array[i+1];
 
1907
 
 
1908
                map = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
 
1909
                                       DMA_TO_DEVICE);
 
1910
                if (dma_mapping_error(&pdev->dev, map))
 
1911
                        goto unwind;
 
1912
 
 
1913
                nf->dma = map;
 
1914
                nf->length = skb_frag_size(frag);
 
1915
        }
 
1916
 
 
1917
        return 0;
 
1918
 
 
1919
unwind:
 
1920
        while (--i >= 0) {
 
1921
                nf = &pbuf->frag_array[i+1];
 
1922
                pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
 
1923
        }
 
1924
 
 
1925
        nf = &pbuf->frag_array[0];
 
1926
        pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
 
1927
 
 
1928
out_err:
 
1929
        return -ENOMEM;
 
1930
}
 
1931
 
 
1932
static inline void
 
1933
netxen_clear_cmddesc(u64 *desc)
 
1934
{
 
1935
        desc[0] = 0ULL;
 
1936
        desc[2] = 0ULL;
 
1937
}
 
1938
 
 
1939
static netdev_tx_t
 
1940
netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
 
1941
{
 
1942
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
1943
        struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
 
1944
        struct netxen_cmd_buffer *pbuf;
 
1945
        struct netxen_skb_frag *buffrag;
 
1946
        struct cmd_desc_type0 *hwdesc, *first_desc;
 
1947
        struct pci_dev *pdev;
 
1948
        int i, k;
 
1949
        int delta = 0;
 
1950
        struct skb_frag_struct *frag;
 
1951
 
 
1952
        u32 producer;
 
1953
        int frag_count, no_of_desc;
 
1954
        u32 num_txd = tx_ring->num_desc;
 
1955
 
 
1956
        frag_count = skb_shinfo(skb)->nr_frags + 1;
 
1957
 
 
1958
        /* 14 frags supported for normal packet and
 
1959
         * 32 frags supported for TSO packet
 
1960
         */
 
1961
        if (!skb_is_gso(skb) && frag_count > NETXEN_MAX_FRAGS_PER_TX) {
 
1962
 
 
1963
                for (i = 0; i < (frag_count - NETXEN_MAX_FRAGS_PER_TX); i++) {
 
1964
                        frag = &skb_shinfo(skb)->frags[i];
 
1965
                        delta += skb_frag_size(frag);
 
1966
                }
 
1967
 
 
1968
                if (!__pskb_pull_tail(skb, delta))
 
1969
                        goto drop_packet;
 
1970
 
 
1971
                frag_count = 1 + skb_shinfo(skb)->nr_frags;
 
1972
        }
 
1973
        /* 4 fragments per cmd des */
 
1974
        no_of_desc = (frag_count + 3) >> 2;
 
1975
 
 
1976
        if (unlikely(netxen_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
 
1977
                netif_stop_queue(netdev);
 
1978
                smp_mb();
 
1979
                if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
 
1980
                        netif_start_queue(netdev);
 
1981
                else
 
1982
                        return NETDEV_TX_BUSY;
 
1983
        }
 
1984
 
 
1985
        producer = tx_ring->producer;
 
1986
        pbuf = &tx_ring->cmd_buf_arr[producer];
 
1987
 
 
1988
        pdev = adapter->pdev;
 
1989
 
 
1990
        if (netxen_map_tx_skb(pdev, skb, pbuf))
 
1991
                goto drop_packet;
 
1992
 
 
1993
        pbuf->skb = skb;
 
1994
        pbuf->frag_count = frag_count;
 
1995
 
 
1996
        first_desc = hwdesc = &tx_ring->desc_head[producer];
 
1997
        netxen_clear_cmddesc((u64 *)hwdesc);
 
1998
 
 
1999
        netxen_set_tx_frags_len(first_desc, frag_count, skb->len);
 
2000
        netxen_set_tx_port(first_desc, adapter->portnum);
 
2001
 
 
2002
        for (i = 0; i < frag_count; i++) {
 
2003
 
 
2004
                k = i % 4;
 
2005
 
 
2006
                if ((k == 0) && (i > 0)) {
 
2007
                        /* move to next desc.*/
 
2008
                        producer = get_next_index(producer, num_txd);
 
2009
                        hwdesc = &tx_ring->desc_head[producer];
 
2010
                        netxen_clear_cmddesc((u64 *)hwdesc);
 
2011
                        tx_ring->cmd_buf_arr[producer].skb = NULL;
 
2012
                }
 
2013
 
 
2014
                buffrag = &pbuf->frag_array[i];
 
2015
 
 
2016
                hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
 
2017
                switch (k) {
 
2018
                case 0:
 
2019
                        hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
 
2020
                        break;
 
2021
                case 1:
 
2022
                        hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
 
2023
                        break;
 
2024
                case 2:
 
2025
                        hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
 
2026
                        break;
 
2027
                case 3:
 
2028
                        hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
 
2029
                        break;
 
2030
                }
 
2031
        }
 
2032
 
 
2033
        tx_ring->producer = get_next_index(producer, num_txd);
 
2034
 
 
2035
        netxen_tso_check(netdev, tx_ring, first_desc, skb);
 
2036
 
 
2037
        adapter->stats.txbytes += skb->len;
 
2038
        adapter->stats.xmitcalled++;
 
2039
 
 
2040
        netxen_nic_update_cmd_producer(adapter, tx_ring);
 
2041
 
 
2042
        return NETDEV_TX_OK;
 
2043
 
 
2044
drop_packet:
 
2045
        adapter->stats.txdropped++;
 
2046
        dev_kfree_skb_any(skb);
 
2047
        return NETDEV_TX_OK;
 
2048
}
 
2049
 
 
2050
static int netxen_nic_check_temp(struct netxen_adapter *adapter)
 
2051
{
 
2052
        struct net_device *netdev = adapter->netdev;
 
2053
        uint32_t temp, temp_state, temp_val;
 
2054
        int rv = 0;
 
2055
 
 
2056
        temp = NXRD32(adapter, CRB_TEMP_STATE);
 
2057
 
 
2058
        temp_state = nx_get_temp_state(temp);
 
2059
        temp_val = nx_get_temp_val(temp);
 
2060
 
 
2061
        if (temp_state == NX_TEMP_PANIC) {
 
2062
                printk(KERN_ALERT
 
2063
                       "%s: Device temperature %d degrees C exceeds"
 
2064
                       " maximum allowed. Hardware has been shut down.\n",
 
2065
                       netdev->name, temp_val);
 
2066
                rv = 1;
 
2067
        } else if (temp_state == NX_TEMP_WARN) {
 
2068
                if (adapter->temp == NX_TEMP_NORMAL) {
 
2069
                        printk(KERN_ALERT
 
2070
                               "%s: Device temperature %d degrees C "
 
2071
                               "exceeds operating range."
 
2072
                               " Immediate action needed.\n",
 
2073
                               netdev->name, temp_val);
 
2074
                }
 
2075
        } else {
 
2076
                if (adapter->temp == NX_TEMP_WARN) {
 
2077
                        printk(KERN_INFO
 
2078
                               "%s: Device temperature is now %d degrees C"
 
2079
                               " in normal range.\n", netdev->name,
 
2080
                               temp_val);
 
2081
                }
 
2082
        }
 
2083
        adapter->temp = temp_state;
 
2084
        return rv;
 
2085
}
 
2086
 
 
2087
void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
 
2088
{
 
2089
        struct net_device *netdev = adapter->netdev;
 
2090
 
 
2091
        if (adapter->ahw.linkup && !linkup) {
 
2092
                printk(KERN_INFO "%s: %s NIC Link is down\n",
 
2093
                       netxen_nic_driver_name, netdev->name);
 
2094
                adapter->ahw.linkup = 0;
 
2095
                if (netif_running(netdev)) {
 
2096
                        netif_carrier_off(netdev);
 
2097
                        netif_stop_queue(netdev);
 
2098
                }
 
2099
                adapter->link_changed = !adapter->has_link_events;
 
2100
        } else if (!adapter->ahw.linkup && linkup) {
 
2101
                printk(KERN_INFO "%s: %s NIC Link is up\n",
 
2102
                       netxen_nic_driver_name, netdev->name);
 
2103
                adapter->ahw.linkup = 1;
 
2104
                if (netif_running(netdev)) {
 
2105
                        netif_carrier_on(netdev);
 
2106
                        netif_wake_queue(netdev);
 
2107
                }
 
2108
                adapter->link_changed = !adapter->has_link_events;
 
2109
        }
 
2110
}
 
2111
 
 
2112
static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
 
2113
{
 
2114
        u32 val, port, linkup;
 
2115
 
 
2116
        port = adapter->physical_port;
 
2117
 
 
2118
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
2119
                val = NXRD32(adapter, CRB_XG_STATE_P3);
 
2120
                val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
 
2121
                linkup = (val == XG_LINK_UP_P3);
 
2122
        } else {
 
2123
                val = NXRD32(adapter, CRB_XG_STATE);
 
2124
                val = (val >> port*8) & 0xff;
 
2125
                linkup = (val == XG_LINK_UP);
 
2126
        }
 
2127
 
 
2128
        netxen_advert_link_change(adapter, linkup);
 
2129
}
 
2130
 
 
2131
static void netxen_tx_timeout(struct net_device *netdev)
 
2132
{
 
2133
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
2134
 
 
2135
        if (test_bit(__NX_RESETTING, &adapter->state))
 
2136
                return;
 
2137
 
 
2138
        dev_err(&netdev->dev, "transmit timeout, resetting.\n");
 
2139
        schedule_work(&adapter->tx_timeout_task);
 
2140
}
 
2141
 
 
2142
static void netxen_tx_timeout_task(struct work_struct *work)
 
2143
{
 
2144
        struct netxen_adapter *adapter =
 
2145
                container_of(work, struct netxen_adapter, tx_timeout_task);
 
2146
 
 
2147
        if (!netif_running(adapter->netdev))
 
2148
                return;
 
2149
 
 
2150
        if (test_and_set_bit(__NX_RESETTING, &adapter->state))
 
2151
                return;
 
2152
 
 
2153
        if (++adapter->tx_timeo_cnt >= NX_MAX_TX_TIMEOUTS)
 
2154
                goto request_reset;
 
2155
 
 
2156
        rtnl_lock();
 
2157
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
 
2158
                /* try to scrub interrupt */
 
2159
                netxen_napi_disable(adapter);
 
2160
 
 
2161
                netxen_napi_enable(adapter);
 
2162
 
 
2163
                netif_wake_queue(adapter->netdev);
 
2164
 
 
2165
                clear_bit(__NX_RESETTING, &adapter->state);
 
2166
        } else {
 
2167
                clear_bit(__NX_RESETTING, &adapter->state);
 
2168
                if (netxen_nic_reset_context(adapter)) {
 
2169
                        rtnl_unlock();
 
2170
                        goto request_reset;
 
2171
                }
 
2172
        }
 
2173
        adapter->netdev->trans_start = jiffies;
 
2174
        rtnl_unlock();
 
2175
        return;
 
2176
 
 
2177
request_reset:
 
2178
        adapter->need_fw_reset = 1;
 
2179
        clear_bit(__NX_RESETTING, &adapter->state);
 
2180
}
 
2181
 
 
2182
static struct rtnl_link_stats64 *netxen_nic_get_stats(struct net_device *netdev,
 
2183
                                                      struct rtnl_link_stats64 *stats)
 
2184
{
 
2185
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
2186
 
 
2187
        stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
 
2188
        stats->tx_packets = adapter->stats.xmitfinished;
 
2189
        stats->rx_bytes = adapter->stats.rxbytes;
 
2190
        stats->tx_bytes = adapter->stats.txbytes;
 
2191
        stats->rx_dropped = adapter->stats.rxdropped;
 
2192
        stats->tx_dropped = adapter->stats.txdropped;
 
2193
 
 
2194
        return stats;
 
2195
}
 
2196
 
 
2197
static irqreturn_t netxen_intr(int irq, void *data)
 
2198
{
 
2199
        struct nx_host_sds_ring *sds_ring = data;
 
2200
        struct netxen_adapter *adapter = sds_ring->adapter;
 
2201
        u32 status = 0;
 
2202
 
 
2203
        status = readl(adapter->isr_int_vec);
 
2204
 
 
2205
        if (!(status & adapter->int_vec_bit))
 
2206
                return IRQ_NONE;
 
2207
 
 
2208
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
 
2209
                /* check interrupt state machine, to be sure */
 
2210
                status = readl(adapter->crb_int_state_reg);
 
2211
                if (!ISR_LEGACY_INT_TRIGGERED(status))
 
2212
                        return IRQ_NONE;
 
2213
 
 
2214
        } else {
 
2215
                unsigned long our_int = 0;
 
2216
 
 
2217
                our_int = readl(adapter->crb_int_state_reg);
 
2218
 
 
2219
                /* not our interrupt */
 
2220
                if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
 
2221
                        return IRQ_NONE;
 
2222
 
 
2223
                /* claim interrupt */
 
2224
                writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
 
2225
 
 
2226
                /* clear interrupt */
 
2227
                netxen_nic_disable_int(sds_ring);
 
2228
        }
 
2229
 
 
2230
        writel(0xffffffff, adapter->tgt_status_reg);
 
2231
        /* read twice to ensure write is flushed */
 
2232
        readl(adapter->isr_int_vec);
 
2233
        readl(adapter->isr_int_vec);
 
2234
 
 
2235
        napi_schedule(&sds_ring->napi);
 
2236
 
 
2237
        return IRQ_HANDLED;
 
2238
}
 
2239
 
 
2240
static irqreturn_t netxen_msi_intr(int irq, void *data)
 
2241
{
 
2242
        struct nx_host_sds_ring *sds_ring = data;
 
2243
        struct netxen_adapter *adapter = sds_ring->adapter;
 
2244
 
 
2245
        /* clear interrupt */
 
2246
        writel(0xffffffff, adapter->tgt_status_reg);
 
2247
 
 
2248
        napi_schedule(&sds_ring->napi);
 
2249
        return IRQ_HANDLED;
 
2250
}
 
2251
 
 
2252
static irqreturn_t netxen_msix_intr(int irq, void *data)
 
2253
{
 
2254
        struct nx_host_sds_ring *sds_ring = data;
 
2255
 
 
2256
        napi_schedule(&sds_ring->napi);
 
2257
        return IRQ_HANDLED;
 
2258
}
 
2259
 
 
2260
static int netxen_nic_poll(struct napi_struct *napi, int budget)
 
2261
{
 
2262
        struct nx_host_sds_ring *sds_ring =
 
2263
                container_of(napi, struct nx_host_sds_ring, napi);
 
2264
 
 
2265
        struct netxen_adapter *adapter = sds_ring->adapter;
 
2266
 
 
2267
        int tx_complete;
 
2268
        int work_done;
 
2269
 
 
2270
        tx_complete = netxen_process_cmd_ring(adapter);
 
2271
 
 
2272
        work_done = netxen_process_rcv_ring(sds_ring, budget);
 
2273
 
 
2274
        if ((work_done < budget) && tx_complete) {
 
2275
                napi_complete(&sds_ring->napi);
 
2276
                if (test_bit(__NX_DEV_UP, &adapter->state))
 
2277
                        netxen_nic_enable_int(sds_ring);
 
2278
        }
 
2279
 
 
2280
        return work_done;
 
2281
}
 
2282
 
 
2283
#ifdef CONFIG_NET_POLL_CONTROLLER
 
2284
static void netxen_nic_poll_controller(struct net_device *netdev)
 
2285
{
 
2286
        int ring;
 
2287
        struct nx_host_sds_ring *sds_ring;
 
2288
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
2289
        struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
 
2290
 
 
2291
        disable_irq(adapter->irq);
 
2292
        for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 
2293
                sds_ring = &recv_ctx->sds_rings[ring];
 
2294
                netxen_intr(adapter->irq, sds_ring);
 
2295
        }
 
2296
        enable_irq(adapter->irq);
 
2297
}
 
2298
#endif
 
2299
 
 
2300
static int
 
2301
nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
 
2302
{
 
2303
        int count;
 
2304
        if (netxen_api_lock(adapter))
 
2305
                return -EIO;
 
2306
 
 
2307
        count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
 
2308
 
 
2309
        NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
 
2310
 
 
2311
        netxen_api_unlock(adapter);
 
2312
        return count;
 
2313
}
 
2314
 
 
2315
static int
 
2316
nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
 
2317
{
 
2318
        int count;
 
2319
        if (netxen_api_lock(adapter))
 
2320
                return -EIO;
 
2321
 
 
2322
        count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
 
2323
        WARN_ON(count == 0);
 
2324
 
 
2325
        NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
 
2326
 
 
2327
        if (count == 0)
 
2328
                NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
 
2329
 
 
2330
        netxen_api_unlock(adapter);
 
2331
        return count;
 
2332
}
 
2333
 
 
2334
static int
 
2335
nx_dev_request_aer(struct netxen_adapter *adapter)
 
2336
{
 
2337
        u32 state;
 
2338
        int ret = -EINVAL;
 
2339
 
 
2340
        if (netxen_api_lock(adapter))
 
2341
                return ret;
 
2342
 
 
2343
        state = NXRD32(adapter, NX_CRB_DEV_STATE);
 
2344
 
 
2345
        if (state == NX_DEV_NEED_AER)
 
2346
                ret = 0;
 
2347
        else if (state == NX_DEV_READY) {
 
2348
                NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_AER);
 
2349
                ret = 0;
 
2350
        }
 
2351
 
 
2352
        netxen_api_unlock(adapter);
 
2353
        return ret;
 
2354
}
 
2355
 
 
2356
static int
 
2357
nx_dev_request_reset(struct netxen_adapter *adapter)
 
2358
{
 
2359
        u32 state;
 
2360
        int ret = -EINVAL;
 
2361
 
 
2362
        if (netxen_api_lock(adapter))
 
2363
                return ret;
 
2364
 
 
2365
        state = NXRD32(adapter, NX_CRB_DEV_STATE);
 
2366
 
 
2367
        if (state == NX_DEV_NEED_RESET)
 
2368
                ret = 0;
 
2369
        else if (state != NX_DEV_INITALIZING && state != NX_DEV_NEED_AER) {
 
2370
                NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_RESET);
 
2371
                ret = 0;
 
2372
        }
 
2373
 
 
2374
        netxen_api_unlock(adapter);
 
2375
 
 
2376
        return ret;
 
2377
}
 
2378
 
 
2379
static int
 
2380
netxen_can_start_firmware(struct netxen_adapter *adapter)
 
2381
{
 
2382
        int count;
 
2383
        int can_start = 0;
 
2384
 
 
2385
        if (netxen_api_lock(adapter))
 
2386
                return 0;
 
2387
 
 
2388
        count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
 
2389
 
 
2390
        if ((count < 0) || (count >= NX_MAX_PCI_FUNC))
 
2391
                count = 0;
 
2392
 
 
2393
        if (count == 0) {
 
2394
                can_start = 1;
 
2395
                NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
 
2396
        }
 
2397
 
 
2398
        NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
 
2399
 
 
2400
        netxen_api_unlock(adapter);
 
2401
 
 
2402
        return can_start;
 
2403
}
 
2404
 
 
2405
static void
 
2406
netxen_schedule_work(struct netxen_adapter *adapter,
 
2407
                work_func_t func, int delay)
 
2408
{
 
2409
        INIT_DELAYED_WORK(&adapter->fw_work, func);
 
2410
        schedule_delayed_work(&adapter->fw_work, delay);
 
2411
}
 
2412
 
 
2413
static void
 
2414
netxen_cancel_fw_work(struct netxen_adapter *adapter)
 
2415
{
 
2416
        while (test_and_set_bit(__NX_RESETTING, &adapter->state))
 
2417
                msleep(10);
 
2418
 
 
2419
        cancel_delayed_work_sync(&adapter->fw_work);
 
2420
}
 
2421
 
 
2422
static void
 
2423
netxen_attach_work(struct work_struct *work)
 
2424
{
 
2425
        struct netxen_adapter *adapter = container_of(work,
 
2426
                                struct netxen_adapter, fw_work.work);
 
2427
        struct net_device *netdev = adapter->netdev;
 
2428
        int err = 0;
 
2429
 
 
2430
        if (netif_running(netdev)) {
 
2431
                err = netxen_nic_attach(adapter);
 
2432
                if (err)
 
2433
                        goto done;
 
2434
 
 
2435
                err = netxen_nic_up(adapter, netdev);
 
2436
                if (err) {
 
2437
                        netxen_nic_detach(adapter);
 
2438
                        goto done;
 
2439
                }
 
2440
 
 
2441
                netxen_restore_indev_addr(netdev, NETDEV_UP);
 
2442
        }
 
2443
 
 
2444
        netif_device_attach(netdev);
 
2445
 
 
2446
done:
 
2447
        adapter->fw_fail_cnt = 0;
 
2448
        clear_bit(__NX_RESETTING, &adapter->state);
 
2449
        netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
 
2450
}
 
2451
 
 
2452
static void
 
2453
netxen_fwinit_work(struct work_struct *work)
 
2454
{
 
2455
        struct netxen_adapter *adapter = container_of(work,
 
2456
                                struct netxen_adapter, fw_work.work);
 
2457
        int dev_state;
 
2458
 
 
2459
        dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
 
2460
 
 
2461
        switch (dev_state) {
 
2462
        case NX_DEV_COLD:
 
2463
        case NX_DEV_READY:
 
2464
                if (!netxen_start_firmware(adapter)) {
 
2465
                        netxen_schedule_work(adapter, netxen_attach_work, 0);
 
2466
                        return;
 
2467
                }
 
2468
                break;
 
2469
 
 
2470
        case NX_DEV_NEED_RESET:
 
2471
        case NX_DEV_INITALIZING:
 
2472
                if (++adapter->fw_wait_cnt < FW_POLL_THRESH) {
 
2473
                        netxen_schedule_work(adapter,
 
2474
                                        netxen_fwinit_work, 2 * FW_POLL_DELAY);
 
2475
                        return;
 
2476
                }
 
2477
 
 
2478
        case NX_DEV_FAILED:
 
2479
        default:
 
2480
                nx_incr_dev_ref_cnt(adapter);
 
2481
                break;
 
2482
        }
 
2483
 
 
2484
        clear_bit(__NX_RESETTING, &adapter->state);
 
2485
}
 
2486
 
 
2487
static void
 
2488
netxen_detach_work(struct work_struct *work)
 
2489
{
 
2490
        struct netxen_adapter *adapter = container_of(work,
 
2491
                                struct netxen_adapter, fw_work.work);
 
2492
        struct net_device *netdev = adapter->netdev;
 
2493
        int ref_cnt, delay;
 
2494
        u32 status;
 
2495
 
 
2496
        netif_device_detach(netdev);
 
2497
 
 
2498
        netxen_nic_down(adapter, netdev);
 
2499
 
 
2500
        rtnl_lock();
 
2501
        netxen_nic_detach(adapter);
 
2502
        rtnl_unlock();
 
2503
 
 
2504
        status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
 
2505
 
 
2506
        if (status & NX_RCODE_FATAL_ERROR)
 
2507
                goto err_ret;
 
2508
 
 
2509
        if (adapter->temp == NX_TEMP_PANIC)
 
2510
                goto err_ret;
 
2511
 
 
2512
        ref_cnt = nx_decr_dev_ref_cnt(adapter);
 
2513
 
 
2514
        if (ref_cnt == -EIO)
 
2515
                goto err_ret;
 
2516
 
 
2517
        delay = (ref_cnt == 0) ? 0 : (2 * FW_POLL_DELAY);
 
2518
 
 
2519
        adapter->fw_wait_cnt = 0;
 
2520
        netxen_schedule_work(adapter, netxen_fwinit_work, delay);
 
2521
 
 
2522
        return;
 
2523
 
 
2524
err_ret:
 
2525
        clear_bit(__NX_RESETTING, &adapter->state);
 
2526
}
 
2527
 
 
2528
static int
 
2529
netxen_check_health(struct netxen_adapter *adapter)
 
2530
{
 
2531
        u32 state, heartbit;
 
2532
        struct net_device *netdev = adapter->netdev;
 
2533
 
 
2534
        state = NXRD32(adapter, NX_CRB_DEV_STATE);
 
2535
        if (state == NX_DEV_NEED_AER)
 
2536
                return 0;
 
2537
 
 
2538
        if (netxen_nic_check_temp(adapter))
 
2539
                goto detach;
 
2540
 
 
2541
        if (adapter->need_fw_reset) {
 
2542
                if (nx_dev_request_reset(adapter))
 
2543
                        return 0;
 
2544
                goto detach;
 
2545
        }
 
2546
 
 
2547
        /* NX_DEV_NEED_RESET, this state can be marked in two cases
 
2548
         * 1. Tx timeout 2. Fw hang
 
2549
         * Send request to destroy context in case of tx timeout only
 
2550
         * and doesn't required in case of Fw hang
 
2551
         */
 
2552
        if (state == NX_DEV_NEED_RESET) {
 
2553
                adapter->need_fw_reset = 1;
 
2554
                if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
2555
                        goto detach;
 
2556
        }
 
2557
 
 
2558
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
2559
                return 0;
 
2560
 
 
2561
        heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
 
2562
        if (heartbit != adapter->heartbit) {
 
2563
                adapter->heartbit = heartbit;
 
2564
                adapter->fw_fail_cnt = 0;
 
2565
                if (adapter->need_fw_reset)
 
2566
                        goto detach;
 
2567
                return 0;
 
2568
        }
 
2569
 
 
2570
        if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
 
2571
                return 0;
 
2572
 
 
2573
        if (nx_dev_request_reset(adapter))
 
2574
                return 0;
 
2575
 
 
2576
        clear_bit(__NX_FW_ATTACHED, &adapter->state);
 
2577
 
 
2578
        dev_info(&netdev->dev, "firmware hang detected\n");
 
2579
 
 
2580
detach:
 
2581
        if ((auto_fw_reset == AUTO_FW_RESET_ENABLED) &&
 
2582
                        !test_and_set_bit(__NX_RESETTING, &adapter->state))
 
2583
                netxen_schedule_work(adapter, netxen_detach_work, 0);
 
2584
        return 1;
 
2585
}
 
2586
 
 
2587
static void
 
2588
netxen_fw_poll_work(struct work_struct *work)
 
2589
{
 
2590
        struct netxen_adapter *adapter = container_of(work,
 
2591
                                struct netxen_adapter, fw_work.work);
 
2592
 
 
2593
        if (test_bit(__NX_RESETTING, &adapter->state))
 
2594
                goto reschedule;
 
2595
 
 
2596
        if (test_bit(__NX_DEV_UP, &adapter->state)) {
 
2597
                if (!adapter->has_link_events) {
 
2598
 
 
2599
                        netxen_nic_handle_phy_intr(adapter);
 
2600
 
 
2601
                        if (adapter->link_changed)
 
2602
                                netxen_nic_set_link_parameters(adapter);
 
2603
                }
 
2604
        }
 
2605
 
 
2606
        if (netxen_check_health(adapter))
 
2607
                return;
 
2608
 
 
2609
reschedule:
 
2610
        netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
 
2611
}
 
2612
 
 
2613
static ssize_t
 
2614
netxen_store_bridged_mode(struct device *dev,
 
2615
                struct device_attribute *attr, const char *buf, size_t len)
 
2616
{
 
2617
        struct net_device *net = to_net_dev(dev);
 
2618
        struct netxen_adapter *adapter = netdev_priv(net);
 
2619
        unsigned long new;
 
2620
        int ret = -EINVAL;
 
2621
 
 
2622
        if (!(adapter->capabilities & NX_FW_CAPABILITY_BDG))
 
2623
                goto err_out;
 
2624
 
 
2625
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
2626
                goto err_out;
 
2627
 
 
2628
        if (strict_strtoul(buf, 2, &new))
 
2629
                goto err_out;
 
2630
 
 
2631
        if (!netxen_config_bridged_mode(adapter, !!new))
 
2632
                ret = len;
 
2633
 
 
2634
err_out:
 
2635
        return ret;
 
2636
}
 
2637
 
 
2638
static ssize_t
 
2639
netxen_show_bridged_mode(struct device *dev,
 
2640
                struct device_attribute *attr, char *buf)
 
2641
{
 
2642
        struct net_device *net = to_net_dev(dev);
 
2643
        struct netxen_adapter *adapter;
 
2644
        int bridged_mode = 0;
 
2645
 
 
2646
        adapter = netdev_priv(net);
 
2647
 
 
2648
        if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
 
2649
                bridged_mode = !!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED);
 
2650
 
 
2651
        return sprintf(buf, "%d\n", bridged_mode);
 
2652
}
 
2653
 
 
2654
static struct device_attribute dev_attr_bridged_mode = {
 
2655
       .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
 
2656
       .show = netxen_show_bridged_mode,
 
2657
       .store = netxen_store_bridged_mode,
 
2658
};
 
2659
 
 
2660
static ssize_t
 
2661
netxen_store_diag_mode(struct device *dev,
 
2662
                struct device_attribute *attr, const char *buf, size_t len)
 
2663
{
 
2664
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2665
        unsigned long new;
 
2666
 
 
2667
        if (strict_strtoul(buf, 2, &new))
 
2668
                return -EINVAL;
 
2669
 
 
2670
        if (!!new != !!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
 
2671
                adapter->flags ^= NETXEN_NIC_DIAG_ENABLED;
 
2672
 
 
2673
        return len;
 
2674
}
 
2675
 
 
2676
static ssize_t
 
2677
netxen_show_diag_mode(struct device *dev,
 
2678
                struct device_attribute *attr, char *buf)
 
2679
{
 
2680
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2681
 
 
2682
        return sprintf(buf, "%d\n",
 
2683
                        !!(adapter->flags & NETXEN_NIC_DIAG_ENABLED));
 
2684
}
 
2685
 
 
2686
static struct device_attribute dev_attr_diag_mode = {
 
2687
        .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
 
2688
        .show = netxen_show_diag_mode,
 
2689
        .store = netxen_store_diag_mode,
 
2690
};
 
2691
 
 
2692
static int
 
2693
netxen_sysfs_validate_crb(struct netxen_adapter *adapter,
 
2694
                loff_t offset, size_t size)
 
2695
{
 
2696
        size_t crb_size = 4;
 
2697
 
 
2698
        if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
 
2699
                return -EIO;
 
2700
 
 
2701
        if (offset < NETXEN_PCI_CRBSPACE) {
 
2702
                if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
2703
                        return -EINVAL;
 
2704
 
 
2705
                if (ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
 
2706
                                                NETXEN_PCI_CAMQM_2M_END))
 
2707
                        crb_size = 8;
 
2708
                else
 
2709
                        return -EINVAL;
 
2710
        }
 
2711
 
 
2712
        if ((size != crb_size) || (offset & (crb_size-1)))
 
2713
                return  -EINVAL;
 
2714
 
 
2715
        return 0;
 
2716
}
 
2717
 
 
2718
static ssize_t
 
2719
netxen_sysfs_read_crb(struct file *filp, struct kobject *kobj,
 
2720
                struct bin_attribute *attr,
 
2721
                char *buf, loff_t offset, size_t size)
 
2722
{
 
2723
        struct device *dev = container_of(kobj, struct device, kobj);
 
2724
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2725
        u32 data;
 
2726
        u64 qmdata;
 
2727
        int ret;
 
2728
 
 
2729
        ret = netxen_sysfs_validate_crb(adapter, offset, size);
 
2730
        if (ret != 0)
 
2731
                return ret;
 
2732
 
 
2733
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
 
2734
                ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
 
2735
                                        NETXEN_PCI_CAMQM_2M_END)) {
 
2736
                netxen_pci_camqm_read_2M(adapter, offset, &qmdata);
 
2737
                memcpy(buf, &qmdata, size);
 
2738
        } else {
 
2739
                data = NXRD32(adapter, offset);
 
2740
                memcpy(buf, &data, size);
 
2741
        }
 
2742
 
 
2743
        return size;
 
2744
}
 
2745
 
 
2746
static ssize_t
 
2747
netxen_sysfs_write_crb(struct file *filp, struct kobject *kobj,
 
2748
                struct bin_attribute *attr,
 
2749
                char *buf, loff_t offset, size_t size)
 
2750
{
 
2751
        struct device *dev = container_of(kobj, struct device, kobj);
 
2752
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2753
        u32 data;
 
2754
        u64 qmdata;
 
2755
        int ret;
 
2756
 
 
2757
        ret = netxen_sysfs_validate_crb(adapter, offset, size);
 
2758
        if (ret != 0)
 
2759
                return ret;
 
2760
 
 
2761
        if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
 
2762
                ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
 
2763
                                        NETXEN_PCI_CAMQM_2M_END)) {
 
2764
                memcpy(&qmdata, buf, size);
 
2765
                netxen_pci_camqm_write_2M(adapter, offset, qmdata);
 
2766
        } else {
 
2767
                memcpy(&data, buf, size);
 
2768
                NXWR32(adapter, offset, data);
 
2769
        }
 
2770
 
 
2771
        return size;
 
2772
}
 
2773
 
 
2774
static int
 
2775
netxen_sysfs_validate_mem(struct netxen_adapter *adapter,
 
2776
                loff_t offset, size_t size)
 
2777
{
 
2778
        if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
 
2779
                return -EIO;
 
2780
 
 
2781
        if ((size != 8) || (offset & 0x7))
 
2782
                return  -EIO;
 
2783
 
 
2784
        return 0;
 
2785
}
 
2786
 
 
2787
static ssize_t
 
2788
netxen_sysfs_read_mem(struct file *filp, struct kobject *kobj,
 
2789
                struct bin_attribute *attr,
 
2790
                char *buf, loff_t offset, size_t size)
 
2791
{
 
2792
        struct device *dev = container_of(kobj, struct device, kobj);
 
2793
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2794
        u64 data;
 
2795
        int ret;
 
2796
 
 
2797
        ret = netxen_sysfs_validate_mem(adapter, offset, size);
 
2798
        if (ret != 0)
 
2799
                return ret;
 
2800
 
 
2801
        if (adapter->pci_mem_read(adapter, offset, &data))
 
2802
                return -EIO;
 
2803
 
 
2804
        memcpy(buf, &data, size);
 
2805
 
 
2806
        return size;
 
2807
}
 
2808
 
 
2809
static ssize_t netxen_sysfs_write_mem(struct file *filp, struct kobject *kobj,
 
2810
                struct bin_attribute *attr, char *buf,
 
2811
                loff_t offset, size_t size)
 
2812
{
 
2813
        struct device *dev = container_of(kobj, struct device, kobj);
 
2814
        struct netxen_adapter *adapter = dev_get_drvdata(dev);
 
2815
        u64 data;
 
2816
        int ret;
 
2817
 
 
2818
        ret = netxen_sysfs_validate_mem(adapter, offset, size);
 
2819
        if (ret != 0)
 
2820
                return ret;
 
2821
 
 
2822
        memcpy(&data, buf, size);
 
2823
 
 
2824
        if (adapter->pci_mem_write(adapter, offset, data))
 
2825
                return -EIO;
 
2826
 
 
2827
        return size;
 
2828
}
 
2829
 
 
2830
 
 
2831
static struct bin_attribute bin_attr_crb = {
 
2832
        .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
 
2833
        .size = 0,
 
2834
        .read = netxen_sysfs_read_crb,
 
2835
        .write = netxen_sysfs_write_crb,
 
2836
};
 
2837
 
 
2838
static struct bin_attribute bin_attr_mem = {
 
2839
        .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
 
2840
        .size = 0,
 
2841
        .read = netxen_sysfs_read_mem,
 
2842
        .write = netxen_sysfs_write_mem,
 
2843
};
 
2844
 
 
2845
 
 
2846
static void
 
2847
netxen_create_sysfs_entries(struct netxen_adapter *adapter)
 
2848
{
 
2849
        struct net_device *netdev = adapter->netdev;
 
2850
        struct device *dev = &netdev->dev;
 
2851
 
 
2852
        if (adapter->capabilities & NX_FW_CAPABILITY_BDG) {
 
2853
                /* bridged_mode control */
 
2854
                if (device_create_file(dev, &dev_attr_bridged_mode)) {
 
2855
                        dev_warn(&netdev->dev,
 
2856
                                "failed to create bridged_mode sysfs entry\n");
 
2857
                }
 
2858
        }
 
2859
}
 
2860
 
 
2861
static void
 
2862
netxen_remove_sysfs_entries(struct netxen_adapter *adapter)
 
2863
{
 
2864
        struct net_device *netdev = adapter->netdev;
 
2865
        struct device *dev = &netdev->dev;
 
2866
 
 
2867
        if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
 
2868
                device_remove_file(dev, &dev_attr_bridged_mode);
 
2869
}
 
2870
 
 
2871
static void
 
2872
netxen_create_diag_entries(struct netxen_adapter *adapter)
 
2873
{
 
2874
        struct pci_dev *pdev = adapter->pdev;
 
2875
        struct device *dev;
 
2876
 
 
2877
        dev = &pdev->dev;
 
2878
        if (device_create_file(dev, &dev_attr_diag_mode))
 
2879
                dev_info(dev, "failed to create diag_mode sysfs entry\n");
 
2880
        if (device_create_bin_file(dev, &bin_attr_crb))
 
2881
                dev_info(dev, "failed to create crb sysfs entry\n");
 
2882
        if (device_create_bin_file(dev, &bin_attr_mem))
 
2883
                dev_info(dev, "failed to create mem sysfs entry\n");
 
2884
}
 
2885
 
 
2886
 
 
2887
static void
 
2888
netxen_remove_diag_entries(struct netxen_adapter *adapter)
 
2889
{
 
2890
        struct pci_dev *pdev = adapter->pdev;
 
2891
        struct device *dev = &pdev->dev;
 
2892
 
 
2893
        device_remove_file(dev, &dev_attr_diag_mode);
 
2894
        device_remove_bin_file(dev, &bin_attr_crb);
 
2895
        device_remove_bin_file(dev, &bin_attr_mem);
 
2896
}
 
2897
 
 
2898
#ifdef CONFIG_INET
 
2899
 
 
2900
#define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
 
2901
 
 
2902
static int
 
2903
netxen_destip_supported(struct netxen_adapter *adapter)
 
2904
{
 
2905
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
 
2906
                return 0;
 
2907
 
 
2908
        if (adapter->ahw.cut_through)
 
2909
                return 0;
 
2910
 
 
2911
        return 1;
 
2912
}
 
2913
 
 
2914
static void
 
2915
netxen_free_vlan_ip_list(struct netxen_adapter *adapter)
 
2916
{
 
2917
        struct nx_vlan_ip_list  *cur;
 
2918
        struct list_head *head = &adapter->vlan_ip_list;
 
2919
 
 
2920
        while (!list_empty(head)) {
 
2921
                cur = list_entry(head->next, struct nx_vlan_ip_list, list);
 
2922
                netxen_config_ipaddr(adapter, cur->ip_addr, NX_IP_DOWN);
 
2923
                list_del(&cur->list);
 
2924
                kfree(cur);
 
2925
        }
 
2926
 
 
2927
}
 
2928
static void
 
2929
netxen_list_config_vlan_ip(struct netxen_adapter *adapter,
 
2930
                struct in_ifaddr *ifa, unsigned long event)
 
2931
{
 
2932
        struct net_device *dev;
 
2933
        struct nx_vlan_ip_list *cur, *tmp_cur;
 
2934
        struct list_head *head;
 
2935
 
 
2936
        dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
 
2937
 
 
2938
        if (dev == NULL)
 
2939
                return;
 
2940
 
 
2941
        if (!is_vlan_dev(dev))
 
2942
                return;
 
2943
 
 
2944
        switch (event) {
 
2945
        case NX_IP_UP:
 
2946
                list_for_each(head, &adapter->vlan_ip_list) {
 
2947
                        cur = list_entry(head, struct nx_vlan_ip_list, list);
 
2948
 
 
2949
                        if (cur->ip_addr == ifa->ifa_address)
 
2950
                                return;
 
2951
                }
 
2952
 
 
2953
                cur = kzalloc(sizeof(struct nx_vlan_ip_list), GFP_ATOMIC);
 
2954
                if (cur == NULL) {
 
2955
                        printk(KERN_ERR "%s: failed to add vlan ip to list\n",
 
2956
                                        adapter->netdev->name);
 
2957
                        return;
 
2958
                }
 
2959
 
 
2960
                cur->ip_addr = ifa->ifa_address;
 
2961
                list_add_tail(&cur->list, &adapter->vlan_ip_list);
 
2962
                break;
 
2963
        case NX_IP_DOWN:
 
2964
                list_for_each_entry_safe(cur, tmp_cur,
 
2965
                                        &adapter->vlan_ip_list, list) {
 
2966
                        if (cur->ip_addr == ifa->ifa_address) {
 
2967
                                list_del(&cur->list);
 
2968
                                kfree(cur);
 
2969
                                break;
 
2970
                        }
 
2971
                }
 
2972
        }
 
2973
}
 
2974
static void
 
2975
netxen_config_indev_addr(struct netxen_adapter *adapter,
 
2976
                struct net_device *dev, unsigned long event)
 
2977
{
 
2978
        struct in_device *indev;
 
2979
 
 
2980
        if (!netxen_destip_supported(adapter))
 
2981
                return;
 
2982
 
 
2983
        indev = in_dev_get(dev);
 
2984
        if (!indev)
 
2985
                return;
 
2986
 
 
2987
        for_ifa(indev) {
 
2988
                switch (event) {
 
2989
                case NETDEV_UP:
 
2990
                        netxen_config_ipaddr(adapter,
 
2991
                                        ifa->ifa_address, NX_IP_UP);
 
2992
                        netxen_list_config_vlan_ip(adapter, ifa, NX_IP_UP);
 
2993
                        break;
 
2994
                case NETDEV_DOWN:
 
2995
                        netxen_config_ipaddr(adapter,
 
2996
                                        ifa->ifa_address, NX_IP_DOWN);
 
2997
                        netxen_list_config_vlan_ip(adapter, ifa, NX_IP_DOWN);
 
2998
                        break;
 
2999
                default:
 
3000
                        break;
 
3001
                }
 
3002
        } endfor_ifa(indev);
 
3003
 
 
3004
        in_dev_put(indev);
 
3005
}
 
3006
 
 
3007
static void
 
3008
netxen_restore_indev_addr(struct net_device *netdev, unsigned long event)
 
3009
 
 
3010
{
 
3011
        struct netxen_adapter *adapter = netdev_priv(netdev);
 
3012
        struct nx_vlan_ip_list *pos, *tmp_pos;
 
3013
        unsigned long ip_event;
 
3014
 
 
3015
        ip_event = (event == NETDEV_UP) ? NX_IP_UP : NX_IP_DOWN;
 
3016
        netxen_config_indev_addr(adapter, netdev, event);
 
3017
 
 
3018
        list_for_each_entry_safe(pos, tmp_pos, &adapter->vlan_ip_list, list) {
 
3019
                netxen_config_ipaddr(adapter, pos->ip_addr, ip_event);
 
3020
        }
 
3021
}
 
3022
 
 
3023
static int netxen_netdev_event(struct notifier_block *this,
 
3024
                                 unsigned long event, void *ptr)
 
3025
{
 
3026
        struct netxen_adapter *adapter;
 
3027
        struct net_device *dev = (struct net_device *)ptr;
 
3028
        struct net_device *orig_dev = dev;
 
3029
 
 
3030
recheck:
 
3031
        if (dev == NULL)
 
3032
                goto done;
 
3033
 
 
3034
        if (dev->priv_flags & IFF_802_1Q_VLAN) {
 
3035
                dev = vlan_dev_real_dev(dev);
 
3036
                goto recheck;
 
3037
        }
 
3038
 
 
3039
        if (!is_netxen_netdev(dev))
 
3040
                goto done;
 
3041
 
 
3042
        adapter = netdev_priv(dev);
 
3043
 
 
3044
        if (!adapter)
 
3045
                goto done;
 
3046
 
 
3047
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
3048
                goto done;
 
3049
 
 
3050
        netxen_config_indev_addr(adapter, orig_dev, event);
 
3051
done:
 
3052
        return NOTIFY_DONE;
 
3053
}
 
3054
 
 
3055
static int
 
3056
netxen_inetaddr_event(struct notifier_block *this,
 
3057
                unsigned long event, void *ptr)
 
3058
{
 
3059
        struct netxen_adapter *adapter;
 
3060
        struct net_device *dev;
 
3061
 
 
3062
        struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
 
3063
 
 
3064
        dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
 
3065
 
 
3066
recheck:
 
3067
        if (dev == NULL)
 
3068
                goto done;
 
3069
 
 
3070
        if (dev->priv_flags & IFF_802_1Q_VLAN) {
 
3071
                dev = vlan_dev_real_dev(dev);
 
3072
                goto recheck;
 
3073
        }
 
3074
 
 
3075
        if (!is_netxen_netdev(dev))
 
3076
                goto done;
 
3077
 
 
3078
        adapter = netdev_priv(dev);
 
3079
 
 
3080
        if (!adapter || !netxen_destip_supported(adapter))
 
3081
                goto done;
 
3082
 
 
3083
        if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
 
3084
                goto done;
 
3085
 
 
3086
        switch (event) {
 
3087
        case NETDEV_UP:
 
3088
                netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
 
3089
                netxen_list_config_vlan_ip(adapter, ifa, NX_IP_UP);
 
3090
                break;
 
3091
        case NETDEV_DOWN:
 
3092
                netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_DOWN);
 
3093
                netxen_list_config_vlan_ip(adapter, ifa, NX_IP_DOWN);
 
3094
                break;
 
3095
        default:
 
3096
                break;
 
3097
        }
 
3098
 
 
3099
done:
 
3100
        return NOTIFY_DONE;
 
3101
}
 
3102
 
 
3103
static struct notifier_block    netxen_netdev_cb = {
 
3104
        .notifier_call = netxen_netdev_event,
 
3105
};
 
3106
 
 
3107
static struct notifier_block netxen_inetaddr_cb = {
 
3108
        .notifier_call = netxen_inetaddr_event,
 
3109
};
 
3110
#else
 
3111
static void
 
3112
netxen_restore_indev_addr(struct net_device *dev, unsigned long event)
 
3113
{ }
 
3114
static void
 
3115
netxen_free_vlan_ip_list(struct netxen_adapter *adapter)
 
3116
{ }
 
3117
#endif
 
3118
 
 
3119
static struct pci_error_handlers netxen_err_handler = {
 
3120
        .error_detected = netxen_io_error_detected,
 
3121
        .slot_reset = netxen_io_slot_reset,
 
3122
        .resume = netxen_io_resume,
 
3123
};
 
3124
 
 
3125
static struct pci_driver netxen_driver = {
 
3126
        .name = netxen_nic_driver_name,
 
3127
        .id_table = netxen_pci_tbl,
 
3128
        .probe = netxen_nic_probe,
 
3129
        .remove = __devexit_p(netxen_nic_remove),
 
3130
#ifdef CONFIG_PM
 
3131
        .suspend = netxen_nic_suspend,
 
3132
        .resume = netxen_nic_resume,
 
3133
#endif
 
3134
        .shutdown = netxen_nic_shutdown,
 
3135
        .err_handler = &netxen_err_handler
 
3136
};
 
3137
 
 
3138
static int __init netxen_init_module(void)
 
3139
{
 
3140
        printk(KERN_INFO "%s\n", netxen_nic_driver_string);
 
3141
 
 
3142
#ifdef CONFIG_INET
 
3143
        register_netdevice_notifier(&netxen_netdev_cb);
 
3144
        register_inetaddr_notifier(&netxen_inetaddr_cb);
 
3145
#endif
 
3146
        return pci_register_driver(&netxen_driver);
 
3147
}
 
3148
 
 
3149
module_init(netxen_init_module);
 
3150
 
 
3151
static void __exit netxen_exit_module(void)
 
3152
{
 
3153
        pci_unregister_driver(&netxen_driver);
 
3154
 
 
3155
#ifdef CONFIG_INET
 
3156
        unregister_inetaddr_notifier(&netxen_inetaddr_cb);
 
3157
        unregister_netdevice_notifier(&netxen_netdev_cb);
 
3158
#endif
 
3159
}
 
3160
 
 
3161
module_exit(netxen_exit_module);