projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'upstream' of git://git.linux-mips.org/pub/scm/ralf/upstream-linus
[deliverable/linux.git] / drivers / net / ethernet / emulex / benet / be_main.c
1 /*
2 * Copyright (C) 2005 - 2013 Emulex
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License version 2
7 * as published by the Free Software Foundation. The full GNU General
8 * Public License is included in this distribution in the file called COPYING.
9 *
10 * Contact Information:
11 * linux-drivers@emulex.com
12 *
13 * Emulex
14 * 3333 Susan Street
15 * Costa Mesa, CA 92626
16 */
17
18 #include <linux/prefetch.h>
19 #include <linux/module.h>
20 #include "be.h"
21 #include "be_cmds.h"
22 #include <asm/div64.h>
23 #include <linux/aer.h>
24
25 MODULE_VERSION(DRV_VER);
26 MODULE_DEVICE_TABLE(pci, be_dev_ids);
27 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
28 MODULE_AUTHOR("Emulex Corporation");
29 MODULE_LICENSE("GPL");
30
31 static unsigned int num_vfs;
32 module_param(num_vfs, uint, S_IRUGO);
33 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
34
35 static ushort rx_frag_size = 2048;
36 module_param(rx_frag_size, ushort, S_IRUGO);
37 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
38
39 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
40 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
41 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
42 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
43 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
44 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
45 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
46 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
47 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
48 { 0 }
49 };
50 MODULE_DEVICE_TABLE(pci, be_dev_ids);
51 /* UE Status Low CSR */
52 static const char * const ue_status_low_desc[] = {
53 "CEV",
54 "CTX",
55 "DBUF",
56 "ERX",
57 "Host",
58 "MPU",
59 "NDMA",
60 "PTC ",
61 "RDMA ",
62 "RXF ",
63 "RXIPS ",
64 "RXULP0 ",
65 "RXULP1 ",
66 "RXULP2 ",
67 "TIM ",
68 "TPOST ",
69 "TPRE ",
70 "TXIPS ",
71 "TXULP0 ",
72 "TXULP1 ",
73 "UC ",
74 "WDMA ",
75 "TXULP2 ",
76 "HOST1 ",
77 "P0_OB_LINK ",
78 "P1_OB_LINK ",
79 "HOST_GPIO ",
80 "MBOX ",
81 "AXGMAC0",
82 "AXGMAC1",
83 "JTAG",
84 "MPU_INTPEND"
85 };
86 /* UE Status High CSR */
87 static const char * const ue_status_hi_desc[] = {
88 "LPCMEMHOST",
89 "MGMT_MAC",
90 "PCS0ONLINE",
91 "MPU_IRAM",
92 "PCS1ONLINE",
93 "PCTL0",
94 "PCTL1",
95 "PMEM",
96 "RR",
97 "TXPB",
98 "RXPP",
99 "XAUI",
100 "TXP",
101 "ARM",
102 "IPC",
103 "HOST2",
104 "HOST3",
105 "HOST4",
106 "HOST5",
107 "HOST6",
108 "HOST7",
109 "HOST8",
110 "HOST9",
111 "NETC",
112 "Unknown",
113 "Unknown",
114 "Unknown",
115 "Unknown",
116 "Unknown",
117 "Unknown",
118 "Unknown",
119 "Unknown"
120 };
121
122 /* Is BE in a multi-channel mode */
123 static inline bool be_is_mc(struct be_adapter *adapter) {
124 return (adapter->function_mode & FLEX10_MODE ||
125 adapter->function_mode & VNIC_MODE ||
126 adapter->function_mode & UMC_ENABLED);
127 }
128
129 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
130 {
131 struct be_dma_mem *mem = &q->dma_mem;
132 if (mem->va) {
133 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
134 mem->dma);
135 mem->va = NULL;
136 }
137 }
138
139 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
140 u16 len, u16 entry_size)
141 {
142 struct be_dma_mem *mem = &q->dma_mem;
143
144 memset(q, 0, sizeof(*q));
145 q->len = len;
146 q->entry_size = entry_size;
147 mem->size = len * entry_size;
148 mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
149 GFP_KERNEL | __GFP_ZERO);
150 if (!mem->va)
151 return -ENOMEM;
152 return 0;
153 }
154
155 static void be_reg_intr_set(struct be_adapter *adapter, bool enable)
156 {
157 u32 reg, enabled;
158
159 pci_read_config_dword(adapter->pdev, PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET,
160 &reg);
161 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
162
163 if (!enabled && enable)
164 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
165 else if (enabled && !enable)
166 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
167 else
168 return;
169
170 pci_write_config_dword(adapter->pdev,
171 PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET, reg);
172 }
173
174 static void be_intr_set(struct be_adapter *adapter, bool enable)
175 {
176 int status = 0;
177
178 /* On lancer interrupts can't be controlled via this register */
179 if (lancer_chip(adapter))
180 return;
181
182 if (adapter->eeh_error)
183 return;
184
185 status = be_cmd_intr_set(adapter, enable);
186 if (status)
187 be_reg_intr_set(adapter, enable);
188 }
189
190 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
191 {
192 u32 val = 0;
193 val |= qid & DB_RQ_RING_ID_MASK;
194 val |= posted << DB_RQ_NUM_POSTED_SHIFT;
195
196 wmb();
197 iowrite32(val, adapter->db + DB_RQ_OFFSET);
198 }
199
200 static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
201 u16 posted)
202 {
203 u32 val = 0;
204 val |= txo->q.id & DB_TXULP_RING_ID_MASK;
205 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
206
207 wmb();
208 iowrite32(val, adapter->db + txo->db_offset);
209 }
210
211 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
212 bool arm, bool clear_int, u16 num_popped)
213 {
214 u32 val = 0;
215 val |= qid & DB_EQ_RING_ID_MASK;
216 val |= ((qid & DB_EQ_RING_ID_EXT_MASK) <<
217 DB_EQ_RING_ID_EXT_MASK_SHIFT);
218
219 if (adapter->eeh_error)
220 return;
221
222 if (arm)
223 val |= 1 << DB_EQ_REARM_SHIFT;
224 if (clear_int)
225 val |= 1 << DB_EQ_CLR_SHIFT;
226 val |= 1 << DB_EQ_EVNT_SHIFT;
227 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
228 iowrite32(val, adapter->db + DB_EQ_OFFSET);
229 }
230
231 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
232 {
233 u32 val = 0;
234 val |= qid & DB_CQ_RING_ID_MASK;
235 val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
236 DB_CQ_RING_ID_EXT_MASK_SHIFT);
237
238 if (adapter->eeh_error)
239 return;
240
241 if (arm)
242 val |= 1 << DB_CQ_REARM_SHIFT;
243 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
244 iowrite32(val, adapter->db + DB_CQ_OFFSET);
245 }
246
247 static int be_mac_addr_set(struct net_device *netdev, void *p)
248 {
249 struct be_adapter *adapter = netdev_priv(netdev);
250 struct sockaddr *addr = p;
251 int status = 0;
252 u8 current_mac[ETH_ALEN];
253 u32 pmac_id = adapter->pmac_id[0];
254 bool active_mac = true;
255
256 if (!is_valid_ether_addr(addr->sa_data))
257 return -EADDRNOTAVAIL;
258
259 /* For BE VF, MAC address is already activated by PF.
260 * Hence only operation left is updating netdev->devaddr.
261 * Update it if user is passing the same MAC which was used
262 * during configuring VF MAC from PF(Hypervisor).
263 */
264 if (!lancer_chip(adapter) && !be_physfn(adapter)) {
265 status = be_cmd_mac_addr_query(adapter, current_mac,
266 false, adapter->if_handle, 0);
267 if (!status && !memcmp(current_mac, addr->sa_data, ETH_ALEN))
268 goto done;
269 else
270 goto err;
271 }
272
273 if (!memcmp(addr->sa_data, netdev->dev_addr, ETH_ALEN))
274 goto done;
275
276 /* For Lancer check if any MAC is active.
277 * If active, get its mac id.
278 */
279 if (lancer_chip(adapter) && !be_physfn(adapter))
280 be_cmd_get_mac_from_list(adapter, current_mac, &active_mac,
281 &pmac_id, 0);
282
283 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
284 adapter->if_handle,
285 &adapter->pmac_id[0], 0);
286
287 if (status)
288 goto err;
289
290 if (active_mac)
291 be_cmd_pmac_del(adapter, adapter->if_handle,
292 pmac_id, 0);
293 done:
294 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
295 return 0;
296 err:
297 dev_err(&adapter->pdev->dev, "MAC %pM set Failed\n", addr->sa_data);
298 return status;
299 }
300
301 /* BE2 supports only v0 cmd */
302 static void *hw_stats_from_cmd(struct be_adapter *adapter)
303 {
304 if (BE2_chip(adapter)) {
305 struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
306
307 return &cmd->hw_stats;
308 } else {
309 struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
310
311 return &cmd->hw_stats;
312 }
313 }
314
315 /* BE2 supports only v0 cmd */
316 static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
317 {
318 if (BE2_chip(adapter)) {
319 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
320
321 return &hw_stats->erx;
322 } else {
323 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
324
325 return &hw_stats->erx;
326 }
327 }
328
329 static void populate_be_v0_stats(struct be_adapter *adapter)
330 {
331 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
332 struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
333 struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
334 struct be_port_rxf_stats_v0 *port_stats =
335 &rxf_stats->port[adapter->port_num];
336 struct be_drv_stats *drvs = &adapter->drv_stats;
337
338 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
339 drvs->rx_pause_frames = port_stats->rx_pause_frames;
340 drvs->rx_crc_errors = port_stats->rx_crc_errors;
341 drvs->rx_control_frames = port_stats->rx_control_frames;
342 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
343 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
344 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
345 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
346 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
347 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
348 drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
349 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
350 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
351 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
352 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
353 drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
354 drvs->rx_dropped_header_too_small =
355 port_stats->rx_dropped_header_too_small;
356 drvs->rx_address_filtered =
357 port_stats->rx_address_filtered +
358 port_stats->rx_vlan_filtered;
359 drvs->rx_alignment_symbol_errors =
360 port_stats->rx_alignment_symbol_errors;
361
362 drvs->tx_pauseframes = port_stats->tx_pauseframes;
363 drvs->tx_controlframes = port_stats->tx_controlframes;
364
365 if (adapter->port_num)
366 drvs->jabber_events = rxf_stats->port1_jabber_events;
367 else
368 drvs->jabber_events = rxf_stats->port0_jabber_events;
369 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
370 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
371 drvs->forwarded_packets = rxf_stats->forwarded_packets;
372 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
373 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
374 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
375 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
376 }
377
378 static void populate_be_v1_stats(struct be_adapter *adapter)
379 {
380 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
381 struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
382 struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
383 struct be_port_rxf_stats_v1 *port_stats =
384 &rxf_stats->port[adapter->port_num];
385 struct be_drv_stats *drvs = &adapter->drv_stats;
386
387 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
388 drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
389 drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
390 drvs->rx_pause_frames = port_stats->rx_pause_frames;
391 drvs->rx_crc_errors = port_stats->rx_crc_errors;
392 drvs->rx_control_frames = port_stats->rx_control_frames;
393 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
394 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
395 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
396 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
397 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
398 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
399 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
400 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
401 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
402 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
403 drvs->rx_dropped_header_too_small =
404 port_stats->rx_dropped_header_too_small;
405 drvs->rx_input_fifo_overflow_drop =
406 port_stats->rx_input_fifo_overflow_drop;
407 drvs->rx_address_filtered = port_stats->rx_address_filtered;
408 drvs->rx_alignment_symbol_errors =
409 port_stats->rx_alignment_symbol_errors;
410 drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
411 drvs->tx_pauseframes = port_stats->tx_pauseframes;
412 drvs->tx_controlframes = port_stats->tx_controlframes;
413 drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
414 drvs->jabber_events = port_stats->jabber_events;
415 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
416 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
417 drvs->forwarded_packets = rxf_stats->forwarded_packets;
418 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
419 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
420 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
421 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
422 }
423
424 static void populate_lancer_stats(struct be_adapter *adapter)
425 {
426
427 struct be_drv_stats *drvs = &adapter->drv_stats;
428 struct lancer_pport_stats *pport_stats =
429 pport_stats_from_cmd(adapter);
430
431 be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
432 drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
433 drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
434 drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
435 drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
436 drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
437 drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
438 drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
439 drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
440 drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
441 drvs->rx_dropped_tcp_length =
442 pport_stats->rx_dropped_invalid_tcp_length;
443 drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
444 drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
445 drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
446 drvs->rx_dropped_header_too_small =
447 pport_stats->rx_dropped_header_too_small;
448 drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
449 drvs->rx_address_filtered =
450 pport_stats->rx_address_filtered +
451 pport_stats->rx_vlan_filtered;
452 drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
453 drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
454 drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
455 drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
456 drvs->jabber_events = pport_stats->rx_jabbers;
457 drvs->forwarded_packets = pport_stats->num_forwards_lo;
458 drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
459 drvs->rx_drops_too_many_frags =
460 pport_stats->rx_drops_too_many_frags_lo;
461 }
462
463 static void accumulate_16bit_val(u32 *acc, u16 val)
464 {
465 #define lo(x) (x & 0xFFFF)
466 #define hi(x) (x & 0xFFFF0000)
467 bool wrapped = val < lo(*acc);
468 u32 newacc = hi(*acc) + val;
469
470 if (wrapped)
471 newacc += 65536;
472 ACCESS_ONCE(*acc) = newacc;
473 }
474
475 void populate_erx_stats(struct be_adapter *adapter,
476 struct be_rx_obj *rxo,
477 u32 erx_stat)
478 {
479 if (!BEx_chip(adapter))
480 rx_stats(rxo)->rx_drops_no_frags = erx_stat;
481 else
482 /* below erx HW counter can actually wrap around after
483 * 65535. Driver accumulates a 32-bit value
484 */
485 accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
486 (u16)erx_stat);
487 }
488
489 void be_parse_stats(struct be_adapter *adapter)
490 {
491 struct be_erx_stats_v1 *erx = be_erx_stats_from_cmd(adapter);
492 struct be_rx_obj *rxo;
493 int i;
494 u32 erx_stat;
495
496 if (lancer_chip(adapter)) {
497 populate_lancer_stats(adapter);
498 } else {
499 if (BE2_chip(adapter))
500 populate_be_v0_stats(adapter);
501 else
502 /* for BE3 and Skyhawk */
503 populate_be_v1_stats(adapter);
504
505 /* as erx_v1 is longer than v0, ok to use v1 for v0 access */
506 for_all_rx_queues(adapter, rxo, i) {
507 erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
508 populate_erx_stats(adapter, rxo, erx_stat);
509 }
510 }
511 }
512
513 static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
514 struct rtnl_link_stats64 *stats)
515 {
516 struct be_adapter *adapter = netdev_priv(netdev);
517 struct be_drv_stats *drvs = &adapter->drv_stats;
518 struct be_rx_obj *rxo;
519 struct be_tx_obj *txo;
520 u64 pkts, bytes;
521 unsigned int start;
522 int i;
523
524 for_all_rx_queues(adapter, rxo, i) {
525 const struct be_rx_stats *rx_stats = rx_stats(rxo);
526 do {
527 start = u64_stats_fetch_begin_bh(&rx_stats->sync);
528 pkts = rx_stats(rxo)->rx_pkts;
529 bytes = rx_stats(rxo)->rx_bytes;
530 } while (u64_stats_fetch_retry_bh(&rx_stats->sync, start));
531 stats->rx_packets += pkts;
532 stats->rx_bytes += bytes;
533 stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
534 stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
535 rx_stats(rxo)->rx_drops_no_frags;
536 }
537
538 for_all_tx_queues(adapter, txo, i) {
539 const struct be_tx_stats *tx_stats = tx_stats(txo);
540 do {
541 start = u64_stats_fetch_begin_bh(&tx_stats->sync);
542 pkts = tx_stats(txo)->tx_pkts;
543 bytes = tx_stats(txo)->tx_bytes;
544 } while (u64_stats_fetch_retry_bh(&tx_stats->sync, start));
545 stats->tx_packets += pkts;
546 stats->tx_bytes += bytes;
547 }
548
549 /* bad pkts received */
550 stats->rx_errors = drvs->rx_crc_errors +
551 drvs->rx_alignment_symbol_errors +
552 drvs->rx_in_range_errors +
553 drvs->rx_out_range_errors +
554 drvs->rx_frame_too_long +
555 drvs->rx_dropped_too_small +
556 drvs->rx_dropped_too_short +
557 drvs->rx_dropped_header_too_small +
558 drvs->rx_dropped_tcp_length +
559 drvs->rx_dropped_runt;
560
561 /* detailed rx errors */
562 stats->rx_length_errors = drvs->rx_in_range_errors +
563 drvs->rx_out_range_errors +
564 drvs->rx_frame_too_long;
565
566 stats->rx_crc_errors = drvs->rx_crc_errors;
567
568 /* frame alignment errors */
569 stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
570
571 /* receiver fifo overrun */
572 /* drops_no_pbuf is no per i/f, it's per BE card */
573 stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
574 drvs->rx_input_fifo_overflow_drop +
575 drvs->rx_drops_no_pbuf;
576 return stats;
577 }
578
579 void be_link_status_update(struct be_adapter *adapter, u8 link_status)
580 {
581 struct net_device *netdev = adapter->netdev;
582
583 if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
584 netif_carrier_off(netdev);
585 adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
586 }
587
588 if ((link_status & LINK_STATUS_MASK) == LINK_UP)
589 netif_carrier_on(netdev);
590 else
591 netif_carrier_off(netdev);
592 }
593
594 static void be_tx_stats_update(struct be_tx_obj *txo,
595 u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
596 {
597 struct be_tx_stats *stats = tx_stats(txo);
598
599 u64_stats_update_begin(&stats->sync);
600 stats->tx_reqs++;
601 stats->tx_wrbs += wrb_cnt;
602 stats->tx_bytes += copied;
603 stats->tx_pkts += (gso_segs ? gso_segs : 1);
604 if (stopped)
605 stats->tx_stops++;
606 u64_stats_update_end(&stats->sync);
607 }
608
609 /* Determine number of WRB entries needed to xmit data in an skb */
610 static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
611 bool *dummy)
612 {
613 int cnt = (skb->len > skb->data_len);
614
615 cnt += skb_shinfo(skb)->nr_frags;
616
617 /* to account for hdr wrb */
618 cnt++;
619 if (lancer_chip(adapter) || !(cnt & 1)) {
620 *dummy = false;
621 } else {
622 /* add a dummy to make it an even num */
623 cnt++;
624 *dummy = true;
625 }
626 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
627 return cnt;
628 }
629
630 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
631 {
632 wrb->frag_pa_hi = upper_32_bits(addr);
633 wrb->frag_pa_lo = addr & 0xFFFFFFFF;
634 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
635 wrb->rsvd0 = 0;
636 }
637
638 static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
639 struct sk_buff *skb)
640 {
641 u8 vlan_prio;
642 u16 vlan_tag;
643
644 vlan_tag = vlan_tx_tag_get(skb);
645 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
646 /* If vlan priority provided by OS is NOT in available bmap */
647 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
648 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
649 adapter->recommended_prio;
650
651 return vlan_tag;
652 }
653
654 static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
655 struct sk_buff *skb, u32 wrb_cnt, u32 len, bool skip_hw_vlan)
656 {
657 u16 vlan_tag;
658
659 memset(hdr, 0, sizeof(*hdr));
660
661 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
662
663 if (skb_is_gso(skb)) {
664 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
665 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
666 hdr, skb_shinfo(skb)->gso_size);
667 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
668 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
669 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
670 if (is_tcp_pkt(skb))
671 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
672 else if (is_udp_pkt(skb))
673 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
674 }
675
676 if (vlan_tx_tag_present(skb)) {
677 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
678 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
679 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
680 }
681
682 /* To skip HW VLAN tagging: evt = 1, compl = 0 */
683 AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, !skip_hw_vlan);
684 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
685 AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
686 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
687 }
688
689 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
690 bool unmap_single)
691 {
692 dma_addr_t dma;
693
694 be_dws_le_to_cpu(wrb, sizeof(*wrb));
695
696 dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
697 if (wrb->frag_len) {
698 if (unmap_single)
699 dma_unmap_single(dev, dma, wrb->frag_len,
700 DMA_TO_DEVICE);
701 else
702 dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
703 }
704 }
705
706 static int make_tx_wrbs(struct be_adapter *adapter, struct be_queue_info *txq,
707 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb,
708 bool skip_hw_vlan)
709 {
710 dma_addr_t busaddr;
711 int i, copied = 0;
712 struct device *dev = &adapter->pdev->dev;
713 struct sk_buff *first_skb = skb;
714 struct be_eth_wrb *wrb;
715 struct be_eth_hdr_wrb *hdr;
716 bool map_single = false;
717 u16 map_head;
718
719 hdr = queue_head_node(txq);
720 queue_head_inc(txq);
721 map_head = txq->head;
722
723 if (skb->len > skb->data_len) {
724 int len = skb_headlen(skb);
725 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
726 if (dma_mapping_error(dev, busaddr))
727 goto dma_err;
728 map_single = true;
729 wrb = queue_head_node(txq);
730 wrb_fill(wrb, busaddr, len);
731 be_dws_cpu_to_le(wrb, sizeof(*wrb));
732 queue_head_inc(txq);
733 copied += len;
734 }
735
736 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
737 const struct skb_frag_struct *frag =
738 &skb_shinfo(skb)->frags[i];
739 busaddr = skb_frag_dma_map(dev, frag, 0,
740 skb_frag_size(frag), DMA_TO_DEVICE);
741 if (dma_mapping_error(dev, busaddr))
742 goto dma_err;
743 wrb = queue_head_node(txq);
744 wrb_fill(wrb, busaddr, skb_frag_size(frag));
745 be_dws_cpu_to_le(wrb, sizeof(*wrb));
746 queue_head_inc(txq);
747 copied += skb_frag_size(frag);
748 }
749
750 if (dummy_wrb) {
751 wrb = queue_head_node(txq);
752 wrb_fill(wrb, 0, 0);
753 be_dws_cpu_to_le(wrb, sizeof(*wrb));
754 queue_head_inc(txq);
755 }
756
757 wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied, skip_hw_vlan);
758 be_dws_cpu_to_le(hdr, sizeof(*hdr));
759
760 return copied;
761 dma_err:
762 txq->head = map_head;
763 while (copied) {
764 wrb = queue_head_node(txq);
765 unmap_tx_frag(dev, wrb, map_single);
766 map_single = false;
767 copied -= wrb->frag_len;
768 queue_head_inc(txq);
769 }
770 return 0;
771 }
772
773 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
774 struct sk_buff *skb,
775 bool *skip_hw_vlan)
776 {
777 u16 vlan_tag = 0;
778
779 skb = skb_share_check(skb, GFP_ATOMIC);
780 if (unlikely(!skb))
781 return skb;
782
783 if (vlan_tx_tag_present(skb)) {
784 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
785 skb = __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
786 if (skb)
787 skb->vlan_tci = 0;
788 }
789
790 if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
791 if (!vlan_tag)
792 vlan_tag = adapter->pvid;
793 if (skip_hw_vlan)
794 *skip_hw_vlan = true;
795 }
796
797 if (vlan_tag) {
798 skb = __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
799 if (unlikely(!skb))
800 return skb;
801
802 skb->vlan_tci = 0;
803 }
804
805 /* Insert the outer VLAN, if any */
806 if (adapter->qnq_vid) {
807 vlan_tag = adapter->qnq_vid;
808 skb = __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
809 if (unlikely(!skb))
810 return skb;
811 if (skip_hw_vlan)
812 *skip_hw_vlan = true;
813 }
814
815 return skb;
816 }
817
818 static bool be_ipv6_exthdr_check(struct sk_buff *skb)
819 {
820 struct ethhdr *eh = (struct ethhdr *)skb->data;
821 u16 offset = ETH_HLEN;
822
823 if (eh->h_proto == htons(ETH_P_IPV6)) {
824 struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);
825
826 offset += sizeof(struct ipv6hdr);
827 if (ip6h->nexthdr != NEXTHDR_TCP &&
828 ip6h->nexthdr != NEXTHDR_UDP) {
829 struct ipv6_opt_hdr *ehdr =
830 (struct ipv6_opt_hdr *) (skb->data + offset);
831
832 /* offending pkt: 2nd byte following IPv6 hdr is 0xff */
833 if (ehdr->hdrlen == 0xff)
834 return true;
835 }
836 }
837 return false;
838 }
839
840 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
841 {
842 return vlan_tx_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
843 }
844
845 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
846 {
847 return BE3_chip(adapter) &&
848 be_ipv6_exthdr_check(skb);
849 }
850
851 static netdev_tx_t be_xmit(struct sk_buff *skb,
852 struct net_device *netdev)
853 {
854 struct be_adapter *adapter = netdev_priv(netdev);
855 struct be_tx_obj *txo = &adapter->tx_obj[skb_get_queue_mapping(skb)];
856 struct be_queue_info *txq = &txo->q;
857 struct iphdr *ip = NULL;
858 u32 wrb_cnt = 0, copied = 0;
859 u32 start = txq->head, eth_hdr_len;
860 bool dummy_wrb, stopped = false;
861 bool skip_hw_vlan = false;
862 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
863
864 eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
865 VLAN_ETH_HLEN : ETH_HLEN;
866
867 /* For padded packets, BE HW modifies tot_len field in IP header
868 * incorrecly when VLAN tag is inserted by HW.
869 */
870 if (skb->len <= 60 && vlan_tx_tag_present(skb) && is_ipv4_pkt(skb)) {
871 ip = (struct iphdr *)ip_hdr(skb);
872 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
873 }
874
875 /* If vlan tag is already inlined in the packet, skip HW VLAN
876 * tagging in UMC mode
877 */
878 if ((adapter->function_mode & UMC_ENABLED) &&
879 veh->h_vlan_proto == htons(ETH_P_8021Q))
880 skip_hw_vlan = true;
881
882 /* HW has a bug wherein it will calculate CSUM for VLAN
883 * pkts even though it is disabled.
884 * Manually insert VLAN in pkt.
885 */
886 if (skb->ip_summed != CHECKSUM_PARTIAL &&
887 vlan_tx_tag_present(skb)) {
888 skb = be_insert_vlan_in_pkt(adapter, skb, &skip_hw_vlan);
889 if (unlikely(!skb))
890 goto tx_drop;
891 }
892
893 /* HW may lockup when VLAN HW tagging is requested on
894 * certain ipv6 packets. Drop such pkts if the HW workaround to
895 * skip HW tagging is not enabled by FW.
896 */
897 if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
898 (adapter->pvid || adapter->qnq_vid) &&
899 !qnq_async_evt_rcvd(adapter)))
900 goto tx_drop;
901
902 /* Manual VLAN tag insertion to prevent:
903 * ASIC lockup when the ASIC inserts VLAN tag into
904 * certain ipv6 packets. Insert VLAN tags in driver,
905 * and set event, completion, vlan bits accordingly
906 * in the Tx WRB.
907 */
908 if (be_ipv6_tx_stall_chk(adapter, skb) &&
909 be_vlan_tag_tx_chk(adapter, skb)) {
910 skb = be_insert_vlan_in_pkt(adapter, skb, &skip_hw_vlan);
911 if (unlikely(!skb))
912 goto tx_drop;
913 }
914
915 wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
916
917 copied = make_tx_wrbs(adapter, txq, skb, wrb_cnt, dummy_wrb,
918 skip_hw_vlan);
919 if (copied) {
920 int gso_segs = skb_shinfo(skb)->gso_segs;
921
922 /* record the sent skb in the sent_skb table */
923 BUG_ON(txo->sent_skb_list[start]);
924 txo->sent_skb_list[start] = skb;
925
926 /* Ensure txq has space for the next skb; Else stop the queue
927 * *BEFORE* ringing the tx doorbell, so that we serialze the
928 * tx compls of the current transmit which'll wake up the queue
929 */
930 atomic_add(wrb_cnt, &txq->used);
931 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
932 txq->len) {
933 netif_stop_subqueue(netdev, skb_get_queue_mapping(skb));
934 stopped = true;
935 }
936
937 be_txq_notify(adapter, txo, wrb_cnt);
938
939 be_tx_stats_update(txo, wrb_cnt, copied, gso_segs, stopped);
940 } else {
941 txq->head = start;
942 dev_kfree_skb_any(skb);
943 }
944 tx_drop:
945 return NETDEV_TX_OK;
946 }
947
948 static int be_change_mtu(struct net_device *netdev, int new_mtu)
949 {
950 struct be_adapter *adapter = netdev_priv(netdev);
951 if (new_mtu < BE_MIN_MTU ||
952 new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
953 (ETH_HLEN + ETH_FCS_LEN))) {
954 dev_info(&adapter->pdev->dev,
955 "MTU must be between %d and %d bytes\n",
956 BE_MIN_MTU,
957 (BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
958 return -EINVAL;
959 }
960 dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
961 netdev->mtu, new_mtu);
962 netdev->mtu = new_mtu;
963 return 0;
964 }
965
966 /*
967 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
968 * If the user configures more, place BE in vlan promiscuous mode.
969 */
970 static int be_vid_config(struct be_adapter *adapter)
971 {
972 u16 vids[BE_NUM_VLANS_SUPPORTED];
973 u16 num = 0, i;
974 int status = 0;
975
976 /* No need to further configure vids if in promiscuous mode */
977 if (adapter->promiscuous)
978 return 0;
979
980 if (adapter->vlans_added > adapter->max_vlans)
981 goto set_vlan_promisc;
982
983 /* Construct VLAN Table to give to HW */
984 for (i = 0; i < VLAN_N_VID; i++)
985 if (adapter->vlan_tag[i])
986 vids[num++] = cpu_to_le16(i);
987
988 status = be_cmd_vlan_config(adapter, adapter->if_handle,
989 vids, num, 1, 0);
990
991 /* Set to VLAN promisc mode as setting VLAN filter failed */
992 if (status) {
993 dev_info(&adapter->pdev->dev, "Exhausted VLAN HW filters.\n");
994 dev_info(&adapter->pdev->dev, "Disabling HW VLAN filtering.\n");
995 goto set_vlan_promisc;
996 }
997
998 return status;
999
1000 set_vlan_promisc:
1001 status = be_cmd_vlan_config(adapter, adapter->if_handle,
1002 NULL, 0, 1, 1);
1003 return status;
1004 }
1005
1006 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
1007 {
1008 struct be_adapter *adapter = netdev_priv(netdev);
1009 int status = 0;
1010
1011 if (!lancer_chip(adapter) && !be_physfn(adapter)) {
1012 status = -EINVAL;
1013 goto ret;
1014 }
1015
1016 /* Packets with VID 0 are always received by Lancer by default */
1017 if (lancer_chip(adapter) && vid == 0)
1018 goto ret;
1019
1020 adapter->vlan_tag[vid] = 1;
1021 if (adapter->vlans_added <= (adapter->max_vlans + 1))
1022 status = be_vid_config(adapter);
1023
1024 if (!status)
1025 adapter->vlans_added++;
1026 else
1027 adapter->vlan_tag[vid] = 0;
1028 ret:
1029 return status;
1030 }
1031
1032 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
1033 {
1034 struct be_adapter *adapter = netdev_priv(netdev);
1035 int status = 0;
1036
1037 if (!lancer_chip(adapter) && !be_physfn(adapter)) {
1038 status = -EINVAL;
1039 goto ret;
1040 }
1041
1042 /* Packets with VID 0 are always received by Lancer by default */
1043 if (lancer_chip(adapter) && vid == 0)
1044 goto ret;
1045
1046 adapter->vlan_tag[vid] = 0;
1047 if (adapter->vlans_added <= adapter->max_vlans)
1048 status = be_vid_config(adapter);
1049
1050 if (!status)
1051 adapter->vlans_added--;
1052 else
1053 adapter->vlan_tag[vid] = 1;
1054 ret:
1055 return status;
1056 }
1057
1058 static void be_set_rx_mode(struct net_device *netdev)
1059 {
1060 struct be_adapter *adapter = netdev_priv(netdev);
1061 int status;
1062
1063 if (netdev->flags & IFF_PROMISC) {
1064 be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
1065 adapter->promiscuous = true;
1066 goto done;
1067 }
1068
1069 /* BE was previously in promiscuous mode; disable it */
1070 if (adapter->promiscuous) {
1071 adapter->promiscuous = false;
1072 be_cmd_rx_filter(adapter, IFF_PROMISC, OFF);
1073
1074 if (adapter->vlans_added)
1075 be_vid_config(adapter);
1076 }
1077
1078 /* Enable multicast promisc if num configured exceeds what we support */
1079 if (netdev->flags & IFF_ALLMULTI ||
1080 netdev_mc_count(netdev) > adapter->max_mcast_mac) {
1081 be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
1082 goto done;
1083 }
1084
1085 if (netdev_uc_count(netdev) != adapter->uc_macs) {
1086 struct netdev_hw_addr *ha;
1087 int i = 1; /* First slot is claimed by the Primary MAC */
1088
1089 for (; adapter->uc_macs > 0; adapter->uc_macs--, i++) {
1090 be_cmd_pmac_del(adapter, adapter->if_handle,
1091 adapter->pmac_id[i], 0);
1092 }
1093
1094 if (netdev_uc_count(netdev) > adapter->max_pmac_cnt) {
1095 be_cmd_rx_filter(adapter, IFF_PROMISC, ON);
1096 adapter->promiscuous = true;
1097 goto done;
1098 }
1099
1100 netdev_for_each_uc_addr(ha, adapter->netdev) {
1101 adapter->uc_macs++; /* First slot is for Primary MAC */
1102 be_cmd_pmac_add(adapter, (u8 *)ha->addr,
1103 adapter->if_handle,
1104 &adapter->pmac_id[adapter->uc_macs], 0);
1105 }
1106 }
1107
1108 status = be_cmd_rx_filter(adapter, IFF_MULTICAST, ON);
1109
1110 /* Set to MCAST promisc mode if setting MULTICAST address fails */
1111 if (status) {
1112 dev_info(&adapter->pdev->dev, "Exhausted multicast HW filters.\n");
1113 dev_info(&adapter->pdev->dev, "Disabling HW multicast filtering.\n");
1114 be_cmd_rx_filter(adapter, IFF_ALLMULTI, ON);
1115 }
1116 done:
1117 return;
1118 }
1119
1120 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1121 {
1122 struct be_adapter *adapter = netdev_priv(netdev);
1123 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1124 int status;
1125 bool active_mac = false;
1126 u32 pmac_id;
1127 u8 old_mac[ETH_ALEN];
1128
1129 if (!sriov_enabled(adapter))
1130 return -EPERM;
1131
1132 if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
1133 return -EINVAL;
1134
1135 if (lancer_chip(adapter)) {
1136 status = be_cmd_get_mac_from_list(adapter, old_mac, &active_mac,
1137 &pmac_id, vf + 1);
1138 if (!status && active_mac)
1139 be_cmd_pmac_del(adapter, vf_cfg->if_handle,
1140 pmac_id, vf + 1);
1141
1142 status = be_cmd_set_mac_list(adapter, mac, 1, vf + 1);
1143 } else {
1144 status = be_cmd_pmac_del(adapter, vf_cfg->if_handle,
1145 vf_cfg->pmac_id, vf + 1);
1146
1147 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
1148 &vf_cfg->pmac_id, vf + 1);
1149 }
1150
1151 if (status)
1152 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
1153 mac, vf);
1154 else
1155 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
1156
1157 return status;
1158 }
1159
1160 static int be_get_vf_config(struct net_device *netdev, int vf,
1161 struct ifla_vf_info *vi)
1162 {
1163 struct be_adapter *adapter = netdev_priv(netdev);
1164 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1165
1166 if (!sriov_enabled(adapter))
1167 return -EPERM;
1168
1169 if (vf >= adapter->num_vfs)
1170 return -EINVAL;
1171
1172 vi->vf = vf;
1173 vi->tx_rate = vf_cfg->tx_rate;
1174 vi->vlan = vf_cfg->vlan_tag;
1175 vi->qos = 0;
1176 memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
1177
1178 return 0;
1179 }
1180
1181 static int be_set_vf_vlan(struct net_device *netdev,
1182 int vf, u16 vlan, u8 qos)
1183 {
1184 struct be_adapter *adapter = netdev_priv(netdev);
1185 int status = 0;
1186
1187 if (!sriov_enabled(adapter))
1188 return -EPERM;
1189
1190 if (vf >= adapter->num_vfs || vlan > 4095)
1191 return -EINVAL;
1192
1193 if (vlan) {
1194 if (adapter->vf_cfg[vf].vlan_tag != vlan) {
1195 /* If this is new value, program it. Else skip. */
1196 adapter->vf_cfg[vf].vlan_tag = vlan;
1197
1198 status = be_cmd_set_hsw_config(adapter, vlan,
1199 vf + 1, adapter->vf_cfg[vf].if_handle);
1200 }
1201 } else {
1202 /* Reset Transparent Vlan Tagging. */
1203 adapter->vf_cfg[vf].vlan_tag = 0;
1204 vlan = adapter->vf_cfg[vf].def_vid;
1205 status = be_cmd_set_hsw_config(adapter, vlan, vf + 1,
1206 adapter->vf_cfg[vf].if_handle);
1207 }
1208
1209
1210 if (status)
1211 dev_info(&adapter->pdev->dev,
1212 "VLAN %d config on VF %d failed\n", vlan, vf);
1213 return status;
1214 }
1215
1216 static int be_set_vf_tx_rate(struct net_device *netdev,
1217 int vf, int rate)
1218 {
1219 struct be_adapter *adapter = netdev_priv(netdev);
1220 int status = 0;
1221
1222 if (!sriov_enabled(adapter))
1223 return -EPERM;
1224
1225 if (vf >= adapter->num_vfs)
1226 return -EINVAL;
1227
1228 if (rate < 100 || rate > 10000) {
1229 dev_err(&adapter->pdev->dev,
1230 "tx rate must be between 100 and 10000 Mbps\n");
1231 return -EINVAL;
1232 }
1233
1234 if (lancer_chip(adapter))
1235 status = be_cmd_set_profile_config(adapter, rate / 10, vf + 1);
1236 else
1237 status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
1238
1239 if (status)
1240 dev_err(&adapter->pdev->dev,
1241 "tx rate %d on VF %d failed\n", rate, vf);
1242 else
1243 adapter->vf_cfg[vf].tx_rate = rate;
1244 return status;
1245 }
1246
1247 static int be_find_vfs(struct be_adapter *adapter, int vf_state)
1248 {
1249 struct pci_dev *dev, *pdev = adapter->pdev;
1250 int vfs = 0, assigned_vfs = 0, pos;
1251 u16 offset, stride;
1252
1253 pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
1254 if (!pos)
1255 return 0;
1256 pci_read_config_word(pdev, pos + PCI_SRIOV_VF_OFFSET, &offset);
1257 pci_read_config_word(pdev, pos + PCI_SRIOV_VF_STRIDE, &stride);
1258
1259 dev = pci_get_device(pdev->vendor, PCI_ANY_ID, NULL);
1260 while (dev) {
1261 if (dev->is_virtfn && pci_physfn(dev) == pdev) {
1262 vfs++;
1263 if (dev->dev_flags & PCI_DEV_FLAGS_ASSIGNED)
1264 assigned_vfs++;
1265 }
1266 dev = pci_get_device(pdev->vendor, PCI_ANY_ID, dev);
1267 }
1268 return (vf_state == ASSIGNED) ? assigned_vfs : vfs;
1269 }
1270
1271 static void be_eqd_update(struct be_adapter *adapter, struct be_eq_obj *eqo)
1272 {
1273 struct be_rx_stats *stats = rx_stats(&adapter->rx_obj[eqo->idx]);
1274 ulong now = jiffies;
1275 ulong delta = now - stats->rx_jiffies;
1276 u64 pkts;
1277 unsigned int start, eqd;
1278
1279 if (!eqo->enable_aic) {
1280 eqd = eqo->eqd;
1281 goto modify_eqd;
1282 }
1283
1284 if (eqo->idx >= adapter->num_rx_qs)
1285 return;
1286
1287 stats = rx_stats(&adapter->rx_obj[eqo->idx]);
1288
1289 /* Wrapped around */
1290 if (time_before(now, stats->rx_jiffies)) {
1291 stats->rx_jiffies = now;
1292 return;
1293 }
1294
1295 /* Update once a second */
1296 if (delta < HZ)
1297 return;
1298
1299 do {
1300 start = u64_stats_fetch_begin_bh(&stats->sync);
1301 pkts = stats->rx_pkts;
1302 } while (u64_stats_fetch_retry_bh(&stats->sync, start));
1303
1304 stats->rx_pps = (unsigned long)(pkts - stats->rx_pkts_prev) / (delta / HZ);
1305 stats->rx_pkts_prev = pkts;
1306 stats->rx_jiffies = now;
1307 eqd = (stats->rx_pps / 110000) << 3;
1308 eqd = min(eqd, eqo->max_eqd);
1309 eqd = max(eqd, eqo->min_eqd);
1310 if (eqd < 10)
1311 eqd = 0;
1312
1313 modify_eqd:
1314 if (eqd != eqo->cur_eqd) {
1315 be_cmd_modify_eqd(adapter, eqo->q.id, eqd);
1316 eqo->cur_eqd = eqd;
1317 }
1318 }
1319
1320 static void be_rx_stats_update(struct be_rx_obj *rxo,
1321 struct be_rx_compl_info *rxcp)
1322 {
1323 struct be_rx_stats *stats = rx_stats(rxo);
1324
1325 u64_stats_update_begin(&stats->sync);
1326 stats->rx_compl++;
1327 stats->rx_bytes += rxcp->pkt_size;
1328 stats->rx_pkts++;
1329 if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1330 stats->rx_mcast_pkts++;
1331 if (rxcp->err)
1332 stats->rx_compl_err++;
1333 u64_stats_update_end(&stats->sync);
1334 }
1335
1336 static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1337 {
1338 /* L4 checksum is not reliable for non TCP/UDP packets.
1339 * Also ignore ipcksm for ipv6 pkts */
1340 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
1341 (rxcp->ip_csum || rxcp->ipv6);
1342 }
1343
1344 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo,
1345 u16 frag_idx)
1346 {
1347 struct be_adapter *adapter = rxo->adapter;
1348 struct be_rx_page_info *rx_page_info;
1349 struct be_queue_info *rxq = &rxo->q;
1350
1351 rx_page_info = &rxo->page_info_tbl[frag_idx];
1352 BUG_ON(!rx_page_info->page);
1353
1354 if (rx_page_info->last_page_user) {
1355 dma_unmap_page(&adapter->pdev->dev,
1356 dma_unmap_addr(rx_page_info, bus),
1357 adapter->big_page_size, DMA_FROM_DEVICE);
1358 rx_page_info->last_page_user = false;
1359 }
1360
1361 atomic_dec(&rxq->used);
1362 return rx_page_info;
1363 }
1364
1365 /* Throwaway the data in the Rx completion */
1366 static void be_rx_compl_discard(struct be_rx_obj *rxo,
1367 struct be_rx_compl_info *rxcp)
1368 {
1369 struct be_queue_info *rxq = &rxo->q;
1370 struct be_rx_page_info *page_info;
1371 u16 i, num_rcvd = rxcp->num_rcvd;
1372
1373 for (i = 0; i < num_rcvd; i++) {
1374 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1375 put_page(page_info->page);
1376 memset(page_info, 0, sizeof(*page_info));
1377 index_inc(&rxcp->rxq_idx, rxq->len);
1378 }
1379 }
1380
1381 /*
1382 * skb_fill_rx_data forms a complete skb for an ether frame
1383 * indicated by rxcp.
1384 */
1385 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
1386 struct be_rx_compl_info *rxcp)
1387 {
1388 struct be_queue_info *rxq = &rxo->q;
1389 struct be_rx_page_info *page_info;
1390 u16 i, j;
1391 u16 hdr_len, curr_frag_len, remaining;
1392 u8 *start;
1393
1394 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1395 start = page_address(page_info->page) + page_info->page_offset;
1396 prefetch(start);
1397
1398 /* Copy data in the first descriptor of this completion */
1399 curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
1400
1401 skb->len = curr_frag_len;
1402 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
1403 memcpy(skb->data, start, curr_frag_len);
1404 /* Complete packet has now been moved to data */
1405 put_page(page_info->page);
1406 skb->data_len = 0;
1407 skb->tail += curr_frag_len;
1408 } else {
1409 hdr_len = ETH_HLEN;
1410 memcpy(skb->data, start, hdr_len);
1411 skb_shinfo(skb)->nr_frags = 1;
1412 skb_frag_set_page(skb, 0, page_info->page);
1413 skb_shinfo(skb)->frags[0].page_offset =
1414 page_info->page_offset + hdr_len;
1415 skb_frag_size_set(&skb_shinfo(skb)->frags[0], curr_frag_len - hdr_len);
1416 skb->data_len = curr_frag_len - hdr_len;
1417 skb->truesize += rx_frag_size;
1418 skb->tail += hdr_len;
1419 }
1420 page_info->page = NULL;
1421
1422 if (rxcp->pkt_size <= rx_frag_size) {
1423 BUG_ON(rxcp->num_rcvd != 1);
1424 return;
1425 }
1426
1427 /* More frags present for this completion */
1428 index_inc(&rxcp->rxq_idx, rxq->len);
1429 remaining = rxcp->pkt_size - curr_frag_len;
1430 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
1431 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1432 curr_frag_len = min(remaining, rx_frag_size);
1433
1434 /* Coalesce all frags from the same physical page in one slot */
1435 if (page_info->page_offset == 0) {
1436 /* Fresh page */
1437 j++;
1438 skb_frag_set_page(skb, j, page_info->page);
1439 skb_shinfo(skb)->frags[j].page_offset =
1440 page_info->page_offset;
1441 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1442 skb_shinfo(skb)->nr_frags++;
1443 } else {
1444 put_page(page_info->page);
1445 }
1446
1447 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
1448 skb->len += curr_frag_len;
1449 skb->data_len += curr_frag_len;
1450 skb->truesize += rx_frag_size;
1451 remaining -= curr_frag_len;
1452 index_inc(&rxcp->rxq_idx, rxq->len);
1453 page_info->page = NULL;
1454 }
1455 BUG_ON(j > MAX_SKB_FRAGS);
1456 }
1457
1458 /* Process the RX completion indicated by rxcp when GRO is disabled */
1459 static void be_rx_compl_process(struct be_rx_obj *rxo,
1460 struct be_rx_compl_info *rxcp)
1461 {
1462 struct be_adapter *adapter = rxo->adapter;
1463 struct net_device *netdev = adapter->netdev;
1464 struct sk_buff *skb;
1465
1466 skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
1467 if (unlikely(!skb)) {
1468 rx_stats(rxo)->rx_drops_no_skbs++;
1469 be_rx_compl_discard(rxo, rxcp);
1470 return;
1471 }
1472
1473 skb_fill_rx_data(rxo, skb, rxcp);
1474
1475 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1476 skb->ip_summed = CHECKSUM_UNNECESSARY;
1477 else
1478 skb_checksum_none_assert(skb);
1479
1480 skb->protocol = eth_type_trans(skb, netdev);
1481 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
1482 if (netdev->features & NETIF_F_RXHASH)
1483 skb->rxhash = rxcp->rss_hash;
1484
1485
1486 if (rxcp->vlanf)
1487 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
1488
1489 netif_receive_skb(skb);
1490 }
1491
1492 /* Process the RX completion indicated by rxcp when GRO is enabled */
1493 void be_rx_compl_process_gro(struct be_rx_obj *rxo, struct napi_struct *napi,
1494 struct be_rx_compl_info *rxcp)
1495 {
1496 struct be_adapter *adapter = rxo->adapter;
1497 struct be_rx_page_info *page_info;
1498 struct sk_buff *skb = NULL;
1499 struct be_queue_info *rxq = &rxo->q;
1500 u16 remaining, curr_frag_len;
1501 u16 i, j;
1502
1503 skb = napi_get_frags(napi);
1504 if (!skb) {
1505 be_rx_compl_discard(rxo, rxcp);
1506 return;
1507 }
1508
1509 remaining = rxcp->pkt_size;
1510 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
1511 page_info = get_rx_page_info(rxo, rxcp->rxq_idx);
1512
1513 curr_frag_len = min(remaining, rx_frag_size);
1514
1515 /* Coalesce all frags from the same physical page in one slot */
1516 if (i == 0 || page_info->page_offset == 0) {
1517 /* First frag or Fresh page */
1518 j++;
1519 skb_frag_set_page(skb, j, page_info->page);
1520 skb_shinfo(skb)->frags[j].page_offset =
1521 page_info->page_offset;
1522 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
1523 } else {
1524 put_page(page_info->page);
1525 }
1526 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
1527 skb->truesize += rx_frag_size;
1528 remaining -= curr_frag_len;
1529 index_inc(&rxcp->rxq_idx, rxq->len);
1530 memset(page_info, 0, sizeof(*page_info));
1531 }
1532 BUG_ON(j > MAX_SKB_FRAGS);
1533
1534 skb_shinfo(skb)->nr_frags = j + 1;
1535 skb->len = rxcp->pkt_size;
1536 skb->data_len = rxcp->pkt_size;
1537 skb->ip_summed = CHECKSUM_UNNECESSARY;
1538 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
1539 if (adapter->netdev->features & NETIF_F_RXHASH)
1540 skb->rxhash = rxcp->rss_hash;
1541
1542 if (rxcp->vlanf)
1543 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
1544
1545 napi_gro_frags(napi);
1546 }
1547
1548 static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
1549 struct be_rx_compl_info *rxcp)
1550 {
1551 rxcp->pkt_size =
1552 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, pktsize, compl);
1553 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtp, compl);
1554 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, err, compl);
1555 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, tcpf, compl);
1556 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1557 rxcp->ip_csum =
1558 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ipcksm, compl);
1559 rxcp->l4_csum =
1560 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, l4_cksm, compl);
1561 rxcp->ipv6 =
1562 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ip_version, compl);
1563 rxcp->rxq_idx =
1564 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, fragndx, compl);
1565 rxcp->num_rcvd =
1566 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
1567 rxcp->pkt_type =
1568 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
1569 rxcp->rss_hash =
1570 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, compl);
1571 if (rxcp->vlanf) {
1572 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1573 compl);
1574 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
1575 compl);
1576 }
1577 rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, port, compl);
1578 }
1579
1580 static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
1581 struct be_rx_compl_info *rxcp)
1582 {
1583 rxcp->pkt_size =
1584 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, pktsize, compl);
1585 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtp, compl);
1586 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, err, compl);
1587 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, tcpf, compl);
1588 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1589 rxcp->ip_csum =
1590 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ipcksm, compl);
1591 rxcp->l4_csum =
1592 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, l4_cksm, compl);
1593 rxcp->ipv6 =
1594 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ip_version, compl);
1595 rxcp->rxq_idx =
1596 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, fragndx, compl);
1597 rxcp->num_rcvd =
1598 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
1599 rxcp->pkt_type =
1600 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
1601 rxcp->rss_hash =
1602 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, compl);
1603 if (rxcp->vlanf) {
1604 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1605 compl);
1606 rxcp->vlan_tag = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
1607 compl);
1608 }
1609 rxcp->port = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, port, compl);
1610 }
1611
1612 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
1613 {
1614 struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
1615 struct be_rx_compl_info *rxcp = &rxo->rxcp;
1616 struct be_adapter *adapter = rxo->adapter;
1617
1618 /* For checking the valid bit it is Ok to use either definition as the
1619 * valid bit is at the same position in both v0 and v1 Rx compl */
1620 if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
1621 return NULL;
1622
1623 rmb();
1624 be_dws_le_to_cpu(compl, sizeof(*compl));
1625
1626 if (adapter->be3_native)
1627 be_parse_rx_compl_v1(compl, rxcp);
1628 else
1629 be_parse_rx_compl_v0(compl, rxcp);
1630
1631 if (rxcp->vlanf) {
1632 /* vlanf could be wrongly set in some cards.
1633 * ignore if vtm is not set */
1634 if ((adapter->function_mode & FLEX10_MODE) && !rxcp->vtm)
1635 rxcp->vlanf = 0;
1636
1637 if (!lancer_chip(adapter))
1638 rxcp->vlan_tag = swab16(rxcp->vlan_tag);
1639
1640 if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
1641 !adapter->vlan_tag[rxcp->vlan_tag])
1642 rxcp->vlanf = 0;
1643 }
1644
1645 /* As the compl has been parsed, reset it; we wont touch it again */
1646 compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
1647
1648 queue_tail_inc(&rxo->cq);
1649 return rxcp;
1650 }
1651
1652 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
1653 {
1654 u32 order = get_order(size);
1655
1656 if (order > 0)
1657 gfp |= __GFP_COMP;
1658 return alloc_pages(gfp, order);
1659 }
1660
1661 /*
1662 * Allocate a page, split it to fragments of size rx_frag_size and post as
1663 * receive buffers to BE
1664 */
1665 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
1666 {
1667 struct be_adapter *adapter = rxo->adapter;
1668 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1669 struct be_queue_info *rxq = &rxo->q;
1670 struct page *pagep = NULL;
1671 struct be_eth_rx_d *rxd;
1672 u64 page_dmaaddr = 0, frag_dmaaddr;
1673 u32 posted, page_offset = 0;
1674
1675 page_info = &rxo->page_info_tbl[rxq->head];
1676 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1677 if (!pagep) {
1678 pagep = be_alloc_pages(adapter->big_page_size, gfp);
1679 if (unlikely(!pagep)) {
1680 rx_stats(rxo)->rx_post_fail++;
1681 break;
1682 }
1683 page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
1684 0, adapter->big_page_size,
1685 DMA_FROM_DEVICE);
1686 page_info->page_offset = 0;
1687 } else {
1688 get_page(pagep);
1689 page_info->page_offset = page_offset + rx_frag_size;
1690 }
1691 page_offset = page_info->page_offset;
1692 page_info->page = pagep;
1693 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
1694 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
1695
1696 rxd = queue_head_node(rxq);
1697 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
1698 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
1699
1700 /* Any space left in the current big page for another frag? */
1701 if ((page_offset + rx_frag_size + rx_frag_size) >
1702 adapter->big_page_size) {
1703 pagep = NULL;
1704 page_info->last_page_user = true;
1705 }
1706
1707 prev_page_info = page_info;
1708 queue_head_inc(rxq);
1709 page_info = &rxo->page_info_tbl[rxq->head];
1710 }
1711 if (pagep)
1712 prev_page_info->last_page_user = true;
1713
1714 if (posted) {
1715 atomic_add(posted, &rxq->used);
1716 be_rxq_notify(adapter, rxq->id, posted);
1717 } else if (atomic_read(&rxq->used) == 0) {
1718 /* Let be_worker replenish when memory is available */
1719 rxo->rx_post_starved = true;
1720 }
1721 }
1722
1723 static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
1724 {
1725 struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
1726
1727 if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
1728 return NULL;
1729
1730 rmb();
1731 be_dws_le_to_cpu(txcp, sizeof(*txcp));
1732
1733 txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
1734
1735 queue_tail_inc(tx_cq);
1736 return txcp;
1737 }
1738
1739 static u16 be_tx_compl_process(struct be_adapter *adapter,
1740 struct be_tx_obj *txo, u16 last_index)
1741 {
1742 struct be_queue_info *txq = &txo->q;
1743 struct be_eth_wrb *wrb;
1744 struct sk_buff **sent_skbs = txo->sent_skb_list;
1745 struct sk_buff *sent_skb;
1746 u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
1747 bool unmap_skb_hdr = true;
1748
1749 sent_skb = sent_skbs[txq->tail];
1750 BUG_ON(!sent_skb);
1751 sent_skbs[txq->tail] = NULL;
1752
1753 /* skip header wrb */
1754 queue_tail_inc(txq);
1755
1756 do {
1757 cur_index = txq->tail;
1758 wrb = queue_tail_node(txq);
1759 unmap_tx_frag(&adapter->pdev->dev, wrb,
1760 (unmap_skb_hdr && skb_headlen(sent_skb)));
1761 unmap_skb_hdr = false;
1762
1763 num_wrbs++;
1764 queue_tail_inc(txq);
1765 } while (cur_index != last_index);
1766
1767 kfree_skb(sent_skb);
1768 return num_wrbs;
1769 }
1770
1771 /* Return the number of events in the event queue */
1772 static inline int events_get(struct be_eq_obj *eqo)
1773 {
1774 struct be_eq_entry *eqe;
1775 int num = 0;
1776
1777 do {
1778 eqe = queue_tail_node(&eqo->q);
1779 if (eqe->evt == 0)
1780 break;
1781
1782 rmb();
1783 eqe->evt = 0;
1784 num++;
1785 queue_tail_inc(&eqo->q);
1786 } while (true);
1787
1788 return num;
1789 }
1790
1791 /* Leaves the EQ is disarmed state */
1792 static void be_eq_clean(struct be_eq_obj *eqo)
1793 {
1794 int num = events_get(eqo);
1795
1796 be_eq_notify(eqo->adapter, eqo->q.id, false, true, num);
1797 }
1798
1799 static void be_rx_cq_clean(struct be_rx_obj *rxo)
1800 {
1801 struct be_rx_page_info *page_info;
1802 struct be_queue_info *rxq = &rxo->q;
1803 struct be_queue_info *rx_cq = &rxo->cq;
1804 struct be_rx_compl_info *rxcp;
1805 struct be_adapter *adapter = rxo->adapter;
1806 int flush_wait = 0;
1807 u16 tail;
1808
1809 /* Consume pending rx completions.
1810 * Wait for the flush completion (identified by zero num_rcvd)
1811 * to arrive. Notify CQ even when there are no more CQ entries
1812 * for HW to flush partially coalesced CQ entries.
1813 * In Lancer, there is no need to wait for flush compl.
1814 */
1815 for (;;) {
1816 rxcp = be_rx_compl_get(rxo);
1817 if (rxcp == NULL) {
1818 if (lancer_chip(adapter))
1819 break;
1820
1821 if (flush_wait++ > 10 || be_hw_error(adapter)) {
1822 dev_warn(&adapter->pdev->dev,
1823 "did not receive flush compl\n");
1824 break;
1825 }
1826 be_cq_notify(adapter, rx_cq->id, true, 0);
1827 mdelay(1);
1828 } else {
1829 be_rx_compl_discard(rxo, rxcp);
1830 be_cq_notify(adapter, rx_cq->id, false, 1);
1831 if (rxcp->num_rcvd == 0)
1832 break;
1833 }
1834 }
1835
1836 /* After cleanup, leave the CQ in unarmed state */
1837 be_cq_notify(adapter, rx_cq->id, false, 0);
1838
1839 /* Then free posted rx buffers that were not used */
1840 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1841 for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1842 page_info = get_rx_page_info(rxo, tail);
1843 put_page(page_info->page);
1844 memset(page_info, 0, sizeof(*page_info));
1845 }
1846 BUG_ON(atomic_read(&rxq->used));
1847 rxq->tail = rxq->head = 0;
1848 }
1849
1850 static void be_tx_compl_clean(struct be_adapter *adapter)
1851 {
1852 struct be_tx_obj *txo;
1853 struct be_queue_info *txq;
1854 struct be_eth_tx_compl *txcp;
1855 u16 end_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
1856 struct sk_buff *sent_skb;
1857 bool dummy_wrb;
1858 int i, pending_txqs;
1859
1860 /* Wait for a max of 200ms for all the tx-completions to arrive. */
1861 do {
1862 pending_txqs = adapter->num_tx_qs;
1863
1864 for_all_tx_queues(adapter, txo, i) {
1865 txq = &txo->q;
1866 while ((txcp = be_tx_compl_get(&txo->cq))) {
1867 end_idx =
1868 AMAP_GET_BITS(struct amap_eth_tx_compl,
1869 wrb_index, txcp);
1870 num_wrbs += be_tx_compl_process(adapter, txo,
1871 end_idx);
1872 cmpl++;
1873 }
1874 if (cmpl) {
1875 be_cq_notify(adapter, txo->cq.id, false, cmpl);
1876 atomic_sub(num_wrbs, &txq->used);
1877 cmpl = 0;
1878 num_wrbs = 0;
1879 }
1880 if (atomic_read(&txq->used) == 0)
1881 pending_txqs--;
1882 }
1883
1884 if (pending_txqs == 0 || ++timeo > 200)
1885 break;
1886
1887 mdelay(1);
1888 } while (true);
1889
1890 for_all_tx_queues(adapter, txo, i) {
1891 txq = &txo->q;
1892 if (atomic_read(&txq->used))
1893 dev_err(&adapter->pdev->dev, "%d pending tx-compls\n",
1894 atomic_read(&txq->used));
1895
1896 /* free posted tx for which compls will never arrive */
1897 while (atomic_read(&txq->used)) {
1898 sent_skb = txo->sent_skb_list[txq->tail];
1899 end_idx = txq->tail;
1900 num_wrbs = wrb_cnt_for_skb(adapter, sent_skb,
1901 &dummy_wrb);
1902 index_adv(&end_idx, num_wrbs - 1, txq->len);
1903 num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
1904 atomic_sub(num_wrbs, &txq->used);
1905 }
1906 }
1907 }
1908
1909 static void be_evt_queues_destroy(struct be_adapter *adapter)
1910 {
1911 struct be_eq_obj *eqo;
1912 int i;
1913
1914 for_all_evt_queues(adapter, eqo, i) {
1915 if (eqo->q.created) {
1916 be_eq_clean(eqo);
1917 be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
1918 }
1919 be_queue_free(adapter, &eqo->q);
1920 }
1921 }
1922
1923 static int be_evt_queues_create(struct be_adapter *adapter)
1924 {
1925 struct be_queue_info *eq;
1926 struct be_eq_obj *eqo;
1927 int i, rc;
1928
1929 adapter->num_evt_qs = num_irqs(adapter);
1930
1931 for_all_evt_queues(adapter, eqo, i) {
1932 eqo->adapter = adapter;
1933 eqo->tx_budget = BE_TX_BUDGET;
1934 eqo->idx = i;
1935 eqo->max_eqd = BE_MAX_EQD;
1936 eqo->enable_aic = true;
1937
1938 eq = &eqo->q;
1939 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1940 sizeof(struct be_eq_entry));
1941 if (rc)
1942 return rc;
1943
1944 rc = be_cmd_eq_create(adapter, eq, eqo->cur_eqd);
1945 if (rc)
1946 return rc;
1947 }
1948 return 0;
1949 }
1950
1951 static void be_mcc_queues_destroy(struct be_adapter *adapter)
1952 {
1953 struct be_queue_info *q;
1954
1955 q = &adapter->mcc_obj.q;
1956 if (q->created)
1957 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1958 be_queue_free(adapter, q);
1959
1960 q = &adapter->mcc_obj.cq;
1961 if (q->created)
1962 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1963 be_queue_free(adapter, q);
1964 }
1965
1966 /* Must be called only after TX qs are created as MCC shares TX EQ */
1967 static int be_mcc_queues_create(struct be_adapter *adapter)
1968 {
1969 struct be_queue_info *q, *cq;
1970
1971 cq = &adapter->mcc_obj.cq;
1972 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1973 sizeof(struct be_mcc_compl)))
1974 goto err;
1975
1976 /* Use the default EQ for MCC completions */
1977 if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
1978 goto mcc_cq_free;
1979
1980 q = &adapter->mcc_obj.q;
1981 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1982 goto mcc_cq_destroy;
1983
1984 if (be_cmd_mccq_create(adapter, q, cq))
1985 goto mcc_q_free;
1986
1987 return 0;
1988
1989 mcc_q_free:
1990 be_queue_free(adapter, q);
1991 mcc_cq_destroy:
1992 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1993 mcc_cq_free:
1994 be_queue_free(adapter, cq);
1995 err:
1996 return -1;
1997 }
1998
1999 static void be_tx_queues_destroy(struct be_adapter *adapter)
2000 {
2001 struct be_queue_info *q;
2002 struct be_tx_obj *txo;
2003 u8 i;
2004
2005 for_all_tx_queues(adapter, txo, i) {
2006 q = &txo->q;
2007 if (q->created)
2008 be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
2009 be_queue_free(adapter, q);
2010
2011 q = &txo->cq;
2012 if (q->created)
2013 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2014 be_queue_free(adapter, q);
2015 }
2016 }
2017
2018 static int be_num_txqs_want(struct be_adapter *adapter)
2019 {
2020 if ((!lancer_chip(adapter) && sriov_want(adapter)) ||
2021 be_is_mc(adapter) ||
2022 (!lancer_chip(adapter) && !be_physfn(adapter)) ||
2023 BE2_chip(adapter))
2024 return 1;
2025 else
2026 return adapter->max_tx_queues;
2027 }
2028
2029 static int be_tx_cqs_create(struct be_adapter *adapter)
2030 {
2031 struct be_queue_info *cq, *eq;
2032 int status;
2033 struct be_tx_obj *txo;
2034 u8 i;
2035
2036 adapter->num_tx_qs = be_num_txqs_want(adapter);
2037 if (adapter->num_tx_qs != MAX_TX_QS) {
2038 rtnl_lock();
2039 netif_set_real_num_tx_queues(adapter->netdev,
2040 adapter->num_tx_qs);
2041 rtnl_unlock();
2042 }
2043
2044 for_all_tx_queues(adapter, txo, i) {
2045 cq = &txo->cq;
2046 status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
2047 sizeof(struct be_eth_tx_compl));
2048 if (status)
2049 return status;
2050
2051 /* If num_evt_qs is less than num_tx_qs, then more than
2052 * one txq share an eq
2053 */
2054 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2055 status = be_cmd_cq_create(adapter, cq, eq, false, 3);
2056 if (status)
2057 return status;
2058 }
2059 return 0;
2060 }
2061
2062 static int be_tx_qs_create(struct be_adapter *adapter)
2063 {
2064 struct be_tx_obj *txo;
2065 int i, status;
2066
2067 for_all_tx_queues(adapter, txo, i) {
2068 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
2069 sizeof(struct be_eth_wrb));
2070 if (status)
2071 return status;
2072
2073 status = be_cmd_txq_create(adapter, txo);
2074 if (status)
2075 return status;
2076 }
2077
2078 dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
2079 adapter->num_tx_qs);
2080 return 0;
2081 }
2082
2083 static void be_rx_cqs_destroy(struct be_adapter *adapter)
2084 {
2085 struct be_queue_info *q;
2086 struct be_rx_obj *rxo;
2087 int i;
2088
2089 for_all_rx_queues(adapter, rxo, i) {
2090 q = &rxo->cq;
2091 if (q->created)
2092 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2093 be_queue_free(adapter, q);
2094 }
2095 }
2096
2097 static int be_rx_cqs_create(struct be_adapter *adapter)
2098 {
2099 struct be_queue_info *eq, *cq;
2100 struct be_rx_obj *rxo;
2101 int rc, i;
2102
2103 /* We'll create as many RSS rings as there are irqs.
2104 * But when there's only one irq there's no use creating RSS rings
2105 */
2106 adapter->num_rx_qs = (num_irqs(adapter) > 1) ?
2107 num_irqs(adapter) + 1 : 1;
2108 if (adapter->num_rx_qs != MAX_RX_QS) {
2109 rtnl_lock();
2110 netif_set_real_num_rx_queues(adapter->netdev,
2111 adapter->num_rx_qs);
2112 rtnl_unlock();
2113 }
2114
2115 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
2116 for_all_rx_queues(adapter, rxo, i) {
2117 rxo->adapter = adapter;
2118 cq = &rxo->cq;
2119 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
2120 sizeof(struct be_eth_rx_compl));
2121 if (rc)
2122 return rc;
2123
2124 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2125 rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
2126 if (rc)
2127 return rc;
2128 }
2129
2130 dev_info(&adapter->pdev->dev,
2131 "created %d RSS queue(s) and 1 default RX queue\n",
2132 adapter->num_rx_qs - 1);
2133 return 0;
2134 }
2135
2136 static irqreturn_t be_intx(int irq, void *dev)
2137 {
2138 struct be_eq_obj *eqo = dev;
2139 struct be_adapter *adapter = eqo->adapter;
2140 int num_evts = 0;
2141
2142 /* IRQ is not expected when NAPI is scheduled as the EQ
2143 * will not be armed.
2144 * But, this can happen on Lancer INTx where it takes
2145 * a while to de-assert INTx or in BE2 where occasionaly
2146 * an interrupt may be raised even when EQ is unarmed.
2147 * If NAPI is already scheduled, then counting & notifying
2148 * events will orphan them.
2149 */
2150 if (napi_schedule_prep(&eqo->napi)) {
2151 num_evts = events_get(eqo);
2152 __napi_schedule(&eqo->napi);
2153 if (num_evts)
2154 eqo->spurious_intr = 0;
2155 }
2156 be_eq_notify(adapter, eqo->q.id, false, true, num_evts);
2157
2158 /* Return IRQ_HANDLED only for the the first spurious intr
2159 * after a valid intr to stop the kernel from branding
2160 * this irq as a bad one!
2161 */
2162 if (num_evts || eqo->spurious_intr++ == 0)
2163 return IRQ_HANDLED;
2164 else
2165 return IRQ_NONE;
2166 }
2167
2168 static irqreturn_t be_msix(int irq, void *dev)
2169 {
2170 struct be_eq_obj *eqo = dev;
2171
2172 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0);
2173 napi_schedule(&eqo->napi);
2174 return IRQ_HANDLED;
2175 }
2176
2177 static inline bool do_gro(struct be_rx_compl_info *rxcp)
2178 {
2179 return (rxcp->tcpf && !rxcp->err) ? true : false;
2180 }
2181
2182 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
2183 int budget)
2184 {
2185 struct be_adapter *adapter = rxo->adapter;
2186 struct be_queue_info *rx_cq = &rxo->cq;
2187 struct be_rx_compl_info *rxcp;
2188 u32 work_done;
2189
2190 for (work_done = 0; work_done < budget; work_done++) {
2191 rxcp = be_rx_compl_get(rxo);
2192 if (!rxcp)
2193 break;
2194
2195 /* Is it a flush compl that has no data */
2196 if (unlikely(rxcp->num_rcvd == 0))
2197 goto loop_continue;
2198
2199 /* Discard compl with partial DMA Lancer B0 */
2200 if (unlikely(!rxcp->pkt_size)) {
2201 be_rx_compl_discard(rxo, rxcp);
2202 goto loop_continue;
2203 }
2204
2205 /* On BE drop pkts that arrive due to imperfect filtering in
2206 * promiscuous mode on some skews
2207 */
2208 if (unlikely(rxcp->port != adapter->port_num &&
2209 !lancer_chip(adapter))) {
2210 be_rx_compl_discard(rxo, rxcp);
2211 goto loop_continue;
2212 }
2213
2214 if (do_gro(rxcp))
2215 be_rx_compl_process_gro(rxo, napi, rxcp);
2216 else
2217 be_rx_compl_process(rxo, rxcp);
2218 loop_continue:
2219 be_rx_stats_update(rxo, rxcp);
2220 }
2221
2222 if (work_done) {
2223 be_cq_notify(adapter, rx_cq->id, true, work_done);
2224
2225 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
2226 be_post_rx_frags(rxo, GFP_ATOMIC);
2227 }
2228
2229 return work_done;
2230 }
2231
2232 static bool be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
2233 int budget, int idx)
2234 {
2235 struct be_eth_tx_compl *txcp;
2236 int num_wrbs = 0, work_done;
2237
2238 for (work_done = 0; work_done < budget; work_done++) {
2239 txcp = be_tx_compl_get(&txo->cq);
2240 if (!txcp)
2241 break;
2242 num_wrbs += be_tx_compl_process(adapter, txo,
2243 AMAP_GET_BITS(struct amap_eth_tx_compl,
2244 wrb_index, txcp));
2245 }
2246
2247 if (work_done) {
2248 be_cq_notify(adapter, txo->cq.id, true, work_done);
2249 atomic_sub(num_wrbs, &txo->q.used);
2250
2251 /* As Tx wrbs have been freed up, wake up netdev queue
2252 * if it was stopped due to lack of tx wrbs. */
2253 if (__netif_subqueue_stopped(adapter->netdev, idx) &&
2254 atomic_read(&txo->q.used) < txo->q.len / 2) {
2255 netif_wake_subqueue(adapter->netdev, idx);
2256 }
2257
2258 u64_stats_update_begin(&tx_stats(txo)->sync_compl);
2259 tx_stats(txo)->tx_compl += work_done;
2260 u64_stats_update_end(&tx_stats(txo)->sync_compl);
2261 }
2262 return (work_done < budget); /* Done */
2263 }
2264
2265 int be_poll(struct napi_struct *napi, int budget)
2266 {
2267 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
2268 struct be_adapter *adapter = eqo->adapter;
2269 int max_work = 0, work, i, num_evts;
2270 bool tx_done;
2271
2272 num_evts = events_get(eqo);
2273
2274 /* Process all TXQs serviced by this EQ */
2275 for (i = eqo->idx; i < adapter->num_tx_qs; i += adapter->num_evt_qs) {
2276 tx_done = be_process_tx(adapter, &adapter->tx_obj[i],
2277 eqo->tx_budget, i);
2278 if (!tx_done)
2279 max_work = budget;
2280 }
2281
2282 /* This loop will iterate twice for EQ0 in which
2283 * completions of the last RXQ (default one) are also processed
2284 * For other EQs the loop iterates only once
2285 */
2286 for (i = eqo->idx; i < adapter->num_rx_qs; i += adapter->num_evt_qs) {
2287 work = be_process_rx(&adapter->rx_obj[i], napi, budget);
2288 max_work = max(work, max_work);
2289 }
2290
2291 if (is_mcc_eqo(eqo))
2292 be_process_mcc(adapter);
2293
2294 if (max_work < budget) {
2295 napi_complete(napi);
2296 be_eq_notify(adapter, eqo->q.id, true, false, num_evts);
2297 } else {
2298 /* As we'll continue in polling mode, count and clear events */
2299 be_eq_notify(adapter, eqo->q.id, false, false, num_evts);
2300 }
2301 return max_work;
2302 }
2303
2304 void be_detect_error(struct be_adapter *adapter)
2305 {
2306 u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
2307 u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
2308 u32 i;
2309
2310 if (be_hw_error(adapter))
2311 return;
2312
2313 if (lancer_chip(adapter)) {
2314 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
2315 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2316 sliport_err1 = ioread32(adapter->db +
2317 SLIPORT_ERROR1_OFFSET);
2318 sliport_err2 = ioread32(adapter->db +
2319 SLIPORT_ERROR2_OFFSET);
2320 }
2321 } else {
2322 pci_read_config_dword(adapter->pdev,
2323 PCICFG_UE_STATUS_LOW, &ue_lo);
2324 pci_read_config_dword(adapter->pdev,
2325 PCICFG_UE_STATUS_HIGH, &ue_hi);
2326 pci_read_config_dword(adapter->pdev,
2327 PCICFG_UE_STATUS_LOW_MASK, &ue_lo_mask);
2328 pci_read_config_dword(adapter->pdev,
2329 PCICFG_UE_STATUS_HI_MASK, &ue_hi_mask);
2330
2331 ue_lo = (ue_lo & ~ue_lo_mask);
2332 ue_hi = (ue_hi & ~ue_hi_mask);
2333 }
2334
2335 /* On certain platforms BE hardware can indicate spurious UEs.
2336 * Allow the h/w to stop working completely in case of a real UE.
2337 * Hence not setting the hw_error for UE detection.
2338 */
2339 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2340 adapter->hw_error = true;
2341 dev_err(&adapter->pdev->dev,
2342 "Error detected in the card\n");
2343 }
2344
2345 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
2346 dev_err(&adapter->pdev->dev,
2347 "ERR: sliport status 0x%x\n", sliport_status);
2348 dev_err(&adapter->pdev->dev,
2349 "ERR: sliport error1 0x%x\n", sliport_err1);
2350 dev_err(&adapter->pdev->dev,
2351 "ERR: sliport error2 0x%x\n", sliport_err2);
2352 }
2353
2354 if (ue_lo) {
2355 for (i = 0; ue_lo; ue_lo >>= 1, i++) {
2356 if (ue_lo & 1)
2357 dev_err(&adapter->pdev->dev,
2358 "UE: %s bit set\n", ue_status_low_desc[i]);
2359 }
2360 }
2361
2362 if (ue_hi) {
2363 for (i = 0; ue_hi; ue_hi >>= 1, i++) {
2364 if (ue_hi & 1)
2365 dev_err(&adapter->pdev->dev,
2366 "UE: %s bit set\n", ue_status_hi_desc[i]);
2367 }
2368 }
2369
2370 }
2371
2372 static void be_msix_disable(struct be_adapter *adapter)
2373 {
2374 if (msix_enabled(adapter)) {
2375 pci_disable_msix(adapter->pdev);
2376 adapter->num_msix_vec = 0;
2377 }
2378 }
2379
2380 static uint be_num_rss_want(struct be_adapter *adapter)
2381 {
2382 u32 num = 0;
2383
2384 if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
2385 (lancer_chip(adapter) ||
2386 (!sriov_want(adapter) && be_physfn(adapter)))) {
2387 num = adapter->max_rss_queues;
2388 num = min_t(u32, num, (u32)netif_get_num_default_rss_queues());
2389 }
2390 return num;
2391 }
2392
2393 static int be_msix_enable(struct be_adapter *adapter)
2394 {
2395 #define BE_MIN_MSIX_VECTORS 1
2396 int i, status, num_vec, num_roce_vec = 0;
2397 struct device *dev = &adapter->pdev->dev;
2398
2399 /* If RSS queues are not used, need a vec for default RX Q */
2400 num_vec = min(be_num_rss_want(adapter), num_online_cpus());
2401 if (be_roce_supported(adapter)) {
2402 num_roce_vec = min_t(u32, MAX_ROCE_MSIX_VECTORS,
2403 (num_online_cpus() + 1));
2404 num_roce_vec = min(num_roce_vec, MAX_ROCE_EQS);
2405 num_vec += num_roce_vec;
2406 num_vec = min(num_vec, MAX_MSIX_VECTORS);
2407 }
2408 num_vec = max(num_vec, BE_MIN_MSIX_VECTORS);
2409
2410 for (i = 0; i < num_vec; i++)
2411 adapter->msix_entries[i].entry = i;
2412
2413 status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
2414 if (status == 0) {
2415 goto done;
2416 } else if (status >= BE_MIN_MSIX_VECTORS) {
2417 num_vec = status;
2418 status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
2419 num_vec);
2420 if (!status)
2421 goto done;
2422 }
2423
2424 dev_warn(dev, "MSIx enable failed\n");
2425 /* INTx is not supported in VFs, so fail probe if enable_msix fails */
2426 if (!be_physfn(adapter))
2427 return status;
2428 return 0;
2429 done:
2430 if (be_roce_supported(adapter)) {
2431 if (num_vec > num_roce_vec) {
2432 adapter->num_msix_vec = num_vec - num_roce_vec;
2433 adapter->num_msix_roce_vec =
2434 num_vec - adapter->num_msix_vec;
2435 } else {
2436 adapter->num_msix_vec = num_vec;
2437 adapter->num_msix_roce_vec = 0;
2438 }
2439 } else
2440 adapter->num_msix_vec = num_vec;
2441 dev_info(dev, "enabled %d MSI-x vector(s)\n", adapter->num_msix_vec);
2442 return 0;
2443 }
2444
2445 static inline int be_msix_vec_get(struct be_adapter *adapter,
2446 struct be_eq_obj *eqo)
2447 {
2448 return adapter->msix_entries[eqo->idx].vector;
2449 }
2450
2451 static int be_msix_register(struct be_adapter *adapter)
2452 {
2453 struct net_device *netdev = adapter->netdev;
2454 struct be_eq_obj *eqo;
2455 int status, i, vec;
2456
2457 for_all_evt_queues(adapter, eqo, i) {
2458 sprintf(eqo->desc, "%s-q%d", netdev->name, i);
2459 vec = be_msix_vec_get(adapter, eqo);
2460 status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
2461 if (status)
2462 goto err_msix;
2463 }
2464
2465 return 0;
2466 err_msix:
2467 for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
2468 free_irq(be_msix_vec_get(adapter, eqo), eqo);
2469 dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
2470 status);
2471 be_msix_disable(adapter);
2472 return status;
2473 }
2474
2475 static int be_irq_register(struct be_adapter *adapter)
2476 {
2477 struct net_device *netdev = adapter->netdev;
2478 int status;
2479
2480 if (msix_enabled(adapter)) {
2481 status = be_msix_register(adapter);
2482 if (status == 0)
2483 goto done;
2484 /* INTx is not supported for VF */
2485 if (!be_physfn(adapter))
2486 return status;
2487 }
2488
2489 /* INTx: only the first EQ is used */
2490 netdev->irq = adapter->pdev->irq;
2491 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
2492 &adapter->eq_obj[0]);
2493 if (status) {
2494 dev_err(&adapter->pdev->dev,
2495 "INTx request IRQ failed - err %d\n", status);
2496 return status;
2497 }
2498 done:
2499 adapter->isr_registered = true;
2500 return 0;
2501 }
2502
2503 static void be_irq_unregister(struct be_adapter *adapter)
2504 {
2505 struct net_device *netdev = adapter->netdev;
2506 struct be_eq_obj *eqo;
2507 int i;
2508
2509 if (!adapter->isr_registered)
2510 return;
2511
2512 /* INTx */
2513 if (!msix_enabled(adapter)) {
2514 free_irq(netdev->irq, &adapter->eq_obj[0]);
2515 goto done;
2516 }
2517
2518 /* MSIx */
2519 for_all_evt_queues(adapter, eqo, i)
2520 free_irq(be_msix_vec_get(adapter, eqo), eqo);
2521
2522 done:
2523 adapter->isr_registered = false;
2524 }
2525
2526 static void be_rx_qs_destroy(struct be_adapter *adapter)
2527 {
2528 struct be_queue_info *q;
2529 struct be_rx_obj *rxo;
2530 int i;
2531
2532 for_all_rx_queues(adapter, rxo, i) {
2533 q = &rxo->q;
2534 if (q->created) {
2535 be_cmd_rxq_destroy(adapter, q);
2536 be_rx_cq_clean(rxo);
2537 }
2538 be_queue_free(adapter, q);
2539 }
2540 }
2541
2542 static int be_close(struct net_device *netdev)
2543 {
2544 struct be_adapter *adapter = netdev_priv(netdev);
2545 struct be_eq_obj *eqo;
2546 int i;
2547
2548 be_roce_dev_close(adapter);
2549
2550 if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
2551 for_all_evt_queues(adapter, eqo, i)
2552 napi_disable(&eqo->napi);
2553 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED;
2554 }
2555
2556 be_async_mcc_disable(adapter);
2557
2558 /* Wait for all pending tx completions to arrive so that
2559 * all tx skbs are freed.
2560 */
2561 be_tx_compl_clean(adapter);
2562 netif_tx_disable(netdev);
2563
2564 be_rx_qs_destroy(adapter);
2565
2566 for_all_evt_queues(adapter, eqo, i) {
2567 if (msix_enabled(adapter))
2568 synchronize_irq(be_msix_vec_get(adapter, eqo));
2569 else
2570 synchronize_irq(netdev->irq);
2571 be_eq_clean(eqo);
2572 }
2573
2574 be_irq_unregister(adapter);
2575
2576 return 0;
2577 }
2578
2579 static int be_rx_qs_create(struct be_adapter *adapter)
2580 {
2581 struct be_rx_obj *rxo;
2582 int rc, i, j;
2583 u8 rsstable[128];
2584
2585 for_all_rx_queues(adapter, rxo, i) {
2586 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
2587 sizeof(struct be_eth_rx_d));
2588 if (rc)
2589 return rc;
2590 }
2591
2592 /* The FW would like the default RXQ to be created first */
2593 rxo = default_rxo(adapter);
2594 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id, rx_frag_size,
2595 adapter->if_handle, false, &rxo->rss_id);
2596 if (rc)
2597 return rc;
2598
2599 for_all_rss_queues(adapter, rxo, i) {
2600 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
2601 rx_frag_size, adapter->if_handle,
2602 true, &rxo->rss_id);
2603 if (rc)
2604 return rc;
2605 }
2606
2607 if (be_multi_rxq(adapter)) {
2608 for (j = 0; j < 128; j += adapter->num_rx_qs - 1) {
2609 for_all_rss_queues(adapter, rxo, i) {
2610 if ((j + i) >= 128)
2611 break;
2612 rsstable[j + i] = rxo->rss_id;
2613 }
2614 }
2615 adapter->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 |
2616 RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6;
2617
2618 if (!BEx_chip(adapter))
2619 adapter->rss_flags |= RSS_ENABLE_UDP_IPV4 |
2620 RSS_ENABLE_UDP_IPV6;
2621
2622 rc = be_cmd_rss_config(adapter, rsstable, adapter->rss_flags,
2623 128);
2624 if (rc) {
2625 adapter->rss_flags = 0;
2626 return rc;
2627 }
2628 }
2629
2630 /* First time posting */
2631 for_all_rx_queues(adapter, rxo, i)
2632 be_post_rx_frags(rxo, GFP_KERNEL);
2633 return 0;
2634 }
2635
2636 static int be_open(struct net_device *netdev)
2637 {
2638 struct be_adapter *adapter = netdev_priv(netdev);
2639 struct be_eq_obj *eqo;
2640 struct be_rx_obj *rxo;
2641 struct be_tx_obj *txo;
2642 u8 link_status;
2643 int status, i;
2644
2645 status = be_rx_qs_create(adapter);
2646 if (status)
2647 goto err;
2648
2649 status = be_irq_register(adapter);
2650 if (status)
2651 goto err;
2652
2653 for_all_rx_queues(adapter, rxo, i)
2654 be_cq_notify(adapter, rxo->cq.id, true, 0);
2655
2656 for_all_tx_queues(adapter, txo, i)
2657 be_cq_notify(adapter, txo->cq.id, true, 0);
2658
2659 be_async_mcc_enable(adapter);
2660
2661 for_all_evt_queues(adapter, eqo, i) {
2662 napi_enable(&eqo->napi);
2663 be_eq_notify(adapter, eqo->q.id, true, false, 0);
2664 }
2665 adapter->flags |= BE_FLAGS_NAPI_ENABLED;
2666
2667 status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
2668 if (!status)
2669 be_link_status_update(adapter, link_status);
2670
2671 netif_tx_start_all_queues(netdev);
2672 be_roce_dev_open(adapter);
2673 return 0;
2674 err:
2675 be_close(adapter->netdev);
2676 return -EIO;
2677 }
2678
2679 static int be_setup_wol(struct be_adapter *adapter, bool enable)
2680 {
2681 struct be_dma_mem cmd;
2682 int status = 0;
2683 u8 mac[ETH_ALEN];
2684
2685 memset(mac, 0, ETH_ALEN);
2686
2687 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2688 cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
2689 GFP_KERNEL | __GFP_ZERO);
2690 if (cmd.va == NULL)
2691 return -1;
2692
2693 if (enable) {
2694 status = pci_write_config_dword(adapter->pdev,
2695 PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
2696 if (status) {
2697 dev_err(&adapter->pdev->dev,
2698 "Could not enable Wake-on-lan\n");
2699 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
2700 cmd.dma);
2701 return status;
2702 }
2703 status = be_cmd_enable_magic_wol(adapter,
2704 adapter->netdev->dev_addr, &cmd);
2705 pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
2706 pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
2707 } else {
2708 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
2709 pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
2710 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2711 }
2712
2713 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2714 return status;
2715 }
2716
2717 /*
2718 * Generate a seed MAC address from the PF MAC Address using jhash.
2719 * MAC Address for VFs are assigned incrementally starting from the seed.
2720 * These addresses are programmed in the ASIC by the PF and the VF driver
2721 * queries for the MAC address during its probe.
2722 */
2723 static int be_vf_eth_addr_config(struct be_adapter *adapter)
2724 {
2725 u32 vf;
2726 int status = 0;
2727 u8 mac[ETH_ALEN];
2728 struct be_vf_cfg *vf_cfg;
2729
2730 be_vf_eth_addr_generate(adapter, mac);
2731
2732 for_all_vfs(adapter, vf_cfg, vf) {
2733 if (lancer_chip(adapter)) {
2734 status = be_cmd_set_mac_list(adapter, mac, 1, vf + 1);
2735 } else {
2736 status = be_cmd_pmac_add(adapter, mac,
2737 vf_cfg->if_handle,
2738 &vf_cfg->pmac_id, vf + 1);
2739 }
2740
2741 if (status)
2742 dev_err(&adapter->pdev->dev,
2743 "Mac address assignment failed for VF %d\n", vf);
2744 else
2745 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
2746
2747 mac[5] += 1;
2748 }
2749 return status;
2750 }
2751
2752 static int be_vfs_mac_query(struct be_adapter *adapter)
2753 {
2754 int status, vf;
2755 u8 mac[ETH_ALEN];
2756 struct be_vf_cfg *vf_cfg;
2757 bool active;
2758
2759 for_all_vfs(adapter, vf_cfg, vf) {
2760 be_cmd_get_mac_from_list(adapter, mac, &active,
2761 &vf_cfg->pmac_id, 0);
2762
2763 status = be_cmd_mac_addr_query(adapter, mac, false,
2764 vf_cfg->if_handle, 0);
2765 if (status)
2766 return status;
2767 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
2768 }
2769 return 0;
2770 }
2771
2772 static void be_vf_clear(struct be_adapter *adapter)
2773 {
2774 struct be_vf_cfg *vf_cfg;
2775 u32 vf;
2776
2777 if (be_find_vfs(adapter, ASSIGNED)) {
2778 dev_warn(&adapter->pdev->dev,
2779 "VFs are assigned to VMs: not disabling VFs\n");
2780 goto done;
2781 }
2782
2783 pci_disable_sriov(adapter->pdev);
2784
2785 for_all_vfs(adapter, vf_cfg, vf) {
2786 if (lancer_chip(adapter))
2787 be_cmd_set_mac_list(adapter, NULL, 0, vf + 1);
2788 else
2789 be_cmd_pmac_del(adapter, vf_cfg->if_handle,
2790 vf_cfg->pmac_id, vf + 1);
2791
2792 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
2793 }
2794 done:
2795 kfree(adapter->vf_cfg);
2796 adapter->num_vfs = 0;
2797 }
2798
2799 static int be_clear(struct be_adapter *adapter)
2800 {
2801 int i = 1;
2802
2803 if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
2804 cancel_delayed_work_sync(&adapter->work);
2805 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
2806 }
2807
2808 if (sriov_enabled(adapter))
2809 be_vf_clear(adapter);
2810
2811 for (; adapter->uc_macs > 0; adapter->uc_macs--, i++)
2812 be_cmd_pmac_del(adapter, adapter->if_handle,
2813 adapter->pmac_id[i], 0);
2814
2815 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
2816
2817 be_mcc_queues_destroy(adapter);
2818 be_rx_cqs_destroy(adapter);
2819 be_tx_queues_destroy(adapter);
2820 be_evt_queues_destroy(adapter);
2821
2822 kfree(adapter->pmac_id);
2823 adapter->pmac_id = NULL;
2824
2825 be_msix_disable(adapter);
2826 return 0;
2827 }
2828
2829 static int be_vfs_if_create(struct be_adapter *adapter)
2830 {
2831 struct be_vf_cfg *vf_cfg;
2832 u32 cap_flags, en_flags, vf;
2833 int status;
2834
2835 cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
2836 BE_IF_FLAGS_MULTICAST;
2837
2838 for_all_vfs(adapter, vf_cfg, vf) {
2839 if (!BE3_chip(adapter))
2840 be_cmd_get_profile_config(adapter, &cap_flags,
2841 NULL, vf + 1);
2842
2843 /* If a FW profile exists, then cap_flags are updated */
2844 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
2845 BE_IF_FLAGS_BROADCAST | BE_IF_FLAGS_MULTICAST);
2846 status = be_cmd_if_create(adapter, cap_flags, en_flags,
2847 &vf_cfg->if_handle, vf + 1);
2848 if (status)
2849 goto err;
2850 }
2851 err:
2852 return status;
2853 }
2854
2855 static int be_vf_setup_init(struct be_adapter *adapter)
2856 {
2857 struct be_vf_cfg *vf_cfg;
2858 int vf;
2859
2860 adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
2861 GFP_KERNEL);
2862 if (!adapter->vf_cfg)
2863 return -ENOMEM;
2864
2865 for_all_vfs(adapter, vf_cfg, vf) {
2866 vf_cfg->if_handle = -1;
2867 vf_cfg->pmac_id = -1;
2868 }
2869 return 0;
2870 }
2871
2872 static int be_vf_setup(struct be_adapter *adapter)
2873 {
2874 struct be_vf_cfg *vf_cfg;
2875 u16 def_vlan, lnk_speed;
2876 int status, old_vfs, vf;
2877 struct device *dev = &adapter->pdev->dev;
2878
2879 old_vfs = be_find_vfs(adapter, ENABLED);
2880 if (old_vfs) {
2881 dev_info(dev, "%d VFs are already enabled\n", old_vfs);
2882 if (old_vfs != num_vfs)
2883 dev_warn(dev, "Ignoring num_vfs=%d setting\n", num_vfs);
2884 adapter->num_vfs = old_vfs;
2885 } else {
2886 if (num_vfs > adapter->dev_num_vfs)
2887 dev_info(dev, "Device supports %d VFs and not %d\n",
2888 adapter->dev_num_vfs, num_vfs);
2889 adapter->num_vfs = min_t(u16, num_vfs, adapter->dev_num_vfs);
2890 if (!adapter->num_vfs)
2891 return 0;
2892 }
2893
2894 status = be_vf_setup_init(adapter);
2895 if (status)
2896 goto err;
2897
2898 if (old_vfs) {
2899 for_all_vfs(adapter, vf_cfg, vf) {
2900 status = be_cmd_get_if_id(adapter, vf_cfg, vf);
2901 if (status)
2902 goto err;
2903 }
2904 } else {
2905 status = be_vfs_if_create(adapter);
2906 if (status)
2907 goto err;
2908 }
2909
2910 if (old_vfs) {
2911 status = be_vfs_mac_query(adapter);
2912 if (status)
2913 goto err;
2914 } else {
2915 status = be_vf_eth_addr_config(adapter);
2916 if (status)
2917 goto err;
2918 }
2919
2920 for_all_vfs(adapter, vf_cfg, vf) {
2921 /* BE3 FW, by default, caps VF TX-rate to 100mbps.
2922 * Allow full available bandwidth
2923 */
2924 if (BE3_chip(adapter) && !old_vfs)
2925 be_cmd_set_qos(adapter, 1000, vf+1);
2926
2927 status = be_cmd_link_status_query(adapter, &lnk_speed,
2928 NULL, vf + 1);
2929 if (!status)
2930 vf_cfg->tx_rate = lnk_speed;
2931
2932 status = be_cmd_get_hsw_config(adapter, &def_vlan,
2933 vf + 1, vf_cfg->if_handle);
2934 if (status)
2935 goto err;
2936 vf_cfg->def_vid = def_vlan;
2937
2938 be_cmd_enable_vf(adapter, vf + 1);
2939 }
2940
2941 if (!old_vfs) {
2942 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
2943 if (status) {
2944 dev_err(dev, "SRIOV enable failed\n");
2945 adapter->num_vfs = 0;
2946 goto err;
2947 }
2948 }
2949 return 0;
2950 err:
2951 dev_err(dev, "VF setup failed\n");
2952 be_vf_clear(adapter);
2953 return status;
2954 }
2955
2956 static void be_setup_init(struct be_adapter *adapter)
2957 {
2958 adapter->vlan_prio_bmap = 0xff;
2959 adapter->phy.link_speed = -1;
2960 adapter->if_handle = -1;
2961 adapter->be3_native = false;
2962 adapter->promiscuous = false;
2963 if (be_physfn(adapter))
2964 adapter->cmd_privileges = MAX_PRIVILEGES;
2965 else
2966 adapter->cmd_privileges = MIN_PRIVILEGES;
2967 }
2968
2969 static int be_get_mac_addr(struct be_adapter *adapter, u8 *mac, u32 if_handle,
2970 bool *active_mac, u32 *pmac_id)
2971 {
2972 int status = 0;
2973
2974 if (!is_zero_ether_addr(adapter->netdev->perm_addr)) {
2975 memcpy(mac, adapter->netdev->dev_addr, ETH_ALEN);
2976 if (!lancer_chip(adapter) && !be_physfn(adapter))
2977 *active_mac = true;
2978 else
2979 *active_mac = false;
2980
2981 return status;
2982 }
2983
2984 if (lancer_chip(adapter)) {
2985 status = be_cmd_get_mac_from_list(adapter, mac,
2986 active_mac, pmac_id, 0);
2987 if (*active_mac) {
2988 status = be_cmd_mac_addr_query(adapter, mac, false,
2989 if_handle, *pmac_id);
2990 }
2991 } else if (be_physfn(adapter)) {
2992 /* For BE3, for PF get permanent MAC */
2993 status = be_cmd_mac_addr_query(adapter, mac, true, 0, 0);
2994 *active_mac = false;
2995 } else {
2996 /* For BE3, for VF get soft MAC assigned by PF*/
2997 status = be_cmd_mac_addr_query(adapter, mac, false,
2998 if_handle, 0);
2999 *active_mac = true;
3000 }
3001 return status;
3002 }
3003
3004 static void be_get_resources(struct be_adapter *adapter)
3005 {
3006 u16 dev_num_vfs;
3007 int pos, status;
3008 bool profile_present = false;
3009 u16 txq_count = 0;
3010
3011 if (!BEx_chip(adapter)) {
3012 status = be_cmd_get_func_config(adapter);
3013 if (!status)
3014 profile_present = true;
3015 } else if (BE3_chip(adapter) && be_physfn(adapter)) {
3016 be_cmd_get_profile_config(adapter, NULL, &txq_count, 0);
3017 }
3018
3019 if (profile_present) {
3020 /* Sanity fixes for Lancer */
3021 adapter->max_pmac_cnt = min_t(u16, adapter->max_pmac_cnt,
3022 BE_UC_PMAC_COUNT);
3023 adapter->max_vlans = min_t(u16, adapter->max_vlans,
3024 BE_NUM_VLANS_SUPPORTED);
3025 adapter->max_mcast_mac = min_t(u16, adapter->max_mcast_mac,
3026 BE_MAX_MC);
3027 adapter->max_tx_queues = min_t(u16, adapter->max_tx_queues,
3028 MAX_TX_QS);
3029 adapter->max_rss_queues = min_t(u16, adapter->max_rss_queues,
3030 BE3_MAX_RSS_QS);
3031 adapter->max_event_queues = min_t(u16,
3032 adapter->max_event_queues,
3033 BE3_MAX_RSS_QS);
3034
3035 if (adapter->max_rss_queues &&
3036 adapter->max_rss_queues == adapter->max_rx_queues)
3037 adapter->max_rss_queues -= 1;
3038
3039 if (adapter->max_event_queues < adapter->max_rss_queues)
3040 adapter->max_rss_queues = adapter->max_event_queues;
3041
3042 } else {
3043 if (be_physfn(adapter))
3044 adapter->max_pmac_cnt = BE_UC_PMAC_COUNT;
3045 else
3046 adapter->max_pmac_cnt = BE_VF_UC_PMAC_COUNT;
3047
3048 if (adapter->function_mode & FLEX10_MODE)
3049 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
3050 else
3051 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
3052
3053 adapter->max_mcast_mac = BE_MAX_MC;
3054 adapter->max_tx_queues = txq_count ? txq_count : MAX_TX_QS;
3055 adapter->max_tx_queues = min_t(u16, adapter->max_tx_queues,
3056 MAX_TX_QS);
3057 adapter->max_rss_queues = (adapter->be3_native) ?
3058 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
3059 adapter->max_event_queues = BE3_MAX_RSS_QS;
3060
3061 adapter->if_cap_flags = BE_IF_FLAGS_UNTAGGED |
3062 BE_IF_FLAGS_BROADCAST |
3063 BE_IF_FLAGS_MULTICAST |
3064 BE_IF_FLAGS_PASS_L3L4_ERRORS |
3065 BE_IF_FLAGS_MCAST_PROMISCUOUS |
3066 BE_IF_FLAGS_VLAN_PROMISCUOUS |
3067 BE_IF_FLAGS_PROMISCUOUS;
3068
3069 if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
3070 adapter->if_cap_flags |= BE_IF_FLAGS_RSS;
3071 }
3072
3073 pos = pci_find_ext_capability(adapter->pdev, PCI_EXT_CAP_ID_SRIOV);
3074 if (pos) {
3075 pci_read_config_word(adapter->pdev, pos + PCI_SRIOV_TOTAL_VF,
3076 &dev_num_vfs);
3077 if (BE3_chip(adapter))
3078 dev_num_vfs = min_t(u16, dev_num_vfs, MAX_VFS);
3079 adapter->dev_num_vfs = dev_num_vfs;
3080 }
3081 }
3082
3083 /* Routine to query per function resource limits */
3084 static int be_get_config(struct be_adapter *adapter)
3085 {
3086 int status;
3087
3088 status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
3089 &adapter->function_mode,
3090 &adapter->function_caps,
3091 &adapter->asic_rev);
3092 if (status)
3093 goto err;
3094
3095 be_get_resources(adapter);
3096
3097 /* primary mac needs 1 pmac entry */
3098 adapter->pmac_id = kcalloc(adapter->max_pmac_cnt + 1,
3099 sizeof(u32), GFP_KERNEL);
3100 if (!adapter->pmac_id) {
3101 status = -ENOMEM;
3102 goto err;
3103 }
3104
3105 err:
3106 return status;
3107 }
3108
3109 static int be_setup(struct be_adapter *adapter)
3110 {
3111 struct device *dev = &adapter->pdev->dev;
3112 u32 en_flags;
3113 u32 tx_fc, rx_fc;
3114 int status;
3115 u8 mac[ETH_ALEN];
3116 bool active_mac;
3117
3118 be_setup_init(adapter);
3119
3120 if (!lancer_chip(adapter))
3121 be_cmd_req_native_mode(adapter);
3122
3123 status = be_get_config(adapter);
3124 if (status)
3125 goto err;
3126
3127 status = be_msix_enable(adapter);
3128 if (status)
3129 goto err;
3130
3131 status = be_evt_queues_create(adapter);
3132 if (status)
3133 goto err;
3134
3135 status = be_tx_cqs_create(adapter);
3136 if (status)
3137 goto err;
3138
3139 status = be_rx_cqs_create(adapter);
3140 if (status)
3141 goto err;
3142
3143 status = be_mcc_queues_create(adapter);
3144 if (status)
3145 goto err;
3146
3147 be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
3148 /* In UMC mode FW does not return right privileges.
3149 * Override with correct privilege equivalent to PF.
3150 */
3151 if (be_is_mc(adapter))
3152 adapter->cmd_privileges = MAX_PRIVILEGES;
3153
3154 en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3155 BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3156
3157 if (adapter->function_caps & BE_FUNCTION_CAPS_RSS)
3158 en_flags |= BE_IF_FLAGS_RSS;
3159
3160 en_flags = en_flags & adapter->if_cap_flags;
3161
3162 status = be_cmd_if_create(adapter, adapter->if_cap_flags, en_flags,
3163 &adapter->if_handle, 0);
3164 if (status != 0)
3165 goto err;
3166
3167 memset(mac, 0, ETH_ALEN);
3168 active_mac = false;
3169 status = be_get_mac_addr(adapter, mac, adapter->if_handle,
3170 &active_mac, &adapter->pmac_id[0]);
3171 if (status != 0)
3172 goto err;
3173
3174 if (!active_mac) {
3175 status = be_cmd_pmac_add(adapter, mac, adapter->if_handle,
3176 &adapter->pmac_id[0], 0);
3177 if (status != 0)
3178 goto err;
3179 }
3180
3181 if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
3182 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
3183 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
3184 }
3185
3186 status = be_tx_qs_create(adapter);
3187 if (status)
3188 goto err;
3189
3190 be_cmd_get_fw_ver(adapter, adapter->fw_ver, NULL);
3191
3192 if (adapter->vlans_added)
3193 be_vid_config(adapter);
3194
3195 be_set_rx_mode(adapter->netdev);
3196
3197 be_cmd_get_flow_control(adapter, &tx_fc, &rx_fc);
3198
3199 if (rx_fc != adapter->rx_fc || tx_fc != adapter->tx_fc)
3200 be_cmd_set_flow_control(adapter, adapter->tx_fc,
3201 adapter->rx_fc);
3202
3203 if (be_physfn(adapter)) {
3204 if (adapter->dev_num_vfs)
3205 be_vf_setup(adapter);
3206 else
3207 dev_warn(dev, "device doesn't support SRIOV\n");
3208 }
3209
3210 status = be_cmd_get_phy_info(adapter);
3211 if (!status && be_pause_supported(adapter))
3212 adapter->phy.fc_autoneg = 1;
3213
3214 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
3215 adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
3216 return 0;
3217 err:
3218 be_clear(adapter);
3219 return status;
3220 }
3221
3222 #ifdef CONFIG_NET_POLL_CONTROLLER
3223 static void be_netpoll(struct net_device *netdev)
3224 {
3225 struct be_adapter *adapter = netdev_priv(netdev);
3226 struct be_eq_obj *eqo;
3227 int i;
3228
3229 for_all_evt_queues(adapter, eqo, i) {
3230 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0);
3231 napi_schedule(&eqo->napi);
3232 }
3233
3234 return;
3235 }
3236 #endif
3237
3238 #define FW_FILE_HDR_SIGN "ServerEngines Corp. "
3239 char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
3240
3241 static bool be_flash_redboot(struct be_adapter *adapter,
3242 const u8 *p, u32 img_start, int image_size,
3243 int hdr_size)
3244 {
3245 u32 crc_offset;
3246 u8 flashed_crc[4];
3247 int status;
3248
3249 crc_offset = hdr_size + img_start + image_size - 4;
3250
3251 p += crc_offset;
3252
3253 status = be_cmd_get_flash_crc(adapter, flashed_crc,
3254 (image_size - 4));
3255 if (status) {
3256 dev_err(&adapter->pdev->dev,
3257 "could not get crc from flash, not flashing redboot\n");
3258 return false;
3259 }
3260
3261 /*update redboot only if crc does not match*/
3262 if (!memcmp(flashed_crc, p, 4))
3263 return false;
3264 else
3265 return true;
3266 }
3267
3268 static bool phy_flashing_required(struct be_adapter *adapter)
3269 {
3270 return (adapter->phy.phy_type == TN_8022 &&
3271 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
3272 }
3273
3274 static bool is_comp_in_ufi(struct be_adapter *adapter,
3275 struct flash_section_info *fsec, int type)
3276 {
3277 int i = 0, img_type = 0;
3278 struct flash_section_info_g2 *fsec_g2 = NULL;
3279
3280 if (BE2_chip(adapter))
3281 fsec_g2 = (struct flash_section_info_g2 *)fsec;
3282
3283 for (i = 0; i < MAX_FLASH_COMP; i++) {
3284 if (fsec_g2)
3285 img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
3286 else
3287 img_type = le32_to_cpu(fsec->fsec_entry[i].type);
3288
3289 if (img_type == type)
3290 return true;
3291 }
3292 return false;
3293
3294 }
3295
3296 struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
3297 int header_size,
3298 const struct firmware *fw)
3299 {
3300 struct flash_section_info *fsec = NULL;
3301 const u8 *p = fw->data;
3302
3303 p += header_size;
3304 while (p < (fw->data + fw->size)) {
3305 fsec = (struct flash_section_info *)p;
3306 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
3307 return fsec;
3308 p += 32;
3309 }
3310 return NULL;
3311 }
3312
3313 static int be_flash(struct be_adapter *adapter, const u8 *img,
3314 struct be_dma_mem *flash_cmd, int optype, int img_size)
3315 {
3316 u32 total_bytes = 0, flash_op, num_bytes = 0;
3317 int status = 0;
3318 struct be_cmd_write_flashrom *req = flash_cmd->va;
3319
3320 total_bytes = img_size;
3321 while (total_bytes) {
3322 num_bytes = min_t(u32, 32*1024, total_bytes);
3323
3324 total_bytes -= num_bytes;
3325
3326 if (!total_bytes) {
3327 if (optype == OPTYPE_PHY_FW)
3328 flash_op = FLASHROM_OPER_PHY_FLASH;
3329 else
3330 flash_op = FLASHROM_OPER_FLASH;
3331 } else {
3332 if (optype == OPTYPE_PHY_FW)
3333 flash_op = FLASHROM_OPER_PHY_SAVE;
3334 else
3335 flash_op = FLASHROM_OPER_SAVE;
3336 }
3337
3338 memcpy(req->data_buf, img, num_bytes);
3339 img += num_bytes;
3340 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
3341 flash_op, num_bytes);
3342 if (status) {
3343 if (status == ILLEGAL_IOCTL_REQ &&
3344 optype == OPTYPE_PHY_FW)
3345 break;
3346 dev_err(&adapter->pdev->dev,
3347 "cmd to write to flash rom failed.\n");
3348 return status;
3349 }
3350 }
3351 return 0;
3352 }
3353
3354 /* For BE2, BE3 and BE3-R */
3355 static int be_flash_BEx(struct be_adapter *adapter,
3356 const struct firmware *fw,
3357 struct be_dma_mem *flash_cmd,
3358 int num_of_images)
3359
3360 {
3361 int status = 0, i, filehdr_size = 0;
3362 int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
3363 const u8 *p = fw->data;
3364 const struct flash_comp *pflashcomp;
3365 int num_comp, redboot;
3366 struct flash_section_info *fsec = NULL;
3367
3368 struct flash_comp gen3_flash_types[] = {
3369 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
3370 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
3371 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
3372 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
3373 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
3374 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
3375 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
3376 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
3377 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
3378 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
3379 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
3380 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
3381 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
3382 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
3383 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
3384 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
3385 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
3386 FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
3387 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
3388 FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
3389 };
3390
3391 struct flash_comp gen2_flash_types[] = {
3392 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
3393 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
3394 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
3395 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
3396 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
3397 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
3398 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
3399 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
3400 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
3401 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
3402 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
3403 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
3404 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
3405 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
3406 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
3407 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
3408 };
3409
3410 if (BE3_chip(adapter)) {
3411 pflashcomp = gen3_flash_types;
3412 filehdr_size = sizeof(struct flash_file_hdr_g3);
3413 num_comp = ARRAY_SIZE(gen3_flash_types);
3414 } else {
3415 pflashcomp = gen2_flash_types;
3416 filehdr_size = sizeof(struct flash_file_hdr_g2);
3417 num_comp = ARRAY_SIZE(gen2_flash_types);
3418 }
3419
3420 /* Get flash section info*/
3421 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
3422 if (!fsec) {
3423 dev_err(&adapter->pdev->dev,
3424 "Invalid Cookie. UFI corrupted ?\n");
3425 return -1;
3426 }
3427 for (i = 0; i < num_comp; i++) {
3428 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
3429 continue;
3430
3431 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
3432 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
3433 continue;
3434
3435 if (pflashcomp[i].optype == OPTYPE_PHY_FW &&
3436 !phy_flashing_required(adapter))
3437 continue;
3438
3439 if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
3440 redboot = be_flash_redboot(adapter, fw->data,
3441 pflashcomp[i].offset, pflashcomp[i].size,
3442 filehdr_size + img_hdrs_size);
3443 if (!redboot)
3444 continue;
3445 }
3446
3447 p = fw->data;
3448 p += filehdr_size + pflashcomp[i].offset + img_hdrs_size;
3449 if (p + pflashcomp[i].size > fw->data + fw->size)
3450 return -1;
3451
3452 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
3453 pflashcomp[i].size);
3454 if (status) {
3455 dev_err(&adapter->pdev->dev,
3456 "Flashing section type %d failed.\n",
3457 pflashcomp[i].img_type);
3458 return status;
3459 }
3460 }
3461 return 0;
3462 }
3463
3464 static int be_flash_skyhawk(struct be_adapter *adapter,
3465 const struct firmware *fw,
3466 struct be_dma_mem *flash_cmd, int num_of_images)
3467 {
3468 int status = 0, i, filehdr_size = 0;
3469 int img_offset, img_size, img_optype, redboot;
3470 int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
3471 const u8 *p = fw->data;
3472 struct flash_section_info *fsec = NULL;
3473
3474 filehdr_size = sizeof(struct flash_file_hdr_g3);
3475 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
3476 if (!fsec) {
3477 dev_err(&adapter->pdev->dev,
3478 "Invalid Cookie. UFI corrupted ?\n");
3479 return -1;
3480 }
3481
3482 for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
3483 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
3484 img_size = le32_to_cpu(fsec->fsec_entry[i].pad_size);
3485
3486 switch (le32_to_cpu(fsec->fsec_entry[i].type)) {
3487 case IMAGE_FIRMWARE_iSCSI:
3488 img_optype = OPTYPE_ISCSI_ACTIVE;
3489 break;
3490 case IMAGE_BOOT_CODE:
3491 img_optype = OPTYPE_REDBOOT;
3492 break;
3493 case IMAGE_OPTION_ROM_ISCSI:
3494 img_optype = OPTYPE_BIOS;
3495 break;
3496 case IMAGE_OPTION_ROM_PXE:
3497 img_optype = OPTYPE_PXE_BIOS;
3498 break;
3499 case IMAGE_OPTION_ROM_FCoE:
3500 img_optype = OPTYPE_FCOE_BIOS;
3501 break;
3502 case IMAGE_FIRMWARE_BACKUP_iSCSI:
3503 img_optype = OPTYPE_ISCSI_BACKUP;
3504 break;
3505 case IMAGE_NCSI:
3506 img_optype = OPTYPE_NCSI_FW;
3507 break;
3508 default:
3509 continue;
3510 }
3511
3512 if (img_optype == OPTYPE_REDBOOT) {
3513 redboot = be_flash_redboot(adapter, fw->data,
3514 img_offset, img_size,
3515 filehdr_size + img_hdrs_size);
3516 if (!redboot)
3517 continue;
3518 }
3519
3520 p = fw->data;
3521 p += filehdr_size + img_offset + img_hdrs_size;
3522 if (p + img_size > fw->data + fw->size)
3523 return -1;
3524
3525 status = be_flash(adapter, p, flash_cmd, img_optype, img_size);
3526 if (status) {
3527 dev_err(&adapter->pdev->dev,
3528 "Flashing section type %d failed.\n",
3529 fsec->fsec_entry[i].type);
3530 return status;
3531 }
3532 }
3533 return 0;
3534 }
3535
3536 static int lancer_wait_idle(struct be_adapter *adapter)
3537 {
3538 #define SLIPORT_IDLE_TIMEOUT 30
3539 u32 reg_val;
3540 int status = 0, i;
3541
3542 for (i = 0; i < SLIPORT_IDLE_TIMEOUT; i++) {
3543 reg_val = ioread32(adapter->db + PHYSDEV_CONTROL_OFFSET);
3544 if ((reg_val & PHYSDEV_CONTROL_INP_MASK) == 0)
3545 break;
3546
3547 ssleep(1);
3548 }
3549
3550 if (i == SLIPORT_IDLE_TIMEOUT)
3551 status = -1;
3552
3553 return status;
3554 }
3555
3556 static int lancer_fw_reset(struct be_adapter *adapter)
3557 {
3558 int status = 0;
3559
3560 status = lancer_wait_idle(adapter);
3561 if (status)
3562 return status;
3563
3564 iowrite32(PHYSDEV_CONTROL_FW_RESET_MASK, adapter->db +
3565 PHYSDEV_CONTROL_OFFSET);
3566
3567 return status;
3568 }
3569
3570 static int lancer_fw_download(struct be_adapter *adapter,
3571 const struct firmware *fw)
3572 {
3573 #define LANCER_FW_DOWNLOAD_CHUNK (32 * 1024)
3574 #define LANCER_FW_DOWNLOAD_LOCATION "/prg"
3575 struct be_dma_mem flash_cmd;
3576 const u8 *data_ptr = NULL;
3577 u8 *dest_image_ptr = NULL;
3578 size_t image_size = 0;
3579 u32 chunk_size = 0;
3580 u32 data_written = 0;
3581 u32 offset = 0;
3582 int status = 0;
3583 u8 add_status = 0;
3584 u8 change_status;
3585
3586 if (!IS_ALIGNED(fw->size, sizeof(u32))) {
3587 dev_err(&adapter->pdev->dev,
3588 "FW Image not properly aligned. "
3589 "Length must be 4 byte aligned.\n");
3590 status = -EINVAL;
3591 goto lancer_fw_exit;
3592 }
3593
3594 flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
3595 + LANCER_FW_DOWNLOAD_CHUNK;
3596 flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
3597 &flash_cmd.dma, GFP_KERNEL);
3598 if (!flash_cmd.va) {
3599 status = -ENOMEM;
3600 goto lancer_fw_exit;
3601 }
3602
3603 dest_image_ptr = flash_cmd.va +
3604 sizeof(struct lancer_cmd_req_write_object);
3605 image_size = fw->size;
3606 data_ptr = fw->data;
3607
3608 while (image_size) {
3609 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
3610
3611 /* Copy the image chunk content. */
3612 memcpy(dest_image_ptr, data_ptr, chunk_size);
3613
3614 status = lancer_cmd_write_object(adapter, &flash_cmd,
3615 chunk_size, offset,
3616 LANCER_FW_DOWNLOAD_LOCATION,
3617 &data_written, &change_status,
3618 &add_status);
3619 if (status)
3620 break;
3621
3622 offset += data_written;
3623 data_ptr += data_written;
3624 image_size -= data_written;
3625 }
3626
3627 if (!status) {
3628 /* Commit the FW written */
3629 status = lancer_cmd_write_object(adapter, &flash_cmd,
3630 0, offset,
3631 LANCER_FW_DOWNLOAD_LOCATION,
3632 &data_written, &change_status,
3633 &add_status);
3634 }
3635
3636 dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
3637 flash_cmd.dma);
3638 if (status) {
3639 dev_err(&adapter->pdev->dev,
3640 "Firmware load error. "
3641 "Status code: 0x%x Additional Status: 0x%x\n",
3642 status, add_status);
3643 goto lancer_fw_exit;
3644 }
3645
3646 if (change_status == LANCER_FW_RESET_NEEDED) {
3647 status = lancer_fw_reset(adapter);
3648 if (status) {
3649 dev_err(&adapter->pdev->dev,
3650 "Adapter busy for FW reset.\n"
3651 "New FW will not be active.\n");
3652 goto lancer_fw_exit;
3653 }
3654 } else if (change_status != LANCER_NO_RESET_NEEDED) {
3655 dev_err(&adapter->pdev->dev,
3656 "System reboot required for new FW"
3657 " to be active\n");
3658 }
3659
3660 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
3661 lancer_fw_exit:
3662 return status;
3663 }
3664
3665 #define UFI_TYPE2 2
3666 #define UFI_TYPE3 3
3667 #define UFI_TYPE3R 10
3668 #define UFI_TYPE4 4
3669 static int be_get_ufi_type(struct be_adapter *adapter,
3670 struct flash_file_hdr_g3 *fhdr)
3671 {
3672 if (fhdr == NULL)
3673 goto be_get_ufi_exit;
3674
3675 if (skyhawk_chip(adapter) && fhdr->build[0] == '4')
3676 return UFI_TYPE4;
3677 else if (BE3_chip(adapter) && fhdr->build[0] == '3') {
3678 if (fhdr->asic_type_rev == 0x10)
3679 return UFI_TYPE3R;
3680 else
3681 return UFI_TYPE3;
3682 } else if (BE2_chip(adapter) && fhdr->build[0] == '2')
3683 return UFI_TYPE2;
3684
3685 be_get_ufi_exit:
3686 dev_err(&adapter->pdev->dev,
3687 "UFI and Interface are not compatible for flashing\n");
3688 return -1;
3689 }
3690
3691 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
3692 {
3693 struct flash_file_hdr_g3 *fhdr3;
3694 struct image_hdr *img_hdr_ptr = NULL;
3695 struct be_dma_mem flash_cmd;
3696 const u8 *p;
3697 int status = 0, i = 0, num_imgs = 0, ufi_type = 0;
3698
3699 flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
3700 flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
3701 &flash_cmd.dma, GFP_KERNEL);
3702 if (!flash_cmd.va) {
3703 status = -ENOMEM;
3704 goto be_fw_exit;
3705 }
3706
3707 p = fw->data;
3708 fhdr3 = (struct flash_file_hdr_g3 *)p;
3709
3710 ufi_type = be_get_ufi_type(adapter, fhdr3);
3711
3712 num_imgs = le32_to_cpu(fhdr3->num_imgs);
3713 for (i = 0; i < num_imgs; i++) {
3714 img_hdr_ptr = (struct image_hdr *)(fw->data +
3715 (sizeof(struct flash_file_hdr_g3) +
3716 i * sizeof(struct image_hdr)));
3717 if (le32_to_cpu(img_hdr_ptr->imageid) == 1) {
3718 switch (ufi_type) {
3719 case UFI_TYPE4:
3720 status = be_flash_skyhawk(adapter, fw,
3721 &flash_cmd, num_imgs);
3722 break;
3723 case UFI_TYPE3R:
3724 status = be_flash_BEx(adapter, fw, &flash_cmd,
3725 num_imgs);
3726 break;
3727 case UFI_TYPE3:
3728 /* Do not flash this ufi on BE3-R cards */
3729 if (adapter->asic_rev < 0x10)
3730 status = be_flash_BEx(adapter, fw,
3731 &flash_cmd,
3732 num_imgs);
3733 else {
3734 status = -1;
3735 dev_err(&adapter->pdev->dev,
3736 "Can't load BE3 UFI on BE3R\n");
3737 }
3738 }
3739 }
3740 }
3741
3742 if (ufi_type == UFI_TYPE2)
3743 status = be_flash_BEx(adapter, fw, &flash_cmd, 0);
3744 else if (ufi_type == -1)
3745 status = -1;
3746
3747 dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
3748 flash_cmd.dma);
3749 if (status) {
3750 dev_err(&adapter->pdev->dev, "Firmware load error\n");
3751 goto be_fw_exit;
3752 }
3753
3754 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
3755
3756 be_fw_exit:
3757 return status;
3758 }
3759
3760 int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
3761 {
3762 const struct firmware *fw;
3763 int status;
3764
3765 if (!netif_running(adapter->netdev)) {
3766 dev_err(&adapter->pdev->dev,
3767 "Firmware load not allowed (interface is down)\n");
3768 return -1;
3769 }
3770
3771 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
3772 if (status)
3773 goto fw_exit;
3774
3775 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
3776
3777 if (lancer_chip(adapter))
3778 status = lancer_fw_download(adapter, fw);
3779 else
3780 status = be_fw_download(adapter, fw);
3781
3782 fw_exit:
3783 release_firmware(fw);
3784 return status;
3785 }
3786
3787 static const struct net_device_ops be_netdev_ops = {
3788 .ndo_open = be_open,
3789 .ndo_stop = be_close,
3790 .ndo_start_xmit = be_xmit,
3791 .ndo_set_rx_mode = be_set_rx_mode,
3792 .ndo_set_mac_address = be_mac_addr_set,
3793 .ndo_change_mtu = be_change_mtu,
3794 .ndo_get_stats64 = be_get_stats64,
3795 .ndo_validate_addr = eth_validate_addr,
3796 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
3797 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
3798 .ndo_set_vf_mac = be_set_vf_mac,
3799 .ndo_set_vf_vlan = be_set_vf_vlan,
3800 .ndo_set_vf_tx_rate = be_set_vf_tx_rate,
3801 .ndo_get_vf_config = be_get_vf_config,
3802 #ifdef CONFIG_NET_POLL_CONTROLLER
3803 .ndo_poll_controller = be_netpoll,
3804 #endif
3805 };
3806
3807 static void be_netdev_init(struct net_device *netdev)
3808 {
3809 struct be_adapter *adapter = netdev_priv(netdev);
3810 struct be_eq_obj *eqo;
3811 int i;
3812
3813 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3814 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
3815 NETIF_F_HW_VLAN_CTAG_TX;
3816 if (be_multi_rxq(adapter))
3817 netdev->hw_features |= NETIF_F_RXHASH;
3818
3819 netdev->features |= netdev->hw_features |
3820 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
3821
3822 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
3823 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
3824
3825 netdev->priv_flags |= IFF_UNICAST_FLT;
3826
3827 netdev->flags |= IFF_MULTICAST;
3828
3829 netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
3830
3831 netdev->netdev_ops = &be_netdev_ops;
3832
3833 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
3834
3835 for_all_evt_queues(adapter, eqo, i)
3836 netif_napi_add(netdev, &eqo->napi, be_poll, BE_NAPI_WEIGHT);
3837 }
3838
3839 static void be_unmap_pci_bars(struct be_adapter *adapter)
3840 {
3841 if (adapter->csr)
3842 pci_iounmap(adapter->pdev, adapter->csr);
3843 if (adapter->db)
3844 pci_iounmap(adapter->pdev, adapter->db);
3845 }
3846
3847 static int db_bar(struct be_adapter *adapter)
3848 {
3849 if (lancer_chip(adapter) || !be_physfn(adapter))
3850 return 0;
3851 else
3852 return 4;
3853 }
3854
3855 static int be_roce_map_pci_bars(struct be_adapter *adapter)
3856 {
3857 if (skyhawk_chip(adapter)) {
3858 adapter->roce_db.size = 4096;
3859 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
3860 db_bar(adapter));
3861 adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
3862 db_bar(adapter));
3863 }
3864 return 0;
3865 }
3866
3867 static int be_map_pci_bars(struct be_adapter *adapter)
3868 {
3869 u8 __iomem *addr;
3870 u32 sli_intf;
3871
3872 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
3873 adapter->if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
3874 SLI_INTF_IF_TYPE_SHIFT;
3875
3876 if (BEx_chip(adapter) && be_physfn(adapter)) {
3877 adapter->csr = pci_iomap(adapter->pdev, 2, 0);
3878 if (adapter->csr == NULL)
3879 return -ENOMEM;
3880 }
3881
3882 addr = pci_iomap(adapter->pdev, db_bar(adapter), 0);
3883 if (addr == NULL)
3884 goto pci_map_err;
3885 adapter->db = addr;
3886
3887 be_roce_map_pci_bars(adapter);
3888 return 0;
3889
3890 pci_map_err:
3891 be_unmap_pci_bars(adapter);
3892 return -ENOMEM;
3893 }
3894
3895 static void be_ctrl_cleanup(struct be_adapter *adapter)
3896 {
3897 struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
3898
3899 be_unmap_pci_bars(adapter);
3900
3901 if (mem->va)
3902 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
3903 mem->dma);
3904
3905 mem = &adapter->rx_filter;
3906 if (mem->va)
3907 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
3908 mem->dma);
3909 }
3910
3911 static int be_ctrl_init(struct be_adapter *adapter)
3912 {
3913 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
3914 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
3915 struct be_dma_mem *rx_filter = &adapter->rx_filter;
3916 u32 sli_intf;
3917 int status;
3918
3919 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
3920 adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
3921 SLI_INTF_FAMILY_SHIFT;
3922 adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
3923
3924 status = be_map_pci_bars(adapter);
3925 if (status)
3926 goto done;
3927
3928 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
3929 mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
3930 mbox_mem_alloc->size,
3931 &mbox_mem_alloc->dma,
3932 GFP_KERNEL);
3933 if (!mbox_mem_alloc->va) {
3934 status = -ENOMEM;
3935 goto unmap_pci_bars;
3936 }
3937 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
3938 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
3939 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
3940 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
3941
3942 rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
3943 rx_filter->va = dma_alloc_coherent(&adapter->pdev->dev, rx_filter->size,
3944 &rx_filter->dma,
3945 GFP_KERNEL | __GFP_ZERO);
3946 if (rx_filter->va == NULL) {
3947 status = -ENOMEM;
3948 goto free_mbox;
3949 }
3950
3951 mutex_init(&adapter->mbox_lock);
3952 spin_lock_init(&adapter->mcc_lock);
3953 spin_lock_init(&adapter->mcc_cq_lock);
3954
3955 init_completion(&adapter->flash_compl);
3956 pci_save_state(adapter->pdev);
3957 return 0;
3958
3959 free_mbox:
3960 dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
3961 mbox_mem_alloc->va, mbox_mem_alloc->dma);
3962
3963 unmap_pci_bars:
3964 be_unmap_pci_bars(adapter);
3965
3966 done:
3967 return status;
3968 }
3969
3970 static void be_stats_cleanup(struct be_adapter *adapter)
3971 {
3972 struct be_dma_mem *cmd = &adapter->stats_cmd;
3973
3974 if (cmd->va)
3975 dma_free_coherent(&adapter->pdev->dev, cmd->size,
3976 cmd->va, cmd->dma);
3977 }
3978
3979 static int be_stats_init(struct be_adapter *adapter)
3980 {
3981 struct be_dma_mem *cmd = &adapter->stats_cmd;
3982
3983 if (lancer_chip(adapter))
3984 cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
3985 else if (BE2_chip(adapter))
3986 cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
3987 else
3988 /* BE3 and Skyhawk */
3989 cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
3990
3991 cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
3992 GFP_KERNEL | __GFP_ZERO);
3993 if (cmd->va == NULL)
3994 return -1;
3995 return 0;
3996 }
3997
3998 static void be_remove(struct pci_dev *pdev)
3999 {
4000 struct be_adapter *adapter = pci_get_drvdata(pdev);
4001
4002 if (!adapter)
4003 return;
4004
4005 be_roce_dev_remove(adapter);
4006 be_intr_set(adapter, false);
4007
4008 cancel_delayed_work_sync(&adapter->func_recovery_work);
4009
4010 unregister_netdev(adapter->netdev);
4011
4012 be_clear(adapter);
4013
4014 /* tell fw we're done with firing cmds */
4015 be_cmd_fw_clean(adapter);
4016
4017 be_stats_cleanup(adapter);
4018
4019 be_ctrl_cleanup(adapter);
4020
4021 pci_disable_pcie_error_reporting(pdev);
4022
4023 pci_set_drvdata(pdev, NULL);
4024 pci_release_regions(pdev);
4025 pci_disable_device(pdev);
4026
4027 free_netdev(adapter->netdev);
4028 }
4029
4030 bool be_is_wol_supported(struct be_adapter *adapter)
4031 {
4032 return ((adapter->wol_cap & BE_WOL_CAP) &&
4033 !be_is_wol_excluded(adapter)) ? true : false;
4034 }
4035
4036 u32 be_get_fw_log_level(struct be_adapter *adapter)
4037 {
4038 struct be_dma_mem extfat_cmd;
4039 struct be_fat_conf_params *cfgs;
4040 int status;
4041 u32 level = 0;
4042 int j;
4043
4044 if (lancer_chip(adapter))
4045 return 0;
4046
4047 memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
4048 extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
4049 extfat_cmd.va = pci_alloc_consistent(adapter->pdev, extfat_cmd.size,
4050 &extfat_cmd.dma);
4051
4052 if (!extfat_cmd.va) {
4053 dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
4054 __func__);
4055 goto err;
4056 }
4057
4058 status = be_cmd_get_ext_fat_capabilites(adapter, &extfat_cmd);
4059 if (!status) {
4060 cfgs = (struct be_fat_conf_params *)(extfat_cmd.va +
4061 sizeof(struct be_cmd_resp_hdr));
4062 for (j = 0; j < le32_to_cpu(cfgs->module[0].num_modes); j++) {
4063 if (cfgs->module[0].trace_lvl[j].mode == MODE_UART)
4064 level = cfgs->module[0].trace_lvl[j].dbg_lvl;
4065 }
4066 }
4067 pci_free_consistent(adapter->pdev, extfat_cmd.size, extfat_cmd.va,
4068 extfat_cmd.dma);
4069 err:
4070 return level;
4071 }
4072
4073 static int be_get_initial_config(struct be_adapter *adapter)
4074 {
4075 int status;
4076 u32 level;
4077
4078 status = be_cmd_get_cntl_attributes(adapter);
4079 if (status)
4080 return status;
4081
4082 status = be_cmd_get_acpi_wol_cap(adapter);
4083 if (status) {
4084 /* in case of a failure to get wol capabillities
4085 * check the exclusion list to determine WOL capability */
4086 if (!be_is_wol_excluded(adapter))
4087 adapter->wol_cap |= BE_WOL_CAP;
4088 }
4089
4090 if (be_is_wol_supported(adapter))
4091 adapter->wol = true;
4092
4093 /* Must be a power of 2 or else MODULO will BUG_ON */
4094 adapter->be_get_temp_freq = 64;
4095
4096 level = be_get_fw_log_level(adapter);
4097 adapter->msg_enable = level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
4098
4099 return 0;
4100 }
4101
4102 static int lancer_recover_func(struct be_adapter *adapter)
4103 {
4104 int status;
4105
4106 status = lancer_test_and_set_rdy_state(adapter);
4107 if (status)
4108 goto err;
4109
4110 if (netif_running(adapter->netdev))
4111 be_close(adapter->netdev);
4112
4113 be_clear(adapter);
4114
4115 adapter->hw_error = false;
4116 adapter->fw_timeout = false;
4117
4118 status = be_setup(adapter);
4119 if (status)
4120 goto err;
4121
4122 if (netif_running(adapter->netdev)) {
4123 status = be_open(adapter->netdev);
4124 if (status)
4125 goto err;
4126 }
4127
4128 dev_err(&adapter->pdev->dev,
4129 "Adapter SLIPORT recovery succeeded\n");
4130 return 0;
4131 err:
4132 if (adapter->eeh_error)
4133 dev_err(&adapter->pdev->dev,
4134 "Adapter SLIPORT recovery failed\n");
4135
4136 return status;
4137 }
4138
4139 static void be_func_recovery_task(struct work_struct *work)
4140 {
4141 struct be_adapter *adapter =
4142 container_of(work, struct be_adapter, func_recovery_work.work);
4143 int status;
4144
4145 be_detect_error(adapter);
4146
4147 if (adapter->hw_error && lancer_chip(adapter)) {
4148
4149 if (adapter->eeh_error)
4150 goto out;
4151
4152 rtnl_lock();
4153 netif_device_detach(adapter->netdev);
4154 rtnl_unlock();
4155
4156 status = lancer_recover_func(adapter);
4157
4158 if (!status)
4159 netif_device_attach(adapter->netdev);
4160 }
4161
4162 out:
4163 schedule_delayed_work(&adapter->func_recovery_work,
4164 msecs_to_jiffies(1000));
4165 }
4166
4167 static void be_worker(struct work_struct *work)
4168 {
4169 struct be_adapter *adapter =
4170 container_of(work, struct be_adapter, work.work);
4171 struct be_rx_obj *rxo;
4172 struct be_eq_obj *eqo;
4173 int i;
4174
4175 /* when interrupts are not yet enabled, just reap any pending
4176 * mcc completions */
4177 if (!netif_running(adapter->netdev)) {
4178 local_bh_disable();
4179 be_process_mcc(adapter);
4180 local_bh_enable();
4181 goto reschedule;
4182 }
4183
4184 if (!adapter->stats_cmd_sent) {
4185 if (lancer_chip(adapter))
4186 lancer_cmd_get_pport_stats(adapter,
4187 &adapter->stats_cmd);
4188 else
4189 be_cmd_get_stats(adapter, &adapter->stats_cmd);
4190 }
4191
4192 if (MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
4193 be_cmd_get_die_temperature(adapter);
4194
4195 for_all_rx_queues(adapter, rxo, i) {
4196 if (rxo->rx_post_starved) {
4197 rxo->rx_post_starved = false;
4198 be_post_rx_frags(rxo, GFP_KERNEL);
4199 }
4200 }
4201
4202 for_all_evt_queues(adapter, eqo, i)
4203 be_eqd_update(adapter, eqo);
4204
4205 reschedule:
4206 adapter->work_counter++;
4207 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
4208 }
4209
4210 static bool be_reset_required(struct be_adapter *adapter)
4211 {
4212 return be_find_vfs(adapter, ENABLED) > 0 ? false : true;
4213 }
4214
4215 static char *mc_name(struct be_adapter *adapter)
4216 {
4217 if (adapter->function_mode & FLEX10_MODE)
4218 return "FLEX10";
4219 else if (adapter->function_mode & VNIC_MODE)
4220 return "vNIC";
4221 else if (adapter->function_mode & UMC_ENABLED)
4222 return "UMC";
4223 else
4224 return "";
4225 }
4226
4227 static inline char *func_name(struct be_adapter *adapter)
4228 {
4229 return be_physfn(adapter) ? "PF" : "VF";
4230 }
4231
4232 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
4233 {
4234 int status = 0;
4235 struct be_adapter *adapter;
4236 struct net_device *netdev;
4237 char port_name;
4238
4239 status = pci_enable_device(pdev);
4240 if (status)
4241 goto do_none;
4242
4243 status = pci_request_regions(pdev, DRV_NAME);
4244 if (status)
4245 goto disable_dev;
4246 pci_set_master(pdev);
4247
4248 netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
4249 if (netdev == NULL) {
4250 status = -ENOMEM;
4251 goto rel_reg;
4252 }
4253 adapter = netdev_priv(netdev);
4254 adapter->pdev = pdev;
4255 pci_set_drvdata(pdev, adapter);
4256 adapter->netdev = netdev;
4257 SET_NETDEV_DEV(netdev, &pdev->dev);
4258
4259 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
4260 if (!status) {
4261 status = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
4262 if (status < 0) {
4263 dev_err(&pdev->dev, "dma_set_coherent_mask failed\n");
4264 goto free_netdev;
4265 }
4266 netdev->features |= NETIF_F_HIGHDMA;
4267 } else {
4268 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
4269 if (status) {
4270 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
4271 goto free_netdev;
4272 }
4273 }
4274
4275 status = pci_enable_pcie_error_reporting(pdev);
4276 if (status)
4277 dev_err(&pdev->dev, "Could not use PCIe error reporting\n");
4278
4279 status = be_ctrl_init(adapter);
4280 if (status)
4281 goto free_netdev;
4282
4283 /* sync up with fw's ready state */
4284 if (be_physfn(adapter)) {
4285 status = be_fw_wait_ready(adapter);
4286 if (status)
4287 goto ctrl_clean;
4288 }
4289
4290 if (be_reset_required(adapter)) {
4291 status = be_cmd_reset_function(adapter);
4292 if (status)
4293 goto ctrl_clean;
4294
4295 /* Wait for interrupts to quiesce after an FLR */
4296 msleep(100);
4297 }
4298
4299 /* Allow interrupts for other ULPs running on NIC function */
4300 be_intr_set(adapter, true);
4301
4302 /* tell fw we're ready to fire cmds */
4303 status = be_cmd_fw_init(adapter);
4304 if (status)
4305 goto ctrl_clean;
4306
4307 status = be_stats_init(adapter);
4308 if (status)
4309 goto ctrl_clean;
4310
4311 status = be_get_initial_config(adapter);
4312 if (status)
4313 goto stats_clean;
4314
4315 INIT_DELAYED_WORK(&adapter->work, be_worker);
4316 INIT_DELAYED_WORK(&adapter->func_recovery_work, be_func_recovery_task);
4317 adapter->rx_fc = adapter->tx_fc = true;
4318
4319 status = be_setup(adapter);
4320 if (status)
4321 goto stats_clean;
4322
4323 be_netdev_init(netdev);
4324 status = register_netdev(netdev);
4325 if (status != 0)
4326 goto unsetup;
4327
4328 be_roce_dev_add(adapter);
4329
4330 schedule_delayed_work(&adapter->func_recovery_work,
4331 msecs_to_jiffies(1000));
4332
4333 be_cmd_query_port_name(adapter, &port_name);
4334
4335 dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
4336 func_name(adapter), mc_name(adapter), port_name);
4337
4338 return 0;
4339
4340 unsetup:
4341 be_clear(adapter);
4342 stats_clean:
4343 be_stats_cleanup(adapter);
4344 ctrl_clean:
4345 be_ctrl_cleanup(adapter);
4346 free_netdev:
4347 free_netdev(netdev);
4348 pci_set_drvdata(pdev, NULL);
4349 rel_reg:
4350 pci_release_regions(pdev);
4351 disable_dev:
4352 pci_disable_device(pdev);
4353 do_none:
4354 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
4355 return status;
4356 }
4357
4358 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
4359 {
4360 struct be_adapter *adapter = pci_get_drvdata(pdev);
4361 struct net_device *netdev = adapter->netdev;
4362
4363 if (adapter->wol)
4364 be_setup_wol(adapter, true);
4365
4366 cancel_delayed_work_sync(&adapter->func_recovery_work);
4367
4368 netif_device_detach(netdev);
4369 if (netif_running(netdev)) {
4370 rtnl_lock();
4371 be_close(netdev);
4372 rtnl_unlock();
4373 }
4374 be_clear(adapter);
4375
4376 pci_save_state(pdev);
4377 pci_disable_device(pdev);
4378 pci_set_power_state(pdev, pci_choose_state(pdev, state));
4379 return 0;
4380 }
4381
4382 static int be_resume(struct pci_dev *pdev)
4383 {
4384 int status = 0;
4385 struct be_adapter *adapter = pci_get_drvdata(pdev);
4386 struct net_device *netdev = adapter->netdev;
4387
4388 netif_device_detach(netdev);
4389
4390 status = pci_enable_device(pdev);
4391 if (status)
4392 return status;
4393
4394 pci_set_power_state(pdev, 0);
4395 pci_restore_state(pdev);
4396
4397 /* tell fw we're ready to fire cmds */
4398 status = be_cmd_fw_init(adapter);
4399 if (status)
4400 return status;
4401
4402 be_setup(adapter);
4403 if (netif_running(netdev)) {
4404 rtnl_lock();
4405 be_open(netdev);
4406 rtnl_unlock();
4407 }
4408
4409 schedule_delayed_work(&adapter->func_recovery_work,
4410 msecs_to_jiffies(1000));
4411 netif_device_attach(netdev);
4412
4413 if (adapter->wol)
4414 be_setup_wol(adapter, false);
4415
4416 return 0;
4417 }
4418
4419 /*
4420 * An FLR will stop BE from DMAing any data.
4421 */
4422 static void be_shutdown(struct pci_dev *pdev)
4423 {
4424 struct be_adapter *adapter = pci_get_drvdata(pdev);
4425
4426 if (!adapter)
4427 return;
4428
4429 cancel_delayed_work_sync(&adapter->work);
4430 cancel_delayed_work_sync(&adapter->func_recovery_work);
4431
4432 netif_device_detach(adapter->netdev);
4433
4434 be_cmd_reset_function(adapter);
4435
4436 pci_disable_device(pdev);
4437 }
4438
4439 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
4440 pci_channel_state_t state)
4441 {
4442 struct be_adapter *adapter = pci_get_drvdata(pdev);
4443 struct net_device *netdev = adapter->netdev;
4444
4445 dev_err(&adapter->pdev->dev, "EEH error detected\n");
4446
4447 adapter->eeh_error = true;
4448
4449 cancel_delayed_work_sync(&adapter->func_recovery_work);
4450
4451 rtnl_lock();
4452 netif_device_detach(netdev);
4453 rtnl_unlock();
4454
4455 if (netif_running(netdev)) {
4456 rtnl_lock();
4457 be_close(netdev);
4458 rtnl_unlock();
4459 }
4460 be_clear(adapter);
4461
4462 if (state == pci_channel_io_perm_failure)
4463 return PCI_ERS_RESULT_DISCONNECT;
4464
4465 pci_disable_device(pdev);
4466
4467 /* The error could cause the FW to trigger a flash debug dump.
4468 * Resetting the card while flash dump is in progress
4469 * can cause it not to recover; wait for it to finish.
4470 * Wait only for first function as it is needed only once per
4471 * adapter.
4472 */
4473 if (pdev->devfn == 0)
4474 ssleep(30);
4475
4476 return PCI_ERS_RESULT_NEED_RESET;
4477 }
4478
4479 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
4480 {
4481 struct be_adapter *adapter = pci_get_drvdata(pdev);
4482 int status;
4483
4484 dev_info(&adapter->pdev->dev, "EEH reset\n");
4485 be_clear_all_error(adapter);
4486
4487 status = pci_enable_device(pdev);
4488 if (status)
4489 return PCI_ERS_RESULT_DISCONNECT;
4490
4491 pci_set_master(pdev);
4492 pci_set_power_state(pdev, 0);
4493 pci_restore_state(pdev);
4494
4495 /* Check if card is ok and fw is ready */
4496 dev_info(&adapter->pdev->dev,
4497 "Waiting for FW to be ready after EEH reset\n");
4498 status = be_fw_wait_ready(adapter);
4499 if (status)
4500 return PCI_ERS_RESULT_DISCONNECT;
4501
4502 pci_cleanup_aer_uncorrect_error_status(pdev);
4503 return PCI_ERS_RESULT_RECOVERED;
4504 }
4505
4506 static void be_eeh_resume(struct pci_dev *pdev)
4507 {
4508 int status = 0;
4509 struct be_adapter *adapter = pci_get_drvdata(pdev);
4510 struct net_device *netdev = adapter->netdev;
4511
4512 dev_info(&adapter->pdev->dev, "EEH resume\n");
4513
4514 pci_save_state(pdev);
4515
4516 status = be_cmd_reset_function(adapter);
4517 if (status)
4518 goto err;
4519
4520 /* tell fw we're ready to fire cmds */
4521 status = be_cmd_fw_init(adapter);
4522 if (status)
4523 goto err;
4524
4525 status = be_setup(adapter);
4526 if (status)
4527 goto err;
4528
4529 if (netif_running(netdev)) {
4530 status = be_open(netdev);
4531 if (status)
4532 goto err;
4533 }
4534
4535 schedule_delayed_work(&adapter->func_recovery_work,
4536 msecs_to_jiffies(1000));
4537 netif_device_attach(netdev);
4538 return;
4539 err:
4540 dev_err(&adapter->pdev->dev, "EEH resume failed\n");
4541 }
4542
4543 static const struct pci_error_handlers be_eeh_handlers = {
4544 .error_detected = be_eeh_err_detected,
4545 .slot_reset = be_eeh_reset,
4546 .resume = be_eeh_resume,
4547 };
4548
4549 static struct pci_driver be_driver = {
4550 .name = DRV_NAME,
4551 .id_table = be_dev_ids,
4552 .probe = be_probe,
4553 .remove = be_remove,
4554 .suspend = be_suspend,
4555 .resume = be_resume,
4556 .shutdown = be_shutdown,
4557 .err_handler = &be_eeh_handlers
4558 };
4559
4560 static int __init be_init_module(void)
4561 {
4562 if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
4563 rx_frag_size != 2048) {
4564 printk(KERN_WARNING DRV_NAME
4565 " : Module param rx_frag_size must be 2048/4096/8192."
4566 " Using 2048\n");
4567 rx_frag_size = 2048;
4568 }
4569
4570 return pci_register_driver(&be_driver);
4571 }
4572 module_init(be_init_module);
4573
4574 static void __exit be_exit_module(void)
4575 {
4576 pci_unregister_driver(&be_driver);
4577 }
4578 module_exit(be_exit_module);
Linux kernel - Deliverables
This page took 0.134015 seconds and 6 git commands to generate.