aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/benet/be_main.c
diff options
context:
space:
mode:
authorGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
committerGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
commitc71c03bda1e86c9d5198c5d83f712e695c4f2a1e (patch)
treeecb166cb3e2b7e2adb3b5e292245fefd23381ac8 /drivers/net/benet/be_main.c
parentea53c912f8a86a8567697115b6a0d8152beee5c8 (diff)
parent6a00f206debf8a5c8899055726ad127dbeeed098 (diff)
Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp
Conflicts: litmus/sched_cedf.c
Diffstat (limited to 'drivers/net/benet/be_main.c')
-rw-r--r--drivers/net/benet/be_main.c1897
1 files changed, 1277 insertions, 620 deletions
diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c
index 6eda7a022256..a485f7fdaf37 100644
--- a/drivers/net/benet/be_main.c
+++ b/drivers/net/benet/be_main.c
@@ -1,5 +1,5 @@
1/* 1/*
2 * Copyright (C) 2005 - 2010 ServerEngines 2 * Copyright (C) 2005 - 2011 Emulex
3 * All rights reserved. 3 * All rights reserved.
4 * 4 *
5 * This program is free software; you can redistribute it and/or 5 * This program is free software; you can redistribute it and/or
@@ -8,13 +8,14 @@
8 * Public License is included in this distribution in the file called COPYING. 8 * Public License is included in this distribution in the file called COPYING.
9 * 9 *
10 * Contact Information: 10 * Contact Information:
11 * linux-drivers@serverengines.com 11 * linux-drivers@emulex.com
12 * 12 *
13 * ServerEngines 13 * Emulex
14 * 209 N. Fair Oaks Ave 14 * 3333 Susan Street
15 * Sunnyvale, CA 94085 15 * Costa Mesa, CA 92626
16 */ 16 */
17 17
18#include <linux/prefetch.h>
18#include "be.h" 19#include "be.h"
19#include "be_cmds.h" 20#include "be_cmds.h"
20#include <asm/div64.h> 21#include <asm/div64.h>
@@ -25,18 +26,24 @@ MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
25MODULE_AUTHOR("ServerEngines Corporation"); 26MODULE_AUTHOR("ServerEngines Corporation");
26MODULE_LICENSE("GPL"); 27MODULE_LICENSE("GPL");
27 28
28static unsigned int rx_frag_size = 2048; 29static ushort rx_frag_size = 2048;
29static unsigned int num_vfs; 30static unsigned int num_vfs;
30module_param(rx_frag_size, uint, S_IRUGO); 31module_param(rx_frag_size, ushort, S_IRUGO);
31module_param(num_vfs, uint, S_IRUGO); 32module_param(num_vfs, uint, S_IRUGO);
32MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data."); 33MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
33MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize"); 34MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
34 35
36static bool multi_rxq = true;
37module_param(multi_rxq, bool, S_IRUGO | S_IWUSR);
38MODULE_PARM_DESC(multi_rxq, "Multi Rx Queue support. Enabled by default");
39
35static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = { 40static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
36 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) }, 41 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
37 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) }, 42 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
38 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) }, 43 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
39 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) }, 44 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
45 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
46 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
40 { 0 } 47 { 0 }
41}; 48};
42MODULE_DEVICE_TABLE(pci, be_dev_ids); 49MODULE_DEVICE_TABLE(pci, be_dev_ids);
@@ -115,8 +122,8 @@ static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
115{ 122{
116 struct be_dma_mem *mem = &q->dma_mem; 123 struct be_dma_mem *mem = &q->dma_mem;
117 if (mem->va) 124 if (mem->va)
118 pci_free_consistent(adapter->pdev, mem->size, 125 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
119 mem->va, mem->dma); 126 mem->dma);
120} 127}
121 128
122static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q, 129static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
@@ -128,7 +135,8 @@ static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
128 q->len = len; 135 q->len = len;
129 q->entry_size = entry_size; 136 q->entry_size = entry_size;
130 mem->size = len * entry_size; 137 mem->size = len * entry_size;
131 mem->va = pci_alloc_consistent(adapter->pdev, mem->size, &mem->dma); 138 mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
139 GFP_KERNEL);
132 if (!mem->va) 140 if (!mem->va)
133 return -1; 141 return -1;
134 memset(mem->va, 0, mem->size); 142 memset(mem->va, 0, mem->size);
@@ -179,6 +187,8 @@ static void be_eq_notify(struct be_adapter *adapter, u16 qid,
179{ 187{
180 u32 val = 0; 188 u32 val = 0;
181 val |= qid & DB_EQ_RING_ID_MASK; 189 val |= qid & DB_EQ_RING_ID_MASK;
190 val |= ((qid & DB_EQ_RING_ID_EXT_MASK) <<
191 DB_EQ_RING_ID_EXT_MASK_SHIFT);
182 192
183 if (adapter->eeh_err) 193 if (adapter->eeh_err)
184 return; 194 return;
@@ -196,6 +206,8 @@ void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
196{ 206{
197 u32 val = 0; 207 u32 val = 0;
198 val |= qid & DB_CQ_RING_ID_MASK; 208 val |= qid & DB_CQ_RING_ID_MASK;
209 val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
210 DB_CQ_RING_ID_EXT_MASK_SHIFT);
199 211
200 if (adapter->eeh_err) 212 if (adapter->eeh_err)
201 return; 213 return;
@@ -221,12 +233,13 @@ static int be_mac_addr_set(struct net_device *netdev, void *p)
221 if (!be_physfn(adapter)) 233 if (!be_physfn(adapter))
222 goto netdev_addr; 234 goto netdev_addr;
223 235
224 status = be_cmd_pmac_del(adapter, adapter->if_handle, adapter->pmac_id); 236 status = be_cmd_pmac_del(adapter, adapter->if_handle,
237 adapter->pmac_id, 0);
225 if (status) 238 if (status)
226 return status; 239 return status;
227 240
228 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data, 241 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
229 adapter->if_handle, &adapter->pmac_id); 242 adapter->if_handle, &adapter->pmac_id, 0);
230netdev_addr: 243netdev_addr:
231 if (!status) 244 if (!status)
232 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len); 245 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
@@ -234,75 +247,242 @@ netdev_addr:
234 return status; 247 return status;
235} 248}
236 249
250static void populate_be2_stats(struct be_adapter *adapter)
251{
252
253 struct be_drv_stats *drvs = &adapter->drv_stats;
254 struct be_pmem_stats *pmem_sts = be_pmem_stats_from_cmd(adapter);
255 struct be_port_rxf_stats_v0 *port_stats =
256 be_port_rxf_stats_from_cmd(adapter);
257 struct be_rxf_stats_v0 *rxf_stats =
258 be_rxf_stats_from_cmd(adapter);
259
260 drvs->rx_pause_frames = port_stats->rx_pause_frames;
261 drvs->rx_crc_errors = port_stats->rx_crc_errors;
262 drvs->rx_control_frames = port_stats->rx_control_frames;
263 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
264 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
265 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
266 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
267 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
268 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
269 drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
270 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
271 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
272 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
273 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
274 drvs->rx_input_fifo_overflow_drop =
275 port_stats->rx_input_fifo_overflow;
276 drvs->rx_dropped_header_too_small =
277 port_stats->rx_dropped_header_too_small;
278 drvs->rx_address_match_errors =
279 port_stats->rx_address_match_errors;
280 drvs->rx_alignment_symbol_errors =
281 port_stats->rx_alignment_symbol_errors;
282
283 drvs->tx_pauseframes = port_stats->tx_pauseframes;
284 drvs->tx_controlframes = port_stats->tx_controlframes;
285
286 if (adapter->port_num)
287 drvs->jabber_events =
288 rxf_stats->port1_jabber_events;
289 else
290 drvs->jabber_events =
291 rxf_stats->port0_jabber_events;
292 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
293 drvs->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
294 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
295 drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
296 drvs->forwarded_packets = rxf_stats->forwarded_packets;
297 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
298 drvs->rx_drops_no_tpre_descr =
299 rxf_stats->rx_drops_no_tpre_descr;
300 drvs->rx_drops_too_many_frags =
301 rxf_stats->rx_drops_too_many_frags;
302 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
303}
304
305static void populate_be3_stats(struct be_adapter *adapter)
306{
307 struct be_drv_stats *drvs = &adapter->drv_stats;
308 struct be_pmem_stats *pmem_sts = be_pmem_stats_from_cmd(adapter);
309
310 struct be_rxf_stats_v1 *rxf_stats =
311 be_rxf_stats_from_cmd(adapter);
312 struct be_port_rxf_stats_v1 *port_stats =
313 be_port_rxf_stats_from_cmd(adapter);
314
315 drvs->rx_priority_pause_frames = 0;
316 drvs->pmem_fifo_overflow_drop = 0;
317 drvs->rx_pause_frames = port_stats->rx_pause_frames;
318 drvs->rx_crc_errors = port_stats->rx_crc_errors;
319 drvs->rx_control_frames = port_stats->rx_control_frames;
320 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
321 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
322 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
323 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
324 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
325 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
326 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
327 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
328 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
329 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
330 drvs->rx_dropped_header_too_small =
331 port_stats->rx_dropped_header_too_small;
332 drvs->rx_input_fifo_overflow_drop =
333 port_stats->rx_input_fifo_overflow_drop;
334 drvs->rx_address_match_errors =
335 port_stats->rx_address_match_errors;
336 drvs->rx_alignment_symbol_errors =
337 port_stats->rx_alignment_symbol_errors;
338 drvs->rxpp_fifo_overflow_drop =
339 port_stats->rxpp_fifo_overflow_drop;
340 drvs->tx_pauseframes = port_stats->tx_pauseframes;
341 drvs->tx_controlframes = port_stats->tx_controlframes;
342 drvs->jabber_events = port_stats->jabber_events;
343 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
344 drvs->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
345 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
346 drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
347 drvs->forwarded_packets = rxf_stats->forwarded_packets;
348 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
349 drvs->rx_drops_no_tpre_descr =
350 rxf_stats->rx_drops_no_tpre_descr;
351 drvs->rx_drops_too_many_frags =
352 rxf_stats->rx_drops_too_many_frags;
353 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
354}
355
356static void populate_lancer_stats(struct be_adapter *adapter)
357{
358
359 struct be_drv_stats *drvs = &adapter->drv_stats;
360 struct lancer_cmd_pport_stats *pport_stats = pport_stats_from_cmd
361 (adapter);
362 drvs->rx_priority_pause_frames = 0;
363 drvs->pmem_fifo_overflow_drop = 0;
364 drvs->rx_pause_frames =
365 make_64bit_val(pport_stats->rx_pause_frames_lo,
366 pport_stats->rx_pause_frames_hi);
367 drvs->rx_crc_errors = make_64bit_val(pport_stats->rx_crc_errors_hi,
368 pport_stats->rx_crc_errors_lo);
369 drvs->rx_control_frames =
370 make_64bit_val(pport_stats->rx_control_frames_hi,
371 pport_stats->rx_control_frames_lo);
372 drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
373 drvs->rx_frame_too_long =
374 make_64bit_val(pport_stats->rx_internal_mac_errors_hi,
375 pport_stats->rx_frames_too_long_lo);
376 drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
377 drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
378 drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
379 drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
380 drvs->rx_dropped_tcp_length =
381 pport_stats->rx_dropped_invalid_tcp_length;
382 drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
383 drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
384 drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
385 drvs->rx_dropped_header_too_small =
386 pport_stats->rx_dropped_header_too_small;
387 drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
388 drvs->rx_address_match_errors = pport_stats->rx_address_match_errors;
389 drvs->rx_alignment_symbol_errors =
390 make_64bit_val(pport_stats->rx_symbol_errors_hi,
391 pport_stats->rx_symbol_errors_lo);
392 drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
393 drvs->tx_pauseframes = make_64bit_val(pport_stats->tx_pause_frames_hi,
394 pport_stats->tx_pause_frames_lo);
395 drvs->tx_controlframes =
396 make_64bit_val(pport_stats->tx_control_frames_hi,
397 pport_stats->tx_control_frames_lo);
398 drvs->jabber_events = pport_stats->rx_jabbers;
399 drvs->rx_drops_no_pbuf = 0;
400 drvs->rx_drops_no_txpb = 0;
401 drvs->rx_drops_no_erx_descr = 0;
402 drvs->rx_drops_invalid_ring = pport_stats->rx_drops_invalid_queue;
403 drvs->forwarded_packets = make_64bit_val(pport_stats->num_forwards_hi,
404 pport_stats->num_forwards_lo);
405 drvs->rx_drops_mtu = make_64bit_val(pport_stats->rx_drops_mtu_hi,
406 pport_stats->rx_drops_mtu_lo);
407 drvs->rx_drops_no_tpre_descr = 0;
408 drvs->rx_drops_too_many_frags =
409 make_64bit_val(pport_stats->rx_drops_too_many_frags_hi,
410 pport_stats->rx_drops_too_many_frags_lo);
411}
412
413void be_parse_stats(struct be_adapter *adapter)
414{
415 if (adapter->generation == BE_GEN3) {
416 if (lancer_chip(adapter))
417 populate_lancer_stats(adapter);
418 else
419 populate_be3_stats(adapter);
420 } else {
421 populate_be2_stats(adapter);
422 }
423}
424
237void netdev_stats_update(struct be_adapter *adapter) 425void netdev_stats_update(struct be_adapter *adapter)
238{ 426{
239 struct be_hw_stats *hw_stats = hw_stats_from_cmd(adapter->stats.cmd.va); 427 struct be_drv_stats *drvs = &adapter->drv_stats;
240 struct be_rxf_stats *rxf_stats = &hw_stats->rxf;
241 struct be_port_rxf_stats *port_stats =
242 &rxf_stats->port[adapter->port_num];
243 struct net_device_stats *dev_stats = &adapter->netdev->stats; 428 struct net_device_stats *dev_stats = &adapter->netdev->stats;
244 struct be_erx_stats *erx_stats = &hw_stats->erx; 429 struct be_rx_obj *rxo;
430 int i;
431
432 memset(dev_stats, 0, sizeof(*dev_stats));
433 for_all_rx_queues(adapter, rxo, i) {
434 dev_stats->rx_packets += rx_stats(rxo)->rx_pkts;
435 dev_stats->rx_bytes += rx_stats(rxo)->rx_bytes;
436 dev_stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
437 /* no space in linux buffers: best possible approximation */
438 if (adapter->generation == BE_GEN3) {
439 if (!(lancer_chip(adapter))) {
440 struct be_erx_stats_v1 *erx_stats =
441 be_erx_stats_from_cmd(adapter);
442 dev_stats->rx_dropped +=
443 erx_stats->rx_drops_no_fragments[rxo->q.id];
444 }
445 } else {
446 struct be_erx_stats_v0 *erx_stats =
447 be_erx_stats_from_cmd(adapter);
448 dev_stats->rx_dropped +=
449 erx_stats->rx_drops_no_fragments[rxo->q.id];
450 }
451 }
245 452
246 dev_stats->rx_packets = drvr_stats(adapter)->be_rx_pkts; 453 dev_stats->tx_packets = tx_stats(adapter)->be_tx_pkts;
247 dev_stats->tx_packets = drvr_stats(adapter)->be_tx_pkts; 454 dev_stats->tx_bytes = tx_stats(adapter)->be_tx_bytes;
248 dev_stats->rx_bytes = drvr_stats(adapter)->be_rx_bytes;
249 dev_stats->tx_bytes = drvr_stats(adapter)->be_tx_bytes;
250 dev_stats->multicast = drvr_stats(adapter)->be_rx_mcast_pkt;
251 455
252 /* bad pkts received */ 456 /* bad pkts received */
253 dev_stats->rx_errors = port_stats->rx_crc_errors + 457 dev_stats->rx_errors = drvs->rx_crc_errors +
254 port_stats->rx_alignment_symbol_errors + 458 drvs->rx_alignment_symbol_errors +
255 port_stats->rx_in_range_errors + 459 drvs->rx_in_range_errors +
256 port_stats->rx_out_range_errors + 460 drvs->rx_out_range_errors +
257 port_stats->rx_frame_too_long + 461 drvs->rx_frame_too_long +
258 port_stats->rx_dropped_too_small + 462 drvs->rx_dropped_too_small +
259 port_stats->rx_dropped_too_short + 463 drvs->rx_dropped_too_short +
260 port_stats->rx_dropped_header_too_small + 464 drvs->rx_dropped_header_too_small +
261 port_stats->rx_dropped_tcp_length + 465 drvs->rx_dropped_tcp_length +
262 port_stats->rx_dropped_runt + 466 drvs->rx_dropped_runt +
263 port_stats->rx_tcp_checksum_errs + 467 drvs->rx_tcp_checksum_errs +
264 port_stats->rx_ip_checksum_errs + 468 drvs->rx_ip_checksum_errs +
265 port_stats->rx_udp_checksum_errs; 469 drvs->rx_udp_checksum_errs;
266
267 /* no space in linux buffers: best possible approximation */
268 dev_stats->rx_dropped =
269 erx_stats->rx_drops_no_fragments[adapter->rx_obj.q.id];
270 470
271 /* detailed rx errors */ 471 /* detailed rx errors */
272 dev_stats->rx_length_errors = port_stats->rx_in_range_errors + 472 dev_stats->rx_length_errors = drvs->rx_in_range_errors +
273 port_stats->rx_out_range_errors + 473 drvs->rx_out_range_errors +
274 port_stats->rx_frame_too_long; 474 drvs->rx_frame_too_long;
275
276 /* receive ring buffer overflow */
277 dev_stats->rx_over_errors = 0;
278 475
279 dev_stats->rx_crc_errors = port_stats->rx_crc_errors; 476 dev_stats->rx_crc_errors = drvs->rx_crc_errors;
280 477
281 /* frame alignment errors */ 478 /* frame alignment errors */
282 dev_stats->rx_frame_errors = port_stats->rx_alignment_symbol_errors; 479 dev_stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
283 480
284 /* receiver fifo overrun */ 481 /* receiver fifo overrun */
285 /* drops_no_pbuf is no per i/f, it's per BE card */ 482 /* drops_no_pbuf is no per i/f, it's per BE card */
286 dev_stats->rx_fifo_errors = port_stats->rx_fifo_overflow + 483 dev_stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
287 port_stats->rx_input_fifo_overflow + 484 drvs->rx_input_fifo_overflow_drop +
288 rxf_stats->rx_drops_no_pbuf; 485 drvs->rx_drops_no_pbuf;
289 /* receiver missed packetd */
290 dev_stats->rx_missed_errors = 0;
291
292 /* packet transmit problems */
293 dev_stats->tx_errors = 0;
294
295 /* no space available in linux */
296 dev_stats->tx_dropped = 0;
297
298 dev_stats->collisions = 0;
299
300 /* detailed tx_errors */
301 dev_stats->tx_aborted_errors = 0;
302 dev_stats->tx_carrier_errors = 0;
303 dev_stats->tx_fifo_errors = 0;
304 dev_stats->tx_heartbeat_errors = 0;
305 dev_stats->tx_window_errors = 0;
306} 486}
307 487
308void be_link_status_update(struct be_adapter *adapter, bool link_up) 488void be_link_status_update(struct be_adapter *adapter, bool link_up)
@@ -313,11 +493,9 @@ void be_link_status_update(struct be_adapter *adapter, bool link_up)
313 if (adapter->link_up != link_up) { 493 if (adapter->link_up != link_up) {
314 adapter->link_speed = -1; 494 adapter->link_speed = -1;
315 if (link_up) { 495 if (link_up) {
316 netif_start_queue(netdev);
317 netif_carrier_on(netdev); 496 netif_carrier_on(netdev);
318 printk(KERN_INFO "%s: Link up\n", netdev->name); 497 printk(KERN_INFO "%s: Link up\n", netdev->name);
319 } else { 498 } else {
320 netif_stop_queue(netdev);
321 netif_carrier_off(netdev); 499 netif_carrier_off(netdev);
322 printk(KERN_INFO "%s: Link down\n", netdev->name); 500 printk(KERN_INFO "%s: Link down\n", netdev->name);
323 } 501 }
@@ -326,10 +504,10 @@ void be_link_status_update(struct be_adapter *adapter, bool link_up)
326} 504}
327 505
328/* Update the EQ delay n BE based on the RX frags consumed / sec */ 506/* Update the EQ delay n BE based on the RX frags consumed / sec */
329static void be_rx_eqd_update(struct be_adapter *adapter) 507static void be_rx_eqd_update(struct be_adapter *adapter, struct be_rx_obj *rxo)
330{ 508{
331 struct be_eq_obj *rx_eq = &adapter->rx_eq; 509 struct be_eq_obj *rx_eq = &rxo->rx_eq;
332 struct be_drvr_stats *stats = &adapter->stats.drvr_stats; 510 struct be_rx_stats *stats = &rxo->stats;
333 ulong now = jiffies; 511 ulong now = jiffies;
334 u32 eqd; 512 u32 eqd;
335 513
@@ -346,12 +524,12 @@ static void be_rx_eqd_update(struct be_adapter *adapter)
346 if ((now - stats->rx_fps_jiffies) < HZ) 524 if ((now - stats->rx_fps_jiffies) < HZ)
347 return; 525 return;
348 526
349 stats->be_rx_fps = (stats->be_rx_frags - stats->be_prev_rx_frags) / 527 stats->rx_fps = (stats->rx_frags - stats->prev_rx_frags) /
350 ((now - stats->rx_fps_jiffies) / HZ); 528 ((now - stats->rx_fps_jiffies) / HZ);
351 529
352 stats->rx_fps_jiffies = now; 530 stats->rx_fps_jiffies = now;
353 stats->be_prev_rx_frags = stats->be_rx_frags; 531 stats->prev_rx_frags = stats->rx_frags;
354 eqd = stats->be_rx_fps / 110000; 532 eqd = stats->rx_fps / 110000;
355 eqd = eqd << 3; 533 eqd = eqd << 3;
356 if (eqd > rx_eq->max_eqd) 534 if (eqd > rx_eq->max_eqd)
357 eqd = rx_eq->max_eqd; 535 eqd = rx_eq->max_eqd;
@@ -365,11 +543,6 @@ static void be_rx_eqd_update(struct be_adapter *adapter)
365 rx_eq->cur_eqd = eqd; 543 rx_eq->cur_eqd = eqd;
366} 544}
367 545
368static struct net_device_stats *be_get_stats(struct net_device *dev)
369{
370 return &dev->stats;
371}
372
373static u32 be_calc_rate(u64 bytes, unsigned long ticks) 546static u32 be_calc_rate(u64 bytes, unsigned long ticks)
374{ 547{
375 u64 rate = bytes; 548 u64 rate = bytes;
@@ -383,7 +556,7 @@ static u32 be_calc_rate(u64 bytes, unsigned long ticks)
383 556
384static void be_tx_rate_update(struct be_adapter *adapter) 557static void be_tx_rate_update(struct be_adapter *adapter)
385{ 558{
386 struct be_drvr_stats *stats = drvr_stats(adapter); 559 struct be_tx_stats *stats = tx_stats(adapter);
387 ulong now = jiffies; 560 ulong now = jiffies;
388 561
389 /* Wrapped around? */ 562 /* Wrapped around? */
@@ -405,7 +578,7 @@ static void be_tx_rate_update(struct be_adapter *adapter)
405static void be_tx_stats_update(struct be_adapter *adapter, 578static void be_tx_stats_update(struct be_adapter *adapter,
406 u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped) 579 u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
407{ 580{
408 struct be_drvr_stats *stats = drvr_stats(adapter); 581 struct be_tx_stats *stats = tx_stats(adapter);
409 stats->be_tx_reqs++; 582 stats->be_tx_reqs++;
410 stats->be_tx_wrbs += wrb_cnt; 583 stats->be_tx_wrbs += wrb_cnt;
411 stats->be_tx_bytes += copied; 584 stats->be_tx_bytes += copied;
@@ -415,7 +588,8 @@ static void be_tx_stats_update(struct be_adapter *adapter,
415} 588}
416 589
417/* Determine number of WRB entries needed to xmit data in an skb */ 590/* Determine number of WRB entries needed to xmit data in an skb */
418static u32 wrb_cnt_for_skb(struct sk_buff *skb, bool *dummy) 591static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
592 bool *dummy)
419{ 593{
420 int cnt = (skb->len > skb->data_len); 594 int cnt = (skb->len > skb->data_len);
421 595
@@ -423,12 +597,13 @@ static u32 wrb_cnt_for_skb(struct sk_buff *skb, bool *dummy)
423 597
424 /* to account for hdr wrb */ 598 /* to account for hdr wrb */
425 cnt++; 599 cnt++;
426 if (cnt & 1) { 600 if (lancer_chip(adapter) || !(cnt & 1)) {
601 *dummy = false;
602 } else {
427 /* add a dummy to make it an even num */ 603 /* add a dummy to make it an even num */
428 cnt++; 604 cnt++;
429 *dummy = true; 605 *dummy = true;
430 } else 606 }
431 *dummy = false;
432 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT); 607 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
433 return cnt; 608 return cnt;
434} 609}
@@ -440,9 +615,12 @@ static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
440 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK; 615 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
441} 616}
442 617
443static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb, 618static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
444 bool vlan, u32 wrb_cnt, u32 len) 619 struct sk_buff *skb, u32 wrb_cnt, u32 len)
445{ 620{
621 u8 vlan_prio = 0;
622 u16 vlan_tag = 0;
623
446 memset(hdr, 0, sizeof(*hdr)); 624 memset(hdr, 0, sizeof(*hdr));
447 625
448 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1); 626 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
@@ -451,8 +629,18 @@ static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb,
451 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1); 629 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
452 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss, 630 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
453 hdr, skb_shinfo(skb)->gso_size); 631 hdr, skb_shinfo(skb)->gso_size);
454 if (skb_is_gso_v6(skb)) 632 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
455 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1); 633 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
634 if (lancer_chip(adapter) && adapter->sli_family ==
635 LANCER_A0_SLI_FAMILY) {
636 AMAP_SET_BITS(struct amap_eth_hdr_wrb, ipcs, hdr, 1);
637 if (is_tcp_pkt(skb))
638 AMAP_SET_BITS(struct amap_eth_hdr_wrb,
639 tcpcs, hdr, 1);
640 else if (is_udp_pkt(skb))
641 AMAP_SET_BITS(struct amap_eth_hdr_wrb,
642 udpcs, hdr, 1);
643 }
456 } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 644 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
457 if (is_tcp_pkt(skb)) 645 if (is_tcp_pkt(skb))
458 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1); 646 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
@@ -460,10 +648,15 @@ static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb,
460 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1); 648 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
461 } 649 }
462 650
463 if (vlan && vlan_tx_tag_present(skb)) { 651 if (adapter->vlan_grp && vlan_tx_tag_present(skb)) {
464 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1); 652 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
465 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, 653 vlan_tag = vlan_tx_tag_get(skb);
466 hdr, vlan_tx_tag_get(skb)); 654 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
655 /* If vlan priority provided by OS is NOT in available bmap */
656 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
657 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
658 adapter->recommended_prio;
659 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
467 } 660 }
468 661
469 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1); 662 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
@@ -472,7 +665,7 @@ static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb,
472 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len); 665 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
473} 666}
474 667
475static void unmap_tx_frag(struct pci_dev *pdev, struct be_eth_wrb *wrb, 668static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
476 bool unmap_single) 669 bool unmap_single)
477{ 670{
478 dma_addr_t dma; 671 dma_addr_t dma;
@@ -482,11 +675,10 @@ static void unmap_tx_frag(struct pci_dev *pdev, struct be_eth_wrb *wrb,
482 dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo; 675 dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
483 if (wrb->frag_len) { 676 if (wrb->frag_len) {
484 if (unmap_single) 677 if (unmap_single)
485 pci_unmap_single(pdev, dma, wrb->frag_len, 678 dma_unmap_single(dev, dma, wrb->frag_len,
486 PCI_DMA_TODEVICE); 679 DMA_TO_DEVICE);
487 else 680 else
488 pci_unmap_page(pdev, dma, wrb->frag_len, 681 dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
489 PCI_DMA_TODEVICE);
490 } 682 }
491} 683}
492 684
@@ -495,7 +687,7 @@ static int make_tx_wrbs(struct be_adapter *adapter,
495{ 687{
496 dma_addr_t busaddr; 688 dma_addr_t busaddr;
497 int i, copied = 0; 689 int i, copied = 0;
498 struct pci_dev *pdev = adapter->pdev; 690 struct device *dev = &adapter->pdev->dev;
499 struct sk_buff *first_skb = skb; 691 struct sk_buff *first_skb = skb;
500 struct be_queue_info *txq = &adapter->tx_obj.q; 692 struct be_queue_info *txq = &adapter->tx_obj.q;
501 struct be_eth_wrb *wrb; 693 struct be_eth_wrb *wrb;
@@ -509,9 +701,8 @@ static int make_tx_wrbs(struct be_adapter *adapter,
509 701
510 if (skb->len > skb->data_len) { 702 if (skb->len > skb->data_len) {
511 int len = skb_headlen(skb); 703 int len = skb_headlen(skb);
512 busaddr = pci_map_single(pdev, skb->data, len, 704 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
513 PCI_DMA_TODEVICE); 705 if (dma_mapping_error(dev, busaddr))
514 if (pci_dma_mapping_error(pdev, busaddr))
515 goto dma_err; 706 goto dma_err;
516 map_single = true; 707 map_single = true;
517 wrb = queue_head_node(txq); 708 wrb = queue_head_node(txq);
@@ -524,10 +715,9 @@ static int make_tx_wrbs(struct be_adapter *adapter,
524 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { 715 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
525 struct skb_frag_struct *frag = 716 struct skb_frag_struct *frag =
526 &skb_shinfo(skb)->frags[i]; 717 &skb_shinfo(skb)->frags[i];
527 busaddr = pci_map_page(pdev, frag->page, 718 busaddr = dma_map_page(dev, frag->page, frag->page_offset,
528 frag->page_offset, 719 frag->size, DMA_TO_DEVICE);
529 frag->size, PCI_DMA_TODEVICE); 720 if (dma_mapping_error(dev, busaddr))
530 if (pci_dma_mapping_error(pdev, busaddr))
531 goto dma_err; 721 goto dma_err;
532 wrb = queue_head_node(txq); 722 wrb = queue_head_node(txq);
533 wrb_fill(wrb, busaddr, frag->size); 723 wrb_fill(wrb, busaddr, frag->size);
@@ -543,8 +733,7 @@ static int make_tx_wrbs(struct be_adapter *adapter,
543 queue_head_inc(txq); 733 queue_head_inc(txq);
544 } 734 }
545 735
546 wrb_fill_hdr(hdr, first_skb, adapter->vlan_grp ? true : false, 736 wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied);
547 wrb_cnt, copied);
548 be_dws_cpu_to_le(hdr, sizeof(*hdr)); 737 be_dws_cpu_to_le(hdr, sizeof(*hdr));
549 738
550 return copied; 739 return copied;
@@ -552,7 +741,7 @@ dma_err:
552 txq->head = map_head; 741 txq->head = map_head;
553 while (copied) { 742 while (copied) {
554 wrb = queue_head_node(txq); 743 wrb = queue_head_node(txq);
555 unmap_tx_frag(pdev, wrb, map_single); 744 unmap_tx_frag(dev, wrb, map_single);
556 map_single = false; 745 map_single = false;
557 copied -= wrb->frag_len; 746 copied -= wrb->frag_len;
558 queue_head_inc(txq); 747 queue_head_inc(txq);
@@ -570,7 +759,7 @@ static netdev_tx_t be_xmit(struct sk_buff *skb,
570 u32 start = txq->head; 759 u32 start = txq->head;
571 bool dummy_wrb, stopped = false; 760 bool dummy_wrb, stopped = false;
572 761
573 wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb); 762 wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
574 763
575 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb); 764 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
576 if (copied) { 765 if (copied) {
@@ -637,7 +826,7 @@ static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
637 826
638 if (adapter->vlans_added <= adapter->max_vlans) { 827 if (adapter->vlans_added <= adapter->max_vlans) {
639 /* Construct VLAN Table to give to HW */ 828 /* Construct VLAN Table to give to HW */
640 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 829 for (i = 0; i < VLAN_N_VID; i++) {
641 if (adapter->vlan_tag[i]) { 830 if (adapter->vlan_tag[i]) {
642 vtag[ntags] = cpu_to_le16(i); 831 vtag[ntags] = cpu_to_le16(i);
643 ntags++; 832 ntags++;
@@ -656,14 +845,8 @@ static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
656static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp) 845static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp)
657{ 846{
658 struct be_adapter *adapter = netdev_priv(netdev); 847 struct be_adapter *adapter = netdev_priv(netdev);
659 struct be_eq_obj *rx_eq = &adapter->rx_eq;
660 struct be_eq_obj *tx_eq = &adapter->tx_eq;
661 848
662 be_eq_notify(adapter, rx_eq->q.id, false, false, 0);
663 be_eq_notify(adapter, tx_eq->q.id, false, false, 0);
664 adapter->vlan_grp = grp; 849 adapter->vlan_grp = grp;
665 be_eq_notify(adapter, rx_eq->q.id, true, false, 0);
666 be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
667} 850}
668 851
669static void be_vlan_add_vid(struct net_device *netdev, u16 vid) 852static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
@@ -699,15 +882,15 @@ static void be_set_multicast_list(struct net_device *netdev)
699 struct be_adapter *adapter = netdev_priv(netdev); 882 struct be_adapter *adapter = netdev_priv(netdev);
700 883
701 if (netdev->flags & IFF_PROMISC) { 884 if (netdev->flags & IFF_PROMISC) {
702 be_cmd_promiscuous_config(adapter, adapter->port_num, 1); 885 be_cmd_promiscuous_config(adapter, true);
703 adapter->promiscuous = true; 886 adapter->promiscuous = true;
704 goto done; 887 goto done;
705 } 888 }
706 889
707 /* BE was previously in promiscous mode; disable it */ 890 /* BE was previously in promiscuous mode; disable it */
708 if (adapter->promiscuous) { 891 if (adapter->promiscuous) {
709 adapter->promiscuous = false; 892 adapter->promiscuous = false;
710 be_cmd_promiscuous_config(adapter, adapter->port_num, 0); 893 be_cmd_promiscuous_config(adapter, false);
711 } 894 }
712 895
713 /* Enable multicast promisc if num configured exceeds what we support */ 896 /* Enable multicast promisc if num configured exceeds what we support */
@@ -738,11 +921,11 @@ static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
738 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID) 921 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
739 status = be_cmd_pmac_del(adapter, 922 status = be_cmd_pmac_del(adapter,
740 adapter->vf_cfg[vf].vf_if_handle, 923 adapter->vf_cfg[vf].vf_if_handle,
741 adapter->vf_cfg[vf].vf_pmac_id); 924 adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
742 925
743 status = be_cmd_pmac_add(adapter, mac, 926 status = be_cmd_pmac_add(adapter, mac,
744 adapter->vf_cfg[vf].vf_if_handle, 927 adapter->vf_cfg[vf].vf_if_handle,
745 &adapter->vf_cfg[vf].vf_pmac_id); 928 &adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
746 929
747 if (status) 930 if (status)
748 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n", 931 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
@@ -817,7 +1000,7 @@ static int be_set_vf_tx_rate(struct net_device *netdev,
817 rate = 10000; 1000 rate = 10000;
818 1001
819 adapter->vf_cfg[vf].vf_tx_rate = rate; 1002 adapter->vf_cfg[vf].vf_tx_rate = rate;
820 status = be_cmd_set_qos(adapter, rate / 10, vf); 1003 status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
821 1004
822 if (status) 1005 if (status)
823 dev_info(&adapter->pdev->dev, 1006 dev_info(&adapter->pdev->dev,
@@ -825,70 +1008,65 @@ static int be_set_vf_tx_rate(struct net_device *netdev,
825 return status; 1008 return status;
826} 1009}
827 1010
828static void be_rx_rate_update(struct be_adapter *adapter) 1011static void be_rx_rate_update(struct be_rx_obj *rxo)
829{ 1012{
830 struct be_drvr_stats *stats = drvr_stats(adapter); 1013 struct be_rx_stats *stats = &rxo->stats;
831 ulong now = jiffies; 1014 ulong now = jiffies;
832 1015
833 /* Wrapped around */ 1016 /* Wrapped around */
834 if (time_before(now, stats->be_rx_jiffies)) { 1017 if (time_before(now, stats->rx_jiffies)) {
835 stats->be_rx_jiffies = now; 1018 stats->rx_jiffies = now;
836 return; 1019 return;
837 } 1020 }
838 1021
839 /* Update the rate once in two seconds */ 1022 /* Update the rate once in two seconds */
840 if ((now - stats->be_rx_jiffies) < 2 * HZ) 1023 if ((now - stats->rx_jiffies) < 2 * HZ)
841 return; 1024 return;
842 1025
843 stats->be_rx_rate = be_calc_rate(stats->be_rx_bytes 1026 stats->rx_rate = be_calc_rate(stats->rx_bytes - stats->rx_bytes_prev,
844 - stats->be_rx_bytes_prev, 1027 now - stats->rx_jiffies);
845 now - stats->be_rx_jiffies); 1028 stats->rx_jiffies = now;
846 stats->be_rx_jiffies = now; 1029 stats->rx_bytes_prev = stats->rx_bytes;
847 stats->be_rx_bytes_prev = stats->be_rx_bytes;
848} 1030}
849 1031
850static void be_rx_stats_update(struct be_adapter *adapter, 1032static void be_rx_stats_update(struct be_rx_obj *rxo,
851 u32 pktsize, u16 numfrags, u8 pkt_type) 1033 struct be_rx_compl_info *rxcp)
852{ 1034{
853 struct be_drvr_stats *stats = drvr_stats(adapter); 1035 struct be_rx_stats *stats = &rxo->stats;
854 1036
855 stats->be_rx_compl++; 1037 stats->rx_compl++;
856 stats->be_rx_frags += numfrags; 1038 stats->rx_frags += rxcp->num_rcvd;
857 stats->be_rx_bytes += pktsize; 1039 stats->rx_bytes += rxcp->pkt_size;
858 stats->be_rx_pkts++; 1040 stats->rx_pkts++;
859 1041 if (rxcp->pkt_type == BE_MULTICAST_PACKET)
860 if (pkt_type == BE_MULTICAST_PACKET) 1042 stats->rx_mcast_pkts++;
861 stats->be_rx_mcast_pkt++; 1043 if (rxcp->err)
1044 stats->rxcp_err++;
862} 1045}
863 1046
864static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso) 1047static inline bool csum_passed(struct be_rx_compl_info *rxcp)
865{ 1048{
866 u8 l4_cksm, ip_version, ipcksm, tcpf = 0, udpf = 0, ipv6_chk; 1049 /* L4 checksum is not reliable for non TCP/UDP packets.
867 1050 * Also ignore ipcksm for ipv6 pkts */
868 l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp); 1051 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
869 ipcksm = AMAP_GET_BITS(struct amap_eth_rx_compl, ipcksm, rxcp); 1052 (rxcp->ip_csum || rxcp->ipv6);
870 ip_version = AMAP_GET_BITS(struct amap_eth_rx_compl, ip_version, rxcp);
871 if (ip_version) {
872 tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
873 udpf = AMAP_GET_BITS(struct amap_eth_rx_compl, udpf, rxcp);
874 }
875 ipv6_chk = (ip_version && (tcpf || udpf));
876
877 return ((l4_cksm && ipv6_chk && ipcksm) && cso) ? false : true;
878} 1053}
879 1054
880static struct be_rx_page_info * 1055static struct be_rx_page_info *
881get_rx_page_info(struct be_adapter *adapter, u16 frag_idx) 1056get_rx_page_info(struct be_adapter *adapter,
1057 struct be_rx_obj *rxo,
1058 u16 frag_idx)
882{ 1059{
883 struct be_rx_page_info *rx_page_info; 1060 struct be_rx_page_info *rx_page_info;
884 struct be_queue_info *rxq = &adapter->rx_obj.q; 1061 struct be_queue_info *rxq = &rxo->q;
885 1062
886 rx_page_info = &adapter->rx_obj.page_info_tbl[frag_idx]; 1063 rx_page_info = &rxo->page_info_tbl[frag_idx];
887 BUG_ON(!rx_page_info->page); 1064 BUG_ON(!rx_page_info->page);
888 1065
889 if (rx_page_info->last_page_user) { 1066 if (rx_page_info->last_page_user) {
890 pci_unmap_page(adapter->pdev, dma_unmap_addr(rx_page_info, bus), 1067 dma_unmap_page(&adapter->pdev->dev,
891 adapter->big_page_size, PCI_DMA_FROMDEVICE); 1068 dma_unmap_addr(rx_page_info, bus),
1069 adapter->big_page_size, DMA_FROM_DEVICE);
892 rx_page_info->last_page_user = false; 1070 rx_page_info->last_page_user = false;
893 } 1071 }
894 1072
@@ -898,20 +1076,18 @@ get_rx_page_info(struct be_adapter *adapter, u16 frag_idx)
898 1076
899/* Throwaway the data in the Rx completion */ 1077/* Throwaway the data in the Rx completion */
900static void be_rx_compl_discard(struct be_adapter *adapter, 1078static void be_rx_compl_discard(struct be_adapter *adapter,
901 struct be_eth_rx_compl *rxcp) 1079 struct be_rx_obj *rxo,
1080 struct be_rx_compl_info *rxcp)
902{ 1081{
903 struct be_queue_info *rxq = &adapter->rx_obj.q; 1082 struct be_queue_info *rxq = &rxo->q;
904 struct be_rx_page_info *page_info; 1083 struct be_rx_page_info *page_info;
905 u16 rxq_idx, i, num_rcvd; 1084 u16 i, num_rcvd = rxcp->num_rcvd;
906
907 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
908 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
909 1085
910 for (i = 0; i < num_rcvd; i++) { 1086 for (i = 0; i < num_rcvd; i++) {
911 page_info = get_rx_page_info(adapter, rxq_idx); 1087 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
912 put_page(page_info->page); 1088 put_page(page_info->page);
913 memset(page_info, 0, sizeof(*page_info)); 1089 memset(page_info, 0, sizeof(*page_info));
914 index_inc(&rxq_idx, rxq->len); 1090 index_inc(&rxcp->rxq_idx, rxq->len);
915 } 1091 }
916} 1092}
917 1093
@@ -919,31 +1095,24 @@ static void be_rx_compl_discard(struct be_adapter *adapter,
919 * skb_fill_rx_data forms a complete skb for an ether frame 1095 * skb_fill_rx_data forms a complete skb for an ether frame
920 * indicated by rxcp. 1096 * indicated by rxcp.
921 */ 1097 */
922static void skb_fill_rx_data(struct be_adapter *adapter, 1098static void skb_fill_rx_data(struct be_adapter *adapter, struct be_rx_obj *rxo,
923 struct sk_buff *skb, struct be_eth_rx_compl *rxcp, 1099 struct sk_buff *skb, struct be_rx_compl_info *rxcp)
924 u16 num_rcvd)
925{ 1100{
926 struct be_queue_info *rxq = &adapter->rx_obj.q; 1101 struct be_queue_info *rxq = &rxo->q;
927 struct be_rx_page_info *page_info; 1102 struct be_rx_page_info *page_info;
928 u16 rxq_idx, i, j; 1103 u16 i, j;
929 u32 pktsize, hdr_len, curr_frag_len, size; 1104 u16 hdr_len, curr_frag_len, remaining;
930 u8 *start; 1105 u8 *start;
931 u8 pkt_type;
932
933 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
934 pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
935 pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
936
937 page_info = get_rx_page_info(adapter, rxq_idx);
938 1106
1107 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
939 start = page_address(page_info->page) + page_info->page_offset; 1108 start = page_address(page_info->page) + page_info->page_offset;
940 prefetch(start); 1109 prefetch(start);
941 1110
942 /* Copy data in the first descriptor of this completion */ 1111 /* Copy data in the first descriptor of this completion */
943 curr_frag_len = min(pktsize, rx_frag_size); 1112 curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
944 1113
945 /* Copy the header portion into skb_data */ 1114 /* Copy the header portion into skb_data */
946 hdr_len = min((u32)BE_HDR_LEN, curr_frag_len); 1115 hdr_len = min(BE_HDR_LEN, curr_frag_len);
947 memcpy(skb->data, start, hdr_len); 1116 memcpy(skb->data, start, hdr_len);
948 skb->len = curr_frag_len; 1117 skb->len = curr_frag_len;
949 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */ 1118 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
@@ -962,19 +1131,17 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
962 } 1131 }
963 page_info->page = NULL; 1132 page_info->page = NULL;
964 1133
965 if (pktsize <= rx_frag_size) { 1134 if (rxcp->pkt_size <= rx_frag_size) {
966 BUG_ON(num_rcvd != 1); 1135 BUG_ON(rxcp->num_rcvd != 1);
967 goto done; 1136 return;
968 } 1137 }
969 1138
970 /* More frags present for this completion */ 1139 /* More frags present for this completion */
971 size = pktsize; 1140 index_inc(&rxcp->rxq_idx, rxq->len);
972 for (i = 1, j = 0; i < num_rcvd; i++) { 1141 remaining = rxcp->pkt_size - curr_frag_len;
973 size -= curr_frag_len; 1142 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
974 index_inc(&rxq_idx, rxq->len); 1143 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
975 page_info = get_rx_page_info(adapter, rxq_idx); 1144 curr_frag_len = min(remaining, rx_frag_size);
976
977 curr_frag_len = min(size, rx_frag_size);
978 1145
979 /* Coalesce all frags from the same physical page in one slot */ 1146 /* Coalesce all frags from the same physical page in one slot */
980 if (page_info->page_offset == 0) { 1147 if (page_info->page_offset == 0) {
@@ -993,62 +1160,49 @@ static void skb_fill_rx_data(struct be_adapter *adapter,
993 skb->len += curr_frag_len; 1160 skb->len += curr_frag_len;
994 skb->data_len += curr_frag_len; 1161 skb->data_len += curr_frag_len;
995 1162
1163 remaining -= curr_frag_len;
1164 index_inc(&rxcp->rxq_idx, rxq->len);
996 page_info->page = NULL; 1165 page_info->page = NULL;
997 } 1166 }
998 BUG_ON(j > MAX_SKB_FRAGS); 1167 BUG_ON(j > MAX_SKB_FRAGS);
999
1000done:
1001 be_rx_stats_update(adapter, pktsize, num_rcvd, pkt_type);
1002} 1168}
1003 1169
1004/* Process the RX completion indicated by rxcp when GRO is disabled */ 1170/* Process the RX completion indicated by rxcp when GRO is disabled */
1005static void be_rx_compl_process(struct be_adapter *adapter, 1171static void be_rx_compl_process(struct be_adapter *adapter,
1006 struct be_eth_rx_compl *rxcp) 1172 struct be_rx_obj *rxo,
1173 struct be_rx_compl_info *rxcp)
1007{ 1174{
1175 struct net_device *netdev = adapter->netdev;
1008 struct sk_buff *skb; 1176 struct sk_buff *skb;
1009 u32 vlanf, vid;
1010 u16 num_rcvd;
1011 u8 vtm;
1012 1177
1013 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp); 1178 skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);
1014 /* Is it a flush compl that has no data */
1015 if (unlikely(num_rcvd == 0))
1016 return;
1017
1018 skb = netdev_alloc_skb_ip_align(adapter->netdev, BE_HDR_LEN);
1019 if (unlikely(!skb)) { 1179 if (unlikely(!skb)) {
1020 if (net_ratelimit()) 1180 if (net_ratelimit())
1021 dev_warn(&adapter->pdev->dev, "skb alloc failed\n"); 1181 dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
1022 be_rx_compl_discard(adapter, rxcp); 1182 be_rx_compl_discard(adapter, rxo, rxcp);
1023 return; 1183 return;
1024 } 1184 }
1025 1185
1026 skb_fill_rx_data(adapter, skb, rxcp, num_rcvd); 1186 skb_fill_rx_data(adapter, rxo, skb, rxcp);
1027 1187
1028 if (do_pkt_csum(rxcp, adapter->rx_csum)) 1188 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1029 skb->ip_summed = CHECKSUM_NONE;
1030 else
1031 skb->ip_summed = CHECKSUM_UNNECESSARY; 1189 skb->ip_summed = CHECKSUM_UNNECESSARY;
1190 else
1191 skb_checksum_none_assert(skb);
1032 1192
1033 skb->truesize = skb->len + sizeof(struct sk_buff); 1193 skb->truesize = skb->len + sizeof(struct sk_buff);
1034 skb->protocol = eth_type_trans(skb, adapter->netdev); 1194 skb->protocol = eth_type_trans(skb, netdev);
1195 if (adapter->netdev->features & NETIF_F_RXHASH)
1196 skb->rxhash = rxcp->rss_hash;
1035 1197
1036 vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1037 vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1038 1198
1039 /* vlanf could be wrongly set in some cards. 1199 if (unlikely(rxcp->vlanf)) {
1040 * ignore if vtm is not set */
1041 if ((adapter->function_mode & 0x400) && !vtm)
1042 vlanf = 0;
1043
1044 if (unlikely(vlanf)) {
1045 if (!adapter->vlan_grp || adapter->vlans_added == 0) { 1200 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
1046 kfree_skb(skb); 1201 kfree_skb(skb);
1047 return; 1202 return;
1048 } 1203 }
1049 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp); 1204 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp,
1050 vid = swab16(vid); 1205 rxcp->vlan_tag);
1051 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp, vid);
1052 } else { 1206 } else {
1053 netif_receive_skb(skb); 1207 netif_receive_skb(skb);
1054 } 1208 }
@@ -1056,42 +1210,25 @@ static void be_rx_compl_process(struct be_adapter *adapter,
1056 1210
1057/* Process the RX completion indicated by rxcp when GRO is enabled */ 1211/* Process the RX completion indicated by rxcp when GRO is enabled */
1058static void be_rx_compl_process_gro(struct be_adapter *adapter, 1212static void be_rx_compl_process_gro(struct be_adapter *adapter,
1059 struct be_eth_rx_compl *rxcp) 1213 struct be_rx_obj *rxo,
1214 struct be_rx_compl_info *rxcp)
1060{ 1215{
1061 struct be_rx_page_info *page_info; 1216 struct be_rx_page_info *page_info;
1062 struct sk_buff *skb = NULL; 1217 struct sk_buff *skb = NULL;
1063 struct be_queue_info *rxq = &adapter->rx_obj.q; 1218 struct be_queue_info *rxq = &rxo->q;
1064 struct be_eq_obj *eq_obj = &adapter->rx_eq; 1219 struct be_eq_obj *eq_obj = &rxo->rx_eq;
1065 u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len; 1220 u16 remaining, curr_frag_len;
1066 u16 i, rxq_idx = 0, vid, j; 1221 u16 i, j;
1067 u8 vtm;
1068 u8 pkt_type;
1069
1070 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
1071 /* Is it a flush compl that has no data */
1072 if (unlikely(num_rcvd == 0))
1073 return;
1074
1075 pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
1076 vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1077 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
1078 vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1079 pkt_type = AMAP_GET_BITS(struct amap_eth_rx_compl, cast_enc, rxcp);
1080
1081 /* vlanf could be wrongly set in some cards.
1082 * ignore if vtm is not set */
1083 if ((adapter->function_mode & 0x400) && !vtm)
1084 vlanf = 0;
1085 1222
1086 skb = napi_get_frags(&eq_obj->napi); 1223 skb = napi_get_frags(&eq_obj->napi);
1087 if (!skb) { 1224 if (!skb) {
1088 be_rx_compl_discard(adapter, rxcp); 1225 be_rx_compl_discard(adapter, rxo, rxcp);
1089 return; 1226 return;
1090 } 1227 }
1091 1228
1092 remaining = pkt_size; 1229 remaining = rxcp->pkt_size;
1093 for (i = 0, j = -1; i < num_rcvd; i++) { 1230 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
1094 page_info = get_rx_page_info(adapter, rxq_idx); 1231 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
1095 1232
1096 curr_frag_len = min(remaining, rx_frag_size); 1233 curr_frag_len = min(remaining, rx_frag_size);
1097 1234
@@ -1109,89 +1246,166 @@ static void be_rx_compl_process_gro(struct be_adapter *adapter,
1109 skb_shinfo(skb)->frags[j].size += curr_frag_len; 1246 skb_shinfo(skb)->frags[j].size += curr_frag_len;
1110 1247
1111 remaining -= curr_frag_len; 1248 remaining -= curr_frag_len;
1112 index_inc(&rxq_idx, rxq->len); 1249 index_inc(&rxcp->rxq_idx, rxq->len);
1113 memset(page_info, 0, sizeof(*page_info)); 1250 memset(page_info, 0, sizeof(*page_info));
1114 } 1251 }
1115 BUG_ON(j > MAX_SKB_FRAGS); 1252 BUG_ON(j > MAX_SKB_FRAGS);
1116 1253
1117 skb_shinfo(skb)->nr_frags = j + 1; 1254 skb_shinfo(skb)->nr_frags = j + 1;
1118 skb->len = pkt_size; 1255 skb->len = rxcp->pkt_size;
1119 skb->data_len = pkt_size; 1256 skb->data_len = rxcp->pkt_size;
1120 skb->truesize += pkt_size; 1257 skb->truesize += rxcp->pkt_size;
1121 skb->ip_summed = CHECKSUM_UNNECESSARY; 1258 skb->ip_summed = CHECKSUM_UNNECESSARY;
1259 if (adapter->netdev->features & NETIF_F_RXHASH)
1260 skb->rxhash = rxcp->rss_hash;
1122 1261
1123 if (likely(!vlanf)) { 1262 if (likely(!rxcp->vlanf))
1124 napi_gro_frags(&eq_obj->napi); 1263 napi_gro_frags(&eq_obj->napi);
1125 } else { 1264 else
1126 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp); 1265 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp,
1127 vid = swab16(vid); 1266 rxcp->vlan_tag);
1267}
1268
1269static void be_parse_rx_compl_v1(struct be_adapter *adapter,
1270 struct be_eth_rx_compl *compl,
1271 struct be_rx_compl_info *rxcp)
1272{
1273 rxcp->pkt_size =
1274 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, pktsize, compl);
1275 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtp, compl);
1276 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, err, compl);
1277 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, tcpf, compl);
1278 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1279 rxcp->ip_csum =
1280 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ipcksm, compl);
1281 rxcp->l4_csum =
1282 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, l4_cksm, compl);
1283 rxcp->ipv6 =
1284 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ip_version, compl);
1285 rxcp->rxq_idx =
1286 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, fragndx, compl);
1287 rxcp->num_rcvd =
1288 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
1289 rxcp->pkt_type =
1290 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
1291 rxcp->rss_hash =
1292 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, rxcp);
1293 if (rxcp->vlanf) {
1294 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1295 compl);
1296 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
1297 compl);
1298 }
1299}
1300
1301static void be_parse_rx_compl_v0(struct be_adapter *adapter,
1302 struct be_eth_rx_compl *compl,
1303 struct be_rx_compl_info *rxcp)
1304{
1305 rxcp->pkt_size =
1306 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, pktsize, compl);
1307 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtp, compl);
1308 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, err, compl);
1309 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, tcpf, compl);
1310 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1311 rxcp->ip_csum =
1312 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ipcksm, compl);
1313 rxcp->l4_csum =
1314 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, l4_cksm, compl);
1315 rxcp->ipv6 =
1316 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ip_version, compl);
1317 rxcp->rxq_idx =
1318 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, fragndx, compl);
1319 rxcp->num_rcvd =
1320 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
1321 rxcp->pkt_type =
1322 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
1323 rxcp->rss_hash =
1324 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, rxcp);
1325 if (rxcp->vlanf) {
1326 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1327 compl);
1328 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
1329 compl);
1330 }
1331}
1332
1333static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
1334{
1335 struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
1336 struct be_rx_compl_info *rxcp = &rxo->rxcp;
1337 struct be_adapter *adapter = rxo->adapter;
1338
1339 /* For checking the valid bit it is Ok to use either definition as the
1340 * valid bit is at the same position in both v0 and v1 Rx compl */
1341 if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
1342 return NULL;
1128 1343
1129 if (!adapter->vlan_grp || adapter->vlans_added == 0) 1344 rmb();
1130 return; 1345 be_dws_le_to_cpu(compl, sizeof(*compl));
1131 1346
1132 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, vid); 1347 if (adapter->be3_native)
1133 } 1348 be_parse_rx_compl_v1(adapter, compl, rxcp);
1349 else
1350 be_parse_rx_compl_v0(adapter, compl, rxcp);
1134 1351
1135 be_rx_stats_update(adapter, pkt_size, num_rcvd, pkt_type); 1352 if (rxcp->vlanf) {
1136} 1353 /* vlanf could be wrongly set in some cards.
1354 * ignore if vtm is not set */
1355 if ((adapter->function_mode & 0x400) && !rxcp->vtm)
1356 rxcp->vlanf = 0;
1137 1357
1138static struct be_eth_rx_compl *be_rx_compl_get(struct be_adapter *adapter) 1358 if (!lancer_chip(adapter))
1139{ 1359 rxcp->vlan_tag = swab16(rxcp->vlan_tag);
1140 struct be_eth_rx_compl *rxcp = queue_tail_node(&adapter->rx_obj.cq);
1141 1360
1142 if (rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] == 0) 1361 if (((adapter->pvid & VLAN_VID_MASK) ==
1143 return NULL; 1362 (rxcp->vlan_tag & VLAN_VID_MASK)) &&
1363 !adapter->vlan_tag[rxcp->vlan_tag])
1364 rxcp->vlanf = 0;
1365 }
1144 1366
1145 rmb(); 1367 /* As the compl has been parsed, reset it; we wont touch it again */
1146 be_dws_le_to_cpu(rxcp, sizeof(*rxcp)); 1368 compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
1147 1369
1148 queue_tail_inc(&adapter->rx_obj.cq); 1370 queue_tail_inc(&rxo->cq);
1149 return rxcp; 1371 return rxcp;
1150} 1372}
1151 1373
1152/* To reset the valid bit, we need to reset the whole word as 1374static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
1153 * when walking the queue the valid entries are little-endian
1154 * and invalid entries are host endian
1155 */
1156static inline void be_rx_compl_reset(struct be_eth_rx_compl *rxcp)
1157{
1158 rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] = 0;
1159}
1160
1161static inline struct page *be_alloc_pages(u32 size)
1162{ 1375{
1163 gfp_t alloc_flags = GFP_ATOMIC;
1164 u32 order = get_order(size); 1376 u32 order = get_order(size);
1377
1165 if (order > 0) 1378 if (order > 0)
1166 alloc_flags |= __GFP_COMP; 1379 gfp |= __GFP_COMP;
1167 return alloc_pages(alloc_flags, order); 1380 return alloc_pages(gfp, order);
1168} 1381}
1169 1382
1170/* 1383/*
1171 * Allocate a page, split it to fragments of size rx_frag_size and post as 1384 * Allocate a page, split it to fragments of size rx_frag_size and post as
1172 * receive buffers to BE 1385 * receive buffers to BE
1173 */ 1386 */
1174static void be_post_rx_frags(struct be_adapter *adapter) 1387static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
1175{ 1388{
1176 struct be_rx_page_info *page_info_tbl = adapter->rx_obj.page_info_tbl; 1389 struct be_adapter *adapter = rxo->adapter;
1390 struct be_rx_page_info *page_info_tbl = rxo->page_info_tbl;
1177 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL; 1391 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1178 struct be_queue_info *rxq = &adapter->rx_obj.q; 1392 struct be_queue_info *rxq = &rxo->q;
1179 struct page *pagep = NULL; 1393 struct page *pagep = NULL;
1180 struct be_eth_rx_d *rxd; 1394 struct be_eth_rx_d *rxd;
1181 u64 page_dmaaddr = 0, frag_dmaaddr; 1395 u64 page_dmaaddr = 0, frag_dmaaddr;
1182 u32 posted, page_offset = 0; 1396 u32 posted, page_offset = 0;
1183 1397
1184 page_info = &page_info_tbl[rxq->head]; 1398 page_info = &rxo->page_info_tbl[rxq->head];
1185 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) { 1399 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1186 if (!pagep) { 1400 if (!pagep) {
1187 pagep = be_alloc_pages(adapter->big_page_size); 1401 pagep = be_alloc_pages(adapter->big_page_size, gfp);
1188 if (unlikely(!pagep)) { 1402 if (unlikely(!pagep)) {
1189 drvr_stats(adapter)->be_ethrx_post_fail++; 1403 rxo->stats.rx_post_fail++;
1190 break; 1404 break;
1191 } 1405 }
1192 page_dmaaddr = pci_map_page(adapter->pdev, pagep, 0, 1406 page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
1193 adapter->big_page_size, 1407 0, adapter->big_page_size,
1194 PCI_DMA_FROMDEVICE); 1408 DMA_FROM_DEVICE);
1195 page_info->page_offset = 0; 1409 page_info->page_offset = 0;
1196 } else { 1410 } else {
1197 get_page(pagep); 1411 get_page(pagep);
@@ -1225,7 +1439,7 @@ static void be_post_rx_frags(struct be_adapter *adapter)
1225 be_rxq_notify(adapter, rxq->id, posted); 1439 be_rxq_notify(adapter, rxq->id, posted);
1226 } else if (atomic_read(&rxq->used) == 0) { 1440 } else if (atomic_read(&rxq->used) == 0) {
1227 /* Let be_worker replenish when memory is available */ 1441 /* Let be_worker replenish when memory is available */
1228 adapter->rx_post_starved = true; 1442 rxo->rx_post_starved = true;
1229 } 1443 }
1230} 1444}
1231 1445
@@ -1245,7 +1459,7 @@ static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
1245 return txcp; 1459 return txcp;
1246} 1460}
1247 1461
1248static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index) 1462static u16 be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
1249{ 1463{
1250 struct be_queue_info *txq = &adapter->tx_obj.q; 1464 struct be_queue_info *txq = &adapter->tx_obj.q;
1251 struct be_eth_wrb *wrb; 1465 struct be_eth_wrb *wrb;
@@ -1264,17 +1478,16 @@ static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
1264 do { 1478 do {
1265 cur_index = txq->tail; 1479 cur_index = txq->tail;
1266 wrb = queue_tail_node(txq); 1480 wrb = queue_tail_node(txq);
1267 unmap_tx_frag(adapter->pdev, wrb, (unmap_skb_hdr && 1481 unmap_tx_frag(&adapter->pdev->dev, wrb,
1268 skb_headlen(sent_skb))); 1482 (unmap_skb_hdr && skb_headlen(sent_skb)));
1269 unmap_skb_hdr = false; 1483 unmap_skb_hdr = false;
1270 1484
1271 num_wrbs++; 1485 num_wrbs++;
1272 queue_tail_inc(txq); 1486 queue_tail_inc(txq);
1273 } while (cur_index != last_index); 1487 } while (cur_index != last_index);
1274 1488
1275 atomic_sub(num_wrbs, &txq->used);
1276
1277 kfree_skb(sent_skb); 1489 kfree_skb(sent_skb);
1490 return num_wrbs;
1278} 1491}
1279 1492
1280static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj) 1493static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj)
@@ -1328,25 +1541,24 @@ static void be_eq_clean(struct be_adapter *adapter,
1328 be_eq_notify(adapter, eq_obj->q.id, false, true, num); 1541 be_eq_notify(adapter, eq_obj->q.id, false, true, num);
1329} 1542}
1330 1543
1331static void be_rx_q_clean(struct be_adapter *adapter) 1544static void be_rx_q_clean(struct be_adapter *adapter, struct be_rx_obj *rxo)
1332{ 1545{
1333 struct be_rx_page_info *page_info; 1546 struct be_rx_page_info *page_info;
1334 struct be_queue_info *rxq = &adapter->rx_obj.q; 1547 struct be_queue_info *rxq = &rxo->q;
1335 struct be_queue_info *rx_cq = &adapter->rx_obj.cq; 1548 struct be_queue_info *rx_cq = &rxo->cq;
1336 struct be_eth_rx_compl *rxcp; 1549 struct be_rx_compl_info *rxcp;
1337 u16 tail; 1550 u16 tail;
1338 1551
1339 /* First cleanup pending rx completions */ 1552 /* First cleanup pending rx completions */
1340 while ((rxcp = be_rx_compl_get(adapter)) != NULL) { 1553 while ((rxcp = be_rx_compl_get(rxo)) != NULL) {
1341 be_rx_compl_discard(adapter, rxcp); 1554 be_rx_compl_discard(adapter, rxo, rxcp);
1342 be_rx_compl_reset(rxcp); 1555 be_cq_notify(adapter, rx_cq->id, false, 1);
1343 be_cq_notify(adapter, rx_cq->id, true, 1);
1344 } 1556 }
1345 1557
1346 /* Then free posted rx buffer that were not used */ 1558 /* Then free posted rx buffer that were not used */
1347 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len; 1559 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1348 for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) { 1560 for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1349 page_info = get_rx_page_info(adapter, tail); 1561 page_info = get_rx_page_info(adapter, rxo, tail);
1350 put_page(page_info->page); 1562 put_page(page_info->page);
1351 memset(page_info, 0, sizeof(*page_info)); 1563 memset(page_info, 0, sizeof(*page_info));
1352 } 1564 }
@@ -1358,7 +1570,7 @@ static void be_tx_compl_clean(struct be_adapter *adapter)
1358 struct be_queue_info *tx_cq = &adapter->tx_obj.cq; 1570 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1359 struct be_queue_info *txq = &adapter->tx_obj.q; 1571 struct be_queue_info *txq = &adapter->tx_obj.q;
1360 struct be_eth_tx_compl *txcp; 1572 struct be_eth_tx_compl *txcp;
1361 u16 end_idx, cmpl = 0, timeo = 0; 1573 u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
1362 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list; 1574 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1363 struct sk_buff *sent_skb; 1575 struct sk_buff *sent_skb;
1364 bool dummy_wrb; 1576 bool dummy_wrb;
@@ -1368,12 +1580,14 @@ static void be_tx_compl_clean(struct be_adapter *adapter)
1368 while ((txcp = be_tx_compl_get(tx_cq))) { 1580 while ((txcp = be_tx_compl_get(tx_cq))) {
1369 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl, 1581 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1370 wrb_index, txcp); 1582 wrb_index, txcp);
1371 be_tx_compl_process(adapter, end_idx); 1583 num_wrbs += be_tx_compl_process(adapter, end_idx);
1372 cmpl++; 1584 cmpl++;
1373 } 1585 }
1374 if (cmpl) { 1586 if (cmpl) {
1375 be_cq_notify(adapter, tx_cq->id, false, cmpl); 1587 be_cq_notify(adapter, tx_cq->id, false, cmpl);
1588 atomic_sub(num_wrbs, &txq->used);
1376 cmpl = 0; 1589 cmpl = 0;
1590 num_wrbs = 0;
1377 } 1591 }
1378 1592
1379 if (atomic_read(&txq->used) == 0 || ++timeo > 200) 1593 if (atomic_read(&txq->used) == 0 || ++timeo > 200)
@@ -1391,8 +1605,10 @@ static void be_tx_compl_clean(struct be_adapter *adapter)
1391 sent_skb = sent_skbs[txq->tail]; 1605 sent_skb = sent_skbs[txq->tail];
1392 end_idx = txq->tail; 1606 end_idx = txq->tail;
1393 index_adv(&end_idx, 1607 index_adv(&end_idx,
1394 wrb_cnt_for_skb(sent_skb, &dummy_wrb) - 1, txq->len); 1608 wrb_cnt_for_skb(adapter, sent_skb, &dummy_wrb) - 1,
1395 be_tx_compl_process(adapter, end_idx); 1609 txq->len);
1610 num_wrbs = be_tx_compl_process(adapter, end_idx);
1611 atomic_sub(num_wrbs, &txq->used);
1396 } 1612 }
1397} 1613}
1398 1614
@@ -1486,7 +1702,9 @@ static int be_tx_queues_create(struct be_adapter *adapter)
1486 /* Ask BE to create Tx Event queue */ 1702 /* Ask BE to create Tx Event queue */
1487 if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd)) 1703 if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd))
1488 goto tx_eq_free; 1704 goto tx_eq_free;
1489 adapter->base_eq_id = adapter->tx_eq.q.id; 1705
1706 adapter->tx_eq.eq_idx = adapter->eq_next_idx++;
1707
1490 1708
1491 /* Alloc TX eth compl queue */ 1709 /* Alloc TX eth compl queue */
1492 cq = &adapter->tx_obj.cq; 1710 cq = &adapter->tx_obj.cq;
@@ -1524,121 +1742,173 @@ tx_eq_free:
1524static void be_rx_queues_destroy(struct be_adapter *adapter) 1742static void be_rx_queues_destroy(struct be_adapter *adapter)
1525{ 1743{
1526 struct be_queue_info *q; 1744 struct be_queue_info *q;
1527 1745 struct be_rx_obj *rxo;
1528 q = &adapter->rx_obj.q; 1746 int i;
1529 if (q->created) { 1747
1530 be_cmd_q_destroy(adapter, q, QTYPE_RXQ); 1748 for_all_rx_queues(adapter, rxo, i) {
1531 1749 q = &rxo->q;
1532 /* After the rxq is invalidated, wait for a grace time 1750 if (q->created) {
1533 * of 1ms for all dma to end and the flush compl to arrive 1751 be_cmd_q_destroy(adapter, q, QTYPE_RXQ);
1534 */ 1752 /* After the rxq is invalidated, wait for a grace time
1535 mdelay(1); 1753 * of 1ms for all dma to end and the flush compl to
1536 be_rx_q_clean(adapter); 1754 * arrive
1755 */
1756 mdelay(1);
1757 be_rx_q_clean(adapter, rxo);
1758 }
1759 be_queue_free(adapter, q);
1760
1761 q = &rxo->cq;
1762 if (q->created)
1763 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1764 be_queue_free(adapter, q);
1765
1766 /* Clear any residual events */
1767 q = &rxo->rx_eq.q;
1768 if (q->created) {
1769 be_eq_clean(adapter, &rxo->rx_eq);
1770 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
1771 }
1772 be_queue_free(adapter, q);
1537 } 1773 }
1538 be_queue_free(adapter, q); 1774}
1539
1540 q = &adapter->rx_obj.cq;
1541 if (q->created)
1542 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1543 be_queue_free(adapter, q);
1544
1545 /* Clear any residual events */
1546 be_eq_clean(adapter, &adapter->rx_eq);
1547 1775
1548 q = &adapter->rx_eq.q; 1776static u32 be_num_rxqs_want(struct be_adapter *adapter)
1549 if (q->created) 1777{
1550 be_cmd_q_destroy(adapter, q, QTYPE_EQ); 1778 if (multi_rxq && (adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
1551 be_queue_free(adapter, q); 1779 !adapter->sriov_enabled && !(adapter->function_mode & 0x400)) {
1780 return 1 + MAX_RSS_QS; /* one default non-RSS queue */
1781 } else {
1782 dev_warn(&adapter->pdev->dev,
1783 "No support for multiple RX queues\n");
1784 return 1;
1785 }
1552} 1786}
1553 1787
1554static int be_rx_queues_create(struct be_adapter *adapter) 1788static int be_rx_queues_create(struct be_adapter *adapter)
1555{ 1789{
1556 struct be_queue_info *eq, *q, *cq; 1790 struct be_queue_info *eq, *q, *cq;
1557 int rc; 1791 struct be_rx_obj *rxo;
1792 int rc, i;
1793
1794 adapter->num_rx_qs = min(be_num_rxqs_want(adapter),
1795 msix_enabled(adapter) ?
1796 adapter->num_msix_vec - 1 : 1);
1797 if (adapter->num_rx_qs != MAX_RX_QS)
1798 dev_warn(&adapter->pdev->dev,
1799 "Can create only %d RX queues", adapter->num_rx_qs);
1558 1800
1559 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE; 1801 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1560 adapter->rx_eq.max_eqd = BE_MAX_EQD; 1802 for_all_rx_queues(adapter, rxo, i) {
1561 adapter->rx_eq.min_eqd = 0; 1803 rxo->adapter = adapter;
1562 adapter->rx_eq.cur_eqd = 0; 1804 rxo->rx_eq.max_eqd = BE_MAX_EQD;
1563 adapter->rx_eq.enable_aic = true; 1805 rxo->rx_eq.enable_aic = true;
1564 1806
1565 /* Alloc Rx Event queue */ 1807 /* EQ */
1566 eq = &adapter->rx_eq.q; 1808 eq = &rxo->rx_eq.q;
1567 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN, 1809 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1568 sizeof(struct be_eq_entry)); 1810 sizeof(struct be_eq_entry));
1569 if (rc) 1811 if (rc)
1570 return rc; 1812 goto err;
1571 1813
1572 /* Ask BE to create Rx Event queue */ 1814 rc = be_cmd_eq_create(adapter, eq, rxo->rx_eq.cur_eqd);
1573 rc = be_cmd_eq_create(adapter, eq, adapter->rx_eq.cur_eqd); 1815 if (rc)
1574 if (rc) 1816 goto err;
1575 goto rx_eq_free; 1817
1576 1818 rxo->rx_eq.eq_idx = adapter->eq_next_idx++;
1577 /* Alloc RX eth compl queue */ 1819
1578 cq = &adapter->rx_obj.cq; 1820 /* CQ */
1579 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN, 1821 cq = &rxo->cq;
1580 sizeof(struct be_eth_rx_compl)); 1822 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
1581 if (rc) 1823 sizeof(struct be_eth_rx_compl));
1582 goto rx_eq_destroy; 1824 if (rc)
1583 1825 goto err;
1584 /* Ask BE to create Rx eth compl queue */ 1826
1585 rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3); 1827 rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3);
1586 if (rc) 1828 if (rc)
1587 goto rx_cq_free; 1829 goto err;
1588 1830 /* Rx Q */
1589 /* Alloc RX eth queue */ 1831 q = &rxo->q;
1590 q = &adapter->rx_obj.q; 1832 rc = be_queue_alloc(adapter, q, RX_Q_LEN,
1591 rc = be_queue_alloc(adapter, q, RX_Q_LEN, sizeof(struct be_eth_rx_d)); 1833 sizeof(struct be_eth_rx_d));
1592 if (rc) 1834 if (rc)
1593 goto rx_cq_destroy; 1835 goto err;
1594 1836
1595 /* Ask BE to create Rx eth queue */ 1837 rc = be_cmd_rxq_create(adapter, q, cq->id, rx_frag_size,
1596 rc = be_cmd_rxq_create(adapter, q, cq->id, rx_frag_size, 1838 BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle,
1597 BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle, false); 1839 (i > 0) ? 1 : 0/* rss enable */, &rxo->rss_id);
1598 if (rc) 1840 if (rc)
1599 goto rx_q_free; 1841 goto err;
1842 }
1843
1844 if (be_multi_rxq(adapter)) {
1845 u8 rsstable[MAX_RSS_QS];
1846
1847 for_all_rss_queues(adapter, rxo, i)
1848 rsstable[i] = rxo->rss_id;
1849
1850 rc = be_cmd_rss_config(adapter, rsstable,
1851 adapter->num_rx_qs - 1);
1852 if (rc)
1853 goto err;
1854 }
1600 1855
1601 return 0; 1856 return 0;
1602rx_q_free: 1857err:
1603 be_queue_free(adapter, q); 1858 be_rx_queues_destroy(adapter);
1604rx_cq_destroy: 1859 return -1;
1605 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1606rx_cq_free:
1607 be_queue_free(adapter, cq);
1608rx_eq_destroy:
1609 be_cmd_q_destroy(adapter, eq, QTYPE_EQ);
1610rx_eq_free:
1611 be_queue_free(adapter, eq);
1612 return rc;
1613} 1860}
1614 1861
1615/* There are 8 evt ids per func. Retruns the evt id's bit number */ 1862static bool event_peek(struct be_eq_obj *eq_obj)
1616static inline int be_evt_bit_get(struct be_adapter *adapter, u32 eq_id)
1617{ 1863{
1618 return eq_id - adapter->base_eq_id; 1864 struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
1865 if (!eqe->evt)
1866 return false;
1867 else
1868 return true;
1619} 1869}
1620 1870
1621static irqreturn_t be_intx(int irq, void *dev) 1871static irqreturn_t be_intx(int irq, void *dev)
1622{ 1872{
1623 struct be_adapter *adapter = dev; 1873 struct be_adapter *adapter = dev;
1624 int isr; 1874 struct be_rx_obj *rxo;
1875 int isr, i, tx = 0 , rx = 0;
1876
1877 if (lancer_chip(adapter)) {
1878 if (event_peek(&adapter->tx_eq))
1879 tx = event_handle(adapter, &adapter->tx_eq);
1880 for_all_rx_queues(adapter, rxo, i) {
1881 if (event_peek(&rxo->rx_eq))
1882 rx |= event_handle(adapter, &rxo->rx_eq);
1883 }
1625 1884
1626 isr = ioread32(adapter->csr + CEV_ISR0_OFFSET + 1885 if (!(tx || rx))
1627 (adapter->tx_eq.q.id/ 8) * CEV_ISR_SIZE); 1886 return IRQ_NONE;
1628 if (!isr)
1629 return IRQ_NONE;
1630 1887
1631 event_handle(adapter, &adapter->tx_eq); 1888 } else {
1632 event_handle(adapter, &adapter->rx_eq); 1889 isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
1890 (adapter->tx_eq.q.id / 8) * CEV_ISR_SIZE);
1891 if (!isr)
1892 return IRQ_NONE;
1893
1894 if ((1 << adapter->tx_eq.eq_idx & isr))
1895 event_handle(adapter, &adapter->tx_eq);
1896
1897 for_all_rx_queues(adapter, rxo, i) {
1898 if ((1 << rxo->rx_eq.eq_idx & isr))
1899 event_handle(adapter, &rxo->rx_eq);
1900 }
1901 }
1633 1902
1634 return IRQ_HANDLED; 1903 return IRQ_HANDLED;
1635} 1904}
1636 1905
1637static irqreturn_t be_msix_rx(int irq, void *dev) 1906static irqreturn_t be_msix_rx(int irq, void *dev)
1638{ 1907{
1639 struct be_adapter *adapter = dev; 1908 struct be_rx_obj *rxo = dev;
1909 struct be_adapter *adapter = rxo->adapter;
1640 1910
1641 event_handle(adapter, &adapter->rx_eq); 1911 event_handle(adapter, &rxo->rx_eq);
1642 1912
1643 return IRQ_HANDLED; 1913 return IRQ_HANDLED;
1644} 1914}
@@ -1652,44 +1922,42 @@ static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
1652 return IRQ_HANDLED; 1922 return IRQ_HANDLED;
1653} 1923}
1654 1924
1655static inline bool do_gro(struct be_adapter *adapter, 1925static inline bool do_gro(struct be_rx_compl_info *rxcp)
1656 struct be_eth_rx_compl *rxcp)
1657{ 1926{
1658 int err = AMAP_GET_BITS(struct amap_eth_rx_compl, err, rxcp); 1927 return (rxcp->tcpf && !rxcp->err) ? true : false;
1659 int tcp_frame = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
1660
1661 if (err)
1662 drvr_stats(adapter)->be_rxcp_err++;
1663
1664 return (tcp_frame && !err) ? true : false;
1665} 1928}
1666 1929
1667int be_poll_rx(struct napi_struct *napi, int budget) 1930static int be_poll_rx(struct napi_struct *napi, int budget)
1668{ 1931{
1669 struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi); 1932 struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1670 struct be_adapter *adapter = 1933 struct be_rx_obj *rxo = container_of(rx_eq, struct be_rx_obj, rx_eq);
1671 container_of(rx_eq, struct be_adapter, rx_eq); 1934 struct be_adapter *adapter = rxo->adapter;
1672 struct be_queue_info *rx_cq = &adapter->rx_obj.cq; 1935 struct be_queue_info *rx_cq = &rxo->cq;
1673 struct be_eth_rx_compl *rxcp; 1936 struct be_rx_compl_info *rxcp;
1674 u32 work_done; 1937 u32 work_done;
1675 1938
1676 adapter->stats.drvr_stats.be_rx_polls++; 1939 rxo->stats.rx_polls++;
1677 for (work_done = 0; work_done < budget; work_done++) { 1940 for (work_done = 0; work_done < budget; work_done++) {
1678 rxcp = be_rx_compl_get(adapter); 1941 rxcp = be_rx_compl_get(rxo);
1679 if (!rxcp) 1942 if (!rxcp)
1680 break; 1943 break;
1681 1944
1682 if (do_gro(adapter, rxcp)) 1945 /* Ignore flush completions */
1683 be_rx_compl_process_gro(adapter, rxcp); 1946 if (rxcp->num_rcvd && rxcp->pkt_size) {
1684 else 1947 if (do_gro(rxcp))
1685 be_rx_compl_process(adapter, rxcp); 1948 be_rx_compl_process_gro(adapter, rxo, rxcp);
1949 else
1950 be_rx_compl_process(adapter, rxo, rxcp);
1951 } else if (rxcp->pkt_size == 0) {
1952 be_rx_compl_discard(adapter, rxo, rxcp);
1953 }
1686 1954
1687 be_rx_compl_reset(rxcp); 1955 be_rx_stats_update(rxo, rxcp);
1688 } 1956 }
1689 1957
1690 /* Refill the queue */ 1958 /* Refill the queue */
1691 if (atomic_read(&adapter->rx_obj.q.used) < RX_FRAGS_REFILL_WM) 1959 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
1692 be_post_rx_frags(adapter); 1960 be_post_rx_frags(rxo, GFP_ATOMIC);
1693 1961
1694 /* All consumed */ 1962 /* All consumed */
1695 if (work_done < budget) { 1963 if (work_done < budget) {
@@ -1714,12 +1982,12 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1714 struct be_queue_info *tx_cq = &adapter->tx_obj.cq; 1982 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1715 struct be_eth_tx_compl *txcp; 1983 struct be_eth_tx_compl *txcp;
1716 int tx_compl = 0, mcc_compl, status = 0; 1984 int tx_compl = 0, mcc_compl, status = 0;
1717 u16 end_idx; 1985 u16 end_idx, num_wrbs = 0;
1718 1986
1719 while ((txcp = be_tx_compl_get(tx_cq))) { 1987 while ((txcp = be_tx_compl_get(tx_cq))) {
1720 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl, 1988 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1721 wrb_index, txcp); 1989 wrb_index, txcp);
1722 be_tx_compl_process(adapter, end_idx); 1990 num_wrbs += be_tx_compl_process(adapter, end_idx);
1723 tx_compl++; 1991 tx_compl++;
1724 } 1992 }
1725 1993
@@ -1735,6 +2003,8 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1735 if (tx_compl) { 2003 if (tx_compl) {
1736 be_cq_notify(adapter, adapter->tx_obj.cq.id, true, tx_compl); 2004 be_cq_notify(adapter, adapter->tx_obj.cq.id, true, tx_compl);
1737 2005
2006 atomic_sub(num_wrbs, &txq->used);
2007
1738 /* As Tx wrbs have been freed up, wake up netdev queue if 2008 /* As Tx wrbs have been freed up, wake up netdev queue if
1739 * it was stopped due to lack of tx wrbs. 2009 * it was stopped due to lack of tx wrbs.
1740 */ 2010 */
@@ -1743,8 +2013,8 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1743 netif_wake_queue(adapter->netdev); 2013 netif_wake_queue(adapter->netdev);
1744 } 2014 }
1745 2015
1746 drvr_stats(adapter)->be_tx_events++; 2016 tx_stats(adapter)->be_tx_events++;
1747 drvr_stats(adapter)->be_tx_compl += tx_compl; 2017 tx_stats(adapter)->be_tx_compl += tx_compl;
1748 } 2018 }
1749 2019
1750 return 1; 2020 return 1;
@@ -1769,6 +2039,7 @@ void be_detect_dump_ue(struct be_adapter *adapter)
1769 2039
1770 if (ue_status_lo || ue_status_hi) { 2040 if (ue_status_lo || ue_status_hi) {
1771 adapter->ue_detected = true; 2041 adapter->ue_detected = true;
2042 adapter->eeh_err = true;
1772 dev_err(&adapter->pdev->dev, "UE Detected!!\n"); 2043 dev_err(&adapter->pdev->dev, "UE Detected!!\n");
1773 } 2044 }
1774 2045
@@ -1793,45 +2064,82 @@ static void be_worker(struct work_struct *work)
1793{ 2064{
1794 struct be_adapter *adapter = 2065 struct be_adapter *adapter =
1795 container_of(work, struct be_adapter, work.work); 2066 container_of(work, struct be_adapter, work.work);
2067 struct be_rx_obj *rxo;
2068 int i;
2069
2070 if (!adapter->ue_detected && !lancer_chip(adapter))
2071 be_detect_dump_ue(adapter);
2072
2073 /* when interrupts are not yet enabled, just reap any pending
2074 * mcc completions */
2075 if (!netif_running(adapter->netdev)) {
2076 int mcc_compl, status = 0;
2077
2078 mcc_compl = be_process_mcc(adapter, &status);
1796 2079
1797 if (!adapter->stats_ioctl_sent) 2080 if (mcc_compl) {
1798 be_cmd_get_stats(adapter, &adapter->stats.cmd); 2081 struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
2082 be_cq_notify(adapter, mcc_obj->cq.id, false, mcc_compl);
2083 }
1799 2084
1800 /* Set EQ delay */ 2085 goto reschedule;
1801 be_rx_eqd_update(adapter); 2086 }
1802 2087
2088 if (!adapter->stats_cmd_sent) {
2089 if (lancer_chip(adapter))
2090 lancer_cmd_get_pport_stats(adapter,
2091 &adapter->stats_cmd);
2092 else
2093 be_cmd_get_stats(adapter, &adapter->stats_cmd);
2094 }
1803 be_tx_rate_update(adapter); 2095 be_tx_rate_update(adapter);
1804 be_rx_rate_update(adapter);
1805 2096
1806 if (adapter->rx_post_starved) { 2097 for_all_rx_queues(adapter, rxo, i) {
1807 adapter->rx_post_starved = false; 2098 be_rx_rate_update(rxo);
1808 be_post_rx_frags(adapter); 2099 be_rx_eqd_update(adapter, rxo);
2100
2101 if (rxo->rx_post_starved) {
2102 rxo->rx_post_starved = false;
2103 be_post_rx_frags(rxo, GFP_KERNEL);
2104 }
1809 } 2105 }
1810 if (!adapter->ue_detected)
1811 be_detect_dump_ue(adapter);
1812 2106
2107reschedule:
2108 adapter->work_counter++;
1813 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000)); 2109 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
1814} 2110}
1815 2111
1816static void be_msix_disable(struct be_adapter *adapter) 2112static void be_msix_disable(struct be_adapter *adapter)
1817{ 2113{
1818 if (adapter->msix_enabled) { 2114 if (msix_enabled(adapter)) {
1819 pci_disable_msix(adapter->pdev); 2115 pci_disable_msix(adapter->pdev);
1820 adapter->msix_enabled = false; 2116 adapter->num_msix_vec = 0;
1821 } 2117 }
1822} 2118}
1823 2119
1824static void be_msix_enable(struct be_adapter *adapter) 2120static void be_msix_enable(struct be_adapter *adapter)
1825{ 2121{
1826 int i, status; 2122#define BE_MIN_MSIX_VECTORS (1 + 1) /* Rx + Tx */
2123 int i, status, num_vec;
1827 2124
1828 for (i = 0; i < BE_NUM_MSIX_VECTORS; i++) 2125 num_vec = be_num_rxqs_want(adapter) + 1;
2126
2127 for (i = 0; i < num_vec; i++)
1829 adapter->msix_entries[i].entry = i; 2128 adapter->msix_entries[i].entry = i;
1830 2129
1831 status = pci_enable_msix(adapter->pdev, adapter->msix_entries, 2130 status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
1832 BE_NUM_MSIX_VECTORS); 2131 if (status == 0) {
1833 if (status == 0) 2132 goto done;
1834 adapter->msix_enabled = true; 2133 } else if (status >= BE_MIN_MSIX_VECTORS) {
2134 num_vec = status;
2135 if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
2136 num_vec) == 0)
2137 goto done;
2138 }
2139 return;
2140done:
2141 adapter->num_msix_vec = num_vec;
2142 return;
1835} 2143}
1836 2144
1837static void be_sriov_enable(struct be_adapter *adapter) 2145static void be_sriov_enable(struct be_adapter *adapter)
@@ -1839,7 +2147,20 @@ static void be_sriov_enable(struct be_adapter *adapter)
1839 be_check_sriov_fn_type(adapter); 2147 be_check_sriov_fn_type(adapter);
1840#ifdef CONFIG_PCI_IOV 2148#ifdef CONFIG_PCI_IOV
1841 if (be_physfn(adapter) && num_vfs) { 2149 if (be_physfn(adapter) && num_vfs) {
1842 int status; 2150 int status, pos;
2151 u16 nvfs;
2152
2153 pos = pci_find_ext_capability(adapter->pdev,
2154 PCI_EXT_CAP_ID_SRIOV);
2155 pci_read_config_word(adapter->pdev,
2156 pos + PCI_SRIOV_TOTAL_VF, &nvfs);
2157
2158 if (num_vfs > nvfs) {
2159 dev_info(&adapter->pdev->dev,
2160 "Device supports %d VFs and not %d\n",
2161 nvfs, num_vfs);
2162 num_vfs = nvfs;
2163 }
1843 2164
1844 status = pci_enable_sriov(adapter->pdev, num_vfs); 2165 status = pci_enable_sriov(adapter->pdev, num_vfs);
1845 adapter->sriov_enabled = status ? false : true; 2166 adapter->sriov_enabled = status ? false : true;
@@ -1857,51 +2178,62 @@ static void be_sriov_disable(struct be_adapter *adapter)
1857#endif 2178#endif
1858} 2179}
1859 2180
1860static inline int be_msix_vec_get(struct be_adapter *adapter, u32 eq_id) 2181static inline int be_msix_vec_get(struct be_adapter *adapter,
2182 struct be_eq_obj *eq_obj)
1861{ 2183{
1862 return adapter->msix_entries[ 2184 return adapter->msix_entries[eq_obj->eq_idx].vector;
1863 be_evt_bit_get(adapter, eq_id)].vector;
1864} 2185}
1865 2186
1866static int be_request_irq(struct be_adapter *adapter, 2187static int be_request_irq(struct be_adapter *adapter,
1867 struct be_eq_obj *eq_obj, 2188 struct be_eq_obj *eq_obj,
1868 void *handler, char *desc) 2189 void *handler, char *desc, void *context)
1869{ 2190{
1870 struct net_device *netdev = adapter->netdev; 2191 struct net_device *netdev = adapter->netdev;
1871 int vec; 2192 int vec;
1872 2193
1873 sprintf(eq_obj->desc, "%s-%s", netdev->name, desc); 2194 sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
1874 vec = be_msix_vec_get(adapter, eq_obj->q.id); 2195 vec = be_msix_vec_get(adapter, eq_obj);
1875 return request_irq(vec, handler, 0, eq_obj->desc, adapter); 2196 return request_irq(vec, handler, 0, eq_obj->desc, context);
1876} 2197}
1877 2198
1878static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj) 2199static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj,
2200 void *context)
1879{ 2201{
1880 int vec = be_msix_vec_get(adapter, eq_obj->q.id); 2202 int vec = be_msix_vec_get(adapter, eq_obj);
1881 free_irq(vec, adapter); 2203 free_irq(vec, context);
1882} 2204}
1883 2205
1884static int be_msix_register(struct be_adapter *adapter) 2206static int be_msix_register(struct be_adapter *adapter)
1885{ 2207{
1886 int status; 2208 struct be_rx_obj *rxo;
2209 int status, i;
2210 char qname[10];
1887 2211
1888 status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx"); 2212 status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx",
2213 adapter);
1889 if (status) 2214 if (status)
1890 goto err; 2215 goto err;
1891 2216
1892 status = be_request_irq(adapter, &adapter->rx_eq, be_msix_rx, "rx"); 2217 for_all_rx_queues(adapter, rxo, i) {
1893 if (status) 2218 sprintf(qname, "rxq%d", i);
1894 goto free_tx_irq; 2219 status = be_request_irq(adapter, &rxo->rx_eq, be_msix_rx,
2220 qname, rxo);
2221 if (status)
2222 goto err_msix;
2223 }
1895 2224
1896 return 0; 2225 return 0;
1897 2226
1898free_tx_irq: 2227err_msix:
1899 be_free_irq(adapter, &adapter->tx_eq); 2228 be_free_irq(adapter, &adapter->tx_eq, adapter);
2229
2230 for (i--, rxo = &adapter->rx_obj[i]; i >= 0; i--, rxo--)
2231 be_free_irq(adapter, &rxo->rx_eq, rxo);
2232
1900err: 2233err:
1901 dev_warn(&adapter->pdev->dev, 2234 dev_warn(&adapter->pdev->dev,
1902 "MSIX Request IRQ failed - err %d\n", status); 2235 "MSIX Request IRQ failed - err %d\n", status);
1903 pci_disable_msix(adapter->pdev); 2236 be_msix_disable(adapter);
1904 adapter->msix_enabled = false;
1905 return status; 2237 return status;
1906} 2238}
1907 2239
@@ -1910,7 +2242,7 @@ static int be_irq_register(struct be_adapter *adapter)
1910 struct net_device *netdev = adapter->netdev; 2242 struct net_device *netdev = adapter->netdev;
1911 int status; 2243 int status;
1912 2244
1913 if (adapter->msix_enabled) { 2245 if (msix_enabled(adapter)) {
1914 status = be_msix_register(adapter); 2246 status = be_msix_register(adapter);
1915 if (status == 0) 2247 if (status == 0)
1916 goto done; 2248 goto done;
@@ -1936,19 +2268,24 @@ done:
1936static void be_irq_unregister(struct be_adapter *adapter) 2268static void be_irq_unregister(struct be_adapter *adapter)
1937{ 2269{
1938 struct net_device *netdev = adapter->netdev; 2270 struct net_device *netdev = adapter->netdev;
2271 struct be_rx_obj *rxo;
2272 int i;
1939 2273
1940 if (!adapter->isr_registered) 2274 if (!adapter->isr_registered)
1941 return; 2275 return;
1942 2276
1943 /* INTx */ 2277 /* INTx */
1944 if (!adapter->msix_enabled) { 2278 if (!msix_enabled(adapter)) {
1945 free_irq(netdev->irq, adapter); 2279 free_irq(netdev->irq, adapter);
1946 goto done; 2280 goto done;
1947 } 2281 }
1948 2282
1949 /* MSIx */ 2283 /* MSIx */
1950 be_free_irq(adapter, &adapter->tx_eq); 2284 be_free_irq(adapter, &adapter->tx_eq, adapter);
1951 be_free_irq(adapter, &adapter->rx_eq); 2285
2286 for_all_rx_queues(adapter, rxo, i)
2287 be_free_irq(adapter, &rxo->rx_eq, rxo);
2288
1952done: 2289done:
1953 adapter->isr_registered = false; 2290 adapter->isr_registered = false;
1954} 2291}
@@ -1956,33 +2293,43 @@ done:
1956static int be_close(struct net_device *netdev) 2293static int be_close(struct net_device *netdev)
1957{ 2294{
1958 struct be_adapter *adapter = netdev_priv(netdev); 2295 struct be_adapter *adapter = netdev_priv(netdev);
1959 struct be_eq_obj *rx_eq = &adapter->rx_eq; 2296 struct be_rx_obj *rxo;
1960 struct be_eq_obj *tx_eq = &adapter->tx_eq; 2297 struct be_eq_obj *tx_eq = &adapter->tx_eq;
1961 int vec; 2298 int vec, i;
1962
1963 cancel_delayed_work_sync(&adapter->work);
1964 2299
1965 be_async_mcc_disable(adapter); 2300 be_async_mcc_disable(adapter);
1966 2301
1967 netif_stop_queue(netdev);
1968 netif_carrier_off(netdev); 2302 netif_carrier_off(netdev);
1969 adapter->link_up = false; 2303 adapter->link_up = false;
1970 2304
1971 be_intr_set(adapter, false); 2305 if (!lancer_chip(adapter))
2306 be_intr_set(adapter, false);
1972 2307
1973 if (adapter->msix_enabled) { 2308 for_all_rx_queues(adapter, rxo, i)
1974 vec = be_msix_vec_get(adapter, tx_eq->q.id); 2309 napi_disable(&rxo->rx_eq.napi);
1975 synchronize_irq(vec); 2310
1976 vec = be_msix_vec_get(adapter, rx_eq->q.id); 2311 napi_disable(&tx_eq->napi);
2312
2313 if (lancer_chip(adapter)) {
2314 be_cq_notify(adapter, adapter->tx_obj.cq.id, false, 0);
2315 be_cq_notify(adapter, adapter->mcc_obj.cq.id, false, 0);
2316 for_all_rx_queues(adapter, rxo, i)
2317 be_cq_notify(adapter, rxo->cq.id, false, 0);
2318 }
2319
2320 if (msix_enabled(adapter)) {
2321 vec = be_msix_vec_get(adapter, tx_eq);
1977 synchronize_irq(vec); 2322 synchronize_irq(vec);
2323
2324 for_all_rx_queues(adapter, rxo, i) {
2325 vec = be_msix_vec_get(adapter, &rxo->rx_eq);
2326 synchronize_irq(vec);
2327 }
1978 } else { 2328 } else {
1979 synchronize_irq(netdev->irq); 2329 synchronize_irq(netdev->irq);
1980 } 2330 }
1981 be_irq_unregister(adapter); 2331 be_irq_unregister(adapter);
1982 2332
1983 napi_disable(&rx_eq->napi);
1984 napi_disable(&tx_eq->napi);
1985
1986 /* Wait for all pending tx completions to arrive so that 2333 /* Wait for all pending tx completions to arrive so that
1987 * all tx skbs are freed. 2334 * all tx skbs are freed.
1988 */ 2335 */
@@ -1994,37 +2341,36 @@ static int be_close(struct net_device *netdev)
1994static int be_open(struct net_device *netdev) 2341static int be_open(struct net_device *netdev)
1995{ 2342{
1996 struct be_adapter *adapter = netdev_priv(netdev); 2343 struct be_adapter *adapter = netdev_priv(netdev);
1997 struct be_eq_obj *rx_eq = &adapter->rx_eq;
1998 struct be_eq_obj *tx_eq = &adapter->tx_eq; 2344 struct be_eq_obj *tx_eq = &adapter->tx_eq;
2345 struct be_rx_obj *rxo;
1999 bool link_up; 2346 bool link_up;
2000 int status; 2347 int status, i;
2001 u8 mac_speed; 2348 u8 mac_speed;
2002 u16 link_speed; 2349 u16 link_speed;
2003 2350
2004 /* First time posting */ 2351 for_all_rx_queues(adapter, rxo, i) {
2005 be_post_rx_frags(adapter); 2352 be_post_rx_frags(rxo, GFP_KERNEL);
2006 2353 napi_enable(&rxo->rx_eq.napi);
2007 napi_enable(&rx_eq->napi); 2354 }
2008 napi_enable(&tx_eq->napi); 2355 napi_enable(&tx_eq->napi);
2009 2356
2010 be_irq_register(adapter); 2357 be_irq_register(adapter);
2011 2358
2012 be_intr_set(adapter, true); 2359 if (!lancer_chip(adapter))
2360 be_intr_set(adapter, true);
2013 2361
2014 /* The evt queues are created in unarmed state; arm them */ 2362 /* The evt queues are created in unarmed state; arm them */
2015 be_eq_notify(adapter, rx_eq->q.id, true, false, 0); 2363 for_all_rx_queues(adapter, rxo, i) {
2364 be_eq_notify(adapter, rxo->rx_eq.q.id, true, false, 0);
2365 be_cq_notify(adapter, rxo->cq.id, true, 0);
2366 }
2016 be_eq_notify(adapter, tx_eq->q.id, true, false, 0); 2367 be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
2017 2368
2018 /* Rx compl queue may be in unarmed state; rearm it */
2019 be_cq_notify(adapter, adapter->rx_obj.cq.id, true, 0);
2020
2021 /* Now that interrupts are on we can process async mcc */ 2369 /* Now that interrupts are on we can process async mcc */
2022 be_async_mcc_enable(adapter); 2370 be_async_mcc_enable(adapter);
2023 2371
2024 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
2025
2026 status = be_cmd_link_status_query(adapter, &link_up, &mac_speed, 2372 status = be_cmd_link_status_query(adapter, &link_up, &mac_speed,
2027 &link_speed); 2373 &link_speed, 0);
2028 if (status) 2374 if (status)
2029 goto err; 2375 goto err;
2030 be_link_status_update(adapter, link_up); 2376 be_link_status_update(adapter, link_up);
@@ -2055,7 +2401,8 @@ static int be_setup_wol(struct be_adapter *adapter, bool enable)
2055 memset(mac, 0, ETH_ALEN); 2401 memset(mac, 0, ETH_ALEN);
2056 2402
2057 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config); 2403 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2058 cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma); 2404 cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
2405 GFP_KERNEL);
2059 if (cmd.va == NULL) 2406 if (cmd.va == NULL)
2060 return -1; 2407 return -1;
2061 memset(cmd.va, 0, cmd.size); 2408 memset(cmd.va, 0, cmd.size);
@@ -2066,8 +2413,8 @@ static int be_setup_wol(struct be_adapter *adapter, bool enable)
2066 if (status) { 2413 if (status) {
2067 dev_err(&adapter->pdev->dev, 2414 dev_err(&adapter->pdev->dev,
2068 "Could not enable Wake-on-lan\n"); 2415 "Could not enable Wake-on-lan\n");
2069 pci_free_consistent(adapter->pdev, cmd.size, cmd.va, 2416 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
2070 cmd.dma); 2417 cmd.dma);
2071 return status; 2418 return status;
2072 } 2419 }
2073 status = be_cmd_enable_magic_wol(adapter, 2420 status = be_cmd_enable_magic_wol(adapter,
@@ -2080,10 +2427,52 @@ static int be_setup_wol(struct be_adapter *adapter, bool enable)
2080 pci_enable_wake(adapter->pdev, PCI_D3cold, 0); 2427 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2081 } 2428 }
2082 2429
2083 pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma); 2430 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2431 return status;
2432}
2433
2434/*
2435 * Generate a seed MAC address from the PF MAC Address using jhash.
2436 * MAC Address for VFs are assigned incrementally starting from the seed.
2437 * These addresses are programmed in the ASIC by the PF and the VF driver
2438 * queries for the MAC address during its probe.
2439 */
2440static inline int be_vf_eth_addr_config(struct be_adapter *adapter)
2441{
2442 u32 vf = 0;
2443 int status = 0;
2444 u8 mac[ETH_ALEN];
2445
2446 be_vf_eth_addr_generate(adapter, mac);
2447
2448 for (vf = 0; vf < num_vfs; vf++) {
2449 status = be_cmd_pmac_add(adapter, mac,
2450 adapter->vf_cfg[vf].vf_if_handle,
2451 &adapter->vf_cfg[vf].vf_pmac_id,
2452 vf + 1);
2453 if (status)
2454 dev_err(&adapter->pdev->dev,
2455 "Mac address add failed for VF %d\n", vf);
2456 else
2457 memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
2458
2459 mac[5] += 1;
2460 }
2084 return status; 2461 return status;
2085} 2462}
2086 2463
2464static inline void be_vf_eth_addr_rem(struct be_adapter *adapter)
2465{
2466 u32 vf;
2467
2468 for (vf = 0; vf < num_vfs; vf++) {
2469 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
2470 be_cmd_pmac_del(adapter,
2471 adapter->vf_cfg[vf].vf_if_handle,
2472 adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
2473 }
2474}
2475
2087static int be_setup(struct be_adapter *adapter) 2476static int be_setup(struct be_adapter *adapter)
2088{ 2477{
2089 struct net_device *netdev = adapter->netdev; 2478 struct net_device *netdev = adapter->netdev;
@@ -2091,13 +2480,20 @@ static int be_setup(struct be_adapter *adapter)
2091 int status; 2480 int status;
2092 u8 mac[ETH_ALEN]; 2481 u8 mac[ETH_ALEN];
2093 2482
2094 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST; 2483 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED |
2484 BE_IF_FLAGS_BROADCAST |
2485 BE_IF_FLAGS_MULTICAST;
2095 2486
2096 if (be_physfn(adapter)) { 2487 if (be_physfn(adapter)) {
2097 cap_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS | 2488 cap_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS |
2098 BE_IF_FLAGS_PROMISCUOUS | 2489 BE_IF_FLAGS_PROMISCUOUS |
2099 BE_IF_FLAGS_PASS_L3L4_ERRORS; 2490 BE_IF_FLAGS_PASS_L3L4_ERRORS;
2100 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS; 2491 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS;
2492
2493 if (adapter->function_caps & BE_FUNCTION_CAPS_RSS) {
2494 cap_flags |= BE_IF_FLAGS_RSS;
2495 en_flags |= BE_IF_FLAGS_RSS;
2496 }
2101 } 2497 }
2102 2498
2103 status = be_cmd_if_create(adapter, cap_flags, en_flags, 2499 status = be_cmd_if_create(adapter, cap_flags, en_flags,
@@ -2107,22 +2503,26 @@ static int be_setup(struct be_adapter *adapter)
2107 goto do_none; 2503 goto do_none;
2108 2504
2109 if (be_physfn(adapter)) { 2505 if (be_physfn(adapter)) {
2110 while (vf < num_vfs) { 2506 if (adapter->sriov_enabled) {
2111 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED 2507 while (vf < num_vfs) {
2112 | BE_IF_FLAGS_BROADCAST; 2508 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED |
2113 status = be_cmd_if_create(adapter, cap_flags, en_flags, 2509 BE_IF_FLAGS_BROADCAST;
2114 mac, true, 2510 status = be_cmd_if_create(adapter, cap_flags,
2511 en_flags, mac, true,
2115 &adapter->vf_cfg[vf].vf_if_handle, 2512 &adapter->vf_cfg[vf].vf_if_handle,
2116 NULL, vf+1); 2513 NULL, vf+1);
2117 if (status) { 2514 if (status) {
2118 dev_err(&adapter->pdev->dev, 2515 dev_err(&adapter->pdev->dev,
2119 "Interface Create failed for VF %d\n", vf); 2516 "Interface Create failed for VF %d\n",
2120 goto if_destroy; 2517 vf);
2518 goto if_destroy;
2519 }
2520 adapter->vf_cfg[vf].vf_pmac_id =
2521 BE_INVALID_PMAC_ID;
2522 vf++;
2121 } 2523 }
2122 adapter->vf_cfg[vf].vf_pmac_id = BE_INVALID_PMAC_ID;
2123 vf++;
2124 } 2524 }
2125 } else if (!be_physfn(adapter)) { 2525 } else {
2126 status = be_cmd_mac_addr_query(adapter, mac, 2526 status = be_cmd_mac_addr_query(adapter, mac,
2127 MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle); 2527 MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
2128 if (!status) { 2528 if (!status) {
@@ -2152,22 +2552,37 @@ rx_qs_destroy:
2152tx_qs_destroy: 2552tx_qs_destroy:
2153 be_tx_queues_destroy(adapter); 2553 be_tx_queues_destroy(adapter);
2154if_destroy: 2554if_destroy:
2155 for (vf = 0; vf < num_vfs; vf++) 2555 if (be_physfn(adapter) && adapter->sriov_enabled)
2156 if (adapter->vf_cfg[vf].vf_if_handle) 2556 for (vf = 0; vf < num_vfs; vf++)
2157 be_cmd_if_destroy(adapter, 2557 if (adapter->vf_cfg[vf].vf_if_handle)
2158 adapter->vf_cfg[vf].vf_if_handle); 2558 be_cmd_if_destroy(adapter,
2159 be_cmd_if_destroy(adapter, adapter->if_handle); 2559 adapter->vf_cfg[vf].vf_if_handle,
2560 vf + 1);
2561 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
2160do_none: 2562do_none:
2161 return status; 2563 return status;
2162} 2564}
2163 2565
2164static int be_clear(struct be_adapter *adapter) 2566static int be_clear(struct be_adapter *adapter)
2165{ 2567{
2568 int vf;
2569
2570 if (be_physfn(adapter) && adapter->sriov_enabled)
2571 be_vf_eth_addr_rem(adapter);
2572
2166 be_mcc_queues_destroy(adapter); 2573 be_mcc_queues_destroy(adapter);
2167 be_rx_queues_destroy(adapter); 2574 be_rx_queues_destroy(adapter);
2168 be_tx_queues_destroy(adapter); 2575 be_tx_queues_destroy(adapter);
2576 adapter->eq_next_idx = 0;
2577
2578 if (be_physfn(adapter) && adapter->sriov_enabled)
2579 for (vf = 0; vf < num_vfs; vf++)
2580 if (adapter->vf_cfg[vf].vf_if_handle)
2581 be_cmd_if_destroy(adapter,
2582 adapter->vf_cfg[vf].vf_if_handle,
2583 vf + 1);
2169 2584
2170 be_cmd_if_destroy(adapter, adapter->if_handle); 2585 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
2171 2586
2172 /* tell fw we're done with firing cmds */ 2587 /* tell fw we're done with firing cmds */
2173 be_cmd_fw_clean(adapter); 2588 be_cmd_fw_clean(adapter);
@@ -2176,9 +2591,6 @@ static int be_clear(struct be_adapter *adapter)
2176 2591
2177 2592
2178#define FW_FILE_HDR_SIGN "ServerEngines Corp. " 2593#define FW_FILE_HDR_SIGN "ServerEngines Corp. "
2179char flash_cookie[2][16] = {"*** SE FLAS",
2180 "H DIRECTORY *** "};
2181
2182static bool be_flash_redboot(struct be_adapter *adapter, 2594static bool be_flash_redboot(struct be_adapter *adapter,
2183 const u8 *p, u32 img_start, int image_size, 2595 const u8 *p, u32 img_start, int image_size,
2184 int hdr_size) 2596 int hdr_size)
@@ -2216,10 +2628,10 @@ static int be_flash_data(struct be_adapter *adapter,
2216 int num_bytes; 2628 int num_bytes;
2217 const u8 *p = fw->data; 2629 const u8 *p = fw->data;
2218 struct be_cmd_write_flashrom *req = flash_cmd->va; 2630 struct be_cmd_write_flashrom *req = flash_cmd->va;
2219 struct flash_comp *pflashcomp; 2631 const struct flash_comp *pflashcomp;
2220 int num_comp; 2632 int num_comp;
2221 2633
2222 struct flash_comp gen3_flash_types[9] = { 2634 static const struct flash_comp gen3_flash_types[9] = {
2223 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE, 2635 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE,
2224 FLASH_IMAGE_MAX_SIZE_g3}, 2636 FLASH_IMAGE_MAX_SIZE_g3},
2225 { FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT, 2637 { FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT,
@@ -2239,7 +2651,7 @@ static int be_flash_data(struct be_adapter *adapter,
2239 { FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW, 2651 { FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2240 FLASH_NCSI_IMAGE_MAX_SIZE_g3} 2652 FLASH_NCSI_IMAGE_MAX_SIZE_g3}
2241 }; 2653 };
2242 struct flash_comp gen2_flash_types[8] = { 2654 static const struct flash_comp gen2_flash_types[8] = {
2243 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE, 2655 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE,
2244 FLASH_IMAGE_MAX_SIZE_g2}, 2656 FLASH_IMAGE_MAX_SIZE_g2},
2245 { FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT, 2657 { FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT,
@@ -2261,11 +2673,11 @@ static int be_flash_data(struct be_adapter *adapter,
2261 if (adapter->generation == BE_GEN3) { 2673 if (adapter->generation == BE_GEN3) {
2262 pflashcomp = gen3_flash_types; 2674 pflashcomp = gen3_flash_types;
2263 filehdr_size = sizeof(struct flash_file_hdr_g3); 2675 filehdr_size = sizeof(struct flash_file_hdr_g3);
2264 num_comp = 9; 2676 num_comp = ARRAY_SIZE(gen3_flash_types);
2265 } else { 2677 } else {
2266 pflashcomp = gen2_flash_types; 2678 pflashcomp = gen2_flash_types;
2267 filehdr_size = sizeof(struct flash_file_hdr_g2); 2679 filehdr_size = sizeof(struct flash_file_hdr_g2);
2268 num_comp = 8; 2680 num_comp = ARRAY_SIZE(gen2_flash_types);
2269 } 2681 }
2270 for (i = 0; i < num_comp; i++) { 2682 for (i = 0; i < num_comp; i++) {
2271 if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) && 2683 if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) &&
@@ -2273,8 +2685,8 @@ static int be_flash_data(struct be_adapter *adapter,
2273 continue; 2685 continue;
2274 if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) && 2686 if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
2275 (!be_flash_redboot(adapter, fw->data, 2687 (!be_flash_redboot(adapter, fw->data,
2276 pflashcomp[i].offset, pflashcomp[i].size, 2688 pflashcomp[i].offset, pflashcomp[i].size, filehdr_size +
2277 filehdr_size))) 2689 (num_of_images * sizeof(struct image_hdr)))))
2278 continue; 2690 continue;
2279 p = fw->data; 2691 p = fw->data;
2280 p += filehdr_size + pflashcomp[i].offset 2692 p += filehdr_size + pflashcomp[i].offset
@@ -2302,7 +2714,6 @@ static int be_flash_data(struct be_adapter *adapter,
2302 "cmd to write to flash rom failed.\n"); 2714 "cmd to write to flash rom failed.\n");
2303 return -1; 2715 return -1;
2304 } 2716 }
2305 yield();
2306 } 2717 }
2307 } 2718 }
2308 return 0; 2719 return 0;
@@ -2320,35 +2731,105 @@ static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
2320 return 0; 2731 return 0;
2321} 2732}
2322 2733
2323int be_load_fw(struct be_adapter *adapter, u8 *func) 2734static int lancer_fw_download(struct be_adapter *adapter,
2735 const struct firmware *fw)
2736{
2737#define LANCER_FW_DOWNLOAD_CHUNK (32 * 1024)
2738#define LANCER_FW_DOWNLOAD_LOCATION "/prg"
2739 struct be_dma_mem flash_cmd;
2740 const u8 *data_ptr = NULL;
2741 u8 *dest_image_ptr = NULL;
2742 size_t image_size = 0;
2743 u32 chunk_size = 0;
2744 u32 data_written = 0;
2745 u32 offset = 0;
2746 int status = 0;
2747 u8 add_status = 0;
2748
2749 if (!IS_ALIGNED(fw->size, sizeof(u32))) {
2750 dev_err(&adapter->pdev->dev,
2751 "FW Image not properly aligned. "
2752 "Length must be 4 byte aligned.\n");
2753 status = -EINVAL;
2754 goto lancer_fw_exit;
2755 }
2756
2757 flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
2758 + LANCER_FW_DOWNLOAD_CHUNK;
2759 flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
2760 &flash_cmd.dma, GFP_KERNEL);
2761 if (!flash_cmd.va) {
2762 status = -ENOMEM;
2763 dev_err(&adapter->pdev->dev,
2764 "Memory allocation failure while flashing\n");
2765 goto lancer_fw_exit;
2766 }
2767
2768 dest_image_ptr = flash_cmd.va +
2769 sizeof(struct lancer_cmd_req_write_object);
2770 image_size = fw->size;
2771 data_ptr = fw->data;
2772
2773 while (image_size) {
2774 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
2775
2776 /* Copy the image chunk content. */
2777 memcpy(dest_image_ptr, data_ptr, chunk_size);
2778
2779 status = lancer_cmd_write_object(adapter, &flash_cmd,
2780 chunk_size, offset, LANCER_FW_DOWNLOAD_LOCATION,
2781 &data_written, &add_status);
2782
2783 if (status)
2784 break;
2785
2786 offset += data_written;
2787 data_ptr += data_written;
2788 image_size -= data_written;
2789 }
2790
2791 if (!status) {
2792 /* Commit the FW written */
2793 status = lancer_cmd_write_object(adapter, &flash_cmd,
2794 0, offset, LANCER_FW_DOWNLOAD_LOCATION,
2795 &data_written, &add_status);
2796 }
2797
2798 dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
2799 flash_cmd.dma);
2800 if (status) {
2801 dev_err(&adapter->pdev->dev,
2802 "Firmware load error. "
2803 "Status code: 0x%x Additional Status: 0x%x\n",
2804 status, add_status);
2805 goto lancer_fw_exit;
2806 }
2807
2808 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
2809lancer_fw_exit:
2810 return status;
2811}
2812
2813static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
2324{ 2814{
2325 char fw_file[ETHTOOL_FLASH_MAX_FILENAME];
2326 const struct firmware *fw;
2327 struct flash_file_hdr_g2 *fhdr; 2815 struct flash_file_hdr_g2 *fhdr;
2328 struct flash_file_hdr_g3 *fhdr3; 2816 struct flash_file_hdr_g3 *fhdr3;
2329 struct image_hdr *img_hdr_ptr = NULL; 2817 struct image_hdr *img_hdr_ptr = NULL;
2330 struct be_dma_mem flash_cmd; 2818 struct be_dma_mem flash_cmd;
2331 int status, i = 0, num_imgs = 0;
2332 const u8 *p; 2819 const u8 *p;
2333 2820 int status = 0, i = 0, num_imgs = 0;
2334 strcpy(fw_file, func);
2335
2336 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
2337 if (status)
2338 goto fw_exit;
2339 2821
2340 p = fw->data; 2822 p = fw->data;
2341 fhdr = (struct flash_file_hdr_g2 *) p; 2823 fhdr = (struct flash_file_hdr_g2 *) p;
2342 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
2343 2824
2344 flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024; 2825 flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
2345 flash_cmd.va = pci_alloc_consistent(adapter->pdev, flash_cmd.size, 2826 flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
2346 &flash_cmd.dma); 2827 &flash_cmd.dma, GFP_KERNEL);
2347 if (!flash_cmd.va) { 2828 if (!flash_cmd.va) {
2348 status = -ENOMEM; 2829 status = -ENOMEM;
2349 dev_err(&adapter->pdev->dev, 2830 dev_err(&adapter->pdev->dev,
2350 "Memory allocation failure while flashing\n"); 2831 "Memory allocation failure while flashing\n");
2351 goto fw_exit; 2832 goto be_fw_exit;
2352 } 2833 }
2353 2834
2354 if ((adapter->generation == BE_GEN3) && 2835 if ((adapter->generation == BE_GEN3) &&
@@ -2372,15 +2853,41 @@ int be_load_fw(struct be_adapter *adapter, u8 *func)
2372 status = -1; 2853 status = -1;
2373 } 2854 }
2374 2855
2375 pci_free_consistent(adapter->pdev, flash_cmd.size, flash_cmd.va, 2856 dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
2376 flash_cmd.dma); 2857 flash_cmd.dma);
2377 if (status) { 2858 if (status) {
2378 dev_err(&adapter->pdev->dev, "Firmware load error\n"); 2859 dev_err(&adapter->pdev->dev, "Firmware load error\n");
2379 goto fw_exit; 2860 goto be_fw_exit;
2380 } 2861 }
2381 2862
2382 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n"); 2863 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
2383 2864
2865be_fw_exit:
2866 return status;
2867}
2868
2869int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
2870{
2871 const struct firmware *fw;
2872 int status;
2873
2874 if (!netif_running(adapter->netdev)) {
2875 dev_err(&adapter->pdev->dev,
2876 "Firmware load not allowed (interface is down)\n");
2877 return -1;
2878 }
2879
2880 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
2881 if (status)
2882 goto fw_exit;
2883
2884 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
2885
2886 if (lancer_chip(adapter))
2887 status = lancer_fw_download(adapter, fw);
2888 else
2889 status = be_fw_download(adapter, fw);
2890
2384fw_exit: 2891fw_exit:
2385 release_firmware(fw); 2892 release_firmware(fw);
2386 return status; 2893 return status;
@@ -2390,7 +2897,6 @@ static struct net_device_ops be_netdev_ops = {
2390 .ndo_open = be_open, 2897 .ndo_open = be_open,
2391 .ndo_stop = be_close, 2898 .ndo_stop = be_close,
2392 .ndo_start_xmit = be_xmit, 2899 .ndo_start_xmit = be_xmit,
2393 .ndo_get_stats = be_get_stats,
2394 .ndo_set_rx_mode = be_set_multicast_list, 2900 .ndo_set_rx_mode = be_set_multicast_list,
2395 .ndo_set_mac_address = be_mac_addr_set, 2901 .ndo_set_mac_address = be_mac_addr_set,
2396 .ndo_change_mtu = be_change_mtu, 2902 .ndo_change_mtu = be_change_mtu,
@@ -2407,16 +2913,25 @@ static struct net_device_ops be_netdev_ops = {
2407static void be_netdev_init(struct net_device *netdev) 2913static void be_netdev_init(struct net_device *netdev)
2408{ 2914{
2409 struct be_adapter *adapter = netdev_priv(netdev); 2915 struct be_adapter *adapter = netdev_priv(netdev);
2916 struct be_rx_obj *rxo;
2917 int i;
2410 2918
2411 netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO | 2919 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2412 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_HW_CSUM | 2920 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
2413 NETIF_F_GRO | NETIF_F_TSO6; 2921 NETIF_F_HW_VLAN_TX;
2922 if (be_multi_rxq(adapter))
2923 netdev->hw_features |= NETIF_F_RXHASH;
2414 2924
2415 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_HW_CSUM; 2925 netdev->features |= netdev->hw_features |
2926 NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
2416 2927
2417 netdev->flags |= IFF_MULTICAST; 2928 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO |
2929 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
2930
2931 if (lancer_chip(adapter))
2932 netdev->vlan_features |= NETIF_F_TSO6;
2418 2933
2419 adapter->rx_csum = true; 2934 netdev->flags |= IFF_MULTICAST;
2420 2935
2421 /* Default settings for Rx and Tx flow control */ 2936 /* Default settings for Rx and Tx flow control */
2422 adapter->rx_fc = true; 2937 adapter->rx_fc = true;
@@ -2428,13 +2943,12 @@ static void be_netdev_init(struct net_device *netdev)
2428 2943
2429 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops); 2944 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
2430 2945
2431 netif_napi_add(netdev, &adapter->rx_eq.napi, be_poll_rx, 2946 for_all_rx_queues(adapter, rxo, i)
2432 BE_NAPI_WEIGHT); 2947 netif_napi_add(netdev, &rxo->rx_eq.napi, be_poll_rx,
2948 BE_NAPI_WEIGHT);
2949
2433 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc, 2950 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
2434 BE_NAPI_WEIGHT); 2951 BE_NAPI_WEIGHT);
2435
2436 netif_carrier_off(netdev);
2437 netif_stop_queue(netdev);
2438} 2952}
2439 2953
2440static void be_unmap_pci_bars(struct be_adapter *adapter) 2954static void be_unmap_pci_bars(struct be_adapter *adapter)
@@ -2452,6 +2966,15 @@ static int be_map_pci_bars(struct be_adapter *adapter)
2452 u8 __iomem *addr; 2966 u8 __iomem *addr;
2453 int pcicfg_reg, db_reg; 2967 int pcicfg_reg, db_reg;
2454 2968
2969 if (lancer_chip(adapter)) {
2970 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 0),
2971 pci_resource_len(adapter->pdev, 0));
2972 if (addr == NULL)
2973 return -ENOMEM;
2974 adapter->db = addr;
2975 return 0;
2976 }
2977
2455 if (be_physfn(adapter)) { 2978 if (be_physfn(adapter)) {
2456 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2), 2979 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
2457 pci_resource_len(adapter->pdev, 2)); 2980 pci_resource_len(adapter->pdev, 2));
@@ -2500,13 +3023,13 @@ static void be_ctrl_cleanup(struct be_adapter *adapter)
2500 be_unmap_pci_bars(adapter); 3023 be_unmap_pci_bars(adapter);
2501 3024
2502 if (mem->va) 3025 if (mem->va)
2503 pci_free_consistent(adapter->pdev, mem->size, 3026 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
2504 mem->va, mem->dma); 3027 mem->dma);
2505 3028
2506 mem = &adapter->mc_cmd_mem; 3029 mem = &adapter->mc_cmd_mem;
2507 if (mem->va) 3030 if (mem->va)
2508 pci_free_consistent(adapter->pdev, mem->size, 3031 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
2509 mem->va, mem->dma); 3032 mem->dma);
2510} 3033}
2511 3034
2512static int be_ctrl_init(struct be_adapter *adapter) 3035static int be_ctrl_init(struct be_adapter *adapter)
@@ -2521,8 +3044,10 @@ static int be_ctrl_init(struct be_adapter *adapter)
2521 goto done; 3044 goto done;
2522 3045
2523 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16; 3046 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
2524 mbox_mem_alloc->va = pci_alloc_consistent(adapter->pdev, 3047 mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
2525 mbox_mem_alloc->size, &mbox_mem_alloc->dma); 3048 mbox_mem_alloc->size,
3049 &mbox_mem_alloc->dma,
3050 GFP_KERNEL);
2526 if (!mbox_mem_alloc->va) { 3051 if (!mbox_mem_alloc->va) {
2527 status = -ENOMEM; 3052 status = -ENOMEM;
2528 goto unmap_pci_bars; 3053 goto unmap_pci_bars;
@@ -2534,15 +3059,16 @@ static int be_ctrl_init(struct be_adapter *adapter)
2534 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox)); 3059 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
2535 3060
2536 mc_cmd_mem->size = sizeof(struct be_cmd_req_mcast_mac_config); 3061 mc_cmd_mem->size = sizeof(struct be_cmd_req_mcast_mac_config);
2537 mc_cmd_mem->va = pci_alloc_consistent(adapter->pdev, mc_cmd_mem->size, 3062 mc_cmd_mem->va = dma_alloc_coherent(&adapter->pdev->dev,
2538 &mc_cmd_mem->dma); 3063 mc_cmd_mem->size, &mc_cmd_mem->dma,
3064 GFP_KERNEL);
2539 if (mc_cmd_mem->va == NULL) { 3065 if (mc_cmd_mem->va == NULL) {
2540 status = -ENOMEM; 3066 status = -ENOMEM;
2541 goto free_mbox; 3067 goto free_mbox;
2542 } 3068 }
2543 memset(mc_cmd_mem->va, 0, mc_cmd_mem->size); 3069 memset(mc_cmd_mem->va, 0, mc_cmd_mem->size);
2544 3070
2545 spin_lock_init(&adapter->mbox_lock); 3071 mutex_init(&adapter->mbox_lock);
2546 spin_lock_init(&adapter->mcc_lock); 3072 spin_lock_init(&adapter->mcc_lock);
2547 spin_lock_init(&adapter->mcc_cq_lock); 3073 spin_lock_init(&adapter->mcc_cq_lock);
2548 3074
@@ -2551,8 +3077,8 @@ static int be_ctrl_init(struct be_adapter *adapter)
2551 return 0; 3077 return 0;
2552 3078
2553free_mbox: 3079free_mbox:
2554 pci_free_consistent(adapter->pdev, mbox_mem_alloc->size, 3080 dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
2555 mbox_mem_alloc->va, mbox_mem_alloc->dma); 3081 mbox_mem_alloc->va, mbox_mem_alloc->dma);
2556 3082
2557unmap_pci_bars: 3083unmap_pci_bars:
2558 be_unmap_pci_bars(adapter); 3084 be_unmap_pci_bars(adapter);
@@ -2563,21 +3089,27 @@ done:
2563 3089
2564static void be_stats_cleanup(struct be_adapter *adapter) 3090static void be_stats_cleanup(struct be_adapter *adapter)
2565{ 3091{
2566 struct be_stats_obj *stats = &adapter->stats; 3092 struct be_dma_mem *cmd = &adapter->stats_cmd;
2567 struct be_dma_mem *cmd = &stats->cmd;
2568 3093
2569 if (cmd->va) 3094 if (cmd->va)
2570 pci_free_consistent(adapter->pdev, cmd->size, 3095 dma_free_coherent(&adapter->pdev->dev, cmd->size,
2571 cmd->va, cmd->dma); 3096 cmd->va, cmd->dma);
2572} 3097}
2573 3098
2574static int be_stats_init(struct be_adapter *adapter) 3099static int be_stats_init(struct be_adapter *adapter)
2575{ 3100{
2576 struct be_stats_obj *stats = &adapter->stats; 3101 struct be_dma_mem *cmd = &adapter->stats_cmd;
2577 struct be_dma_mem *cmd = &stats->cmd;
2578 3102
2579 cmd->size = sizeof(struct be_cmd_req_get_stats); 3103 if (adapter->generation == BE_GEN2) {
2580 cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma); 3104 cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
3105 } else {
3106 if (lancer_chip(adapter))
3107 cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
3108 else
3109 cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
3110 }
3111 cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
3112 GFP_KERNEL);
2581 if (cmd->va == NULL) 3113 if (cmd->va == NULL)
2582 return -1; 3114 return -1;
2583 memset(cmd->va, 0, cmd->size); 3115 memset(cmd->va, 0, cmd->size);
@@ -2591,6 +3123,8 @@ static void __devexit be_remove(struct pci_dev *pdev)
2591 if (!adapter) 3123 if (!adapter)
2592 return; 3124 return;
2593 3125
3126 cancel_delayed_work_sync(&adapter->work);
3127
2594 unregister_netdev(adapter->netdev); 3128 unregister_netdev(adapter->netdev);
2595 3129
2596 be_clear(adapter); 3130 be_clear(adapter);
@@ -2599,6 +3133,7 @@ static void __devexit be_remove(struct pci_dev *pdev)
2599 3133
2600 be_ctrl_cleanup(adapter); 3134 be_ctrl_cleanup(adapter);
2601 3135
3136 kfree(adapter->vf_cfg);
2602 be_sriov_disable(adapter); 3137 be_sriov_disable(adapter);
2603 3138
2604 be_msix_disable(adapter); 3139 be_msix_disable(adapter);
@@ -2619,14 +3154,15 @@ static int be_get_config(struct be_adapter *adapter)
2619 if (status) 3154 if (status)
2620 return status; 3155 return status;
2621 3156
2622 status = be_cmd_query_fw_cfg(adapter, 3157 status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
2623 &adapter->port_num, &adapter->function_mode); 3158 &adapter->function_mode, &adapter->function_caps);
2624 if (status) 3159 if (status)
2625 return status; 3160 return status;
2626 3161
2627 memset(mac, 0, ETH_ALEN); 3162 memset(mac, 0, ETH_ALEN);
2628 3163
2629 if (be_physfn(adapter)) { 3164 /* A default permanent address is given to each VF for Lancer*/
3165 if (be_physfn(adapter) || lancer_chip(adapter)) {
2630 status = be_cmd_mac_addr_query(adapter, mac, 3166 status = be_cmd_mac_addr_query(adapter, mac,
2631 MAC_ADDRESS_TYPE_NETWORK, true /*permanent */, 0); 3167 MAC_ADDRESS_TYPE_NETWORK, true /*permanent */, 0);
2632 3168
@@ -2645,9 +3181,97 @@ static int be_get_config(struct be_adapter *adapter)
2645 else 3181 else
2646 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED; 3182 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
2647 3183
3184 status = be_cmd_get_cntl_attributes(adapter);
3185 if (status)
3186 return status;
3187
3188 be_cmd_check_native_mode(adapter);
3189 return 0;
3190}
3191
3192static int be_dev_family_check(struct be_adapter *adapter)
3193{
3194 struct pci_dev *pdev = adapter->pdev;
3195 u32 sli_intf = 0, if_type;
3196
3197 switch (pdev->device) {
3198 case BE_DEVICE_ID1:
3199 case OC_DEVICE_ID1:
3200 adapter->generation = BE_GEN2;
3201 break;
3202 case BE_DEVICE_ID2:
3203 case OC_DEVICE_ID2:
3204 adapter->generation = BE_GEN3;
3205 break;
3206 case OC_DEVICE_ID3:
3207 case OC_DEVICE_ID4:
3208 pci_read_config_dword(pdev, SLI_INTF_REG_OFFSET, &sli_intf);
3209 if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
3210 SLI_INTF_IF_TYPE_SHIFT;
3211
3212 if (((sli_intf & SLI_INTF_VALID_MASK) != SLI_INTF_VALID) ||
3213 if_type != 0x02) {
3214 dev_err(&pdev->dev, "SLI_INTF reg val is not valid\n");
3215 return -EINVAL;
3216 }
3217 adapter->sli_family = ((sli_intf & SLI_INTF_FAMILY_MASK) >>
3218 SLI_INTF_FAMILY_SHIFT);
3219 adapter->generation = BE_GEN3;
3220 break;
3221 default:
3222 adapter->generation = 0;
3223 }
2648 return 0; 3224 return 0;
2649} 3225}
2650 3226
3227static int lancer_wait_ready(struct be_adapter *adapter)
3228{
3229#define SLIPORT_READY_TIMEOUT 500
3230 u32 sliport_status;
3231 int status = 0, i;
3232
3233 for (i = 0; i < SLIPORT_READY_TIMEOUT; i++) {
3234 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
3235 if (sliport_status & SLIPORT_STATUS_RDY_MASK)
3236 break;
3237
3238 msleep(20);
3239 }
3240
3241 if (i == SLIPORT_READY_TIMEOUT)
3242 status = -1;
3243
3244 return status;
3245}
3246
3247static int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
3248{
3249 int status;
3250 u32 sliport_status, err, reset_needed;
3251 status = lancer_wait_ready(adapter);
3252 if (!status) {
3253 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
3254 err = sliport_status & SLIPORT_STATUS_ERR_MASK;
3255 reset_needed = sliport_status & SLIPORT_STATUS_RN_MASK;
3256 if (err && reset_needed) {
3257 iowrite32(SLI_PORT_CONTROL_IP_MASK,
3258 adapter->db + SLIPORT_CONTROL_OFFSET);
3259
3260 /* check adapter has corrected the error */
3261 status = lancer_wait_ready(adapter);
3262 sliport_status = ioread32(adapter->db +
3263 SLIPORT_STATUS_OFFSET);
3264 sliport_status &= (SLIPORT_STATUS_ERR_MASK |
3265 SLIPORT_STATUS_RN_MASK);
3266 if (status || sliport_status)
3267 status = -1;
3268 } else if (err || reset_needed) {
3269 status = -1;
3270 }
3271 }
3272 return status;
3273}
3274
2651static int __devinit be_probe(struct pci_dev *pdev, 3275static int __devinit be_probe(struct pci_dev *pdev,
2652 const struct pci_device_id *pdev_id) 3276 const struct pci_device_id *pdev_id)
2653{ 3277{
@@ -2655,7 +3279,6 @@ static int __devinit be_probe(struct pci_dev *pdev,
2655 struct be_adapter *adapter; 3279 struct be_adapter *adapter;
2656 struct net_device *netdev; 3280 struct net_device *netdev;
2657 3281
2658
2659 status = pci_enable_device(pdev); 3282 status = pci_enable_device(pdev);
2660 if (status) 3283 if (status)
2661 goto do_none; 3284 goto do_none;
@@ -2671,33 +3294,21 @@ static int __devinit be_probe(struct pci_dev *pdev,
2671 goto rel_reg; 3294 goto rel_reg;
2672 } 3295 }
2673 adapter = netdev_priv(netdev); 3296 adapter = netdev_priv(netdev);
2674
2675 switch (pdev->device) {
2676 case BE_DEVICE_ID1:
2677 case OC_DEVICE_ID1:
2678 adapter->generation = BE_GEN2;
2679 break;
2680 case BE_DEVICE_ID2:
2681 case OC_DEVICE_ID2:
2682 adapter->generation = BE_GEN3;
2683 break;
2684 default:
2685 adapter->generation = 0;
2686 }
2687
2688 adapter->pdev = pdev; 3297 adapter->pdev = pdev;
2689 pci_set_drvdata(pdev, adapter); 3298 pci_set_drvdata(pdev, adapter);
3299
3300 status = be_dev_family_check(adapter);
3301 if (status)
3302 goto free_netdev;
3303
2690 adapter->netdev = netdev; 3304 adapter->netdev = netdev;
2691 be_netdev_init(netdev);
2692 SET_NETDEV_DEV(netdev, &pdev->dev); 3305 SET_NETDEV_DEV(netdev, &pdev->dev);
2693 3306
2694 be_msix_enable(adapter); 3307 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
2695
2696 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
2697 if (!status) { 3308 if (!status) {
2698 netdev->features |= NETIF_F_HIGHDMA; 3309 netdev->features |= NETIF_F_HIGHDMA;
2699 } else { 3310 } else {
2700 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 3311 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
2701 if (status) { 3312 if (status) {
2702 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n"); 3313 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
2703 goto free_netdev; 3314 goto free_netdev;
@@ -2705,10 +3316,25 @@ static int __devinit be_probe(struct pci_dev *pdev,
2705 } 3316 }
2706 3317
2707 be_sriov_enable(adapter); 3318 be_sriov_enable(adapter);
3319 if (adapter->sriov_enabled) {
3320 adapter->vf_cfg = kcalloc(num_vfs,
3321 sizeof(struct be_vf_cfg), GFP_KERNEL);
3322
3323 if (!adapter->vf_cfg)
3324 goto free_netdev;
3325 }
2708 3326
2709 status = be_ctrl_init(adapter); 3327 status = be_ctrl_init(adapter);
2710 if (status) 3328 if (status)
2711 goto free_netdev; 3329 goto free_vf_cfg;
3330
3331 if (lancer_chip(adapter)) {
3332 status = lancer_test_and_set_rdy_state(adapter);
3333 if (status) {
3334 dev_err(&pdev->dev, "Adapter in non recoverable error\n");
3335 goto ctrl_clean;
3336 }
3337 }
2712 3338
2713 /* sync up with fw's ready state */ 3339 /* sync up with fw's ready state */
2714 if (be_physfn(adapter)) { 3340 if (be_physfn(adapter)) {
@@ -2722,11 +3348,9 @@ static int __devinit be_probe(struct pci_dev *pdev,
2722 if (status) 3348 if (status)
2723 goto ctrl_clean; 3349 goto ctrl_clean;
2724 3350
2725 if (be_physfn(adapter)) { 3351 status = be_cmd_reset_function(adapter);
2726 status = be_cmd_reset_function(adapter); 3352 if (status)
2727 if (status) 3353 goto ctrl_clean;
2728 goto ctrl_clean;
2729 }
2730 3354
2731 status = be_stats_init(adapter); 3355 status = be_stats_init(adapter);
2732 if (status) 3356 if (status)
@@ -2736,29 +3360,60 @@ static int __devinit be_probe(struct pci_dev *pdev,
2736 if (status) 3360 if (status)
2737 goto stats_clean; 3361 goto stats_clean;
2738 3362
3363 be_msix_enable(adapter);
3364
2739 INIT_DELAYED_WORK(&adapter->work, be_worker); 3365 INIT_DELAYED_WORK(&adapter->work, be_worker);
2740 3366
2741 status = be_setup(adapter); 3367 status = be_setup(adapter);
2742 if (status) 3368 if (status)
2743 goto stats_clean; 3369 goto msix_disable;
2744 3370
3371 be_netdev_init(netdev);
2745 status = register_netdev(netdev); 3372 status = register_netdev(netdev);
2746 if (status != 0) 3373 if (status != 0)
2747 goto unsetup; 3374 goto unsetup;
3375 netif_carrier_off(netdev);
3376
3377 if (be_physfn(adapter) && adapter->sriov_enabled) {
3378 u8 mac_speed;
3379 bool link_up;
3380 u16 vf, lnk_speed;
3381
3382 if (!lancer_chip(adapter)) {
3383 status = be_vf_eth_addr_config(adapter);
3384 if (status)
3385 goto unreg_netdev;
3386 }
3387
3388 for (vf = 0; vf < num_vfs; vf++) {
3389 status = be_cmd_link_status_query(adapter, &link_up,
3390 &mac_speed, &lnk_speed, vf + 1);
3391 if (!status)
3392 adapter->vf_cfg[vf].vf_tx_rate = lnk_speed * 10;
3393 else
3394 goto unreg_netdev;
3395 }
3396 }
2748 3397
2749 dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num); 3398 dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
3399 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
2750 return 0; 3400 return 0;
2751 3401
3402unreg_netdev:
3403 unregister_netdev(netdev);
2752unsetup: 3404unsetup:
2753 be_clear(adapter); 3405 be_clear(adapter);
3406msix_disable:
3407 be_msix_disable(adapter);
2754stats_clean: 3408stats_clean:
2755 be_stats_cleanup(adapter); 3409 be_stats_cleanup(adapter);
2756ctrl_clean: 3410ctrl_clean:
2757 be_ctrl_cleanup(adapter); 3411 be_ctrl_cleanup(adapter);
3412free_vf_cfg:
3413 kfree(adapter->vf_cfg);
2758free_netdev: 3414free_netdev:
2759 be_msix_disable(adapter);
2760 be_sriov_disable(adapter); 3415 be_sriov_disable(adapter);
2761 free_netdev(adapter->netdev); 3416 free_netdev(netdev);
2762 pci_set_drvdata(pdev, NULL); 3417 pci_set_drvdata(pdev, NULL);
2763rel_reg: 3418rel_reg:
2764 pci_release_regions(pdev); 3419 pci_release_regions(pdev);
@@ -2774,6 +3429,7 @@ static int be_suspend(struct pci_dev *pdev, pm_message_t state)
2774 struct be_adapter *adapter = pci_get_drvdata(pdev); 3429 struct be_adapter *adapter = pci_get_drvdata(pdev);
2775 struct net_device *netdev = adapter->netdev; 3430 struct net_device *netdev = adapter->netdev;
2776 3431
3432 cancel_delayed_work_sync(&adapter->work);
2777 if (adapter->wol) 3433 if (adapter->wol)
2778 be_setup_wol(adapter, true); 3434 be_setup_wol(adapter, true);
2779 3435
@@ -2786,6 +3442,7 @@ static int be_suspend(struct pci_dev *pdev, pm_message_t state)
2786 be_cmd_get_flow_control(adapter, &adapter->tx_fc, &adapter->rx_fc); 3442 be_cmd_get_flow_control(adapter, &adapter->tx_fc, &adapter->rx_fc);
2787 be_clear(adapter); 3443 be_clear(adapter);
2788 3444
3445 be_msix_disable(adapter);
2789 pci_save_state(pdev); 3446 pci_save_state(pdev);
2790 pci_disable_device(pdev); 3447 pci_disable_device(pdev);
2791 pci_set_power_state(pdev, pci_choose_state(pdev, state)); 3448 pci_set_power_state(pdev, pci_choose_state(pdev, state));
@@ -2807,6 +3464,7 @@ static int be_resume(struct pci_dev *pdev)
2807 pci_set_power_state(pdev, 0); 3464 pci_set_power_state(pdev, 0);
2808 pci_restore_state(pdev); 3465 pci_restore_state(pdev);
2809 3466
3467 be_msix_enable(adapter);
2810 /* tell fw we're ready to fire cmds */ 3468 /* tell fw we're ready to fire cmds */
2811 status = be_cmd_fw_init(adapter); 3469 status = be_cmd_fw_init(adapter);
2812 if (status) 3470 if (status)
@@ -2822,6 +3480,8 @@ static int be_resume(struct pci_dev *pdev)
2822 3480
2823 if (adapter->wol) 3481 if (adapter->wol)
2824 be_setup_wol(adapter, false); 3482 be_setup_wol(adapter, false);
3483
3484 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
2825 return 0; 3485 return 0;
2826} 3486}
2827 3487
@@ -2831,15 +3491,19 @@ static int be_resume(struct pci_dev *pdev)
2831static void be_shutdown(struct pci_dev *pdev) 3491static void be_shutdown(struct pci_dev *pdev)
2832{ 3492{
2833 struct be_adapter *adapter = pci_get_drvdata(pdev); 3493 struct be_adapter *adapter = pci_get_drvdata(pdev);
2834 struct net_device *netdev = adapter->netdev;
2835 3494
2836 netif_device_detach(netdev); 3495 if (!adapter)
3496 return;
2837 3497
2838 be_cmd_reset_function(adapter); 3498 cancel_delayed_work_sync(&adapter->work);
3499
3500 netif_device_detach(adapter->netdev);
2839 3501
2840 if (adapter->wol) 3502 if (adapter->wol)
2841 be_setup_wol(adapter, true); 3503 be_setup_wol(adapter, true);
2842 3504
3505 be_cmd_reset_function(adapter);
3506
2843 pci_disable_device(pdev); 3507 pci_disable_device(pdev);
2844} 3508}
2845 3509
@@ -2951,13 +3615,6 @@ static int __init be_init_module(void)
2951 rx_frag_size = 2048; 3615 rx_frag_size = 2048;
2952 } 3616 }
2953 3617
2954 if (num_vfs > 32) {
2955 printk(KERN_WARNING DRV_NAME
2956 " : Module param num_vfs must not be greater than 32."
2957 "Using 32\n");
2958 num_vfs = 32;
2959 }
2960
2961 return pci_register_driver(&be_driver); 3618 return pci_register_driver(&be_driver);
2962} 3619}
2963module_init(be_init_module); 3620module_init(be_init_module);
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-04 02:32:27 -0400