Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qlcnic_main.c
Go to the documentation of this file.
1 /*
2  * QLogic qlcnic NIC Driver
3  * Copyright (c) 2009-2010 QLogic Corporation
4  *
5  * See LICENSE.qlcnic for copyright and licensing details.
6  */
7 
8 #include <linux/slab.h>
9 #include <linux/vmalloc.h>
10 #include <linux/interrupt.h>
11 
12 #include "qlcnic.h"
13 
14 #include <linux/swab.h>
15 #include <linux/dma-mapping.h>
16 #include <net/ip.h>
17 #include <linux/ipv6.h>
18 #include <linux/inetdevice.h>
19 #include <linux/sysfs.h>
20 #include <linux/aer.h>
21 #include <linux/log2.h>
22 
23 MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
24 MODULE_LICENSE("GPL");
25 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
26 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
27 
28 char qlcnic_driver_name[] = "qlcnic";
29 static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
30  "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
31 
32 static struct workqueue_struct *qlcnic_wq;
33 static int qlcnic_mac_learn;
34 module_param(qlcnic_mac_learn, int, 0444);
35 MODULE_PARM_DESC(qlcnic_mac_learn, "Mac Filter (0=disabled, 1=enabled)");
36 
37 static int use_msi = 1;
38 module_param(use_msi, int, 0444);
39 MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
40 
41 static int use_msi_x = 1;
42 module_param(use_msi_x, int, 0444);
43 MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
44 
45 static int auto_fw_reset = 1;
46 module_param(auto_fw_reset, int, 0644);
47 MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
48 
49 static int load_fw_file;
50 module_param(load_fw_file, int, 0444);
51 MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
52 
53 static int qlcnic_config_npars;
54 module_param(qlcnic_config_npars, int, 0444);
55 MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
56 
57 static int __devinit qlcnic_probe(struct pci_dev *pdev,
58  const struct pci_device_id *ent);
59 static void __devexit qlcnic_remove(struct pci_dev *pdev);
60 static int qlcnic_open(struct net_device *netdev);
61 static int qlcnic_close(struct net_device *netdev);
62 static void qlcnic_tx_timeout(struct net_device *netdev);
63 static void qlcnic_attach_work(struct work_struct *work);
64 static void qlcnic_fwinit_work(struct work_struct *work);
65 static void qlcnic_fw_poll_work(struct work_struct *work);
66 static void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
67  work_func_t func, int delay);
68 static void qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter);
69 static int qlcnic_poll(struct napi_struct *napi, int budget);
70 static int qlcnic_rx_poll(struct napi_struct *napi, int budget);
71 #ifdef CONFIG_NET_POLL_CONTROLLER
72 static void qlcnic_poll_controller(struct net_device *netdev);
73 #endif
74 
75 static void qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter);
76 static void qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter);
77 static void qlcnic_create_diag_entries(struct qlcnic_adapter *adapter);
78 static void qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter);
79 
80 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
81 static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
82 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
83 
84 static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
85 static irqreturn_t qlcnic_intr(int irq, void *data);
86 static irqreturn_t qlcnic_msi_intr(int irq, void *data);
87 static irqreturn_t qlcnic_msix_intr(int irq, void *data);
88 
89 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
90 static void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long);
91 static int qlcnic_start_firmware(struct qlcnic_adapter *);
92 
93 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
94 static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
95 static int qlcnicvf_config_led(struct qlcnic_adapter *, u32, u32);
96 static int qlcnicvf_config_bridged_mode(struct qlcnic_adapter *, u32);
97 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
98 static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
99  struct qlcnic_esw_func_cfg *);
100 static int qlcnic_vlan_rx_add(struct net_device *, u16);
101 static int qlcnic_vlan_rx_del(struct net_device *, u16);
102 
103 /* PCI Device ID Table */
104 #define ENTRY(device) \
105  {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
106  .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
107 
108 #define PCI_DEVICE_ID_QLOGIC_QLE824X 0x8020
109 
110 static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
111  ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
112  {0,}
113 };
114 
115 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
116 
117 
118 inline void
119 qlcnic_update_cmd_producer(struct qlcnic_adapter *adapter,
120  struct qlcnic_host_tx_ring *tx_ring)
121 {
122  writel(tx_ring->producer, tx_ring->crb_cmd_producer);
123 }
124 
125 static const u32 msi_tgt_status[8] = {
126  ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
127  ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
128  ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
129  ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
130 };
131 
132 static const
133 struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
134 
135 static inline void qlcnic_disable_int(struct qlcnic_host_sds_ring *sds_ring)
136 {
137  writel(0, sds_ring->crb_intr_mask);
138 }
139 
140 static inline void qlcnic_enable_int(struct qlcnic_host_sds_ring *sds_ring)
141 {
142  struct qlcnic_adapter *adapter = sds_ring->adapter;
143 
144  writel(0x1, sds_ring->crb_intr_mask);
145 
146  if (!QLCNIC_IS_MSI_FAMILY(adapter))
147  writel(0xfbff, adapter->tgt_mask_reg);
148 }
149 
150 static int
151 qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
152 {
153  int size = sizeof(struct qlcnic_host_sds_ring) * count;
154 
155  recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
156 
157  return recv_ctx->sds_rings == NULL;
158 }
159 
160 static void
161 qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
162 {
163  if (recv_ctx->sds_rings != NULL)
164  kfree(recv_ctx->sds_rings);
165 
166  recv_ctx->sds_rings = NULL;
167 }
168 
169 static int
170 qlcnic_napi_add(struct qlcnic_adapter *adapter, struct net_device *netdev)
171 {
172  int ring;
173  struct qlcnic_host_sds_ring *sds_ring;
174  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
175 
176  if (qlcnic_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
177  return -ENOMEM;
178 
179  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
180  sds_ring = &recv_ctx->sds_rings[ring];
181 
182  if (ring == adapter->max_sds_rings - 1)
183  netif_napi_add(netdev, &sds_ring->napi, qlcnic_poll,
184  QLCNIC_NETDEV_WEIGHT/adapter->max_sds_rings);
185  else
186  netif_napi_add(netdev, &sds_ring->napi,
187  qlcnic_rx_poll, QLCNIC_NETDEV_WEIGHT*2);
188  }
189 
190  return 0;
191 }
192 
193 static void
194 qlcnic_napi_del(struct qlcnic_adapter *adapter)
195 {
196  int ring;
197  struct qlcnic_host_sds_ring *sds_ring;
198  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
199 
200  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
201  sds_ring = &recv_ctx->sds_rings[ring];
202  netif_napi_del(&sds_ring->napi);
203  }
204 
205  qlcnic_free_sds_rings(adapter->recv_ctx);
206 }
207 
208 static void
209 qlcnic_napi_enable(struct qlcnic_adapter *adapter)
210 {
211  int ring;
212  struct qlcnic_host_sds_ring *sds_ring;
213  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
214 
215  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
216  return;
217 
218  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
219  sds_ring = &recv_ctx->sds_rings[ring];
220  napi_enable(&sds_ring->napi);
221  qlcnic_enable_int(sds_ring);
222  }
223 }
224 
225 static void
226 qlcnic_napi_disable(struct qlcnic_adapter *adapter)
227 {
228  int ring;
229  struct qlcnic_host_sds_ring *sds_ring;
230  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
231 
232  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
233  return;
234 
235  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
236  sds_ring = &recv_ctx->sds_rings[ring];
237  qlcnic_disable_int(sds_ring);
238  napi_synchronize(&sds_ring->napi);
239  napi_disable(&sds_ring->napi);
240  }
241 }
242 
243 static void qlcnic_clear_stats(struct qlcnic_adapter *adapter)
244 {
245  memset(&adapter->stats, 0, sizeof(adapter->stats));
246 }
247 
248 static void qlcnic_set_msix_bit(struct pci_dev *pdev, int enable)
249 {
250  u32 control;
251  int pos;
252 
253  pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
254  if (pos) {
255  pci_read_config_dword(pdev, pos, &control);
256  if (enable)
257  control |= PCI_MSIX_FLAGS_ENABLE;
258  else
259  control = 0;
260  pci_write_config_dword(pdev, pos, control);
261  }
262 }
263 
264 static void qlcnic_init_msix_entries(struct qlcnic_adapter *adapter, int count)
265 {
266  int i;
267 
268  for (i = 0; i < count; i++)
269  adapter->msix_entries[i].entry = i;
270 }
271 
272 static int
273 qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
274 {
275  u8 mac_addr[ETH_ALEN];
276  struct net_device *netdev = adapter->netdev;
277  struct pci_dev *pdev = adapter->pdev;
278 
279  if (qlcnic_get_mac_address(adapter, mac_addr) != 0)
280  return -EIO;
281 
282  memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
283  memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
284  memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
285 
286  /* set station address */
287 
288  if (!is_valid_ether_addr(netdev->perm_addr))
289  dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
290  netdev->dev_addr);
291 
292  return 0;
293 }
294 
295 static int qlcnic_set_mac(struct net_device *netdev, void *p)
296 {
297  struct qlcnic_adapter *adapter = netdev_priv(netdev);
298  struct sockaddr *addr = p;
299 
300  if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
301  return -EOPNOTSUPP;
302 
303  if (!is_valid_ether_addr(addr->sa_data))
304  return -EADDRNOTAVAIL;
305 
306  if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
307  netif_device_detach(netdev);
308  qlcnic_napi_disable(adapter);
309  }
310 
311  memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
312  memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
313  qlcnic_set_multi(adapter->netdev);
314 
315  if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
316  netif_device_attach(netdev);
317  qlcnic_napi_enable(adapter);
318  }
319  return 0;
320 }
321 
322 static const struct net_device_ops qlcnic_netdev_ops = {
323  .ndo_open = qlcnic_open,
324  .ndo_stop = qlcnic_close,
325  .ndo_start_xmit = qlcnic_xmit_frame,
326  .ndo_get_stats = qlcnic_get_stats,
327  .ndo_validate_addr = eth_validate_addr,
328  .ndo_set_rx_mode = qlcnic_set_multi,
329  .ndo_set_mac_address = qlcnic_set_mac,
330  .ndo_change_mtu = qlcnic_change_mtu,
331  .ndo_fix_features = qlcnic_fix_features,
332  .ndo_set_features = qlcnic_set_features,
333  .ndo_tx_timeout = qlcnic_tx_timeout,
334  .ndo_vlan_rx_add_vid = qlcnic_vlan_rx_add,
335  .ndo_vlan_rx_kill_vid = qlcnic_vlan_rx_del,
336 #ifdef CONFIG_NET_POLL_CONTROLLER
337  .ndo_poll_controller = qlcnic_poll_controller,
338 #endif
339 };
340 
341 static const struct net_device_ops qlcnic_netdev_failed_ops = {
342  .ndo_open = qlcnic_open,
343 };
344 
345 static struct qlcnic_nic_template qlcnic_ops = {
346  .config_bridged_mode = qlcnic_config_bridged_mode,
347  .config_led = qlcnic_config_led,
348  .start_firmware = qlcnic_start_firmware
349 };
350 
351 static struct qlcnic_nic_template qlcnic_vf_ops = {
352  .config_bridged_mode = qlcnicvf_config_bridged_mode,
353  .config_led = qlcnicvf_config_led,
354  .start_firmware = qlcnicvf_start_firmware
355 };
356 
357 static int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
358 {
359  struct pci_dev *pdev = adapter->pdev;
360  int err = -1;
361 
362  adapter->max_sds_rings = 1;
363  adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
364  qlcnic_set_msix_bit(pdev, 0);
365 
366  if (adapter->msix_supported) {
367  enable_msix:
368  qlcnic_init_msix_entries(adapter, num_msix);
369  err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
370  if (err == 0) {
371  adapter->flags |= QLCNIC_MSIX_ENABLED;
372  qlcnic_set_msix_bit(pdev, 1);
373 
374  adapter->max_sds_rings = num_msix;
375 
376  dev_info(&pdev->dev, "using msi-x interrupts\n");
377  return err;
378  }
379  if (err > 0) {
380  num_msix = rounddown_pow_of_two(err);
381  if (num_msix)
382  goto enable_msix;
383  }
384  }
385  return err;
386 }
387 
388 
389 static void qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
390 {
391  const struct qlcnic_legacy_intr_set *legacy_intrp;
392  struct pci_dev *pdev = adapter->pdev;
393 
394  if (use_msi && !pci_enable_msi(pdev)) {
395  adapter->flags |= QLCNIC_MSI_ENABLED;
396  adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
397  msi_tgt_status[adapter->ahw->pci_func]);
398  dev_info(&pdev->dev, "using msi interrupts\n");
399  adapter->msix_entries[0].vector = pdev->irq;
400  return;
401  }
402 
403  legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
404 
405  adapter->int_vec_bit = legacy_intrp->int_vec_bit;
406  adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter,
407  legacy_intrp->tgt_status_reg);
408  adapter->tgt_mask_reg = qlcnic_get_ioaddr(adapter,
409  legacy_intrp->tgt_mask_reg);
410  adapter->isr_int_vec = qlcnic_get_ioaddr(adapter, ISR_INT_VECTOR);
411 
412  adapter->crb_int_state_reg = qlcnic_get_ioaddr(adapter,
413  ISR_INT_STATE_REG);
414  dev_info(&pdev->dev, "using legacy interrupts\n");
415  adapter->msix_entries[0].vector = pdev->irq;
416 }
417 
418 static void
419 qlcnic_setup_intr(struct qlcnic_adapter *adapter)
420 {
421  int num_msix;
422 
423  if (adapter->msix_supported) {
424  num_msix = rounddown_pow_of_two(min_t(int, num_online_cpus(),
425  QLCNIC_DEF_NUM_STS_DESC_RINGS));
426  } else
427  num_msix = 1;
428 
429  if (!qlcnic_enable_msix(adapter, num_msix))
430  return;
431 
432  qlcnic_enable_msi_legacy(adapter);
433 }
434 
435 static void
436 qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
437 {
438  if (adapter->flags & QLCNIC_MSIX_ENABLED)
439  pci_disable_msix(adapter->pdev);
440  if (adapter->flags & QLCNIC_MSI_ENABLED)
441  pci_disable_msi(adapter->pdev);
442 }
443 
444 static void
445 qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
446 {
447  if (adapter->ahw->pci_base0 != NULL)
448  iounmap(adapter->ahw->pci_base0);
449 }
450 
451 static int
452 qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
453 {
454  struct qlcnic_pci_info *pci_info;
455  int i, ret = 0;
456  u8 pfn;
457 
458  pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
459  if (!pci_info)
460  return -ENOMEM;
461 
462  adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
463  QLCNIC_MAX_PCI_FUNC, GFP_KERNEL);
464  if (!adapter->npars) {
465  ret = -ENOMEM;
466  goto err_pci_info;
467  }
468 
469  adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
470  QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
471  if (!adapter->eswitch) {
472  ret = -ENOMEM;
473  goto err_npars;
474  }
475 
476  ret = qlcnic_get_pci_info(adapter, pci_info);
477  if (ret)
478  goto err_eswitch;
479 
480  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
481  pfn = pci_info[i].id;
482  if (pfn >= QLCNIC_MAX_PCI_FUNC) {
483  ret = QL_STATUS_INVALID_PARAM;
484  goto err_eswitch;
485  }
486  adapter->npars[pfn].active = (u8)pci_info[i].active;
487  adapter->npars[pfn].type = (u8)pci_info[i].type;
488  adapter->npars[pfn].phy_port = (u8)pci_info[i].default_port;
489  adapter->npars[pfn].min_bw = pci_info[i].tx_min_bw;
490  adapter->npars[pfn].max_bw = pci_info[i].tx_max_bw;
491  }
492 
493  for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
494  adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
495 
496  kfree(pci_info);
497  return 0;
498 
499 err_eswitch:
500  kfree(adapter->eswitch);
501  adapter->eswitch = NULL;
502 err_npars:
503  kfree(adapter->npars);
504  adapter->npars = NULL;
505 err_pci_info:
506  kfree(pci_info);
507 
508  return ret;
509 }
510 
511 static int
512 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
513 {
514  u8 id;
515  u32 ref_count;
516  int i, ret = 1;
517  u32 data = QLCNIC_MGMT_FUNC;
518  void __iomem *priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
519 
520  /* If other drivers are not in use set their privilege level */
521  ref_count = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
522  ret = qlcnic_api_lock(adapter);
523  if (ret)
524  goto err_lock;
525 
526  if (qlcnic_config_npars) {
527  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
528  id = i;
529  if (adapter->npars[i].type != QLCNIC_TYPE_NIC ||
530  id == adapter->ahw->pci_func)
531  continue;
532  data |= (qlcnic_config_npars &
533  QLC_DEV_SET_DRV(0xf, id));
534  }
535  } else {
536  data = readl(priv_op);
537  data = (data & ~QLC_DEV_SET_DRV(0xf, adapter->ahw->pci_func)) |
538  (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
539  adapter->ahw->pci_func));
540  }
541  writel(data, priv_op);
542  qlcnic_api_unlock(adapter);
543 err_lock:
544  return ret;
545 }
546 
547 static void
548 qlcnic_check_vf(struct qlcnic_adapter *adapter)
549 {
550  void __iomem *msix_base_addr;
551  void __iomem *priv_op;
552  u32 func;
553  u32 msix_base;
554  u32 op_mode, priv_level;
555 
556  /* Determine FW API version */
557  adapter->fw_hal_version = readl(adapter->ahw->pci_base0 +
558  QLCNIC_FW_API);
559 
560  /* Find PCI function number */
561  pci_read_config_dword(adapter->pdev, QLCNIC_MSIX_TABLE_OFFSET, &func);
562  msix_base_addr = adapter->ahw->pci_base0 + QLCNIC_MSIX_BASE;
563  msix_base = readl(msix_base_addr);
564  func = (func - msix_base)/QLCNIC_MSIX_TBL_PGSIZE;
565  adapter->ahw->pci_func = func;
566 
567  /* Determine function privilege level */
568  priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
569  op_mode = readl(priv_op);
570  if (op_mode == QLC_DEV_DRV_DEFAULT)
571  priv_level = QLCNIC_MGMT_FUNC;
572  else
573  priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
574 
575  if (priv_level == QLCNIC_NON_PRIV_FUNC) {
576  adapter->op_mode = QLCNIC_NON_PRIV_FUNC;
577  dev_info(&adapter->pdev->dev,
578  "HAL Version: %d Non Privileged function\n",
579  adapter->fw_hal_version);
580  adapter->nic_ops = &qlcnic_vf_ops;
581  } else
582  adapter->nic_ops = &qlcnic_ops;
583 }
584 
585 static int
586 qlcnic_setup_pci_map(struct qlcnic_adapter *adapter)
587 {
588  void __iomem *mem_ptr0 = NULL;
589  resource_size_t mem_base;
590  unsigned long mem_len, pci_len0 = 0;
591 
592  struct pci_dev *pdev = adapter->pdev;
593 
594  /* remap phys address */
595  mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */
596  mem_len = pci_resource_len(pdev, 0);
597 
598  if (mem_len == QLCNIC_PCI_2MB_SIZE) {
599 
600  mem_ptr0 = pci_ioremap_bar(pdev, 0);
601  if (mem_ptr0 == NULL) {
602  dev_err(&pdev->dev, "failed to map PCI bar 0\n");
603  return -EIO;
604  }
605  pci_len0 = mem_len;
606  } else {
607  return -EIO;
608  }
609 
610  dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
611 
612  adapter->ahw->pci_base0 = mem_ptr0;
613  adapter->ahw->pci_len0 = pci_len0;
614 
615  qlcnic_check_vf(adapter);
616 
617  adapter->ahw->ocm_win_crb = qlcnic_get_ioaddr(adapter,
618  QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(
619  adapter->ahw->pci_func)));
620 
621  return 0;
622 }
623 
624 static void get_brd_name(struct qlcnic_adapter *adapter, char *name)
625 {
626  struct pci_dev *pdev = adapter->pdev;
627  int i, found = 0;
628 
629  for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
630  if (qlcnic_boards[i].vendor == pdev->vendor &&
631  qlcnic_boards[i].device == pdev->device &&
632  qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
633  qlcnic_boards[i].sub_device == pdev->subsystem_device) {
634  sprintf(name, "%pM: %s" ,
635  adapter->mac_addr,
636  qlcnic_boards[i].short_name);
637  found = 1;
638  break;
639  }
640 
641  }
642 
643  if (!found)
644  sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
645 }
646 
647 static void
648 qlcnic_check_options(struct qlcnic_adapter *adapter)
649 {
650  u32 fw_major, fw_minor, fw_build, prev_fw_version;
651  struct pci_dev *pdev = adapter->pdev;
652  struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
653 
654  prev_fw_version = adapter->fw_version;
655 
656  fw_major = QLCRD32(adapter, QLCNIC_FW_VERSION_MAJOR);
657  fw_minor = QLCRD32(adapter, QLCNIC_FW_VERSION_MINOR);
658  fw_build = QLCRD32(adapter, QLCNIC_FW_VERSION_SUB);
659 
660  adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
661 
662  if (adapter->op_mode != QLCNIC_NON_PRIV_FUNC) {
663  if (fw_dump->tmpl_hdr == NULL ||
664  adapter->fw_version > prev_fw_version) {
665  if (fw_dump->tmpl_hdr)
666  vfree(fw_dump->tmpl_hdr);
667  if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
668  dev_info(&pdev->dev,
669  "Supports FW dump capability\n");
670  }
671  }
672 
673  dev_info(&pdev->dev, "firmware v%d.%d.%d\n",
674  fw_major, fw_minor, fw_build);
675  if (adapter->ahw->port_type == QLCNIC_XGBE) {
676  if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
677  adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
678  adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
679  } else {
680  adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
681  adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
682  }
683 
684  adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
685  adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
686 
687  } else if (adapter->ahw->port_type == QLCNIC_GBE) {
688  adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
689  adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
690  adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
691  adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
692  }
693 
694  adapter->msix_supported = !!use_msi_x;
695 
696  adapter->num_txd = MAX_CMD_DESCRIPTORS;
697 
698  adapter->max_rds_rings = MAX_RDS_RINGS;
699 }
700 
701 static int
702 qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
703 {
704  int err;
705  struct qlcnic_info nic_info;
706 
707  err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
708  if (err)
709  return err;
710 
711  adapter->physical_port = (u8)nic_info.phys_port;
712  adapter->switch_mode = nic_info.switch_mode;
713  adapter->max_tx_ques = nic_info.max_tx_ques;
714  adapter->max_rx_ques = nic_info.max_rx_ques;
715  adapter->capabilities = nic_info.capabilities;
716  adapter->max_mac_filters = nic_info.max_mac_filters;
717  adapter->max_mtu = nic_info.max_mtu;
718 
719  if (adapter->capabilities & BIT_6)
720  adapter->flags |= QLCNIC_ESWITCH_ENABLED;
721  else
722  adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
723 
724  return err;
725 }
726 
727 static void
728 qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
729  struct qlcnic_esw_func_cfg *esw_cfg)
730 {
731  if (esw_cfg->discard_tagged)
732  adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
733  else
734  adapter->flags |= QLCNIC_TAGGING_ENABLED;
735 
736  if (esw_cfg->vlan_id)
737  adapter->pvid = esw_cfg->vlan_id;
738  else
739  adapter->pvid = 0;
740 }
741 
742 static int
743 qlcnic_vlan_rx_add(struct net_device *netdev, u16 vid)
744 {
745  struct qlcnic_adapter *adapter = netdev_priv(netdev);
746  set_bit(vid, adapter->vlans);
747  return 0;
748 }
749 
750 static int
751 qlcnic_vlan_rx_del(struct net_device *netdev, u16 vid)
752 {
753  struct qlcnic_adapter *adapter = netdev_priv(netdev);
754 
755  qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
756  clear_bit(vid, adapter->vlans);
757  return 0;
758 }
759 
760 static void
761 qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
762  struct qlcnic_esw_func_cfg *esw_cfg)
763 {
764  adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
765  QLCNIC_PROMISC_DISABLED);
766 
767  if (esw_cfg->mac_anti_spoof)
768  adapter->flags |= QLCNIC_MACSPOOF;
769 
770  if (!esw_cfg->mac_override)
771  adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
772 
773  if (!esw_cfg->promisc_mode)
774  adapter->flags |= QLCNIC_PROMISC_DISABLED;
775 
776  qlcnic_set_netdev_features(adapter, esw_cfg);
777 }
778 
779 static int
780 qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
781 {
782  struct qlcnic_esw_func_cfg esw_cfg;
783 
784  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
785  return 0;
786 
787  esw_cfg.pci_func = adapter->ahw->pci_func;
788  if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
789  return -EIO;
790  qlcnic_set_vlan_config(adapter, &esw_cfg);
791  qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
792 
793  return 0;
794 }
795 
796 static void
797 qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
798  struct qlcnic_esw_func_cfg *esw_cfg)
799 {
800  struct net_device *netdev = adapter->netdev;
801  netdev_features_t features, vlan_features;
802 
803  features = (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
804  NETIF_F_IPV6_CSUM | NETIF_F_GRO);
805  vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
806  NETIF_F_IPV6_CSUM | NETIF_F_HW_VLAN_FILTER);
807 
808  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO) {
809  features |= (NETIF_F_TSO | NETIF_F_TSO6);
810  vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
811  }
812 
813  if (netdev->features & NETIF_F_LRO)
814  features |= NETIF_F_LRO;
815 
816  if (esw_cfg->offload_flags & BIT_0) {
817  netdev->features |= features;
818  if (!(esw_cfg->offload_flags & BIT_1))
819  netdev->features &= ~NETIF_F_TSO;
820  if (!(esw_cfg->offload_flags & BIT_2))
821  netdev->features &= ~NETIF_F_TSO6;
822  } else {
823  netdev->features &= ~features;
824  }
825 
826  netdev->vlan_features = (features & vlan_features);
827 }
828 
829 static int
830 qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
831 {
832  void __iomem *priv_op;
833  u32 op_mode, priv_level;
834  int err = 0;
835 
836  err = qlcnic_initialize_nic(adapter);
837  if (err)
838  return err;
839 
840  if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
841  return 0;
842 
843  priv_op = adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE;
844  op_mode = readl(priv_op);
845  priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
846 
847  if (op_mode == QLC_DEV_DRV_DEFAULT)
848  priv_level = QLCNIC_MGMT_FUNC;
849  else
850  priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
851 
852  if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
853  if (priv_level == QLCNIC_MGMT_FUNC) {
854  adapter->op_mode = QLCNIC_MGMT_FUNC;
855  err = qlcnic_init_pci_info(adapter);
856  if (err)
857  return err;
858  /* Set privilege level for other functions */
859  qlcnic_set_function_modes(adapter);
860  dev_info(&adapter->pdev->dev,
861  "HAL Version: %d, Management function\n",
862  adapter->fw_hal_version);
863  } else if (priv_level == QLCNIC_PRIV_FUNC) {
864  adapter->op_mode = QLCNIC_PRIV_FUNC;
865  dev_info(&adapter->pdev->dev,
866  "HAL Version: %d, Privileged function\n",
867  adapter->fw_hal_version);
868  }
869  }
870 
871  adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
872 
873  return err;
874 }
875 
876 static int
877 qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
878 {
879  struct qlcnic_esw_func_cfg esw_cfg;
880  struct qlcnic_npar_info *npar;
881  u8 i;
882 
883  if (adapter->need_fw_reset)
884  return 0;
885 
886  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
887  if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
888  continue;
889  memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
890  esw_cfg.pci_func = i;
891  esw_cfg.offload_flags = BIT_0;
892  esw_cfg.mac_override = BIT_0;
893  esw_cfg.promisc_mode = BIT_0;
894  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO)
895  esw_cfg.offload_flags |= (BIT_1 | BIT_2);
896  if (qlcnic_config_switch_port(adapter, &esw_cfg))
897  return -EIO;
898  npar = &adapter->npars[i];
899  npar->pvid = esw_cfg.vlan_id;
900  npar->mac_override = esw_cfg.mac_override;
901  npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
902  npar->discard_tagged = esw_cfg.discard_tagged;
903  npar->promisc_mode = esw_cfg.promisc_mode;
904  npar->offload_flags = esw_cfg.offload_flags;
905  }
906 
907  return 0;
908 }
909 
910 static int
911 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
912  struct qlcnic_npar_info *npar, int pci_func)
913 {
914  struct qlcnic_esw_func_cfg esw_cfg;
915  esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
916  esw_cfg.pci_func = pci_func;
917  esw_cfg.vlan_id = npar->pvid;
918  esw_cfg.mac_override = npar->mac_override;
919  esw_cfg.discard_tagged = npar->discard_tagged;
920  esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
921  esw_cfg.offload_flags = npar->offload_flags;
922  esw_cfg.promisc_mode = npar->promisc_mode;
923  if (qlcnic_config_switch_port(adapter, &esw_cfg))
924  return -EIO;
925 
926  esw_cfg.op_mode = QLCNIC_ADD_VLAN;
927  if (qlcnic_config_switch_port(adapter, &esw_cfg))
928  return -EIO;
929 
930  return 0;
931 }
932 
933 static int
934 qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
935 {
936  int i, err;
937  struct qlcnic_npar_info *npar;
938  struct qlcnic_info nic_info;
939 
940  if (!adapter->need_fw_reset)
941  return 0;
942 
943  /* Set the NPAR config data after FW reset */
944  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
945  npar = &adapter->npars[i];
946  if (npar->type != QLCNIC_TYPE_NIC)
947  continue;
948  err = qlcnic_get_nic_info(adapter, &nic_info, i);
949  if (err)
950  return err;
951  nic_info.min_tx_bw = npar->min_bw;
952  nic_info.max_tx_bw = npar->max_bw;
953  err = qlcnic_set_nic_info(adapter, &nic_info);
954  if (err)
955  return err;
956 
957  if (npar->enable_pm) {
958  err = qlcnic_config_port_mirroring(adapter,
959  npar->dest_npar, 1, i);
960  if (err)
961  return err;
962  }
963  err = qlcnic_reset_eswitch_config(adapter, npar, i);
964  if (err)
965  return err;
966  }
967  return 0;
968 }
969 
970 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
971 {
972  u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
973  u32 npar_state;
974 
975  if (adapter->op_mode == QLCNIC_MGMT_FUNC)
976  return 0;
977 
978  npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
979  while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
980  msleep(1000);
981  npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
982  }
983  if (!npar_opt_timeo) {
984  dev_err(&adapter->pdev->dev,
985  "Waiting for NPAR state to opertional timeout\n");
986  return -EIO;
987  }
988  return 0;
989 }
990 
991 static int
992 qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
993 {
994  int err;
995 
996  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
997  adapter->op_mode != QLCNIC_MGMT_FUNC)
998  return 0;
999 
1000  err = qlcnic_set_default_offload_settings(adapter);
1001  if (err)
1002  return err;
1003 
1004  err = qlcnic_reset_npar_config(adapter);
1005  if (err)
1006  return err;
1007 
1008  qlcnic_dev_set_npar_ready(adapter);
1009 
1010  return err;
1011 }
1012 
1013 static int
1014 qlcnic_start_firmware(struct qlcnic_adapter *adapter)
1015 {
1016  int err;
1017 
1018  err = qlcnic_can_start_firmware(adapter);
1019  if (err < 0)
1020  return err;
1021  else if (!err)
1022  goto check_fw_status;
1023 
1024  if (load_fw_file)
1025  qlcnic_request_firmware(adapter);
1026  else {
1027  err = qlcnic_check_flash_fw_ver(adapter);
1028  if (err)
1029  goto err_out;
1030 
1031  adapter->fw_type = QLCNIC_FLASH_ROMIMAGE;
1032  }
1033 
1034  err = qlcnic_need_fw_reset(adapter);
1035  if (err == 0)
1036  goto check_fw_status;
1037 
1038  err = qlcnic_pinit_from_rom(adapter);
1039  if (err)
1040  goto err_out;
1041 
1042  err = qlcnic_load_firmware(adapter);
1043  if (err)
1044  goto err_out;
1045 
1046  qlcnic_release_firmware(adapter);
1047  QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1048 
1049 check_fw_status:
1050  err = qlcnic_check_fw_status(adapter);
1051  if (err)
1052  goto err_out;
1053 
1054  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1055  qlcnic_idc_debug_info(adapter, 1);
1056 
1057  err = qlcnic_check_eswitch_mode(adapter);
1058  if (err) {
1059  dev_err(&adapter->pdev->dev,
1060  "Memory allocation failed for eswitch\n");
1061  goto err_out;
1062  }
1063  err = qlcnic_set_mgmt_operations(adapter);
1064  if (err)
1065  goto err_out;
1066 
1067  qlcnic_check_options(adapter);
1068  adapter->need_fw_reset = 0;
1069 
1070  qlcnic_release_firmware(adapter);
1071  return 0;
1072 
1073 err_out:
1074  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1075  dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1076 
1077  qlcnic_release_firmware(adapter);
1078  return err;
1079 }
1080 
1081 static int
1082 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1083 {
1084  irq_handler_t handler;
1085  struct qlcnic_host_sds_ring *sds_ring;
1086  int err, ring;
1087 
1088  unsigned long flags = 0;
1089  struct net_device *netdev = adapter->netdev;
1090  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1091 
1092  if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1093  handler = qlcnic_tmp_intr;
1094  if (!QLCNIC_IS_MSI_FAMILY(adapter))
1095  flags |= IRQF_SHARED;
1096 
1097  } else {
1098  if (adapter->flags & QLCNIC_MSIX_ENABLED)
1099  handler = qlcnic_msix_intr;
1100  else if (adapter->flags & QLCNIC_MSI_ENABLED)
1101  handler = qlcnic_msi_intr;
1102  else {
1103  flags |= IRQF_SHARED;
1104  handler = qlcnic_intr;
1105  }
1106  }
1107  adapter->irq = netdev->irq;
1108 
1109  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1110  sds_ring = &recv_ctx->sds_rings[ring];
1111  sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
1112  err = request_irq(sds_ring->irq, handler,
1113  flags, sds_ring->name, sds_ring);
1114  if (err)
1115  return err;
1116  }
1117 
1118  return 0;
1119 }
1120 
1121 static void
1122 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1123 {
1124  int ring;
1125  struct qlcnic_host_sds_ring *sds_ring;
1126 
1127  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1128 
1129  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1130  sds_ring = &recv_ctx->sds_rings[ring];
1131  free_irq(sds_ring->irq, sds_ring);
1132  }
1133 }
1134 
1135 static int
1136 __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1137 {
1138  int ring;
1139  u32 capab2;
1140 
1141  struct qlcnic_host_rds_ring *rds_ring;
1142 
1143  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1144  return -EIO;
1145 
1146  if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1147  return 0;
1148  if (qlcnic_set_eswitch_port_config(adapter))
1149  return -EIO;
1150 
1151  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
1152  capab2 = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
1153  if (capab2 & QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1154  adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1155  }
1156 
1157  if (qlcnic_fw_create_ctx(adapter))
1158  return -EIO;
1159 
1160  for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1161  rds_ring = &adapter->recv_ctx->rds_rings[ring];
1162  qlcnic_post_rx_buffers(adapter, rds_ring);
1163  }
1164 
1165  qlcnic_set_multi(netdev);
1166  qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1167 
1168  adapter->ahw->linkup = 0;
1169 
1170  if (adapter->max_sds_rings > 1)
1171  qlcnic_config_rss(adapter, 1);
1172 
1173  qlcnic_config_intr_coalesce(adapter);
1174 
1175  if (netdev->features & NETIF_F_LRO)
1176  qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1177 
1178  qlcnic_napi_enable(adapter);
1179 
1180  qlcnic_linkevent_request(adapter, 1);
1181 
1182  adapter->reset_context = 0;
1183  set_bit(__QLCNIC_DEV_UP, &adapter->state);
1184  return 0;
1185 }
1186 
1187 /* Usage: During resume and firmware recovery module.*/
1188 
1189 static int
1190 qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1191 {
1192  int err = 0;
1193 
1194  rtnl_lock();
1195  if (netif_running(netdev))
1196  err = __qlcnic_up(adapter, netdev);
1197  rtnl_unlock();
1198 
1199  return err;
1200 }
1201 
1202 static void
1203 __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1204 {
1205  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1206  return;
1207 
1208  if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1209  return;
1210 
1211  smp_mb();
1212  spin_lock(&adapter->tx_clean_lock);
1213  netif_carrier_off(netdev);
1214  netif_tx_disable(netdev);
1215 
1216  qlcnic_free_mac_list(adapter);
1217 
1218  if (adapter->fhash.fnum)
1219  qlcnic_delete_lb_filters(adapter);
1220 
1221  qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1222 
1223  qlcnic_napi_disable(adapter);
1224 
1225  qlcnic_fw_destroy_ctx(adapter);
1226  adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
1227 
1228  qlcnic_reset_rx_buffers_list(adapter);
1229  qlcnic_release_tx_buffers(adapter);
1230  spin_unlock(&adapter->tx_clean_lock);
1231 }
1232 
1233 /* Usage: During suspend and firmware recovery module */
1234 
1235 static void
1236 qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1237 {
1238  rtnl_lock();
1239  if (netif_running(netdev))
1240  __qlcnic_down(adapter, netdev);
1241  rtnl_unlock();
1242 
1243 }
1244 
1245 static int
1246 qlcnic_attach(struct qlcnic_adapter *adapter)
1247 {
1248  struct net_device *netdev = adapter->netdev;
1249  struct pci_dev *pdev = adapter->pdev;
1250  int err;
1251 
1252  if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1253  return 0;
1254 
1255  err = qlcnic_napi_add(adapter, netdev);
1256  if (err)
1257  return err;
1258 
1259  err = qlcnic_alloc_sw_resources(adapter);
1260  if (err) {
1261  dev_err(&pdev->dev, "Error in setting sw resources\n");
1262  goto err_out_napi_del;
1263  }
1264 
1265  err = qlcnic_alloc_hw_resources(adapter);
1266  if (err) {
1267  dev_err(&pdev->dev, "Error in setting hw resources\n");
1268  goto err_out_free_sw;
1269  }
1270 
1271  err = qlcnic_request_irq(adapter);
1272  if (err) {
1273  dev_err(&pdev->dev, "failed to setup interrupt\n");
1274  goto err_out_free_hw;
1275  }
1276 
1277  qlcnic_create_sysfs_entries(adapter);
1278 
1279  adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1280  return 0;
1281 
1282 err_out_free_hw:
1283  qlcnic_free_hw_resources(adapter);
1284 err_out_free_sw:
1285  qlcnic_free_sw_resources(adapter);
1286 err_out_napi_del:
1287  qlcnic_napi_del(adapter);
1288  return err;
1289 }
1290 
1291 static void
1292 qlcnic_detach(struct qlcnic_adapter *adapter)
1293 {
1294  if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1295  return;
1296 
1297  qlcnic_remove_sysfs_entries(adapter);
1298 
1299  qlcnic_free_hw_resources(adapter);
1300  qlcnic_release_rx_buffers(adapter);
1301  qlcnic_free_irq(adapter);
1302  qlcnic_napi_del(adapter);
1303  qlcnic_free_sw_resources(adapter);
1304 
1305  adapter->is_up = 0;
1306 }
1307 
1308 void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1309 {
1310  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1311  struct qlcnic_host_sds_ring *sds_ring;
1312  int ring;
1313 
1314  clear_bit(__QLCNIC_DEV_UP, &adapter->state);
1315  if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1316  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1317  sds_ring = &adapter->recv_ctx->sds_rings[ring];
1318  qlcnic_disable_int(sds_ring);
1319  }
1320  }
1321 
1322  qlcnic_fw_destroy_ctx(adapter);
1323 
1324  qlcnic_detach(adapter);
1325 
1326  adapter->diag_test = 0;
1327  adapter->max_sds_rings = max_sds_rings;
1328 
1329  if (qlcnic_attach(adapter))
1330  goto out;
1331 
1332  if (netif_running(netdev))
1333  __qlcnic_up(adapter, netdev);
1334 out:
1335  netif_device_attach(netdev);
1336 }
1337 
1338 static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
1339 {
1340  int err = 0;
1341  adapter->ahw = kzalloc(sizeof(struct qlcnic_hardware_context),
1342  GFP_KERNEL);
1343  if (!adapter->ahw) {
1344  dev_err(&adapter->pdev->dev,
1345  "Failed to allocate recv ctx resources for adapter\n");
1346  err = -ENOMEM;
1347  goto err_out;
1348  }
1349  adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
1350  GFP_KERNEL);
1351  if (!adapter->recv_ctx) {
1352  dev_err(&adapter->pdev->dev,
1353  "Failed to allocate recv ctx resources for adapter\n");
1354  kfree(adapter->ahw);
1355  adapter->ahw = NULL;
1356  err = -ENOMEM;
1357  goto err_out;
1358  }
1359  /* Initialize interrupt coalesce parameters */
1360  adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1361  adapter->ahw->coal.rx_time_us = QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1362  adapter->ahw->coal.rx_packets = QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
1363 err_out:
1364  return err;
1365 }
1366 
1367 static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
1368 {
1369  kfree(adapter->recv_ctx);
1370  adapter->recv_ctx = NULL;
1371 
1372  if (adapter->ahw->fw_dump.tmpl_hdr) {
1373  vfree(adapter->ahw->fw_dump.tmpl_hdr);
1374  adapter->ahw->fw_dump.tmpl_hdr = NULL;
1375  }
1376  kfree(adapter->ahw);
1377  adapter->ahw = NULL;
1378 }
1379 
1380 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1381 {
1382  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1383  struct qlcnic_host_sds_ring *sds_ring;
1384  struct qlcnic_host_rds_ring *rds_ring;
1385  int ring;
1386  int ret;
1387 
1388  netif_device_detach(netdev);
1389 
1390  if (netif_running(netdev))
1391  __qlcnic_down(adapter, netdev);
1392 
1393  qlcnic_detach(adapter);
1394 
1395  adapter->max_sds_rings = 1;
1396  adapter->diag_test = test;
1397 
1398  ret = qlcnic_attach(adapter);
1399  if (ret) {
1400  netif_device_attach(netdev);
1401  return ret;
1402  }
1403 
1404  ret = qlcnic_fw_create_ctx(adapter);
1405  if (ret) {
1406  qlcnic_detach(adapter);
1407  netif_device_attach(netdev);
1408  return ret;
1409  }
1410 
1411  for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1412  rds_ring = &adapter->recv_ctx->rds_rings[ring];
1413  qlcnic_post_rx_buffers(adapter, rds_ring);
1414  }
1415 
1416  if (adapter->diag_test == QLCNIC_INTERRUPT_TEST) {
1417  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1418  sds_ring = &adapter->recv_ctx->sds_rings[ring];
1419  qlcnic_enable_int(sds_ring);
1420  }
1421  }
1422 
1423  if (adapter->diag_test == QLCNIC_LOOPBACK_TEST) {
1424  adapter->ahw->loopback_state = 0;
1425  qlcnic_linkevent_request(adapter, 1);
1426  }
1427 
1428  set_bit(__QLCNIC_DEV_UP, &adapter->state);
1429 
1430  return 0;
1431 }
1432 
1433 /* Reset context in hardware only */
1434 static int
1435 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
1436 {
1437  struct net_device *netdev = adapter->netdev;
1438 
1439  if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1440  return -EBUSY;
1441 
1442  netif_device_detach(netdev);
1443 
1444  qlcnic_down(adapter, netdev);
1445 
1446  qlcnic_up(adapter, netdev);
1447 
1448  netif_device_attach(netdev);
1449 
1450  clear_bit(__QLCNIC_RESETTING, &adapter->state);
1451  return 0;
1452 }
1453 
1454 int
1455 qlcnic_reset_context(struct qlcnic_adapter *adapter)
1456 {
1457  int err = 0;
1458  struct net_device *netdev = adapter->netdev;
1459 
1460  if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1461  return -EBUSY;
1462 
1463  if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1464 
1465  netif_device_detach(netdev);
1466 
1467  if (netif_running(netdev))
1468  __qlcnic_down(adapter, netdev);
1469 
1470  qlcnic_detach(adapter);
1471 
1472  if (netif_running(netdev)) {
1473  err = qlcnic_attach(adapter);
1474  if (!err) {
1475  __qlcnic_up(adapter, netdev);
1476  qlcnic_restore_indev_addr(netdev, NETDEV_UP);
1477  }
1478  }
1479 
1480  netif_device_attach(netdev);
1481  }
1482 
1483  clear_bit(__QLCNIC_RESETTING, &adapter->state);
1484  return err;
1485 }
1486 
1487 static int
1488 qlcnic_setup_netdev(struct qlcnic_adapter *adapter,
1489  struct net_device *netdev, u8 pci_using_dac)
1490 {
1491  int err;
1492  struct pci_dev *pdev = adapter->pdev;
1493 
1494  adapter->mc_enabled = 0;
1495  adapter->max_mc_count = 38;
1496 
1497  netdev->netdev_ops = &qlcnic_netdev_ops;
1498  netdev->watchdog_timeo = 5*HZ;
1499 
1500  qlcnic_change_mtu(netdev, netdev->mtu);
1501 
1502  SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1503 
1504  netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM |
1505  NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM;
1506 
1507  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_TSO)
1508  netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
1509  if (pci_using_dac)
1510  netdev->hw_features |= NETIF_F_HIGHDMA;
1511 
1512  netdev->vlan_features = netdev->hw_features;
1513 
1514  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX)
1515  netdev->hw_features |= NETIF_F_HW_VLAN_TX;
1516  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1517  netdev->hw_features |= NETIF_F_LRO;
1518 
1519  netdev->features |= netdev->hw_features |
1520  NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
1521 
1522  netdev->irq = adapter->msix_entries[0].vector;
1523 
1524  err = register_netdev(netdev);
1525  if (err) {
1526  dev_err(&pdev->dev, "failed to register net device\n");
1527  return err;
1528  }
1529 
1530  return 0;
1531 }
1532 
1533 static int qlcnic_set_dma_mask(struct pci_dev *pdev, u8 *pci_using_dac)
1534 {
1535  if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1536  !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1537  *pci_using_dac = 1;
1538  else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1539  !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1540  *pci_using_dac = 0;
1541  else {
1542  dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1543  return -EIO;
1544  }
1545 
1546  return 0;
1547 }
1548 
1549 static int
1550 qlcnic_alloc_msix_entries(struct qlcnic_adapter *adapter, u16 count)
1551 {
1552  adapter->msix_entries = kcalloc(count, sizeof(struct msix_entry),
1553  GFP_KERNEL);
1554 
1555  if (adapter->msix_entries)
1556  return 0;
1557 
1558  dev_err(&adapter->pdev->dev, "failed allocating msix_entries\n");
1559  return -ENOMEM;
1560 }
1561 
1562 static int __devinit
1563 qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1564 {
1565  struct net_device *netdev = NULL;
1566  struct qlcnic_adapter *adapter = NULL;
1567  int err;
1568  uint8_t revision_id;
1569  uint8_t pci_using_dac;
1570  char brd_name[QLCNIC_MAX_BOARD_NAME_LEN];
1571 
1572  err = pci_enable_device(pdev);
1573  if (err)
1574  return err;
1575 
1576  if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1577  err = -ENODEV;
1578  goto err_out_disable_pdev;
1579  }
1580 
1581  err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1582  if (err)
1583  goto err_out_disable_pdev;
1584 
1585  err = pci_request_regions(pdev, qlcnic_driver_name);
1586  if (err)
1587  goto err_out_disable_pdev;
1588 
1589  pci_set_master(pdev);
1590  pci_enable_pcie_error_reporting(pdev);
1591 
1592  netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1593  if (!netdev) {
1594  err = -ENOMEM;
1595  goto err_out_free_res;
1596  }
1597 
1598  SET_NETDEV_DEV(netdev, &pdev->dev);
1599 
1600  adapter = netdev_priv(netdev);
1601  adapter->netdev = netdev;
1602  adapter->pdev = pdev;
1603 
1604  err = qlcnic_alloc_adapter_resources(adapter);
1605  if (err)
1606  goto err_out_free_netdev;
1607 
1608  adapter->dev_rst_time = jiffies;
1609  revision_id = pdev->revision;
1610  adapter->ahw->revision_id = revision_id;
1611  adapter->mac_learn = qlcnic_mac_learn;
1612 
1613  rwlock_init(&adapter->ahw->crb_lock);
1614  mutex_init(&adapter->ahw->mem_lock);
1615 
1616  spin_lock_init(&adapter->tx_clean_lock);
1617  INIT_LIST_HEAD(&adapter->mac_list);
1618 
1619  err = qlcnic_setup_pci_map(adapter);
1620  if (err)
1621  goto err_out_free_hw;
1622 
1623  /* This will be reset for mezz cards */
1624  adapter->portnum = adapter->ahw->pci_func;
1625 
1626  err = qlcnic_get_board_info(adapter);
1627  if (err) {
1628  dev_err(&pdev->dev, "Error getting board config info.\n");
1629  goto err_out_iounmap;
1630  }
1631 
1632  err = qlcnic_setup_idc_param(adapter);
1633  if (err)
1634  goto err_out_iounmap;
1635 
1636  adapter->flags |= QLCNIC_NEED_FLR;
1637 
1638  err = adapter->nic_ops->start_firmware(adapter);
1639  if (err) {
1640  dev_err(&pdev->dev, "Loading fw failed. Please Reboot\n"
1641  "\t\tIf reboot doesn't help, try flashing the card\n");
1642  goto err_out_maintenance_mode;
1643  }
1644 
1645  if (qlcnic_read_mac_addr(adapter))
1646  dev_warn(&pdev->dev, "failed to read mac addr\n");
1647 
1648  if (adapter->portnum == 0) {
1649  get_brd_name(adapter, brd_name);
1650 
1651  pr_info("%s: %s Board Chip rev 0x%x\n",
1652  module_name(THIS_MODULE),
1653  brd_name, adapter->ahw->revision_id);
1654  }
1655 
1656  qlcnic_clear_stats(adapter);
1657 
1658  err = qlcnic_alloc_msix_entries(adapter, adapter->max_rx_ques);
1659  if (err)
1660  goto err_out_decr_ref;
1661 
1662  qlcnic_setup_intr(adapter);
1663 
1664  err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
1665  if (err)
1666  goto err_out_disable_msi;
1667 
1668  pci_set_drvdata(pdev, adapter);
1669 
1670  qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1671 
1672  switch (adapter->ahw->port_type) {
1673  case QLCNIC_GBE:
1674  dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1675  adapter->netdev->name);
1676  break;
1677  case QLCNIC_XGBE:
1678  dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1679  adapter->netdev->name);
1680  break;
1681  }
1682 
1683  if (adapter->mac_learn)
1684  qlcnic_alloc_lb_filters_mem(adapter);
1685 
1686  qlcnic_create_diag_entries(adapter);
1687 
1688  return 0;
1689 
1690 err_out_disable_msi:
1691  qlcnic_teardown_intr(adapter);
1692  kfree(adapter->msix_entries);
1693 
1694 err_out_decr_ref:
1695  qlcnic_clr_all_drv_state(adapter, 0);
1696 
1697 err_out_iounmap:
1698  qlcnic_cleanup_pci_map(adapter);
1699 
1700 err_out_free_hw:
1701  qlcnic_free_adapter_resources(adapter);
1702 
1703 err_out_free_netdev:
1704  free_netdev(netdev);
1705 
1706 err_out_free_res:
1707  pci_release_regions(pdev);
1708 
1709 err_out_disable_pdev:
1710  pci_set_drvdata(pdev, NULL);
1711  pci_disable_device(pdev);
1712  return err;
1713 
1714 err_out_maintenance_mode:
1715  netdev->netdev_ops = &qlcnic_netdev_failed_ops;
1716  SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_failed_ops);
1717  err = register_netdev(netdev);
1718  if (err) {
1719  dev_err(&pdev->dev, "failed to register net device\n");
1720  goto err_out_decr_ref;
1721  }
1722  pci_set_drvdata(pdev, adapter);
1723  qlcnic_create_diag_entries(adapter);
1724  return 0;
1725 }
1726 
1727 static void __devexit qlcnic_remove(struct pci_dev *pdev)
1728 {
1729  struct qlcnic_adapter *adapter;
1730  struct net_device *netdev;
1731 
1732  adapter = pci_get_drvdata(pdev);
1733  if (adapter == NULL)
1734  return;
1735 
1736  netdev = adapter->netdev;
1737 
1738  qlcnic_cancel_fw_work(adapter);
1739 
1740  unregister_netdev(netdev);
1741 
1742  qlcnic_detach(adapter);
1743 
1744  if (adapter->npars != NULL)
1745  kfree(adapter->npars);
1746  if (adapter->eswitch != NULL)
1747  kfree(adapter->eswitch);
1748 
1749  qlcnic_clr_all_drv_state(adapter, 0);
1750 
1751  clear_bit(__QLCNIC_RESETTING, &adapter->state);
1752 
1753  qlcnic_free_lb_filters_mem(adapter);
1754 
1755  qlcnic_teardown_intr(adapter);
1756  kfree(adapter->msix_entries);
1757 
1758  qlcnic_remove_diag_entries(adapter);
1759 
1760  qlcnic_cleanup_pci_map(adapter);
1761 
1762  qlcnic_release_firmware(adapter);
1763 
1764  pci_disable_pcie_error_reporting(pdev);
1765  pci_release_regions(pdev);
1766  pci_disable_device(pdev);
1767  pci_set_drvdata(pdev, NULL);
1768 
1769  qlcnic_free_adapter_resources(adapter);
1770  free_netdev(netdev);
1771 }
1772 static int __qlcnic_shutdown(struct pci_dev *pdev)
1773 {
1774  struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1775  struct net_device *netdev = adapter->netdev;
1776  int retval;
1777 
1778  netif_device_detach(netdev);
1779 
1780  qlcnic_cancel_fw_work(adapter);
1781 
1782  if (netif_running(netdev))
1783  qlcnic_down(adapter, netdev);
1784 
1785  qlcnic_clr_all_drv_state(adapter, 0);
1786 
1787  clear_bit(__QLCNIC_RESETTING, &adapter->state);
1788 
1789  retval = pci_save_state(pdev);
1790  if (retval)
1791  return retval;
1792 
1793  if (qlcnic_wol_supported(adapter)) {
1794  pci_enable_wake(pdev, PCI_D3cold, 1);
1795  pci_enable_wake(pdev, PCI_D3hot, 1);
1796  }
1797 
1798  return 0;
1799 }
1800 
1801 static void qlcnic_shutdown(struct pci_dev *pdev)
1802 {
1803  if (__qlcnic_shutdown(pdev))
1804  return;
1805 
1806  pci_disable_device(pdev);
1807 }
1808 
1809 #ifdef CONFIG_PM
1810 static int
1811 qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
1812 {
1813  int retval;
1814 
1815  retval = __qlcnic_shutdown(pdev);
1816  if (retval)
1817  return retval;
1818 
1819  pci_set_power_state(pdev, pci_choose_state(pdev, state));
1820  return 0;
1821 }
1822 
1823 static int
1824 qlcnic_resume(struct pci_dev *pdev)
1825 {
1826  struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1827  struct net_device *netdev = adapter->netdev;
1828  int err;
1829 
1830  err = pci_enable_device(pdev);
1831  if (err)
1832  return err;
1833 
1834  pci_set_power_state(pdev, PCI_D0);
1835  pci_set_master(pdev);
1836  pci_restore_state(pdev);
1837 
1838  err = adapter->nic_ops->start_firmware(adapter);
1839  if (err) {
1840  dev_err(&pdev->dev, "failed to start firmware\n");
1841  return err;
1842  }
1843 
1844  if (netif_running(netdev)) {
1845  err = qlcnic_up(adapter, netdev);
1846  if (err)
1847  goto done;
1848 
1849  qlcnic_restore_indev_addr(netdev, NETDEV_UP);
1850  }
1851 done:
1852  netif_device_attach(netdev);
1853  qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
1854  return 0;
1855 }
1856 #endif
1857 
1858 static int qlcnic_open(struct net_device *netdev)
1859 {
1860  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1861  u32 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
1862  int err;
1863 
1864  if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD)) {
1865  netdev_err(netdev, "Device in FAILED state\n");
1866  return -EIO;
1867  }
1868 
1869  netif_carrier_off(netdev);
1870 
1871  err = qlcnic_attach(adapter);
1872  if (err)
1873  return err;
1874 
1875  err = __qlcnic_up(adapter, netdev);
1876  if (err)
1877  goto err_out;
1878 
1879  netif_start_queue(netdev);
1880 
1881  return 0;
1882 
1883 err_out:
1884  qlcnic_detach(adapter);
1885  return err;
1886 }
1887 
1888 /*
1889  * qlcnic_close - Disables a network interface entry point
1890  */
1891 static int qlcnic_close(struct net_device *netdev)
1892 {
1893  struct qlcnic_adapter *adapter = netdev_priv(netdev);
1894 
1895  __qlcnic_down(adapter, netdev);
1896  return 0;
1897 }
1898 
1899 void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
1900 {
1901  void *head;
1902  int i;
1903 
1904  if (adapter->fhash.fmax && adapter->fhash.fhead)
1905  return;
1906 
1907  spin_lock_init(&adapter->mac_learn_lock);
1908 
1909  head = kcalloc(QLCNIC_LB_MAX_FILTERS, sizeof(struct hlist_head),
1910  GFP_KERNEL);
1911  if (!head)
1912  return;
1913 
1914  adapter->fhash.fmax = QLCNIC_LB_MAX_FILTERS;
1915  adapter->fhash.fhead = head;
1916 
1917  for (i = 0; i < adapter->fhash.fmax; i++)
1918  INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
1919 }
1920 
1921 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
1922 {
1923  if (adapter->fhash.fmax && adapter->fhash.fhead)
1924  kfree(adapter->fhash.fhead);
1925 
1926  adapter->fhash.fhead = NULL;
1927  adapter->fhash.fmax = 0;
1928 }
1929 
1930 static void qlcnic_change_filter(struct qlcnic_adapter *adapter,
1931  u64 uaddr, __le16 vlan_id, struct qlcnic_host_tx_ring *tx_ring)
1932 {
1933  struct cmd_desc_type0 *hwdesc;
1934  struct qlcnic_nic_req *req;
1935  struct qlcnic_mac_req *mac_req;
1936  struct qlcnic_vlan_req *vlan_req;
1937  u32 producer;
1938  u64 word;
1939 
1940  producer = tx_ring->producer;
1941  hwdesc = &tx_ring->desc_head[tx_ring->producer];
1942 
1943  req = (struct qlcnic_nic_req *)hwdesc;
1944  memset(req, 0, sizeof(struct qlcnic_nic_req));
1945  req->qhdr = cpu_to_le64(QLCNIC_REQUEST << 23);
1946 
1947  word = QLCNIC_MAC_EVENT | ((u64)(adapter->portnum) << 16);
1948  req->req_hdr = cpu_to_le64(word);
1949 
1950  mac_req = (struct qlcnic_mac_req *)&(req->words[0]);
1951  mac_req->op = vlan_id ? QLCNIC_MAC_VLAN_ADD : QLCNIC_MAC_ADD;
1952  memcpy(mac_req->mac_addr, &uaddr, ETH_ALEN);
1953 
1954  vlan_req = (struct qlcnic_vlan_req *)&req->words[1];
1955  vlan_req->vlan_id = vlan_id;
1956 
1957  tx_ring->producer = get_next_index(producer, tx_ring->num_desc);
1958  smp_mb();
1959 }
1960 
1961 #define QLCNIC_MAC_HASH(MAC)\
1962  ((((MAC) & 0x70000) >> 0x10) | (((MAC) & 0x70000000000ULL) >> 0x25))
1963 
1964 static void
1965 qlcnic_send_filter(struct qlcnic_adapter *adapter,
1966  struct qlcnic_host_tx_ring *tx_ring,
1967  struct cmd_desc_type0 *first_desc,
1968  struct sk_buff *skb)
1969 {
1970  struct ethhdr *phdr = (struct ethhdr *)(skb->data);
1971  struct qlcnic_filter *fil, *tmp_fil;
1972  struct hlist_node *tmp_hnode, *n;
1973  struct hlist_head *head;
1974  u64 src_addr = 0;
1975  __le16 vlan_id = 0;
1976  u8 hindex;
1977 
1978  if (ether_addr_equal(phdr->h_source, adapter->mac_addr))
1979  return;
1980 
1981  if (adapter->fhash.fnum >= adapter->fhash.fmax)
1982  return;
1983 
1984  /* Only NPAR capable devices support vlan based learning*/
1985  if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
1986  vlan_id = first_desc->vlan_TCI;
1987  memcpy(&src_addr, phdr->h_source, ETH_ALEN);
1988  hindex = QLCNIC_MAC_HASH(src_addr) & (QLCNIC_LB_MAX_FILTERS - 1);
1989  head = &(adapter->fhash.fhead[hindex]);
1990 
1991  hlist_for_each_entry_safe(tmp_fil, tmp_hnode, n, head, fnode) {
1992  if (!memcmp(tmp_fil->faddr, &src_addr, ETH_ALEN) &&
1993  tmp_fil->vlan_id == vlan_id) {
1994 
1995  if (jiffies >
1996  (QLCNIC_READD_AGE * HZ + tmp_fil->ftime))
1997  qlcnic_change_filter(adapter, src_addr, vlan_id,
1998  tx_ring);
1999  tmp_fil->ftime = jiffies;
2000  return;
2001  }
2002  }
2003 
2004  fil = kzalloc(sizeof(struct qlcnic_filter), GFP_ATOMIC);
2005  if (!fil)
2006  return;
2007 
2008  qlcnic_change_filter(adapter, src_addr, vlan_id, tx_ring);
2009 
2010  fil->ftime = jiffies;
2011  fil->vlan_id = vlan_id;
2012  memcpy(fil->faddr, &src_addr, ETH_ALEN);
2013  spin_lock(&adapter->mac_learn_lock);
2014  hlist_add_head(&(fil->fnode), head);
2015  adapter->fhash.fnum++;
2016  spin_unlock(&adapter->mac_learn_lock);
2017 }
2018 
2019 static int
2020 qlcnic_tx_pkt(struct qlcnic_adapter *adapter,
2021  struct cmd_desc_type0 *first_desc,
2022  struct sk_buff *skb)
2023 {
2024  u8 opcode = 0, hdr_len = 0;
2025  u16 flags = 0, vlan_tci = 0;
2026  int copied, offset, copy_len;
2027  struct cmd_desc_type0 *hwdesc;
2028  struct vlan_ethhdr *vh;
2029  struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2030  u16 protocol = ntohs(skb->protocol);
2031  u32 producer = tx_ring->producer;
2032 
2033  if (protocol == ETH_P_8021Q) {
2034  vh = (struct vlan_ethhdr *)skb->data;
2035  flags = FLAGS_VLAN_TAGGED;
2036  vlan_tci = vh->h_vlan_TCI;
2037  protocol = ntohs(vh->h_vlan_encapsulated_proto);
2038  } else if (vlan_tx_tag_present(skb)) {
2039  flags = FLAGS_VLAN_OOB;
2040  vlan_tci = vlan_tx_tag_get(skb);
2041  }
2042  if (unlikely(adapter->pvid)) {
2043  if (vlan_tci && !(adapter->flags & QLCNIC_TAGGING_ENABLED))
2044  return -EIO;
2045  if (vlan_tci && (adapter->flags & QLCNIC_TAGGING_ENABLED))
2046  goto set_flags;
2047 
2048  flags = FLAGS_VLAN_OOB;
2049  vlan_tci = adapter->pvid;
2050  }
2051 set_flags:
2052  qlcnic_set_tx_vlan_tci(first_desc, vlan_tci);
2053  qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
2054 
2055  if (*(skb->data) & BIT_0) {
2056  flags |= BIT_0;
2057  memcpy(&first_desc->eth_addr, skb->data, ETH_ALEN);
2058  }
2059  opcode = TX_ETHER_PKT;
2060  if ((adapter->netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
2061  skb_shinfo(skb)->gso_size > 0) {
2062 
2063  hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
2064 
2065  first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
2066  first_desc->total_hdr_length = hdr_len;
2067 
2068  opcode = (protocol == ETH_P_IPV6) ? TX_TCP_LSO6 : TX_TCP_LSO;
2069 
2070  /* For LSO, we need to copy the MAC/IP/TCP headers into
2071  * the descriptor ring */
2072  copied = 0;
2073  offset = 2;
2074 
2075  if (flags & FLAGS_VLAN_OOB) {
2076  first_desc->total_hdr_length += VLAN_HLEN;
2077  first_desc->tcp_hdr_offset = VLAN_HLEN;
2078  first_desc->ip_hdr_offset = VLAN_HLEN;
2079  /* Only in case of TSO on vlan device */
2080  flags |= FLAGS_VLAN_TAGGED;
2081 
2082  /* Create a TSO vlan header template for firmware */
2083 
2084  hwdesc = &tx_ring->desc_head[producer];
2085  tx_ring->cmd_buf_arr[producer].skb = NULL;
2086 
2087  copy_len = min((int)sizeof(struct cmd_desc_type0) -
2088  offset, hdr_len + VLAN_HLEN);
2089 
2090  vh = (struct vlan_ethhdr *)((char *) hwdesc + 2);
2091  skb_copy_from_linear_data(skb, vh, 12);
2092  vh->h_vlan_proto = htons(ETH_P_8021Q);
2093  vh->h_vlan_TCI = htons(vlan_tci);
2094 
2095  skb_copy_from_linear_data_offset(skb, 12,
2096  (char *)vh + 16, copy_len - 16);
2097 
2098  copied = copy_len - VLAN_HLEN;
2099  offset = 0;
2100 
2101  producer = get_next_index(producer, tx_ring->num_desc);
2102  }
2103 
2104  while (copied < hdr_len) {
2105 
2106  copy_len = min((int)sizeof(struct cmd_desc_type0) -
2107  offset, (hdr_len - copied));
2108 
2109  hwdesc = &tx_ring->desc_head[producer];
2110  tx_ring->cmd_buf_arr[producer].skb = NULL;
2111 
2112  skb_copy_from_linear_data_offset(skb, copied,
2113  (char *) hwdesc + offset, copy_len);
2114 
2115  copied += copy_len;
2116  offset = 0;
2117 
2118  producer = get_next_index(producer, tx_ring->num_desc);
2119  }
2120 
2121  tx_ring->producer = producer;
2122  smp_mb();
2123  adapter->stats.lso_frames++;
2124 
2125  } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
2126  u8 l4proto;
2127 
2128  if (protocol == ETH_P_IP) {
2129  l4proto = ip_hdr(skb)->protocol;
2130 
2131  if (l4proto == IPPROTO_TCP)
2132  opcode = TX_TCP_PKT;
2133  else if (l4proto == IPPROTO_UDP)
2134  opcode = TX_UDP_PKT;
2135  } else if (protocol == ETH_P_IPV6) {
2136  l4proto = ipv6_hdr(skb)->nexthdr;
2137 
2138  if (l4proto == IPPROTO_TCP)
2139  opcode = TX_TCPV6_PKT;
2140  else if (l4proto == IPPROTO_UDP)
2141  opcode = TX_UDPV6_PKT;
2142  }
2143  }
2144  first_desc->tcp_hdr_offset += skb_transport_offset(skb);
2145  first_desc->ip_hdr_offset += skb_network_offset(skb);
2146  qlcnic_set_tx_flags_opcode(first_desc, flags, opcode);
2147 
2148  return 0;
2149 }
2150 
2151 static int
2152 qlcnic_map_tx_skb(struct pci_dev *pdev,
2153  struct sk_buff *skb, struct qlcnic_cmd_buffer *pbuf)
2154 {
2155  struct qlcnic_skb_frag *nf;
2156  struct skb_frag_struct *frag;
2157  int i, nr_frags;
2158  dma_addr_t map;
2159 
2160  nr_frags = skb_shinfo(skb)->nr_frags;
2161  nf = &pbuf->frag_array[0];
2162 
2163  map = pci_map_single(pdev, skb->data,
2164  skb_headlen(skb), PCI_DMA_TODEVICE);
2165  if (pci_dma_mapping_error(pdev, map))
2166  goto out_err;
2167 
2168  nf->dma = map;
2169  nf->length = skb_headlen(skb);
2170 
2171  for (i = 0; i < nr_frags; i++) {
2172  frag = &skb_shinfo(skb)->frags[i];
2173  nf = &pbuf->frag_array[i+1];
2174 
2175  map = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
2176  DMA_TO_DEVICE);
2177  if (dma_mapping_error(&pdev->dev, map))
2178  goto unwind;
2179 
2180  nf->dma = map;
2181  nf->length = skb_frag_size(frag);
2182  }
2183 
2184  return 0;
2185 
2186 unwind:
2187  while (--i >= 0) {
2188  nf = &pbuf->frag_array[i+1];
2189  pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
2190  }
2191 
2192  nf = &pbuf->frag_array[0];
2193  pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
2194 
2195 out_err:
2196  return -ENOMEM;
2197 }
2198 
2199 static void
2200 qlcnic_unmap_buffers(struct pci_dev *pdev, struct sk_buff *skb,
2201  struct qlcnic_cmd_buffer *pbuf)
2202 {
2203  struct qlcnic_skb_frag *nf = &pbuf->frag_array[0];
2204  int nr_frags = skb_shinfo(skb)->nr_frags;
2205  int i;
2206 
2207  for (i = 0; i < nr_frags; i++) {
2208  nf = &pbuf->frag_array[i+1];
2209  pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
2210  }
2211 
2212  nf = &pbuf->frag_array[0];
2213  pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
2214  pbuf->skb = NULL;
2215 }
2216 
2217 static inline void
2218 qlcnic_clear_cmddesc(u64 *desc)
2219 {
2220  desc[0] = 0ULL;
2221  desc[2] = 0ULL;
2222  desc[7] = 0ULL;
2223 }
2224 
2225 netdev_tx_t
2226 qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
2227 {
2228  struct qlcnic_adapter *adapter = netdev_priv(netdev);
2229  struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2230  struct qlcnic_cmd_buffer *pbuf;
2231  struct qlcnic_skb_frag *buffrag;
2232  struct cmd_desc_type0 *hwdesc, *first_desc;
2233  struct pci_dev *pdev;
2234  struct ethhdr *phdr;
2235  int delta = 0;
2236  int i, k;
2237 
2238  u32 producer;
2239  int frag_count;
2240  u32 num_txd = tx_ring->num_desc;
2241 
2242  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
2243  netif_stop_queue(netdev);
2244  return NETDEV_TX_BUSY;
2245  }
2246 
2247  if (adapter->flags & QLCNIC_MACSPOOF) {
2248  phdr = (struct ethhdr *)skb->data;
2249  if (!ether_addr_equal(phdr->h_source, adapter->mac_addr))
2250  goto drop_packet;
2251  }
2252 
2253  frag_count = skb_shinfo(skb)->nr_frags + 1;
2254  /* 14 frags supported for normal packet and
2255  * 32 frags supported for TSO packet
2256  */
2257  if (!skb_is_gso(skb) && frag_count > QLCNIC_MAX_FRAGS_PER_TX) {
2258 
2259  for (i = 0; i < (frag_count - QLCNIC_MAX_FRAGS_PER_TX); i++)
2260  delta += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2261 
2262  if (!__pskb_pull_tail(skb, delta))
2263  goto drop_packet;
2264 
2265  frag_count = 1 + skb_shinfo(skb)->nr_frags;
2266  }
2267 
2268  if (unlikely(qlcnic_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
2269  netif_stop_queue(netdev);
2270  if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH)
2271  netif_start_queue(netdev);
2272  else {
2273  adapter->stats.xmit_off++;
2274  return NETDEV_TX_BUSY;
2275  }
2276  }
2277 
2278  producer = tx_ring->producer;
2279  pbuf = &tx_ring->cmd_buf_arr[producer];
2280 
2281  pdev = adapter->pdev;
2282 
2283  first_desc = hwdesc = &tx_ring->desc_head[producer];
2284  qlcnic_clear_cmddesc((u64 *)hwdesc);
2285 
2286  if (qlcnic_map_tx_skb(pdev, skb, pbuf)) {
2287  adapter->stats.tx_dma_map_error++;
2288  goto drop_packet;
2289  }
2290 
2291  pbuf->skb = skb;
2292  pbuf->frag_count = frag_count;
2293 
2294  qlcnic_set_tx_frags_len(first_desc, frag_count, skb->len);
2295  qlcnic_set_tx_port(first_desc, adapter->portnum);
2296 
2297  for (i = 0; i < frag_count; i++) {
2298 
2299  k = i % 4;
2300 
2301  if ((k == 0) && (i > 0)) {
2302  /* move to next desc.*/
2303  producer = get_next_index(producer, num_txd);
2304  hwdesc = &tx_ring->desc_head[producer];
2305  qlcnic_clear_cmddesc((u64 *)hwdesc);
2306  tx_ring->cmd_buf_arr[producer].skb = NULL;
2307  }
2308 
2309  buffrag = &pbuf->frag_array[i];
2310 
2311  hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
2312  switch (k) {
2313  case 0:
2314  hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
2315  break;
2316  case 1:
2317  hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
2318  break;
2319  case 2:
2320  hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
2321  break;
2322  case 3:
2323  hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
2324  break;
2325  }
2326  }
2327 
2328  tx_ring->producer = get_next_index(producer, num_txd);
2329  smp_mb();
2330 
2331  if (unlikely(qlcnic_tx_pkt(adapter, first_desc, skb)))
2332  goto unwind_buff;
2333 
2334  if (adapter->mac_learn)
2335  qlcnic_send_filter(adapter, tx_ring, first_desc, skb);
2336 
2337  adapter->stats.txbytes += skb->len;
2338  adapter->stats.xmitcalled++;
2339 
2340  qlcnic_update_cmd_producer(adapter, tx_ring);
2341 
2342  return NETDEV_TX_OK;
2343 
2344 unwind_buff:
2345  qlcnic_unmap_buffers(pdev, skb, pbuf);
2346 drop_packet:
2347  adapter->stats.txdropped++;
2348  dev_kfree_skb_any(skb);
2349  return NETDEV_TX_OK;
2350 }
2351 
2352 static int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2353 {
2354  struct net_device *netdev = adapter->netdev;
2355  u32 temp, temp_state, temp_val;
2356  int rv = 0;
2357 
2358  temp = QLCRD32(adapter, CRB_TEMP_STATE);
2359 
2360  temp_state = qlcnic_get_temp_state(temp);
2361  temp_val = qlcnic_get_temp_val(temp);
2362 
2363  if (temp_state == QLCNIC_TEMP_PANIC) {
2364  dev_err(&netdev->dev,
2365  "Device temperature %d degrees C exceeds"
2366  " maximum allowed. Hardware has been shut down.\n",
2367  temp_val);
2368  rv = 1;
2369  } else if (temp_state == QLCNIC_TEMP_WARN) {
2370  if (adapter->temp == QLCNIC_TEMP_NORMAL) {
2371  dev_err(&netdev->dev,
2372  "Device temperature %d degrees C "
2373  "exceeds operating range."
2374  " Immediate action needed.\n",
2375  temp_val);
2376  }
2377  } else {
2378  if (adapter->temp == QLCNIC_TEMP_WARN) {
2379  dev_info(&netdev->dev,
2380  "Device temperature is now %d degrees C"
2381  " in normal range.\n", temp_val);
2382  }
2383  }
2384  adapter->temp = temp_state;
2385  return rv;
2386 }
2387 
2388 void qlcnic_advert_link_change(struct qlcnic_adapter *adapter, int linkup)
2389 {
2390  struct net_device *netdev = adapter->netdev;
2391 
2392  if (adapter->ahw->linkup && !linkup) {
2393  netdev_info(netdev, "NIC Link is down\n");
2394  adapter->ahw->linkup = 0;
2395  if (netif_running(netdev)) {
2396  netif_carrier_off(netdev);
2397  netif_stop_queue(netdev);
2398  }
2399  } else if (!adapter->ahw->linkup && linkup) {
2400  netdev_info(netdev, "NIC Link is up\n");
2401  adapter->ahw->linkup = 1;
2402  if (netif_running(netdev)) {
2403  netif_carrier_on(netdev);
2404  netif_wake_queue(netdev);
2405  }
2406  }
2407 }
2408 
2409 static void qlcnic_tx_timeout(struct net_device *netdev)
2410 {
2411  struct qlcnic_adapter *adapter = netdev_priv(netdev);
2412 
2413  if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2414  return;
2415 
2416  dev_err(&netdev->dev, "transmit timeout, resetting.\n");
2417 
2418  if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
2419  adapter->need_fw_reset = 1;
2420  else
2421  adapter->reset_context = 1;
2422 }
2423 
2424 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
2425 {
2426  struct qlcnic_adapter *adapter = netdev_priv(netdev);
2427  struct net_device_stats *stats = &netdev->stats;
2428 
2429  stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2430  stats->tx_packets = adapter->stats.xmitfinished;
2431  stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
2432  stats->tx_bytes = adapter->stats.txbytes;
2433  stats->rx_dropped = adapter->stats.rxdropped;
2434  stats->tx_dropped = adapter->stats.txdropped;
2435 
2436  return stats;
2437 }
2438 
2439 static irqreturn_t qlcnic_clear_legacy_intr(struct qlcnic_adapter *adapter)
2440 {
2441  u32 status;
2442 
2443  status = readl(adapter->isr_int_vec);
2444 
2445  if (!(status & adapter->int_vec_bit))
2446  return IRQ_NONE;
2447 
2448  /* check interrupt state machine, to be sure */
2449  status = readl(adapter->crb_int_state_reg);
2450  if (!ISR_LEGACY_INT_TRIGGERED(status))
2451  return IRQ_NONE;
2452 
2453  writel(0xffffffff, adapter->tgt_status_reg);
2454  /* read twice to ensure write is flushed */
2455  readl(adapter->isr_int_vec);
2456  readl(adapter->isr_int_vec);
2457 
2458  return IRQ_HANDLED;
2459 }
2460 
2461 static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
2462 {
2463  struct qlcnic_host_sds_ring *sds_ring = data;
2464  struct qlcnic_adapter *adapter = sds_ring->adapter;
2465 
2466  if (adapter->flags & QLCNIC_MSIX_ENABLED)
2467  goto done;
2468  else if (adapter->flags & QLCNIC_MSI_ENABLED) {
2469  writel(0xffffffff, adapter->tgt_status_reg);
2470  goto done;
2471  }
2472 
2473  if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2474  return IRQ_NONE;
2475 
2476 done:
2477  adapter->diag_cnt++;
2478  qlcnic_enable_int(sds_ring);
2479  return IRQ_HANDLED;
2480 }
2481 
2482 static irqreturn_t qlcnic_intr(int irq, void *data)
2483 {
2484  struct qlcnic_host_sds_ring *sds_ring = data;
2485  struct qlcnic_adapter *adapter = sds_ring->adapter;
2486 
2487  if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2488  return IRQ_NONE;
2489 
2490  napi_schedule(&sds_ring->napi);
2491 
2492  return IRQ_HANDLED;
2493 }
2494 
2495 static irqreturn_t qlcnic_msi_intr(int irq, void *data)
2496 {
2497  struct qlcnic_host_sds_ring *sds_ring = data;
2498  struct qlcnic_adapter *adapter = sds_ring->adapter;
2499 
2500  /* clear interrupt */
2501  writel(0xffffffff, adapter->tgt_status_reg);
2502 
2503  napi_schedule(&sds_ring->napi);
2504  return IRQ_HANDLED;
2505 }
2506 
2507 static irqreturn_t qlcnic_msix_intr(int irq, void *data)
2508 {
2509  struct qlcnic_host_sds_ring *sds_ring = data;
2510 
2511  napi_schedule(&sds_ring->napi);
2512  return IRQ_HANDLED;
2513 }
2514 
2515 static int qlcnic_process_cmd_ring(struct qlcnic_adapter *adapter)
2516 {
2517  u32 sw_consumer, hw_consumer;
2518  int count = 0, i;
2519  struct qlcnic_cmd_buffer *buffer;
2520  struct pci_dev *pdev = adapter->pdev;
2521  struct net_device *netdev = adapter->netdev;
2522  struct qlcnic_skb_frag *frag;
2523  int done;
2524  struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
2525 
2526  if (!spin_trylock(&adapter->tx_clean_lock))
2527  return 1;
2528 
2529  sw_consumer = tx_ring->sw_consumer;
2530  hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2531 
2532  while (sw_consumer != hw_consumer) {
2533  buffer = &tx_ring->cmd_buf_arr[sw_consumer];
2534  if (buffer->skb) {
2535  frag = &buffer->frag_array[0];
2536  pci_unmap_single(pdev, frag->dma, frag->length,
2537  PCI_DMA_TODEVICE);
2538  frag->dma = 0ULL;
2539  for (i = 1; i < buffer->frag_count; i++) {
2540  frag++;
2541  pci_unmap_page(pdev, frag->dma, frag->length,
2542  PCI_DMA_TODEVICE);
2543  frag->dma = 0ULL;
2544  }
2545 
2546  adapter->stats.xmitfinished++;
2547  dev_kfree_skb_any(buffer->skb);
2548  buffer->skb = NULL;
2549  }
2550 
2551  sw_consumer = get_next_index(sw_consumer, tx_ring->num_desc);
2552  if (++count >= MAX_STATUS_HANDLE)
2553  break;
2554  }
2555 
2556  if (count && netif_running(netdev)) {
2557  tx_ring->sw_consumer = sw_consumer;
2558 
2559  smp_mb();
2560 
2561  if (netif_queue_stopped(netdev) && netif_carrier_ok(netdev)) {
2562  if (qlcnic_tx_avail(tx_ring) > TX_STOP_THRESH) {
2563  netif_wake_queue(netdev);
2564  adapter->stats.xmit_on++;
2565  }
2566  }
2567  adapter->tx_timeo_cnt = 0;
2568  }
2569  /*
2570  * If everything is freed up to consumer then check if the ring is full
2571  * If the ring is full then check if more needs to be freed and
2572  * schedule the call back again.
2573  *
2574  * This happens when there are 2 CPUs. One could be freeing and the
2575  * other filling it. If the ring is full when we get out of here and
2576  * the card has already interrupted the host then the host can miss the
2577  * interrupt.
2578  *
2579  * There is still a possible race condition and the host could miss an
2580  * interrupt. The card has to take care of this.
2581  */
2582  hw_consumer = le32_to_cpu(*(tx_ring->hw_consumer));
2583  done = (sw_consumer == hw_consumer);
2584  spin_unlock(&adapter->tx_clean_lock);
2585 
2586  return done;
2587 }
2588 
2589 static int qlcnic_poll(struct napi_struct *napi, int budget)
2590 {
2591  struct qlcnic_host_sds_ring *sds_ring =
2592  container_of(napi, struct qlcnic_host_sds_ring, napi);
2593 
2594  struct qlcnic_adapter *adapter = sds_ring->adapter;
2595 
2596  int tx_complete;
2597  int work_done;
2598 
2599  tx_complete = qlcnic_process_cmd_ring(adapter);
2600 
2601  work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2602 
2603  if ((work_done < budget) && tx_complete) {
2604  napi_complete(&sds_ring->napi);
2605  if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2606  qlcnic_enable_int(sds_ring);
2607  }
2608 
2609  return work_done;
2610 }
2611 
2612 static int qlcnic_rx_poll(struct napi_struct *napi, int budget)
2613 {
2614  struct qlcnic_host_sds_ring *sds_ring =
2615  container_of(napi, struct qlcnic_host_sds_ring, napi);
2616 
2617  struct qlcnic_adapter *adapter = sds_ring->adapter;
2618  int work_done;
2619 
2620  work_done = qlcnic_process_rcv_ring(sds_ring, budget);
2621 
2622  if (work_done < budget) {
2623  napi_complete(&sds_ring->napi);
2624  if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
2625  qlcnic_enable_int(sds_ring);
2626  }
2627 
2628  return work_done;
2629 }
2630 
2631 #ifdef CONFIG_NET_POLL_CONTROLLER
2632 static void qlcnic_poll_controller(struct net_device *netdev)
2633 {
2634  int ring;
2635  struct qlcnic_host_sds_ring *sds_ring;
2636  struct qlcnic_adapter *adapter = netdev_priv(netdev);
2637  struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
2638 
2639  disable_irq(adapter->irq);
2640  for (ring = 0; ring < adapter->max_sds_rings; ring++) {
2641  sds_ring = &recv_ctx->sds_rings[ring];
2642  qlcnic_intr(adapter->irq, sds_ring);
2643  }
2644  enable_irq(adapter->irq);
2645 }
2646 #endif
2647 
2648 static void
2649 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2650 {
2651  u32 val;
2652 
2653  val = adapter->portnum & 0xf;
2654  val |= encoding << 7;
2655  val |= (jiffies - adapter->dev_rst_time) << 8;
2656 
2657  QLCWR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2658  adapter->dev_rst_time = jiffies;
2659 }
2660 
2661 static int
2662 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
2663 {
2664  u32 val;
2665 
2666  WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2667  state != QLCNIC_DEV_NEED_QUISCENT);
2668 
2669  if (qlcnic_api_lock(adapter))
2670  return -EIO;
2671 
2672  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2673 
2674  if (state == QLCNIC_DEV_NEED_RESET)
2675  QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2676  else if (state == QLCNIC_DEV_NEED_QUISCENT)
2677  QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
2678 
2679  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2680 
2681  qlcnic_api_unlock(adapter);
2682 
2683  return 0;
2684 }
2685 
2686 static int
2687 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2688 {
2689  u32 val;
2690 
2691  if (qlcnic_api_lock(adapter))
2692  return -EBUSY;
2693 
2694  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2695  QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2696  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2697 
2698  qlcnic_api_unlock(adapter);
2699 
2700  return 0;
2701 }
2702 
2703 static void
2704 qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
2705 {
2706  u32 val;
2707 
2708  if (qlcnic_api_lock(adapter))
2709  goto err;
2710 
2711  val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2712  QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
2713  QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2714 
2715  if (failed) {
2716  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
2717  dev_info(&adapter->pdev->dev,
2718  "Device state set to Failed. Please Reboot\n");
2719  } else if (!(val & 0x11111111))
2720  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_COLD);
2721 
2722  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2723  QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2724  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2725 
2726  qlcnic_api_unlock(adapter);
2727 err:
2728  adapter->fw_fail_cnt = 0;
2729  adapter->flags &= ~QLCNIC_FW_HANG;
2730  clear_bit(__QLCNIC_START_FW, &adapter->state);
2731  clear_bit(__QLCNIC_RESETTING, &adapter->state);
2732 }
2733 
2734 /* Grab api lock, before checking state */
2735 static int
2736 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2737 {
2738  int act, state, active_mask;
2739 
2740  state = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2741  act = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2742 
2743  if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
2744  active_mask = (~(1 << (adapter->ahw->pci_func * 4)));
2745  act = act & active_mask;
2746  }
2747 
2748  if (((state & 0x11111111) == (act & 0x11111111)) ||
2749  ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2750  return 0;
2751  else
2752  return 1;
2753 }
2754 
2755 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2756 {
2757  u32 val = QLCRD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
2758 
2759  if (val != QLCNIC_DRV_IDC_VER) {
2760  dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2761  " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2762  }
2763 
2764  return 0;
2765 }
2766 
2767 static int
2768 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2769 {
2770  u32 val, prev_state;
2771  u8 dev_init_timeo = adapter->dev_init_timeo;
2772  u8 portnum = adapter->portnum;
2773  u8 ret;
2774 
2775  if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2776  return 1;
2777 
2778  if (qlcnic_api_lock(adapter))
2779  return -1;
2780 
2781  val = QLCRD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2782  if (!(val & (1 << (portnum * 4)))) {
2783  QLC_DEV_SET_REF_CNT(val, portnum);
2784  QLCWR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2785  }
2786 
2787  prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2788  QLCDB(adapter, HW, "Device state = %u\n", prev_state);
2789 
2790  switch (prev_state) {
2791  case QLCNIC_DEV_COLD:
2792  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
2793  QLCWR32(adapter, QLCNIC_CRB_DRV_IDC_VER, QLCNIC_DRV_IDC_VER);
2794  qlcnic_idc_debug_info(adapter, 0);
2795  qlcnic_api_unlock(adapter);
2796  return 1;
2797 
2798  case QLCNIC_DEV_READY:
2799  ret = qlcnic_check_idc_ver(adapter);
2800  qlcnic_api_unlock(adapter);
2801  return ret;
2802 
2803  case QLCNIC_DEV_NEED_RESET:
2804  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2805  QLC_DEV_SET_RST_RDY(val, portnum);
2806  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2807  break;
2808 
2809  case QLCNIC_DEV_NEED_QUISCENT:
2810  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2811  QLC_DEV_SET_QSCNT_RDY(val, portnum);
2812  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2813  break;
2814 
2815  case QLCNIC_DEV_FAILED:
2816  dev_err(&adapter->pdev->dev, "Device in failed state.\n");
2817  qlcnic_api_unlock(adapter);
2818  return -1;
2819 
2820  case QLCNIC_DEV_INITIALIZING:
2821  case QLCNIC_DEV_QUISCENT:
2822  break;
2823  }
2824 
2825  qlcnic_api_unlock(adapter);
2826 
2827  do {
2828  msleep(1000);
2829  prev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2830 
2831  if (prev_state == QLCNIC_DEV_QUISCENT)
2832  continue;
2833  } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
2834 
2835  if (!dev_init_timeo) {
2836  dev_err(&adapter->pdev->dev,
2837  "Waiting for device to initialize timeout\n");
2838  return -1;
2839  }
2840 
2841  if (qlcnic_api_lock(adapter))
2842  return -1;
2843 
2844  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2845  QLC_DEV_CLR_RST_QSCNT(val, portnum);
2846  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2847 
2848  ret = qlcnic_check_idc_ver(adapter);
2849  qlcnic_api_unlock(adapter);
2850 
2851  return ret;
2852 }
2853 
2854 static void
2855 qlcnic_fwinit_work(struct work_struct *work)
2856 {
2857  struct qlcnic_adapter *adapter = container_of(work,
2858  struct qlcnic_adapter, fw_work.work);
2859  u32 dev_state = 0xf;
2860  u32 val;
2861 
2862  if (qlcnic_api_lock(adapter))
2863  goto err_ret;
2864 
2865  dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2866  if (dev_state == QLCNIC_DEV_QUISCENT ||
2867  dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2868  qlcnic_api_unlock(adapter);
2869  qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2870  FW_POLL_DELAY * 2);
2871  return;
2872  }
2873 
2874  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
2875  qlcnic_api_unlock(adapter);
2876  goto wait_npar;
2877  }
2878 
2879  if (dev_state == QLCNIC_DEV_INITIALIZING ||
2880  dev_state == QLCNIC_DEV_READY) {
2881  dev_info(&adapter->pdev->dev, "Detected state change from "
2882  "DEV_NEED_RESET, skipping ack check\n");
2883  goto skip_ack_check;
2884  }
2885 
2886  if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2887  dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2888  adapter->reset_ack_timeo);
2889  goto skip_ack_check;
2890  }
2891 
2892  if (!qlcnic_check_drv_state(adapter)) {
2893 skip_ack_check:
2894  dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2895 
2896  if (dev_state == QLCNIC_DEV_NEED_RESET) {
2897  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE,
2898  QLCNIC_DEV_INITIALIZING);
2899  set_bit(__QLCNIC_START_FW, &adapter->state);
2900  QLCDB(adapter, DRV, "Restarting fw\n");
2901  qlcnic_idc_debug_info(adapter, 0);
2902  val = QLCRD32(adapter, QLCNIC_CRB_DRV_STATE);
2903  QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2904  QLCWR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2905  }
2906 
2907  qlcnic_api_unlock(adapter);
2908 
2909  rtnl_lock();
2910  if (adapter->ahw->fw_dump.enable &&
2911  (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
2912  QLCDB(adapter, DRV, "Take FW dump\n");
2913  qlcnic_dump_fw(adapter);
2914  adapter->flags |= QLCNIC_FW_HANG;
2915  }
2916  rtnl_unlock();
2917 
2918  adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
2919  if (!adapter->nic_ops->start_firmware(adapter)) {
2920  qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2921  adapter->fw_wait_cnt = 0;
2922  return;
2923  }
2924  goto err_ret;
2925  }
2926 
2927  qlcnic_api_unlock(adapter);
2928 
2929 wait_npar:
2930  dev_state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
2931  QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
2932 
2933  switch (dev_state) {
2934  case QLCNIC_DEV_READY:
2935  if (!adapter->nic_ops->start_firmware(adapter)) {
2936  qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2937  adapter->fw_wait_cnt = 0;
2938  return;
2939  }
2940  case QLCNIC_DEV_FAILED:
2941  break;
2942  default:
2943  qlcnic_schedule_work(adapter,
2944  qlcnic_fwinit_work, FW_POLL_DELAY);
2945  return;
2946  }
2947 
2948 err_ret:
2949  dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2950  "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
2951  netif_device_attach(adapter->netdev);
2952  qlcnic_clr_all_drv_state(adapter, 0);
2953 }
2954 
2955 static void
2956 qlcnic_detach_work(struct work_struct *work)
2957 {
2958  struct qlcnic_adapter *adapter = container_of(work,
2959  struct qlcnic_adapter, fw_work.work);
2960  struct net_device *netdev = adapter->netdev;
2961  u32 status;
2962 
2963  netif_device_detach(netdev);
2964 
2965  /* Dont grab rtnl lock during Quiscent mode */
2966  if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2967  if (netif_running(netdev))
2968  __qlcnic_down(adapter, netdev);
2969  } else
2970  qlcnic_down(adapter, netdev);
2971 
2972  status = QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2973 
2974  if (status & QLCNIC_RCODE_FATAL_ERROR) {
2975  dev_err(&adapter->pdev->dev,
2976  "Detaching the device: peg halt status1=0x%x\n",
2977  status);
2978 
2979  if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
2980  dev_err(&adapter->pdev->dev,
2981  "On board active cooling fan failed. "
2982  "Device has been halted.\n");
2983  dev_err(&adapter->pdev->dev,
2984  "Replace the adapter.\n");
2985  }
2986 
2987  goto err_ret;
2988  }
2989 
2990  if (adapter->temp == QLCNIC_TEMP_PANIC) {
2991  dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
2992  adapter->temp);
2993  goto err_ret;
2994  }
2995 
2996  /* Dont ack if this instance is the reset owner */
2997  if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
2998  if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
2999  dev_err(&adapter->pdev->dev,
3000  "Failed to set driver state,"
3001  "detaching the device.\n");
3002  goto err_ret;
3003  }
3004  }
3005 
3006  adapter->fw_wait_cnt = 0;
3007 
3008  qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
3009 
3010  return;
3011 
3012 err_ret:
3013  netif_device_attach(netdev);
3014  qlcnic_clr_all_drv_state(adapter, 1);
3015 }
3016 
3017 /*Transit NPAR state to NON Operational */
3018 static void
3019 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
3020 {
3021  u32 state;
3022 
3023  state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3024  if (state == QLCNIC_DEV_NPAR_NON_OPER)
3025  return;
3026 
3027  if (qlcnic_api_lock(adapter))
3028  return;
3029  QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
3030  qlcnic_api_unlock(adapter);
3031 }
3032 
3033 /*Transit to RESET state from READY state only */
3034 void
3035 qlcnic_dev_request_reset(struct qlcnic_adapter *adapter)
3036 {
3037  u32 state, xg_val = 0, gb_val = 0;
3038 
3039  qlcnic_xg_set_xg0_mask(xg_val);
3040  qlcnic_xg_set_xg1_mask(xg_val);
3041  QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
3042  qlcnic_gb_set_gb0_mask(gb_val);
3043  qlcnic_gb_set_gb1_mask(gb_val);
3044  qlcnic_gb_set_gb2_mask(gb_val);
3045  qlcnic_gb_set_gb3_mask(gb_val);
3046  QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
3047  dev_info(&adapter->pdev->dev, "Pause control frames disabled"
3048  " on all ports\n");
3049  adapter->need_fw_reset = 1;
3050  if (qlcnic_api_lock(adapter))
3051  return;
3052 
3053  state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
3054  if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD)) {
3055  netdev_err(adapter->netdev,
3056  "Device is in FAILED state, Please Reboot\n");
3057  qlcnic_api_unlock(adapter);
3058  return;
3059  }
3060 
3061  if (state == QLCNIC_DEV_READY) {
3062  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_NEED_RESET);
3063  adapter->flags |= QLCNIC_FW_RESET_OWNER;
3064  QLCDB(adapter, DRV, "NEED_RESET state set\n");
3065  qlcnic_idc_debug_info(adapter, 0);
3066  }
3067 
3068  QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_NON_OPER);
3069  qlcnic_api_unlock(adapter);
3070 }
3071 
3072 /* Transit to NPAR READY state from NPAR NOT READY state */
3073 static void
3074 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
3075 {
3076  if (qlcnic_api_lock(adapter))
3077  return;
3078 
3079  QLCWR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE, QLCNIC_DEV_NPAR_OPER);
3080  QLCDB(adapter, DRV, "NPAR operational state set\n");
3081 
3082  qlcnic_api_unlock(adapter);
3083 }
3084 
3085 static void
3086 qlcnic_schedule_work(struct qlcnic_adapter *adapter,
3087  work_func_t func, int delay)
3088 {
3089  if (test_bit(__QLCNIC_AER, &adapter->state))
3090  return;
3091 
3092  INIT_DELAYED_WORK(&adapter->fw_work, func);
3093  queue_delayed_work(qlcnic_wq, &adapter->fw_work,
3094  round_jiffies_relative(delay));
3095 }
3096 
3097 static void
3098 qlcnic_cancel_fw_work(struct qlcnic_adapter *adapter)
3099 {
3100  while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
3101  msleep(10);
3102 
3103  if (!adapter->fw_work.work.func)
3104  return;
3105 
3106  cancel_delayed_work_sync(&adapter->fw_work);
3107 }
3108 
3109 static void
3110 qlcnic_attach_work(struct work_struct *work)
3111 {
3112  struct qlcnic_adapter *adapter = container_of(work,
3113  struct qlcnic_adapter, fw_work.work);
3114  struct net_device *netdev = adapter->netdev;
3115  u32 npar_state;
3116 
3117  if (adapter->op_mode != QLCNIC_MGMT_FUNC) {
3118  npar_state = QLCRD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3119  if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
3120  qlcnic_clr_all_drv_state(adapter, 0);
3121  else if (npar_state != QLCNIC_DEV_NPAR_OPER)
3122  qlcnic_schedule_work(adapter, qlcnic_attach_work,
3123  FW_POLL_DELAY);
3124  else
3125  goto attach;
3126  QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
3127  return;
3128  }
3129 attach:
3130  if (netif_running(netdev)) {
3131  if (qlcnic_up(adapter, netdev))
3132  goto done;
3133 
3134  qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3135  }
3136 
3137 done:
3138  netif_device_attach(netdev);
3139  adapter->fw_fail_cnt = 0;
3140  adapter->flags &= ~QLCNIC_FW_HANG;
3141  clear_bit(__QLCNIC_RESETTING, &adapter->state);
3142 
3143  if (!qlcnic_clr_drv_state(adapter))
3144  qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3145  FW_POLL_DELAY);
3146 }
3147 
3148 static int
3149 qlcnic_check_health(struct qlcnic_adapter *adapter)
3150 {
3151  u32 state = 0, heartbeat;
3152  u32 peg_status;
3153 
3154  if (qlcnic_check_temp(adapter))
3155  goto detach;
3156 
3157  if (adapter->need_fw_reset)
3158  qlcnic_dev_request_reset(adapter);
3159 
3160  state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
3161  if (state == QLCNIC_DEV_NEED_RESET) {
3162  qlcnic_set_npar_non_operational(adapter);
3163  adapter->need_fw_reset = 1;
3164  } else if (state == QLCNIC_DEV_NEED_QUISCENT)
3165  goto detach;
3166 
3167  heartbeat = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
3168  if (heartbeat != adapter->heartbeat) {
3169  adapter->heartbeat = heartbeat;
3170  adapter->fw_fail_cnt = 0;
3171  if (adapter->need_fw_reset)
3172  goto detach;
3173 
3174  if (adapter->reset_context && auto_fw_reset) {
3175  qlcnic_reset_hw_context(adapter);
3176  adapter->netdev->trans_start = jiffies;
3177  }
3178 
3179  return 0;
3180  }
3181 
3182  if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3183  return 0;
3184 
3185  adapter->flags |= QLCNIC_FW_HANG;
3186 
3187  qlcnic_dev_request_reset(adapter);
3188 
3189  if (auto_fw_reset)
3190  clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3191 
3192  dev_err(&adapter->pdev->dev, "firmware hang detected\n");
3193  dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
3194  "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
3195  "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
3196  "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
3197  "PEG_NET_4_PC: 0x%x\n",
3198  QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1),
3199  QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS2),
3200  QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c),
3201  QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c),
3202  QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c),
3203  QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c),
3204  QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c));
3205  peg_status = QLCRD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3206  if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
3207  dev_err(&adapter->pdev->dev,
3208  "Firmware aborted with error code 0x00006700. "
3209  "Device is being reset.\n");
3210 detach:
3211  adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3212  QLCNIC_DEV_NEED_RESET;
3213 
3214  if (auto_fw_reset &&
3215  !test_and_set_bit(__QLCNIC_RESETTING, &adapter->state)) {
3216 
3217  qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3218  QLCDB(adapter, DRV, "fw recovery scheduled.\n");
3219  }
3220 
3221  return 1;
3222 }
3223 
3224 static void
3225 qlcnic_fw_poll_work(struct work_struct *work)
3226 {
3227  struct qlcnic_adapter *adapter = container_of(work,
3228  struct qlcnic_adapter, fw_work.work);
3229 
3230  if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3231  goto reschedule;
3232 
3233 
3234  if (qlcnic_check_health(adapter))
3235  return;
3236 
3237  if (adapter->fhash.fnum)
3238  qlcnic_prune_lb_filters(adapter);
3239 
3240 reschedule:
3241  qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3242 }
3243 
3244 static int qlcnic_is_first_func(struct pci_dev *pdev)
3245 {
3246  struct pci_dev *oth_pdev;
3247  int val = pdev->devfn;
3248 
3249  while (val-- > 0) {
3250  oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
3251  (pdev->bus), pdev->bus->number,
3252  PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
3253  if (!oth_pdev)
3254  continue;
3255 
3256  if (oth_pdev->current_state != PCI_D3cold) {
3257  pci_dev_put(oth_pdev);
3258  return 0;
3259  }
3260  pci_dev_put(oth_pdev);
3261  }
3262  return 1;
3263 }
3264 
3265 static int qlcnic_attach_func(struct pci_dev *pdev)
3266 {
3267  int err, first_func;
3268  struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3269  struct net_device *netdev = adapter->netdev;
3270 
3271  pdev->error_state = pci_channel_io_normal;
3272 
3273  err = pci_enable_device(pdev);
3274  if (err)
3275  return err;
3276 
3277  pci_set_power_state(pdev, PCI_D0);
3278  pci_set_master(pdev);
3279  pci_restore_state(pdev);
3280 
3281  first_func = qlcnic_is_first_func(pdev);
3282 
3283  if (qlcnic_api_lock(adapter))
3284  return -EINVAL;
3285 
3286  if (adapter->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3287  adapter->need_fw_reset = 1;
3288  set_bit(__QLCNIC_START_FW, &adapter->state);
3289  QLCWR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_INITIALIZING);
3290  QLCDB(adapter, DRV, "Restarting fw\n");
3291  }
3292  qlcnic_api_unlock(adapter);
3293 
3294  err = adapter->nic_ops->start_firmware(adapter);
3295  if (err)
3296  return err;
3297 
3298  qlcnic_clr_drv_state(adapter);
3299  qlcnic_setup_intr(adapter);
3300 
3301  if (netif_running(netdev)) {
3302  err = qlcnic_attach(adapter);
3303  if (err) {
3304  qlcnic_clr_all_drv_state(adapter, 1);
3305  clear_bit(__QLCNIC_AER, &adapter->state);
3306  netif_device_attach(netdev);
3307  return err;
3308  }
3309 
3310  err = qlcnic_up(adapter, netdev);
3311  if (err)
3312  goto done;
3313 
3314  qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3315  }
3316  done:
3317  netif_device_attach(netdev);
3318  return err;
3319 }
3320 
3321 static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3322  pci_channel_state_t state)
3323 {
3324  struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3325  struct net_device *netdev = adapter->netdev;
3326 
3327  if (state == pci_channel_io_perm_failure)
3328  return PCI_ERS_RESULT_DISCONNECT;
3329 
3330  if (state == pci_channel_io_normal)
3331  return PCI_ERS_RESULT_RECOVERED;
3332 
3333  set_bit(__QLCNIC_AER, &adapter->state);
3334  netif_device_detach(netdev);
3335 
3336  cancel_delayed_work_sync(&adapter->fw_work);
3337 
3338  if (netif_running(netdev))
3339  qlcnic_down(adapter, netdev);
3340 
3341  qlcnic_detach(adapter);
3342  qlcnic_teardown_intr(adapter);
3343 
3344  clear_bit(__QLCNIC_RESETTING, &adapter->state);
3345 
3346  pci_save_state(pdev);
3347  pci_disable_device(pdev);
3348 
3349  return PCI_ERS_RESULT_NEED_RESET;
3350 }
3351 
3352 static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3353 {
3354  return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3355  PCI_ERS_RESULT_RECOVERED;
3356 }
3357 
3358 static void qlcnic_io_resume(struct pci_dev *pdev)
3359 {
3360  struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3361 
3362  pci_cleanup_aer_uncorrect_error_status(pdev);
3363 
3364  if (QLCRD32(adapter, QLCNIC_CRB_DEV_STATE) == QLCNIC_DEV_READY &&
3365  test_and_clear_bit(__QLCNIC_AER, &adapter->state))
3366  qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3367  FW_POLL_DELAY);
3368 }
3369 
3370 static int
3371 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3372 {
3373  int err;
3374 
3375  err = qlcnic_can_start_firmware(adapter);
3376  if (err)
3377  return err;
3378 
3379  err = qlcnic_check_npar_opertional(adapter);
3380  if (err)
3381  return err;
3382 
3383  err = qlcnic_initialize_nic(adapter);
3384  if (err)
3385  return err;
3386 
3387  qlcnic_check_options(adapter);
3388 
3389  err = qlcnic_set_eswitch_port_config(adapter);
3390  if (err)
3391  return err;
3392 
3393  adapter->need_fw_reset = 0;
3394 
3395  return err;
3396 }
3397 
3398 static int
3399 qlcnicvf_config_bridged_mode(struct qlcnic_adapter *adapter, u32 enable)
3400 {
3401  return -EOPNOTSUPP;
3402 }
3403 
3404 static int
3405 qlcnicvf_config_led(struct qlcnic_adapter *adapter, u32 state, u32 rate)
3406 {
3407  return -EOPNOTSUPP;
3408 }
3409 
3410 static ssize_t
3411 qlcnic_store_bridged_mode(struct device *dev,
3412  struct device_attribute *attr, const char *buf, size_t len)
3413 {
3414  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3415  unsigned long new;
3416  int ret = -EINVAL;
3417 
3418  if (!(adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG))
3419  goto err_out;
3420 
3421  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3422  goto err_out;
3423 
3424  if (strict_strtoul(buf, 2, &new))
3425  goto err_out;
3426 
3427  if (!adapter->nic_ops->config_bridged_mode(adapter, !!new))
3428  ret = len;
3429 
3430 err_out:
3431  return ret;
3432 }
3433 
3434 static ssize_t
3435 qlcnic_show_bridged_mode(struct device *dev,
3436  struct device_attribute *attr, char *buf)
3437 {
3438  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3439  int bridged_mode = 0;
3440 
3441  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
3442  bridged_mode = !!(adapter->flags & QLCNIC_BRIDGE_ENABLED);
3443 
3444  return sprintf(buf, "%d\n", bridged_mode);
3445 }
3446 
3447 static struct device_attribute dev_attr_bridged_mode = {
3448  .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
3449  .show = qlcnic_show_bridged_mode,
3450  .store = qlcnic_store_bridged_mode,
3451 };
3452 
3453 static ssize_t
3454 qlcnic_store_diag_mode(struct device *dev,
3455  struct device_attribute *attr, const char *buf, size_t len)
3456 {
3457  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3458  unsigned long new;
3459 
3460  if (strict_strtoul(buf, 2, &new))
3461  return -EINVAL;
3462 
3463  if (!!new != !!(adapter->flags & QLCNIC_DIAG_ENABLED))
3464  adapter->flags ^= QLCNIC_DIAG_ENABLED;
3465 
3466  return len;
3467 }
3468 
3469 static ssize_t
3470 qlcnic_show_diag_mode(struct device *dev,
3471  struct device_attribute *attr, char *buf)
3472 {
3473  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3474 
3475  return sprintf(buf, "%d\n",
3476  !!(adapter->flags & QLCNIC_DIAG_ENABLED));
3477 }
3478 
3479 static struct device_attribute dev_attr_diag_mode = {
3480  .attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
3481  .show = qlcnic_show_diag_mode,
3482  .store = qlcnic_store_diag_mode,
3483 };
3484 
3485 int qlcnic_validate_max_rss(struct net_device *netdev, u8 max_hw, u8 val)
3486 {
3487  if (!use_msi_x && !use_msi) {
3488  netdev_info(netdev, "no msix or msi support, hence no rss\n");
3489  return -EINVAL;
3490  }
3491 
3492  if ((val > max_hw) || (val < 2) || !is_power_of_2(val)) {
3493  netdev_info(netdev, "rss_ring valid range [2 - %x] in "
3494  " powers of 2\n", max_hw);
3495  return -EINVAL;
3496  }
3497  return 0;
3498 
3499 }
3500 
3501 int qlcnic_set_max_rss(struct qlcnic_adapter *adapter, u8 data)
3502 {
3503  struct net_device *netdev = adapter->netdev;
3504  int err = 0;
3505 
3506  if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
3507  return -EBUSY;
3508 
3509  netif_device_detach(netdev);
3510  if (netif_running(netdev))
3511  __qlcnic_down(adapter, netdev);
3512  qlcnic_detach(adapter);
3513  qlcnic_teardown_intr(adapter);
3514 
3515  if (qlcnic_enable_msix(adapter, data)) {
3516  netdev_info(netdev, "failed setting max_rss; rss disabled\n");
3517  qlcnic_enable_msi_legacy(adapter);
3518  }
3519 
3520  if (netif_running(netdev)) {
3521  err = qlcnic_attach(adapter);
3522  if (err)
3523  goto done;
3524  err = __qlcnic_up(adapter, netdev);
3525  if (err)
3526  goto done;
3527  qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3528  }
3529  done:
3530  netif_device_attach(netdev);
3531  clear_bit(__QLCNIC_RESETTING, &adapter->state);
3532  return err;
3533 }
3534 
3535 static int
3536 qlcnic_validate_beacon(struct qlcnic_adapter *adapter, u16 beacon, u8 *state,
3537  u8 *rate)
3538 {
3539  *rate = LSB(beacon);
3540  *state = MSB(beacon);
3541 
3542  QLCDB(adapter, DRV, "rate %x state %x\n", *rate, *state);
3543 
3544  if (!*state) {
3545  *rate = __QLCNIC_MAX_LED_RATE;
3546  return 0;
3547  } else if (*state > __QLCNIC_MAX_LED_STATE)
3548  return -EINVAL;
3549 
3550  if ((!*rate) || (*rate > __QLCNIC_MAX_LED_RATE))
3551  return -EINVAL;
3552 
3553  return 0;
3554 }
3555 
3556 static ssize_t
3557 qlcnic_store_beacon(struct device *dev,
3558  struct device_attribute *attr, const char *buf, size_t len)
3559 {
3560  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3561  int max_sds_rings = adapter->max_sds_rings;
3562  u16 beacon;
3563  u8 b_state, b_rate;
3564  int err;
3565 
3566  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC) {
3567  dev_warn(dev, "LED test not supported for non "
3568  "privilege function\n");
3569  return -EOPNOTSUPP;
3570  }
3571 
3572  if (len != sizeof(u16))
3573  return QL_STATUS_INVALID_PARAM;
3574 
3575  memcpy(&beacon, buf, sizeof(u16));
3576  err = qlcnic_validate_beacon(adapter, beacon, &b_state, &b_rate);
3577  if (err)
3578  return err;
3579 
3580  if (adapter->ahw->beacon_state == b_state)
3581  return len;
3582 
3583  rtnl_lock();
3584 
3585  if (!adapter->ahw->beacon_state)
3586  if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state)) {
3587  rtnl_unlock();
3588  return -EBUSY;
3589  }
3590 
3591  if (test_bit(__QLCNIC_RESETTING, &adapter->state)) {
3592  err = -EIO;
3593  goto out;
3594  }
3595 
3596  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
3597  err = qlcnic_diag_alloc_res(adapter->netdev, QLCNIC_LED_TEST);
3598  if (err)
3599  goto out;
3600  set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
3601  }
3602 
3603  err = qlcnic_config_led(adapter, b_state, b_rate);
3604 
3605  if (!err) {
3606  err = len;
3607  adapter->ahw->beacon_state = b_state;
3608  }
3609 
3610  if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
3611  qlcnic_diag_free_res(adapter->netdev, max_sds_rings);
3612 
3613  out:
3614  if (!adapter->ahw->beacon_state)
3615  clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
3616  rtnl_unlock();
3617 
3618  return err;
3619 }
3620 
3621 static ssize_t
3622 qlcnic_show_beacon(struct device *dev,
3623  struct device_attribute *attr, char *buf)
3624 {
3625  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3626 
3627  return sprintf(buf, "%d\n", adapter->ahw->beacon_state);
3628 }
3629 
3630 static struct device_attribute dev_attr_beacon = {
3631  .attr = {.name = "beacon", .mode = (S_IRUGO | S_IWUSR)},
3632  .show = qlcnic_show_beacon,
3633  .store = qlcnic_store_beacon,
3634 };
3635 
3636 static int
3637 qlcnic_sysfs_validate_crb(struct qlcnic_adapter *adapter,
3638  loff_t offset, size_t size)
3639 {
3640  size_t crb_size = 4;
3641 
3642  if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3643  return -EIO;
3644 
3645  if (offset < QLCNIC_PCI_CRBSPACE) {
3646  if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM,
3647  QLCNIC_PCI_CAMQM_END))
3648  crb_size = 8;
3649  else
3650  return -EINVAL;
3651  }
3652 
3653  if ((size != crb_size) || (offset & (crb_size-1)))
3654  return -EINVAL;
3655 
3656  return 0;
3657 }
3658 
3659 static ssize_t
3660 qlcnic_sysfs_read_crb(struct file *filp, struct kobject *kobj,
3661  struct bin_attribute *attr,
3662  char *buf, loff_t offset, size_t size)
3663 {
3664  struct device *dev = container_of(kobj, struct device, kobj);
3665  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3666  u32 data;
3667  u64 qmdata;
3668  int ret;
3669 
3670  ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3671  if (ret != 0)
3672  return ret;
3673 
3674  if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3675  qlcnic_pci_camqm_read_2M(adapter, offset, &qmdata);
3676  memcpy(buf, &qmdata, size);
3677  } else {
3678  data = QLCRD32(adapter, offset);
3679  memcpy(buf, &data, size);
3680  }
3681  return size;
3682 }
3683 
3684 static ssize_t
3685 qlcnic_sysfs_write_crb(struct file *filp, struct kobject *kobj,
3686  struct bin_attribute *attr,
3687  char *buf, loff_t offset, size_t size)
3688 {
3689  struct device *dev = container_of(kobj, struct device, kobj);
3690  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3691  u32 data;
3692  u64 qmdata;
3693  int ret;
3694 
3695  ret = qlcnic_sysfs_validate_crb(adapter, offset, size);
3696  if (ret != 0)
3697  return ret;
3698 
3699  if (ADDR_IN_RANGE(offset, QLCNIC_PCI_CAMQM, QLCNIC_PCI_CAMQM_END)) {
3700  memcpy(&qmdata, buf, size);
3701  qlcnic_pci_camqm_write_2M(adapter, offset, qmdata);
3702  } else {
3703  memcpy(&data, buf, size);
3704  QLCWR32(adapter, offset, data);
3705  }
3706  return size;
3707 }
3708 
3709 static int
3710 qlcnic_sysfs_validate_mem(struct qlcnic_adapter *adapter,
3711  loff_t offset, size_t size)
3712 {
3713  if (!(adapter->flags & QLCNIC_DIAG_ENABLED))
3714  return -EIO;
3715 
3716  if ((size != 8) || (offset & 0x7))
3717  return -EIO;
3718 
3719  return 0;
3720 }
3721 
3722 static ssize_t
3723 qlcnic_sysfs_read_mem(struct file *filp, struct kobject *kobj,
3724  struct bin_attribute *attr,
3725  char *buf, loff_t offset, size_t size)
3726 {
3727  struct device *dev = container_of(kobj, struct device, kobj);
3728  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3729  u64 data;
3730  int ret;
3731 
3732  ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3733  if (ret != 0)
3734  return ret;
3735 
3736  if (qlcnic_pci_mem_read_2M(adapter, offset, &data))
3737  return -EIO;
3738 
3739  memcpy(buf, &data, size);
3740 
3741  return size;
3742 }
3743 
3744 static ssize_t
3745 qlcnic_sysfs_write_mem(struct file *filp, struct kobject *kobj,
3746  struct bin_attribute *attr,
3747  char *buf, loff_t offset, size_t size)
3748 {
3749  struct device *dev = container_of(kobj, struct device, kobj);
3750  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3751  u64 data;
3752  int ret;
3753 
3754  ret = qlcnic_sysfs_validate_mem(adapter, offset, size);
3755  if (ret != 0)
3756  return ret;
3757 
3758  memcpy(&data, buf, size);
3759 
3760  if (qlcnic_pci_mem_write_2M(adapter, offset, data))
3761  return -EIO;
3762 
3763  return size;
3764 }
3765 
3766 static struct bin_attribute bin_attr_crb = {
3767  .attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
3768  .size = 0,
3769  .read = qlcnic_sysfs_read_crb,
3770  .write = qlcnic_sysfs_write_crb,
3771 };
3772 
3773 static struct bin_attribute bin_attr_mem = {
3774  .attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
3775  .size = 0,
3776  .read = qlcnic_sysfs_read_mem,
3777  .write = qlcnic_sysfs_write_mem,
3778 };
3779 
3780 static int
3781 validate_pm_config(struct qlcnic_adapter *adapter,
3782  struct qlcnic_pm_func_cfg *pm_cfg, int count)
3783 {
3784 
3785  u8 src_pci_func, s_esw_id, d_esw_id;
3786  u8 dest_pci_func;
3787  int i;
3788 
3789  for (i = 0; i < count; i++) {
3790  src_pci_func = pm_cfg[i].pci_func;
3791  dest_pci_func = pm_cfg[i].dest_npar;
3792  if (src_pci_func >= QLCNIC_MAX_PCI_FUNC
3793  || dest_pci_func >= QLCNIC_MAX_PCI_FUNC)
3794  return QL_STATUS_INVALID_PARAM;
3795 
3796  if (adapter->npars[src_pci_func].type != QLCNIC_TYPE_NIC)
3797  return QL_STATUS_INVALID_PARAM;
3798 
3799  if (adapter->npars[dest_pci_func].type != QLCNIC_TYPE_NIC)
3800  return QL_STATUS_INVALID_PARAM;
3801 
3802  s_esw_id = adapter->npars[src_pci_func].phy_port;
3803  d_esw_id = adapter->npars[dest_pci_func].phy_port;
3804 
3805  if (s_esw_id != d_esw_id)
3806  return QL_STATUS_INVALID_PARAM;
3807 
3808  }
3809  return 0;
3810 
3811 }
3812 
3813 static ssize_t
3814 qlcnic_sysfs_write_pm_config(struct file *filp, struct kobject *kobj,
3815  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3816 {
3817  struct device *dev = container_of(kobj, struct device, kobj);
3818  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3819  struct qlcnic_pm_func_cfg *pm_cfg;
3820  u32 id, action, pci_func;
3821  int count, rem, i, ret;
3822 
3823  count = size / sizeof(struct qlcnic_pm_func_cfg);
3824  rem = size % sizeof(struct qlcnic_pm_func_cfg);
3825  if (rem)
3826  return QL_STATUS_INVALID_PARAM;
3827 
3828  pm_cfg = (struct qlcnic_pm_func_cfg *) buf;
3829 
3830  ret = validate_pm_config(adapter, pm_cfg, count);
3831  if (ret)
3832  return ret;
3833  for (i = 0; i < count; i++) {
3834  pci_func = pm_cfg[i].pci_func;
3835  action = !!pm_cfg[i].action;
3836  id = adapter->npars[pci_func].phy_port;
3837  ret = qlcnic_config_port_mirroring(adapter, id,
3838  action, pci_func);
3839  if (ret)
3840  return ret;
3841  }
3842 
3843  for (i = 0; i < count; i++) {
3844  pci_func = pm_cfg[i].pci_func;
3845  id = adapter->npars[pci_func].phy_port;
3846  adapter->npars[pci_func].enable_pm = !!pm_cfg[i].action;
3847  adapter->npars[pci_func].dest_npar = id;
3848  }
3849  return size;
3850 }
3851 
3852 static ssize_t
3853 qlcnic_sysfs_read_pm_config(struct file *filp, struct kobject *kobj,
3854  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3855 {
3856  struct device *dev = container_of(kobj, struct device, kobj);
3857  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3858  struct qlcnic_pm_func_cfg pm_cfg[QLCNIC_MAX_PCI_FUNC];
3859  int i;
3860 
3861  if (size != sizeof(pm_cfg))
3862  return QL_STATUS_INVALID_PARAM;
3863 
3864  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
3865  if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
3866  continue;
3867  pm_cfg[i].action = adapter->npars[i].enable_pm;
3868  pm_cfg[i].dest_npar = 0;
3869  pm_cfg[i].pci_func = i;
3870  }
3871  memcpy(buf, &pm_cfg, size);
3872 
3873  return size;
3874 }
3875 
3876 static int
3877 validate_esw_config(struct qlcnic_adapter *adapter,
3878  struct qlcnic_esw_func_cfg *esw_cfg, int count)
3879 {
3880  u32 op_mode;
3881  u8 pci_func;
3882  int i;
3883 
3884  op_mode = readl(adapter->ahw->pci_base0 + QLCNIC_DRV_OP_MODE);
3885 
3886  for (i = 0; i < count; i++) {
3887  pci_func = esw_cfg[i].pci_func;
3888  if (pci_func >= QLCNIC_MAX_PCI_FUNC)
3889  return QL_STATUS_INVALID_PARAM;
3890 
3891  if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3892  if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
3893  return QL_STATUS_INVALID_PARAM;
3894 
3895  switch (esw_cfg[i].op_mode) {
3896  case QLCNIC_PORT_DEFAULTS:
3897  if (QLC_DEV_GET_DRV(op_mode, pci_func) !=
3898  QLCNIC_NON_PRIV_FUNC) {
3899  if (esw_cfg[i].mac_anti_spoof != 0)
3900  return QL_STATUS_INVALID_PARAM;
3901  if (esw_cfg[i].mac_override != 1)
3902  return QL_STATUS_INVALID_PARAM;
3903  if (esw_cfg[i].promisc_mode != 1)
3904  return QL_STATUS_INVALID_PARAM;
3905  }
3906  break;
3907  case QLCNIC_ADD_VLAN:
3908  if (!IS_VALID_VLAN(esw_cfg[i].vlan_id))
3909  return QL_STATUS_INVALID_PARAM;
3910  if (!esw_cfg[i].op_type)
3911  return QL_STATUS_INVALID_PARAM;
3912  break;
3913  case QLCNIC_DEL_VLAN:
3914  if (!esw_cfg[i].op_type)
3915  return QL_STATUS_INVALID_PARAM;
3916  break;
3917  default:
3918  return QL_STATUS_INVALID_PARAM;
3919  }
3920  }
3921  return 0;
3922 }
3923 
3924 static ssize_t
3925 qlcnic_sysfs_write_esw_config(struct file *file, struct kobject *kobj,
3926  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
3927 {
3928  struct device *dev = container_of(kobj, struct device, kobj);
3929  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
3930  struct qlcnic_esw_func_cfg *esw_cfg;
3931  struct qlcnic_npar_info *npar;
3932  int count, rem, i, ret;
3933  u8 pci_func, op_mode = 0;
3934 
3935  count = size / sizeof(struct qlcnic_esw_func_cfg);
3936  rem = size % sizeof(struct qlcnic_esw_func_cfg);
3937  if (rem)
3938  return QL_STATUS_INVALID_PARAM;
3939 
3940  esw_cfg = (struct qlcnic_esw_func_cfg *) buf;
3941  ret = validate_esw_config(adapter, esw_cfg, count);
3942  if (ret)
3943  return ret;
3944 
3945  for (i = 0; i < count; i++) {
3946  if (adapter->op_mode == QLCNIC_MGMT_FUNC)
3947  if (qlcnic_config_switch_port(adapter, &esw_cfg[i]))
3948  return QL_STATUS_INVALID_PARAM;
3949 
3950  if (adapter->ahw->pci_func != esw_cfg[i].pci_func)
3951  continue;
3952 
3953  op_mode = esw_cfg[i].op_mode;
3954  qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]);
3955  esw_cfg[i].op_mode = op_mode;
3956  esw_cfg[i].pci_func = adapter->ahw->pci_func;
3957 
3958  switch (esw_cfg[i].op_mode) {
3959  case QLCNIC_PORT_DEFAULTS:
3960  qlcnic_set_eswitch_port_features(adapter, &esw_cfg[i]);
3961  break;
3962  case QLCNIC_ADD_VLAN:
3963  qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3964  break;
3965  case QLCNIC_DEL_VLAN:
3966  esw_cfg[i].vlan_id = 0;
3967  qlcnic_set_vlan_config(adapter, &esw_cfg[i]);
3968  break;
3969  }
3970  }
3971 
3972  if (adapter->op_mode != QLCNIC_MGMT_FUNC)
3973  goto out;
3974 
3975  for (i = 0; i < count; i++) {
3976  pci_func = esw_cfg[i].pci_func;
3977  npar = &adapter->npars[pci_func];
3978  switch (esw_cfg[i].op_mode) {
3979  case QLCNIC_PORT_DEFAULTS:
3980  npar->promisc_mode = esw_cfg[i].promisc_mode;
3981  npar->mac_override = esw_cfg[i].mac_override;
3982  npar->offload_flags = esw_cfg[i].offload_flags;
3983  npar->mac_anti_spoof = esw_cfg[i].mac_anti_spoof;
3984  npar->discard_tagged = esw_cfg[i].discard_tagged;
3985  break;
3986  case QLCNIC_ADD_VLAN:
3987  npar->pvid = esw_cfg[i].vlan_id;
3988  break;
3989  case QLCNIC_DEL_VLAN:
3990  npar->pvid = 0;
3991  break;
3992  }
3993  }
3994 out:
3995  return size;
3996 }
3997 
3998 static ssize_t
3999 qlcnic_sysfs_read_esw_config(struct file *file, struct kobject *kobj,
4000  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4001 {
4002  struct device *dev = container_of(kobj, struct device, kobj);
4003  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4004  struct qlcnic_esw_func_cfg esw_cfg[QLCNIC_MAX_PCI_FUNC];
4005  u8 i;
4006 
4007  if (size != sizeof(esw_cfg))
4008  return QL_STATUS_INVALID_PARAM;
4009 
4010  for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
4011  if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
4012  continue;
4013  esw_cfg[i].pci_func = i;
4014  if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg[i]))
4015  return QL_STATUS_INVALID_PARAM;
4016  }
4017  memcpy(buf, &esw_cfg, size);
4018 
4019  return size;
4020 }
4021 
4022 static int
4023 validate_npar_config(struct qlcnic_adapter *adapter,
4024  struct qlcnic_npar_func_cfg *np_cfg, int count)
4025 {
4026  u8 pci_func, i;
4027 
4028  for (i = 0; i < count; i++) {
4029  pci_func = np_cfg[i].pci_func;
4030  if (pci_func >= QLCNIC_MAX_PCI_FUNC)
4031  return QL_STATUS_INVALID_PARAM;
4032 
4033  if (adapter->npars[pci_func].type != QLCNIC_TYPE_NIC)
4034  return QL_STATUS_INVALID_PARAM;
4035 
4036  if (!IS_VALID_BW(np_cfg[i].min_bw) ||
4037  !IS_VALID_BW(np_cfg[i].max_bw))
4038  return QL_STATUS_INVALID_PARAM;
4039  }
4040  return 0;
4041 }
4042 
4043 static ssize_t
4044 qlcnic_sysfs_write_npar_config(struct file *file, struct kobject *kobj,
4045  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4046 {
4047  struct device *dev = container_of(kobj, struct device, kobj);
4048  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4049  struct qlcnic_info nic_info;
4050  struct qlcnic_npar_func_cfg *np_cfg;
4051  int i, count, rem, ret;
4052  u8 pci_func;
4053 
4054  count = size / sizeof(struct qlcnic_npar_func_cfg);
4055  rem = size % sizeof(struct qlcnic_npar_func_cfg);
4056  if (rem)
4057  return QL_STATUS_INVALID_PARAM;
4058 
4059  np_cfg = (struct qlcnic_npar_func_cfg *) buf;
4060  ret = validate_npar_config(adapter, np_cfg, count);
4061  if (ret)
4062  return ret;
4063 
4064  for (i = 0; i < count ; i++) {
4065  pci_func = np_cfg[i].pci_func;
4066  ret = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
4067  if (ret)
4068  return ret;
4069  nic_info.pci_func = pci_func;
4070  nic_info.min_tx_bw = np_cfg[i].min_bw;
4071  nic_info.max_tx_bw = np_cfg[i].max_bw;
4072  ret = qlcnic_set_nic_info(adapter, &nic_info);
4073  if (ret)
4074  return ret;
4075  adapter->npars[i].min_bw = nic_info.min_tx_bw;
4076  adapter->npars[i].max_bw = nic_info.max_tx_bw;
4077  }
4078 
4079  return size;
4080 
4081 }
4082 static ssize_t
4083 qlcnic_sysfs_read_npar_config(struct file *file, struct kobject *kobj,
4084  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4085 {
4086  struct device *dev = container_of(kobj, struct device, kobj);
4087  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4088  struct qlcnic_info nic_info;
4089  struct qlcnic_npar_func_cfg np_cfg[QLCNIC_MAX_PCI_FUNC];
4090  int i, ret;
4091 
4092  if (size != sizeof(np_cfg))
4093  return QL_STATUS_INVALID_PARAM;
4094 
4095  for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
4096  if (adapter->npars[i].type != QLCNIC_TYPE_NIC)
4097  continue;
4098  ret = qlcnic_get_nic_info(adapter, &nic_info, i);
4099  if (ret)
4100  return ret;
4101 
4102  np_cfg[i].pci_func = i;
4103  np_cfg[i].op_mode = (u8)nic_info.op_mode;
4104  np_cfg[i].port_num = nic_info.phys_port;
4105  np_cfg[i].fw_capab = nic_info.capabilities;
4106  np_cfg[i].min_bw = nic_info.min_tx_bw ;
4107  np_cfg[i].max_bw = nic_info.max_tx_bw;
4108  np_cfg[i].max_tx_queues = nic_info.max_tx_ques;
4109  np_cfg[i].max_rx_queues = nic_info.max_rx_ques;
4110  }
4111  memcpy(buf, &np_cfg, size);
4112  return size;
4113 }
4114 
4115 static ssize_t
4116 qlcnic_sysfs_get_port_stats(struct file *file, struct kobject *kobj,
4117  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4118 {
4119  struct device *dev = container_of(kobj, struct device, kobj);
4120  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4121  struct qlcnic_esw_statistics port_stats;
4122  int ret;
4123 
4124  if (size != sizeof(struct qlcnic_esw_statistics))
4125  return QL_STATUS_INVALID_PARAM;
4126 
4127  if (offset >= QLCNIC_MAX_PCI_FUNC)
4128  return QL_STATUS_INVALID_PARAM;
4129 
4130  memset(&port_stats, 0, size);
4131  ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
4132  &port_stats.rx);
4133  if (ret)
4134  return ret;
4135 
4136  ret = qlcnic_get_port_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
4137  &port_stats.tx);
4138  if (ret)
4139  return ret;
4140 
4141  memcpy(buf, &port_stats, size);
4142  return size;
4143 }
4144 
4145 static ssize_t
4146 qlcnic_sysfs_get_esw_stats(struct file *file, struct kobject *kobj,
4147  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4148 {
4149  struct device *dev = container_of(kobj, struct device, kobj);
4150  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4151  struct qlcnic_esw_statistics esw_stats;
4152  int ret;
4153 
4154  if (size != sizeof(struct qlcnic_esw_statistics))
4155  return QL_STATUS_INVALID_PARAM;
4156 
4157  if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
4158  return QL_STATUS_INVALID_PARAM;
4159 
4160  memset(&esw_stats, 0, size);
4161  ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_RX_COUNTER,
4162  &esw_stats.rx);
4163  if (ret)
4164  return ret;
4165 
4166  ret = qlcnic_get_eswitch_stats(adapter, offset, QLCNIC_QUERY_TX_COUNTER,
4167  &esw_stats.tx);
4168  if (ret)
4169  return ret;
4170 
4171  memcpy(buf, &esw_stats, size);
4172  return size;
4173 }
4174 
4175 static ssize_t
4176 qlcnic_sysfs_clear_esw_stats(struct file *file, struct kobject *kobj,
4177  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4178 {
4179  struct device *dev = container_of(kobj, struct device, kobj);
4180  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4181  int ret;
4182 
4183  if (offset >= QLCNIC_NIU_MAX_XG_PORTS)
4184  return QL_STATUS_INVALID_PARAM;
4185 
4186  ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
4187  QLCNIC_QUERY_RX_COUNTER);
4188  if (ret)
4189  return ret;
4190 
4191  ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_ESWITCH, offset,
4192  QLCNIC_QUERY_TX_COUNTER);
4193  if (ret)
4194  return ret;
4195 
4196  return size;
4197 }
4198 
4199 static ssize_t
4200 qlcnic_sysfs_clear_port_stats(struct file *file, struct kobject *kobj,
4201  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4202 {
4203 
4204  struct device *dev = container_of(kobj, struct device, kobj);
4205  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4206  int ret;
4207 
4208  if (offset >= QLCNIC_MAX_PCI_FUNC)
4209  return QL_STATUS_INVALID_PARAM;
4210 
4211  ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
4212  QLCNIC_QUERY_RX_COUNTER);
4213  if (ret)
4214  return ret;
4215 
4216  ret = qlcnic_clear_esw_stats(adapter, QLCNIC_STATS_PORT, offset,
4217  QLCNIC_QUERY_TX_COUNTER);
4218  if (ret)
4219  return ret;
4220 
4221  return size;
4222 }
4223 
4224 static ssize_t
4225 qlcnic_sysfs_read_pci_config(struct file *file, struct kobject *kobj,
4226  struct bin_attribute *attr, char *buf, loff_t offset, size_t size)
4227 {
4228  struct device *dev = container_of(kobj, struct device, kobj);
4229  struct qlcnic_adapter *adapter = dev_get_drvdata(dev);
4230  struct qlcnic_pci_func_cfg pci_cfg[QLCNIC_MAX_PCI_FUNC];
4231  struct qlcnic_pci_info *pci_info;
4232  int i, ret;
4233 
4234  if (size != sizeof(pci_cfg))
4235  return QL_STATUS_INVALID_PARAM;
4236 
4237  pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
4238  if (!pci_info)
4239  return -ENOMEM;
4240 
4241  ret = qlcnic_get_pci_info(adapter, pci_info);
4242  if (ret) {
4243  kfree(pci_info);
4244  return ret;
4245  }
4246 
4247  for (i = 0; i < QLCNIC_MAX_PCI_FUNC ; i++) {
4248  pci_cfg[i].pci_func = pci_info[i].id;
4249  pci_cfg[i].func_type = pci_info[i].type;
4250  pci_cfg[i].port_num = pci_info[i].default_port;
4251  pci_cfg[i].min_bw = pci_info[i].tx_min_bw;
4252  pci_cfg[i].max_bw = pci_info[i].tx_max_bw;
4253  memcpy(&pci_cfg[i].def_mac_addr, &pci_info[i].mac, ETH_ALEN);
4254  }
4255  memcpy(buf, &pci_cfg, size);
4256  kfree(pci_info);
4257  return size;
4258 }
4259 static struct bin_attribute bin_attr_npar_config = {
4260  .attr = {.name = "npar_config", .mode = (S_IRUGO | S_IWUSR)},
4261  .size = 0,
4262  .read = qlcnic_sysfs_read_npar_config,
4263  .write = qlcnic_sysfs_write_npar_config,
4264 };
4265 
4266 static struct bin_attribute bin_attr_pci_config = {
4267  .attr = {.name = "pci_config", .mode = (S_IRUGO | S_IWUSR)},
4268  .size = 0,
4269  .read = qlcnic_sysfs_read_pci_config,
4270  .write = NULL,
4271 };
4272 
4273 static struct bin_attribute bin_attr_port_stats = {
4274  .attr = {.name = "port_stats", .mode = (S_IRUGO | S_IWUSR)},
4275  .size = 0,
4276  .read = qlcnic_sysfs_get_port_stats,
4277  .write = qlcnic_sysfs_clear_port_stats,
4278 };
4279 
4280 static struct bin_attribute bin_attr_esw_stats = {
4281  .attr = {.name = "esw_stats", .mode = (S_IRUGO | S_IWUSR)},
4282  .size = 0,
4283  .read = qlcnic_sysfs_get_esw_stats,
4284  .write = qlcnic_sysfs_clear_esw_stats,
4285 };
4286 
4287 static struct bin_attribute bin_attr_esw_config = {
4288  .attr = {.name = "esw_config", .mode = (S_IRUGO | S_IWUSR)},
4289  .size = 0,
4290  .read = qlcnic_sysfs_read_esw_config,
4291  .write = qlcnic_sysfs_write_esw_config,
4292 };
4293 
4294 static struct bin_attribute bin_attr_pm_config = {
4295  .attr = {.name = "pm_config", .mode = (S_IRUGO | S_IWUSR)},
4296  .size = 0,
4297  .read = qlcnic_sysfs_read_pm_config,
4298  .write = qlcnic_sysfs_write_pm_config,
4299 };
4300 
4301 static void
4302 qlcnic_create_sysfs_entries(struct qlcnic_adapter *adapter)
4303 {
4304  struct device *dev = &adapter->pdev->dev;
4305 
4306  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
4307  if (device_create_file(dev, &dev_attr_bridged_mode))
4308  dev_warn(dev,
4309  "failed to create bridged_mode sysfs entry\n");
4310 }
4311 
4312 static void
4313 qlcnic_remove_sysfs_entries(struct qlcnic_adapter *adapter)
4314 {
4315  struct device *dev = &adapter->pdev->dev;
4316 
4317  if (adapter->capabilities & QLCNIC_FW_CAPABILITY_BDG)
4318  device_remove_file(dev, &dev_attr_bridged_mode);
4319 }
4320 
4321 static void
4322 qlcnic_create_diag_entries(struct qlcnic_adapter *adapter)
4323 {
4324  struct device *dev = &adapter->pdev->dev;
4325  u32 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
4326 
4327  if (device_create_bin_file(dev, &bin_attr_port_stats))
4328  dev_info(dev, "failed to create port stats sysfs entry");
4329 
4330  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
4331  return;
4332  if (device_create_file(dev, &dev_attr_diag_mode))
4333  dev_info(dev, "failed to create diag_mode sysfs entry\n");
4334  if (device_create_bin_file(dev, &bin_attr_crb))
4335  dev_info(dev, "failed to create crb sysfs entry\n");
4336  if (device_create_bin_file(dev, &bin_attr_mem))
4337  dev_info(dev, "failed to create mem sysfs entry\n");
4338 
4339  if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
4340  return;
4341 
4342  if (device_create_bin_file(dev, &bin_attr_pci_config))
4343  dev_info(dev, "failed to create pci config sysfs entry");
4344  if (device_create_file(dev, &dev_attr_beacon))
4345  dev_info(dev, "failed to create beacon sysfs entry");
4346 
4347  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
4348  return;
4349  if (device_create_bin_file(dev, &bin_attr_esw_config))
4350  dev_info(dev, "failed to create esw config sysfs entry");
4351  if (adapter->op_mode != QLCNIC_MGMT_FUNC)
4352  return;
4353  if (device_create_bin_file(dev, &bin_attr_npar_config))
4354  dev_info(dev, "failed to create npar config sysfs entry");
4355  if (device_create_bin_file(dev, &bin_attr_pm_config))
4356  dev_info(dev, "failed to create pm config sysfs entry");
4357  if (device_create_bin_file(dev, &bin_attr_esw_stats))
4358  dev_info(dev, "failed to create eswitch stats sysfs entry");
4359 }
4360 
4361 static void
4362 qlcnic_remove_diag_entries(struct qlcnic_adapter *adapter)
4363 {
4364  struct device *dev = &adapter->pdev->dev;
4365  u32 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
4366 
4367  device_remove_bin_file(dev, &bin_attr_port_stats);
4368 
4369  if (adapter->op_mode == QLCNIC_NON_PRIV_FUNC)
4370  return;
4371  device_remove_file(dev, &dev_attr_diag_mode);
4372  device_remove_bin_file(dev, &bin_attr_crb);
4373  device_remove_bin_file(dev, &bin_attr_mem);
4374  if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
4375  return;
4376  device_remove_bin_file(dev, &bin_attr_pci_config);
4377  device_remove_file(dev, &dev_attr_beacon);
4378  if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
4379  return;
4380  device_remove_bin_file(dev, &bin_attr_esw_config);
4381  if (adapter->op_mode != QLCNIC_MGMT_FUNC)
4382  return;
4383  device_remove_bin_file(dev, &bin_attr_npar_config);
4384  device_remove_bin_file(dev, &bin_attr_pm_config);
4385  device_remove_bin_file(dev, &bin_attr_esw_stats);
4386 }
4387 
4388 #ifdef CONFIG_INET
4389 
4390 #define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
4391 
4392 static void
4393 qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4394  struct net_device *dev, unsigned long event)
4395 {
4396  struct in_device *indev;
4397 
4398  indev = in_dev_get(dev);
4399  if (!indev)
4400  return;
4401 
4402  for_ifa(indev) {
4403  switch (event) {
4404  case NETDEV_UP:
4405  qlcnic_config_ipaddr(adapter,
4406  ifa->ifa_address, QLCNIC_IP_UP);
4407  break;
4408  case NETDEV_DOWN:
4409  qlcnic_config_ipaddr(adapter,
4410  ifa->ifa_address, QLCNIC_IP_DOWN);
4411  break;
4412  default:
4413  break;
4414  }
4415  } endfor_ifa(indev);
4416 
4417  in_dev_put(indev);
4418 }
4419 
4420 static void
4421 qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
4422 {
4423  struct qlcnic_adapter *adapter = netdev_priv(netdev);
4424  struct net_device *dev;
4425  u16 vid;
4426 
4427  qlcnic_config_indev_addr(adapter, netdev, event);
4428 
4429  for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
4430  dev = __vlan_find_dev_deep(netdev, vid);
4431  if (!dev)
4432  continue;
4433  qlcnic_config_indev_addr(adapter, dev, event);
4434  }
4435 }
4436 
4437 static int qlcnic_netdev_event(struct notifier_block *this,
4438  unsigned long event, void *ptr)
4439 {
4440  struct qlcnic_adapter *adapter;
4441  struct net_device *dev = (struct net_device *)ptr;
4442 
4443 recheck:
4444  if (dev == NULL)
4445  goto done;
4446 
4447  if (dev->priv_flags & IFF_802_1Q_VLAN) {
4448  dev = vlan_dev_real_dev(dev);
4449  goto recheck;
4450  }
4451 
4452  if (!is_qlcnic_netdev(dev))
4453  goto done;
4454 
4455  adapter = netdev_priv(dev);
4456 
4457  if (!adapter)
4458  goto done;
4459 
4460  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4461  goto done;
4462 
4463  qlcnic_config_indev_addr(adapter, dev, event);
4464 done:
4465  return NOTIFY_DONE;
4466 }
4467 
4468 static int
4469 qlcnic_inetaddr_event(struct notifier_block *this,
4470  unsigned long event, void *ptr)
4471 {
4472  struct qlcnic_adapter *adapter;
4473  struct net_device *dev;
4474 
4475  struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
4476 
4477  dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
4478 
4479 recheck:
4480  if (dev == NULL)
4481  goto done;
4482 
4483  if (dev->priv_flags & IFF_802_1Q_VLAN) {
4484  dev = vlan_dev_real_dev(dev);
4485  goto recheck;
4486  }
4487 
4488  if (!is_qlcnic_netdev(dev))
4489  goto done;
4490 
4491  adapter = netdev_priv(dev);
4492 
4493  if (!adapter)
4494  goto done;
4495 
4496  if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4497  goto done;
4498 
4499  switch (event) {
4500  case NETDEV_UP:
4501  qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
4502  break;
4503  case NETDEV_DOWN:
4504  qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
4505  break;
4506  default:
4507  break;
4508  }
4509 
4510 done:
4511  return NOTIFY_DONE;
4512 }
4513 
4514 static struct notifier_block qlcnic_netdev_cb = {
4515  .notifier_call = qlcnic_netdev_event,
4516 };
4517 
4518 static struct notifier_block qlcnic_inetaddr_cb = {
4519  .notifier_call = qlcnic_inetaddr_event,
4520 };
4521 #else
4522 static void
4523 qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
4524 { }
4525 #endif
4526 static const struct pci_error_handlers qlcnic_err_handler = {
4527  .error_detected = qlcnic_io_error_detected,
4528  .slot_reset = qlcnic_io_slot_reset,
4529  .resume = qlcnic_io_resume,
4530 };
4531 
4532 static struct pci_driver qlcnic_driver = {
4533  .name = qlcnic_driver_name,
4534  .id_table = qlcnic_pci_tbl,
4535  .probe = qlcnic_probe,
4536  .remove = __devexit_p(qlcnic_remove),
4537 #ifdef CONFIG_PM
4538  .suspend = qlcnic_suspend,
4539  .resume = qlcnic_resume,
4540 #endif
4541  .shutdown = qlcnic_shutdown,
4542  .err_handler = &qlcnic_err_handler
4543 
4544 };
4545 
4546 static int __init qlcnic_init_module(void)
4547 {
4548  int ret;
4549 
4550  printk(KERN_INFO "%s\n", qlcnic_driver_string);
4551 
4552  qlcnic_wq = create_singlethread_workqueue("qlcnic");
4553  if (qlcnic_wq == NULL) {
4554  printk(KERN_ERR "qlcnic: cannot create workqueue\n");
4555  return -ENOMEM;
4556  }
4557 
4558 #ifdef CONFIG_INET
4559  register_netdevice_notifier(&qlcnic_netdev_cb);
4560  register_inetaddr_notifier(&qlcnic_inetaddr_cb);
4561 #endif
4562 
4563  ret = pci_register_driver(&qlcnic_driver);
4564  if (ret) {
4565 #ifdef CONFIG_INET
4566  unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4567  unregister_netdevice_notifier(&qlcnic_netdev_cb);
4568 #endif
4569  destroy_workqueue(qlcnic_wq);
4570  }
4571 
4572  return ret;
4573 }
4574 
4575 module_init(qlcnic_init_module);
4576 
4577 static void __exit qlcnic_exit_module(void)
4578 {
4579 
4580  pci_unregister_driver(&qlcnic_driver);
4581 
4582 #ifdef CONFIG_INET
4583  unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4584  unregister_netdevice_notifier(&qlcnic_netdev_cb);
4585 #endif
4586  destroy_workqueue(qlcnic_wq);
4587 }
4588 
4589 module_exit(qlcnic_exit_module);
Generated on Thu Jan 10 2013 14:04:27 for Linux Kernel by   doxygen 1.8.2