projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
qlcnic: 83xx sysfs routines
[deliverable/linux.git] / drivers / net / ethernet / qlogic / qlcnic / qlcnic_main.c
CommitLineData
af19b491 1/*
40839129
SV		 2 * QLogic qlcnic NIC Driver
3 * Copyright (c) 2009-2010 QLogic Corporation
af19b491 4 *
13159183
SC		 5 * PCI searching functions pci_get_domain_bus_and_slot & pci_channel_offline
6 * Copyright (C) 1993 -- 1997 Drew Eckhardt, Frederic Potter,
7 * David Mosberger-Tang
8 * Copyright (C) 1997 -- 2000 Martin Mares <mj@ucw.cz>
9 * Copyright (C) 2003 -- 2004 Greg Kroah-Hartman <greg@kroah.com>.
10 *
40839129 11 * See LICENSE.qlcnic for copyright and licensing details.
af19b491
AKS		 12 */
13
14#include <linux/vmalloc.h>
15#include <linux/interrupt.h>
16
17#include "qlcnic.h"
a15ebd37 18#include "qlcnic_hw.h"
af19b491 19
7e56cac4 20#include <linux/swab.h>
af19b491 21#include <linux/dma-mapping.h>
13159183 22#include <linux/if_vlan.h>
af19b491
AKS		 23#include <net/ip.h>
24#include <linux/ipv6.h>
25#include <linux/inetdevice.h>
451724c8 26#include <linux/aer.h>
f94bc1e7 27#include <linux/log2.h>
af19b491 28
7f9a0c34 29MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
af19b491
AKS		 30MODULE_LICENSE("GPL");
31MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
32MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
33
34char qlcnic_driver_name[] = "qlcnic";
7f9a0c34
SV		 35static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
36 "Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
af19b491 37
b5e5492c 38static int qlcnic_mac_learn;
b11a25aa 39module_param(qlcnic_mac_learn, int, 0444);
b5e5492c
AKS		 40MODULE_PARM_DESC(qlcnic_mac_learn, "Mac Filter (0=disabled, 1=enabled)");
41
099f7aa7 42static int qlcnic_use_msi = 1;
af19b491 43MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled");
099f7aa7 44module_param_named(use_msi, qlcnic_use_msi, int, 0444);
af19b491 45
099f7aa7 46static int qlcnic_use_msi_x = 1;
af19b491 47MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled");
099f7aa7 48module_param_named(use_msi_x, qlcnic_use_msi_x, int, 0444);
af19b491 49
099f7aa7 50static int qlcnic_auto_fw_reset = 1;
af19b491 51MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled");
099f7aa7 52module_param_named(auto_fw_reset, qlcnic_auto_fw_reset, int, 0644);
af19b491 53
099f7aa7 54static int qlcnic_load_fw_file;
4d5bdb38 55MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file");
099f7aa7 56module_param_named(load_fw_file, qlcnic_load_fw_file, int, 0444);
4d5bdb38 57
2e9d722d 58static int qlcnic_config_npars;
b11a25aa 59module_param(qlcnic_config_npars, int, 0444);
2e9d722d
AC		 60MODULE_PARM_DESC(qlcnic_config_npars, "Configure NPARs (0=disabled, 1=enabled");
61
1dd06ae8 62static int qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
6bb58bb0 63static void qlcnic_remove(struct pci_dev *pdev);
af19b491
AKS		 64static int qlcnic_open(struct net_device *netdev);
65static int qlcnic_close(struct net_device *netdev);
af19b491 66static void qlcnic_tx_timeout(struct net_device *netdev);
af19b491
AKS		 67static void qlcnic_attach_work(struct work_struct *work);
68static void qlcnic_fwinit_work(struct work_struct *work);
69static void qlcnic_fw_poll_work(struct work_struct *work);
af19b491
AKS		 70#ifdef CONFIG_NET_POLL_CONTROLLER
71static void qlcnic_poll_controller(struct net_device *netdev);
72#endif
73
6df900e9 74static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
21854f02 75static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
af19b491
AKS		 76static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
77
7eb9855d 78static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
af19b491
AKS		 79static irqreturn_t qlcnic_intr(int irq, void *data);
80static irqreturn_t qlcnic_msi_intr(int irq, void *data);
81static irqreturn_t qlcnic_msix_intr(int irq, void *data);
13159183 82static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
af19b491
AKS		 83
84static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
9f26f547
AC		 85static int qlcnic_start_firmware(struct qlcnic_adapter *);
86
b5e5492c 87static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
9f26f547 88static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
9f26f547 89static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
0325d69b
RB		 90static void qlcnic_set_netdev_features(struct qlcnic_adapter *,
91 struct qlcnic_esw_func_cfg *);
8e586137
JP		 92static int qlcnic_vlan_rx_add(struct net_device *, u16);
93static int qlcnic_vlan_rx_del(struct net_device *, u16);
b9796a14 94
bff57d8e
SC		 95#define QLCNIC_IS_TSO_CAPABLE(adapter) \
96 ((adapter)->ahw->capabilities & QLCNIC_FW_CAPABILITY_TSO)
97
13159183
SC		 98static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
99{
100 struct qlcnic_hardware_context *ahw = adapter->ahw;
101
102 if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
103 return ahw->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX;
104 else
105 return 1;
106}
107
af19b491
AKS		 108/* PCI Device ID Table */
109#define ENTRY(device) \
110 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
111 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
112
6a902881 113static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
af19b491 114 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
13159183 115 ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
af19b491
AKS		 116 {0,}
117};
118
119MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
120
121
5ad6ff9d 122inline void qlcnic_update_cmd_producer(struct qlcnic_host_tx_ring *tx_ring)
af19b491
AKS		 123{
124 writel(tx_ring->producer, tx_ring->crb_cmd_producer);
af19b491
AKS		 125}
126
127static const u32 msi_tgt_status[8] = {
128 ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
129 ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
130 ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
131 ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
132};
133
7e2cf4fe
SC		 134static const u32 qlcnic_reg_tbl[] = {
135 0x1B20A8, /* PEG_HALT_STAT1 */
136 0x1B20AC, /* PEG_HALT_STAT2 */
137 0x1B20B0, /* FW_HEARTBEAT */
138 0x1B2100, /* LOCK ID */
139 0x1B2128, /* FW_CAPABILITIES */
140 0x1B2138, /* drv active */
141 0x1B2140, /* dev state */
142 0x1B2144, /* drv state */
143 0x1B2148, /* drv scratch */
144 0x1B214C, /* dev partition info */
145 0x1B2174, /* drv idc ver */
146 0x1B2150, /* fw version major */
147 0x1B2154, /* fw version minor */
148 0x1B2158, /* fw version sub */
149 0x1B219C, /* npar state */
150 0x1B21FC, /* FW_IMG_VALID */
151 0x1B2250, /* CMD_PEG_STATE */
152 0x1B233C, /* RCV_PEG_STATE */
153 0x1B23B4, /* ASIC TEMP */
154 0x1B216C, /* FW api */
155 0x1B2170, /* drv op mode */
156 0x13C010, /* flash lock */
157 0x13C014, /* flash unlock */
158};
159
22999798
SC		 160static const struct qlcnic_board_info qlcnic_boards[] = {
161 {0x1077, 0x8020, 0x1077, 0x203,
162 "8200 Series Single Port 10GbE Converged Network Adapter"
163 "(TCP/IP Networking)"},
164 {0x1077, 0x8020, 0x1077, 0x207,
165 "8200 Series Dual Port 10GbE Converged Network Adapter"
166 "(TCP/IP Networking)"},
167 {0x1077, 0x8020, 0x1077, 0x20b,
168 "3200 Series Dual Port 10Gb Intelligent Ethernet Adapter"},
169 {0x1077, 0x8020, 0x1077, 0x20c,
170 "3200 Series Quad Port 1Gb Intelligent Ethernet Adapter"},
171 {0x1077, 0x8020, 0x1077, 0x20f,
172 "3200 Series Single Port 10Gb Intelligent Ethernet Adapter"},
173 {0x1077, 0x8020, 0x103c, 0x3733,
174 "NC523SFP 10Gb 2-port Server Adapter"},
175 {0x1077, 0x8020, 0x103c, 0x3346,
176 "CN1000Q Dual Port Converged Network Adapter"},
177 {0x1077, 0x8020, 0x1077, 0x210,
178 "QME8242-k 10GbE Dual Port Mezzanine Card"},
179 {0x1077, 0x8020, 0x0, 0x0, "cLOM8214 1/10GbE Controller"},
180};
181
182#define NUM_SUPPORTED_BOARDS ARRAY_SIZE(qlcnic_boards)
319ecf12 183#define QLC_MAX_SDS_RINGS 8
22999798 184
af19b491
AKS		 185static const
186struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
187
c70001a9 188int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
af19b491
AKS		 189{
190 int size = sizeof(struct qlcnic_host_sds_ring) * count;
191
192 recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
193
807540ba 194 return recv_ctx->sds_rings == NULL;
af19b491
AKS		 195}
196
c70001a9 197void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
af19b491
AKS		 198{
199 if (recv_ctx->sds_rings != NULL)
200 kfree(recv_ctx->sds_rings);
201
202 recv_ctx->sds_rings = NULL;
203}
204
af19b491
AKS		 205static int
206qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
207{
2e9d722d 208 u8 mac_addr[ETH_ALEN];
af19b491
AKS		 209 struct net_device *netdev = adapter->netdev;
210 struct pci_dev *pdev = adapter->pdev;
211
da48e6c3 212 if (qlcnic_get_mac_address(adapter, mac_addr) != 0)
af19b491
AKS		 213 return -EIO;
214
2e9d722d 215 memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
af19b491
AKS		 216 memcpy(netdev->perm_addr, netdev->dev_addr, netdev->addr_len);
217 memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
218
219 /* set station address */
220
221 if (!is_valid_ether_addr(netdev->perm_addr))
222 dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
223 netdev->dev_addr);
224
225 return 0;
226}
227
228static int qlcnic_set_mac(struct net_device *netdev, void *p)
229{
230 struct qlcnic_adapter *adapter = netdev_priv(netdev);
231 struct sockaddr *addr = p;
232
7373373d
RB		 233 if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
234 return -EOPNOTSUPP;
235
af19b491 236 if (!is_valid_ether_addr(addr->sa_data))
13159183 237 return -EINVAL;
af19b491 238
8a15ad1f 239 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
af19b491
AKS		 240 netif_device_detach(netdev);
241 qlcnic_napi_disable(adapter);
242 }
243
244 memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
245 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
246 qlcnic_set_multi(adapter->netdev);
247
8a15ad1f 248 if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
af19b491
AKS		 249 netif_device_attach(netdev);
250 qlcnic_napi_enable(adapter);
251 }
252 return 0;
253}
254
7e2cf4fe
SC		 255static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
256{
257 while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
258 usleep_range(10000, 11000);
259
260 cancel_delayed_work_sync(&adapter->fw_work);
261}
262
af19b491
AKS		 263static const struct net_device_ops qlcnic_netdev_ops = {
264 .ndo_open = qlcnic_open,
265 .ndo_stop = qlcnic_close,
266 .ndo_start_xmit = qlcnic_xmit_frame,
267 .ndo_get_stats = qlcnic_get_stats,
268 .ndo_validate_addr = eth_validate_addr,
afc4b13d 269 .ndo_set_rx_mode = qlcnic_set_multi,
af19b491
AKS		 270 .ndo_set_mac_address = qlcnic_set_mac,
271 .ndo_change_mtu = qlcnic_change_mtu,
135d84a9
MM		 272 .ndo_fix_features = qlcnic_fix_features,
273 .ndo_set_features = qlcnic_set_features,
af19b491 274 .ndo_tx_timeout = qlcnic_tx_timeout,
b9796a14
AC		 275 .ndo_vlan_rx_add_vid = qlcnic_vlan_rx_add,
276 .ndo_vlan_rx_kill_vid = qlcnic_vlan_rx_del,
af19b491
AKS		 277#ifdef CONFIG_NET_POLL_CONTROLLER
278 .ndo_poll_controller = qlcnic_poll_controller,
279#endif
280};
281
b43e5ee7
SC		 282static const struct net_device_ops qlcnic_netdev_failed_ops = {
283 .ndo_open = qlcnic_open,
284};
285
2e9d722d 286static struct qlcnic_nic_template qlcnic_ops = {
7e2cf4fe
SC		 287 .config_bridged_mode = qlcnic_config_bridged_mode,
288 .config_led = qlcnic_82xx_config_led,
289 .start_firmware = qlcnic_82xx_start_firmware,
290 .request_reset = qlcnic_82xx_dev_request_reset,
291 .cancel_idc_work = qlcnic_82xx_cancel_idc_work,
292 .napi_add = qlcnic_82xx_napi_add,
4be41e92 293 .napi_del = qlcnic_82xx_napi_del,
7e2cf4fe
SC		 294 .config_ipaddr = qlcnic_82xx_config_ipaddr,
295 .clear_legacy_intr = qlcnic_82xx_clear_legacy_intr,
296};
297
298struct qlcnic_nic_template qlcnic_vf_ops = {
299 .config_bridged_mode = qlcnicvf_config_bridged_mode,
300 .config_led = qlcnicvf_config_led,
301 .start_firmware = qlcnicvf_start_firmware
9f26f547
AC		 302};
303
7e2cf4fe
SC		 304static struct qlcnic_hardware_ops qlcnic_hw_ops = {
305 .read_crb = qlcnic_82xx_read_crb,
306 .write_crb = qlcnic_82xx_write_crb,
307 .read_reg = qlcnic_82xx_hw_read_wx_2M,
308 .write_reg = qlcnic_82xx_hw_write_wx_2M,
309 .get_mac_address = qlcnic_82xx_get_mac_address,
310 .setup_intr = qlcnic_82xx_setup_intr,
311 .alloc_mbx_args = qlcnic_82xx_alloc_mbx_args,
312 .mbx_cmd = qlcnic_82xx_issue_cmd,
313 .get_func_no = qlcnic_82xx_get_func_no,
314 .api_lock = qlcnic_82xx_api_lock,
315 .api_unlock = qlcnic_82xx_api_unlock,
316 .add_sysfs = qlcnic_82xx_add_sysfs,
317 .remove_sysfs = qlcnic_82xx_remove_sysfs,
318 .process_lb_rcv_ring_diag = qlcnic_82xx_process_rcv_ring_diag,
319 .create_rx_ctx = qlcnic_82xx_fw_cmd_create_rx_ctx,
320 .create_tx_ctx = qlcnic_82xx_fw_cmd_create_tx_ctx,
321 .setup_link_event = qlcnic_82xx_linkevent_request,
322 .get_nic_info = qlcnic_82xx_get_nic_info,
323 .get_pci_info = qlcnic_82xx_get_pci_info,
324 .set_nic_info = qlcnic_82xx_set_nic_info,
325 .change_macvlan = qlcnic_82xx_sre_macaddr_change,
326 .napi_enable = qlcnic_82xx_napi_enable,
327 .napi_disable = qlcnic_82xx_napi_disable,
328 .config_intr_coal = qlcnic_82xx_config_intr_coalesce,
329 .config_rss = qlcnic_82xx_config_rss,
330 .config_hw_lro = qlcnic_82xx_config_hw_lro,
331 .config_loopback = qlcnic_82xx_set_lb_mode,
332 .clear_loopback = qlcnic_82xx_clear_lb_mode,
333 .config_promisc_mode = qlcnic_82xx_nic_set_promisc,
334 .change_l2_filter = qlcnic_82xx_change_filter,
335 .get_board_info = qlcnic_82xx_get_board_info,
2e9d722d
AC		 336};
337
7f966452 338int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
af19b491 339{
af19b491 340 struct pci_dev *pdev = adapter->pdev;
13159183
SC		 341 int err = -1, i;
342 int max_tx_rings;
343
344 if (!adapter->msix_entries) {
345 adapter->msix_entries = kcalloc(num_msix,
346 sizeof(struct msix_entry),
347 GFP_KERNEL);
348 if (!adapter->msix_entries) {
349 dev_err(&pdev->dev, "failed allocating msix_entries\n");
350 return -ENOMEM;
351 }
352 }
af19b491
AKS		 353
354 adapter->max_sds_rings = 1;
af19b491 355 adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
af19b491 356
79788450 357 if (adapter->ahw->msix_supported) {
f94bc1e7 358 enable_msix:
13159183
SC		 359 for (i = 0; i < num_msix; i++)
360 adapter->msix_entries[i].entry = i;
af19b491
AKS		 361 err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
362 if (err == 0) {
363 adapter->flags |= QLCNIC_MSIX_ENABLED;
13159183
SC		 364 if (qlcnic_83xx_check(adapter)) {
365 adapter->ahw->num_msix = num_msix;
366 /* subtract mail box and tx ring vectors */
367 max_tx_rings = adapter->max_drv_tx_rings;
368 adapter->max_sds_rings = num_msix -
369 max_tx_rings - 1;
370 } else {
371 adapter->max_sds_rings = num_msix;
372 }
af19b491 373 dev_info(&pdev->dev, "using msi-x interrupts\n");
f94bc1e7 374 return err;
13159183
SC		 375 } else if (err > 0) {
376 dev_info(&pdev->dev,
377 "Unable to allocate %d MSI-X interrupt vectors\n",
378 num_msix);
379 if (qlcnic_83xx_check(adapter)) {
380 if (err < QLC_83XX_MINIMUM_VECTOR)
381 return err;
382 err -= (adapter->max_drv_tx_rings + 1);
383 num_msix = rounddown_pow_of_two(err);
384 num_msix += (adapter->max_drv_tx_rings + 1);
385 } else {
386 num_msix = rounddown_pow_of_two(err);
387 }
388
389 if (num_msix) {
390 dev_info(&pdev->dev,
391 "Trying %d MSI-X interrupt vectors\n",
392 num_msix);
f94bc1e7 393 goto enable_msix;
13159183
SC		 394 }
395 } else {
396 dev_info(&pdev->dev, "Failed to get %d vectors\n",
397 num_msix);
f94bc1e7
SC		 398 }
399 }
13159183 400
f94bc1e7
SC		 401 return err;
402}
af19b491 403
f94bc1e7
SC		 404static void qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
405{
15087c2b 406 u32 offset, mask_reg;
f94bc1e7 407 const struct qlcnic_legacy_intr_set *legacy_intrp;
15087c2b 408 struct qlcnic_hardware_context *ahw = adapter->ahw;
f94bc1e7 409 struct pci_dev *pdev = adapter->pdev;
af19b491 410
099f7aa7 411 if (qlcnic_use_msi && !pci_enable_msi(pdev)) {
af19b491 412 adapter->flags |= QLCNIC_MSI_ENABLED;
15087c2b
SC		 413 offset = msi_tgt_status[adapter->ahw->pci_func];
414 adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
415 offset);
af19b491
AKS		 416 dev_info(&pdev->dev, "using msi interrupts\n");
417 adapter->msix_entries[0].vector = pdev->irq;
418 return;
419 }
420
f94bc1e7 421 legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
79788450 422 adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
15087c2b
SC		 423 offset = legacy_intrp->tgt_status_reg;
424 adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
425 mask_reg = legacy_intrp->tgt_mask_reg;
426 adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
427 adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
428 adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
af19b491
AKS		 429 dev_info(&pdev->dev, "using legacy interrupts\n");
430 adapter->msix_entries[0].vector = pdev->irq;
431}
432
7e2cf4fe 433int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter, u8 num_intr)
f94bc1e7 434{
7e2cf4fe 435 int num_msix, err;
f94bc1e7 436
7e2cf4fe
SC		 437 if (!num_intr)
438 num_intr = QLCNIC_DEF_NUM_STS_DESC_RINGS;
439
440 if (adapter->ahw->msix_supported)
5f6ec29a 441 num_msix = rounddown_pow_of_two(min_t(int, num_online_cpus(),
7e2cf4fe
SC		 442 num_intr));
443 else
f94bc1e7
SC		 444 num_msix = 1;
445
7e2cf4fe
SC		 446 err = qlcnic_enable_msix(adapter, num_msix);
447 if (err == -ENOMEM || !err)
448 return err;
f94bc1e7
SC		 449
450 qlcnic_enable_msi_legacy(adapter);
7e2cf4fe 451 return 0;
f94bc1e7 452}
13159183 453
319ecf12 454void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
af19b491
AKS		 455{
456 if (adapter->flags & QLCNIC_MSIX_ENABLED)
457 pci_disable_msix(adapter->pdev);
458 if (adapter->flags & QLCNIC_MSI_ENABLED)
459 pci_disable_msi(adapter->pdev);
13159183
SC		 460
461 kfree(adapter->msix_entries);
462 adapter->msix_entries = NULL;
463
464 if (adapter->ahw->intr_tbl) {
465 vfree(adapter->ahw->intr_tbl);
466 adapter->ahw->intr_tbl = NULL;
467 }
af19b491
AKS		 468}
469
470static void
471qlcnic_cleanup_pci_map(struct qlcnic_adapter *adapter)
472{
b1fc6d3c
AC		 473 if (adapter->ahw->pci_base0 != NULL)
474 iounmap(adapter->ahw->pci_base0);
af19b491
AKS		 475}
476
7e2cf4fe
SC		 477static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
478{
479 struct qlcnic_pci_info *pci_info;
480 int ret;
481
482 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
483 switch (adapter->ahw->port_type) {
484 case QLCNIC_GBE:
485 adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_GBE_PORTS;
486 break;
487 case QLCNIC_XGBE:
488 adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_XG_PORTS;
489 break;
490 }
491 return 0;
492 }
493
494 if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
495 return 0;
496
497 pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
498 if (!pci_info)
499 return -ENOMEM;
500
501 ret = qlcnic_get_pci_info(adapter, pci_info);
502 kfree(pci_info);
503 return ret;
504}
bff57d8e 505static int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
346fe763 506{
e88db3bd 507 struct qlcnic_pci_info *pci_info;
bff57d8e
SC		 508 int i, ret = 0, j = 0;
509 u16 act_pci_func;
346fe763
RB		 510 u8 pfn;
511
e88db3bd
DC		 512 pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
513 if (!pci_info)
514 return -ENOMEM;
515
bff57d8e
SC		 516 ret = qlcnic_get_pci_info(adapter, pci_info);
517 if (ret)
518 goto err_pci_info;
519
520 act_pci_func = adapter->ahw->act_pci_func;
521
ca315ac2 522 adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
bff57d8e 523 act_pci_func, GFP_KERNEL);
e88db3bd 524 if (!adapter->npars) {
900853a4 525 ret = -ENOMEM;
e88db3bd
DC		 526 goto err_pci_info;
527 }
346fe763 528
ca315ac2 529 adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
346fe763
RB		 530 QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
531 if (!adapter->eswitch) {
900853a4 532 ret = -ENOMEM;
ca315ac2 533 goto err_npars;
346fe763
RB		 534 }
535
ca315ac2
DC		 536 for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
537 pfn = pci_info[i].id;
bff57d8e 538
0f6efff9 539 if (pfn >= QLCNIC_MAX_PCI_FUNC) {
f848d6dd
SC		 540 ret = QL_STATUS_INVALID_PARAM;
541 goto err_eswitch;
542 }
bff57d8e
SC		 543
544 if (!pci_info[i].active ||
545 (pci_info[i].type != QLCNIC_TYPE_NIC))
546 continue;
547
548 adapter->npars[j].pci_func = pfn;
549 adapter->npars[j].active = (u8)pci_info[i].active;
550 adapter->npars[j].type = (u8)pci_info[i].type;
551 adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
552 adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
553 adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
554 j++;
346fe763
RB		 555 }
556
13159183 557 for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++) {
ca315ac2 558 adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
13159183
SC		 559 if (qlcnic_83xx_check(adapter))
560 qlcnic_enable_eswitch(adapter, i, 1);
561 }
ca315ac2 562
e88db3bd 563 kfree(pci_info);
ca315ac2
DC		 564 return 0;
565
566err_eswitch:
346fe763
RB		 567 kfree(adapter->eswitch);
568 adapter->eswitch = NULL;
ca315ac2 569err_npars:
346fe763 570 kfree(adapter->npars);
ca315ac2 571 adapter->npars = NULL;
e88db3bd
DC		 572err_pci_info:
573 kfree(pci_info);
346fe763
RB		 574
575 return ret;
576}
577
2e9d722d
AC		 578static int
579qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
580{
581 u8 id;
2e9d722d
AC		 582 int i, ret = 1;
583 u32 data = QLCNIC_MGMT_FUNC;
bff57d8e 584 struct qlcnic_hardware_context *ahw = adapter->ahw;
2e9d722d 585
2e9d722d
AC		 586 ret = qlcnic_api_lock(adapter);
587 if (ret)
588 goto err_lock;
2e9d722d 589
0e33c664 590 if (qlcnic_config_npars) {
bff57d8e
SC		 591 for (i = 0; i < ahw->act_pci_func; i++) {
592 id = adapter->npars[i].pci_func;
593 if (id == ahw->pci_func)
0e33c664
AC		 594 continue;
595 data |= (qlcnic_config_npars &
596 QLC_DEV_SET_DRV(0xf, id));
597 }
598 } else {
a15ebd37 599 data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
bff57d8e 600 data = (data & ~QLC_DEV_SET_DRV(0xf, ahw->pci_func)) |
0e33c664 601 (QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC,
bff57d8e 602 ahw->pci_func));
2e9d722d 603 }
a15ebd37 604 QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
2e9d722d
AC		 605 qlcnic_api_unlock(adapter);
606err_lock:
607 return ret;
608}
609
13159183
SC		 610static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
611 const struct pci_device_id *ent)
2e9d722d 612{
2e9d722d
AC		 613 u32 op_mode, priv_level;
614
615 /* Determine FW API version */
13159183
SC		 616 adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
617 QLCNIC_FW_API);
2e9d722d
AC		 618
619 /* Find PCI function number */
13159183 620 qlcnic_get_func_no(adapter);
2e9d722d
AC		 621
622 /* Determine function privilege level */
13159183 623 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
0e33c664 624 if (op_mode == QLC_DEV_DRV_DEFAULT)
2e9d722d 625 priv_level = QLCNIC_MGMT_FUNC;
0e33c664 626 else
b1fc6d3c 627 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
2e9d722d 628
0866d96d 629 if (priv_level == QLCNIC_NON_PRIV_FUNC) {
79788450 630 adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
9f26f547
AC		 631 dev_info(&adapter->pdev->dev,
632 "HAL Version: %d Non Privileged function\n",
79788450 633 adapter->ahw->fw_hal_version);
9f26f547 634 adapter->nic_ops = &qlcnic_vf_ops;
0866d96d
AC		 635 } else
636 adapter->nic_ops = &qlcnic_ops;
2e9d722d
AC		 637}
638
15087c2b 639#define QLCNIC_82XX_BAR0_LENGTH 0x00200000UL
13159183 640#define QLCNIC_83XX_BAR0_LENGTH 0x4000
15087c2b
SC		 641static void qlcnic_get_bar_length(u32 dev_id, ulong *bar)
642{
643 switch (dev_id) {
644 case PCI_DEVICE_ID_QLOGIC_QLE824X:
645 *bar = QLCNIC_82XX_BAR0_LENGTH;
646 break;
13159183
SC		 647 case PCI_DEVICE_ID_QLOGIC_QLE834X:
648 *bar = QLCNIC_83XX_BAR0_LENGTH;
649 break;
15087c2b
SC		 650 default:
651 *bar = 0;
652 }
653}
654
655static int qlcnic_setup_pci_map(struct pci_dev *pdev,
656 struct qlcnic_hardware_context *ahw)
af19b491 657{
15087c2b 658 u32 offset;
af19b491 659 void __iomem *mem_ptr0 = NULL;
15087c2b 660 unsigned long mem_len, pci_len0 = 0, bar0_len;
af19b491 661
af19b491 662 /* remap phys address */
af19b491
AKS		 663 mem_len = pci_resource_len(pdev, 0);
664
15087c2b
SC		 665 qlcnic_get_bar_length(pdev->device, &bar0_len);
666 if (mem_len >= bar0_len) {
af19b491
AKS		 667
668 mem_ptr0 = pci_ioremap_bar(pdev, 0);
669 if (mem_ptr0 == NULL) {
670 dev_err(&pdev->dev, "failed to map PCI bar 0\n");
671 return -EIO;
672 }
673 pci_len0 = mem_len;
674 } else {
675 return -EIO;
676 }
677
678 dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
7e2cf4fe 679
15087c2b
SC		 680 ahw->pci_base0 = mem_ptr0;
681 ahw->pci_len0 = pci_len0;
682 offset = QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(ahw->pci_func));
683 qlcnic_get_ioaddr(ahw, offset);
af19b491
AKS		 684
685 return 0;
686}
687
22999798 688static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
af19b491
AKS		 689{
690 struct pci_dev *pdev = adapter->pdev;
691 int i, found = 0;
692
693 for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
694 if (qlcnic_boards[i].vendor == pdev->vendor &&
695 qlcnic_boards[i].device == pdev->device &&
696 qlcnic_boards[i].sub_vendor == pdev->subsystem_vendor &&
697 qlcnic_boards[i].sub_device == pdev->subsystem_device) {
02f6e46f
SC		 698 sprintf(name, "%pM: %s" ,
699 adapter->mac_addr,
700 qlcnic_boards[i].short_name);
af19b491
AKS		 701 found = 1;
702 break;
703 }
704
705 }
706
707 if (!found)
7f9a0c34 708 sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
af19b491
AKS		 709}
710
711static void
712qlcnic_check_options(struct qlcnic_adapter *adapter)
713{
a15ebd37 714 int err;
031a4a26 715 u32 fw_major, fw_minor, fw_build, prev_fw_version;
af19b491 716 struct pci_dev *pdev = adapter->pdev;
a15ebd37
HM		 717 struct qlcnic_hardware_context *ahw = adapter->ahw;
718 struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
031a4a26
SV		 719
720 prev_fw_version = adapter->fw_version;
af19b491 721
a15ebd37
HM		 722 fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
723 fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
724 fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
af19b491
AKS		 725
726 adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
727
a15ebd37
HM		 728 err = qlcnic_get_board_info(adapter);
729 if (err) {
730 dev_err(&pdev->dev, "Error getting board config info.\n");
731 return;
732 }
733 if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
031a4a26
SV		 734 if (fw_dump->tmpl_hdr == NULL ||
735 adapter->fw_version > prev_fw_version) {
736 if (fw_dump->tmpl_hdr)
737 vfree(fw_dump->tmpl_hdr);
738 if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
739 dev_info(&pdev->dev,
740 "Supports FW dump capability\n");
741 }
742 }
743
13159183
SC		 744 dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d\n",
745 QLCNIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build);
746
b1fc6d3c 747 if (adapter->ahw->port_type == QLCNIC_XGBE) {
90d19005
SC		 748 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
749 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
750 adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
751 } else {
752 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
753 adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
754 }
755
af19b491 756 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
90d19005
SC		 757 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
758
b1fc6d3c 759 } else if (adapter->ahw->port_type == QLCNIC_GBE) {
af19b491
AKS		 760 adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
761 adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
90d19005
SC		 762 adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
763 adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
af19b491
AKS		 764 }
765
099f7aa7 766 adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
af19b491
AKS		 767
768 adapter->num_txd = MAX_CMD_DESCRIPTORS;
769
251b036a 770 adapter->max_rds_rings = MAX_RDS_RINGS;
af19b491
AKS		 771}
772
174240a8
RB		 773static int
774qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
775{
776 int err;
777 struct qlcnic_info nic_info;
778
bff57d8e 779 memset(&nic_info, 0, sizeof(struct qlcnic_info));
b1fc6d3c 780 err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
174240a8
RB		 781 if (err)
782 return err;
783
79788450
SC		 784 adapter->ahw->physical_port = (u8)nic_info.phys_port;
785 adapter->ahw->switch_mode = nic_info.switch_mode;
786 adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
787 adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
788 adapter->ahw->capabilities = nic_info.capabilities;
789 adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
790 adapter->ahw->max_mtu = nic_info.max_mtu;
174240a8 791
13159183
SC		 792 /* Disable NPAR for 83XX */
793 if (qlcnic_83xx_check(adapter))
794 return err;
795
79788450 796 if (adapter->ahw->capabilities & BIT_6)
174240a8
RB		 797 adapter->flags |= QLCNIC_ESWITCH_ENABLED;
798 else
799 adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
800
801 return err;
802}
803
ec079a07
SC		 804void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
805 struct qlcnic_esw_func_cfg *esw_cfg)
8cf61f89
AKS		 806{
807 if (esw_cfg->discard_tagged)
808 adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
809 else
810 adapter->flags |= QLCNIC_TAGGING_ENABLED;
811
812 if (esw_cfg->vlan_id)
813 adapter->pvid = esw_cfg->vlan_id;
814 else
815 adapter->pvid = 0;
816}
817
8e586137 818static int
b9796a14
AC		 819qlcnic_vlan_rx_add(struct net_device *netdev, u16 vid)
820{
821 struct qlcnic_adapter *adapter = netdev_priv(netdev);
822 set_bit(vid, adapter->vlans);
8e586137 823 return 0;
b9796a14
AC		 824}
825
8e586137 826static int
b9796a14
AC		 827qlcnic_vlan_rx_del(struct net_device *netdev, u16 vid)
828{
829 struct qlcnic_adapter *adapter = netdev_priv(netdev);
830
831 qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
832 clear_bit(vid, adapter->vlans);
8e586137 833 return 0;
b9796a14
AC		 834}
835
ec079a07
SC		 836void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
837 struct qlcnic_esw_func_cfg *esw_cfg)
0325d69b 838{
ee07c1a7
RB		 839 adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
840 QLCNIC_PROMISC_DISABLED);
7613c87b
RB		 841
842 if (esw_cfg->mac_anti_spoof)
843 adapter->flags |= QLCNIC_MACSPOOF;
fe4d434d 844
7373373d
RB		 845 if (!esw_cfg->mac_override)
846 adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
847
ee07c1a7
RB		 848 if (!esw_cfg->promisc_mode)
849 adapter->flags |= QLCNIC_PROMISC_DISABLED;
850
0325d69b
RB		 851 qlcnic_set_netdev_features(adapter, esw_cfg);
852}
853
ec079a07 854static int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
0325d69b
RB		 855{
856 struct qlcnic_esw_func_cfg esw_cfg;
857
858 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
859 return 0;
860
b1fc6d3c 861 esw_cfg.pci_func = adapter->ahw->pci_func;
0325d69b
RB		 862 if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
863 return -EIO;
8cf61f89 864 qlcnic_set_vlan_config(adapter, &esw_cfg);
0325d69b
RB		 865 qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
866
867 return 0;
868}
869
870static void
871qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
872 struct qlcnic_esw_func_cfg *esw_cfg)
873{
874 struct net_device *netdev = adapter->netdev;
13159183
SC		 875 unsigned long features, vlan_features;
876
877 if (qlcnic_83xx_check(adapter))
878 return;
0325d69b 879
13159183 880 features = (NETIF_F_SG | NETIF_F_IP_CSUM |
0325d69b
RB		 881 NETIF_F_IPV6_CSUM | NETIF_F_GRO);
882 vlan_features = (NETIF_F_SG | NETIF_F_IP_CSUM |
13159183 883 NETIF_F_IPV6_CSUM);
0325d69b 884
13159183 885 if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
0325d69b
RB		 886 features |= (NETIF_F_TSO | NETIF_F_TSO6);
887 vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
888 }
b56421d0
RB		 889
890 if (netdev->features & NETIF_F_LRO)
0325d69b
RB		 891 features |= NETIF_F_LRO;
892
893 if (esw_cfg->offload_flags & BIT_0) {
894 netdev->features |= features;
13159183 895 adapter->rx_csum = 1;
0325d69b
RB		 896 if (!(esw_cfg->offload_flags & BIT_1))
897 netdev->features &= ~NETIF_F_TSO;
898 if (!(esw_cfg->offload_flags & BIT_2))
899 netdev->features &= ~NETIF_F_TSO6;
900 } else {
901 netdev->features &= ~features;
13159183 902 adapter->rx_csum = 0;
0325d69b
RB		 903 }
904
905 netdev->vlan_features = (features & vlan_features);
906}
907
0866d96d
AC		 908static int
909qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
910{
0866d96d
AC		 911 u32 op_mode, priv_level;
912 int err = 0;
913
174240a8
RB		 914 err = qlcnic_initialize_nic(adapter);
915 if (err)
916 return err;
917
0866d96d
AC		 918 if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
919 return 0;
920
13159183 921 op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
b1fc6d3c 922 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
0866d96d
AC		 923
924 if (op_mode == QLC_DEV_DRV_DEFAULT)
925 priv_level = QLCNIC_MGMT_FUNC;
926 else
b1fc6d3c 927 priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
0866d96d 928
174240a8 929 if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
0866d96d 930 if (priv_level == QLCNIC_MGMT_FUNC) {
79788450 931 adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
0866d96d
AC		 932 err = qlcnic_init_pci_info(adapter);
933 if (err)
934 return err;
935 /* Set privilege level for other functions */
936 qlcnic_set_function_modes(adapter);
937 dev_info(&adapter->pdev->dev,
938 "HAL Version: %d, Management function\n",
79788450 939 adapter->ahw->fw_hal_version);
0866d96d 940 } else if (priv_level == QLCNIC_PRIV_FUNC) {
79788450 941 adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
0866d96d
AC		 942 dev_info(&adapter->pdev->dev,
943 "HAL Version: %d, Privileged function\n",
79788450 944 adapter->ahw->fw_hal_version);
0866d96d 945 }
174240a8 946 }
0866d96d
AC		 947
948 adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
949
950 return err;
951}
952
bff57d8e 953static int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
0325d69b
RB		 954{
955 struct qlcnic_esw_func_cfg esw_cfg;
956 struct qlcnic_npar_info *npar;
957 u8 i;
958
174240a8 959 if (adapter->need_fw_reset)
0325d69b
RB		 960 return 0;
961
bff57d8e 962 for (i = 0; i < adapter->ahw->act_pci_func; i++) {
0325d69b 963 memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
bff57d8e 964 esw_cfg.pci_func = adapter->npars[i].pci_func;
7373373d 965 esw_cfg.mac_override = BIT_0;
ee07c1a7 966 esw_cfg.promisc_mode = BIT_0;
bff57d8e
SC		 967 if (qlcnic_82xx_check(adapter)) {
968 esw_cfg.offload_flags = BIT_0;
969 if (QLCNIC_IS_TSO_CAPABLE(adapter))
970 esw_cfg.offload_flags |= (BIT_1 | BIT_2);
971 }
0325d69b
RB		 972 if (qlcnic_config_switch_port(adapter, &esw_cfg))
973 return -EIO;
974 npar = &adapter->npars[i];
975 npar->pvid = esw_cfg.vlan_id;
7373373d 976 npar->mac_override = esw_cfg.mac_override;
0325d69b
RB		 977 npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
978 npar->discard_tagged = esw_cfg.discard_tagged;
979 npar->promisc_mode = esw_cfg.promisc_mode;
980 npar->offload_flags = esw_cfg.offload_flags;
981 }
982
983 return 0;
984}
985
13159183 986
4e8acb01
RB		 987static int
988qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
989 struct qlcnic_npar_info *npar, int pci_func)
990{
991 struct qlcnic_esw_func_cfg esw_cfg;
992 esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
993 esw_cfg.pci_func = pci_func;
994 esw_cfg.vlan_id = npar->pvid;
7373373d 995 esw_cfg.mac_override = npar->mac_override;
4e8acb01
RB		 996 esw_cfg.discard_tagged = npar->discard_tagged;
997 esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
998 esw_cfg.offload_flags = npar->offload_flags;
999 esw_cfg.promisc_mode = npar->promisc_mode;
1000 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1001 return -EIO;
1002
1003 esw_cfg.op_mode = QLCNIC_ADD_VLAN;
1004 if (qlcnic_config_switch_port(adapter, &esw_cfg))
1005 return -EIO;
1006
1007 return 0;
1008}
1009
bff57d8e 1010static int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
cea8975e 1011{
4e8acb01 1012 int i, err;
cea8975e
AC		 1013 struct qlcnic_npar_info *npar;
1014 struct qlcnic_info nic_info;
bff57d8e 1015 u8 pci_func;
cea8975e 1016
bff57d8e
SC		 1017 if (qlcnic_82xx_check(adapter))
1018 if (!adapter->need_fw_reset)
1019 return 0;
cea8975e 1020
4e8acb01 1021 /* Set the NPAR config data after FW reset */
bff57d8e 1022 for (i = 0; i < adapter->ahw->act_pci_func; i++) {
4e8acb01 1023 npar = &adapter->npars[i];
bff57d8e
SC		 1024 pci_func = npar->pci_func;
1025 memset(&nic_info, 0, sizeof(struct qlcnic_info));
13159183 1026 err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
4e8acb01
RB		 1027 if (err)
1028 return err;
1029 nic_info.min_tx_bw = npar->min_bw;
1030 nic_info.max_tx_bw = npar->max_bw;
1031 err = qlcnic_set_nic_info(adapter, &nic_info);
1032 if (err)
1033 return err;
cea8975e 1034
4e8acb01
RB		 1035 if (npar->enable_pm) {
1036 err = qlcnic_config_port_mirroring(adapter,
bff57d8e
SC		 1037 npar->dest_npar, 1,
1038 pci_func);
4e8acb01
RB		 1039 if (err)
1040 return err;
cea8975e 1041 }
bff57d8e 1042 err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
4e8acb01
RB		 1043 if (err)
1044 return err;
cea8975e 1045 }
4e8acb01 1046 return 0;
cea8975e
AC		 1047}
1048
78f84e1a
AKS		 1049static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
1050{
1051 u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
1052 u32 npar_state;
1053
79788450 1054 if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
78f84e1a
AKS		 1055 return 0;
1056
a15ebd37
HM		 1057 npar_state = QLC_SHARED_REG_RD32(adapter,
1058 QLCNIC_CRB_DEV_NPAR_STATE);
78f84e1a
AKS		 1059 while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
1060 msleep(1000);
a15ebd37
HM		 1061 npar_state = QLC_SHARED_REG_RD32(adapter,
1062 QLCNIC_CRB_DEV_NPAR_STATE);
78f84e1a
AKS		 1063 }
1064 if (!npar_opt_timeo) {
1065 dev_err(&adapter->pdev->dev,
1066 "Waiting for NPAR state to opertional timeout\n");
1067 return -EIO;
1068 }
1069 return 0;
1070}
1071
174240a8
RB		 1072static int
1073qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
1074{
1075 int err;
1076
1077 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
79788450 1078 adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
174240a8
RB		 1079 return 0;
1080
1081 err = qlcnic_set_default_offload_settings(adapter);
1082 if (err)
1083 return err;
1084
1085 err = qlcnic_reset_npar_config(adapter);
1086 if (err)
1087 return err;
1088
1089 qlcnic_dev_set_npar_ready(adapter);
1090
13159183
SC		 1091 if (qlcnic_83xx_check(adapter))
1092 qlcnic_83xx_register_nic_idc_func(adapter, 1);
174240a8
RB		 1093 return err;
1094}
1095
7e2cf4fe 1096int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
af19b491 1097{
d4066833 1098 int err;
af19b491 1099
aa5e18c0
SC		 1100 err = qlcnic_can_start_firmware(adapter);
1101 if (err < 0)
1102 return err;
1103 else if (!err)
d4066833 1104 goto check_fw_status;
af19b491 1105
099f7aa7 1106 if (qlcnic_load_fw_file)
4d5bdb38 1107 qlcnic_request_firmware(adapter);
8f891387 1108 else {
8cfdce08
SC		 1109 err = qlcnic_check_flash_fw_ver(adapter);
1110 if (err)
8f891387 1111 goto err_out;
1112
79788450 1113 adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
8f891387 1114 }
af19b491
AKS		 1115
1116 err = qlcnic_need_fw_reset(adapter);
af19b491 1117 if (err == 0)
4e70812b 1118 goto check_fw_status;
af19b491 1119
d4066833
SC		 1120 err = qlcnic_pinit_from_rom(adapter);
1121 if (err)
1122 goto err_out;
af19b491
AKS		 1123
1124 err = qlcnic_load_firmware(adapter);
1125 if (err)
1126 goto err_out;
1127
1128 qlcnic_release_firmware(adapter);
d4066833 1129 QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
af19b491 1130
d4066833
SC		 1131check_fw_status:
1132 err = qlcnic_check_fw_status(adapter);
af19b491
AKS		 1133 if (err)
1134 goto err_out;
1135
a15ebd37 1136 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
6df900e9 1137 qlcnic_idc_debug_info(adapter, 1);
0866d96d
AC		 1138 err = qlcnic_check_eswitch_mode(adapter);
1139 if (err) {
1140 dev_err(&adapter->pdev->dev,
1141 "Memory allocation failed for eswitch\n");
1142 goto err_out;
1143 }
174240a8
RB		 1144 err = qlcnic_set_mgmt_operations(adapter);
1145 if (err)
1146 goto err_out;
1147
1148 qlcnic_check_options(adapter);
af19b491
AKS		 1149 adapter->need_fw_reset = 0;
1150
a7fc948f
AKS		 1151 qlcnic_release_firmware(adapter);
1152 return 0;
af19b491
AKS		 1153
1154err_out:
a15ebd37 1155 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
a7fc948f 1156 dev_err(&adapter->pdev->dev, "Device state set to failed\n");
0866d96d 1157
af19b491
AKS		 1158 qlcnic_release_firmware(adapter);
1159 return err;
1160}
1161
1162static int
1163qlcnic_request_irq(struct qlcnic_adapter *adapter)
1164{
1165 irq_handler_t handler;
1166 struct qlcnic_host_sds_ring *sds_ring;
13159183 1167 struct qlcnic_host_tx_ring *tx_ring;
af19b491
AKS		 1168 int err, ring;
1169
1170 unsigned long flags = 0;
1171 struct net_device *netdev = adapter->netdev;
b1fc6d3c 1172 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
af19b491 1173
79788450 1174 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
13159183
SC		 1175 if (qlcnic_82xx_check(adapter))
1176 handler = qlcnic_tmp_intr;
7eb9855d
AKS		 1177 if (!QLCNIC_IS_MSI_FAMILY(adapter))
1178 flags |= IRQF_SHARED;
1179
1180 } else {
1181 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1182 handler = qlcnic_msix_intr;
1183 else if (adapter->flags & QLCNIC_MSI_ENABLED)
1184 handler = qlcnic_msi_intr;
1185 else {
1186 flags |= IRQF_SHARED;
1187 handler = qlcnic_intr;
1188 }
af19b491
AKS		 1189 }
1190 adapter->irq = netdev->irq;
1191
13159183
SC		 1192 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1193 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1194 sds_ring = &recv_ctx->sds_rings[ring];
1195 snprintf(sds_ring->name, sizeof(int) + IFNAMSIZ,
1196 "%s[%d]", netdev->name, ring);
1197 err = request_irq(sds_ring->irq, handler, flags,
1198 sds_ring->name, sds_ring);
1199 if (err)
1200 return err;
1201 }
1202 if (qlcnic_83xx_check(adapter) &&
1203 (adapter->flags & QLCNIC_MSIX_ENABLED)) {
1204 handler = qlcnic_msix_tx_intr;
1205 for (ring = 0; ring < adapter->max_drv_tx_rings;
1206 ring++) {
1207 tx_ring = &adapter->tx_ring[ring];
1208 snprintf(tx_ring->name, sizeof(int) + IFNAMSIZ,
1209 "%s[%d]", netdev->name,
1210 adapter->max_sds_rings + ring);
1211 err = request_irq(tx_ring->irq, handler, flags,
1212 tx_ring->name, tx_ring);
1213 if (err)
1214 return err;
1215 }
1216 }
af19b491 1217 }
af19b491
AKS		 1218 return 0;
1219}
1220
1221static void
1222qlcnic_free_irq(struct qlcnic_adapter *adapter)
1223{
1224 int ring;
1225 struct qlcnic_host_sds_ring *sds_ring;
13159183 1226 struct qlcnic_host_tx_ring *tx_ring;
af19b491 1227
b1fc6d3c 1228 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
af19b491 1229
13159183
SC		 1230 if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1231 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1232 sds_ring = &recv_ctx->sds_rings[ring];
1233 free_irq(sds_ring->irq, sds_ring);
1234 }
1235 if (qlcnic_83xx_check(adapter)) {
1236 for (ring = 0; ring < adapter->max_drv_tx_rings;
1237 ring++) {
1238 tx_ring = &adapter->tx_ring[ring];
1239 if (tx_ring->irq)
1240 free_irq(tx_ring->irq, tx_ring);
1241 }
1242 }
af19b491
AKS		 1243 }
1244}
1245
319ecf12 1246int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491 1247{
8a15ad1f 1248 int ring;
cae82d49
RB		 1249 u32 capab2;
1250
8a15ad1f
AKS		 1251 struct qlcnic_host_rds_ring *rds_ring;
1252
af19b491
AKS		 1253 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1254 return -EIO;
1255
8a15ad1f
AKS		 1256 if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1257 return 0;
0325d69b
RB		 1258 if (qlcnic_set_eswitch_port_config(adapter))
1259 return -EIO;
8a15ad1f 1260
79788450 1261 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
cae82d49
RB		 1262 capab2 = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
1263 if (capab2 & QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1264 adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1265 }
1266
8a15ad1f
AKS		 1267 if (qlcnic_fw_create_ctx(adapter))
1268 return -EIO;
1269
1270 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
b1fc6d3c 1271 rds_ring = &adapter->recv_ctx->rds_rings[ring];
4be41e92 1272 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
8a15ad1f
AKS		 1273 }
1274
af19b491
AKS		 1275 qlcnic_set_multi(netdev);
1276 qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1277
b1fc6d3c 1278 adapter->ahw->linkup = 0;
af19b491
AKS		 1279
1280 if (adapter->max_sds_rings > 1)
1281 qlcnic_config_rss(adapter, 1);
1282
1283 qlcnic_config_intr_coalesce(adapter);
1284
24763d80 1285 if (netdev->features & NETIF_F_LRO)
af19b491
AKS		 1286 qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1287
1288 qlcnic_napi_enable(adapter);
1289
1290 qlcnic_linkevent_request(adapter, 1);
1291
79788450 1292 adapter->ahw->reset_context = 0;
af19b491
AKS		 1293 set_bit(__QLCNIC_DEV_UP, &adapter->state);
1294 return 0;
1295}
1296
1297/* Usage: During resume and firmware recovery module.*/
1298
13159183 1299static int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491
AKS		 1300{
1301 int err = 0;
1302
1303 rtnl_lock();
1304 if (netif_running(netdev))
1305 err = __qlcnic_up(adapter, netdev);
1306 rtnl_unlock();
1307
1308 return err;
1309}
1310
319ecf12 1311void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
af19b491
AKS		 1312{
1313 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1314 return;
1315
1316 if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1317 return;
1318
1319 smp_mb();
1320 spin_lock(&adapter->tx_clean_lock);
1321 netif_carrier_off(netdev);
1322 netif_tx_disable(netdev);
1323
1324 qlcnic_free_mac_list(adapter);
1325
b5e5492c
AKS		 1326 if (adapter->fhash.fnum)
1327 qlcnic_delete_lb_filters(adapter);
1328
af19b491
AKS		 1329 qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1330
1331 qlcnic_napi_disable(adapter);
1332
8a15ad1f 1333 qlcnic_fw_destroy_ctx(adapter);
cae82d49 1334 adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
8a15ad1f
AKS		 1335
1336 qlcnic_reset_rx_buffers_list(adapter);
af19b491
AKS		 1337 qlcnic_release_tx_buffers(adapter);
1338 spin_unlock(&adapter->tx_clean_lock);
1339}
1340
1341/* Usage: During suspend and firmware recovery module */
1342
1343static void
1344qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1345{
1346 rtnl_lock();
1347 if (netif_running(netdev))
1348 __qlcnic_down(adapter, netdev);
1349 rtnl_unlock();
1350
1351}
1352
319ecf12 1353int
af19b491
AKS		 1354qlcnic_attach(struct qlcnic_adapter *adapter)
1355{
1356 struct net_device *netdev = adapter->netdev;
1357 struct pci_dev *pdev = adapter->pdev;
8a15ad1f 1358 int err;
af19b491
AKS		 1359
1360 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1361 return 0;
1362
af19b491
AKS		 1363 err = qlcnic_napi_add(adapter, netdev);
1364 if (err)
1365 return err;
1366
1367 err = qlcnic_alloc_sw_resources(adapter);
1368 if (err) {
1369 dev_err(&pdev->dev, "Error in setting sw resources\n");
8a15ad1f 1370 goto err_out_napi_del;
af19b491
AKS		 1371 }
1372
1373 err = qlcnic_alloc_hw_resources(adapter);
1374 if (err) {
1375 dev_err(&pdev->dev, "Error in setting hw resources\n");
1376 goto err_out_free_sw;
1377 }
1378
af19b491
AKS		 1379 err = qlcnic_request_irq(adapter);
1380 if (err) {
1381 dev_err(&pdev->dev, "failed to setup interrupt\n");
8a15ad1f 1382 goto err_out_free_hw;
af19b491
AKS		 1383 }
1384
af19b491
AKS		 1385 qlcnic_create_sysfs_entries(adapter);
1386
1387 adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
1388 return 0;
1389
8a15ad1f 1390err_out_free_hw:
af19b491
AKS		 1391 qlcnic_free_hw_resources(adapter);
1392err_out_free_sw:
1393 qlcnic_free_sw_resources(adapter);
8a15ad1f
AKS		 1394err_out_napi_del:
1395 qlcnic_napi_del(adapter);
af19b491
AKS		 1396 return err;
1397}
1398
319ecf12 1399void qlcnic_detach(struct qlcnic_adapter *adapter)
af19b491
AKS		 1400{
1401 if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1402 return;
1403
1404 qlcnic_remove_sysfs_entries(adapter);
1405
1406 qlcnic_free_hw_resources(adapter);
1407 qlcnic_release_rx_buffers(adapter);
1408 qlcnic_free_irq(adapter);
1409 qlcnic_napi_del(adapter);
1410 qlcnic_free_sw_resources(adapter);
1411
1412 adapter->is_up = 0;
1413}
1414
7eb9855d
AKS		 1415void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
1416{
1417 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1418 struct qlcnic_host_sds_ring *sds_ring;
1419 int ring;
1420
78ad3892 1421 clear_bit(__QLCNIC_DEV_UP, &adapter->state);
79788450 1422 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
cdaff185 1423 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
b1fc6d3c 1424 sds_ring = &adapter->recv_ctx->sds_rings[ring];
13159183
SC		 1425 if (qlcnic_83xx_check(adapter))
1426 writel(1, sds_ring->crb_intr_mask);
1427 else
1428 qlcnic_disable_int(sds_ring);
cdaff185 1429 }
7eb9855d
AKS		 1430 }
1431
8a15ad1f
AKS		 1432 qlcnic_fw_destroy_ctx(adapter);
1433
7eb9855d
AKS		 1434 qlcnic_detach(adapter);
1435
79788450 1436 adapter->ahw->diag_test = 0;
7eb9855d
AKS		 1437 adapter->max_sds_rings = max_sds_rings;
1438
1439 if (qlcnic_attach(adapter))
34ce3626 1440 goto out;
7eb9855d
AKS		 1441
1442 if (netif_running(netdev))
1443 __qlcnic_up(adapter, netdev);
34ce3626 1444out:
7eb9855d
AKS		 1445 netif_device_attach(netdev);
1446}
1447
b1fc6d3c
AC		 1448static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
1449{
1450 int err = 0;
b1fc6d3c
AC		 1451 adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
1452 GFP_KERNEL);
1453 if (!adapter->recv_ctx) {
1454 dev_err(&adapter->pdev->dev,
1455 "Failed to allocate recv ctx resources for adapter\n");
b1fc6d3c 1456 err = -ENOMEM;
8816d009 1457 goto err_out;
b1fc6d3c 1458 }
8816d009
AC		 1459 /* Initialize interrupt coalesce parameters */
1460 adapter->ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1461 adapter->ahw->coal.rx_time_us = QLCNIC_DEFAULT_INTR_COALESCE_RX_TIME_US;
1462 adapter->ahw->coal.rx_packets = QLCNIC_DEFAULT_INTR_COALESCE_RX_PACKETS;
4be41e92
SC		 1463 /* clear stats */
1464 memset(&adapter->stats, 0, sizeof(adapter->stats));
b1fc6d3c
AC		 1465err_out:
1466 return err;
1467}
1468
1469static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
1470{
1471 kfree(adapter->recv_ctx);
1472 adapter->recv_ctx = NULL;
1473
18f2f616
AC		 1474 if (adapter->ahw->fw_dump.tmpl_hdr) {
1475 vfree(adapter->ahw->fw_dump.tmpl_hdr);
1476 adapter->ahw->fw_dump.tmpl_hdr = NULL;
1477 }
4be41e92
SC		 1478
1479 adapter->ahw->fw_dump.tmpl_hdr = NULL;
b1fc6d3c
AC		 1480}
1481
7eb9855d
AKS		 1482int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
1483{
1484 struct qlcnic_adapter *adapter = netdev_priv(netdev);
1485 struct qlcnic_host_sds_ring *sds_ring;
8a15ad1f 1486 struct qlcnic_host_rds_ring *rds_ring;
7eb9855d
AKS		 1487 int ring;
1488 int ret;
1489
1490 netif_device_detach(netdev);
1491
1492 if (netif_running(netdev))
1493 __qlcnic_down(adapter, netdev);
1494
1495 qlcnic_detach(adapter);
1496
1497 adapter->max_sds_rings = 1;
79788450 1498 adapter->ahw->diag_test = test;
4be41e92 1499 adapter->ahw->linkup = 0;
7eb9855d
AKS		 1500
1501 ret = qlcnic_attach(adapter);
34ce3626
AKS		 1502 if (ret) {
1503 netif_device_attach(netdev);
7eb9855d 1504 return ret;
34ce3626 1505 }
7eb9855d 1506
8a15ad1f
AKS		 1507 ret = qlcnic_fw_create_ctx(adapter);
1508 if (ret) {
1509 qlcnic_detach(adapter);
57e46248 1510 netif_device_attach(netdev);
8a15ad1f
AKS		 1511 return ret;
1512 }
1513
1514 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
b1fc6d3c 1515 rds_ring = &adapter->recv_ctx->rds_rings[ring];
4be41e92 1516 qlcnic_post_rx_buffers(adapter, rds_ring, ring);
8a15ad1f
AKS		 1517 }
1518
79788450 1519 if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
cdaff185 1520 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
b1fc6d3c 1521 sds_ring = &adapter->recv_ctx->sds_rings[ring];
cdaff185
AKS		 1522 qlcnic_enable_int(sds_ring);
1523 }
7eb9855d 1524 }
22c8c934 1525
79788450 1526 if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
22c8c934
SC		 1527 adapter->ahw->loopback_state = 0;
1528 qlcnic_linkevent_request(adapter, 1);
1529 }
1530
78ad3892 1531 set_bit(__QLCNIC_DEV_UP, &adapter->state);
7eb9855d
AKS		 1532
1533 return 0;
1534}
1535
68bf1c68
AKS		 1536/* Reset context in hardware only */
1537static int
1538qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
1539{
1540 struct net_device *netdev = adapter->netdev;
1541
1542 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1543 return -EBUSY;
1544
1545 netif_device_detach(netdev);
1546
1547 qlcnic_down(adapter, netdev);
1548
1549 qlcnic_up(adapter, netdev);
1550
1551 netif_device_attach(netdev);
1552
1553 clear_bit(__QLCNIC_RESETTING, &adapter->state);
13159183 1554 dev_err(&adapter->pdev->dev, "%s:\n", __func__);
68bf1c68
AKS		 1555 return 0;
1556}
1557
af19b491
AKS		 1558int
1559qlcnic_reset_context(struct qlcnic_adapter *adapter)
1560{
1561 int err = 0;
1562 struct net_device *netdev = adapter->netdev;
1563
1564 if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1565 return -EBUSY;
1566
1567 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1568
1569 netif_device_detach(netdev);
1570
1571 if (netif_running(netdev))
1572 __qlcnic_down(adapter, netdev);
1573
1574 qlcnic_detach(adapter);
1575
1576 if (netif_running(netdev)) {
1577 err = qlcnic_attach(adapter);
1d5c88e3 1578 if (!err) {
34ce3626 1579 __qlcnic_up(adapter, netdev);
1d5c88e3
AC		 1580 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
1581 }
af19b491
AKS		 1582 }
1583
1584 netif_device_attach(netdev);
1585 }
1586
af19b491
AKS		 1587 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1588 return err;
1589}
1590
1591static int
5ad6ff9d
SC		 1592qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev,
1593 int pci_using_dac)
af19b491
AKS		 1594{
1595 int err;
1596 struct pci_dev *pdev = adapter->pdev;
1597
13159183 1598 adapter->rx_csum = 1;
79788450 1599 adapter->ahw->mc_enabled = 0;
13159183 1600 adapter->ahw->max_mc_count = QLCNIC_MAX_MC_COUNT;
af19b491
AKS		 1601
1602 netdev->netdev_ops = &qlcnic_netdev_ops;
13159183 1603 netdev->watchdog_timeo = QLCNIC_WATCHDOG_TIMEOUTVALUE * HZ;
af19b491
AKS		 1604
1605 qlcnic_change_mtu(netdev, netdev->mtu);
1606
1607 SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1608
13159183
SC		 1609 netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1610 NETIF_F_IPV6_CSUM | NETIF_F_GRO |
1611 NETIF_F_HW_VLAN_RX);
1612 netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
1613 NETIF_F_IPV6_CSUM);
ac8d0c4f 1614
13159183
SC		 1615 if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
1616 netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
1617 netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
1618 }
af19b491 1619
13159183
SC		 1620 if (pci_using_dac) {
1621 netdev->features |= NETIF_F_HIGHDMA;
1622 netdev->vlan_features |= NETIF_F_HIGHDMA;
1623 }
af19b491 1624
13159183
SC		 1625 if (qlcnic_vlan_tx_check(adapter))
1626 netdev->features |= (NETIF_F_HW_VLAN_TX);
135d84a9 1627
13159183
SC		 1628 if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
1629 netdev->features |= NETIF_F_LRO;
135d84a9 1630
af19b491
AKS		 1631 netdev->irq = adapter->msix_entries[0].vector;
1632
af19b491
AKS		 1633 err = register_netdev(netdev);
1634 if (err) {
1635 dev_err(&pdev->dev, "failed to register net device\n");
1636 return err;
1637 }
1638
1639 return 0;
1640}
1641
5ad6ff9d 1642static int qlcnic_set_dma_mask(struct pci_dev *pdev, int *pci_using_dac)
1bb09fb9
AKS		 1643{
1644 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
1645 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1646 *pci_using_dac = 1;
1647 else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
1648 !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
1649 *pci_using_dac = 0;
1650 else {
1651 dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
1652 return -EIO;
1653 }
1654
1655 return 0;
1656}
1657
4be41e92
SC		 1658void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
1659{
1660 int ring;
1661 struct qlcnic_host_tx_ring *tx_ring;
1662
1663 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1664 tx_ring = &adapter->tx_ring[ring];
1665 if (tx_ring && tx_ring->cmd_buf_arr != NULL) {
1666 vfree(tx_ring->cmd_buf_arr);
1667 tx_ring->cmd_buf_arr = NULL;
1668 }
1669 }
1670 if (adapter->tx_ring != NULL)
1671 kfree(adapter->tx_ring);
1672}
1673
1674int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
1675 struct net_device *netdev)
1676{
1677 int ring, size, vector, index;
1678 struct qlcnic_host_tx_ring *tx_ring;
1679 struct qlcnic_cmd_buffer *cmd_buf_arr;
1680
1681 size = adapter->max_drv_tx_rings * sizeof(struct qlcnic_host_tx_ring);
1682 tx_ring = kzalloc(size, GFP_KERNEL);
1683 if (tx_ring == NULL) {
1684 dev_err(&netdev->dev, "failed to allocate tx rings\n");
1685 return -ENOMEM;
1686 }
1687 adapter->tx_ring = tx_ring;
1688
1689 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1690 tx_ring = &adapter->tx_ring[ring];
1691 tx_ring->num_desc = adapter->num_txd;
1692 tx_ring->txq = netdev_get_tx_queue(netdev, ring);
1693 cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
1694 if (cmd_buf_arr == NULL) {
1695 dev_err(&netdev->dev,
1696 "failed to allocate cmd buffer ring\n");
1697 qlcnic_free_tx_rings(adapter);
1698 return -ENOMEM;
1699 }
1700 memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
1701 tx_ring->cmd_buf_arr = cmd_buf_arr;
1702 }
1703
1704 if (qlcnic_83xx_check(adapter)) {
1705 for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
1706 tx_ring = &adapter->tx_ring[ring];
1707 tx_ring->adapter = adapter;
1708 if (adapter->flags & QLCNIC_MSIX_ENABLED) {
1709 index = adapter->max_sds_rings + ring;
1710 vector = adapter->msix_entries[index].vector;
1711 tx_ring->irq = vector;
1712 }
1713 }
1714 }
1715 return 0;
1716}
1717
7e2cf4fe 1718static int __devinit
af19b491
AKS		 1719qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1720{
1721 struct net_device *netdev = NULL;
1722 struct qlcnic_adapter *adapter = NULL;
7e2cf4fe 1723 struct qlcnic_hardware_context *ahw;
5ad6ff9d 1724 int err, pci_using_dac = -1;
22999798 1725 char board_name[QLCNIC_MAX_BOARD_NAME_LEN];
af19b491
AKS		 1726
1727 err = pci_enable_device(pdev);
1728 if (err)
1729 return err;
1730
1731 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1732 err = -ENODEV;
1733 goto err_out_disable_pdev;
1734 }
1735
1bb09fb9
AKS		 1736 err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
1737 if (err)
1738 goto err_out_disable_pdev;
1739
af19b491
AKS		 1740 err = pci_request_regions(pdev, qlcnic_driver_name);
1741 if (err)
1742 goto err_out_disable_pdev;
1743
1744 pci_set_master(pdev);
451724c8 1745 pci_enable_pcie_error_reporting(pdev);
af19b491 1746
7e2cf4fe
SC		 1747 ahw = kzalloc(sizeof(struct qlcnic_hardware_context), GFP_KERNEL);
1748 if (!ahw)
1749 goto err_out_free_res;
1750
1751 if (ent->device == PCI_DEVICE_ID_QLOGIC_QLE824X) {
1752 ahw->hw_ops = &qlcnic_hw_ops;
1753 ahw->reg_tbl = (u32 *)qlcnic_reg_tbl;
13159183
SC		 1754 } else if (ent->device == PCI_DEVICE_ID_QLOGIC_QLE834X) {
1755 qlcnic_83xx_register_map(ahw);
1756 } else {
1757 goto err_out_free_hw_res;
7e2cf4fe
SC		 1758 }
1759
1760 err = qlcnic_setup_pci_map(pdev, ahw);
1761 if (err)
1762 goto err_out_free_hw_res;
1763
af19b491
AKS		 1764 netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
1765 if (!netdev) {
af19b491 1766 err = -ENOMEM;
7e2cf4fe 1767 goto err_out_iounmap;
af19b491
AKS		 1768 }
1769
1770 SET_NETDEV_DEV(netdev, &pdev->dev);
1771
1772 adapter = netdev_priv(netdev);
1773 adapter->netdev = netdev;
1774 adapter->pdev = pdev;
13159183
SC		 1775 adapter->ahw = ahw;
1776
1777 adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
1778 if (adapter->qlcnic_wq == NULL) {
1779 dev_err(&pdev->dev, "Failed to create workqueue\n");
1780 goto err_out_free_netdev;
1781 }
af19b491 1782
2dfc9671
PST		 1783 err = qlcnic_alloc_adapter_resources(adapter);
1784 if (err)
b1fc6d3c
AC		 1785 goto err_out_free_netdev;
1786
1787 adapter->dev_rst_time = jiffies;
7e2cf4fe 1788 adapter->ahw->revision_id = pdev->revision;
e5dcf6dc 1789 adapter->mac_learn = qlcnic_mac_learn;
7e2cf4fe 1790 adapter->max_drv_tx_rings = 1;
af19b491 1791
b1fc6d3c
AC		 1792 rwlock_init(&adapter->ahw->crb_lock);
1793 mutex_init(&adapter->ahw->mem_lock);
af19b491
AKS		 1794
1795 spin_lock_init(&adapter->tx_clean_lock);
1796 INIT_LIST_HEAD(&adapter->mac_list);
1797
7e2cf4fe 1798 if (qlcnic_82xx_check(adapter)) {
13159183 1799 qlcnic_check_vf(adapter, ent);
7e2cf4fe
SC		 1800 adapter->portnum = adapter->ahw->pci_func;
1801 err = qlcnic_start_firmware(adapter);
1802 if (err) {
1803 dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
1804 goto err_out_free_hw;
1805 }
af19b491 1806
7e2cf4fe
SC		 1807 err = qlcnic_setup_idc_param(adapter);
1808 if (err)
1809 goto err_out_free_hw;
b0044bcf 1810
7e2cf4fe 1811 adapter->flags |= QLCNIC_NEED_FLR;
13159183
SC		 1812 } else if (qlcnic_83xx_check(adapter)) {
1813 qlcnic_83xx_check_vf(adapter, ent);
1814 adapter->portnum = adapter->ahw->pci_func;
1815 } else {
1816 dev_err(&pdev->dev,
1817 "%s: failed. Please Reboot\n", __func__);
1818 goto err_out_free_hw;
a7fc948f 1819 }
af19b491 1820
da48e6c3
RB		 1821 if (qlcnic_read_mac_addr(adapter))
1822 dev_warn(&pdev->dev, "failed to read mac addr\n");
1823
1824 if (adapter->portnum == 0) {
22999798 1825 qlcnic_get_board_name(adapter, board_name);
13159183 1826
da48e6c3 1827 pr_info("%s: %s Board Chip rev 0x%x\n",
22999798
SC		 1828 module_name(THIS_MODULE),
1829 board_name, adapter->ahw->revision_id);
da48e6c3 1830 }
7e2cf4fe
SC		 1831 err = qlcnic_setup_intr(adapter, 0);
1832 if (err)
1833 goto err_out_disable_msi;
f94bc1e7 1834
13159183
SC		 1835 if (qlcnic_83xx_check(adapter)) {
1836 err = qlcnic_83xx_setup_mbx_intr(adapter);
1837 if (err)
1838 goto err_out_disable_msi;
1839 }
af19b491 1840
1bb09fb9 1841 err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
af19b491 1842 if (err)
7e2cf4fe 1843 goto err_out_disable_mbx_intr;
af19b491
AKS		 1844
1845 pci_set_drvdata(pdev, adapter);
1846
97ee45eb
SC		 1847 if (qlcnic_82xx_check(adapter))
1848 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
1849 FW_POLL_DELAY);
af19b491 1850
b1fc6d3c 1851 switch (adapter->ahw->port_type) {
af19b491
AKS		 1852 case QLCNIC_GBE:
1853 dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1854 adapter->netdev->name);
1855 break;
1856 case QLCNIC_XGBE:
1857 dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1858 adapter->netdev->name);
1859 break;
1860 }
1861
7e2cf4fe
SC		 1862 if (qlcnic_get_act_pci_func(adapter))
1863 goto err_out_disable_mbx_intr;
1864
e5dcf6dc
SC		 1865 if (adapter->mac_learn)
1866 qlcnic_alloc_lb_filters_mem(adapter);
1867
7e2cf4fe 1868 qlcnic_add_sysfs(adapter);
af19b491
AKS		 1869
1870 return 0;
1871
7e2cf4fe 1872err_out_disable_mbx_intr:
13159183
SC		 1873 if (qlcnic_83xx_check(adapter)) {
1874 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1875 qlcnic_83xx_config_intrpt(adapter, 0);
1876 qlcnic_83xx_free_mbx_intr(adapter);
1877 }
7e2cf4fe 1878
af19b491
AKS		 1879err_out_disable_msi:
1880 qlcnic_teardown_intr(adapter);
7e2cf4fe 1881 qlcnic_cancel_idc_work(adapter);
21854f02 1882 qlcnic_clr_all_drv_state(adapter, 0);
af19b491 1883
b1fc6d3c
AC		 1884err_out_free_hw:
1885 qlcnic_free_adapter_resources(adapter);
1886
af19b491
AKS		 1887err_out_free_netdev:
1888 free_netdev(netdev);
1889
7e2cf4fe
SC		 1890err_out_iounmap:
1891 qlcnic_cleanup_pci_map(adapter);
1892
1893err_out_free_hw_res:
1894 kfree(ahw);
1895
af19b491
AKS		 1896err_out_free_res:
1897 pci_release_regions(pdev);
1898
1899err_out_disable_pdev:
1900 pci_set_drvdata(pdev, NULL);
1901 pci_disable_device(pdev);
1902 return err;
1903}
1904
13159183 1905static void __devexit qlcnic_remove(struct pci_dev *pdev)
af19b491
AKS		 1906{
1907 struct qlcnic_adapter *adapter;
1908 struct net_device *netdev;
13159183 1909 struct qlcnic_hardware_context *ahw;
af19b491
AKS		 1910
1911 adapter = pci_get_drvdata(pdev);
1912 if (adapter == NULL)
1913 return;
1914
1915 netdev = adapter->netdev;
1916
13159183
SC		 1917 qlcnic_cancel_idc_work(adapter);
1918 ahw = adapter->ahw;
af19b491
AKS		 1919
1920 unregister_netdev(netdev);
1921
13159183
SC		 1922 if (qlcnic_83xx_check(adapter)) {
1923 if (adapter->flags & QLCNIC_MSIX_ENABLED)
1924 qlcnic_83xx_config_intrpt(adapter, 0);
1925 qlcnic_83xx_free_mbx_intr(adapter);
1926 }
1927
af19b491
AKS		 1928 qlcnic_detach(adapter);
1929
2e9d722d
AC		 1930 if (adapter->npars != NULL)
1931 kfree(adapter->npars);
1932 if (adapter->eswitch != NULL)
1933 kfree(adapter->eswitch);
1934
97ee45eb
SC		 1935 if (qlcnic_82xx_check(adapter))
1936 qlcnic_clr_all_drv_state(adapter, 0);
af19b491
AKS		 1937
1938 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1939
b5e5492c
AKS		 1940 qlcnic_free_lb_filters_mem(adapter);
1941
af19b491
AKS		 1942 qlcnic_teardown_intr(adapter);
1943
13159183 1944 qlcnic_remove_sysfs(adapter);
af19b491
AKS		 1945
1946 qlcnic_cleanup_pci_map(adapter);
1947
1948 qlcnic_release_firmware(adapter);
1949
451724c8 1950 pci_disable_pcie_error_reporting(pdev);
af19b491
AKS		 1951 pci_release_regions(pdev);
1952 pci_disable_device(pdev);
1953 pci_set_drvdata(pdev, NULL);
1954
13159183
SC		 1955 if (adapter->qlcnic_wq) {
1956 destroy_workqueue(adapter->qlcnic_wq);
1957 adapter->qlcnic_wq = NULL;
1958 }
b1fc6d3c 1959 qlcnic_free_adapter_resources(adapter);
13159183 1960 kfree(ahw);
af19b491
AKS		 1961 free_netdev(netdev);
1962}
1963static int __qlcnic_shutdown(struct pci_dev *pdev)
1964{
1965 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
1966 struct net_device *netdev = adapter->netdev;
1967 int retval;
1968
1969 netif_device_detach(netdev);
1970
13159183 1971 qlcnic_cancel_idc_work(adapter);
af19b491
AKS		 1972
1973 if (netif_running(netdev))
1974 qlcnic_down(adapter, netdev);
1975
97ee45eb
SC		 1976 if (qlcnic_82xx_check(adapter))
1977 qlcnic_clr_all_drv_state(adapter, 0);
af19b491
AKS		 1978
1979 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1980
1981 retval = pci_save_state(pdev);
1982 if (retval)
1983 return retval;
97ee45eb
SC		 1984 if (qlcnic_82xx_check(adapter)) {
1985 if (qlcnic_wol_supported(adapter)) {
1986 pci_enable_wake(pdev, PCI_D3cold, 1);
1987 pci_enable_wake(pdev, PCI_D3hot, 1);
1988 }
af19b491
AKS		 1989 }
1990
1991 return 0;
1992}
1993
1994static void qlcnic_shutdown(struct pci_dev *pdev)
1995{
1996 if (__qlcnic_shutdown(pdev))
1997 return;
1998
1999 pci_disable_device(pdev);
2000}
2001
2002#ifdef CONFIG_PM
2003static int
2004qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
2005{
2006 int retval;
2007
2008 retval = __qlcnic_shutdown(pdev);
2009 if (retval)
2010 return retval;
2011
2012 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2013 return 0;
2014}
2015
2016static int
2017qlcnic_resume(struct pci_dev *pdev)
2018{
2019 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2020 struct net_device *netdev = adapter->netdev;
2021 int err;
2022
2023 err = pci_enable_device(pdev);
2024 if (err)
2025 return err;
2026
2027 pci_set_power_state(pdev, PCI_D0);
2028 pci_set_master(pdev);
2029 pci_restore_state(pdev);
2030
13159183 2031 err = qlcnic_start_firmware(adapter);
af19b491
AKS		 2032 if (err) {
2033 dev_err(&pdev->dev, "failed to start firmware\n");
2034 return err;
2035 }
2036
2037 if (netif_running(netdev)) {
af19b491
AKS		 2038 err = qlcnic_up(adapter, netdev);
2039 if (err)
52486a3a 2040 goto done;
af19b491 2041
aec1e845 2042 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
af19b491 2043 }
52486a3a 2044done:
af19b491
AKS		 2045 netif_device_attach(netdev);
2046 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
2047 return 0;
af19b491
AKS		 2048}
2049#endif
2050
2051static int qlcnic_open(struct net_device *netdev)
2052{
2053 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2054 int err;
2055
c55ad8e5
AKS		 2056 netif_carrier_off(netdev);
2057
af19b491
AKS		 2058 err = qlcnic_attach(adapter);
2059 if (err)
2060 return err;
2061
2062 err = __qlcnic_up(adapter, netdev);
2063 if (err)
2064 goto err_out;
2065
2066 netif_start_queue(netdev);
2067
2068 return 0;
2069
2070err_out:
2071 qlcnic_detach(adapter);
2072 return err;
2073}
2074
2075/*
2076 * qlcnic_close - Disables a network interface entry point
2077 */
2078static int qlcnic_close(struct net_device *netdev)
2079{
2080 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2081
2082 __qlcnic_down(adapter, netdev);
13159183
SC		 2083 if (qlcnic_83xx_check(adapter)) {
2084 qlcnic_83xx_register_nic_idc_func(adapter, 0);
2085 cancel_delayed_work_sync(&adapter->idc_aen_work);
2086 }
2087
af19b491
AKS		 2088 return 0;
2089}
2090
e5dcf6dc 2091void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
b5e5492c
AKS		 2092{
2093 void *head;
2094 int i;
13159183
SC		 2095 struct net_device *netdev = adapter->netdev;
2096 u32 filter_size = 0;
2097 u16 act_pci_func = 0;
b5e5492c 2098
e5dcf6dc 2099 if (adapter->fhash.fmax && adapter->fhash.fhead)
b5e5492c
AKS		 2100 return;
2101
13159183 2102 act_pci_func = adapter->ahw->act_pci_func;
b5e5492c
AKS		 2103 spin_lock_init(&adapter->mac_learn_lock);
2104
13159183
SC		 2105 if (qlcnic_82xx_check(adapter)) {
2106 filter_size = QLCNIC_LB_MAX_FILTERS;
2107 adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
2108 } else {
2109 filter_size = QLC_83XX_LB_MAX_FILTERS;
2110 adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
2111 }
2112
2113 head = kcalloc(adapter->fhash.fbucket_size,
2114 sizeof(struct hlist_head), GFP_KERNEL);
2115
b5e5492c
AKS		 2116 if (!head)
2117 return;
2118
13159183 2119 adapter->fhash.fmax = (filter_size / act_pci_func);
43d620c8 2120 adapter->fhash.fhead = head;
b5e5492c 2121
13159183
SC		 2122 netdev_info(netdev, "active nic func = %d, mac filter size=%d\n",
2123 act_pci_func, adapter->fhash.fmax);
2124
2125 for (i = 0; i < adapter->fhash.fbucket_size; i++)
b5e5492c
AKS		 2126 INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
2127}
2128
2129static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
2130{
2131 if (adapter->fhash.fmax && adapter->fhash.fhead)
2132 kfree(adapter->fhash.fhead);
2133
2134 adapter->fhash.fhead = NULL;
2135 adapter->fhash.fmax = 0;
2136}
2137
af19b491
AKS		 2138static int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2139{
2140 struct net_device *netdev = adapter->netdev;
97ee45eb 2141 u32 temp_state, temp_val, temp = 0;
af19b491
AKS		 2142 int rv = 0;
2143
13159183
SC		 2144 if (qlcnic_83xx_check(adapter))
2145 temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
2146
97ee45eb 2147 if (qlcnic_82xx_check(adapter))
a15ebd37 2148 temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
af19b491
AKS		 2149
2150 temp_state = qlcnic_get_temp_state(temp);
2151 temp_val = qlcnic_get_temp_val(temp);
2152
2153 if (temp_state == QLCNIC_TEMP_PANIC) {
2154 dev_err(&netdev->dev,
2155 "Device temperature %d degrees C exceeds"
2156 " maximum allowed. Hardware has been shut down.\n",
2157 temp_val);
2158 rv = 1;
2159 } else if (temp_state == QLCNIC_TEMP_WARN) {
79788450 2160 if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
af19b491
AKS		 2161 dev_err(&netdev->dev,
2162 "Device temperature %d degrees C "
2163 "exceeds operating range."
2164 " Immediate action needed.\n",
2165 temp_val);
2166 }
2167 } else {
79788450 2168 if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
af19b491
AKS		 2169 dev_info(&netdev->dev,
2170 "Device temperature is now %d degrees C"
2171 " in normal range.\n", temp_val);
2172 }
2173 }
79788450 2174 adapter->ahw->temp = temp_state;
af19b491
AKS		 2175 return rv;
2176}
2177
af19b491
AKS		 2178static void qlcnic_tx_timeout(struct net_device *netdev)
2179{
2180 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2181
2182 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2183 return;
2184
2185 dev_err(&netdev->dev, "transmit timeout, resetting.\n");
af19b491
AKS		 2186
2187 if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS)
68bf1c68
AKS		 2188 adapter->need_fw_reset = 1;
2189 else
79788450 2190 adapter->ahw->reset_context = 1;
af19b491
AKS		 2191}
2192
2193static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
2194{
2195 struct qlcnic_adapter *adapter = netdev_priv(netdev);
2196 struct net_device_stats *stats = &netdev->stats;
2197
af19b491
AKS		 2198 stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2199 stats->tx_packets = adapter->stats.xmitfinished;
7e382594 2200 stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
af19b491
AKS		 2201 stats->tx_bytes = adapter->stats.txbytes;
2202 stats->rx_dropped = adapter->stats.rxdropped;
2203 stats->tx_dropped = adapter->stats.txdropped;
2204
2205 return stats;
2206}
2207
7e2cf4fe 2208irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
af19b491 2209{
af19b491
AKS		 2210 u32 status;
2211
2212 status = readl(adapter->isr_int_vec);
2213
79788450 2214 if (!(status & adapter->ahw->int_vec_bit))
af19b491
AKS		 2215 return IRQ_NONE;
2216
2217 /* check interrupt state machine, to be sure */
2218 status = readl(adapter->crb_int_state_reg);
2219 if (!ISR_LEGACY_INT_TRIGGERED(status))
2220 return IRQ_NONE;
2221
2222 writel(0xffffffff, adapter->tgt_status_reg);
2223 /* read twice to ensure write is flushed */
2224 readl(adapter->isr_int_vec);
2225 readl(adapter->isr_int_vec);
2226
7eb9855d
AKS		 2227 return IRQ_HANDLED;
2228}
2229
2230static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
2231{
2232 struct qlcnic_host_sds_ring *sds_ring = data;
2233 struct qlcnic_adapter *adapter = sds_ring->adapter;
2234
2235 if (adapter->flags & QLCNIC_MSIX_ENABLED)
2236 goto done;
2237 else if (adapter->flags & QLCNIC_MSI_ENABLED) {
2238 writel(0xffffffff, adapter->tgt_status_reg);
2239 goto done;
2240 }
2241
2242 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2243 return IRQ_NONE;
2244
2245done:
79788450 2246 adapter->ahw->diag_cnt++;
7eb9855d
AKS		 2247 qlcnic_enable_int(sds_ring);
2248 return IRQ_HANDLED;
2249}
2250
2251static irqreturn_t qlcnic_intr(int irq, void *data)
2252{
2253 struct qlcnic_host_sds_ring *sds_ring = data;
2254 struct qlcnic_adapter *adapter = sds_ring->adapter;
2255
2256 if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
2257 return IRQ_NONE;
2258
af19b491
AKS		 2259 napi_schedule(&sds_ring->napi);
2260
2261 return IRQ_HANDLED;
2262}
2263
2264static irqreturn_t qlcnic_msi_intr(int irq, void *data)
2265{
2266 struct qlcnic_host_sds_ring *sds_ring = data;
2267 struct qlcnic_adapter *adapter = sds_ring->adapter;
2268
2269 /* clear interrupt */
2270 writel(0xffffffff, adapter->tgt_status_reg);
2271
2272 napi_schedule(&sds_ring->napi);
2273 return IRQ_HANDLED;
2274}
2275
2276static irqreturn_t qlcnic_msix_intr(int irq, void *data)
2277{
2278 struct qlcnic_host_sds_ring *sds_ring = data;
2279
2280 napi_schedule(&sds_ring->napi);
2281 return IRQ_HANDLED;
2282}
2283
13159183
SC		 2284static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data)
2285{
2286 struct qlcnic_host_tx_ring *tx_ring = data;
2287
2288 napi_schedule(&tx_ring->napi);
2289 return IRQ_HANDLED;
2290}
2291
af19b491
AKS		 2292#ifdef CONFIG_NET_POLL_CONTROLLER
2293static void qlcnic_poll_controller(struct net_device *netdev)
2294{
bf82791e
YL		 2295 int ring;
2296 struct qlcnic_host_sds_ring *sds_ring;
af19b491 2297 struct qlcnic_adapter *adapter = netdev_priv(netdev);
b1fc6d3c 2298 struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
bf82791e 2299
af19b491 2300 disable_irq(adapter->irq);
bf82791e
YL		 2301 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
2302 sds_ring = &recv_ctx->sds_rings[ring];
2303 qlcnic_intr(adapter->irq, sds_ring);
2304 }
af19b491
AKS		 2305 enable_irq(adapter->irq);
2306}
2307#endif
2308
6df900e9
SC		 2309static void
2310qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
2311{
2312 u32 val;
2313
2314 val = adapter->portnum & 0xf;
2315 val |= encoding << 7;
2316 val |= (jiffies - adapter->dev_rst_time) << 8;
2317
a15ebd37 2318 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
6df900e9
SC		 2319 adapter->dev_rst_time = jiffies;
2320}
2321
ade91f8e
AKS		 2322static int
2323qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
af19b491
AKS		 2324{
2325 u32 val;
2326
2327 WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
2328 state != QLCNIC_DEV_NEED_QUISCENT);
2329
2330 if (qlcnic_api_lock(adapter))
ade91f8e 2331 return -EIO;
af19b491 2332
a15ebd37 2333 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
af19b491
AKS		 2334
2335 if (state == QLCNIC_DEV_NEED_RESET)
6d2a4724 2336 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
af19b491 2337 else if (state == QLCNIC_DEV_NEED_QUISCENT)
6d2a4724 2338 QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
af19b491 2339
a15ebd37 2340 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 2341
2342 qlcnic_api_unlock(adapter);
ade91f8e
AKS		 2343
2344 return 0;
af19b491
AKS		 2345}
2346
1b95a839
AKS		 2347static int
2348qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
2349{
2350 u32 val;
2351
2352 if (qlcnic_api_lock(adapter))
2353 return -EBUSY;
2354
a15ebd37 2355 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2356 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
a15ebd37 2357 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
1b95a839
AKS		 2358
2359 qlcnic_api_unlock(adapter);
2360
2361 return 0;
2362}
2363
af19b491 2364static void
21854f02 2365qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
af19b491
AKS		 2366{
2367 u32 val;
2368
2369 if (qlcnic_api_lock(adapter))
2370 goto err;
2371
a15ebd37 2372 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
6d2a4724 2373 QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
a15ebd37 2374 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
af19b491 2375
21854f02 2376 if (failed) {
a15ebd37
HM		 2377 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2378 QLCNIC_DEV_FAILED);
21854f02
AKS		 2379 dev_info(&adapter->pdev->dev,
2380 "Device state set to Failed. Please Reboot\n");
2381 } else if (!(val & 0x11111111))
a15ebd37
HM		 2382 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2383 QLCNIC_DEV_COLD);
af19b491 2384
a15ebd37 2385 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2386 QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
a15ebd37 2387 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 2388
2389 qlcnic_api_unlock(adapter);
2390err:
2391 adapter->fw_fail_cnt = 0;
032a13c7 2392 adapter->flags &= ~QLCNIC_FW_HANG;
af19b491
AKS		 2393 clear_bit(__QLCNIC_START_FW, &adapter->state);
2394 clear_bit(__QLCNIC_RESETTING, &adapter->state);
2395}
2396
f73dfc50 2397/* Grab api lock, before checking state */
af19b491
AKS		 2398static int
2399qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
2400{
602ca6f0 2401 int act, state, active_mask;
a15ebd37 2402 struct qlcnic_hardware_context *ahw = adapter->ahw;
af19b491 2403
a15ebd37
HM		 2404 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2405 act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
af19b491 2406
602ca6f0 2407 if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
a15ebd37 2408 active_mask = (~(1 << (ahw->pci_func * 4)));
602ca6f0
SV		 2409 act = act & active_mask;
2410 }
2411
af19b491
AKS		 2412 if (((state & 0x11111111) == (act & 0x11111111)) ||
2413 ((act & 0x11111111) == ((state >> 1) & 0x11111111)))
2414 return 0;
2415 else
2416 return 1;
2417}
2418
96f8118c
SC		 2419static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
2420{
a15ebd37 2421 u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
96f8118c
SC		 2422
2423 if (val != QLCNIC_DRV_IDC_VER) {
2424 dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
2425 " idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
2426 }
2427
2428 return 0;
2429}
2430
af19b491
AKS		 2431static int
2432qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
2433{
2434 u32 val, prev_state;
aa5e18c0 2435 u8 dev_init_timeo = adapter->dev_init_timeo;
6d2a4724 2436 u8 portnum = adapter->portnum;
96f8118c 2437 u8 ret;
af19b491 2438
f73dfc50
AKS		 2439 if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
2440 return 1;
2441
af19b491
AKS		 2442 if (qlcnic_api_lock(adapter))
2443 return -1;
2444
a15ebd37 2445 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
6d2a4724
AKS		 2446 if (!(val & (1 << (portnum * 4)))) {
2447 QLC_DEV_SET_REF_CNT(val, portnum);
a15ebd37 2448 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
af19b491
AKS		 2449 }
2450
a15ebd37 2451 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
65b5b420 2452 QLCDB(adapter, HW, "Device state = %u\n", prev_state);
af19b491
AKS		 2453
2454 switch (prev_state) {
2455 case QLCNIC_DEV_COLD:
a15ebd37
HM		 2456 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2457 QLCNIC_DEV_INITIALIZING);
2458 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
2459 QLCNIC_DRV_IDC_VER);
6df900e9 2460 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 2461 qlcnic_api_unlock(adapter);
2462 return 1;
2463
2464 case QLCNIC_DEV_READY:
96f8118c 2465 ret = qlcnic_check_idc_ver(adapter);
af19b491 2466 qlcnic_api_unlock(adapter);
96f8118c 2467 return ret;
af19b491
AKS		 2468
2469 case QLCNIC_DEV_NEED_RESET:
a15ebd37 2470 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2471 QLC_DEV_SET_RST_RDY(val, portnum);
a15ebd37 2472 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 2473 break;
2474
2475 case QLCNIC_DEV_NEED_QUISCENT:
a15ebd37 2476 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2477 QLC_DEV_SET_QSCNT_RDY(val, portnum);
a15ebd37 2478 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 2479 break;
2480
2481 case QLCNIC_DEV_FAILED:
a7fc948f 2482 dev_err(&adapter->pdev->dev, "Device in failed state.\n");
af19b491
AKS		 2483 qlcnic_api_unlock(adapter);
2484 return -1;
bbd8c6a4
AKS		 2485
2486 case QLCNIC_DEV_INITIALIZING:
2487 case QLCNIC_DEV_QUISCENT:
2488 break;
af19b491
AKS		 2489 }
2490
2491 qlcnic_api_unlock(adapter);
aa5e18c0
SC		 2492
2493 do {
af19b491 2494 msleep(1000);
a15ebd37 2495 prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
a5e463d0
SC		 2496
2497 if (prev_state == QLCNIC_DEV_QUISCENT)
2498 continue;
2499 } while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
af19b491 2500
65b5b420
AKS		 2501 if (!dev_init_timeo) {
2502 dev_err(&adapter->pdev->dev,
2503 "Waiting for device to initialize timeout\n");
af19b491 2504 return -1;
65b5b420 2505 }
af19b491
AKS		 2506
2507 if (qlcnic_api_lock(adapter))
2508 return -1;
2509
a15ebd37 2510 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
6d2a4724 2511 QLC_DEV_CLR_RST_QSCNT(val, portnum);
a15ebd37 2512 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
af19b491 2513
96f8118c 2514 ret = qlcnic_check_idc_ver(adapter);
af19b491
AKS		 2515 qlcnic_api_unlock(adapter);
2516
96f8118c 2517 return ret;
af19b491
AKS		 2518}
2519
2520static void
2521qlcnic_fwinit_work(struct work_struct *work)
2522{
2523 struct qlcnic_adapter *adapter = container_of(work,
2524 struct qlcnic_adapter, fw_work.work);
3c4b23b1 2525 u32 dev_state = 0xf;
7b749ff4 2526 u32 val;
af19b491 2527
f73dfc50
AKS		 2528 if (qlcnic_api_lock(adapter))
2529 goto err_ret;
af19b491 2530
a15ebd37 2531 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
b8c17620
AKS		 2532 if (dev_state == QLCNIC_DEV_QUISCENT ||
2533 dev_state == QLCNIC_DEV_NEED_QUISCENT) {
a5e463d0
SC		 2534 qlcnic_api_unlock(adapter);
2535 qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
2536 FW_POLL_DELAY * 2);
2537 return;
2538 }
2539
79788450 2540 if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
3c4b23b1
AKS		 2541 qlcnic_api_unlock(adapter);
2542 goto wait_npar;
9f26f547
AC		 2543 }
2544
16e3cf73
SV		 2545 if (dev_state == QLCNIC_DEV_INITIALIZING ||
2546 dev_state == QLCNIC_DEV_READY) {
2547 dev_info(&adapter->pdev->dev, "Detected state change from "
2548 "DEV_NEED_RESET, skipping ack check\n");
2549 goto skip_ack_check;
2550 }
2551
f73dfc50 2552 if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
16e3cf73 2553 dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
f73dfc50
AKS		 2554 adapter->reset_ack_timeo);
2555 goto skip_ack_check;
2556 }
2557
2558 if (!qlcnic_check_drv_state(adapter)) {
2559skip_ack_check:
a15ebd37 2560 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
a5e463d0 2561
f73dfc50 2562 if (dev_state == QLCNIC_DEV_NEED_RESET) {
a15ebd37
HM		 2563 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2564 QLCNIC_DEV_INITIALIZING);
f73dfc50
AKS		 2565 set_bit(__QLCNIC_START_FW, &adapter->state);
2566 QLCDB(adapter, DRV, "Restarting fw\n");
6df900e9 2567 qlcnic_idc_debug_info(adapter, 0);
a15ebd37
HM		 2568 val = QLC_SHARED_REG_RD32(adapter,
2569 QLCNIC_CRB_DRV_STATE);
7b749ff4 2570 QLC_DEV_SET_RST_RDY(val, adapter->portnum);
a15ebd37
HM		 2571 QLC_SHARED_REG_WR32(adapter,
2572 QLCNIC_CRB_DRV_STATE, val);
af19b491
AKS		 2573 }
2574
f73dfc50
AKS		 2575 qlcnic_api_unlock(adapter);
2576
287e38aa 2577 rtnl_lock();
7b749ff4
SV		 2578 if (adapter->ahw->fw_dump.enable &&
2579 (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
9d6a6440
AC		 2580 QLCDB(adapter, DRV, "Take FW dump\n");
2581 qlcnic_dump_fw(adapter);
032a13c7 2582 adapter->flags |= QLCNIC_FW_HANG;
9d6a6440 2583 }
287e38aa 2584 rtnl_unlock();
7b749ff4
SV		 2585
2586 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
9f26f547 2587 if (!adapter->nic_ops->start_firmware(adapter)) {
af19b491 2588 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
b18971d1 2589 adapter->fw_wait_cnt = 0;
af19b491
AKS		 2590 return;
2591 }
af19b491
AKS		 2592 goto err_ret;
2593 }
2594
f73dfc50 2595 qlcnic_api_unlock(adapter);
aa5e18c0 2596
9f26f547 2597wait_npar:
a15ebd37 2598 dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
f73dfc50 2599 QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
65b5b420 2600
af19b491 2601 switch (dev_state) {
3c4b23b1 2602 case QLCNIC_DEV_READY:
7e2cf4fe 2603 if (!qlcnic_start_firmware(adapter)) {
f73dfc50 2604 qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
b18971d1 2605 adapter->fw_wait_cnt = 0;
f73dfc50
AKS		 2606 return;
2607 }
3c4b23b1
AKS		 2608 case QLCNIC_DEV_FAILED:
2609 break;
2610 default:
2611 qlcnic_schedule_work(adapter,
2612 qlcnic_fwinit_work, FW_POLL_DELAY);
2613 return;
af19b491
AKS		 2614 }
2615
2616err_ret:
f73dfc50
AKS		 2617 dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
2618 "fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
34ce3626 2619 netif_device_attach(adapter->netdev);
21854f02 2620 qlcnic_clr_all_drv_state(adapter, 0);
af19b491
AKS		 2621}
2622
2623static void
2624qlcnic_detach_work(struct work_struct *work)
2625{
2626 struct qlcnic_adapter *adapter = container_of(work,
2627 struct qlcnic_adapter, fw_work.work);
2628 struct net_device *netdev = adapter->netdev;
2629 u32 status;
2630
2631 netif_device_detach(netdev);
2632
b8c17620
AKS		 2633 /* Dont grab rtnl lock during Quiscent mode */
2634 if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2635 if (netif_running(netdev))
2636 __qlcnic_down(adapter, netdev);
2637 } else
2638 qlcnic_down(adapter, netdev);
af19b491 2639
a15ebd37 2640 status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
af19b491 2641
44f65b29
SC		 2642 if (status & QLCNIC_RCODE_FATAL_ERROR) {
2643 dev_err(&adapter->pdev->dev,
2644 "Detaching the device: peg halt status1=0x%x\n",
2645 status);
2646
2647 if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
2648 dev_err(&adapter->pdev->dev,
2649 "On board active cooling fan failed. "
2650 "Device has been halted.\n");
2651 dev_err(&adapter->pdev->dev,
2652 "Replace the adapter.\n");
2653 }
2654
af19b491 2655 goto err_ret;
44f65b29 2656 }
af19b491 2657
79788450 2658 if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
44f65b29 2659 dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
79788450 2660 adapter->ahw->temp);
af19b491 2661 goto err_ret;
44f65b29
SC		 2662 }
2663
602ca6f0
SV		 2664 /* Dont ack if this instance is the reset owner */
2665 if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
44f65b29
SC		 2666 if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
2667 dev_err(&adapter->pdev->dev,
2668 "Failed to set driver state,"
2669 "detaching the device.\n");
602ca6f0 2670 goto err_ret;
44f65b29 2671 }
602ca6f0 2672 }
af19b491
AKS		 2673
2674 adapter->fw_wait_cnt = 0;
2675
2676 qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
2677
2678 return;
2679
2680err_ret:
34ce3626 2681 netif_device_attach(netdev);
21854f02 2682 qlcnic_clr_all_drv_state(adapter, 1);
af19b491
AKS		 2683}
2684
3c4b23b1
AKS		 2685/*Transit NPAR state to NON Operational */
2686static void
2687qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
2688{
2689 u32 state;
2690
a15ebd37 2691 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3c4b23b1
AKS		 2692 if (state == QLCNIC_DEV_NPAR_NON_OPER)
2693 return;
2694
2695 if (qlcnic_api_lock(adapter))
2696 return;
a15ebd37
HM		 2697 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2698 QLCNIC_DEV_NPAR_NON_OPER);
3c4b23b1
AKS		 2699 qlcnic_api_unlock(adapter);
2700}
2701
7e2cf4fe 2702void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter, u32 key)
af19b491 2703{
646779f1
SV		 2704 u32 state, xg_val = 0, gb_val = 0;
2705
2706 qlcnic_xg_set_xg0_mask(xg_val);
2707 qlcnic_xg_set_xg1_mask(xg_val);
2708 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
2709 qlcnic_gb_set_gb0_mask(gb_val);
2710 qlcnic_gb_set_gb1_mask(gb_val);
2711 qlcnic_gb_set_gb2_mask(gb_val);
2712 qlcnic_gb_set_gb3_mask(gb_val);
2713 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
2714 dev_info(&adapter->pdev->dev, "Pause control frames disabled"
2715 " on all ports\n");
cea8975e 2716 adapter->need_fw_reset = 1;
13159183 2717
af19b491
AKS		 2718 if (qlcnic_api_lock(adapter))
2719 return;
2720
13159183 2721 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
af19b491 2722
f73dfc50 2723 if (state == QLCNIC_DEV_READY) {
13159183
SC		 2724 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2725 QLCNIC_DEV_NEED_RESET);
602ca6f0 2726 adapter->flags |= QLCNIC_FW_RESET_OWNER;
65b5b420 2727 QLCDB(adapter, DRV, "NEED_RESET state set\n");
6df900e9 2728 qlcnic_idc_debug_info(adapter, 0);
af19b491
AKS		 2729 }
2730
13159183
SC		 2731 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2732 QLCNIC_DEV_NPAR_NON_OPER);
af19b491
AKS		 2733 qlcnic_api_unlock(adapter);
2734}
2735
9f26f547
AC		 2736/* Transit to NPAR READY state from NPAR NOT READY state */
2737static void
2738qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
2739{
9f26f547
AC		 2740 if (qlcnic_api_lock(adapter))
2741 return;
2742
a15ebd37
HM		 2743 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
2744 QLCNIC_DEV_NPAR_OPER);
3c4b23b1 2745 QLCDB(adapter, DRV, "NPAR operational state set\n");
9f26f547
AC		 2746
2747 qlcnic_api_unlock(adapter);
2748}
2749
13159183
SC		 2750void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
2751 work_func_t func, int delay)
af19b491 2752{
451724c8
SC		 2753 if (test_bit(__QLCNIC_AER, &adapter->state))
2754 return;
2755
af19b491 2756 INIT_DELAYED_WORK(&adapter->fw_work, func);
13159183
SC		 2757 queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
2758 round_jiffies_relative(delay));
af19b491
AKS		 2759}
2760
2761static void
2762qlcnic_attach_work(struct work_struct *work)
2763{
2764 struct qlcnic_adapter *adapter = container_of(work,
2765 struct qlcnic_adapter, fw_work.work);
2766 struct net_device *netdev = adapter->netdev;
b18971d1 2767 u32 npar_state;
af19b491 2768
79788450 2769 if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
a15ebd37
HM		 2770 npar_state = QLC_SHARED_REG_RD32(adapter,
2771 QLCNIC_CRB_DEV_NPAR_STATE);
b18971d1
AKS		 2772 if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
2773 qlcnic_clr_all_drv_state(adapter, 0);
2774 else if (npar_state != QLCNIC_DEV_NPAR_OPER)
2775 qlcnic_schedule_work(adapter, qlcnic_attach_work,
2776 FW_POLL_DELAY);
2777 else
2778 goto attach;
2779 QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
2780 return;
2781 }
2782attach:
af19b491 2783 if (netif_running(netdev)) {
52486a3a 2784 if (qlcnic_up(adapter, netdev))
af19b491 2785 goto done;
af19b491 2786
aec1e845 2787 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
af19b491
AKS		 2788 }
2789
af19b491 2790done:
34ce3626 2791 netif_device_attach(netdev);
af19b491 2792 adapter->fw_fail_cnt = 0;
032a13c7 2793 adapter->flags &= ~QLCNIC_FW_HANG;
af19b491 2794 clear_bit(__QLCNIC_RESETTING, &adapter->state);
1b95a839
AKS		 2795
2796 if (!qlcnic_clr_drv_state(adapter))
2797 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2798 FW_POLL_DELAY);
af19b491
AKS		 2799}
2800
2801static int
2802qlcnic_check_health(struct qlcnic_adapter *adapter)
2803{
4e70812b 2804 u32 state = 0, heartbeat;
853d4bca 2805 u32 peg_status;
af19b491
AKS		 2806
2807 if (qlcnic_check_temp(adapter))
2808 goto detach;
2809
2372a5f1 2810 if (adapter->need_fw_reset)
7e2cf4fe 2811 qlcnic_dev_request_reset(adapter, 0);
af19b491 2812
a15ebd37 2813 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
b8c17620 2814 if (state == QLCNIC_DEV_NEED_RESET) {
3c4b23b1 2815 qlcnic_set_npar_non_operational(adapter);
af19b491 2816 adapter->need_fw_reset = 1;
b8c17620
AKS		 2817 } else if (state == QLCNIC_DEV_NEED_QUISCENT)
2818 goto detach;
af19b491 2819
a15ebd37 2820 heartbeat = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
4e70812b
SC		 2821 if (heartbeat != adapter->heartbeat) {
2822 adapter->heartbeat = heartbeat;
af19b491
AKS		 2823 adapter->fw_fail_cnt = 0;
2824 if (adapter->need_fw_reset)
2825 goto detach;
68bf1c68 2826
099f7aa7 2827 if (adapter->ahw->reset_context && qlcnic_auto_fw_reset) {
68bf1c68
AKS		 2828 qlcnic_reset_hw_context(adapter);
2829 adapter->netdev->trans_start = jiffies;
2830 }
2831
af19b491
AKS		 2832 return 0;
2833 }
2834
2835 if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2836 return 0;
2837
032a13c7
SV		 2838 adapter->flags |= QLCNIC_FW_HANG;
2839
7e2cf4fe 2840 qlcnic_dev_request_reset(adapter, 0);
af19b491 2841
099f7aa7 2842 if (qlcnic_auto_fw_reset)
0df170b6 2843 clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
af19b491 2844
853d4bca 2845 dev_err(&adapter->pdev->dev, "firmware hang detected\n");
a15ebd37 2846 peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
853d4bca 2847 dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
c76ecb7a
SV		 2848 "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
2849 "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
2850 "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
2851 "PEG_NET_4_PC: 0x%x\n",
a15ebd37
HM		 2852 peg_status,
2853 QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
c76ecb7a
SV		 2854 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c),
2855 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c),
2856 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c),
2857 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c),
2858 QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c));
97048a1f 2859 if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
853d4bca
AR		 2860 dev_err(&adapter->pdev->dev,
2861 "Firmware aborted with error code 0x00006700. "
2862 "Device is being reset.\n");
af19b491
AKS		 2863detach:
2864 adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
2865 QLCNIC_DEV_NEED_RESET;
2866
099f7aa7
SC		 2867 if (qlcnic_auto_fw_reset && !test_and_set_bit(__QLCNIC_RESETTING,
2868 &adapter->state)) {
65b5b420 2869
af19b491 2870 qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
65b5b420
AKS		 2871 QLCDB(adapter, DRV, "fw recovery scheduled.\n");
2872 }
af19b491
AKS		 2873
2874 return 1;
2875}
2876
2877static void
2878qlcnic_fw_poll_work(struct work_struct *work)
2879{
2880 struct qlcnic_adapter *adapter = container_of(work,
2881 struct qlcnic_adapter, fw_work.work);
2882
2883 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
2884 goto reschedule;
2885
2886
2887 if (qlcnic_check_health(adapter))
2888 return;
2889
b5e5492c
AKS		 2890 if (adapter->fhash.fnum)
2891 qlcnic_prune_lb_filters(adapter);
2892
af19b491
AKS		 2893reschedule:
2894 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
2895}
2896
13159183
SC		 2897struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
2898 unsigned int devfn)
2899{
2900 struct pci_dev *dev = NULL;
2901
2902 while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
2903 if (pci_domain_nr(dev->bus) == domain &&
2904 (dev->bus->number == bus && dev->devfn == devfn))
2905 return dev;
2906 }
2907 return NULL;
2908}
2909
451724c8
SC		 2910static int qlcnic_is_first_func(struct pci_dev *pdev)
2911{
2912 struct pci_dev *oth_pdev;
2913 int val = pdev->devfn;
2914
2915 while (val-- > 0) {
2916 oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
2917 (pdev->bus), pdev->bus->number,
2918 PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
bfc978fa
AKS		 2919 if (!oth_pdev)
2920 continue;
451724c8 2921
bfc978fa
AKS		 2922 if (oth_pdev->current_state != PCI_D3cold) {
2923 pci_dev_put(oth_pdev);
451724c8 2924 return 0;
bfc978fa
AKS		 2925 }
2926 pci_dev_put(oth_pdev);
451724c8
SC		 2927 }
2928 return 1;
2929}
2930
2931static int qlcnic_attach_func(struct pci_dev *pdev)
2932{
2933 int err, first_func;
2934 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2935 struct net_device *netdev = adapter->netdev;
2936
2937 pdev->error_state = pci_channel_io_normal;
2938
2939 err = pci_enable_device(pdev);
2940 if (err)
2941 return err;
2942
2943 pci_set_power_state(pdev, PCI_D0);
2944 pci_set_master(pdev);
2945 pci_restore_state(pdev);
2946
2947 first_func = qlcnic_is_first_func(pdev);
2948
2949 if (qlcnic_api_lock(adapter))
2950 return -EINVAL;
2951
79788450 2952 if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
451724c8
SC		 2953 adapter->need_fw_reset = 1;
2954 set_bit(__QLCNIC_START_FW, &adapter->state);
a15ebd37
HM		 2955 QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
2956 QLCNIC_DEV_INITIALIZING);
451724c8
SC		 2957 QLCDB(adapter, DRV, "Restarting fw\n");
2958 }
2959 qlcnic_api_unlock(adapter);
2960
13159183 2961 err = qlcnic_start_firmware(adapter);
451724c8
SC		 2962 if (err)
2963 return err;
2964
2965 qlcnic_clr_drv_state(adapter);
13159183
SC		 2966 kfree(adapter->msix_entries);
2967 adapter->msix_entries = NULL;
2968 err = qlcnic_setup_intr(adapter, 0);
2969
2970 if (qlcnic_83xx_check(adapter)) {
2971 err = qlcnic_83xx_setup_mbx_intr(adapter);
2972 if (err) {
2973 dev_err(&adapter->pdev->dev,
2974 "failed to setup mbx interrupt\n");
2975 qlcnic_clr_all_drv_state(adapter, 1);
2976 clear_bit(__QLCNIC_AER, &adapter->state);
2977 goto done;
2978 }
2979 }
451724c8
SC		 2980
2981 if (netif_running(netdev)) {
2982 err = qlcnic_attach(adapter);
2983 if (err) {
21854f02 2984 qlcnic_clr_all_drv_state(adapter, 1);
451724c8
SC		 2985 clear_bit(__QLCNIC_AER, &adapter->state);
2986 netif_device_attach(netdev);
2987 return err;
2988 }
2989
2990 err = qlcnic_up(adapter, netdev);
2991 if (err)
2992 goto done;
2993
aec1e845 2994 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
451724c8
SC		 2995 }
2996 done:
2997 netif_device_attach(netdev);
2998 return err;
2999}
3000
3001static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3002 pci_channel_state_t state)
3003{
3004 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3005 struct net_device *netdev = adapter->netdev;
3006
3007 if (state == pci_channel_io_perm_failure)
3008 return PCI_ERS_RESULT_DISCONNECT;
3009
3010 if (state == pci_channel_io_normal)
3011 return PCI_ERS_RESULT_RECOVERED;
3012
3013 set_bit(__QLCNIC_AER, &adapter->state);
3014 netif_device_detach(netdev);
3015
3016 cancel_delayed_work_sync(&adapter->fw_work);
3017
3018 if (netif_running(netdev))
3019 qlcnic_down(adapter, netdev);
3020
13159183
SC		 3021 if (qlcnic_83xx_check(adapter)) {
3022 if (adapter->flags & QLCNIC_MSIX_ENABLED)
3023 qlcnic_83xx_config_intrpt(adapter, 0);
3024 qlcnic_83xx_free_mbx_intr(adapter);
3025 }
3026
451724c8
SC		 3027 qlcnic_detach(adapter);
3028 qlcnic_teardown_intr(adapter);
3029
3030 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3031
3032 pci_save_state(pdev);
3033 pci_disable_device(pdev);
3034
3035 return PCI_ERS_RESULT_NEED_RESET;
3036}
3037
3038static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3039{
3040 return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3041 PCI_ERS_RESULT_RECOVERED;
3042}
3043
3044static void qlcnic_io_resume(struct pci_dev *pdev)
3045{
a15ebd37 3046 u32 state;
451724c8
SC		 3047 struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3048
3049 pci_cleanup_aer_uncorrect_error_status(pdev);
a15ebd37
HM		 3050 state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3051 if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
3052 &adapter->state))
451724c8
SC		 3053 qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3054 FW_POLL_DELAY);
3055}
3056
87eb743b
AC		 3057static int
3058qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3059{
3060 int err;
3061
3062 err = qlcnic_can_start_firmware(adapter);
3063 if (err)
3064 return err;
3065
78f84e1a
AKS		 3066 err = qlcnic_check_npar_opertional(adapter);
3067 if (err)
3068 return err;
3c4b23b1 3069
174240a8
RB		 3070 err = qlcnic_initialize_nic(adapter);
3071 if (err)
3072 return err;
3073
87eb743b
AC		 3074 qlcnic_check_options(adapter);
3075
7373373d
RB		 3076 err = qlcnic_set_eswitch_port_config(adapter);
3077 if (err)
3078 return err;
3079
87eb743b
AC		 3080 adapter->need_fw_reset = 0;
3081
3082 return err;
3083}
3084
319ecf12 3085int qlcnic_validate_max_rss(u8 max_hw, u8 val)
f94bc1e7 3086{
319ecf12
SC		 3087 u32 max_allowed;
3088
3089 if (max_hw > QLC_MAX_SDS_RINGS) {
3090 max_hw = QLC_MAX_SDS_RINGS;
3091 pr_info("max rss reset to %d\n", QLC_MAX_SDS_RINGS);
f94bc1e7
SC		 3092 }
3093
319ecf12
SC		 3094 max_allowed = rounddown_pow_of_two(min_t(int, max_hw,
3095 num_online_cpus()));
3096 if ((val > max_allowed) || (val < 2) || !is_power_of_2(val)) {
3097 pr_info("rss_ring valid range [2 - %x] in powers of 2\n",
3098 max_allowed);
f94bc1e7
SC		 3099 return -EINVAL;
3100 }
3101 return 0;
f94bc1e7
SC		 3102}
3103
319ecf12 3104int qlcnic_set_max_rss(struct qlcnic_adapter *adapter, u8 data, size_t len)
f94bc1e7 3105{
13159183 3106 int err;
f94bc1e7 3107 struct net_device *netdev = adapter->netdev;
f94bc1e7 3108
319ecf12
SC		 3109 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3110 return -EBUSY;
3111
f94bc1e7
SC		 3112 netif_device_detach(netdev);
3113 if (netif_running(netdev))
3114 __qlcnic_down(adapter, netdev);
13159183 3115
319ecf12 3116 if (qlcnic_82xx_check(adapter)) {
13159183
SC		 3117 if (adapter->flags & QLCNIC_MSIX_ENABLED)
3118 qlcnic_83xx_config_intrpt(adapter, 0);
3119 qlcnic_83xx_free_mbx_intr(adapter);
3120 }
3121
f94bc1e7
SC		 3122 qlcnic_detach(adapter);
3123 qlcnic_teardown_intr(adapter);
319ecf12 3124 err = qlcnic_setup_intr(adapter, data);
13159183
SC		 3125 if (err)
3126 dev_err(&adapter->pdev->dev,
3127 "failed setting max_rss; rss disabled\n");
f94bc1e7 3128
13159183
SC		 3129 if (qlcnic_83xx_check(adapter)) {
3130 err = qlcnic_83xx_setup_mbx_intr(adapter);
3131 if (err) {
3132 dev_err(&adapter->pdev->dev,
3133 "failed to setup mbx interrupt\n");
3134 goto done;
3135 }
f94bc1e7
SC		 3136 }
3137
3138 if (netif_running(netdev)) {
3139 err = qlcnic_attach(adapter);
3140 if (err)
3141 goto done;
3142 err = __qlcnic_up(adapter, netdev);
3143 if (err)
3144 goto done;
3145 qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3146 }
319ecf12 3147 err = len;
f94bc1e7
SC		 3148 done:
3149 netif_device_attach(netdev);
3150 clear_bit(__QLCNIC_RESETTING, &adapter->state);
3151 return err;
3152}
3153
af19b491
AKS		 3154#ifdef CONFIG_INET
3155
3156#define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
3157
af19b491 3158static void
aec1e845
AKS		 3159qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
3160 struct net_device *dev, unsigned long event)
af19b491
AKS		 3161{
3162 struct in_device *indev;
af19b491 3163
af19b491
AKS		 3164 indev = in_dev_get(dev);
3165 if (!indev)
3166 return;
3167
3168 for_ifa(indev) {
3169 switch (event) {
3170 case NETDEV_UP:
3171 qlcnic_config_ipaddr(adapter,
3172 ifa->ifa_address, QLCNIC_IP_UP);
3173 break;
3174 case NETDEV_DOWN:
3175 qlcnic_config_ipaddr(adapter,
3176 ifa->ifa_address, QLCNIC_IP_DOWN);
3177 break;
3178 default:
3179 break;
3180 }
3181 } endfor_ifa(indev);
3182
3183 in_dev_put(indev);
af19b491
AKS		 3184}
3185
319ecf12 3186void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
aec1e845
AKS		 3187{
3188 struct qlcnic_adapter *adapter = netdev_priv(netdev);
3189 struct net_device *dev;
3190 u16 vid;
3191
3192 qlcnic_config_indev_addr(adapter, netdev, event);
3193
b9796a14 3194 for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
223bb15e 3195 dev = __vlan_find_dev_deep(netdev, vid);
aec1e845
AKS		 3196 if (!dev)
3197 continue;
aec1e845
AKS		 3198 qlcnic_config_indev_addr(adapter, dev, event);
3199 }
3200}
3201
af19b491
AKS		 3202static int qlcnic_netdev_event(struct notifier_block *this,
3203 unsigned long event, void *ptr)
3204{
3205 struct qlcnic_adapter *adapter;
3206 struct net_device *dev = (struct net_device *)ptr;
3207
3208recheck:
3209 if (dev == NULL)
3210 goto done;
3211
3212 if (dev->priv_flags & IFF_802_1Q_VLAN) {
3213 dev = vlan_dev_real_dev(dev);
3214 goto recheck;
3215 }
3216
3217 if (!is_qlcnic_netdev(dev))
3218 goto done;
3219
3220 adapter = netdev_priv(dev);
3221
3222 if (!adapter)
3223 goto done;
3224
8a15ad1f 3225 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
af19b491
AKS		 3226 goto done;
3227
aec1e845 3228 qlcnic_config_indev_addr(adapter, dev, event);
af19b491
AKS		 3229done:
3230 return NOTIFY_DONE;
3231}
3232
3233static int
3234qlcnic_inetaddr_event(struct notifier_block *this,
3235 unsigned long event, void *ptr)
3236{
3237 struct qlcnic_adapter *adapter;
3238 struct net_device *dev;
3239
3240 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3241
3242 dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
3243
3244recheck:
aec1e845 3245 if (dev == NULL)
af19b491
AKS		 3246 goto done;
3247
3248 if (dev->priv_flags & IFF_802_1Q_VLAN) {
3249 dev = vlan_dev_real_dev(dev);
3250 goto recheck;
3251 }
3252
3253 if (!is_qlcnic_netdev(dev))
3254 goto done;
3255
3256 adapter = netdev_priv(dev);
3257
251a84c9 3258 if (!adapter)
af19b491
AKS		 3259 goto done;
3260
8a15ad1f 3261 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
af19b491
AKS		 3262 goto done;
3263
3264 switch (event) {
3265 case NETDEV_UP:
3266 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
13159183 3267
af19b491
AKS		 3268 break;
3269 case NETDEV_DOWN:
3270 qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
13159183 3271
af19b491
AKS		 3272 break;
3273 default:
3274 break;
3275 }
3276
3277done:
3278 return NOTIFY_DONE;
3279}
3280
3281static struct notifier_block qlcnic_netdev_cb = {
3282 .notifier_call = qlcnic_netdev_event,
3283};
3284
3285static struct notifier_block qlcnic_inetaddr_cb = {
3286 .notifier_call = qlcnic_inetaddr_event,
3287};
3288#else
3289static void
aec1e845 3290qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
af19b491
AKS		 3291{ }
3292#endif
63507592 3293static struct pci_error_handlers qlcnic_err_handler = {
451724c8
SC		 3294 .error_detected = qlcnic_io_error_detected,
3295 .slot_reset = qlcnic_io_slot_reset,
3296 .resume = qlcnic_io_resume,
3297};
af19b491
AKS		 3298
3299static struct pci_driver qlcnic_driver = {
3300 .name = qlcnic_driver_name,
3301 .id_table = qlcnic_pci_tbl,
3302 .probe = qlcnic_probe,
6bb58bb0 3303 .remove = qlcnic_remove,
af19b491
AKS		 3304#ifdef CONFIG_PM
3305 .suspend = qlcnic_suspend,
3306 .resume = qlcnic_resume,
3307#endif
451724c8
SC		 3308 .shutdown = qlcnic_shutdown,
3309 .err_handler = &qlcnic_err_handler
3310
af19b491
AKS		 3311};
3312
3313static int __init qlcnic_init_module(void)
3314{
0cf3a14c 3315 int ret;
af19b491
AKS		 3316
3317 printk(KERN_INFO "%s\n", qlcnic_driver_string);
3318
3319#ifdef CONFIG_INET
3320 register_netdevice_notifier(&qlcnic_netdev_cb);
3321 register_inetaddr_notifier(&qlcnic_inetaddr_cb);
3322#endif
3323
0cf3a14c
AKS		 3324 ret = pci_register_driver(&qlcnic_driver);
3325 if (ret) {
3326#ifdef CONFIG_INET
3327 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3328 unregister_netdevice_notifier(&qlcnic_netdev_cb);
3329#endif
3330 }
af19b491 3331
0cf3a14c 3332 return ret;
af19b491
AKS		 3333}
3334
3335module_init(qlcnic_init_module);
3336
3337static void __exit qlcnic_exit_module(void)
3338{
af19b491
AKS		 3339 pci_unregister_driver(&qlcnic_driver);
3340
3341#ifdef CONFIG_INET
3342 unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
3343 unregister_netdevice_notifier(&qlcnic_netdev_cb);
3344#endif
3345}
3346
3347module_exit(qlcnic_exit_module);
Linux kernel - Deliverables
This page took 0.655059 seconds and 5 git commands to generate.