]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/qlcnic/qlcnic_main.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
qlcnic: seperate interrupt for TX
[net-next-2.6.git] / drivers / net / qlcnic / qlcnic_main.c
CommitLineData
af19b491
AKS		 1/*
2 * Copyright (C) 2009 - QLogic Corporation.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 * MA 02111-1307, USA.
19 *
20 * The full GNU General Public License is included in this distribution
21 * in the file called "COPYING".
22 *
23 */
24
5a0e3ad6 25#include <linux/slab.h>
af19b491
AKS		 26#include <linux/vmalloc.h>
27#include <linux/interrupt.h>
28
29#include "qlcnic.h"
30
31#include <linux/dma-mapping.h>
32#include <linux/if_vlan.h>
33#include <net/ip.h>
34#include <linux/ipv6.h>
35#include <linux/inetdevice.h>
36#include <linux/sysfs.h>
37
7f9a0c34 38MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
af19b491
AKS		 39MODULE_LICENSE("GPL");
40MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
41MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
42
43char qlcnic_driver_name[] = "qlcnic";
7f9a0c34
SV		 44static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
45 "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
af19b491
AKS		 46
47static int port_mode = QLCNIC_PORT_MODE_AUTO_NEG;
48
49/* Default to restricted 1G auto-neg mode */
50static int wol_port_mode = 5;
51
52static int use_msi = 1;
53module_param(use_msi, int, 0644);
54MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
55
56static int use_msi_x = 1;
57module_param(use_msi_x, int, 0644);
58MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
59
60static int auto_fw_reset = AUTO_FW_RESET_ENABLED;
61module_param(auto_fw_reset, int, 0644);
62MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
63
4d5bdb38
AKS		 64static int load_fw_file;
65module_param(load_fw_file, int, 0644);
66MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
67
2e9d722d
AC		 68static int qlcnic_config_npars;
69module_param(qlcnic_config_npars, int, 0644);
70MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
71
af19b491
AKS		 72static int __devinit qlcnic_probe(struct pci_dev *pdev,
73 const struct pci_device_id *ent);
74static void __devexit qlcnic_remove(struct pci_dev *pdev);
75static int qlcnic_open(struct net_device *netdev);
76static int qlcnic_close(struct net_device *netdev);
af19b491
AKS		 77static void qlcnic_tx_timeout(struct net_device *netdev);
78static void qlcnic_tx_timeout_task(struct work_struct *work);
79static void qlcnic_attach_work(struct work_struct *work);
80static void qlcnic_fwinit_work(struct work_struct *work);
81static void qlcnic_fw_poll_work(struct work_struct *work);
82static void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
83 work_func_t func, int delay);
84static void qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter);
85static int qlcnic_poll(struct napi_struct *napi, int budget);
8f891387 86static int qlcnic_rx_poll(struct napi_struct *napi, int budget);
af19b491
AKS		 87#ifdef CONFIG_NET_POLL_CONTROLLER
88static void qlcnic_poll_controller(struct net_device *netdev);
89#endif
90
91static void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter);
92static void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter);
93static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter);
94static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter);
95
6df900e9 96static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
af19b491
AKS		 97static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter);
98static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
99
7eb9855d 100static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
af19b491
AKS		 101static irqreturn_t qlcnic_intr(int irq, void *data);
102static irqreturn_t qlcnic_msi_intr(int irq, void *data);
103static irqreturn_t qlcnic_msix_intr(int irq, void *data);
104
105static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
106static void qlcnic_config_indev_addr(struct net_device *dev, unsigned long);
9f26f547
AC		 107static int qlcnic_start_firmware(struct qlcnic_adapter *);
108
109static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
110static void qlcnicvf_clear_ilb_mode(struct qlcnic_adapter *);
111static int qlcnicvf_set_ilb_mode(struct qlcnic_adapter *);
112static int qlcnicvf_config_led(struct qlcnic_adapter *, u32, u32);
113static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
114static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
af19b491
AKS		 115/* PCI Device ID Table */
116#define ENTRY(device) \
117 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
118 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
119
120#define PCI_DEVICE_ID_QLOGIC_QLE824X 0x8020
121
6a902881 122static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
af19b491
AKS		 123 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
124 {0,}
125};
126
127MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
128
129
130void
131qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
132 struct qlcnic_host_tx_ring *tx_ring)
133{
134 writel(tx_ring->producer, tx_ring->crb_cmd_producer);
135
136 if (qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH) {
137 netif_stop_queue(adapter->netdev);
138 smp_mb();
8bfe8b91 139 adapter->stats.xmit_off++;
af19b491
AKS		 140 }
141}
142
143static const u32 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
150static const
151struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
152
153static inline void qlcnic_disable_int(struct qlcnic_host_sds_ring *sds_ring)
154{
155 writel(0, sds_ring->crb_intr_mask);
156}
157
158static inline void qlcnic_enable_int(struct qlcnic_host_sds_ring *sds_ring)
159{
160 struct qlcnic_adapter *adapter = sds_ring->adapter;
161
162 writel(0x1, sds_ring->crb_intr_mask);
163
164 if (!QLCNIC_IS_MSI_FAMILY(adapter))
165 writel(0xfbff, adapter->tgt_mask_reg);
166}
167
168static int
169qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
170{
171 int size = sizeof(struct qlcnic_host_sds_ring) * count;
172
173 recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
174
175 return (recv_ctx->sds_rings == NULL);
176}
177
178static void
179qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
180{
181 if (recv_ctx->sds_rings != NULL)
182 kfree(recv_ctx->sds_rings);
183
184 recv_ctx->sds_rings = NULL;
185}
186
187static int
188qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
189{
190 int ring;
191 struct qlcnic_host_sds_ring *sds_ring;
192 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
193
194 if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
195 return -ENOMEM;
196
197 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
198 sds_ring = &recv_ctx->sds_rings[ring];
8f891387 199
200 if (ring == adapter->max_sds_rings - 1)
201 netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
202 QLCNIC_NETDEV_WEIGHT/adapter->max_sds_rings);
203 else
204 netif_napi_add(netdev, &sds_ring->napi,
205 qlcnic_rx_poll, QLCNIC_NETDEV_WEIGHT*2);
af19b491
AKS		 206 }
207
208 return 0;
209}
210
211static void
212qlcnic_napi_del(struct qlcnic_adapter *adapter)
213{
214 int ring;
215 struct qlcnic_host_sds_ring *sds_ring;
216 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
217
218 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
219 sds_ring = &recv_ctx->sds_rings[ring];
220 netif_napi_del(&sds_ring->napi);
221 }
222
223 qlcnic_free_sds_rings(&adapter->recv_ctx);
224}
225
226static void
227qlcnic_napi_enable(struct qlcnic_adapter *adapter)
228{
229 int ring;
230 struct qlcnic_host_sds_ring *sds_ring;
231 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
232
780ab790
AKS		 233 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
234 return;
235
af19b491
AKS		 236 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
237 sds_ring = &recv_ctx->sds_rings[ring];
238 napi_enable(&sds_ring->napi);
239 qlcnic_enable_int(sds_ring);
240 }
241}
242
243static void
244qlcnic_napi_disable(struct qlcnic_adapter *adapter)
245{
246 int ring;
247 struct qlcnic_host_sds_ring *sds_ring;
248 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
249
780ab790
AKS		 250 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
251 return;
252
af19b491
AKS		 253 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
254 sds_ring = &recv_ctx->sds_rings[ring];
255 qlcnic_disable_int(sds_ring);
256 napi_synchronize(&sds_ring->napi);
257 napi_disable(&sds_ring->napi);
258 }
259}
260
261static void qlcnic_clear_stats(struct qlcnic_adapter *adapter)
262{
263 memset(&adapter->stats, 0, sizeof(adapter->stats));
af19b491
AKS		 264}
265
af19b491
AKS		 266static void qlcnic_set_port_mode(struct qlcnic_adapter *adapter)
267{
268 u32 val, data;
269
270 val = adapter->ahw.board_type;
271 if ((val == QLCNIC_BRDTYPE_P3_HMEZ) ||
272 (val == QLCNIC_BRDTYPE_P3_XG_LOM)) {
273 if (port_mode == QLCNIC_PORT_MODE_802_3_AP) {
274 data = QLCNIC_PORT_MODE_802_3_AP;
275 QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
276 } else if (port_mode == QLCNIC_PORT_MODE_XG) {
277 data = QLCNIC_PORT_MODE_XG;
278 QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
279 } else if (port_mode == QLCNIC_PORT_MODE_AUTO_NEG_1G) {
280 data = QLCNIC_PORT_MODE_AUTO_NEG_1G;
281 QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
282 } else if (port_mode == QLCNIC_PORT_MODE_AUTO_NEG_XG) {
283 data = QLCNIC_PORT_MODE_AUTO_NEG_XG;
284 QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
285 } else {
286 data = QLCNIC_PORT_MODE_AUTO_NEG;
287 QLCWR32(adapter, QLCNIC_PORT_MODE_ADDR, data);
288 }
289
290 if ((wol_port_mode != QLCNIC_PORT_MODE_802_3_AP) &&
291 (wol_port_mode != QLCNIC_PORT_MODE_XG) &&
292 (wol_port_mode != QLCNIC_PORT_MODE_AUTO_NEG_1G) &&
293 (wol_port_mode != QLCNIC_PORT_MODE_AUTO_NEG_XG)) {
294 wol_port_mode = QLCNIC_PORT_MODE_AUTO_NEG;
295 }
296 QLCWR32(adapter, QLCNIC_WOL_PORT_MODE, wol_port_mode);
297 }
298}
299
300static void qlcnic_set_msix_bit(struct pci_dev *pdev, int enable)
301{
302 u32 control;
303 int pos;
304
305 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
306 if (pos) {
307 pci_read_config_dword(pdev, pos, &control);
308 if (enable)
309 control |= PCI_MSIX_FLAGS_ENABLE;
310 else
311 control = 0;
312 pci_write_config_dword(pdev, pos, control);
313 }
314}
315
316static void qlcnic_init_msix_entries(struct qlcnic_adapter *adapter, int count)
317{
318 int i;
319
320 for (i = 0; i < count; i++)
321 adapter->msix_entries[i].entry = i;
322}
323
324static int
325qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
326{
2e9d722d 327 u8 mac_addr[ETH_ALEN];
af19b491
AKS		 328 struct net_device *netdev = adapter->netdev;
329 struct pci_dev *pdev = adapter->pdev;
330
2e9d722d 331 if (adapter->nic_ops->get_mac_addr(adapter, mac_addr) != 0)
af19b491
AKS		 332 return -EIO;
333
2e9d722d 334 memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
af19b491
AKS		 335 memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
336 memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
337
338 /* set station address */
339
340 if (!is_valid_ether_addr(netdev->perm_addr))
341 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
342 netdev->dev_addr);
343
344 return 0;
345}
346
347static int qlcnic_set_mac(struct net_device *netdev, void *p)
348{
349 struct qlcnic_adapter *adapter = netdev_priv(netdev);
350 struct sockaddr *addr = p;
351
352 if (!is_valid_ether_addr(addr->sa_data))
353 return -EINVAL;
354
355 if (netif_running(netdev)) {
356 netif_device_detach(netdev);
357 qlcnic_napi_disable(adapter);
358 }
359
360 memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
361 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
362 qlcnic_set_multi(adapter->netdev);
363
364 if (netif_running(netdev)) {
365 netif_device_attach(netdev);
366 qlcnic_napi_enable(adapter);
367 }
368 return 0;
369}
370
371static const struct net_device_ops qlcnic_netdev_ops = {
372 .ndo_open = qlcnic_open,
373 .ndo_stop = qlcnic_close,
374 .ndo_start_xmit = qlcnic_xmit_frame,
375 .ndo_get_stats = qlcnic_get_stats,
376 .ndo_validate_addr = eth_validate_addr,
377 .ndo_set_multicast_list = qlcnic_set_multi,
378 .ndo_set_mac_address = qlcnic_set_mac,
379 .ndo_change_mtu = qlcnic_change_mtu,
380 .ndo_tx_timeout = qlcnic_tx_timeout,
381#ifdef CONFIG_NET_POLL_CONTROLLER
382 .ndo_poll_controller = qlcnic_poll_controller,
383#endif
384};
385
2e9d722d
AC		 386static struct qlcnic_nic_template qlcnic_ops = {
387 .get_mac_addr = qlcnic_get_mac_addr,
388 .config_bridged_mode = qlcnic_config_bridged_mode,
389 .config_led = qlcnic_config_led,
390 .set_ilb_mode = qlcnic_set_ilb_mode,
9f26f547
AC		 391 .clear_ilb_mode = qlcnic_clear_ilb_mode,
392 .start_firmware = qlcnic_start_firmware
2e9d722d
AC		 393};
394
395static struct qlcnic_nic_template qlcnic_pf_ops = {
396 .get_mac_addr = qlcnic_get_mac_address,
397 .config_bridged_mode = qlcnic_config_bridged_mode,
398 .config_led = qlcnic_config_led,
399 .set_ilb_mode = qlcnic_set_ilb_mode,
9f26f547
AC		 400 .clear_ilb_mode = qlcnic_clear_ilb_mode,
401 .start_firmware = qlcnic_start_firmware
402};
403
404static struct qlcnic_nic_template qlcnic_vf_ops = {
405 .get_mac_addr = qlcnic_get_mac_address,
406 .config_bridged_mode = qlcnicvf_config_bridged_mode,
407 .config_led = qlcnicvf_config_led,
408 .set_ilb_mode = qlcnicvf_set_ilb_mode,
409 .clear_ilb_mode = qlcnicvf_clear_ilb_mode,
410 .start_firmware = qlcnicvf_start_firmware
2e9d722d
AC		 411};
412
af19b491
AKS		 413static void
414qlcnic_setup_intr(struct qlcnic_adapter *adapter)
415{
416 const struct qlcnic_legacy_intr_set *legacy_intrp;
417 struct pci_dev *pdev = adapter->pdev;
418 int err, num_msix;
419
420 if (adapter->rss_supported) {
421 num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
422 MSIX_ENTRIES_PER_ADAPTER : 2;
423 } else
424 num_msix = 1;
425
426 adapter->max_sds_rings = 1;
427
428 adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
429
430 legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
431
432 adapter->int_vec_bit = legacy_intrp->int_vec_bit;
433 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
434 legacy_intrp->tgt_status_reg);
435 adapter->tgt_mask_reg = qlcnic_get_ioaddr(adapter,
436 legacy_intrp->tgt_mask_reg);
437 adapter->isr_int_vec = qlcnic_get_ioaddr(adapter, ISR_INT_VECTOR);
438
439 adapter->crb_int_state_reg = qlcnic_get_ioaddr(adapter,
440 ISR_INT_STATE_REG);
441
442 qlcnic_set_msix_bit(pdev, 0);
443
444 if (adapter->msix_supported) {
445
446 qlcnic_init_msix_entries(adapter, num_msix);
447 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
448 if (err == 0) {
449 adapter->flags |= QLCNIC_MSIX_ENABLED;
450 qlcnic_set_msix_bit(pdev, 1);
451
452 if (adapter->rss_supported)
453 adapter->max_sds_rings = num_msix;
454
455 dev_info(&pdev->dev, "using msi-x interrupts\n");
456 return;
457 }
458
459 if (err > 0)
460 pci_disable_msix(pdev);
461
462 /* fall through for msi */
463 }
464
465 if (use_msi && !pci_enable_msi(pdev)) {
466 adapter->flags |= QLCNIC_MSI_ENABLED;
467 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
468 msi_tgt_status[adapter->ahw.pci_func]);
469 dev_info(&pdev->dev, "using msi interrupts\n");
470 adapter->msix_entries[0].vector = pdev->irq;
471 return;
472 }
473
474 dev_info(&pdev->dev, "using legacy interrupts\n");
475 adapter->msix_entries[0].vector = pdev->irq;
476}
477
478static void
479qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
480{
481 if (adapter->flags & QLCNIC_MSIX_ENABLED)
482 pci_disable_msix(adapter->pdev);
483 if (adapter->flags & QLCNIC_MSI_ENABLED)
484 pci_disable_msi(adapter->pdev);
485}
486
487static void
488qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
489{
490 if (adapter->ahw.pci_base0 != NULL)
491 iounmap(adapter->ahw.pci_base0);
492}
493
2e9d722d
AC		 494static int
495qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
496{
497 u8 id;
498 u32 ref_count;
499 int i, ret = 1;
500 u32 data = QLCNIC_MGMT_FUNC;
501 void __iomem *priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
502
503 /* If other drivers are not in use set their privilege level */
504 ref_count = QLCRD32(adapter, QLCNIC_CRB_DEV_REF_COUNT);
505 ret = qlcnic_api_lock(adapter);
506 if (ret)
507 goto err_lock;
508 if (QLC_DEV_CLR_REF_CNT(ref_count, adapter->ahw.pci_func))
509 goto err_npar;
510
0e33c664
AC		 511 if (qlcnic_config_npars) {
512 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
513 id = adapter->npars[i].id;
514 if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
515 id == adapter->ahw.pci_func)
516 continue;
517 data |= (qlcnic_config_npars &
518 QLC_DEV_SET_DRV(0xf, id));
519 }
520 } else {
521 data = readl(priv_op);
522 data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw.pci_func)) |
523 (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
524 adapter->ahw.pci_func));
2e9d722d
AC		 525 }
526 writel(data, priv_op);
2e9d722d
AC		 527err_npar:
528 qlcnic_api_unlock(adapter);
529err_lock:
530 return ret;
531}
532
2e9d722d
AC		 533static u32
534qlcnic_get_driver_mode(struct qlcnic_adapter *adapter)
535{
536 void __iomem *msix_base_addr;
537 void __iomem *priv_op;
538 u32 func;
539 u32 msix_base;
540 u32 op_mode, priv_level;
541
542 /* Determine FW API version */
543 adapter->fw_hal_version = readl(adapter->ahw.pci_base0 + QLCNIC_FW_API);
544 if (adapter->fw_hal_version == ~0) {
545 adapter->nic_ops = &qlcnic_ops;
546 adapter->fw_hal_version = QLCNIC_FW_BASE;
547 adapter->ahw.pci_func = PCI_FUNC(adapter->pdev->devfn);
0e33c664 548 adapter->capabilities = QLCRD32(adapter, CRB_FW_CAPABILITIES_1);
2e9d722d
AC		 549 dev_info(&adapter->pdev->dev,
550 "FW does not support nic partion\n");
551 return adapter->fw_hal_version;
552 }
553
554 /* Find PCI function number */
555 pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
556 msix_base_addr = adapter->ahw.pci_base0 + QLCNIC_MSIX_BASE;
557 msix_base = readl(msix_base_addr);
558 func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
559 adapter->ahw.pci_func = func;
560
0e33c664
AC		 561 qlcnic_get_nic_info(adapter, adapter->ahw.pci_func);
562
563 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
564 adapter->nic_ops = &qlcnic_ops;
565 return adapter->fw_hal_version;
566 }
567
2e9d722d
AC		 568 /* Determine function privilege level */
569 priv_op = adapter->ahw.pci_base0 + QLCNIC_DRV_OP_MODE;
570 op_mode = readl(priv_op);
0e33c664 571 if (op_mode == QLC_DEV_DRV_DEFAULT)
2e9d722d 572 priv_level = QLCNIC_MGMT_FUNC;
0e33c664 573 else
2e9d722d
AC		 574 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw.pci_func);
575
576 switch (priv_level) {
577 case QLCNIC_MGMT_FUNC:
578 adapter->op_mode = QLCNIC_MGMT_FUNC;
579 adapter->nic_ops = &qlcnic_pf_ops;
0e33c664 580 qlcnic_get_pci_info(adapter);
2e9d722d 581 /* Set privilege level for other functions */
0e33c664 582 qlcnic_set_function_modes(adapter);
2e9d722d
AC		 583 dev_info(&adapter->pdev->dev,
584 "HAL Version: %d, Management function\n",
585 adapter->fw_hal_version);
586 break;
587 case QLCNIC_PRIV_FUNC:
588 adapter->op_mode = QLCNIC_PRIV_FUNC;
589 dev_info(&adapter->pdev->dev,
590 "HAL Version: %d, Privileged function\n",
591 adapter->fw_hal_version);
592 adapter->nic_ops = &qlcnic_pf_ops;
593 break;
9f26f547
AC		 594 case QLCNIC_NON_PRIV_FUNC:
595 adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
596 dev_info(&adapter->pdev->dev,
597 "HAL Version: %d Non Privileged function\n",
598 adapter->fw_hal_version);
599 adapter->nic_ops = &qlcnic_vf_ops;
600 break;
2e9d722d
AC		 601 default:
602 dev_info(&adapter->pdev->dev, "Unknown function mode: %d\n",
603 priv_level);
604 return 0;
605 }
606 return adapter->fw_hal_version;
607}
608
af19b491
AKS		 609static int
610qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
611{
612 void __iomem *mem_ptr0 = NULL;
613 resource_size_t mem_base;
614 unsigned long mem_len, pci_len0 = 0;
615
616 struct pci_dev *pdev = adapter->pdev;
af19b491 617
af19b491
AKS		 618 /* remap phys address */
619 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
620 mem_len = pci_resource_len(pdev, 0);
621
622 if (mem_len == QLCNIC_PCI_2MB_SIZE) {
623
624 mem_ptr0 = pci_ioremap_bar(pdev, 0);
625 if (mem_ptr0 == NULL) {
626 dev_err(&pdev->dev, "failed to map PCI bar 0\n");
627 return -EIO;
628 }
629 pci_len0 = mem_len;
630 } else {
631 return -EIO;
632 }
633
634 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
635
636 adapter->ahw.pci_base0 = mem_ptr0;
637 adapter->ahw.pci_len0 = pci_len0;
638
2e9d722d
AC		 639 if (!qlcnic_get_driver_mode(adapter)) {
640 iounmap(adapter->ahw.pci_base0);
641 return -EIO;
642 }
643
af19b491 644 adapter->ahw.ocm_win_crb = qlcnic_get_ioaddr(adapter,
2e9d722d 645 QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(adapter->ahw.pci_func)));
af19b491
AKS		 646
647 return 0;
648}
649
650static void get_brd_name(struct qlcnic_adapter *adapter, char *name)
651{
652 struct pci_dev *pdev = adapter->pdev;
653 int i, found = 0;
654
655 for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
656 if (qlcnic_boards[i].vendor == pdev->vendor &&
657 qlcnic_boards[i].device == pdev->device &&
658 qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
659 qlcnic_boards[i].sub_device == pdev->subsystem_device) {
02f6e46f
SC		 660 sprintf(name, "%pM: %s" ,
661 adapter->mac_addr,
662 qlcnic_boards[i].short_name);
af19b491
AKS		 663 found = 1;
664 break;
665 }
666
667 }
668
669 if (!found)
7f9a0c34 670 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
af19b491
AKS		 671}
672
673static void
674qlcnic_check_options(struct qlcnic_adapter *adapter)
675{
676 u32 fw_major, fw_minor, fw_build;
677 char brd_name[QLCNIC_MAX_BOARD_NAME_LEN];
678 char serial_num[32];
679 int i, offset, val;
680 int *ptr32;
681 struct pci_dev *pdev = adapter->pdev;
682
683 adapter->driver_mismatch = 0;
684
685 ptr32 = (int *)&serial_num;
686 offset = QLCNIC_FW_SERIAL_NUM_OFFSET;
687 for (i = 0; i < 8; i++) {
688 if (qlcnic_rom_fast_read(adapter, offset, &val) == -1) {
689 dev_err(&pdev->dev, "error reading board info\n");
690 adapter->driver_mismatch = 1;
691 return;
692 }
693 ptr32[i] = cpu_to_le32(val);
694 offset += sizeof(u32);
695 }
696
697 fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
698 fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
699 fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
700
701 adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
702
703 if (adapter->portnum == 0) {
704 get_brd_name(adapter, brd_name);
705
706 pr_info("%s: %s Board Chip rev 0x%x\n",
707 module_name(THIS_MODULE),
708 brd_name, adapter->ahw.revision_id);
709 }
710
251a84c9
AKS		 711 dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
712 fw_major, fw_minor, fw_build);
af19b491 713
af19b491
AKS		 714 adapter->flags &= ~QLCNIC_LRO_ENABLED;
715
716 if (adapter->ahw.port_type == QLCNIC_XGBE) {
717 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
718 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
719 } else if (adapter->ahw.port_type == QLCNIC_GBE) {
720 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
721 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
722 }
723
0e33c664
AC		 724 qlcnic_get_nic_info(adapter, adapter->ahw.pci_func);
725
af19b491
AKS		 726 adapter->msix_supported = !!use_msi_x;
727 adapter->rss_supported = !!use_msi_x;
728
729 adapter->num_txd = MAX_CMD_DESCRIPTORS;
730
af19b491
AKS		 731 adapter->max_rds_rings = 2;
732}
733
734static int
735qlcnic_start_firmware(struct qlcnic_adapter *adapter)
736{
737 int val, err, first_boot;
738
aa5e18c0
SC		 739 err = qlcnic_can_start_firmware(adapter);
740 if (err < 0)
741 return err;
742 else if (!err)
af19b491
AKS		 743 goto wait_init;
744
745 first_boot = QLCRD32(adapter, QLCNIC_CAM_RAM(0x1fc));
746 if (first_boot == 0x55555555)
747 /* This is the first boot after power up */
748 QLCWR32(adapter, QLCNIC_CAM_RAM(0x1fc), QLCNIC_BDINFO_MAGIC);
749
4d5bdb38
AKS		 750 if (load_fw_file)
751 qlcnic_request_firmware(adapter);
8f891387 752 else {
753 if (qlcnic_check_flash_fw_ver(adapter))
754 goto err_out;
755
4d5bdb38 756 adapter->fw_type = QLCNIC_FLASH_ROMIMAGE;
8f891387 757 }
af19b491
AKS		 758
759 err = qlcnic_need_fw_reset(adapter);
760 if (err < 0)
761 goto err_out;
762 if (err == 0)
763 goto wait_init;
764
765 if (first_boot != 0x55555555) {
766 QLCWR32(adapter, CRB_CMDPEG_STATE, 0);
767 qlcnic_pinit_from_rom(adapter);
768 msleep(1);
769 }
770
af19b491
AKS		 771 QLCWR32(adapter, QLCNIC_PEG_HALT_STATUS1, 0);
772 QLCWR32(adapter, QLCNIC_PEG_HALT_STATUS2, 0);
773
774 qlcnic_set_port_mode(adapter);
775
776 err = qlcnic_load_firmware(adapter);
777 if (err)
778 goto err_out;
779
780 qlcnic_release_firmware(adapter);
781
782 val = (_QLCNIC_LINUX_MAJOR << 16)
783 | ((_QLCNIC_LINUX_MINOR << 8))
784 | (_QLCNIC_LINUX_SUBVERSION);
785 QLCWR32(adapter, CRB_DRIVER_VERSION, val);
786
787wait_init:
788 /* Handshake with the card before we register the devices. */
789 err = qlcnic_phantom_init(adapter);
790 if (err)
791 goto err_out;
792
793 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
6df900e9 794 qlcnic_idc_debug_info(adapter, 1);
af19b491 795
af19b491
AKS		 796 qlcnic_check_options(adapter);
797
0e33c664
AC		 798 if (adapter->flags & QLCNIC_ESWITCH_ENABLED &&
799 adapter->op_mode != QLCNIC_NON_PRIV_FUNC)
800 qlcnic_dev_set_npar_ready(adapter);
2e9d722d 801
af19b491
AKS		 802 adapter->need_fw_reset = 0;
803
a7fc948f
AKS		 804 qlcnic_release_firmware(adapter);
805 return 0;
af19b491
AKS		 806
807err_out:
a7fc948f
AKS		 808 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
809 dev_err(&adapter->pdev->dev, "Device state set to failed\n");
af19b491
AKS		 810 qlcnic_release_firmware(adapter);
811 return err;
812}
813
814static int
815qlcnic_request_irq(struct qlcnic_adapter *adapter)
816{
817 irq_handler_t handler;
818 struct qlcnic_host_sds_ring *sds_ring;
819 int err, ring;
820
821 unsigned long flags = 0;
822 struct net_device *netdev = adapter->netdev;
823 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
824
7eb9855d
AKS		 825 if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
826 handler = qlcnic_tmp_intr;
827 if (!QLCNIC_IS_MSI_FAMILY(adapter))
828 flags |= IRQF_SHARED;
829
830 } else {
831 if (adapter->flags & QLCNIC_MSIX_ENABLED)
832 handler = qlcnic_msix_intr;
833 else if (adapter->flags & QLCNIC_MSI_ENABLED)
834 handler = qlcnic_msi_intr;
835 else {
836 flags |= IRQF_SHARED;
837 handler = qlcnic_intr;
838 }
af19b491
AKS		 839 }
840 adapter->irq = netdev->irq;
841
842 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
843 sds_ring = &recv_ctx->sds_rings[ring];
844 sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
845 err = request_irq(sds_ring->irq, handler,
846 flags, sds_ring->name, sds_ring);
847 if (err)
848 return err;
849 }
850
851 return 0;
852}
853
854static void
855qlcnic_free_irq(struct qlcnic_adapter *adapter)
856{
857 int ring;
858 struct qlcnic_host_sds_ring *sds_ring;
859
860 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
861
862 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
863 sds_ring = &recv_ctx->sds_rings[ring];
864 free_irq(sds_ring->irq, sds_ring);
865 }
866}
867
868static void
869qlcnic_init_coalesce_defaults(struct qlcnic_adapter *adapter)
870{
871 adapter->coal.flags = QLCNIC_INTR_DEFAULT;
872 adapter->coal.normal.data.rx_time_us =
873 QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
874 adapter->coal.normal.data.rx_packets =
875 QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
876 adapter->coal.normal.data.tx_time_us =
877 QLCNIC_DEFAULT_INTR_COALESCE_TX_TIME_US;
878 adapter->coal.normal.data.tx_packets =
879 QLCNIC_DEFAULT_INTR_COALESCE_TX_PACKETS;
880}
881
882static int
883__qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
884{
885 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
886 return -EIO;
887
888 qlcnic_set_multi(netdev);
889 qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
890
891 adapter->ahw.linkup = 0;
892
893 if (adapter->max_sds_rings > 1)
894 qlcnic_config_rss(adapter, 1);
895
896 qlcnic_config_intr_coalesce(adapter);
897
898 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
899 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
900
901 qlcnic_napi_enable(adapter);
902
903 qlcnic_linkevent_request(adapter, 1);
904
905 set_bit(__QLCNIC_DEV_UP, &adapter->state);
906 return 0;
907}
908
909/* Usage: During resume and firmware recovery module.*/
910
911static int
912qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
913{
914 int err = 0;
915
916 rtnl_lock();
917 if (netif_running(netdev))
918 err = __qlcnic_up(adapter, netdev);
919 rtnl_unlock();
920
921 return err;
922}
923
924static void
925__qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
926{
927 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
928 return;
929
930 if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
931 return;
932
933 smp_mb();
934 spin_lock(&adapter->tx_clean_lock);
935 netif_carrier_off(netdev);
936 netif_tx_disable(netdev);
937
938 qlcnic_free_mac_list(adapter);
939
940 qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
941
942 qlcnic_napi_disable(adapter);
943
944 qlcnic_release_tx_buffers(adapter);
945 spin_unlock(&adapter->tx_clean_lock);
946}
947
948/* Usage: During suspend and firmware recovery module */
949
950static void
951qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
952{
953 rtnl_lock();
954 if (netif_running(netdev))
955 __qlcnic_down(adapter, netdev);
956 rtnl_unlock();
957
958}
959
960static int
961qlcnic_attach(struct qlcnic_adapter *adapter)
962{
963 struct net_device *netdev = adapter->netdev;
964 struct pci_dev *pdev = adapter->pdev;
965 int err, ring;
966 struct qlcnic_host_rds_ring *rds_ring;
967
968 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
969 return 0;
970
971 err = qlcnic_init_firmware(adapter);
972 if (err)
973 return err;
974
975 err = qlcnic_napi_add(adapter, netdev);
976 if (err)
977 return err;
978
979 err = qlcnic_alloc_sw_resources(adapter);
980 if (err) {
981 dev_err(&pdev->dev, "Error in setting sw resources\n");
982 return err;
983 }
984
985 err = qlcnic_alloc_hw_resources(adapter);
986 if (err) {
987 dev_err(&pdev->dev, "Error in setting hw resources\n");
988 goto err_out_free_sw;
989 }
990
991
992 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
993 rds_ring = &adapter->recv_ctx.rds_rings[ring];
994 qlcnic_post_rx_buffers(adapter, ring, rds_ring);
995 }
996
997 err = qlcnic_request_irq(adapter);
998 if (err) {
999 dev_err(&pdev->dev, "failed to setup interrupt\n");
1000 goto err_out_free_rxbuf;
1001 }
1002
1003 qlcnic_init_coalesce_defaults(adapter);
1004
1005 qlcnic_create_sysfs_entries(adapter);
1006
1007 adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1008 return 0;
1009
1010err_out_free_rxbuf:
1011 qlcnic_release_rx_buffers(adapter);
1012 qlcnic_free_hw_resources(adapter);
1013err_out_free_sw:
1014 qlcnic_free_sw_resources(adapter);
1015 return err;
1016}
1017
1018static void
1019qlcnic_detach(struct qlcnic_adapter *adapter)
1020{
1021 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1022 return;
1023
1024 qlcnic_remove_sysfs_entries(adapter);
1025
1026 qlcnic_free_hw_resources(adapter);
1027 qlcnic_release_rx_buffers(adapter);
1028 qlcnic_free_irq(adapter);
1029 qlcnic_napi_del(adapter);
1030 qlcnic_free_sw_resources(adapter);
1031
1032 adapter->is_up = 0;
1033}
1034
7eb9855d
AKS		 1035void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1036{
1037 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1038 struct qlcnic_host_sds_ring *sds_ring;
1039 int ring;
1040
78ad3892 1041 clear_bit(__QLCNIC_DEV_UP, &adapter->state);
cdaff185
AKS		 1042 if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1043 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1044 sds_ring = &adapter->recv_ctx.sds_rings[ring];
1045 qlcnic_disable_int(sds_ring);
1046 }
7eb9855d
AKS		 1047 }
1048
1049 qlcnic_detach(adapter);
1050
1051 adapter->diag_test = 0;
1052 adapter->max_sds_rings = max_sds_rings;
1053
1054 if (qlcnic_attach(adapter))
34ce3626 1055 goto out;
7eb9855d
AKS		 1056
1057 if (netif_running(netdev))
1058 __qlcnic_up(adapter, netdev);
34ce3626 1059out:
7eb9855d
AKS		 1060 netif_device_attach(netdev);
1061}
1062
1063int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1064{
1065 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1066 struct qlcnic_host_sds_ring *sds_ring;
1067 int ring;
1068 int ret;
1069
1070 netif_device_detach(netdev);
1071
1072 if (netif_running(netdev))
1073 __qlcnic_down(adapter, netdev);
1074
1075 qlcnic_detach(adapter);
1076
1077 adapter->max_sds_rings = 1;
1078 adapter->diag_test = test;
1079
1080 ret = qlcnic_attach(adapter);
34ce3626
AKS		 1081 if (ret) {
1082 netif_device_attach(netdev);
7eb9855d 1083 return ret;
34ce3626 1084 }
7eb9855d 1085
cdaff185
AKS		 1086 if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1087 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1088 sds_ring = &adapter->recv_ctx.sds_rings[ring];
1089 qlcnic_enable_int(sds_ring);
1090 }
7eb9855d 1091 }
78ad3892 1092 set_bit(__QLCNIC_DEV_UP, &adapter->state);
7eb9855d
AKS		 1093
1094 return 0;
1095}
1096
af19b491
AKS		 1097int
1098qlcnic_reset_context(struct qlcnic_adapter *adapter)
1099{
1100 int err = 0;
1101 struct net_device *netdev = adapter->netdev;
1102
1103 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1104 return -EBUSY;
1105
1106 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1107
1108 netif_device_detach(netdev);
1109
1110 if (netif_running(netdev))
1111 __qlcnic_down(adapter, netdev);
1112
1113 qlcnic_detach(adapter);
1114
1115 if (netif_running(netdev)) {
1116 err = qlcnic_attach(adapter);
1117 if (!err)
34ce3626 1118 __qlcnic_up(adapter, netdev);
af19b491
AKS		 1119 }
1120
1121 netif_device_attach(netdev);
1122 }
1123
af19b491
AKS		 1124 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1125 return err;
1126}
1127
1128static int
1129qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
1bb09fb9 1130 struct net_device *netdev, u8 pci_using_dac)
af19b491
AKS		 1131{
1132 int err;
1133 struct pci_dev *pdev = adapter->pdev;
1134
1135 adapter->rx_csum = 1;
1136 adapter->mc_enabled = 0;
1137 adapter->max_mc_count = 38;
1138
1139 netdev->netdev_ops = &qlcnic_netdev_ops;
1140 netdev->watchdog_timeo = 2*HZ;
1141
1142 qlcnic_change_mtu(netdev, netdev->mtu);
1143
1144 SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1145
2e9d722d
AC		 1146 netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1147 NETIF_F_IPV6_CSUM | NETIF_F_GRO | NETIF_F_TSO | NETIF_F_TSO6);
af19b491 1148
2e9d722d
AC		 1149 netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1150 NETIF_F_IPV6_CSUM | NETIF_F_TSO | NETIF_F_TSO6);
af19b491 1151
1bb09fb9 1152 if (pci_using_dac) {
af19b491
AKS		 1153 netdev->features |= NETIF_F_HIGHDMA;
1154 netdev->vlan_features |= NETIF_F_HIGHDMA;
1155 }
1156
1157 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX)
1158 netdev->features |= (NETIF_F_HW_VLAN_TX);
1159
1160 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1161 netdev->features |= NETIF_F_LRO;
1162
1163 netdev->irq = adapter->msix_entries[0].vector;
1164
1165 INIT_WORK(&adapter->tx_timeout_task, qlcnic_tx_timeout_task);
1166
1167 if (qlcnic_read_mac_addr(adapter))
1168 dev_warn(&pdev->dev, "failed to read mac addr\n");
1169
1170 netif_carrier_off(netdev);
1171 netif_stop_queue(netdev);
1172
1173 err = register_netdev(netdev);
1174 if (err) {
1175 dev_err(&pdev->dev, "failed to register net device\n");
1176 return err;
1177 }
1178
1179 return 0;
1180}
1181
1bb09fb9
AKS		 1182static int qlcnic_set_dma_mask(struct pci_dev *pdev, u8 *pci_using_dac)
1183{
1184 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1185 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1186 *pci_using_dac = 1;
1187 else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1188 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1189 *pci_using_dac = 0;
1190 else {
1191 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1192 return -EIO;
1193 }
1194
1195 return 0;
1196}
1197
af19b491
AKS		 1198static int __devinit
1199qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1200{
1201 struct net_device *netdev = NULL;
1202 struct qlcnic_adapter *adapter = NULL;
1203 int err;
af19b491 1204 uint8_t revision_id;
1bb09fb9 1205 uint8_t pci_using_dac;
af19b491
AKS		 1206
1207 err = pci_enable_device(pdev);
1208 if (err)
1209 return err;
1210
1211 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1212 err = -ENODEV;
1213 goto err_out_disable_pdev;
1214 }
1215
1bb09fb9
AKS		 1216 err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1217 if (err)
1218 goto err_out_disable_pdev;
1219
af19b491
AKS		 1220 err = pci_request_regions(pdev, qlcnic_driver_name);
1221 if (err)
1222 goto err_out_disable_pdev;
1223
1224 pci_set_master(pdev);
1225
1226 netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1227 if (!netdev) {
1228 dev_err(&pdev->dev, "failed to allocate net_device\n");
1229 err = -ENOMEM;
1230 goto err_out_free_res;
1231 }
1232
1233 SET_NETDEV_DEV(netdev, &pdev->dev);
1234
1235 adapter = netdev_priv(netdev);
1236 adapter->netdev = netdev;
1237 adapter->pdev = pdev;
6df900e9 1238 adapter->dev_rst_time = jiffies;
af19b491
AKS		 1239
1240 revision_id = pdev->revision;
1241 adapter->ahw.revision_id = revision_id;
1242
1243 rwlock_init(&adapter->ahw.crb_lock);
1244 mutex_init(&adapter->ahw.mem_lock);
1245
1246 spin_lock_init(&adapter->tx_clean_lock);
1247 INIT_LIST_HEAD(&adapter->mac_list);
1248
1249 err = qlcnic_setup_pci_map(adapter);
1250 if (err)
1251 goto err_out_free_netdev;
1252
1253 /* This will be reset for mezz cards */
2e9d722d 1254 adapter->portnum = adapter->ahw.pci_func;
af19b491
AKS		 1255
1256 err = qlcnic_get_board_info(adapter);
1257 if (err) {
1258 dev_err(&pdev->dev, "Error getting board config info.\n");
1259 goto err_out_iounmap;
1260 }
1261
02f6e46f
SC		 1262 if (qlcnic_read_mac_addr(adapter))
1263 dev_warn(&pdev->dev, "failed to read mac addr\n");
1264
b3a24649
SC		 1265 if (qlcnic_setup_idc_param(adapter))
1266 goto err_out_iounmap;
af19b491 1267
9f26f547 1268 err = adapter->nic_ops->start_firmware(adapter);
a7fc948f
AKS		 1269 if (err) {
1270 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
af19b491 1271 goto err_out_decr_ref;
a7fc948f 1272 }
af19b491 1273
af19b491
AKS		 1274 qlcnic_clear_stats(adapter);
1275
1276 qlcnic_setup_intr(adapter);
1277
1bb09fb9 1278 err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
af19b491
AKS		 1279 if (err)
1280 goto err_out_disable_msi;
1281
1282 pci_set_drvdata(pdev, adapter);
1283
1284 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1285
1286 switch (adapter->ahw.port_type) {
1287 case QLCNIC_GBE:
1288 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1289 adapter->netdev->name);
1290 break;
1291 case QLCNIC_XGBE:
1292 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1293 adapter->netdev->name);
1294 break;
1295 }
1296
1297 qlcnic_create_diag_entries(adapter);
1298
1299 return 0;
1300
1301err_out_disable_msi:
1302 qlcnic_teardown_intr(adapter);
1303
1304err_out_decr_ref:
1305 qlcnic_clr_all_drv_state(adapter);
1306
1307err_out_iounmap:
1308 qlcnic_cleanup_pci_map(adapter);
1309
1310err_out_free_netdev:
1311 free_netdev(netdev);
1312
1313err_out_free_res:
1314 pci_release_regions(pdev);
1315
1316err_out_disable_pdev:
1317 pci_set_drvdata(pdev, NULL);
1318 pci_disable_device(pdev);
1319 return err;
1320}
1321
1322static void __devexit qlcnic_remove(struct pci_dev *pdev)
1323{
1324 struct qlcnic_adapter *adapter;
1325 struct net_device *netdev;
1326
1327 adapter = pci_get_drvdata(pdev);
1328 if (adapter == NULL)
1329 return;
1330
1331 netdev = adapter->netdev;
1332
1333 qlcnic_cancel_fw_work(adapter);
1334
1335 unregister_netdev(netdev);
1336
1337 cancel_work_sync(&adapter->tx_timeout_task);
1338
1339 qlcnic_detach(adapter);
1340
2e9d722d
AC		 1341 if (adapter->npars != NULL)
1342 kfree(adapter->npars);
1343 if (adapter->eswitch != NULL)
1344 kfree(adapter->eswitch);
1345
af19b491
AKS		 1346 qlcnic_clr_all_drv_state(adapter);
1347
1348 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1349
1350 qlcnic_teardown_intr(adapter);
1351
1352 qlcnic_remove_diag_entries(adapter);
1353
1354 qlcnic_cleanup_pci_map(adapter);
1355
1356 qlcnic_release_firmware(adapter);
1357
1358 pci_release_regions(pdev);
1359 pci_disable_device(pdev);
1360 pci_set_drvdata(pdev, NULL);
1361
1362 free_netdev(netdev);
1363}
1364static int __qlcnic_shutdown(struct pci_dev *pdev)
1365{
1366 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1367 struct net_device *netdev = adapter->netdev;
1368 int retval;
1369
1370 netif_device_detach(netdev);
1371
1372 qlcnic_cancel_fw_work(adapter);
1373
1374 if (netif_running(netdev))
1375 qlcnic_down(adapter, netdev);
1376
1377 cancel_work_sync(&adapter->tx_timeout_task);
1378
1379 qlcnic_detach(adapter);
1380
1381 qlcnic_clr_all_drv_state(adapter);
1382
1383 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1384
1385 retval = pci_save_state(pdev);
1386 if (retval)
1387 return retval;
1388
1389 if (qlcnic_wol_supported(adapter)) {
1390 pci_enable_wake(pdev, PCI_D3cold, 1);
1391 pci_enable_wake(pdev, PCI_D3hot, 1);
1392 }
1393
1394 return 0;
1395}
1396
1397static void qlcnic_shutdown(struct pci_dev *pdev)
1398{
1399 if (__qlcnic_shutdown(pdev))
1400 return;
1401
1402 pci_disable_device(pdev);
1403}
1404
1405#ifdef CONFIG_PM
1406static int
1407qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
1408{
1409 int retval;
1410
1411 retval = __qlcnic_shutdown(pdev);
1412 if (retval)
1413 return retval;
1414
1415 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1416 return 0;
1417}
1418
1419static int
1420qlcnic_resume(struct pci_dev *pdev)
1421{
1422 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1423 struct net_device *netdev = adapter->netdev;
1424 int err;
1425
1426 err = pci_enable_device(pdev);
1427 if (err)
1428 return err;
1429
1430 pci_set_power_state(pdev, PCI_D0);
1431 pci_set_master(pdev);
1432 pci_restore_state(pdev);
1433
9f26f547 1434 err = adapter->nic_ops->start_firmware(adapter);
af19b491
AKS		 1435 if (err) {
1436 dev_err(&pdev->dev, "failed to start firmware\n");
1437 return err;
1438 }
1439
1440 if (netif_running(netdev)) {
1441 err = qlcnic_attach(adapter);
1442 if (err)
1443 goto err_out;
1444
1445 err = qlcnic_up(adapter, netdev);
1446 if (err)
1447 goto err_out_detach;
1448
1449
1450 qlcnic_config_indev_addr(netdev, NETDEV_UP);
1451 }
1452
1453 netif_device_attach(netdev);
1454 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1455 return 0;
1456
1457err_out_detach:
1458 qlcnic_detach(adapter);
1459err_out:
1460 qlcnic_clr_all_drv_state(adapter);
34ce3626 1461 netif_device_attach(netdev);
af19b491
AKS		 1462 return err;
1463}
1464#endif
1465
1466static int qlcnic_open(struct net_device *netdev)
1467{
1468 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1469 int err;
1470
1471 if (adapter->driver_mismatch)
1472 return -EIO;
1473
1474 err = qlcnic_attach(adapter);
1475 if (err)
1476 return err;
1477
1478 err = __qlcnic_up(adapter, netdev);
1479 if (err)
1480 goto err_out;
1481
1482 netif_start_queue(netdev);
1483
1484 return 0;
1485
1486err_out:
1487 qlcnic_detach(adapter);
1488 return err;
1489}
1490
1491/*
1492 * qlcnic_close - Disables a network interface entry point
1493 */
1494static int qlcnic_close(struct net_device *netdev)
1495{
1496 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1497
1498 __qlcnic_down(adapter, netdev);
1499 return 0;
1500}
1501
1502static void
1503qlcnic_tso_check(struct net_device *netdev,
1504 struct qlcnic_host_tx_ring *tx_ring,
1505 struct cmd_desc_type0 *first_desc,
1506 struct sk_buff *skb)
1507{
1508 u8 opcode = TX_ETHER_PKT;
1509 __be16 protocol = skb->protocol;
1510 u16 flags = 0, vid = 0;
af19b491
AKS		 1511 int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
1512 struct cmd_desc_type0 *hwdesc;
1513 struct vlan_ethhdr *vh;
8bfe8b91 1514 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2e9d722d 1515 u32 producer = tx_ring->producer;
af19b491
AKS		 1516
1517 if (protocol == cpu_to_be16(ETH_P_8021Q)) {
1518
1519 vh = (struct vlan_ethhdr *)skb->data;
1520 protocol = vh->h_vlan_encapsulated_proto;
1521 flags = FLAGS_VLAN_TAGGED;
1522
1523 } else if (vlan_tx_tag_present(skb)) {
1524
1525 flags = FLAGS_VLAN_OOB;
1526 vid = vlan_tx_tag_get(skb);
1527 qlcnic_set_tx_vlan_tci(first_desc, vid);
1528 vlan_oob = 1;
1529 }
1530
2e9d722d
AC		 1531 if (*(skb->data) & BIT_0) {
1532 flags |= BIT_0;
1533 memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
1534 }
1535
af19b491
AKS		 1536 if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1537 skb_shinfo(skb)->gso_size > 0) {
1538
1539 hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1540
1541 first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1542 first_desc->total_hdr_length = hdr_len;
1543 if (vlan_oob) {
1544 first_desc->total_hdr_length += VLAN_HLEN;
1545 first_desc->tcp_hdr_offset = VLAN_HLEN;
1546 first_desc->ip_hdr_offset = VLAN_HLEN;
1547 /* Only in case of TSO on vlan device */
1548 flags |= FLAGS_VLAN_TAGGED;
1549 }
1550
1551 opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
1552 TX_TCP_LSO6 : TX_TCP_LSO;
1553 tso = 1;
1554
1555 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
1556 u8 l4proto;
1557
1558 if (protocol == cpu_to_be16(ETH_P_IP)) {
1559 l4proto = ip_hdr(skb)->protocol;
1560
1561 if (l4proto == IPPROTO_TCP)
1562 opcode = TX_TCP_PKT;
1563 else if (l4proto == IPPROTO_UDP)
1564 opcode = TX_UDP_PKT;
1565 } else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
1566 l4proto = ipv6_hdr(skb)->nexthdr;
1567
1568 if (l4proto == IPPROTO_TCP)
1569 opcode = TX_TCPV6_PKT;
1570 else if (l4proto == IPPROTO_UDP)
1571 opcode = TX_UDPV6_PKT;
1572 }
1573 }
1574
1575 first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1576 first_desc->ip_hdr_offset += skb_network_offset(skb);
1577 qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
1578
1579 if (!tso)
1580 return;
1581
1582 /* For LSO, we need to copy the MAC/IP/TCP headers into
1583 * the descriptor ring
1584 */
af19b491
AKS		 1585 copied = 0;
1586 offset = 2;
1587
1588 if (vlan_oob) {
1589 /* Create a TSO vlan header template for firmware */
1590
1591 hwdesc = &tx_ring->desc_head[producer];
1592 tx_ring->cmd_buf_arr[producer].skb = NULL;
1593
1594 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1595 hdr_len + VLAN_HLEN);
1596
1597 vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1598 skb_copy_from_linear_data(skb, vh, 12);
1599 vh->h_vlan_proto = htons(ETH_P_8021Q);
1600 vh->h_vlan_TCI = htons(vid);
1601 skb_copy_from_linear_data_offset(skb, 12,
1602 (char *)vh + 16, copy_len - 16);
1603
1604 copied = copy_len - VLAN_HLEN;
1605 offset = 0;
1606
1607 producer = get_next_index(producer, tx_ring->num_desc);
1608 }
1609
1610 while (copied < hdr_len) {
1611
1612 copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1613 (hdr_len - copied));
1614
1615 hwdesc = &tx_ring->desc_head[producer];
1616 tx_ring->cmd_buf_arr[producer].skb = NULL;
1617
1618 skb_copy_from_linear_data_offset(skb, copied,
1619 (char *)hwdesc + offset, copy_len);
1620
1621 copied += copy_len;
1622 offset = 0;
1623
1624 producer = get_next_index(producer, tx_ring->num_desc);
1625 }
1626
1627 tx_ring->producer = producer;
1628 barrier();
8bfe8b91 1629 adapter->stats.lso_frames++;
af19b491
AKS		 1630}
1631
1632static int
1633qlcnic_map_tx_skb(struct pci_dev *pdev,
1634 struct sk_buff *skb, struct qlcnic_cmd_buffer *pbuf)
1635{
1636 struct qlcnic_skb_frag *nf;
1637 struct skb_frag_struct *frag;
1638 int i, nr_frags;
1639 dma_addr_t map;
1640
1641 nr_frags = skb_shinfo(skb)->nr_frags;
1642 nf = &pbuf->frag_array[0];
1643
1644 map = pci_map_single(pdev, skb->data,
1645 skb_headlen(skb), PCI_DMA_TODEVICE);
1646 if (pci_dma_mapping_error(pdev, map))
1647 goto out_err;
1648
1649 nf->dma = map;
1650 nf->length = skb_headlen(skb);
1651
1652 for (i = 0; i < nr_frags; i++) {
1653 frag = &skb_shinfo(skb)->frags[i];
1654 nf = &pbuf->frag_array[i+1];
1655
1656 map = pci_map_page(pdev, frag->page, frag->page_offset,
1657 frag->size, PCI_DMA_TODEVICE);
1658 if (pci_dma_mapping_error(pdev, map))
1659 goto unwind;
1660
1661 nf->dma = map;
1662 nf->length = frag->size;
1663 }
1664
1665 return 0;
1666
1667unwind:
1668 while (--i >= 0) {
1669 nf = &pbuf->frag_array[i+1];
1670 pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
1671 }
1672
1673 nf = &pbuf->frag_array[0];
1674 pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
1675
1676out_err:
1677 return -ENOMEM;
1678}
1679
1680static inline void
1681qlcnic_clear_cmddesc(u64 *desc)
1682{
1683 desc[0] = 0ULL;
1684 desc[2] = 0ULL;
1685}
1686
cdaff185 1687netdev_tx_t
af19b491
AKS		 1688qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
1689{
1690 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1691 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
1692 struct qlcnic_cmd_buffer *pbuf;
1693 struct qlcnic_skb_frag *buffrag;
1694 struct cmd_desc_type0 *hwdesc, *first_desc;
1695 struct pci_dev *pdev;
1696 int i, k;
1697
1698 u32 producer;
1699 int frag_count, no_of_desc;
1700 u32 num_txd = tx_ring->num_desc;
1701
780ab790
AKS		 1702 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1703 netif_stop_queue(netdev);
1704 return NETDEV_TX_BUSY;
1705 }
1706
af19b491
AKS		 1707 frag_count = skb_shinfo(skb)->nr_frags + 1;
1708
1709 /* 4 fragments per cmd des */
1710 no_of_desc = (frag_count + 3) >> 2;
1711
1712 if (unlikely(no_of_desc + 2 > qlcnic_tx_avail(tx_ring))) {
1713 netif_stop_queue(netdev);
8bfe8b91 1714 adapter->stats.xmit_off++;
af19b491
AKS		 1715 return NETDEV_TX_BUSY;
1716 }
1717
1718 producer = tx_ring->producer;
1719 pbuf = &tx_ring->cmd_buf_arr[producer];
1720
1721 pdev = adapter->pdev;
1722
8ae6df97
AKS		 1723 if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
1724 adapter->stats.tx_dma_map_error++;
af19b491 1725 goto drop_packet;
8ae6df97 1726 }
af19b491
AKS		 1727
1728 pbuf->skb = skb;
1729 pbuf->frag_count = frag_count;
1730
1731 first_desc = hwdesc = &tx_ring->desc_head[producer];
1732 qlcnic_clear_cmddesc((u64 *)hwdesc);
1733
1734 qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
1735 qlcnic_set_tx_port(first_desc, adapter->portnum);
1736
1737 for (i = 0; i < frag_count; i++) {
1738
1739 k = i % 4;
1740
1741 if ((k == 0) && (i > 0)) {
1742 /* move to next desc.*/
1743 producer = get_next_index(producer, num_txd);
1744 hwdesc = &tx_ring->desc_head[producer];
1745 qlcnic_clear_cmddesc((u64 *)hwdesc);
1746 tx_ring->cmd_buf_arr[producer].skb = NULL;
1747 }
1748
1749 buffrag = &pbuf->frag_array[i];
1750
1751 hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
1752 switch (k) {
1753 case 0:
1754 hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
1755 break;
1756 case 1:
1757 hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
1758 break;
1759 case 2:
1760 hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
1761 break;
1762 case 3:
1763 hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
1764 break;
1765 }
1766 }
1767
1768 tx_ring->producer = get_next_index(producer, num_txd);
1769
1770 qlcnic_tso_check(netdev, tx_ring, first_desc, skb);
1771
1772 qlcnic_update_cmd_producer(adapter, tx_ring);
1773
1774 adapter->stats.txbytes += skb->len;
1775 adapter->stats.xmitcalled++;
1776
1777 return NETDEV_TX_OK;
1778
1779drop_packet:
1780 adapter->stats.txdropped++;
1781 dev_kfree_skb_any(skb);
1782 return NETDEV_TX_OK;
1783}
1784
1785static int qlcnic_check_temp(struct qlcnic_adapter *adapter)
1786{
1787 struct net_device *netdev = adapter->netdev;
1788 u32 temp, temp_state, temp_val;
1789 int rv = 0;
1790
1791 temp = QLCRD32(adapter, CRB_TEMP_STATE);
1792
1793 temp_state = qlcnic_get_temp_state(temp);
1794 temp_val = qlcnic_get_temp_val(temp);
1795
1796 if (temp_state == QLCNIC_TEMP_PANIC) {
1797 dev_err(&netdev->dev,
1798 "Device temperature %d degrees C exceeds"
1799 " maximum allowed. Hardware has been shut down.\n",
1800 temp_val);
1801 rv = 1;
1802 } else if (temp_state == QLCNIC_TEMP_WARN) {
1803 if (adapter->temp == QLCNIC_TEMP_NORMAL) {
1804 dev_err(&netdev->dev,
1805 "Device temperature %d degrees C "
1806 "exceeds operating range."
1807 " Immediate action needed.\n",
1808 temp_val);
1809 }
1810 } else {
1811 if (adapter->temp == QLCNIC_TEMP_WARN) {
1812 dev_info(&netdev->dev,
1813 "Device temperature is now %d degrees C"
1814 " in normal range.\n", temp_val);
1815 }
1816 }
1817 adapter->temp = temp_state;
1818 return rv;
1819}
1820
1821void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
1822{
1823 struct net_device *netdev = adapter->netdev;
1824
1825 if (adapter->ahw.linkup && !linkup) {
1826 dev_info(&netdev->dev, "NIC Link is down\n");
1827 adapter->ahw.linkup = 0;
1828 if (netif_running(netdev)) {
1829 netif_carrier_off(netdev);
1830 netif_stop_queue(netdev);
1831 }
1832 } else if (!adapter->ahw.linkup && linkup) {
1833 dev_info(&netdev->dev, "NIC Link is up\n");
1834 adapter->ahw.linkup = 1;
1835 if (netif_running(netdev)) {
1836 netif_carrier_on(netdev);
1837 netif_wake_queue(netdev);
1838 }
1839 }
1840}
1841
1842static void qlcnic_tx_timeout(struct net_device *netdev)
1843{
1844 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1845
1846 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1847 return;
1848
1849 dev_err(&netdev->dev, "transmit timeout, resetting.\n");
1850 schedule_work(&adapter->tx_timeout_task);
1851}
1852
1853static void qlcnic_tx_timeout_task(struct work_struct *work)
1854{
1855 struct qlcnic_adapter *adapter =
1856 container_of(work, struct qlcnic_adapter, tx_timeout_task);
1857
1858 if (!netif_running(adapter->netdev))
1859 return;
1860
1861 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1862 return;
1863
1864 if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
1865 goto request_reset;
1866
1867 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1868 if (!qlcnic_reset_context(adapter)) {
1869 adapter->netdev->trans_start = jiffies;
1870 return;
1871
1872 /* context reset failed, fall through for fw reset */
1873 }
1874
1875request_reset:
1876 adapter->need_fw_reset = 1;
1877 clear_bit(__QLCNIC_RESETTING, &adapter->state);
65b5b420 1878 QLCDB(adapter, DRV, "Resetting adapter\n");
af19b491
AKS		 1879}
1880
1881static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
1882{
1883 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1884 struct net_device_stats *stats = &netdev->stats;
1885
1886 memset(stats, 0, sizeof(*stats));
1887
1888 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
1889 stats->tx_packets = adapter->stats.xmitfinished;
7e382594 1890 stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
af19b491
AKS		 1891 stats->tx_bytes = adapter->stats.txbytes;
1892 stats->rx_dropped = adapter->stats.rxdropped;
1893 stats->tx_dropped = adapter->stats.txdropped;
1894
1895 return stats;
1896}
1897
7eb9855d 1898static irqreturn_t qlcnic_clear_legacy_intr(struct qlcnic_adapter *adapter)
af19b491 1899{
af19b491
AKS		 1900 u32 status;
1901
1902 status = readl(adapter->isr_int_vec);
1903
1904 if (!(status & adapter->int_vec_bit))
1905 return IRQ_NONE;
1906
1907 /* check interrupt state machine, to be sure */
1908 status = readl(adapter->crb_int_state_reg);
1909 if (!ISR_LEGACY_INT_TRIGGERED(status))
1910 return IRQ_NONE;
1911
1912 writel(0xffffffff, adapter->tgt_status_reg);
1913 /* read twice to ensure write is flushed */
1914 readl(adapter->isr_int_vec);
1915 readl(adapter->isr_int_vec);
1916
7eb9855d
AKS		 1917 return IRQ_HANDLED;
1918}
1919
1920static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
1921{
1922 struct qlcnic_host_sds_ring *sds_ring = data;
1923 struct qlcnic_adapter *adapter = sds_ring->adapter;
1924
1925 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1926 goto done;
1927 else if (adapter->flags & QLCNIC_MSI_ENABLED) {
1928 writel(0xffffffff, adapter->tgt_status_reg);
1929 goto done;
1930 }
1931
1932 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
1933 return IRQ_NONE;
1934
1935done:
1936 adapter->diag_cnt++;
1937 qlcnic_enable_int(sds_ring);
1938 return IRQ_HANDLED;
1939}
1940
1941static irqreturn_t qlcnic_intr(int irq, void *data)
1942{
1943 struct qlcnic_host_sds_ring *sds_ring = data;
1944 struct qlcnic_adapter *adapter = sds_ring->adapter;
1945
1946 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
1947 return IRQ_NONE;
1948
af19b491
AKS		 1949 napi_schedule(&sds_ring->napi);
1950
1951 return IRQ_HANDLED;
1952}
1953
1954static irqreturn_t qlcnic_msi_intr(int irq, void *data)
1955{
1956 struct qlcnic_host_sds_ring *sds_ring = data;
1957 struct qlcnic_adapter *adapter = sds_ring->adapter;
1958
1959 /* clear interrupt */
1960 writel(0xffffffff, adapter->tgt_status_reg);
1961
1962 napi_schedule(&sds_ring->napi);
1963 return IRQ_HANDLED;
1964}
1965
1966static irqreturn_t qlcnic_msix_intr(int irq, void *data)
1967{
1968 struct qlcnic_host_sds_ring *sds_ring = data;
1969
1970 napi_schedule(&sds_ring->napi);
1971 return IRQ_HANDLED;
1972}
1973
1974static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
1975{
1976 u32 sw_consumer, hw_consumer;
1977 int count = 0, i;
1978 struct qlcnic_cmd_buffer *buffer;
1979 struct pci_dev *pdev = adapter->pdev;
1980 struct net_device *netdev = adapter->netdev;
1981 struct qlcnic_skb_frag *frag;
1982 int done;
1983 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
1984
1985 if (!spin_trylock(&adapter->tx_clean_lock))
1986 return 1;
1987
1988 sw_consumer = tx_ring->sw_consumer;
1989 hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
1990
1991 while (sw_consumer != hw_consumer) {
1992 buffer = &tx_ring->cmd_buf_arr[sw_consumer];
1993 if (buffer->skb) {
1994 frag = &buffer->frag_array[0];
1995 pci_unmap_single(pdev, frag->dma, frag->length,
1996 PCI_DMA_TODEVICE);
1997 frag->dma = 0ULL;
1998 for (i = 1; i < buffer->frag_count; i++) {
1999 frag++;
2000 pci_unmap_page(pdev, frag->dma, frag->length,
2001 PCI_DMA_TODEVICE);
2002 frag->dma = 0ULL;
2003 }
2004
2005 adapter->stats.xmitfinished++;
2006 dev_kfree_skb_any(buffer->skb);
2007 buffer->skb = NULL;
2008 }
2009
2010 sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
2011 if (++count >= MAX_STATUS_HANDLE)
2012 break;
2013 }
2014
2015 if (count && netif_running(netdev)) {
2016 tx_ring->sw_consumer = sw_consumer;
2017
2018 smp_mb();
2019
2020 if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
2021 __netif_tx_lock(tx_ring->txq, smp_processor_id());
2022 if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
2023 netif_wake_queue(netdev);
2024 adapter->tx_timeo_cnt = 0;
8bfe8b91 2025 adapter->stats.xmit_on++;
af19b491
AKS		 2026 }
2027 __netif_tx_unlock(tx_ring->txq);
2028 }
2029 }
2030 /*
2031 * If everything is freed up to consumer then check if the ring is full
2032 * If the ring is full then check if more needs to be freed and
2033 * schedule the call back again.
2034 *
2035 * This happens when there are 2 CPUs. One could be freeing and the
2036 * other filling it. If the ring is full when we get out of here and
2037 * the card has already interrupted the host then the host can miss the
2038 * interrupt.
2039 *
2040 * There is still a possible race condition and the host could miss an
2041 * interrupt. The card has to take care of this.
2042 */
2043 hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2044 done = (sw_consumer == hw_consumer);
2045 spin_unlock(&adapter->tx_clean_lock);
2046
2047 return done;
2048}
2049
2050static int qlcnic_poll(struct napi_struct *napi, int budget)
2051{
2052 struct qlcnic_host_sds_ring *sds_ring =
2053 container_of(napi, struct qlcnic_host_sds_ring, napi);
2054
2055 struct qlcnic_adapter *adapter = sds_ring->adapter;
2056
2057 int tx_complete;
2058 int work_done;
2059
2060 tx_complete = qlcnic_process_cmd_ring(adapter);
2061
2062 work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2063
2064 if ((work_done < budget) && tx_complete) {
2065 napi_complete(&sds_ring->napi);
2066 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2067 qlcnic_enable_int(sds_ring);
2068 }
2069
2070 return work_done;
2071}
2072
8f891387 2073static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
2074{
2075 struct qlcnic_host_sds_ring *sds_ring =
2076 container_of(napi, struct qlcnic_host_sds_ring, napi);
2077
2078 struct qlcnic_adapter *adapter = sds_ring->adapter;
2079 int work_done;
2080
2081 work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2082
2083 if (work_done < budget) {
2084 napi_complete(&sds_ring->napi);
2085 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2086 qlcnic_enable_int(sds_ring);
2087 }
2088
2089 return work_done;
2090}
2091
af19b491
AKS		 2092#ifdef CONFIG_NET_POLL_CONTROLLER
2093static void qlcnic_poll_controller(struct net_device *netdev)
2094{
2095 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2096 disable_irq(adapter->irq);
2097 qlcnic_intr(adapter->irq, adapter);
2098 enable_irq(adapter->irq);
2099}
2100#endif
2101
6df900e9
SC		 2102static void
2103qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2104{
2105 u32 val;
2106
2107 val = adapter->portnum & 0xf;
2108 val |= encoding << 7;
2109 val |= (jiffies - adapter->dev_rst_time) << 8;
2110
2111 QLCWR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2112 adapter->dev_rst_time = jiffies;
2113}
2114
ade91f8e
AKS		 2115static int
2116qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
af19b491
AKS		 2117{
2118 u32 val;
2119
2120 WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2121 state != QLCNIC_DEV_NEED_QUISCENT);
2122
2123 if (qlcnic_api_lock(adapter))
ade91f8e 2124 return -EIO;
af19b491
AKS		 2125
2126 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2127
2128 if (state == QLCNIC_DEV_NEED_RESET)
6d2a4724 2129 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
af19b491 2130 else if (state == QLCNIC_DEV_NEED_QUISCENT)
6d2a4724 2131 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
af19b491
AKS		 2132
2133 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2134
2135 qlcnic_api_unlock(adapter);
ade91f8e
AKS		 2136
2137 return 0;
af19b491
AKS		 2138}
2139
1b95a839
AKS		 2140static int
2141qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2142{
2143 u32 val;
2144
2145 if (qlcnic_api_lock(adapter))
2146 return -EBUSY;
2147
2148 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2149 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
1b95a839
AKS		 2150 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2151
2152 qlcnic_api_unlock(adapter);
2153
2154 return 0;
2155}
2156
af19b491
AKS		 2157static void
2158qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter)
2159{
2160 u32 val;
2161
2162 if (qlcnic_api_lock(adapter))
2163 goto err;
2164
2165 val = QLCRD32(adapter, QLCNIC_CRB_DEV_REF_COUNT);
6d2a4724 2166 QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
af19b491
AKS		 2167 QLCWR32(adapter, QLCNIC_CRB_DEV_REF_COUNT, val);
2168
2169 if (!(val & 0x11111111))
2170 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_COLD);
2171
2172 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2173 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
af19b491
AKS		 2174 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2175
2176 qlcnic_api_unlock(adapter);
2177err:
2178 adapter->fw_fail_cnt = 0;
2179 clear_bit(__QLCNIC_START_FW, &adapter->state);
2180 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2181}
2182
f73dfc50 2183/* Grab api lock, before checking state */
af19b491
AKS		 2184static int
2185qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2186{
2187 int act, state;
2188
2189 state = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2190 act = QLCRD32(adapter, QLCNIC_CRB_DEV_REF_COUNT);
2191
2192 if (((state & 0x11111111) == (act & 0x11111111)) ||
2193 ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2194 return 0;
2195 else
2196 return 1;
2197}
2198
96f8118c
SC		 2199static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2200{
2201 u32 val = QLCRD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
2202
2203 if (val != QLCNIC_DRV_IDC_VER) {
2204 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2205 " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2206 }
2207
2208 return 0;
2209}
2210
af19b491
AKS		 2211static int
2212qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2213{
2214 u32 val, prev_state;
aa5e18c0 2215 u8 dev_init_timeo = adapter->dev_init_timeo;
6d2a4724 2216 u8 portnum = adapter->portnum;
96f8118c 2217 u8 ret;
af19b491 2218
f73dfc50
AKS		 2219 if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2220 return 1;
2221
af19b491
AKS		 2222 if (qlcnic_api_lock(adapter))
2223 return -1;
2224
2225 val = QLCRD32(adapter, QLCNIC_CRB_DEV_REF_COUNT);
6d2a4724
AKS		 2226 if (!(val & (1 << (portnum * 4)))) {
2227 QLC_DEV_SET_REF_CNT(val, portnum);
af19b491 2228 QLCWR32(adapter, QLCNIC_CRB_DEV_REF_COUNT, val);
af19b491
AKS		 2229 }
2230
2231 prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
65b5b420 2232 QLCDB(adapter, HW, "Device state = %u\n", prev_state);
af19b491
AKS		 2233
2234 switch (prev_state) {
2235 case QLCNIC_DEV_COLD:
bbd8c6a4 2236 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
96f8118c 2237 QLCWR32(adapter, QLCNIC_CRB_DRV_IDC_VER, QLCNIC_DRV_IDC_VER);
6df900e9 2238 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 2239 qlcnic_api_unlock(adapter);
2240 return 1;
2241
2242 case QLCNIC_DEV_READY:
96f8118c 2243 ret = qlcnic_check_idc_ver(adapter);
af19b491 2244 qlcnic_api_unlock(adapter);
96f8118c 2245 return ret;
af19b491
AKS		 2246
2247 case QLCNIC_DEV_NEED_RESET:
2248 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2249 QLC_DEV_SET_RST_RDY(val, portnum);
af19b491
AKS		 2250 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2251 break;
2252
2253 case QLCNIC_DEV_NEED_QUISCENT:
2254 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2255 QLC_DEV_SET_QSCNT_RDY(val, portnum);
af19b491
AKS		 2256 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2257 break;
2258
2259 case QLCNIC_DEV_FAILED:
a7fc948f 2260 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
af19b491
AKS		 2261 qlcnic_api_unlock(adapter);
2262 return -1;
bbd8c6a4
AKS		 2263
2264 case QLCNIC_DEV_INITIALIZING:
2265 case QLCNIC_DEV_QUISCENT:
2266 break;
af19b491
AKS		 2267 }
2268
2269 qlcnic_api_unlock(adapter);
aa5e18c0
SC		 2270
2271 do {
af19b491 2272 msleep(1000);
a5e463d0
SC		 2273 prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2274
2275 if (prev_state == QLCNIC_DEV_QUISCENT)
2276 continue;
2277 } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
af19b491 2278
65b5b420
AKS		 2279 if (!dev_init_timeo) {
2280 dev_err(&adapter->pdev->dev,
2281 "Waiting for device to initialize timeout\n");
af19b491 2282 return -1;
65b5b420 2283 }
af19b491
AKS		 2284
2285 if (qlcnic_api_lock(adapter))
2286 return -1;
2287
2288 val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2289 QLC_DEV_CLR_RST_QSCNT(val, portnum);
af19b491
AKS		 2290 QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2291
96f8118c 2292 ret = qlcnic_check_idc_ver(adapter);
af19b491
AKS		 2293 qlcnic_api_unlock(adapter);
2294
96f8118c 2295 return ret;
af19b491
AKS		 2296}
2297
2298static void
2299qlcnic_fwinit_work(struct work_struct *work)
2300{
2301 struct qlcnic_adapter *adapter = container_of(work,
2302 struct qlcnic_adapter, fw_work.work);
9f26f547 2303 u32 dev_state = 0xf, npar_state;
af19b491 2304
f73dfc50
AKS		 2305 if (qlcnic_api_lock(adapter))
2306 goto err_ret;
af19b491 2307
a5e463d0
SC		 2308 dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2309 if (dev_state == QLCNIC_DEV_QUISCENT) {
2310 qlcnic_api_unlock(adapter);
2311 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2312 FW_POLL_DELAY * 2);
2313 return;
2314 }
2315
9f26f547
AC		 2316 if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
2317 npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2318 if (npar_state == QLCNIC_DEV_NPAR_RDY) {
2319 qlcnic_api_unlock(adapter);
2320 goto wait_npar;
2321 } else {
2322 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2323 FW_POLL_DELAY);
2324 qlcnic_api_unlock(adapter);
2325 return;
2326 }
2327 }
2328
f73dfc50
AKS		 2329 if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2330 dev_err(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2331 adapter->reset_ack_timeo);
2332 goto skip_ack_check;
2333 }
2334
2335 if (!qlcnic_check_drv_state(adapter)) {
2336skip_ack_check:
2337 dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
a5e463d0
SC		 2338
2339 if (dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2340 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2341 QLCNIC_DEV_QUISCENT);
2342 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2343 FW_POLL_DELAY * 2);
2344 QLCDB(adapter, DRV, "Quiscing the driver\n");
6df900e9
SC		 2345 qlcnic_idc_debug_info(adapter, 0);
2346
a5e463d0
SC		 2347 qlcnic_api_unlock(adapter);
2348 return;
2349 }
2350
f73dfc50
AKS		 2351 if (dev_state == QLCNIC_DEV_NEED_RESET) {
2352 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2353 QLCNIC_DEV_INITIALIZING);
2354 set_bit(__QLCNIC_START_FW, &adapter->state);
2355 QLCDB(adapter, DRV, "Restarting fw\n");
6df900e9 2356 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 2357 }
2358
f73dfc50
AKS		 2359 qlcnic_api_unlock(adapter);
2360
9f26f547 2361 if (!adapter->nic_ops->start_firmware(adapter)) {
af19b491
AKS		 2362 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2363 return;
2364 }
af19b491
AKS		 2365 goto err_ret;
2366 }
2367
f73dfc50 2368 qlcnic_api_unlock(adapter);
aa5e18c0 2369
9f26f547 2370wait_npar:
af19b491 2371 dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
f73dfc50 2372 QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
65b5b420 2373
af19b491 2374 switch (dev_state) {
a5e463d0
SC		 2375 case QLCNIC_DEV_QUISCENT:
2376 case QLCNIC_DEV_NEED_QUISCENT:
f73dfc50
AKS		 2377 case QLCNIC_DEV_NEED_RESET:
2378 qlcnic_schedule_work(adapter,
2379 qlcnic_fwinit_work, FW_POLL_DELAY);
2380 return;
af19b491
AKS		 2381 case QLCNIC_DEV_FAILED:
2382 break;
2383
2384 default:
9f26f547 2385 if (!adapter->nic_ops->start_firmware(adapter)) {
f73dfc50
AKS		 2386 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2387 return;
2388 }
af19b491
AKS		 2389 }
2390
2391err_ret:
f73dfc50
AKS		 2392 dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2393 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
34ce3626 2394 netif_device_attach(adapter->netdev);
af19b491
AKS		 2395 qlcnic_clr_all_drv_state(adapter);
2396}
2397
2398static void
2399qlcnic_detach_work(struct work_struct *work)
2400{
2401 struct qlcnic_adapter *adapter = container_of(work,
2402 struct qlcnic_adapter, fw_work.work);
2403 struct net_device *netdev = adapter->netdev;
2404 u32 status;
2405
2406 netif_device_detach(netdev);
2407
2408 qlcnic_down(adapter, netdev);
2409
ce668443 2410 rtnl_lock();
af19b491 2411 qlcnic_detach(adapter);
ce668443 2412 rtnl_unlock();
af19b491
AKS		 2413
2414 status = QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2415
2416 if (status & QLCNIC_RCODE_FATAL_ERROR)
2417 goto err_ret;
2418
2419 if (adapter->temp == QLCNIC_TEMP_PANIC)
2420 goto err_ret;
2421
ade91f8e
AKS		 2422 if (qlcnic_set_drv_state(adapter, adapter->dev_state))
2423 goto err_ret;
af19b491
AKS		 2424
2425 adapter->fw_wait_cnt = 0;
2426
2427 qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
2428
2429 return;
2430
2431err_ret:
65b5b420
AKS		 2432 dev_err(&adapter->pdev->dev, "detach failed; status=%d temp=%d\n",
2433 status, adapter->temp);
34ce3626 2434 netif_device_attach(netdev);
af19b491
AKS		 2435 qlcnic_clr_all_drv_state(adapter);
2436
2437}
2438
f73dfc50 2439/*Transit to RESET state from READY state only */
af19b491
AKS		 2440static void
2441qlcnic_dev_request_reset(struct qlcnic_adapter *adapter)
2442{
2443 u32 state;
2444
2445 if (qlcnic_api_lock(adapter))
2446 return;
2447
2448 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2449
f73dfc50 2450 if (state == QLCNIC_DEV_READY) {
af19b491 2451 QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_NEED_RESET);
65b5b420 2452 QLCDB(adapter, DRV, "NEED_RESET state set\n");
6df900e9 2453 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 2454 }
2455
2456 qlcnic_api_unlock(adapter);
2457}
2458
9f26f547
AC		 2459/* Transit to NPAR READY state from NPAR NOT READY state */
2460static void
2461qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
2462{
2463 u32 state;
2464
9f26f547
AC		 2465 if (qlcnic_api_lock(adapter))
2466 return;
2467
2468 state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2469
2470 if (state != QLCNIC_DEV_NPAR_RDY) {
2471 QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2472 QLCNIC_DEV_NPAR_RDY);
2473 QLCDB(adapter, DRV, "NPAR READY state set\n");
2474 }
2475
2476 qlcnic_api_unlock(adapter);
2477}
2478
af19b491
AKS		 2479static void
2480qlcnic_schedule_work(struct qlcnic_adapter *adapter,
2481 work_func_t func, int delay)
2482{
2483 INIT_DELAYED_WORK(&adapter->fw_work, func);
2484 schedule_delayed_work(&adapter->fw_work, round_jiffies_relative(delay));
2485}
2486
2487static void
2488qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter)
2489{
2490 while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2491 msleep(10);
2492
2493 cancel_delayed_work_sync(&adapter->fw_work);
2494}
2495
2496static void
2497qlcnic_attach_work(struct work_struct *work)
2498{
2499 struct qlcnic_adapter *adapter = container_of(work,
2500 struct qlcnic_adapter, fw_work.work);
2501 struct net_device *netdev = adapter->netdev;
2502 int err;
2503
2504 if (netif_running(netdev)) {
2505 err = qlcnic_attach(adapter);
2506 if (err)
2507 goto done;
2508
2509 err = qlcnic_up(adapter, netdev);
2510 if (err) {
2511 qlcnic_detach(adapter);
2512 goto done;
2513 }
2514
2515 qlcnic_config_indev_addr(netdev, NETDEV_UP);
2516 }
2517
af19b491 2518done:
34ce3626 2519 netif_device_attach(netdev);
af19b491
AKS		 2520 adapter->fw_fail_cnt = 0;
2521 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1b95a839
AKS		 2522
2523 if (!qlcnic_clr_drv_state(adapter))
2524 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2525 FW_POLL_DELAY);
af19b491
AKS		 2526}
2527
2528static int
2529qlcnic_check_health(struct qlcnic_adapter *adapter)
2530{
2531 u32 state = 0, heartbit;
2532 struct net_device *netdev = adapter->netdev;
2533
2534 if (qlcnic_check_temp(adapter))
2535 goto detach;
2536
2372a5f1 2537 if (adapter->need_fw_reset)
af19b491 2538 qlcnic_dev_request_reset(adapter);
af19b491
AKS		 2539
2540 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2541 if (state == QLCNIC_DEV_NEED_RESET || state == QLCNIC_DEV_NEED_QUISCENT)
2542 adapter->need_fw_reset = 1;
2543
2544 heartbit = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
2545 if (heartbit != adapter->heartbit) {
2546 adapter->heartbit = heartbit;
2547 adapter->fw_fail_cnt = 0;
2548 if (adapter->need_fw_reset)
2549 goto detach;
2550 return 0;
2551 }
2552
2553 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2554 return 0;
2555
2556 qlcnic_dev_request_reset(adapter);
2557
2558 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
2559
2560 dev_info(&netdev->dev, "firmware hang detected\n");
2561
2562detach:
2563 adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
2564 QLCNIC_DEV_NEED_RESET;
2565
2566 if ((auto_fw_reset == AUTO_FW_RESET_ENABLED) &&
65b5b420
AKS		 2567 !test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) {
2568
af19b491 2569 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
65b5b420
AKS		 2570 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
2571 }
af19b491
AKS		 2572
2573 return 1;
2574}
2575
2576static void
2577qlcnic_fw_poll_work(struct work_struct *work)
2578{
2579 struct qlcnic_adapter *adapter = container_of(work,
2580 struct qlcnic_adapter, fw_work.work);
2581
2582 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2583 goto reschedule;
2584
2585
2586 if (qlcnic_check_health(adapter))
2587 return;
2588
2589reschedule:
2590 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
2591}
2592
87eb743b
AC		 2593static int
2594qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
2595{
2596 int err;
2597
2598 err = qlcnic_can_start_firmware(adapter);
2599 if (err)
2600 return err;
2601
2602 qlcnic_check_options(adapter);
2603
2604 adapter->need_fw_reset = 0;
2605
2606 return err;
2607}
2608
2609static int
2610qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
2611{
2612 return -EOPNOTSUPP;
2613}
2614
2615static int
2616qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
2617{
2618 return -EOPNOTSUPP;
2619}
2620
2621static int
2622qlcnicvf_set_ilb_mode(struct qlcnic_adapter *adapter)
2623{
2624 return -EOPNOTSUPP;
2625}
2626
2627static void
2628qlcnicvf_clear_ilb_mode(struct qlcnic_adapter *adapter)
2629{
2630 return;
2631}
2632
af19b491
AKS		 2633static ssize_t
2634qlcnic_store_bridged_mode(struct device *dev,
2635 struct device_attribute *attr, const char *buf, size_t len)
2636{
2637 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2638 unsigned long new;
2639 int ret = -EINVAL;
2640
2641 if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG))
2642 goto err_out;
2643
2644 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2645 goto err_out;
2646
2647 if (strict_strtoul(buf, 2, &new))
2648 goto err_out;
2649
2e9d722d 2650 if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
af19b491
AKS		 2651 ret = len;
2652
2653err_out:
2654 return ret;
2655}
2656
2657static ssize_t
2658qlcnic_show_bridged_mode(struct device *dev,
2659 struct device_attribute *attr, char *buf)
2660{
2661 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2662 int bridged_mode = 0;
2663
2664 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
2665 bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
2666
2667 return sprintf(buf, "%d\n", bridged_mode);
2668}
2669
2670static struct device_attribute dev_attr_bridged_mode = {
2671 .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
2672 .show = qlcnic_show_bridged_mode,
2673 .store = qlcnic_store_bridged_mode,
2674};
2675
2676static ssize_t
2677qlcnic_store_diag_mode(struct device *dev,
2678 struct device_attribute *attr, const char *buf, size_t len)
2679{
2680 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2681 unsigned long new;
2682
2683 if (strict_strtoul(buf, 2, &new))
2684 return -EINVAL;
2685
2686 if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
2687 adapter->flags ^= QLCNIC_DIAG_ENABLED;
2688
2689 return len;
2690}
2691
2692static ssize_t
2693qlcnic_show_diag_mode(struct device *dev,
2694 struct device_attribute *attr, char *buf)
2695{
2696 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2697
2698 return sprintf(buf, "%d\n",
2699 !!(adapter->flags & QLCNIC_DIAG_ENABLED));
2700}
2701
2702static struct device_attribute dev_attr_diag_mode = {
2703 .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
2704 .show = qlcnic_show_diag_mode,
2705 .store = qlcnic_store_diag_mode,
2706};
2707
2708static int
2709qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
2710 loff_t offset, size_t size)
2711{
897e8c7c
DP		 2712 size_t crb_size = 4;
2713
af19b491
AKS		 2714 if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
2715 return -EIO;
2716
897e8c7c
DP		 2717 if (offset < QLCNIC_PCI_CRBSPACE) {
2718 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
2719 QLCNIC_PCI_CAMQM_END))
2720 crb_size = 8;
2721 else
2722 return -EINVAL;
2723 }
af19b491 2724
897e8c7c
DP		 2725 if ((size != crb_size) || (offset & (crb_size-1)))
2726 return -EINVAL;
af19b491
AKS		 2727
2728 return 0;
2729}
2730
2731static ssize_t
2c3c8bea
CW		 2732qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
2733 struct bin_attribute *attr,
af19b491
AKS		 2734 char *buf, loff_t offset, size_t size)
2735{
2736 struct device *dev = container_of(kobj, struct device, kobj);
2737 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2738 u32 data;
897e8c7c 2739 u64 qmdata;
af19b491
AKS		 2740 int ret;
2741
2742 ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
2743 if (ret != 0)
2744 return ret;
2745
897e8c7c
DP		 2746 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
2747 qlcnic_pci_camqm_read_2M(adapter, offset, &qmdata);
2748 memcpy(buf, &qmdata, size);
2749 } else {
2750 data = QLCRD32(adapter, offset);
2751 memcpy(buf, &data, size);
2752 }
af19b491
AKS		 2753 return size;
2754}
2755
2756static ssize_t
2c3c8bea
CW		 2757qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
2758 struct bin_attribute *attr,
af19b491
AKS		 2759 char *buf, loff_t offset, size_t size)
2760{
2761 struct device *dev = container_of(kobj, struct device, kobj);
2762 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2763 u32 data;
897e8c7c 2764 u64 qmdata;
af19b491
AKS		 2765 int ret;
2766
2767 ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
2768 if (ret != 0)
2769 return ret;
2770
897e8c7c
DP		 2771 if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
2772 memcpy(&qmdata, buf, size);
2773 qlcnic_pci_camqm_write_2M(adapter, offset, qmdata);
2774 } else {
2775 memcpy(&data, buf, size);
2776 QLCWR32(adapter, offset, data);
2777 }
af19b491
AKS		 2778 return size;
2779}
2780
2781static int
2782qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
2783 loff_t offset, size_t size)
2784{
2785 if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
2786 return -EIO;
2787
2788 if ((size != 8) || (offset & 0x7))
2789 return -EIO;
2790
2791 return 0;
2792}
2793
2794static ssize_t
2c3c8bea
CW		 2795qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
2796 struct bin_attribute *attr,
af19b491
AKS		 2797 char *buf, loff_t offset, size_t size)
2798{
2799 struct device *dev = container_of(kobj, struct device, kobj);
2800 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2801 u64 data;
2802 int ret;
2803
2804 ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
2805 if (ret != 0)
2806 return ret;
2807
2808 if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
2809 return -EIO;
2810
2811 memcpy(buf, &data, size);
2812
2813 return size;
2814}
2815
2816static ssize_t
2c3c8bea
CW		 2817qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
2818 struct bin_attribute *attr,
af19b491
AKS		 2819 char *buf, loff_t offset, size_t size)
2820{
2821 struct device *dev = container_of(kobj, struct device, kobj);
2822 struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
2823 u64 data;
2824 int ret;
2825
2826 ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
2827 if (ret != 0)
2828 return ret;
2829
2830 memcpy(&data, buf, size);
2831
2832 if (qlcnic_pci_mem_write_2M(adapter, offset, data))
2833 return -EIO;
2834
2835 return size;
2836}
2837
2838
2839static struct bin_attribute bin_attr_crb = {
2840 .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
2841 .size = 0,
2842 .read = qlcnic_sysfs_read_crb,
2843 .write = qlcnic_sysfs_write_crb,
2844};
2845
2846static struct bin_attribute bin_attr_mem = {
2847 .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
2848 .size = 0,
2849 .read = qlcnic_sysfs_read_mem,
2850 .write = qlcnic_sysfs_write_mem,
2851};
2852
2853static void
2854qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
2855{
2856 struct device *dev = &adapter->pdev->dev;
2857
2858 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
2859 if (device_create_file(dev, &dev_attr_bridged_mode))
2860 dev_warn(dev,
2861 "failed to create bridged_mode sysfs entry\n");
2862}
2863
2864static void
2865qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
2866{
2867 struct device *dev = &adapter->pdev->dev;
2868
2869 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
2870 device_remove_file(dev, &dev_attr_bridged_mode);
2871}
2872
2873static void
2874qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
2875{
2876 struct device *dev = &adapter->pdev->dev;
2877
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
2887static void
2888qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
2889{
2890 struct device *dev = &adapter->pdev->dev;
2891
2892 device_remove_file(dev, &dev_attr_diag_mode);
2893 device_remove_bin_file(dev, &bin_attr_crb);
2894 device_remove_bin_file(dev, &bin_attr_mem);
2895}
2896
2897#ifdef CONFIG_INET
2898
2899#define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
2900
af19b491
AKS		 2901static void
2902qlcnic_config_indev_addr(struct net_device *dev, unsigned long event)
2903{
2904 struct in_device *indev;
2905 struct qlcnic_adapter *adapter = netdev_priv(dev);
2906
af19b491
AKS		 2907 indev = in_dev_get(dev);
2908 if (!indev)
2909 return;
2910
2911 for_ifa(indev) {
2912 switch (event) {
2913 case NETDEV_UP:
2914 qlcnic_config_ipaddr(adapter,
2915 ifa->ifa_address, QLCNIC_IP_UP);
2916 break;
2917 case NETDEV_DOWN:
2918 qlcnic_config_ipaddr(adapter,
2919 ifa->ifa_address, QLCNIC_IP_DOWN);
2920 break;
2921 default:
2922 break;
2923 }
2924 } endfor_ifa(indev);
2925
2926 in_dev_put(indev);
af19b491
AKS		 2927}
2928
2929static int qlcnic_netdev_event(struct notifier_block *this,
2930 unsigned long event, void *ptr)
2931{
2932 struct qlcnic_adapter *adapter;
2933 struct net_device *dev = (struct net_device *)ptr;
2934
2935recheck:
2936 if (dev == NULL)
2937 goto done;
2938
2939 if (dev->priv_flags & IFF_802_1Q_VLAN) {
2940 dev = vlan_dev_real_dev(dev);
2941 goto recheck;
2942 }
2943
2944 if (!is_qlcnic_netdev(dev))
2945 goto done;
2946
2947 adapter = netdev_priv(dev);
2948
2949 if (!adapter)
2950 goto done;
2951
2952 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2953 goto done;
2954
2955 qlcnic_config_indev_addr(dev, event);
2956done:
2957 return NOTIFY_DONE;
2958}
2959
2960static int
2961qlcnic_inetaddr_event(struct notifier_block *this,
2962 unsigned long event, void *ptr)
2963{
2964 struct qlcnic_adapter *adapter;
2965 struct net_device *dev;
2966
2967 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2968
2969 dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
2970
2971recheck:
2972 if (dev == NULL || !netif_running(dev))
2973 goto done;
2974
2975 if (dev->priv_flags & IFF_802_1Q_VLAN) {
2976 dev = vlan_dev_real_dev(dev);
2977 goto recheck;
2978 }
2979
2980 if (!is_qlcnic_netdev(dev))
2981 goto done;
2982
2983 adapter = netdev_priv(dev);
2984
251a84c9 2985 if (!adapter)
af19b491
AKS		 2986 goto done;
2987
2988 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2989 goto done;
2990
2991 switch (event) {
2992 case NETDEV_UP:
2993 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
2994 break;
2995 case NETDEV_DOWN:
2996 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
2997 break;
2998 default:
2999 break;
3000 }
3001
3002done:
3003 return NOTIFY_DONE;
3004}
3005
3006static struct notifier_block qlcnic_netdev_cb = {
3007 .notifier_call = qlcnic_netdev_event,
3008};
3009
3010static struct notifier_block qlcnic_inetaddr_cb = {
3011 .notifier_call = qlcnic_inetaddr_event,
3012};
3013#else
3014static void
3015qlcnic_config_indev_addr(struct net_device *dev, unsigned long event)
3016{ }
3017#endif
3018
3019static struct pci_driver qlcnic_driver = {
3020 .name = qlcnic_driver_name,
3021 .id_table = qlcnic_pci_tbl,
3022 .probe = qlcnic_probe,
3023 .remove = __devexit_p(qlcnic_remove),
3024#ifdef CONFIG_PM
3025 .suspend = qlcnic_suspend,
3026 .resume = qlcnic_resume,
3027#endif
3028 .shutdown = qlcnic_shutdown
3029};
3030
3031static int __init qlcnic_init_module(void)
3032{
3033
3034 printk(KERN_INFO "%s\n", qlcnic_driver_string);
3035
3036#ifdef CONFIG_INET
3037 register_netdevice_notifier(&qlcnic_netdev_cb);
3038 register_inetaddr_notifier(&qlcnic_inetaddr_cb);
3039#endif
3040
3041
3042 return pci_register_driver(&qlcnic_driver);
3043}
3044
3045module_init(qlcnic_init_module);
3046
3047static void __exit qlcnic_exit_module(void)
3048{
3049
3050 pci_unregister_driver(&qlcnic_driver);
3051
3052#ifdef CONFIG_INET
3053 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3054 unregister_netdevice_notifier(&qlcnic_netdev_cb);
3055#endif
3056}
3057
3058module_exit(qlcnic_exit_module);
Clone of davem's net-next-2.6 tree