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