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