]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/net/ethernet/emulex/benet/be_main.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:


b6ad02909d6b3c87b861d4e35c345426bef30a64
[mirror_ubuntu-zesty-kernel.git] / drivers / net / ethernet / emulex / benet / be_main.c
1 /*
2 * Copyright (C) 2005 - 2015 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 #include <linux/if_bridge.h>
25 #include <net/busy_poll.h>
26 #include <net/vxlan.h>
27
28 MODULE_VERSION(DRV_VER);
29 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
30 MODULE_AUTHOR("Emulex Corporation");
31 MODULE_LICENSE("GPL");
32
33 /* num_vfs module param is obsolete.
34 * Use sysfs method to enable/disable VFs.
35 */
36 static unsigned int num_vfs;
37 module_param(num_vfs, uint, S_IRUGO);
38 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
39
40 static ushort rx_frag_size = 2048;
41 module_param(rx_frag_size, ushort, S_IRUGO);
42 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
43
44 static const struct pci_device_id be_dev_ids[] = {
45 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
46 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
47 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
48 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
49 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
50 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID4)},
51 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID5)},
52 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID6)},
53 { 0 }
54 };
55 MODULE_DEVICE_TABLE(pci, be_dev_ids);
56 /* UE Status Low CSR */
57 static const char * const ue_status_low_desc[] = {
58 "CEV",
59 "CTX",
60 "DBUF",
61 "ERX",
62 "Host",
63 "MPU",
64 "NDMA",
65 "PTC ",
66 "RDMA ",
67 "RXF ",
68 "RXIPS ",
69 "RXULP0 ",
70 "RXULP1 ",
71 "RXULP2 ",
72 "TIM ",
73 "TPOST ",
74 "TPRE ",
75 "TXIPS ",
76 "TXULP0 ",
77 "TXULP1 ",
78 "UC ",
79 "WDMA ",
80 "TXULP2 ",
81 "HOST1 ",
82 "P0_OB_LINK ",
83 "P1_OB_LINK ",
84 "HOST_GPIO ",
85 "MBOX ",
86 "ERX2 ",
87 "SPARE ",
88 "JTAG ",
89 "MPU_INTPEND "
90 };
91
92 /* UE Status High CSR */
93 static const char * const ue_status_hi_desc[] = {
94 "LPCMEMHOST",
95 "MGMT_MAC",
96 "PCS0ONLINE",
97 "MPU_IRAM",
98 "PCS1ONLINE",
99 "PCTL0",
100 "PCTL1",
101 "PMEM",
102 "RR",
103 "TXPB",
104 "RXPP",
105 "XAUI",
106 "TXP",
107 "ARM",
108 "IPC",
109 "HOST2",
110 "HOST3",
111 "HOST4",
112 "HOST5",
113 "HOST6",
114 "HOST7",
115 "ECRC",
116 "Poison TLP",
117 "NETC",
118 "PERIPH",
119 "LLTXULP",
120 "D2P",
121 "RCON",
122 "LDMA",
123 "LLTXP",
124 "LLTXPB",
125 "Unknown"
126 };
127
128 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
129 {
130 struct be_dma_mem *mem = &q->dma_mem;
131
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_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
149 GFP_KERNEL);
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 (be_check_error(adapter, BE_ERROR_EEH))
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
194 if (be_check_error(adapter, BE_ERROR_HW))
195 return;
196
197 val |= qid & DB_RQ_RING_ID_MASK;
198 val |= posted << DB_RQ_NUM_POSTED_SHIFT;
199
200 wmb();
201 iowrite32(val, adapter->db + DB_RQ_OFFSET);
202 }
203
204 static void be_txq_notify(struct be_adapter *adapter, struct be_tx_obj *txo,
205 u16 posted)
206 {
207 u32 val = 0;
208
209 if (be_check_error(adapter, BE_ERROR_HW))
210 return;
211
212 val |= txo->q.id & DB_TXULP_RING_ID_MASK;
213 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
214
215 wmb();
216 iowrite32(val, adapter->db + txo->db_offset);
217 }
218
219 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
220 bool arm, bool clear_int, u16 num_popped,
221 u32 eq_delay_mult_enc)
222 {
223 u32 val = 0;
224
225 val |= qid & DB_EQ_RING_ID_MASK;
226 val |= ((qid & DB_EQ_RING_ID_EXT_MASK) << DB_EQ_RING_ID_EXT_MASK_SHIFT);
227
228 if (be_check_error(adapter, BE_ERROR_HW))
229 return;
230
231 if (arm)
232 val |= 1 << DB_EQ_REARM_SHIFT;
233 if (clear_int)
234 val |= 1 << DB_EQ_CLR_SHIFT;
235 val |= 1 << DB_EQ_EVNT_SHIFT;
236 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
237 val |= eq_delay_mult_enc << DB_EQ_R2I_DLY_SHIFT;
238 iowrite32(val, adapter->db + DB_EQ_OFFSET);
239 }
240
241 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
242 {
243 u32 val = 0;
244
245 val |= qid & DB_CQ_RING_ID_MASK;
246 val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
247 DB_CQ_RING_ID_EXT_MASK_SHIFT);
248
249 if (be_check_error(adapter, BE_ERROR_HW))
250 return;
251
252 if (arm)
253 val |= 1 << DB_CQ_REARM_SHIFT;
254 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
255 iowrite32(val, adapter->db + DB_CQ_OFFSET);
256 }
257
258 static int be_mac_addr_set(struct net_device *netdev, void *p)
259 {
260 struct be_adapter *adapter = netdev_priv(netdev);
261 struct device *dev = &adapter->pdev->dev;
262 struct sockaddr *addr = p;
263 int status;
264 u8 mac[ETH_ALEN];
265 u32 old_pmac_id = adapter->pmac_id[0], curr_pmac_id = 0;
266
267 if (!is_valid_ether_addr(addr->sa_data))
268 return -EADDRNOTAVAIL;
269
270 /* Proceed further only if, User provided MAC is different
271 * from active MAC
272 */
273 if (ether_addr_equal(addr->sa_data, netdev->dev_addr))
274 return 0;
275
276 /* if device is not running, copy MAC to netdev->dev_addr */
277 if (!netif_running(netdev))
278 goto done;
279
280 /* The PMAC_ADD cmd may fail if the VF doesn't have FILTMGMT
281 * privilege or if PF did not provision the new MAC address.
282 * On BE3, this cmd will always fail if the VF doesn't have the
283 * FILTMGMT privilege. This failure is OK, only if the PF programmed
284 * the MAC for the VF.
285 */
286 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
287 adapter->if_handle, &adapter->pmac_id[0], 0);
288 if (!status) {
289 curr_pmac_id = adapter->pmac_id[0];
290
291 /* Delete the old programmed MAC. This call may fail if the
292 * old MAC was already deleted by the PF driver.
293 */
294 if (adapter->pmac_id[0] != old_pmac_id)
295 be_cmd_pmac_del(adapter, adapter->if_handle,
296 old_pmac_id, 0);
297 }
298
299 /* Decide if the new MAC is successfully activated only after
300 * querying the FW
301 */
302 status = be_cmd_get_active_mac(adapter, curr_pmac_id, mac,
303 adapter->if_handle, true, 0);
304 if (status)
305 goto err;
306
307 /* The MAC change did not happen, either due to lack of privilege
308 * or PF didn't pre-provision.
309 */
310 if (!ether_addr_equal(addr->sa_data, mac)) {
311 status = -EPERM;
312 goto err;
313 }
314 done:
315 ether_addr_copy(netdev->dev_addr, addr->sa_data);
316 dev_info(dev, "MAC address changed to %pM\n", addr->sa_data);
317 return 0;
318 err:
319 dev_warn(dev, "MAC address change to %pM failed\n", addr->sa_data);
320 return status;
321 }
322
323 /* BE2 supports only v0 cmd */
324 static void *hw_stats_from_cmd(struct be_adapter *adapter)
325 {
326 if (BE2_chip(adapter)) {
327 struct be_cmd_resp_get_stats_v0 *cmd = adapter->stats_cmd.va;
328
329 return &cmd->hw_stats;
330 } else if (BE3_chip(adapter)) {
331 struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
332
333 return &cmd->hw_stats;
334 } else {
335 struct be_cmd_resp_get_stats_v2 *cmd = adapter->stats_cmd.va;
336
337 return &cmd->hw_stats;
338 }
339 }
340
341 /* BE2 supports only v0 cmd */
342 static void *be_erx_stats_from_cmd(struct be_adapter *adapter)
343 {
344 if (BE2_chip(adapter)) {
345 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
346
347 return &hw_stats->erx;
348 } else if (BE3_chip(adapter)) {
349 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
350
351 return &hw_stats->erx;
352 } else {
353 struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
354
355 return &hw_stats->erx;
356 }
357 }
358
359 static void populate_be_v0_stats(struct be_adapter *adapter)
360 {
361 struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
362 struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
363 struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
364 struct be_port_rxf_stats_v0 *port_stats =
365 &rxf_stats->port[adapter->port_num];
366 struct be_drv_stats *drvs = &adapter->drv_stats;
367
368 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
369 drvs->rx_pause_frames = port_stats->rx_pause_frames;
370 drvs->rx_crc_errors = port_stats->rx_crc_errors;
371 drvs->rx_control_frames = port_stats->rx_control_frames;
372 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
373 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
374 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
375 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
376 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
377 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
378 drvs->rxpp_fifo_overflow_drop = port_stats->rx_fifo_overflow;
379 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
380 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
381 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
382 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
383 drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
384 drvs->rx_dropped_header_too_small =
385 port_stats->rx_dropped_header_too_small;
386 drvs->rx_address_filtered =
387 port_stats->rx_address_filtered +
388 port_stats->rx_vlan_filtered;
389 drvs->rx_alignment_symbol_errors =
390 port_stats->rx_alignment_symbol_errors;
391
392 drvs->tx_pauseframes = port_stats->tx_pauseframes;
393 drvs->tx_controlframes = port_stats->tx_controlframes;
394
395 if (adapter->port_num)
396 drvs->jabber_events = rxf_stats->port1_jabber_events;
397 else
398 drvs->jabber_events = rxf_stats->port0_jabber_events;
399 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
400 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
401 drvs->forwarded_packets = rxf_stats->forwarded_packets;
402 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
403 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
404 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
405 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
406 }
407
408 static void populate_be_v1_stats(struct be_adapter *adapter)
409 {
410 struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
411 struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
412 struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
413 struct be_port_rxf_stats_v1 *port_stats =
414 &rxf_stats->port[adapter->port_num];
415 struct be_drv_stats *drvs = &adapter->drv_stats;
416
417 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
418 drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
419 drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
420 drvs->rx_pause_frames = port_stats->rx_pause_frames;
421 drvs->rx_crc_errors = port_stats->rx_crc_errors;
422 drvs->rx_control_frames = port_stats->rx_control_frames;
423 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
424 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
425 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
426 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
427 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
428 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
429 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
430 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
431 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
432 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
433 drvs->rx_dropped_header_too_small =
434 port_stats->rx_dropped_header_too_small;
435 drvs->rx_input_fifo_overflow_drop =
436 port_stats->rx_input_fifo_overflow_drop;
437 drvs->rx_address_filtered = port_stats->rx_address_filtered;
438 drvs->rx_alignment_symbol_errors =
439 port_stats->rx_alignment_symbol_errors;
440 drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
441 drvs->tx_pauseframes = port_stats->tx_pauseframes;
442 drvs->tx_controlframes = port_stats->tx_controlframes;
443 drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
444 drvs->jabber_events = port_stats->jabber_events;
445 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
446 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
447 drvs->forwarded_packets = rxf_stats->forwarded_packets;
448 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
449 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
450 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
451 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
452 }
453
454 static void populate_be_v2_stats(struct be_adapter *adapter)
455 {
456 struct be_hw_stats_v2 *hw_stats = hw_stats_from_cmd(adapter);
457 struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
458 struct be_rxf_stats_v2 *rxf_stats = &hw_stats->rxf;
459 struct be_port_rxf_stats_v2 *port_stats =
460 &rxf_stats->port[adapter->port_num];
461 struct be_drv_stats *drvs = &adapter->drv_stats;
462
463 be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
464 drvs->pmem_fifo_overflow_drop = port_stats->pmem_fifo_overflow_drop;
465 drvs->rx_priority_pause_frames = port_stats->rx_priority_pause_frames;
466 drvs->rx_pause_frames = port_stats->rx_pause_frames;
467 drvs->rx_crc_errors = port_stats->rx_crc_errors;
468 drvs->rx_control_frames = port_stats->rx_control_frames;
469 drvs->rx_in_range_errors = port_stats->rx_in_range_errors;
470 drvs->rx_frame_too_long = port_stats->rx_frame_too_long;
471 drvs->rx_dropped_runt = port_stats->rx_dropped_runt;
472 drvs->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs;
473 drvs->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs;
474 drvs->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs;
475 drvs->rx_dropped_tcp_length = port_stats->rx_dropped_tcp_length;
476 drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
477 drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
478 drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
479 drvs->rx_dropped_header_too_small =
480 port_stats->rx_dropped_header_too_small;
481 drvs->rx_input_fifo_overflow_drop =
482 port_stats->rx_input_fifo_overflow_drop;
483 drvs->rx_address_filtered = port_stats->rx_address_filtered;
484 drvs->rx_alignment_symbol_errors =
485 port_stats->rx_alignment_symbol_errors;
486 drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
487 drvs->tx_pauseframes = port_stats->tx_pauseframes;
488 drvs->tx_controlframes = port_stats->tx_controlframes;
489 drvs->tx_priority_pauseframes = port_stats->tx_priority_pauseframes;
490 drvs->jabber_events = port_stats->jabber_events;
491 drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
492 drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
493 drvs->forwarded_packets = rxf_stats->forwarded_packets;
494 drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
495 drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
496 drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
497 adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
498 if (be_roce_supported(adapter)) {
499 drvs->rx_roce_bytes_lsd = port_stats->roce_bytes_received_lsd;
500 drvs->rx_roce_bytes_msd = port_stats->roce_bytes_received_msd;
501 drvs->rx_roce_frames = port_stats->roce_frames_received;
502 drvs->roce_drops_crc = port_stats->roce_drops_crc;
503 drvs->roce_drops_payload_len =
504 port_stats->roce_drops_payload_len;
505 }
506 }
507
508 static void populate_lancer_stats(struct be_adapter *adapter)
509 {
510 struct be_drv_stats *drvs = &adapter->drv_stats;
511 struct lancer_pport_stats *pport_stats = pport_stats_from_cmd(adapter);
512
513 be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
514 drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
515 drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
516 drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
517 drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
518 drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
519 drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
520 drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
521 drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
522 drvs->rx_udp_checksum_errs = pport_stats->rx_udp_checksum_errors;
523 drvs->rx_dropped_tcp_length =
524 pport_stats->rx_dropped_invalid_tcp_length;
525 drvs->rx_dropped_too_small = pport_stats->rx_dropped_too_small;
526 drvs->rx_dropped_too_short = pport_stats->rx_dropped_too_short;
527 drvs->rx_out_range_errors = pport_stats->rx_out_of_range_errors;
528 drvs->rx_dropped_header_too_small =
529 pport_stats->rx_dropped_header_too_small;
530 drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
531 drvs->rx_address_filtered =
532 pport_stats->rx_address_filtered +
533 pport_stats->rx_vlan_filtered;
534 drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
535 drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
536 drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
537 drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
538 drvs->jabber_events = pport_stats->rx_jabbers;
539 drvs->forwarded_packets = pport_stats->num_forwards_lo;
540 drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
541 drvs->rx_drops_too_many_frags =
542 pport_stats->rx_drops_too_many_frags_lo;
543 }
544
545 static void accumulate_16bit_val(u32 *acc, u16 val)
546 {
547 #define lo(x) (x & 0xFFFF)
548 #define hi(x) (x & 0xFFFF0000)
549 bool wrapped = val < lo(*acc);
550 u32 newacc = hi(*acc) + val;
551
552 if (wrapped)
553 newacc += 65536;
554 ACCESS_ONCE(*acc) = newacc;
555 }
556
557 static void populate_erx_stats(struct be_adapter *adapter,
558 struct be_rx_obj *rxo, u32 erx_stat)
559 {
560 if (!BEx_chip(adapter))
561 rx_stats(rxo)->rx_drops_no_frags = erx_stat;
562 else
563 /* below erx HW counter can actually wrap around after
564 * 65535. Driver accumulates a 32-bit value
565 */
566 accumulate_16bit_val(&rx_stats(rxo)->rx_drops_no_frags,
567 (u16)erx_stat);
568 }
569
570 void be_parse_stats(struct be_adapter *adapter)
571 {
572 struct be_erx_stats_v2 *erx = be_erx_stats_from_cmd(adapter);
573 struct be_rx_obj *rxo;
574 int i;
575 u32 erx_stat;
576
577 if (lancer_chip(adapter)) {
578 populate_lancer_stats(adapter);
579 } else {
580 if (BE2_chip(adapter))
581 populate_be_v0_stats(adapter);
582 else if (BE3_chip(adapter))
583 /* for BE3 */
584 populate_be_v1_stats(adapter);
585 else
586 populate_be_v2_stats(adapter);
587
588 /* erx_v2 is longer than v0, v1. use v2 for v0, v1 access */
589 for_all_rx_queues(adapter, rxo, i) {
590 erx_stat = erx->rx_drops_no_fragments[rxo->q.id];
591 populate_erx_stats(adapter, rxo, erx_stat);
592 }
593 }
594 }
595
596 static struct rtnl_link_stats64 *be_get_stats64(struct net_device *netdev,
597 struct rtnl_link_stats64 *stats)
598 {
599 struct be_adapter *adapter = netdev_priv(netdev);
600 struct be_drv_stats *drvs = &adapter->drv_stats;
601 struct be_rx_obj *rxo;
602 struct be_tx_obj *txo;
603 u64 pkts, bytes;
604 unsigned int start;
605 int i;
606
607 for_all_rx_queues(adapter, rxo, i) {
608 const struct be_rx_stats *rx_stats = rx_stats(rxo);
609
610 do {
611 start = u64_stats_fetch_begin_irq(&rx_stats->sync);
612 pkts = rx_stats(rxo)->rx_pkts;
613 bytes = rx_stats(rxo)->rx_bytes;
614 } while (u64_stats_fetch_retry_irq(&rx_stats->sync, start));
615 stats->rx_packets += pkts;
616 stats->rx_bytes += bytes;
617 stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
618 stats->rx_dropped += rx_stats(rxo)->rx_drops_no_skbs +
619 rx_stats(rxo)->rx_drops_no_frags;
620 }
621
622 for_all_tx_queues(adapter, txo, i) {
623 const struct be_tx_stats *tx_stats = tx_stats(txo);
624
625 do {
626 start = u64_stats_fetch_begin_irq(&tx_stats->sync);
627 pkts = tx_stats(txo)->tx_pkts;
628 bytes = tx_stats(txo)->tx_bytes;
629 } while (u64_stats_fetch_retry_irq(&tx_stats->sync, start));
630 stats->tx_packets += pkts;
631 stats->tx_bytes += bytes;
632 }
633
634 /* bad pkts received */
635 stats->rx_errors = drvs->rx_crc_errors +
636 drvs->rx_alignment_symbol_errors +
637 drvs->rx_in_range_errors +
638 drvs->rx_out_range_errors +
639 drvs->rx_frame_too_long +
640 drvs->rx_dropped_too_small +
641 drvs->rx_dropped_too_short +
642 drvs->rx_dropped_header_too_small +
643 drvs->rx_dropped_tcp_length +
644 drvs->rx_dropped_runt;
645
646 /* detailed rx errors */
647 stats->rx_length_errors = drvs->rx_in_range_errors +
648 drvs->rx_out_range_errors +
649 drvs->rx_frame_too_long;
650
651 stats->rx_crc_errors = drvs->rx_crc_errors;
652
653 /* frame alignment errors */
654 stats->rx_frame_errors = drvs->rx_alignment_symbol_errors;
655
656 /* receiver fifo overrun */
657 /* drops_no_pbuf is no per i/f, it's per BE card */
658 stats->rx_fifo_errors = drvs->rxpp_fifo_overflow_drop +
659 drvs->rx_input_fifo_overflow_drop +
660 drvs->rx_drops_no_pbuf;
661 return stats;
662 }
663
664 void be_link_status_update(struct be_adapter *adapter, u8 link_status)
665 {
666 struct net_device *netdev = adapter->netdev;
667
668 if (!(adapter->flags & BE_FLAGS_LINK_STATUS_INIT)) {
669 netif_carrier_off(netdev);
670 adapter->flags |= BE_FLAGS_LINK_STATUS_INIT;
671 }
672
673 if (link_status)
674 netif_carrier_on(netdev);
675 else
676 netif_carrier_off(netdev);
677
678 netdev_info(netdev, "Link is %s\n", link_status ? "Up" : "Down");
679 }
680
681 static void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb)
682 {
683 struct be_tx_stats *stats = tx_stats(txo);
684 u64 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1;
685
686 u64_stats_update_begin(&stats->sync);
687 stats->tx_reqs++;
688 stats->tx_bytes += skb->len;
689 stats->tx_pkts += tx_pkts;
690 if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL)
691 stats->tx_vxlan_offload_pkts += tx_pkts;
692 u64_stats_update_end(&stats->sync);
693 }
694
695 /* Returns number of WRBs needed for the skb */
696 static u32 skb_wrb_cnt(struct sk_buff *skb)
697 {
698 /* +1 for the header wrb */
699 return 1 + (skb_headlen(skb) ? 1 : 0) + skb_shinfo(skb)->nr_frags;
700 }
701
702 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
703 {
704 wrb->frag_pa_hi = cpu_to_le32(upper_32_bits(addr));
705 wrb->frag_pa_lo = cpu_to_le32(lower_32_bits(addr));
706 wrb->frag_len = cpu_to_le32(len & ETH_WRB_FRAG_LEN_MASK);
707 wrb->rsvd0 = 0;
708 }
709
710 /* A dummy wrb is just all zeros. Using a separate routine for dummy-wrb
711 * to avoid the swap and shift/mask operations in wrb_fill().
712 */
713 static inline void wrb_fill_dummy(struct be_eth_wrb *wrb)
714 {
715 wrb->frag_pa_hi = 0;
716 wrb->frag_pa_lo = 0;
717 wrb->frag_len = 0;
718 wrb->rsvd0 = 0;
719 }
720
721 static inline u16 be_get_tx_vlan_tag(struct be_adapter *adapter,
722 struct sk_buff *skb)
723 {
724 u8 vlan_prio;
725 u16 vlan_tag;
726
727 vlan_tag = skb_vlan_tag_get(skb);
728 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
729 /* If vlan priority provided by OS is NOT in available bmap */
730 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
731 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
732 adapter->recommended_prio;
733
734 return vlan_tag;
735 }
736
737 /* Used only for IP tunnel packets */
738 static u16 skb_inner_ip_proto(struct sk_buff *skb)
739 {
740 return (inner_ip_hdr(skb)->version == 4) ?
741 inner_ip_hdr(skb)->protocol : inner_ipv6_hdr(skb)->nexthdr;
742 }
743
744 static u16 skb_ip_proto(struct sk_buff *skb)
745 {
746 return (ip_hdr(skb)->version == 4) ?
747 ip_hdr(skb)->protocol : ipv6_hdr(skb)->nexthdr;
748 }
749
750 static inline bool be_is_txq_full(struct be_tx_obj *txo)
751 {
752 return atomic_read(&txo->q.used) + BE_MAX_TX_FRAG_COUNT >= txo->q.len;
753 }
754
755 static inline bool be_can_txq_wake(struct be_tx_obj *txo)
756 {
757 return atomic_read(&txo->q.used) < txo->q.len / 2;
758 }
759
760 static inline bool be_is_tx_compl_pending(struct be_tx_obj *txo)
761 {
762 return atomic_read(&txo->q.used) > txo->pend_wrb_cnt;
763 }
764
765 static void be_get_wrb_params_from_skb(struct be_adapter *adapter,
766 struct sk_buff *skb,
767 struct be_wrb_params *wrb_params)
768 {
769 u16 proto;
770
771 if (skb_is_gso(skb)) {
772 BE_WRB_F_SET(wrb_params->features, LSO, 1);
773 wrb_params->lso_mss = skb_shinfo(skb)->gso_size;
774 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
775 BE_WRB_F_SET(wrb_params->features, LSO6, 1);
776 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
777 if (skb->encapsulation) {
778 BE_WRB_F_SET(wrb_params->features, IPCS, 1);
779 proto = skb_inner_ip_proto(skb);
780 } else {
781 proto = skb_ip_proto(skb);
782 }
783 if (proto == IPPROTO_TCP)
784 BE_WRB_F_SET(wrb_params->features, TCPCS, 1);
785 else if (proto == IPPROTO_UDP)
786 BE_WRB_F_SET(wrb_params->features, UDPCS, 1);
787 }
788
789 if (skb_vlan_tag_present(skb)) {
790 BE_WRB_F_SET(wrb_params->features, VLAN, 1);
791 wrb_params->vlan_tag = be_get_tx_vlan_tag(adapter, skb);
792 }
793
794 BE_WRB_F_SET(wrb_params->features, CRC, 1);
795 }
796
797 static void wrb_fill_hdr(struct be_adapter *adapter,
798 struct be_eth_hdr_wrb *hdr,
799 struct be_wrb_params *wrb_params,
800 struct sk_buff *skb)
801 {
802 memset(hdr, 0, sizeof(*hdr));
803
804 SET_TX_WRB_HDR_BITS(crc, hdr,
805 BE_WRB_F_GET(wrb_params->features, CRC));
806 SET_TX_WRB_HDR_BITS(ipcs, hdr,
807 BE_WRB_F_GET(wrb_params->features, IPCS));
808 SET_TX_WRB_HDR_BITS(tcpcs, hdr,
809 BE_WRB_F_GET(wrb_params->features, TCPCS));
810 SET_TX_WRB_HDR_BITS(udpcs, hdr,
811 BE_WRB_F_GET(wrb_params->features, UDPCS));
812
813 SET_TX_WRB_HDR_BITS(lso, hdr,
814 BE_WRB_F_GET(wrb_params->features, LSO));
815 SET_TX_WRB_HDR_BITS(lso6, hdr,
816 BE_WRB_F_GET(wrb_params->features, LSO6));
817 SET_TX_WRB_HDR_BITS(lso_mss, hdr, wrb_params->lso_mss);
818
819 /* Hack to skip HW VLAN tagging needs evt = 1, compl = 0. When this
820 * hack is not needed, the evt bit is set while ringing DB.
821 */
822 SET_TX_WRB_HDR_BITS(event, hdr,
823 BE_WRB_F_GET(wrb_params->features, VLAN_SKIP_HW));
824 SET_TX_WRB_HDR_BITS(vlan, hdr,
825 BE_WRB_F_GET(wrb_params->features, VLAN));
826 SET_TX_WRB_HDR_BITS(vlan_tag, hdr, wrb_params->vlan_tag);
827
828 SET_TX_WRB_HDR_BITS(num_wrb, hdr, skb_wrb_cnt(skb));
829 SET_TX_WRB_HDR_BITS(len, hdr, skb->len);
830 SET_TX_WRB_HDR_BITS(mgmt, hdr,
831 BE_WRB_F_GET(wrb_params->features, OS2BMC));
832 }
833
834 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
835 bool unmap_single)
836 {
837 dma_addr_t dma;
838 u32 frag_len = le32_to_cpu(wrb->frag_len);
839
840
841 dma = (u64)le32_to_cpu(wrb->frag_pa_hi) << 32 |
842 (u64)le32_to_cpu(wrb->frag_pa_lo);
843 if (frag_len) {
844 if (unmap_single)
845 dma_unmap_single(dev, dma, frag_len, DMA_TO_DEVICE);
846 else
847 dma_unmap_page(dev, dma, frag_len, DMA_TO_DEVICE);
848 }
849 }
850
851 /* Grab a WRB header for xmit */
852 static u16 be_tx_get_wrb_hdr(struct be_tx_obj *txo)
853 {
854 u16 head = txo->q.head;
855
856 queue_head_inc(&txo->q);
857 return head;
858 }
859
860 /* Set up the WRB header for xmit */
861 static void be_tx_setup_wrb_hdr(struct be_adapter *adapter,
862 struct be_tx_obj *txo,
863 struct be_wrb_params *wrb_params,
864 struct sk_buff *skb, u16 head)
865 {
866 u32 num_frags = skb_wrb_cnt(skb);
867 struct be_queue_info *txq = &txo->q;
868 struct be_eth_hdr_wrb *hdr = queue_index_node(txq, head);
869
870 wrb_fill_hdr(adapter, hdr, wrb_params, skb);
871 be_dws_cpu_to_le(hdr, sizeof(*hdr));
872
873 BUG_ON(txo->sent_skb_list[head]);
874 txo->sent_skb_list[head] = skb;
875 txo->last_req_hdr = head;
876 atomic_add(num_frags, &txq->used);
877 txo->last_req_wrb_cnt = num_frags;
878 txo->pend_wrb_cnt += num_frags;
879 }
880
881 /* Setup a WRB fragment (buffer descriptor) for xmit */
882 static void be_tx_setup_wrb_frag(struct be_tx_obj *txo, dma_addr_t busaddr,
883 int len)
884 {
885 struct be_eth_wrb *wrb;
886 struct be_queue_info *txq = &txo->q;
887
888 wrb = queue_head_node(txq);
889 wrb_fill(wrb, busaddr, len);
890 queue_head_inc(txq);
891 }
892
893 /* Bring the queue back to the state it was in before be_xmit_enqueue() routine
894 * was invoked. The producer index is restored to the previous packet and the
895 * WRBs of the current packet are unmapped. Invoked to handle tx setup errors.
896 */
897 static void be_xmit_restore(struct be_adapter *adapter,
898 struct be_tx_obj *txo, u16 head, bool map_single,
899 u32 copied)
900 {
901 struct device *dev;
902 struct be_eth_wrb *wrb;
903 struct be_queue_info *txq = &txo->q;
904
905 dev = &adapter->pdev->dev;
906 txq->head = head;
907
908 /* skip the first wrb (hdr); it's not mapped */
909 queue_head_inc(txq);
910 while (copied) {
911 wrb = queue_head_node(txq);
912 unmap_tx_frag(dev, wrb, map_single);
913 map_single = false;
914 copied -= le32_to_cpu(wrb->frag_len);
915 queue_head_inc(txq);
916 }
917
918 txq->head = head;
919 }
920
921 /* Enqueue the given packet for transmit. This routine allocates WRBs for the
922 * packet, dma maps the packet buffers and sets up the WRBs. Returns the number
923 * of WRBs used up by the packet.
924 */
925 static u32 be_xmit_enqueue(struct be_adapter *adapter, struct be_tx_obj *txo,
926 struct sk_buff *skb,
927 struct be_wrb_params *wrb_params)
928 {
929 u32 i, copied = 0, wrb_cnt = skb_wrb_cnt(skb);
930 struct device *dev = &adapter->pdev->dev;
931 struct be_queue_info *txq = &txo->q;
932 bool map_single = false;
933 u16 head = txq->head;
934 dma_addr_t busaddr;
935 int len;
936
937 head = be_tx_get_wrb_hdr(txo);
938
939 if (skb->len > skb->data_len) {
940 len = skb_headlen(skb);
941
942 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
943 if (dma_mapping_error(dev, busaddr))
944 goto dma_err;
945 map_single = true;
946 be_tx_setup_wrb_frag(txo, busaddr, len);
947 copied += len;
948 }
949
950 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
951 const struct skb_frag_struct *frag = &skb_shinfo(skb)->frags[i];
952 len = skb_frag_size(frag);
953
954 busaddr = skb_frag_dma_map(dev, frag, 0, len, DMA_TO_DEVICE);
955 if (dma_mapping_error(dev, busaddr))
956 goto dma_err;
957 be_tx_setup_wrb_frag(txo, busaddr, len);
958 copied += len;
959 }
960
961 be_tx_setup_wrb_hdr(adapter, txo, wrb_params, skb, head);
962
963 be_tx_stats_update(txo, skb);
964 return wrb_cnt;
965
966 dma_err:
967 adapter->drv_stats.dma_map_errors++;
968 be_xmit_restore(adapter, txo, head, map_single, copied);
969 return 0;
970 }
971
972 static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)
973 {
974 return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;
975 }
976
977 static struct sk_buff *be_insert_vlan_in_pkt(struct be_adapter *adapter,
978 struct sk_buff *skb,
979 struct be_wrb_params
980 *wrb_params)
981 {
982 u16 vlan_tag = 0;
983
984 skb = skb_share_check(skb, GFP_ATOMIC);
985 if (unlikely(!skb))
986 return skb;
987
988 if (skb_vlan_tag_present(skb))
989 vlan_tag = be_get_tx_vlan_tag(adapter, skb);
990
991 if (qnq_async_evt_rcvd(adapter) && adapter->pvid) {
992 if (!vlan_tag)
993 vlan_tag = adapter->pvid;
994 /* f/w workaround to set skip_hw_vlan = 1, informs the F/W to
995 * skip VLAN insertion
996 */
997 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
998 }
999
1000 if (vlan_tag) {
1001 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
1002 vlan_tag);
1003 if (unlikely(!skb))
1004 return skb;
1005 skb->vlan_tci = 0;
1006 }
1007
1008 /* Insert the outer VLAN, if any */
1009 if (adapter->qnq_vid) {
1010 vlan_tag = adapter->qnq_vid;
1011 skb = vlan_insert_tag_set_proto(skb, htons(ETH_P_8021Q),
1012 vlan_tag);
1013 if (unlikely(!skb))
1014 return skb;
1015 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1016 }
1017
1018 return skb;
1019 }
1020
1021 static bool be_ipv6_exthdr_check(struct sk_buff *skb)
1022 {
1023 struct ethhdr *eh = (struct ethhdr *)skb->data;
1024 u16 offset = ETH_HLEN;
1025
1026 if (eh->h_proto == htons(ETH_P_IPV6)) {
1027 struct ipv6hdr *ip6h = (struct ipv6hdr *)(skb->data + offset);
1028
1029 offset += sizeof(struct ipv6hdr);
1030 if (ip6h->nexthdr != NEXTHDR_TCP &&
1031 ip6h->nexthdr != NEXTHDR_UDP) {
1032 struct ipv6_opt_hdr *ehdr =
1033 (struct ipv6_opt_hdr *)(skb->data + offset);
1034
1035 /* offending pkt: 2nd byte following IPv6 hdr is 0xff */
1036 if (ehdr->hdrlen == 0xff)
1037 return true;
1038 }
1039 }
1040 return false;
1041 }
1042
1043 static int be_vlan_tag_tx_chk(struct be_adapter *adapter, struct sk_buff *skb)
1044 {
1045 return skb_vlan_tag_present(skb) || adapter->pvid || adapter->qnq_vid;
1046 }
1047
1048 static int be_ipv6_tx_stall_chk(struct be_adapter *adapter, struct sk_buff *skb)
1049 {
1050 return BE3_chip(adapter) && be_ipv6_exthdr_check(skb);
1051 }
1052
1053 static struct sk_buff *be_lancer_xmit_workarounds(struct be_adapter *adapter,
1054 struct sk_buff *skb,
1055 struct be_wrb_params
1056 *wrb_params)
1057 {
1058 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1059 unsigned int eth_hdr_len;
1060 struct iphdr *ip;
1061
1062 /* For padded packets, BE HW modifies tot_len field in IP header
1063 * incorrecly when VLAN tag is inserted by HW.
1064 * For padded packets, Lancer computes incorrect checksum.
1065 */
1066 eth_hdr_len = ntohs(skb->protocol) == ETH_P_8021Q ?
1067 VLAN_ETH_HLEN : ETH_HLEN;
1068 if (skb->len <= 60 &&
1069 (lancer_chip(adapter) || skb_vlan_tag_present(skb)) &&
1070 is_ipv4_pkt(skb)) {
1071 ip = (struct iphdr *)ip_hdr(skb);
1072 pskb_trim(skb, eth_hdr_len + ntohs(ip->tot_len));
1073 }
1074
1075 /* If vlan tag is already inlined in the packet, skip HW VLAN
1076 * tagging in pvid-tagging mode
1077 */
1078 if (be_pvid_tagging_enabled(adapter) &&
1079 veh->h_vlan_proto == htons(ETH_P_8021Q))
1080 BE_WRB_F_SET(wrb_params->features, VLAN_SKIP_HW, 1);
1081
1082 /* HW has a bug wherein it will calculate CSUM for VLAN
1083 * pkts even though it is disabled.
1084 * Manually insert VLAN in pkt.
1085 */
1086 if (skb->ip_summed != CHECKSUM_PARTIAL &&
1087 skb_vlan_tag_present(skb)) {
1088 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1089 if (unlikely(!skb))
1090 goto err;
1091 }
1092
1093 /* HW may lockup when VLAN HW tagging is requested on
1094 * certain ipv6 packets. Drop such pkts if the HW workaround to
1095 * skip HW tagging is not enabled by FW.
1096 */
1097 if (unlikely(be_ipv6_tx_stall_chk(adapter, skb) &&
1098 (adapter->pvid || adapter->qnq_vid) &&
1099 !qnq_async_evt_rcvd(adapter)))
1100 goto tx_drop;
1101
1102 /* Manual VLAN tag insertion to prevent:
1103 * ASIC lockup when the ASIC inserts VLAN tag into
1104 * certain ipv6 packets. Insert VLAN tags in driver,
1105 * and set event, completion, vlan bits accordingly
1106 * in the Tx WRB.
1107 */
1108 if (be_ipv6_tx_stall_chk(adapter, skb) &&
1109 be_vlan_tag_tx_chk(adapter, skb)) {
1110 skb = be_insert_vlan_in_pkt(adapter, skb, wrb_params);
1111 if (unlikely(!skb))
1112 goto err;
1113 }
1114
1115 return skb;
1116 tx_drop:
1117 dev_kfree_skb_any(skb);
1118 err:
1119 return NULL;
1120 }
1121
1122 static struct sk_buff *be_xmit_workarounds(struct be_adapter *adapter,
1123 struct sk_buff *skb,
1124 struct be_wrb_params *wrb_params)
1125 {
1126 /* Lancer, SH and BE3 in SRIOV mode have a bug wherein
1127 * packets that are 32b or less may cause a transmit stall
1128 * on that port. The workaround is to pad such packets
1129 * (len <= 32 bytes) to a minimum length of 36b.
1130 */
1131 if (skb->len <= 32) {
1132 if (skb_put_padto(skb, 36))
1133 return NULL;
1134 }
1135
1136 if (BEx_chip(adapter) || lancer_chip(adapter)) {
1137 skb = be_lancer_xmit_workarounds(adapter, skb, wrb_params);
1138 if (!skb)
1139 return NULL;
1140 }
1141
1142 return skb;
1143 }
1144
1145 static void be_xmit_flush(struct be_adapter *adapter, struct be_tx_obj *txo)
1146 {
1147 struct be_queue_info *txq = &txo->q;
1148 struct be_eth_hdr_wrb *hdr = queue_index_node(txq, txo->last_req_hdr);
1149
1150 /* Mark the last request eventable if it hasn't been marked already */
1151 if (!(hdr->dw[2] & cpu_to_le32(TX_HDR_WRB_EVT)))
1152 hdr->dw[2] |= cpu_to_le32(TX_HDR_WRB_EVT | TX_HDR_WRB_COMPL);
1153
1154 /* compose a dummy wrb if there are odd set of wrbs to notify */
1155 if (!lancer_chip(adapter) && (txo->pend_wrb_cnt & 1)) {
1156 wrb_fill_dummy(queue_head_node(txq));
1157 queue_head_inc(txq);
1158 atomic_inc(&txq->used);
1159 txo->pend_wrb_cnt++;
1160 hdr->dw[2] &= ~cpu_to_le32(TX_HDR_WRB_NUM_MASK <<
1161 TX_HDR_WRB_NUM_SHIFT);
1162 hdr->dw[2] |= cpu_to_le32((txo->last_req_wrb_cnt + 1) <<
1163 TX_HDR_WRB_NUM_SHIFT);
1164 }
1165 be_txq_notify(adapter, txo, txo->pend_wrb_cnt);
1166 txo->pend_wrb_cnt = 0;
1167 }
1168
1169 /* OS2BMC related */
1170
1171 #define DHCP_CLIENT_PORT 68
1172 #define DHCP_SERVER_PORT 67
1173 #define NET_BIOS_PORT1 137
1174 #define NET_BIOS_PORT2 138
1175 #define DHCPV6_RAS_PORT 547
1176
1177 #define is_mc_allowed_on_bmc(adapter, eh) \
1178 (!is_multicast_filt_enabled(adapter) && \
1179 is_multicast_ether_addr(eh->h_dest) && \
1180 !is_broadcast_ether_addr(eh->h_dest))
1181
1182 #define is_bc_allowed_on_bmc(adapter, eh) \
1183 (!is_broadcast_filt_enabled(adapter) && \
1184 is_broadcast_ether_addr(eh->h_dest))
1185
1186 #define is_arp_allowed_on_bmc(adapter, skb) \
1187 (is_arp(skb) && is_arp_filt_enabled(adapter))
1188
1189 #define is_broadcast_packet(eh, adapter) \
1190 (is_multicast_ether_addr(eh->h_dest) && \
1191 !compare_ether_addr(eh->h_dest, adapter->netdev->broadcast))
1192
1193 #define is_arp(skb) (skb->protocol == htons(ETH_P_ARP))
1194
1195 #define is_arp_filt_enabled(adapter) \
1196 (adapter->bmc_filt_mask & (BMC_FILT_BROADCAST_ARP))
1197
1198 #define is_dhcp_client_filt_enabled(adapter) \
1199 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_CLIENT)
1200
1201 #define is_dhcp_srvr_filt_enabled(adapter) \
1202 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_DHCP_SERVER)
1203
1204 #define is_nbios_filt_enabled(adapter) \
1205 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST_NET_BIOS)
1206
1207 #define is_ipv6_na_filt_enabled(adapter) \
1208 (adapter->bmc_filt_mask & \
1209 BMC_FILT_MULTICAST_IPV6_NEIGH_ADVER)
1210
1211 #define is_ipv6_ra_filt_enabled(adapter) \
1212 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RA)
1213
1214 #define is_ipv6_ras_filt_enabled(adapter) \
1215 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST_IPV6_RAS)
1216
1217 #define is_broadcast_filt_enabled(adapter) \
1218 (adapter->bmc_filt_mask & BMC_FILT_BROADCAST)
1219
1220 #define is_multicast_filt_enabled(adapter) \
1221 (adapter->bmc_filt_mask & BMC_FILT_MULTICAST)
1222
1223 static bool be_send_pkt_to_bmc(struct be_adapter *adapter,
1224 struct sk_buff **skb)
1225 {
1226 struct ethhdr *eh = (struct ethhdr *)(*skb)->data;
1227 bool os2bmc = false;
1228
1229 if (!be_is_os2bmc_enabled(adapter))
1230 goto done;
1231
1232 if (!is_multicast_ether_addr(eh->h_dest))
1233 goto done;
1234
1235 if (is_mc_allowed_on_bmc(adapter, eh) ||
1236 is_bc_allowed_on_bmc(adapter, eh) ||
1237 is_arp_allowed_on_bmc(adapter, (*skb))) {
1238 os2bmc = true;
1239 goto done;
1240 }
1241
1242 if ((*skb)->protocol == htons(ETH_P_IPV6)) {
1243 struct ipv6hdr *hdr = ipv6_hdr((*skb));
1244 u8 nexthdr = hdr->nexthdr;
1245
1246 if (nexthdr == IPPROTO_ICMPV6) {
1247 struct icmp6hdr *icmp6 = icmp6_hdr((*skb));
1248
1249 switch (icmp6->icmp6_type) {
1250 case NDISC_ROUTER_ADVERTISEMENT:
1251 os2bmc = is_ipv6_ra_filt_enabled(adapter);
1252 goto done;
1253 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1254 os2bmc = is_ipv6_na_filt_enabled(adapter);
1255 goto done;
1256 default:
1257 break;
1258 }
1259 }
1260 }
1261
1262 if (is_udp_pkt((*skb))) {
1263 struct udphdr *udp = udp_hdr((*skb));
1264
1265 switch (ntohs(udp->dest)) {
1266 case DHCP_CLIENT_PORT:
1267 os2bmc = is_dhcp_client_filt_enabled(adapter);
1268 goto done;
1269 case DHCP_SERVER_PORT:
1270 os2bmc = is_dhcp_srvr_filt_enabled(adapter);
1271 goto done;
1272 case NET_BIOS_PORT1:
1273 case NET_BIOS_PORT2:
1274 os2bmc = is_nbios_filt_enabled(adapter);
1275 goto done;
1276 case DHCPV6_RAS_PORT:
1277 os2bmc = is_ipv6_ras_filt_enabled(adapter);
1278 goto done;
1279 default:
1280 break;
1281 }
1282 }
1283 done:
1284 /* For packets over a vlan, which are destined
1285 * to BMC, asic expects the vlan to be inline in the packet.
1286 */
1287 if (os2bmc)
1288 *skb = be_insert_vlan_in_pkt(adapter, *skb, NULL);
1289
1290 return os2bmc;
1291 }
1292
1293 static netdev_tx_t be_xmit(struct sk_buff *skb, struct net_device *netdev)
1294 {
1295 struct be_adapter *adapter = netdev_priv(netdev);
1296 u16 q_idx = skb_get_queue_mapping(skb);
1297 struct be_tx_obj *txo = &adapter->tx_obj[q_idx];
1298 struct be_wrb_params wrb_params = { 0 };
1299 bool flush = !skb->xmit_more;
1300 u16 wrb_cnt;
1301
1302 skb = be_xmit_workarounds(adapter, skb, &wrb_params);
1303 if (unlikely(!skb))
1304 goto drop;
1305
1306 be_get_wrb_params_from_skb(adapter, skb, &wrb_params);
1307
1308 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1309 if (unlikely(!wrb_cnt)) {
1310 dev_kfree_skb_any(skb);
1311 goto drop;
1312 }
1313
1314 /* if os2bmc is enabled and if the pkt is destined to bmc,
1315 * enqueue the pkt a 2nd time with mgmt bit set.
1316 */
1317 if (be_send_pkt_to_bmc(adapter, &skb)) {
1318 BE_WRB_F_SET(wrb_params.features, OS2BMC, 1);
1319 wrb_cnt = be_xmit_enqueue(adapter, txo, skb, &wrb_params);
1320 if (unlikely(!wrb_cnt))
1321 goto drop;
1322 else
1323 skb_get(skb);
1324 }
1325
1326 if (be_is_txq_full(txo)) {
1327 netif_stop_subqueue(netdev, q_idx);
1328 tx_stats(txo)->tx_stops++;
1329 }
1330
1331 if (flush || __netif_subqueue_stopped(netdev, q_idx))
1332 be_xmit_flush(adapter, txo);
1333
1334 return NETDEV_TX_OK;
1335 drop:
1336 tx_stats(txo)->tx_drv_drops++;
1337 /* Flush the already enqueued tx requests */
1338 if (flush && txo->pend_wrb_cnt)
1339 be_xmit_flush(adapter, txo);
1340
1341 return NETDEV_TX_OK;
1342 }
1343
1344 static int be_change_mtu(struct net_device *netdev, int new_mtu)
1345 {
1346 struct be_adapter *adapter = netdev_priv(netdev);
1347 struct device *dev = &adapter->pdev->dev;
1348
1349 if (new_mtu < BE_MIN_MTU || new_mtu > BE_MAX_MTU) {
1350 dev_info(dev, "MTU must be between %d and %d bytes\n",
1351 BE_MIN_MTU, BE_MAX_MTU);
1352 return -EINVAL;
1353 }
1354
1355 dev_info(dev, "MTU changed from %d to %d bytes\n",
1356 netdev->mtu, new_mtu);
1357 netdev->mtu = new_mtu;
1358 return 0;
1359 }
1360
1361 static inline bool be_in_all_promisc(struct be_adapter *adapter)
1362 {
1363 return (adapter->if_flags & BE_IF_FLAGS_ALL_PROMISCUOUS) ==
1364 BE_IF_FLAGS_ALL_PROMISCUOUS;
1365 }
1366
1367 static int be_set_vlan_promisc(struct be_adapter *adapter)
1368 {
1369 struct device *dev = &adapter->pdev->dev;
1370 int status;
1371
1372 if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS)
1373 return 0;
1374
1375 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, ON);
1376 if (!status) {
1377 dev_info(dev, "Enabled VLAN promiscuous mode\n");
1378 adapter->if_flags |= BE_IF_FLAGS_VLAN_PROMISCUOUS;
1379 } else {
1380 dev_err(dev, "Failed to enable VLAN promiscuous mode\n");
1381 }
1382 return status;
1383 }
1384
1385 static int be_clear_vlan_promisc(struct be_adapter *adapter)
1386 {
1387 struct device *dev = &adapter->pdev->dev;
1388 int status;
1389
1390 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_VLAN_PROMISCUOUS, OFF);
1391 if (!status) {
1392 dev_info(dev, "Disabling VLAN promiscuous mode\n");
1393 adapter->if_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
1394 }
1395 return status;
1396 }
1397
1398 /*
1399 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
1400 * If the user configures more, place BE in vlan promiscuous mode.
1401 */
1402 static int be_vid_config(struct be_adapter *adapter)
1403 {
1404 struct device *dev = &adapter->pdev->dev;
1405 u16 vids[BE_NUM_VLANS_SUPPORTED];
1406 u16 num = 0, i = 0;
1407 int status = 0;
1408
1409 /* No need to further configure vids if in promiscuous mode */
1410 if (be_in_all_promisc(adapter))
1411 return 0;
1412
1413 if (adapter->vlans_added > be_max_vlans(adapter))
1414 return be_set_vlan_promisc(adapter);
1415
1416 /* Construct VLAN Table to give to HW */
1417 for_each_set_bit(i, adapter->vids, VLAN_N_VID)
1418 vids[num++] = cpu_to_le16(i);
1419
1420 status = be_cmd_vlan_config(adapter, adapter->if_handle, vids, num, 0);
1421 if (status) {
1422 dev_err(dev, "Setting HW VLAN filtering failed\n");
1423 /* Set to VLAN promisc mode as setting VLAN filter failed */
1424 if (addl_status(status) == MCC_ADDL_STATUS_INSUFFICIENT_VLANS ||
1425 addl_status(status) ==
1426 MCC_ADDL_STATUS_INSUFFICIENT_RESOURCES)
1427 return be_set_vlan_promisc(adapter);
1428 } else if (adapter->if_flags & BE_IF_FLAGS_VLAN_PROMISCUOUS) {
1429 status = be_clear_vlan_promisc(adapter);
1430 }
1431 return status;
1432 }
1433
1434 static int be_vlan_add_vid(struct net_device *netdev, __be16 proto, u16 vid)
1435 {
1436 struct be_adapter *adapter = netdev_priv(netdev);
1437 int status = 0;
1438
1439 /* Packets with VID 0 are always received by Lancer by default */
1440 if (lancer_chip(adapter) && vid == 0)
1441 return status;
1442
1443 if (test_bit(vid, adapter->vids))
1444 return status;
1445
1446 set_bit(vid, adapter->vids);
1447 adapter->vlans_added++;
1448
1449 status = be_vid_config(adapter);
1450 if (status) {
1451 adapter->vlans_added--;
1452 clear_bit(vid, adapter->vids);
1453 }
1454
1455 return status;
1456 }
1457
1458 static int be_vlan_rem_vid(struct net_device *netdev, __be16 proto, u16 vid)
1459 {
1460 struct be_adapter *adapter = netdev_priv(netdev);
1461
1462 /* Packets with VID 0 are always received by Lancer by default */
1463 if (lancer_chip(adapter) && vid == 0)
1464 return 0;
1465
1466 clear_bit(vid, adapter->vids);
1467 adapter->vlans_added--;
1468
1469 return be_vid_config(adapter);
1470 }
1471
1472 static void be_clear_all_promisc(struct be_adapter *adapter)
1473 {
1474 be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, OFF);
1475 adapter->if_flags &= ~BE_IF_FLAGS_ALL_PROMISCUOUS;
1476 }
1477
1478 static void be_set_all_promisc(struct be_adapter *adapter)
1479 {
1480 be_cmd_rx_filter(adapter, BE_IF_FLAGS_ALL_PROMISCUOUS, ON);
1481 adapter->if_flags |= BE_IF_FLAGS_ALL_PROMISCUOUS;
1482 }
1483
1484 static void be_set_mc_promisc(struct be_adapter *adapter)
1485 {
1486 int status;
1487
1488 if (adapter->if_flags & BE_IF_FLAGS_MCAST_PROMISCUOUS)
1489 return;
1490
1491 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MCAST_PROMISCUOUS, ON);
1492 if (!status)
1493 adapter->if_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS;
1494 }
1495
1496 static void be_set_mc_list(struct be_adapter *adapter)
1497 {
1498 int status;
1499
1500 status = be_cmd_rx_filter(adapter, BE_IF_FLAGS_MULTICAST, ON);
1501 if (!status)
1502 adapter->if_flags &= ~BE_IF_FLAGS_MCAST_PROMISCUOUS;
1503 else
1504 be_set_mc_promisc(adapter);
1505 }
1506
1507 static void be_set_uc_list(struct be_adapter *adapter)
1508 {
1509 struct netdev_hw_addr *ha;
1510 int i = 1; /* First slot is claimed by the Primary MAC */
1511
1512 for (; adapter->uc_macs > 0; adapter->uc_macs--, i++)
1513 be_cmd_pmac_del(adapter, adapter->if_handle,
1514 adapter->pmac_id[i], 0);
1515
1516 if (netdev_uc_count(adapter->netdev) > be_max_uc(adapter)) {
1517 be_set_all_promisc(adapter);
1518 return;
1519 }
1520
1521 netdev_for_each_uc_addr(ha, adapter->netdev) {
1522 adapter->uc_macs++; /* First slot is for Primary MAC */
1523 be_cmd_pmac_add(adapter, (u8 *)ha->addr, adapter->if_handle,
1524 &adapter->pmac_id[adapter->uc_macs], 0);
1525 }
1526 }
1527
1528 static void be_clear_uc_list(struct be_adapter *adapter)
1529 {
1530 int i;
1531
1532 for (i = 1; i < (adapter->uc_macs + 1); i++)
1533 be_cmd_pmac_del(adapter, adapter->if_handle,
1534 adapter->pmac_id[i], 0);
1535 adapter->uc_macs = 0;
1536 }
1537
1538 static void be_set_rx_mode(struct net_device *netdev)
1539 {
1540 struct be_adapter *adapter = netdev_priv(netdev);
1541
1542 if (netdev->flags & IFF_PROMISC) {
1543 be_set_all_promisc(adapter);
1544 return;
1545 }
1546
1547 /* Interface was previously in promiscuous mode; disable it */
1548 if (be_in_all_promisc(adapter)) {
1549 be_clear_all_promisc(adapter);
1550 if (adapter->vlans_added)
1551 be_vid_config(adapter);
1552 }
1553
1554 /* Enable multicast promisc if num configured exceeds what we support */
1555 if (netdev->flags & IFF_ALLMULTI ||
1556 netdev_mc_count(netdev) > be_max_mc(adapter)) {
1557 be_set_mc_promisc(adapter);
1558 return;
1559 }
1560
1561 if (netdev_uc_count(netdev) != adapter->uc_macs)
1562 be_set_uc_list(adapter);
1563
1564 be_set_mc_list(adapter);
1565 }
1566
1567 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
1568 {
1569 struct be_adapter *adapter = netdev_priv(netdev);
1570 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1571 int status;
1572
1573 if (!sriov_enabled(adapter))
1574 return -EPERM;
1575
1576 if (!is_valid_ether_addr(mac) || vf >= adapter->num_vfs)
1577 return -EINVAL;
1578
1579 /* Proceed further only if user provided MAC is different
1580 * from active MAC
1581 */
1582 if (ether_addr_equal(mac, vf_cfg->mac_addr))
1583 return 0;
1584
1585 if (BEx_chip(adapter)) {
1586 be_cmd_pmac_del(adapter, vf_cfg->if_handle, vf_cfg->pmac_id,
1587 vf + 1);
1588
1589 status = be_cmd_pmac_add(adapter, mac, vf_cfg->if_handle,
1590 &vf_cfg->pmac_id, vf + 1);
1591 } else {
1592 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
1593 vf + 1);
1594 }
1595
1596 if (status) {
1597 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed: %#x",
1598 mac, vf, status);
1599 return be_cmd_status(status);
1600 }
1601
1602 ether_addr_copy(vf_cfg->mac_addr, mac);
1603
1604 return 0;
1605 }
1606
1607 static int be_get_vf_config(struct net_device *netdev, int vf,
1608 struct ifla_vf_info *vi)
1609 {
1610 struct be_adapter *adapter = netdev_priv(netdev);
1611 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1612
1613 if (!sriov_enabled(adapter))
1614 return -EPERM;
1615
1616 if (vf >= adapter->num_vfs)
1617 return -EINVAL;
1618
1619 vi->vf = vf;
1620 vi->max_tx_rate = vf_cfg->tx_rate;
1621 vi->min_tx_rate = 0;
1622 vi->vlan = vf_cfg->vlan_tag & VLAN_VID_MASK;
1623 vi->qos = vf_cfg->vlan_tag >> VLAN_PRIO_SHIFT;
1624 memcpy(&vi->mac, vf_cfg->mac_addr, ETH_ALEN);
1625 vi->linkstate = adapter->vf_cfg[vf].plink_tracking;
1626 vi->spoofchk = adapter->vf_cfg[vf].spoofchk;
1627
1628 return 0;
1629 }
1630
1631 static int be_set_vf_tvt(struct be_adapter *adapter, int vf, u16 vlan)
1632 {
1633 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1634 u16 vids[BE_NUM_VLANS_SUPPORTED];
1635 int vf_if_id = vf_cfg->if_handle;
1636 int status;
1637
1638 /* Enable Transparent VLAN Tagging */
1639 status = be_cmd_set_hsw_config(adapter, vlan, vf + 1, vf_if_id, 0, 0);
1640 if (status)
1641 return status;
1642
1643 /* Clear pre-programmed VLAN filters on VF if any, if TVT is enabled */
1644 vids[0] = 0;
1645 status = be_cmd_vlan_config(adapter, vf_if_id, vids, 1, vf + 1);
1646 if (!status)
1647 dev_info(&adapter->pdev->dev,
1648 "Cleared guest VLANs on VF%d", vf);
1649
1650 /* After TVT is enabled, disallow VFs to program VLAN filters */
1651 if (vf_cfg->privileges & BE_PRIV_FILTMGMT) {
1652 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges &
1653 ~BE_PRIV_FILTMGMT, vf + 1);
1654 if (!status)
1655 vf_cfg->privileges &= ~BE_PRIV_FILTMGMT;
1656 }
1657 return 0;
1658 }
1659
1660 static int be_clear_vf_tvt(struct be_adapter *adapter, int vf)
1661 {
1662 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1663 struct device *dev = &adapter->pdev->dev;
1664 int status;
1665
1666 /* Reset Transparent VLAN Tagging. */
1667 status = be_cmd_set_hsw_config(adapter, BE_RESET_VLAN_TAG_ID, vf + 1,
1668 vf_cfg->if_handle, 0, 0);
1669 if (status)
1670 return status;
1671
1672 /* Allow VFs to program VLAN filtering */
1673 if (!(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
1674 status = be_cmd_set_fn_privileges(adapter, vf_cfg->privileges |
1675 BE_PRIV_FILTMGMT, vf + 1);
1676 if (!status) {
1677 vf_cfg->privileges |= BE_PRIV_FILTMGMT;
1678 dev_info(dev, "VF%d: FILTMGMT priv enabled", vf);
1679 }
1680 }
1681
1682 dev_info(dev,
1683 "Disable/re-enable i/f in VM to clear Transparent VLAN tag");
1684 return 0;
1685 }
1686
1687 static int be_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos)
1688 {
1689 struct be_adapter *adapter = netdev_priv(netdev);
1690 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1691 int status;
1692
1693 if (!sriov_enabled(adapter))
1694 return -EPERM;
1695
1696 if (vf >= adapter->num_vfs || vlan > 4095 || qos > 7)
1697 return -EINVAL;
1698
1699 if (vlan || qos) {
1700 vlan |= qos << VLAN_PRIO_SHIFT;
1701 status = be_set_vf_tvt(adapter, vf, vlan);
1702 } else {
1703 status = be_clear_vf_tvt(adapter, vf);
1704 }
1705
1706 if (status) {
1707 dev_err(&adapter->pdev->dev,
1708 "VLAN %d config on VF %d failed : %#x\n", vlan, vf,
1709 status);
1710 return be_cmd_status(status);
1711 }
1712
1713 vf_cfg->vlan_tag = vlan;
1714 return 0;
1715 }
1716
1717 static int be_set_vf_tx_rate(struct net_device *netdev, int vf,
1718 int min_tx_rate, int max_tx_rate)
1719 {
1720 struct be_adapter *adapter = netdev_priv(netdev);
1721 struct device *dev = &adapter->pdev->dev;
1722 int percent_rate, status = 0;
1723 u16 link_speed = 0;
1724 u8 link_status;
1725
1726 if (!sriov_enabled(adapter))
1727 return -EPERM;
1728
1729 if (vf >= adapter->num_vfs)
1730 return -EINVAL;
1731
1732 if (min_tx_rate)
1733 return -EINVAL;
1734
1735 if (!max_tx_rate)
1736 goto config_qos;
1737
1738 status = be_cmd_link_status_query(adapter, &link_speed,
1739 &link_status, 0);
1740 if (status)
1741 goto err;
1742
1743 if (!link_status) {
1744 dev_err(dev, "TX-rate setting not allowed when link is down\n");
1745 status = -ENETDOWN;
1746 goto err;
1747 }
1748
1749 if (max_tx_rate < 100 || max_tx_rate > link_speed) {
1750 dev_err(dev, "TX-rate must be between 100 and %d Mbps\n",
1751 link_speed);
1752 status = -EINVAL;
1753 goto err;
1754 }
1755
1756 /* On Skyhawk the QOS setting must be done only as a % value */
1757 percent_rate = link_speed / 100;
1758 if (skyhawk_chip(adapter) && (max_tx_rate % percent_rate)) {
1759 dev_err(dev, "TX-rate must be a multiple of %d Mbps\n",
1760 percent_rate);
1761 status = -EINVAL;
1762 goto err;
1763 }
1764
1765 config_qos:
1766 status = be_cmd_config_qos(adapter, max_tx_rate, link_speed, vf + 1);
1767 if (status)
1768 goto err;
1769
1770 adapter->vf_cfg[vf].tx_rate = max_tx_rate;
1771 return 0;
1772
1773 err:
1774 dev_err(dev, "TX-rate setting of %dMbps on VF%d failed\n",
1775 max_tx_rate, vf);
1776 return be_cmd_status(status);
1777 }
1778
1779 static int be_set_vf_link_state(struct net_device *netdev, int vf,
1780 int link_state)
1781 {
1782 struct be_adapter *adapter = netdev_priv(netdev);
1783 int status;
1784
1785 if (!sriov_enabled(adapter))
1786 return -EPERM;
1787
1788 if (vf >= adapter->num_vfs)
1789 return -EINVAL;
1790
1791 status = be_cmd_set_logical_link_config(adapter, link_state, vf+1);
1792 if (status) {
1793 dev_err(&adapter->pdev->dev,
1794 "Link state change on VF %d failed: %#x\n", vf, status);
1795 return be_cmd_status(status);
1796 }
1797
1798 adapter->vf_cfg[vf].plink_tracking = link_state;
1799
1800 return 0;
1801 }
1802
1803 static int be_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable)
1804 {
1805 struct be_adapter *adapter = netdev_priv(netdev);
1806 struct be_vf_cfg *vf_cfg = &adapter->vf_cfg[vf];
1807 u8 spoofchk;
1808 int status;
1809
1810 if (!sriov_enabled(adapter))
1811 return -EPERM;
1812
1813 if (vf >= adapter->num_vfs)
1814 return -EINVAL;
1815
1816 if (BEx_chip(adapter))
1817 return -EOPNOTSUPP;
1818
1819 if (enable == vf_cfg->spoofchk)
1820 return 0;
1821
1822 spoofchk = enable ? ENABLE_MAC_SPOOFCHK : DISABLE_MAC_SPOOFCHK;
1823
1824 status = be_cmd_set_hsw_config(adapter, 0, vf + 1, vf_cfg->if_handle,
1825 0, spoofchk);
1826 if (status) {
1827 dev_err(&adapter->pdev->dev,
1828 "Spoofchk change on VF %d failed: %#x\n", vf, status);
1829 return be_cmd_status(status);
1830 }
1831
1832 vf_cfg->spoofchk = enable;
1833 return 0;
1834 }
1835
1836 static void be_aic_update(struct be_aic_obj *aic, u64 rx_pkts, u64 tx_pkts,
1837 ulong now)
1838 {
1839 aic->rx_pkts_prev = rx_pkts;
1840 aic->tx_reqs_prev = tx_pkts;
1841 aic->jiffies = now;
1842 }
1843
1844 static int be_get_new_eqd(struct be_eq_obj *eqo)
1845 {
1846 struct be_adapter *adapter = eqo->adapter;
1847 int eqd, start;
1848 struct be_aic_obj *aic;
1849 struct be_rx_obj *rxo;
1850 struct be_tx_obj *txo;
1851 u64 rx_pkts = 0, tx_pkts = 0;
1852 ulong now;
1853 u32 pps, delta;
1854 int i;
1855
1856 aic = &adapter->aic_obj[eqo->idx];
1857 if (!aic->enable) {
1858 if (aic->jiffies)
1859 aic->jiffies = 0;
1860 eqd = aic->et_eqd;
1861 return eqd;
1862 }
1863
1864 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
1865 do {
1866 start = u64_stats_fetch_begin_irq(&rxo->stats.sync);
1867 rx_pkts += rxo->stats.rx_pkts;
1868 } while (u64_stats_fetch_retry_irq(&rxo->stats.sync, start));
1869 }
1870
1871 for_all_tx_queues_on_eq(adapter, eqo, txo, i) {
1872 do {
1873 start = u64_stats_fetch_begin_irq(&txo->stats.sync);
1874 tx_pkts += txo->stats.tx_reqs;
1875 } while (u64_stats_fetch_retry_irq(&txo->stats.sync, start));
1876 }
1877
1878 /* Skip, if wrapped around or first calculation */
1879 now = jiffies;
1880 if (!aic->jiffies || time_before(now, aic->jiffies) ||
1881 rx_pkts < aic->rx_pkts_prev ||
1882 tx_pkts < aic->tx_reqs_prev) {
1883 be_aic_update(aic, rx_pkts, tx_pkts, now);
1884 return aic->prev_eqd;
1885 }
1886
1887 delta = jiffies_to_msecs(now - aic->jiffies);
1888 if (delta == 0)
1889 return aic->prev_eqd;
1890
1891 pps = (((u32)(rx_pkts - aic->rx_pkts_prev) * 1000) / delta) +
1892 (((u32)(tx_pkts - aic->tx_reqs_prev) * 1000) / delta);
1893 eqd = (pps / 15000) << 2;
1894
1895 if (eqd < 8)
1896 eqd = 0;
1897 eqd = min_t(u32, eqd, aic->max_eqd);
1898 eqd = max_t(u32, eqd, aic->min_eqd);
1899
1900 be_aic_update(aic, rx_pkts, tx_pkts, now);
1901
1902 return eqd;
1903 }
1904
1905 /* For Skyhawk-R only */
1906 static u32 be_get_eq_delay_mult_enc(struct be_eq_obj *eqo)
1907 {
1908 struct be_adapter *adapter = eqo->adapter;
1909 struct be_aic_obj *aic = &adapter->aic_obj[eqo->idx];
1910 ulong now = jiffies;
1911 int eqd;
1912 u32 mult_enc;
1913
1914 if (!aic->enable)
1915 return 0;
1916
1917 if (time_before_eq(now, aic->jiffies) ||
1918 jiffies_to_msecs(now - aic->jiffies) < 1)
1919 eqd = aic->prev_eqd;
1920 else
1921 eqd = be_get_new_eqd(eqo);
1922
1923 if (eqd > 100)
1924 mult_enc = R2I_DLY_ENC_1;
1925 else if (eqd > 60)
1926 mult_enc = R2I_DLY_ENC_2;
1927 else if (eqd > 20)
1928 mult_enc = R2I_DLY_ENC_3;
1929 else
1930 mult_enc = R2I_DLY_ENC_0;
1931
1932 aic->prev_eqd = eqd;
1933
1934 return mult_enc;
1935 }
1936
1937 void be_eqd_update(struct be_adapter *adapter, bool force_update)
1938 {
1939 struct be_set_eqd set_eqd[MAX_EVT_QS];
1940 struct be_aic_obj *aic;
1941 struct be_eq_obj *eqo;
1942 int i, num = 0, eqd;
1943
1944 for_all_evt_queues(adapter, eqo, i) {
1945 aic = &adapter->aic_obj[eqo->idx];
1946 eqd = be_get_new_eqd(eqo);
1947 if (force_update || eqd != aic->prev_eqd) {
1948 set_eqd[num].delay_multiplier = (eqd * 65)/100;
1949 set_eqd[num].eq_id = eqo->q.id;
1950 aic->prev_eqd = eqd;
1951 num++;
1952 }
1953 }
1954
1955 if (num)
1956 be_cmd_modify_eqd(adapter, set_eqd, num);
1957 }
1958
1959 static void be_rx_stats_update(struct be_rx_obj *rxo,
1960 struct be_rx_compl_info *rxcp)
1961 {
1962 struct be_rx_stats *stats = rx_stats(rxo);
1963
1964 u64_stats_update_begin(&stats->sync);
1965 stats->rx_compl++;
1966 stats->rx_bytes += rxcp->pkt_size;
1967 stats->rx_pkts++;
1968 if (rxcp->tunneled)
1969 stats->rx_vxlan_offload_pkts++;
1970 if (rxcp->pkt_type == BE_MULTICAST_PACKET)
1971 stats->rx_mcast_pkts++;
1972 if (rxcp->err)
1973 stats->rx_compl_err++;
1974 u64_stats_update_end(&stats->sync);
1975 }
1976
1977 static inline bool csum_passed(struct be_rx_compl_info *rxcp)
1978 {
1979 /* L4 checksum is not reliable for non TCP/UDP packets.
1980 * Also ignore ipcksm for ipv6 pkts
1981 */
1982 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
1983 (rxcp->ip_csum || rxcp->ipv6) && !rxcp->err;
1984 }
1985
1986 static struct be_rx_page_info *get_rx_page_info(struct be_rx_obj *rxo)
1987 {
1988 struct be_adapter *adapter = rxo->adapter;
1989 struct be_rx_page_info *rx_page_info;
1990 struct be_queue_info *rxq = &rxo->q;
1991 u16 frag_idx = rxq->tail;
1992
1993 rx_page_info = &rxo->page_info_tbl[frag_idx];
1994 BUG_ON(!rx_page_info->page);
1995
1996 if (rx_page_info->last_frag) {
1997 dma_unmap_page(&adapter->pdev->dev,
1998 dma_unmap_addr(rx_page_info, bus),
1999 adapter->big_page_size, DMA_FROM_DEVICE);
2000 rx_page_info->last_frag = false;
2001 } else {
2002 dma_sync_single_for_cpu(&adapter->pdev->dev,
2003 dma_unmap_addr(rx_page_info, bus),
2004 rx_frag_size, DMA_FROM_DEVICE);
2005 }
2006
2007 queue_tail_inc(rxq);
2008 atomic_dec(&rxq->used);
2009 return rx_page_info;
2010 }
2011
2012 /* Throwaway the data in the Rx completion */
2013 static void be_rx_compl_discard(struct be_rx_obj *rxo,
2014 struct be_rx_compl_info *rxcp)
2015 {
2016 struct be_rx_page_info *page_info;
2017 u16 i, num_rcvd = rxcp->num_rcvd;
2018
2019 for (i = 0; i < num_rcvd; i++) {
2020 page_info = get_rx_page_info(rxo);
2021 put_page(page_info->page);
2022 memset(page_info, 0, sizeof(*page_info));
2023 }
2024 }
2025
2026 /*
2027 * skb_fill_rx_data forms a complete skb for an ether frame
2028 * indicated by rxcp.
2029 */
2030 static void skb_fill_rx_data(struct be_rx_obj *rxo, struct sk_buff *skb,
2031 struct be_rx_compl_info *rxcp)
2032 {
2033 struct be_rx_page_info *page_info;
2034 u16 i, j;
2035 u16 hdr_len, curr_frag_len, remaining;
2036 u8 *start;
2037
2038 page_info = get_rx_page_info(rxo);
2039 start = page_address(page_info->page) + page_info->page_offset;
2040 prefetch(start);
2041
2042 /* Copy data in the first descriptor of this completion */
2043 curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
2044
2045 skb->len = curr_frag_len;
2046 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
2047 memcpy(skb->data, start, curr_frag_len);
2048 /* Complete packet has now been moved to data */
2049 put_page(page_info->page);
2050 skb->data_len = 0;
2051 skb->tail += curr_frag_len;
2052 } else {
2053 hdr_len = ETH_HLEN;
2054 memcpy(skb->data, start, hdr_len);
2055 skb_shinfo(skb)->nr_frags = 1;
2056 skb_frag_set_page(skb, 0, page_info->page);
2057 skb_shinfo(skb)->frags[0].page_offset =
2058 page_info->page_offset + hdr_len;
2059 skb_frag_size_set(&skb_shinfo(skb)->frags[0],
2060 curr_frag_len - hdr_len);
2061 skb->data_len = curr_frag_len - hdr_len;
2062 skb->truesize += rx_frag_size;
2063 skb->tail += hdr_len;
2064 }
2065 page_info->page = NULL;
2066
2067 if (rxcp->pkt_size <= rx_frag_size) {
2068 BUG_ON(rxcp->num_rcvd != 1);
2069 return;
2070 }
2071
2072 /* More frags present for this completion */
2073 remaining = rxcp->pkt_size - curr_frag_len;
2074 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
2075 page_info = get_rx_page_info(rxo);
2076 curr_frag_len = min(remaining, rx_frag_size);
2077
2078 /* Coalesce all frags from the same physical page in one slot */
2079 if (page_info->page_offset == 0) {
2080 /* Fresh page */
2081 j++;
2082 skb_frag_set_page(skb, j, page_info->page);
2083 skb_shinfo(skb)->frags[j].page_offset =
2084 page_info->page_offset;
2085 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2086 skb_shinfo(skb)->nr_frags++;
2087 } else {
2088 put_page(page_info->page);
2089 }
2090
2091 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
2092 skb->len += curr_frag_len;
2093 skb->data_len += curr_frag_len;
2094 skb->truesize += rx_frag_size;
2095 remaining -= curr_frag_len;
2096 page_info->page = NULL;
2097 }
2098 BUG_ON(j > MAX_SKB_FRAGS);
2099 }
2100
2101 /* Process the RX completion indicated by rxcp when GRO is disabled */
2102 static void be_rx_compl_process(struct be_rx_obj *rxo, struct napi_struct *napi,
2103 struct be_rx_compl_info *rxcp)
2104 {
2105 struct be_adapter *adapter = rxo->adapter;
2106 struct net_device *netdev = adapter->netdev;
2107 struct sk_buff *skb;
2108
2109 skb = netdev_alloc_skb_ip_align(netdev, BE_RX_SKB_ALLOC_SIZE);
2110 if (unlikely(!skb)) {
2111 rx_stats(rxo)->rx_drops_no_skbs++;
2112 be_rx_compl_discard(rxo, rxcp);
2113 return;
2114 }
2115
2116 skb_fill_rx_data(rxo, skb, rxcp);
2117
2118 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
2119 skb->ip_summed = CHECKSUM_UNNECESSARY;
2120 else
2121 skb_checksum_none_assert(skb);
2122
2123 skb->protocol = eth_type_trans(skb, netdev);
2124 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
2125 if (netdev->features & NETIF_F_RXHASH)
2126 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2127
2128 skb->csum_level = rxcp->tunneled;
2129 skb_mark_napi_id(skb, napi);
2130
2131 if (rxcp->vlanf)
2132 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
2133
2134 netif_receive_skb(skb);
2135 }
2136
2137 /* Process the RX completion indicated by rxcp when GRO is enabled */
2138 static void be_rx_compl_process_gro(struct be_rx_obj *rxo,
2139 struct napi_struct *napi,
2140 struct be_rx_compl_info *rxcp)
2141 {
2142 struct be_adapter *adapter = rxo->adapter;
2143 struct be_rx_page_info *page_info;
2144 struct sk_buff *skb = NULL;
2145 u16 remaining, curr_frag_len;
2146 u16 i, j;
2147
2148 skb = napi_get_frags(napi);
2149 if (!skb) {
2150 be_rx_compl_discard(rxo, rxcp);
2151 return;
2152 }
2153
2154 remaining = rxcp->pkt_size;
2155 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
2156 page_info = get_rx_page_info(rxo);
2157
2158 curr_frag_len = min(remaining, rx_frag_size);
2159
2160 /* Coalesce all frags from the same physical page in one slot */
2161 if (i == 0 || page_info->page_offset == 0) {
2162 /* First frag or Fresh page */
2163 j++;
2164 skb_frag_set_page(skb, j, page_info->page);
2165 skb_shinfo(skb)->frags[j].page_offset =
2166 page_info->page_offset;
2167 skb_frag_size_set(&skb_shinfo(skb)->frags[j], 0);
2168 } else {
2169 put_page(page_info->page);
2170 }
2171 skb_frag_size_add(&skb_shinfo(skb)->frags[j], curr_frag_len);
2172 skb->truesize += rx_frag_size;
2173 remaining -= curr_frag_len;
2174 memset(page_info, 0, sizeof(*page_info));
2175 }
2176 BUG_ON(j > MAX_SKB_FRAGS);
2177
2178 skb_shinfo(skb)->nr_frags = j + 1;
2179 skb->len = rxcp->pkt_size;
2180 skb->data_len = rxcp->pkt_size;
2181 skb->ip_summed = CHECKSUM_UNNECESSARY;
2182 skb_record_rx_queue(skb, rxo - &adapter->rx_obj[0]);
2183 if (adapter->netdev->features & NETIF_F_RXHASH)
2184 skb_set_hash(skb, rxcp->rss_hash, PKT_HASH_TYPE_L3);
2185
2186 skb->csum_level = rxcp->tunneled;
2187 skb_mark_napi_id(skb, napi);
2188
2189 if (rxcp->vlanf)
2190 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
2191
2192 napi_gro_frags(napi);
2193 }
2194
2195 static void be_parse_rx_compl_v1(struct be_eth_rx_compl *compl,
2196 struct be_rx_compl_info *rxcp)
2197 {
2198 rxcp->pkt_size = GET_RX_COMPL_V1_BITS(pktsize, compl);
2199 rxcp->vlanf = GET_RX_COMPL_V1_BITS(vtp, compl);
2200 rxcp->err = GET_RX_COMPL_V1_BITS(err, compl);
2201 rxcp->tcpf = GET_RX_COMPL_V1_BITS(tcpf, compl);
2202 rxcp->udpf = GET_RX_COMPL_V1_BITS(udpf, compl);
2203 rxcp->ip_csum = GET_RX_COMPL_V1_BITS(ipcksm, compl);
2204 rxcp->l4_csum = GET_RX_COMPL_V1_BITS(l4_cksm, compl);
2205 rxcp->ipv6 = GET_RX_COMPL_V1_BITS(ip_version, compl);
2206 rxcp->num_rcvd = GET_RX_COMPL_V1_BITS(numfrags, compl);
2207 rxcp->pkt_type = GET_RX_COMPL_V1_BITS(cast_enc, compl);
2208 rxcp->rss_hash = GET_RX_COMPL_V1_BITS(rsshash, compl);
2209 if (rxcp->vlanf) {
2210 rxcp->qnq = GET_RX_COMPL_V1_BITS(qnq, compl);
2211 rxcp->vlan_tag = GET_RX_COMPL_V1_BITS(vlan_tag, compl);
2212 }
2213 rxcp->port = GET_RX_COMPL_V1_BITS(port, compl);
2214 rxcp->tunneled =
2215 GET_RX_COMPL_V1_BITS(tunneled, compl);
2216 }
2217
2218 static void be_parse_rx_compl_v0(struct be_eth_rx_compl *compl,
2219 struct be_rx_compl_info *rxcp)
2220 {
2221 rxcp->pkt_size = GET_RX_COMPL_V0_BITS(pktsize, compl);
2222 rxcp->vlanf = GET_RX_COMPL_V0_BITS(vtp, compl);
2223 rxcp->err = GET_RX_COMPL_V0_BITS(err, compl);
2224 rxcp->tcpf = GET_RX_COMPL_V0_BITS(tcpf, compl);
2225 rxcp->udpf = GET_RX_COMPL_V0_BITS(udpf, compl);
2226 rxcp->ip_csum = GET_RX_COMPL_V0_BITS(ipcksm, compl);
2227 rxcp->l4_csum = GET_RX_COMPL_V0_BITS(l4_cksm, compl);
2228 rxcp->ipv6 = GET_RX_COMPL_V0_BITS(ip_version, compl);
2229 rxcp->num_rcvd = GET_RX_COMPL_V0_BITS(numfrags, compl);
2230 rxcp->pkt_type = GET_RX_COMPL_V0_BITS(cast_enc, compl);
2231 rxcp->rss_hash = GET_RX_COMPL_V0_BITS(rsshash, compl);
2232 if (rxcp->vlanf) {
2233 rxcp->qnq = GET_RX_COMPL_V0_BITS(qnq, compl);
2234 rxcp->vlan_tag = GET_RX_COMPL_V0_BITS(vlan_tag, compl);
2235 }
2236 rxcp->port = GET_RX_COMPL_V0_BITS(port, compl);
2237 rxcp->ip_frag = GET_RX_COMPL_V0_BITS(ip_frag, compl);
2238 }
2239
2240 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
2241 {
2242 struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
2243 struct be_rx_compl_info *rxcp = &rxo->rxcp;
2244 struct be_adapter *adapter = rxo->adapter;
2245
2246 /* For checking the valid bit it is Ok to use either definition as the
2247 * valid bit is at the same position in both v0 and v1 Rx compl */
2248 if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
2249 return NULL;
2250
2251 rmb();
2252 be_dws_le_to_cpu(compl, sizeof(*compl));
2253
2254 if (adapter->be3_native)
2255 be_parse_rx_compl_v1(compl, rxcp);
2256 else
2257 be_parse_rx_compl_v0(compl, rxcp);
2258
2259 if (rxcp->ip_frag)
2260 rxcp->l4_csum = 0;
2261
2262 if (rxcp->vlanf) {
2263 /* In QNQ modes, if qnq bit is not set, then the packet was
2264 * tagged only with the transparent outer vlan-tag and must
2265 * not be treated as a vlan packet by host
2266 */
2267 if (be_is_qnq_mode(adapter) && !rxcp->qnq)
2268 rxcp->vlanf = 0;
2269
2270 if (!lancer_chip(adapter))
2271 rxcp->vlan_tag = swab16(rxcp->vlan_tag);
2272
2273 if (adapter->pvid == (rxcp->vlan_tag & VLAN_VID_MASK) &&
2274 !test_bit(rxcp->vlan_tag, adapter->vids))
2275 rxcp->vlanf = 0;
2276 }
2277
2278 /* As the compl has been parsed, reset it; we wont touch it again */
2279 compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
2280
2281 queue_tail_inc(&rxo->cq);
2282 return rxcp;
2283 }
2284
2285 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
2286 {
2287 u32 order = get_order(size);
2288
2289 if (order > 0)
2290 gfp |= __GFP_COMP;
2291 return alloc_pages(gfp, order);
2292 }
2293
2294 /*
2295 * Allocate a page, split it to fragments of size rx_frag_size and post as
2296 * receive buffers to BE
2297 */
2298 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp, u32 frags_needed)
2299 {
2300 struct be_adapter *adapter = rxo->adapter;
2301 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
2302 struct be_queue_info *rxq = &rxo->q;
2303 struct page *pagep = NULL;
2304 struct device *dev = &adapter->pdev->dev;
2305 struct be_eth_rx_d *rxd;
2306 u64 page_dmaaddr = 0, frag_dmaaddr;
2307 u32 posted, page_offset = 0, notify = 0;
2308
2309 page_info = &rxo->page_info_tbl[rxq->head];
2310 for (posted = 0; posted < frags_needed && !page_info->page; posted++) {
2311 if (!pagep) {
2312 pagep = be_alloc_pages(adapter->big_page_size, gfp);
2313 if (unlikely(!pagep)) {
2314 rx_stats(rxo)->rx_post_fail++;
2315 break;
2316 }
2317 page_dmaaddr = dma_map_page(dev, pagep, 0,
2318 adapter->big_page_size,
2319 DMA_FROM_DEVICE);
2320 if (dma_mapping_error(dev, page_dmaaddr)) {
2321 put_page(pagep);
2322 pagep = NULL;
2323 adapter->drv_stats.dma_map_errors++;
2324 break;
2325 }
2326 page_offset = 0;
2327 } else {
2328 get_page(pagep);
2329 page_offset += rx_frag_size;
2330 }
2331 page_info->page_offset = page_offset;
2332 page_info->page = pagep;
2333
2334 rxd = queue_head_node(rxq);
2335 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
2336 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
2337 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
2338
2339 /* Any space left in the current big page for another frag? */
2340 if ((page_offset + rx_frag_size + rx_frag_size) >
2341 adapter->big_page_size) {
2342 pagep = NULL;
2343 page_info->last_frag = true;
2344 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
2345 } else {
2346 dma_unmap_addr_set(page_info, bus, frag_dmaaddr);
2347 }
2348
2349 prev_page_info = page_info;
2350 queue_head_inc(rxq);
2351 page_info = &rxo->page_info_tbl[rxq->head];
2352 }
2353
2354 /* Mark the last frag of a page when we break out of the above loop
2355 * with no more slots available in the RXQ
2356 */
2357 if (pagep) {
2358 prev_page_info->last_frag = true;
2359 dma_unmap_addr_set(prev_page_info, bus, page_dmaaddr);
2360 }
2361
2362 if (posted) {
2363 atomic_add(posted, &rxq->used);
2364 if (rxo->rx_post_starved)
2365 rxo->rx_post_starved = false;
2366 do {
2367 notify = min(MAX_NUM_POST_ERX_DB, posted);
2368 be_rxq_notify(adapter, rxq->id, notify);
2369 posted -= notify;
2370 } while (posted);
2371 } else if (atomic_read(&rxq->used) == 0) {
2372 /* Let be_worker replenish when memory is available */
2373 rxo->rx_post_starved = true;
2374 }
2375 }
2376
2377 static struct be_tx_compl_info *be_tx_compl_get(struct be_tx_obj *txo)
2378 {
2379 struct be_queue_info *tx_cq = &txo->cq;
2380 struct be_tx_compl_info *txcp = &txo->txcp;
2381 struct be_eth_tx_compl *compl = queue_tail_node(tx_cq);
2382
2383 if (compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
2384 return NULL;
2385
2386 /* Ensure load ordering of valid bit dword and other dwords below */
2387 rmb();
2388 be_dws_le_to_cpu(compl, sizeof(*compl));
2389
2390 txcp->status = GET_TX_COMPL_BITS(status, compl);
2391 txcp->end_index = GET_TX_COMPL_BITS(wrb_index, compl);
2392
2393 compl->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
2394 queue_tail_inc(tx_cq);
2395 return txcp;
2396 }
2397
2398 static u16 be_tx_compl_process(struct be_adapter *adapter,
2399 struct be_tx_obj *txo, u16 last_index)
2400 {
2401 struct sk_buff **sent_skbs = txo->sent_skb_list;
2402 struct be_queue_info *txq = &txo->q;
2403 u16 frag_index, num_wrbs = 0;
2404 struct sk_buff *skb = NULL;
2405 bool unmap_skb_hdr = false;
2406 struct be_eth_wrb *wrb;
2407
2408 do {
2409 if (sent_skbs[txq->tail]) {
2410 /* Free skb from prev req */
2411 if (skb)
2412 dev_consume_skb_any(skb);
2413 skb = sent_skbs[txq->tail];
2414 sent_skbs[txq->tail] = NULL;
2415 queue_tail_inc(txq); /* skip hdr wrb */
2416 num_wrbs++;
2417 unmap_skb_hdr = true;
2418 }
2419 wrb = queue_tail_node(txq);
2420 frag_index = txq->tail;
2421 unmap_tx_frag(&adapter->pdev->dev, wrb,
2422 (unmap_skb_hdr && skb_headlen(skb)));
2423 unmap_skb_hdr = false;
2424 queue_tail_inc(txq);
2425 num_wrbs++;
2426 } while (frag_index != last_index);
2427 dev_consume_skb_any(skb);
2428
2429 return num_wrbs;
2430 }
2431
2432 /* Return the number of events in the event queue */
2433 static inline int events_get(struct be_eq_obj *eqo)
2434 {
2435 struct be_eq_entry *eqe;
2436 int num = 0;
2437
2438 do {
2439 eqe = queue_tail_node(&eqo->q);
2440 if (eqe->evt == 0)
2441 break;
2442
2443 rmb();
2444 eqe->evt = 0;
2445 num++;
2446 queue_tail_inc(&eqo->q);
2447 } while (true);
2448
2449 return num;
2450 }
2451
2452 /* Leaves the EQ is disarmed state */
2453 static void be_eq_clean(struct be_eq_obj *eqo)
2454 {
2455 int num = events_get(eqo);
2456
2457 be_eq_notify(eqo->adapter, eqo->q.id, false, true, num, 0);
2458 }
2459
2460 /* Free posted rx buffers that were not used */
2461 static void be_rxq_clean(struct be_rx_obj *rxo)
2462 {
2463 struct be_queue_info *rxq = &rxo->q;
2464 struct be_rx_page_info *page_info;
2465
2466 while (atomic_read(&rxq->used) > 0) {
2467 page_info = get_rx_page_info(rxo);
2468 put_page(page_info->page);
2469 memset(page_info, 0, sizeof(*page_info));
2470 }
2471 BUG_ON(atomic_read(&rxq->used));
2472 rxq->tail = 0;
2473 rxq->head = 0;
2474 }
2475
2476 static void be_rx_cq_clean(struct be_rx_obj *rxo)
2477 {
2478 struct be_queue_info *rx_cq = &rxo->cq;
2479 struct be_rx_compl_info *rxcp;
2480 struct be_adapter *adapter = rxo->adapter;
2481 int flush_wait = 0;
2482
2483 /* Consume pending rx completions.
2484 * Wait for the flush completion (identified by zero num_rcvd)
2485 * to arrive. Notify CQ even when there are no more CQ entries
2486 * for HW to flush partially coalesced CQ entries.
2487 * In Lancer, there is no need to wait for flush compl.
2488 */
2489 for (;;) {
2490 rxcp = be_rx_compl_get(rxo);
2491 if (!rxcp) {
2492 if (lancer_chip(adapter))
2493 break;
2494
2495 if (flush_wait++ > 50 ||
2496 be_check_error(adapter,
2497 BE_ERROR_HW)) {
2498 dev_warn(&adapter->pdev->dev,
2499 "did not receive flush compl\n");
2500 break;
2501 }
2502 be_cq_notify(adapter, rx_cq->id, true, 0);
2503 mdelay(1);
2504 } else {
2505 be_rx_compl_discard(rxo, rxcp);
2506 be_cq_notify(adapter, rx_cq->id, false, 1);
2507 if (rxcp->num_rcvd == 0)
2508 break;
2509 }
2510 }
2511
2512 /* After cleanup, leave the CQ in unarmed state */
2513 be_cq_notify(adapter, rx_cq->id, false, 0);
2514 }
2515
2516 static void be_tx_compl_clean(struct be_adapter *adapter)
2517 {
2518 u16 end_idx, notified_idx, cmpl = 0, timeo = 0, num_wrbs = 0;
2519 struct device *dev = &adapter->pdev->dev;
2520 struct be_tx_compl_info *txcp;
2521 struct be_queue_info *txq;
2522 struct be_tx_obj *txo;
2523 int i, pending_txqs;
2524
2525 /* Stop polling for compls when HW has been silent for 10ms */
2526 do {
2527 pending_txqs = adapter->num_tx_qs;
2528
2529 for_all_tx_queues(adapter, txo, i) {
2530 cmpl = 0;
2531 num_wrbs = 0;
2532 txq = &txo->q;
2533 while ((txcp = be_tx_compl_get(txo))) {
2534 num_wrbs +=
2535 be_tx_compl_process(adapter, txo,
2536 txcp->end_index);
2537 cmpl++;
2538 }
2539 if (cmpl) {
2540 be_cq_notify(adapter, txo->cq.id, false, cmpl);
2541 atomic_sub(num_wrbs, &txq->used);
2542 timeo = 0;
2543 }
2544 if (!be_is_tx_compl_pending(txo))
2545 pending_txqs--;
2546 }
2547
2548 if (pending_txqs == 0 || ++timeo > 10 ||
2549 be_check_error(adapter, BE_ERROR_HW))
2550 break;
2551
2552 mdelay(1);
2553 } while (true);
2554
2555 /* Free enqueued TX that was never notified to HW */
2556 for_all_tx_queues(adapter, txo, i) {
2557 txq = &txo->q;
2558
2559 if (atomic_read(&txq->used)) {
2560 dev_info(dev, "txq%d: cleaning %d pending tx-wrbs\n",
2561 i, atomic_read(&txq->used));
2562 notified_idx = txq->tail;
2563 end_idx = txq->tail;
2564 index_adv(&end_idx, atomic_read(&txq->used) - 1,
2565 txq->len);
2566 /* Use the tx-compl process logic to handle requests
2567 * that were not sent to the HW.
2568 */
2569 num_wrbs = be_tx_compl_process(adapter, txo, end_idx);
2570 atomic_sub(num_wrbs, &txq->used);
2571 BUG_ON(atomic_read(&txq->used));
2572 txo->pend_wrb_cnt = 0;
2573 /* Since hw was never notified of these requests,
2574 * reset TXQ indices
2575 */
2576 txq->head = notified_idx;
2577 txq->tail = notified_idx;
2578 }
2579 }
2580 }
2581
2582 static void be_evt_queues_destroy(struct be_adapter *adapter)
2583 {
2584 struct be_eq_obj *eqo;
2585 int i;
2586
2587 for_all_evt_queues(adapter, eqo, i) {
2588 if (eqo->q.created) {
2589 be_eq_clean(eqo);
2590 be_cmd_q_destroy(adapter, &eqo->q, QTYPE_EQ);
2591 napi_hash_del(&eqo->napi);
2592 netif_napi_del(&eqo->napi);
2593 free_cpumask_var(eqo->affinity_mask);
2594 }
2595 be_queue_free(adapter, &eqo->q);
2596 }
2597 }
2598
2599 static int be_evt_queues_create(struct be_adapter *adapter)
2600 {
2601 struct be_queue_info *eq;
2602 struct be_eq_obj *eqo;
2603 struct be_aic_obj *aic;
2604 int i, rc;
2605
2606 adapter->num_evt_qs = min_t(u16, num_irqs(adapter),
2607 adapter->cfg_num_qs);
2608
2609 for_all_evt_queues(adapter, eqo, i) {
2610 int numa_node = dev_to_node(&adapter->pdev->dev);
2611
2612 aic = &adapter->aic_obj[i];
2613 eqo->adapter = adapter;
2614 eqo->idx = i;
2615 aic->max_eqd = BE_MAX_EQD;
2616 aic->enable = true;
2617
2618 eq = &eqo->q;
2619 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
2620 sizeof(struct be_eq_entry));
2621 if (rc)
2622 return rc;
2623
2624 rc = be_cmd_eq_create(adapter, eqo);
2625 if (rc)
2626 return rc;
2627
2628 if (!zalloc_cpumask_var(&eqo->affinity_mask, GFP_KERNEL))
2629 return -ENOMEM;
2630 cpumask_set_cpu(cpumask_local_spread(i, numa_node),
2631 eqo->affinity_mask);
2632 netif_napi_add(adapter->netdev, &eqo->napi, be_poll,
2633 BE_NAPI_WEIGHT);
2634 napi_hash_add(&eqo->napi);
2635 }
2636 return 0;
2637 }
2638
2639 static void be_mcc_queues_destroy(struct be_adapter *adapter)
2640 {
2641 struct be_queue_info *q;
2642
2643 q = &adapter->mcc_obj.q;
2644 if (q->created)
2645 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
2646 be_queue_free(adapter, q);
2647
2648 q = &adapter->mcc_obj.cq;
2649 if (q->created)
2650 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2651 be_queue_free(adapter, q);
2652 }
2653
2654 /* Must be called only after TX qs are created as MCC shares TX EQ */
2655 static int be_mcc_queues_create(struct be_adapter *adapter)
2656 {
2657 struct be_queue_info *q, *cq;
2658
2659 cq = &adapter->mcc_obj.cq;
2660 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
2661 sizeof(struct be_mcc_compl)))
2662 goto err;
2663
2664 /* Use the default EQ for MCC completions */
2665 if (be_cmd_cq_create(adapter, cq, &mcc_eqo(adapter)->q, true, 0))
2666 goto mcc_cq_free;
2667
2668 q = &adapter->mcc_obj.q;
2669 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
2670 goto mcc_cq_destroy;
2671
2672 if (be_cmd_mccq_create(adapter, q, cq))
2673 goto mcc_q_free;
2674
2675 return 0;
2676
2677 mcc_q_free:
2678 be_queue_free(adapter, q);
2679 mcc_cq_destroy:
2680 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
2681 mcc_cq_free:
2682 be_queue_free(adapter, cq);
2683 err:
2684 return -1;
2685 }
2686
2687 static void be_tx_queues_destroy(struct be_adapter *adapter)
2688 {
2689 struct be_queue_info *q;
2690 struct be_tx_obj *txo;
2691 u8 i;
2692
2693 for_all_tx_queues(adapter, txo, i) {
2694 q = &txo->q;
2695 if (q->created)
2696 be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
2697 be_queue_free(adapter, q);
2698
2699 q = &txo->cq;
2700 if (q->created)
2701 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2702 be_queue_free(adapter, q);
2703 }
2704 }
2705
2706 static int be_tx_qs_create(struct be_adapter *adapter)
2707 {
2708 struct be_queue_info *cq;
2709 struct be_tx_obj *txo;
2710 struct be_eq_obj *eqo;
2711 int status, i;
2712
2713 adapter->num_tx_qs = min(adapter->num_evt_qs, be_max_txqs(adapter));
2714
2715 for_all_tx_queues(adapter, txo, i) {
2716 cq = &txo->cq;
2717 status = be_queue_alloc(adapter, cq, TX_CQ_LEN,
2718 sizeof(struct be_eth_tx_compl));
2719 if (status)
2720 return status;
2721
2722 u64_stats_init(&txo->stats.sync);
2723 u64_stats_init(&txo->stats.sync_compl);
2724
2725 /* If num_evt_qs is less than num_tx_qs, then more than
2726 * one txq share an eq
2727 */
2728 eqo = &adapter->eq_obj[i % adapter->num_evt_qs];
2729 status = be_cmd_cq_create(adapter, cq, &eqo->q, false, 3);
2730 if (status)
2731 return status;
2732
2733 status = be_queue_alloc(adapter, &txo->q, TX_Q_LEN,
2734 sizeof(struct be_eth_wrb));
2735 if (status)
2736 return status;
2737
2738 status = be_cmd_txq_create(adapter, txo);
2739 if (status)
2740 return status;
2741
2742 netif_set_xps_queue(adapter->netdev, eqo->affinity_mask,
2743 eqo->idx);
2744 }
2745
2746 dev_info(&adapter->pdev->dev, "created %d TX queue(s)\n",
2747 adapter->num_tx_qs);
2748 return 0;
2749 }
2750
2751 static void be_rx_cqs_destroy(struct be_adapter *adapter)
2752 {
2753 struct be_queue_info *q;
2754 struct be_rx_obj *rxo;
2755 int i;
2756
2757 for_all_rx_queues(adapter, rxo, i) {
2758 q = &rxo->cq;
2759 if (q->created)
2760 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
2761 be_queue_free(adapter, q);
2762 }
2763 }
2764
2765 static int be_rx_cqs_create(struct be_adapter *adapter)
2766 {
2767 struct be_queue_info *eq, *cq;
2768 struct be_rx_obj *rxo;
2769 int rc, i;
2770
2771 /* We can create as many RSS rings as there are EQs. */
2772 adapter->num_rss_qs = adapter->num_evt_qs;
2773
2774 /* We'll use RSS only if atleast 2 RSS rings are supported. */
2775 if (adapter->num_rss_qs <= 1)
2776 adapter->num_rss_qs = 0;
2777
2778 adapter->num_rx_qs = adapter->num_rss_qs + adapter->need_def_rxq;
2779
2780 /* When the interface is not capable of RSS rings (and there is no
2781 * need to create a default RXQ) we'll still need one RXQ
2782 */
2783 if (adapter->num_rx_qs == 0)
2784 adapter->num_rx_qs = 1;
2785
2786 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
2787 for_all_rx_queues(adapter, rxo, i) {
2788 rxo->adapter = adapter;
2789 cq = &rxo->cq;
2790 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
2791 sizeof(struct be_eth_rx_compl));
2792 if (rc)
2793 return rc;
2794
2795 u64_stats_init(&rxo->stats.sync);
2796 eq = &adapter->eq_obj[i % adapter->num_evt_qs].q;
2797 rc = be_cmd_cq_create(adapter, cq, eq, false, 3);
2798 if (rc)
2799 return rc;
2800 }
2801
2802 dev_info(&adapter->pdev->dev,
2803 "created %d RX queue(s)\n", adapter->num_rx_qs);
2804 return 0;
2805 }
2806
2807 static irqreturn_t be_intx(int irq, void *dev)
2808 {
2809 struct be_eq_obj *eqo = dev;
2810 struct be_adapter *adapter = eqo->adapter;
2811 int num_evts = 0;
2812
2813 /* IRQ is not expected when NAPI is scheduled as the EQ
2814 * will not be armed.
2815 * But, this can happen on Lancer INTx where it takes
2816 * a while to de-assert INTx or in BE2 where occasionaly
2817 * an interrupt may be raised even when EQ is unarmed.
2818 * If NAPI is already scheduled, then counting & notifying
2819 * events will orphan them.
2820 */
2821 if (napi_schedule_prep(&eqo->napi)) {
2822 num_evts = events_get(eqo);
2823 __napi_schedule(&eqo->napi);
2824 if (num_evts)
2825 eqo->spurious_intr = 0;
2826 }
2827 be_eq_notify(adapter, eqo->q.id, false, true, num_evts, 0);
2828
2829 /* Return IRQ_HANDLED only for the the first spurious intr
2830 * after a valid intr to stop the kernel from branding
2831 * this irq as a bad one!
2832 */
2833 if (num_evts || eqo->spurious_intr++ == 0)
2834 return IRQ_HANDLED;
2835 else
2836 return IRQ_NONE;
2837 }
2838
2839 static irqreturn_t be_msix(int irq, void *dev)
2840 {
2841 struct be_eq_obj *eqo = dev;
2842
2843 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
2844 napi_schedule(&eqo->napi);
2845 return IRQ_HANDLED;
2846 }
2847
2848 static inline bool do_gro(struct be_rx_compl_info *rxcp)
2849 {
2850 return (rxcp->tcpf && !rxcp->err && rxcp->l4_csum) ? true : false;
2851 }
2852
2853 static int be_process_rx(struct be_rx_obj *rxo, struct napi_struct *napi,
2854 int budget, int polling)
2855 {
2856 struct be_adapter *adapter = rxo->adapter;
2857 struct be_queue_info *rx_cq = &rxo->cq;
2858 struct be_rx_compl_info *rxcp;
2859 u32 work_done;
2860 u32 frags_consumed = 0;
2861
2862 for (work_done = 0; work_done < budget; work_done++) {
2863 rxcp = be_rx_compl_get(rxo);
2864 if (!rxcp)
2865 break;
2866
2867 /* Is it a flush compl that has no data */
2868 if (unlikely(rxcp->num_rcvd == 0))
2869 goto loop_continue;
2870
2871 /* Discard compl with partial DMA Lancer B0 */
2872 if (unlikely(!rxcp->pkt_size)) {
2873 be_rx_compl_discard(rxo, rxcp);
2874 goto loop_continue;
2875 }
2876
2877 /* On BE drop pkts that arrive due to imperfect filtering in
2878 * promiscuous mode on some skews
2879 */
2880 if (unlikely(rxcp->port != adapter->port_num &&
2881 !lancer_chip(adapter))) {
2882 be_rx_compl_discard(rxo, rxcp);
2883 goto loop_continue;
2884 }
2885
2886 /* Don't do gro when we're busy_polling */
2887 if (do_gro(rxcp) && polling != BUSY_POLLING)
2888 be_rx_compl_process_gro(rxo, napi, rxcp);
2889 else
2890 be_rx_compl_process(rxo, napi, rxcp);
2891
2892 loop_continue:
2893 frags_consumed += rxcp->num_rcvd;
2894 be_rx_stats_update(rxo, rxcp);
2895 }
2896
2897 if (work_done) {
2898 be_cq_notify(adapter, rx_cq->id, true, work_done);
2899
2900 /* When an rx-obj gets into post_starved state, just
2901 * let be_worker do the posting.
2902 */
2903 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM &&
2904 !rxo->rx_post_starved)
2905 be_post_rx_frags(rxo, GFP_ATOMIC,
2906 max_t(u32, MAX_RX_POST,
2907 frags_consumed));
2908 }
2909
2910 return work_done;
2911 }
2912
2913 static inline void be_update_tx_err(struct be_tx_obj *txo, u8 status)
2914 {
2915 switch (status) {
2916 case BE_TX_COMP_HDR_PARSE_ERR:
2917 tx_stats(txo)->tx_hdr_parse_err++;
2918 break;
2919 case BE_TX_COMP_NDMA_ERR:
2920 tx_stats(txo)->tx_dma_err++;
2921 break;
2922 case BE_TX_COMP_ACL_ERR:
2923 tx_stats(txo)->tx_spoof_check_err++;
2924 break;
2925 }
2926 }
2927
2928 static inline void lancer_update_tx_err(struct be_tx_obj *txo, u8 status)
2929 {
2930 switch (status) {
2931 case LANCER_TX_COMP_LSO_ERR:
2932 tx_stats(txo)->tx_tso_err++;
2933 break;
2934 case LANCER_TX_COMP_HSW_DROP_MAC_ERR:
2935 case LANCER_TX_COMP_HSW_DROP_VLAN_ERR:
2936 tx_stats(txo)->tx_spoof_check_err++;
2937 break;
2938 case LANCER_TX_COMP_QINQ_ERR:
2939 tx_stats(txo)->tx_qinq_err++;
2940 break;
2941 case LANCER_TX_COMP_PARITY_ERR:
2942 tx_stats(txo)->tx_internal_parity_err++;
2943 break;
2944 case LANCER_TX_COMP_DMA_ERR:
2945 tx_stats(txo)->tx_dma_err++;
2946 break;
2947 }
2948 }
2949
2950 static void be_process_tx(struct be_adapter *adapter, struct be_tx_obj *txo,
2951 int idx)
2952 {
2953 int num_wrbs = 0, work_done = 0;
2954 struct be_tx_compl_info *txcp;
2955
2956 while ((txcp = be_tx_compl_get(txo))) {
2957 num_wrbs += be_tx_compl_process(adapter, txo, txcp->end_index);
2958 work_done++;
2959
2960 if (txcp->status) {
2961 if (lancer_chip(adapter))
2962 lancer_update_tx_err(txo, txcp->status);
2963 else
2964 be_update_tx_err(txo, txcp->status);
2965 }
2966 }
2967
2968 if (work_done) {
2969 be_cq_notify(adapter, txo->cq.id, true, work_done);
2970 atomic_sub(num_wrbs, &txo->q.used);
2971
2972 /* As Tx wrbs have been freed up, wake up netdev queue
2973 * if it was stopped due to lack of tx wrbs. */
2974 if (__netif_subqueue_stopped(adapter->netdev, idx) &&
2975 be_can_txq_wake(txo)) {
2976 netif_wake_subqueue(adapter->netdev, idx);
2977 }
2978
2979 u64_stats_update_begin(&tx_stats(txo)->sync_compl);
2980 tx_stats(txo)->tx_compl += work_done;
2981 u64_stats_update_end(&tx_stats(txo)->sync_compl);
2982 }
2983 }
2984
2985 #ifdef CONFIG_NET_RX_BUSY_POLL
2986 static inline bool be_lock_napi(struct be_eq_obj *eqo)
2987 {
2988 bool status = true;
2989
2990 spin_lock(&eqo->lock); /* BH is already disabled */
2991 if (eqo->state & BE_EQ_LOCKED) {
2992 WARN_ON(eqo->state & BE_EQ_NAPI);
2993 eqo->state |= BE_EQ_NAPI_YIELD;
2994 status = false;
2995 } else {
2996 eqo->state = BE_EQ_NAPI;
2997 }
2998 spin_unlock(&eqo->lock);
2999 return status;
3000 }
3001
3002 static inline void be_unlock_napi(struct be_eq_obj *eqo)
3003 {
3004 spin_lock(&eqo->lock); /* BH is already disabled */
3005
3006 WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));
3007 eqo->state = BE_EQ_IDLE;
3008
3009 spin_unlock(&eqo->lock);
3010 }
3011
3012 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
3013 {
3014 bool status = true;
3015
3016 spin_lock_bh(&eqo->lock);
3017 if (eqo->state & BE_EQ_LOCKED) {
3018 eqo->state |= BE_EQ_POLL_YIELD;
3019 status = false;
3020 } else {
3021 eqo->state |= BE_EQ_POLL;
3022 }
3023 spin_unlock_bh(&eqo->lock);
3024 return status;
3025 }
3026
3027 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
3028 {
3029 spin_lock_bh(&eqo->lock);
3030
3031 WARN_ON(eqo->state & (BE_EQ_NAPI));
3032 eqo->state = BE_EQ_IDLE;
3033
3034 spin_unlock_bh(&eqo->lock);
3035 }
3036
3037 static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
3038 {
3039 spin_lock_init(&eqo->lock);
3040 eqo->state = BE_EQ_IDLE;
3041 }
3042
3043 static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
3044 {
3045 local_bh_disable();
3046
3047 /* It's enough to just acquire napi lock on the eqo to stop
3048 * be_busy_poll() from processing any queueus.
3049 */
3050 while (!be_lock_napi(eqo))
3051 mdelay(1);
3052
3053 local_bh_enable();
3054 }
3055
3056 #else /* CONFIG_NET_RX_BUSY_POLL */
3057
3058 static inline bool be_lock_napi(struct be_eq_obj *eqo)
3059 {
3060 return true;
3061 }
3062
3063 static inline void be_unlock_napi(struct be_eq_obj *eqo)
3064 {
3065 }
3066
3067 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
3068 {
3069 return false;
3070 }
3071
3072 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
3073 {
3074 }
3075
3076 static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
3077 {
3078 }
3079
3080 static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
3081 {
3082 }
3083 #endif /* CONFIG_NET_RX_BUSY_POLL */
3084
3085 int be_poll(struct napi_struct *napi, int budget)
3086 {
3087 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
3088 struct be_adapter *adapter = eqo->adapter;
3089 int max_work = 0, work, i, num_evts;
3090 struct be_rx_obj *rxo;
3091 struct be_tx_obj *txo;
3092 u32 mult_enc = 0;
3093
3094 num_evts = events_get(eqo);
3095
3096 for_all_tx_queues_on_eq(adapter, eqo, txo, i)
3097 be_process_tx(adapter, txo, i);
3098
3099 if (be_lock_napi(eqo)) {
3100 /* This loop will iterate twice for EQ0 in which
3101 * completions of the last RXQ (default one) are also processed
3102 * For other EQs the loop iterates only once
3103 */
3104 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
3105 work = be_process_rx(rxo, napi, budget, NAPI_POLLING);
3106 max_work = max(work, max_work);
3107 }
3108 be_unlock_napi(eqo);
3109 } else {
3110 max_work = budget;
3111 }
3112
3113 if (is_mcc_eqo(eqo))
3114 be_process_mcc(adapter);
3115
3116 if (max_work < budget) {
3117 napi_complete(napi);
3118
3119 /* Skyhawk EQ_DB has a provision to set the rearm to interrupt
3120 * delay via a delay multiplier encoding value
3121 */
3122 if (skyhawk_chip(adapter))
3123 mult_enc = be_get_eq_delay_mult_enc(eqo);
3124
3125 be_eq_notify(adapter, eqo->q.id, true, false, num_evts,
3126 mult_enc);
3127 } else {
3128 /* As we'll continue in polling mode, count and clear events */
3129 be_eq_notify(adapter, eqo->q.id, false, false, num_evts, 0);
3130 }
3131 return max_work;
3132 }
3133
3134 #ifdef CONFIG_NET_RX_BUSY_POLL
3135 static int be_busy_poll(struct napi_struct *napi)
3136 {
3137 struct be_eq_obj *eqo = container_of(napi, struct be_eq_obj, napi);
3138 struct be_adapter *adapter = eqo->adapter;
3139 struct be_rx_obj *rxo;
3140 int i, work = 0;
3141
3142 if (!be_lock_busy_poll(eqo))
3143 return LL_FLUSH_BUSY;
3144
3145 for_all_rx_queues_on_eq(adapter, eqo, rxo, i) {
3146 work = be_process_rx(rxo, napi, 4, BUSY_POLLING);
3147 if (work)
3148 break;
3149 }
3150
3151 be_unlock_busy_poll(eqo);
3152 return work;
3153 }
3154 #endif
3155
3156 void be_detect_error(struct be_adapter *adapter)
3157 {
3158 u32 ue_lo = 0, ue_hi = 0, ue_lo_mask = 0, ue_hi_mask = 0;
3159 u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;
3160 u32 i;
3161 struct device *dev = &adapter->pdev->dev;
3162
3163 if (be_check_error(adapter, BE_ERROR_HW))
3164 return;
3165
3166 if (lancer_chip(adapter)) {
3167 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
3168 if (sliport_status & SLIPORT_STATUS_ERR_MASK) {
3169 be_set_error(adapter, BE_ERROR_UE);
3170 sliport_err1 = ioread32(adapter->db +
3171 SLIPORT_ERROR1_OFFSET);
3172 sliport_err2 = ioread32(adapter->db +
3173 SLIPORT_ERROR2_OFFSET);
3174 /* Do not log error messages if its a FW reset */
3175 if (sliport_err1 == SLIPORT_ERROR_FW_RESET1 &&
3176 sliport_err2 == SLIPORT_ERROR_FW_RESET2) {
3177 dev_info(dev, "Firmware update in progress\n");
3178 } else {
3179 dev_err(dev, "Error detected in the card\n");
3180 dev_err(dev, "ERR: sliport status 0x%x\n",
3181 sliport_status);
3182 dev_err(dev, "ERR: sliport error1 0x%x\n",
3183 sliport_err1);
3184 dev_err(dev, "ERR: sliport error2 0x%x\n",
3185 sliport_err2);
3186 }
3187 }
3188 } else {
3189 ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW);
3190 ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH);
3191 ue_lo_mask = ioread32(adapter->pcicfg +
3192 PCICFG_UE_STATUS_LOW_MASK);
3193 ue_hi_mask = ioread32(adapter->pcicfg +
3194 PCICFG_UE_STATUS_HI_MASK);
3195
3196 ue_lo = (ue_lo & ~ue_lo_mask);
3197 ue_hi = (ue_hi & ~ue_hi_mask);
3198
3199 /* On certain platforms BE hardware can indicate spurious UEs.
3200 * Allow HW to stop working completely in case of a real UE.
3201 * Hence not setting the hw_error for UE detection.
3202 */
3203
3204 if (ue_lo || ue_hi) {
3205 dev_err(dev,
3206 "Unrecoverable Error detected in the adapter");
3207 dev_err(dev, "Please reboot server to recover");
3208 if (skyhawk_chip(adapter))
3209 be_set_error(adapter, BE_ERROR_UE);
3210
3211 for (i = 0; ue_lo; ue_lo >>= 1, i++) {
3212 if (ue_lo & 1)
3213 dev_err(dev, "UE: %s bit set\n",
3214 ue_status_low_desc[i]);
3215 }
3216 for (i = 0; ue_hi; ue_hi >>= 1, i++) {
3217 if (ue_hi & 1)
3218 dev_err(dev, "UE: %s bit set\n",
3219 ue_status_hi_desc[i]);
3220 }
3221 }
3222 }
3223 }
3224
3225 static void be_msix_disable(struct be_adapter *adapter)
3226 {
3227 if (msix_enabled(adapter)) {
3228 pci_disable_msix(adapter->pdev);
3229 adapter->num_msix_vec = 0;
3230 adapter->num_msix_roce_vec = 0;
3231 }
3232 }
3233
3234 static int be_msix_enable(struct be_adapter *adapter)
3235 {
3236 int i, num_vec;
3237 struct device *dev = &adapter->pdev->dev;
3238
3239 /* If RoCE is supported, program the max number of NIC vectors that
3240 * may be configured via set-channels, along with vectors needed for
3241 * RoCe. Else, just program the number we'll use initially.
3242 */
3243 if (be_roce_supported(adapter))
3244 num_vec = min_t(int, 2 * be_max_eqs(adapter),
3245 2 * num_online_cpus());
3246 else
3247 num_vec = adapter->cfg_num_qs;
3248
3249 for (i = 0; i < num_vec; i++)
3250 adapter->msix_entries[i].entry = i;
3251
3252 num_vec = pci_enable_msix_range(adapter->pdev, adapter->msix_entries,
3253 MIN_MSIX_VECTORS, num_vec);
3254 if (num_vec < 0)
3255 goto fail;
3256
3257 if (be_roce_supported(adapter) && num_vec > MIN_MSIX_VECTORS) {
3258 adapter->num_msix_roce_vec = num_vec / 2;
3259 dev_info(dev, "enabled %d MSI-x vector(s) for RoCE\n",
3260 adapter->num_msix_roce_vec);
3261 }
3262
3263 adapter->num_msix_vec = num_vec - adapter->num_msix_roce_vec;
3264
3265 dev_info(dev, "enabled %d MSI-x vector(s) for NIC\n",
3266 adapter->num_msix_vec);
3267 return 0;
3268
3269 fail:
3270 dev_warn(dev, "MSIx enable failed\n");
3271
3272 /* INTx is not supported in VFs, so fail probe if enable_msix fails */
3273 if (be_virtfn(adapter))
3274 return num_vec;
3275 return 0;
3276 }
3277
3278 static inline int be_msix_vec_get(struct be_adapter *adapter,
3279 struct be_eq_obj *eqo)
3280 {
3281 return adapter->msix_entries[eqo->msix_idx].vector;
3282 }
3283
3284 static int be_msix_register(struct be_adapter *adapter)
3285 {
3286 struct net_device *netdev = adapter->netdev;
3287 struct be_eq_obj *eqo;
3288 int status, i, vec;
3289
3290 for_all_evt_queues(adapter, eqo, i) {
3291 sprintf(eqo->desc, "%s-q%d", netdev->name, i);
3292 vec = be_msix_vec_get(adapter, eqo);
3293 status = request_irq(vec, be_msix, 0, eqo->desc, eqo);
3294 if (status)
3295 goto err_msix;
3296
3297 irq_set_affinity_hint(vec, eqo->affinity_mask);
3298 }
3299
3300 return 0;
3301 err_msix:
3302 for (i--, eqo = &adapter->eq_obj[i]; i >= 0; i--, eqo--)
3303 free_irq(be_msix_vec_get(adapter, eqo), eqo);
3304 dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
3305 status);
3306 be_msix_disable(adapter);
3307 return status;
3308 }
3309
3310 static int be_irq_register(struct be_adapter *adapter)
3311 {
3312 struct net_device *netdev = adapter->netdev;
3313 int status;
3314
3315 if (msix_enabled(adapter)) {
3316 status = be_msix_register(adapter);
3317 if (status == 0)
3318 goto done;
3319 /* INTx is not supported for VF */
3320 if (be_virtfn(adapter))
3321 return status;
3322 }
3323
3324 /* INTx: only the first EQ is used */
3325 netdev->irq = adapter->pdev->irq;
3326 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
3327 &adapter->eq_obj[0]);
3328 if (status) {
3329 dev_err(&adapter->pdev->dev,
3330 "INTx request IRQ failed - err %d\n", status);
3331 return status;
3332 }
3333 done:
3334 adapter->isr_registered = true;
3335 return 0;
3336 }
3337
3338 static void be_irq_unregister(struct be_adapter *adapter)
3339 {
3340 struct net_device *netdev = adapter->netdev;
3341 struct be_eq_obj *eqo;
3342 int i, vec;
3343
3344 if (!adapter->isr_registered)
3345 return;
3346
3347 /* INTx */
3348 if (!msix_enabled(adapter)) {
3349 free_irq(netdev->irq, &adapter->eq_obj[0]);
3350 goto done;
3351 }
3352
3353 /* MSIx */
3354 for_all_evt_queues(adapter, eqo, i) {
3355 vec = be_msix_vec_get(adapter, eqo);
3356 irq_set_affinity_hint(vec, NULL);
3357 free_irq(vec, eqo);
3358 }
3359
3360 done:
3361 adapter->isr_registered = false;
3362 }
3363
3364 static void be_rx_qs_destroy(struct be_adapter *adapter)
3365 {
3366 struct be_queue_info *q;
3367 struct be_rx_obj *rxo;
3368 int i;
3369
3370 for_all_rx_queues(adapter, rxo, i) {
3371 q = &rxo->q;
3372 if (q->created) {
3373 /* If RXQs are destroyed while in an "out of buffer"
3374 * state, there is a possibility of an HW stall on
3375 * Lancer. So, post 64 buffers to each queue to relieve
3376 * the "out of buffer" condition.
3377 * Make sure there's space in the RXQ before posting.
3378 */
3379 if (lancer_chip(adapter)) {
3380 be_rx_cq_clean(rxo);
3381 if (atomic_read(&q->used) == 0)
3382 be_post_rx_frags(rxo, GFP_KERNEL,
3383 MAX_RX_POST);
3384 }
3385
3386 be_cmd_rxq_destroy(adapter, q);
3387 be_rx_cq_clean(rxo);
3388 be_rxq_clean(rxo);
3389 }
3390 be_queue_free(adapter, q);
3391 }
3392 }
3393
3394 static void be_disable_if_filters(struct be_adapter *adapter)
3395 {
3396 be_cmd_pmac_del(adapter, adapter->if_handle,
3397 adapter->pmac_id[0], 0);
3398
3399 be_clear_uc_list(adapter);
3400
3401 /* The IFACE flags are enabled in the open path and cleared
3402 * in the close path. When a VF gets detached from the host and
3403 * assigned to a VM the following happens:
3404 * - VF's IFACE flags get cleared in the detach path
3405 * - IFACE create is issued by the VF in the attach path
3406 * Due to a bug in the BE3/Skyhawk-R FW
3407 * (Lancer FW doesn't have the bug), the IFACE capability flags
3408 * specified along with the IFACE create cmd issued by a VF are not
3409 * honoured by FW. As a consequence, if a *new* driver
3410 * (that enables/disables IFACE flags in open/close)
3411 * is loaded in the host and an *old* driver is * used by a VM/VF,
3412 * the IFACE gets created *without* the needed flags.
3413 * To avoid this, disable RX-filter flags only for Lancer.
3414 */
3415 if (lancer_chip(adapter)) {
3416 be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF);
3417 adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS;
3418 }
3419 }
3420
3421 static int be_close(struct net_device *netdev)
3422 {
3423 struct be_adapter *adapter = netdev_priv(netdev);
3424 struct be_eq_obj *eqo;
3425 int i;
3426
3427 /* This protection is needed as be_close() may be called even when the
3428 * adapter is in cleared state (after eeh perm failure)
3429 */
3430 if (!(adapter->flags & BE_FLAGS_SETUP_DONE))
3431 return 0;
3432
3433 be_disable_if_filters(adapter);
3434
3435 be_roce_dev_close(adapter);
3436
3437 if (adapter->flags & BE_FLAGS_NAPI_ENABLED) {
3438 for_all_evt_queues(adapter, eqo, i) {
3439 napi_disable(&eqo->napi);
3440 be_disable_busy_poll(eqo);
3441 }
3442 adapter->flags &= ~BE_FLAGS_NAPI_ENABLED;
3443 }
3444
3445 be_async_mcc_disable(adapter);
3446
3447 /* Wait for all pending tx completions to arrive so that
3448 * all tx skbs are freed.
3449 */
3450 netif_tx_disable(netdev);
3451 be_tx_compl_clean(adapter);
3452
3453 be_rx_qs_destroy(adapter);
3454
3455 for_all_evt_queues(adapter, eqo, i) {
3456 if (msix_enabled(adapter))
3457 synchronize_irq(be_msix_vec_get(adapter, eqo));
3458 else
3459 synchronize_irq(netdev->irq);
3460 be_eq_clean(eqo);
3461 }
3462
3463 be_irq_unregister(adapter);
3464
3465 return 0;
3466 }
3467
3468 static int be_rx_qs_create(struct be_adapter *adapter)
3469 {
3470 struct rss_info *rss = &adapter->rss_info;
3471 u8 rss_key[RSS_HASH_KEY_LEN];
3472 struct be_rx_obj *rxo;
3473 int rc, i, j;
3474
3475 for_all_rx_queues(adapter, rxo, i) {
3476 rc = be_queue_alloc(adapter, &rxo->q, RX_Q_LEN,
3477 sizeof(struct be_eth_rx_d));
3478 if (rc)
3479 return rc;
3480 }
3481
3482 if (adapter->need_def_rxq || !adapter->num_rss_qs) {
3483 rxo = default_rxo(adapter);
3484 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
3485 rx_frag_size, adapter->if_handle,
3486 false, &rxo->rss_id);
3487 if (rc)
3488 return rc;
3489 }
3490
3491 for_all_rss_queues(adapter, rxo, i) {
3492 rc = be_cmd_rxq_create(adapter, &rxo->q, rxo->cq.id,
3493 rx_frag_size, adapter->if_handle,
3494 true, &rxo->rss_id);
3495 if (rc)
3496 return rc;
3497 }
3498
3499 if (be_multi_rxq(adapter)) {
3500 for (j = 0; j < RSS_INDIR_TABLE_LEN; j += adapter->num_rss_qs) {
3501 for_all_rss_queues(adapter, rxo, i) {
3502 if ((j + i) >= RSS_INDIR_TABLE_LEN)
3503 break;
3504 rss->rsstable[j + i] = rxo->rss_id;
3505 rss->rss_queue[j + i] = i;
3506 }
3507 }
3508 rss->rss_flags = RSS_ENABLE_TCP_IPV4 | RSS_ENABLE_IPV4 |
3509 RSS_ENABLE_TCP_IPV6 | RSS_ENABLE_IPV6;
3510
3511 if (!BEx_chip(adapter))
3512 rss->rss_flags |= RSS_ENABLE_UDP_IPV4 |
3513 RSS_ENABLE_UDP_IPV6;
3514 } else {
3515 /* Disable RSS, if only default RX Q is created */
3516 rss->rss_flags = RSS_ENABLE_NONE;
3517 }
3518
3519 netdev_rss_key_fill(rss_key, RSS_HASH_KEY_LEN);
3520 rc = be_cmd_rss_config(adapter, rss->rsstable, rss->rss_flags,
3521 RSS_INDIR_TABLE_LEN, rss_key);
3522 if (rc) {
3523 rss->rss_flags = RSS_ENABLE_NONE;
3524 return rc;
3525 }
3526
3527 memcpy(rss->rss_hkey, rss_key, RSS_HASH_KEY_LEN);
3528
3529 /* Post 1 less than RXQ-len to avoid head being equal to tail,
3530 * which is a queue empty condition
3531 */
3532 for_all_rx_queues(adapter, rxo, i)
3533 be_post_rx_frags(rxo, GFP_KERNEL, RX_Q_LEN - 1);
3534
3535 return 0;
3536 }
3537
3538 static int be_enable_if_filters(struct be_adapter *adapter)
3539 {
3540 int status;
3541
3542 status = be_cmd_rx_filter(adapter, BE_IF_EN_FLAGS, ON);
3543 if (status)
3544 return status;
3545
3546 /* For BE3 VFs, the PF programs the initial MAC address */
3547 if (!(BEx_chip(adapter) && be_virtfn(adapter))) {
3548 status = be_cmd_pmac_add(adapter, adapter->netdev->dev_addr,
3549 adapter->if_handle,
3550 &adapter->pmac_id[0], 0);
3551 if (status)
3552 return status;
3553 }
3554
3555 if (adapter->vlans_added)
3556 be_vid_config(adapter);
3557
3558 be_set_rx_mode(adapter->netdev);
3559
3560 return 0;
3561 }
3562
3563 static int be_open(struct net_device *netdev)
3564 {
3565 struct be_adapter *adapter = netdev_priv(netdev);
3566 struct be_eq_obj *eqo;
3567 struct be_rx_obj *rxo;
3568 struct be_tx_obj *txo;
3569 u8 link_status;
3570 int status, i;
3571
3572 status = be_rx_qs_create(adapter);
3573 if (status)
3574 goto err;
3575
3576 status = be_enable_if_filters(adapter);
3577 if (status)
3578 goto err;
3579
3580 status = be_irq_register(adapter);
3581 if (status)
3582 goto err;
3583
3584 for_all_rx_queues(adapter, rxo, i)
3585 be_cq_notify(adapter, rxo->cq.id, true, 0);
3586
3587 for_all_tx_queues(adapter, txo, i)
3588 be_cq_notify(adapter, txo->cq.id, true, 0);
3589
3590 be_async_mcc_enable(adapter);
3591
3592 for_all_evt_queues(adapter, eqo, i) {
3593 napi_enable(&eqo->napi);
3594 be_enable_busy_poll(eqo);
3595 be_eq_notify(adapter, eqo->q.id, true, true, 0, 0);
3596 }
3597 adapter->flags |= BE_FLAGS_NAPI_ENABLED;
3598
3599 status = be_cmd_link_status_query(adapter, NULL, &link_status, 0);
3600 if (!status)
3601 be_link_status_update(adapter, link_status);
3602
3603 netif_tx_start_all_queues(netdev);
3604 be_roce_dev_open(adapter);
3605
3606 #ifdef CONFIG_BE2NET_VXLAN
3607 if (skyhawk_chip(adapter))
3608 vxlan_get_rx_port(netdev);
3609 #endif
3610
3611 return 0;
3612 err:
3613 be_close(adapter->netdev);
3614 return -EIO;
3615 }
3616
3617 static int be_setup_wol(struct be_adapter *adapter, bool enable)
3618 {
3619 struct device *dev = &adapter->pdev->dev;
3620 struct be_dma_mem cmd;
3621 u8 mac[ETH_ALEN];
3622 int status;
3623
3624 eth_zero_addr(mac);
3625
3626 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
3627 cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
3628 if (!cmd.va)
3629 return -ENOMEM;
3630
3631 if (enable) {
3632 status = pci_write_config_dword(adapter->pdev,
3633 PCICFG_PM_CONTROL_OFFSET,
3634 PCICFG_PM_CONTROL_MASK);
3635 if (status) {
3636 dev_err(dev, "Could not enable Wake-on-lan\n");
3637 goto err;
3638 }
3639 } else {
3640 ether_addr_copy(mac, adapter->netdev->dev_addr);
3641 }
3642
3643 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
3644 pci_enable_wake(adapter->pdev, PCI_D3hot, enable);
3645 pci_enable_wake(adapter->pdev, PCI_D3cold, enable);
3646 err:
3647 dma_free_coherent(dev, cmd.size, cmd.va, cmd.dma);
3648 return status;
3649 }
3650
3651 static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
3652 {
3653 u32 addr;
3654
3655 addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);
3656
3657 mac[5] = (u8)(addr & 0xFF);
3658 mac[4] = (u8)((addr >> 8) & 0xFF);
3659 mac[3] = (u8)((addr >> 16) & 0xFF);
3660 /* Use the OUI from the current MAC address */
3661 memcpy(mac, adapter->netdev->dev_addr, 3);
3662 }
3663
3664 /*
3665 * Generate a seed MAC address from the PF MAC Address using jhash.
3666 * MAC Address for VFs are assigned incrementally starting from the seed.
3667 * These addresses are programmed in the ASIC by the PF and the VF driver
3668 * queries for the MAC address during its probe.
3669 */
3670 static int be_vf_eth_addr_config(struct be_adapter *adapter)
3671 {
3672 u32 vf;
3673 int status = 0;
3674 u8 mac[ETH_ALEN];
3675 struct be_vf_cfg *vf_cfg;
3676
3677 be_vf_eth_addr_generate(adapter, mac);
3678
3679 for_all_vfs(adapter, vf_cfg, vf) {
3680 if (BEx_chip(adapter))
3681 status = be_cmd_pmac_add(adapter, mac,
3682 vf_cfg->if_handle,
3683 &vf_cfg->pmac_id, vf + 1);
3684 else
3685 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
3686 vf + 1);
3687
3688 if (status)
3689 dev_err(&adapter->pdev->dev,
3690 "Mac address assignment failed for VF %d\n",
3691 vf);
3692 else
3693 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3694
3695 mac[5] += 1;
3696 }
3697 return status;
3698 }
3699
3700 static int be_vfs_mac_query(struct be_adapter *adapter)
3701 {
3702 int status, vf;
3703 u8 mac[ETH_ALEN];
3704 struct be_vf_cfg *vf_cfg;
3705
3706 for_all_vfs(adapter, vf_cfg, vf) {
3707 status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id,
3708 mac, vf_cfg->if_handle,
3709 false, vf+1);
3710 if (status)
3711 return status;
3712 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3713 }
3714 return 0;
3715 }
3716
3717 static void be_vf_clear(struct be_adapter *adapter)
3718 {
3719 struct be_vf_cfg *vf_cfg;
3720 u32 vf;
3721
3722 if (pci_vfs_assigned(adapter->pdev)) {
3723 dev_warn(&adapter->pdev->dev,
3724 "VFs are assigned to VMs: not disabling VFs\n");
3725 goto done;
3726 }
3727
3728 pci_disable_sriov(adapter->pdev);
3729
3730 for_all_vfs(adapter, vf_cfg, vf) {
3731 if (BEx_chip(adapter))
3732 be_cmd_pmac_del(adapter, vf_cfg->if_handle,
3733 vf_cfg->pmac_id, vf + 1);
3734 else
3735 be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle,
3736 vf + 1);
3737
3738 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
3739 }
3740 done:
3741 kfree(adapter->vf_cfg);
3742 adapter->num_vfs = 0;
3743 adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED;
3744 }
3745
3746 static void be_clear_queues(struct be_adapter *adapter)
3747 {
3748 be_mcc_queues_destroy(adapter);
3749 be_rx_cqs_destroy(adapter);
3750 be_tx_queues_destroy(adapter);
3751 be_evt_queues_destroy(adapter);
3752 }
3753
3754 static void be_cancel_worker(struct be_adapter *adapter)
3755 {
3756 if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
3757 cancel_delayed_work_sync(&adapter->work);
3758 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
3759 }
3760 }
3761
3762 static void be_cancel_err_detection(struct be_adapter *adapter)
3763 {
3764 if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) {
3765 cancel_delayed_work_sync(&adapter->be_err_detection_work);
3766 adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED;
3767 }
3768 }
3769
3770 #ifdef CONFIG_BE2NET_VXLAN
3771 static void be_disable_vxlan_offloads(struct be_adapter *adapter)
3772 {
3773 struct net_device *netdev = adapter->netdev;
3774
3775 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)
3776 be_cmd_manage_iface(adapter, adapter->if_handle,
3777 OP_CONVERT_TUNNEL_TO_NORMAL);
3778
3779 if (adapter->vxlan_port)
3780 be_cmd_set_vxlan_port(adapter, 0);
3781
3782 adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS;
3783 adapter->vxlan_port = 0;
3784
3785 netdev->hw_enc_features = 0;
3786 netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3787 netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3788 }
3789 #endif
3790
3791 static u16 be_calculate_vf_qs(struct be_adapter *adapter, u16 num_vfs)
3792 {
3793 struct be_resources res = adapter->pool_res;
3794 u16 num_vf_qs = 1;
3795
3796 /* Distribute the queue resources equally among the PF and it's VFs
3797 * Do not distribute queue resources in multi-channel configuration.
3798 */
3799 if (num_vfs && !be_is_mc(adapter)) {
3800 /* If number of VFs requested is 8 less than max supported,
3801 * assign 8 queue pairs to the PF and divide the remaining
3802 * resources evenly among the VFs
3803 */
3804 if (num_vfs < (be_max_vfs(adapter) - 8))
3805 num_vf_qs = (res.max_rss_qs - 8) / num_vfs;
3806 else
3807 num_vf_qs = res.max_rss_qs / num_vfs;
3808
3809 /* Skyhawk-R chip supports only MAX_RSS_IFACES RSS capable
3810 * interfaces per port. Provide RSS on VFs, only if number
3811 * of VFs requested is less than MAX_RSS_IFACES limit.
3812 */
3813 if (num_vfs >= MAX_RSS_IFACES)
3814 num_vf_qs = 1;
3815 }
3816 return num_vf_qs;
3817 }
3818
3819 static int be_clear(struct be_adapter *adapter)
3820 {
3821 struct pci_dev *pdev = adapter->pdev;
3822 u16 num_vf_qs;
3823
3824 be_cancel_worker(adapter);
3825
3826 if (sriov_enabled(adapter))
3827 be_vf_clear(adapter);
3828
3829 /* Re-configure FW to distribute resources evenly across max-supported
3830 * number of VFs, only when VFs are not already enabled.
3831 */
3832 if (skyhawk_chip(adapter) && be_physfn(adapter) &&
3833 !pci_vfs_assigned(pdev)) {
3834 num_vf_qs = be_calculate_vf_qs(adapter,
3835 pci_sriov_get_totalvfs(pdev));
3836 be_cmd_set_sriov_config(adapter, adapter->pool_res,
3837 pci_sriov_get_totalvfs(pdev),
3838 num_vf_qs);
3839 }
3840
3841 #ifdef CONFIG_BE2NET_VXLAN
3842 be_disable_vxlan_offloads(adapter);
3843 #endif
3844 kfree(adapter->pmac_id);
3845 adapter->pmac_id = NULL;
3846
3847 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
3848
3849 be_clear_queues(adapter);
3850
3851 be_msix_disable(adapter);
3852 adapter->flags &= ~BE_FLAGS_SETUP_DONE;
3853 return 0;
3854 }
3855
3856 static int be_vfs_if_create(struct be_adapter *adapter)
3857 {
3858 struct be_resources res = {0};
3859 u32 cap_flags, en_flags, vf;
3860 struct be_vf_cfg *vf_cfg;
3861 int status;
3862
3863 /* If a FW profile exists, then cap_flags are updated */
3864 cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3865 BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3866
3867 for_all_vfs(adapter, vf_cfg, vf) {
3868 if (!BE3_chip(adapter)) {
3869 status = be_cmd_get_profile_config(adapter, &res,
3870 RESOURCE_LIMITS,
3871 vf + 1);
3872 if (!status) {
3873 cap_flags = res.if_cap_flags;
3874 /* Prevent VFs from enabling VLAN promiscuous
3875 * mode
3876 */
3877 cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
3878 }
3879 }
3880
3881 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
3882 BE_IF_FLAGS_BROADCAST |
3883 BE_IF_FLAGS_MULTICAST |
3884 BE_IF_FLAGS_PASS_L3L4_ERRORS);
3885 status = be_cmd_if_create(adapter, cap_flags, en_flags,
3886 &vf_cfg->if_handle, vf + 1);
3887 if (status)
3888 return status;
3889 }
3890
3891 return 0;
3892 }
3893
3894 static int be_vf_setup_init(struct be_adapter *adapter)
3895 {
3896 struct be_vf_cfg *vf_cfg;
3897 int vf;
3898
3899 adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
3900 GFP_KERNEL);
3901 if (!adapter->vf_cfg)
3902 return -ENOMEM;
3903
3904 for_all_vfs(adapter, vf_cfg, vf) {
3905 vf_cfg->if_handle = -1;
3906 vf_cfg->pmac_id = -1;
3907 }
3908 return 0;
3909 }
3910
3911 static int be_vf_setup(struct be_adapter *adapter)
3912 {
3913 struct device *dev = &adapter->pdev->dev;
3914 struct be_vf_cfg *vf_cfg;
3915 int status, old_vfs, vf;
3916 bool spoofchk;
3917
3918 old_vfs = pci_num_vf(adapter->pdev);
3919
3920 status = be_vf_setup_init(adapter);
3921 if (status)
3922 goto err;
3923
3924 if (old_vfs) {
3925 for_all_vfs(adapter, vf_cfg, vf) {
3926 status = be_cmd_get_if_id(adapter, vf_cfg, vf);
3927 if (status)
3928 goto err;
3929 }
3930
3931 status = be_vfs_mac_query(adapter);
3932 if (status)
3933 goto err;
3934 } else {
3935 status = be_vfs_if_create(adapter);
3936 if (status)
3937 goto err;
3938
3939 status = be_vf_eth_addr_config(adapter);
3940 if (status)
3941 goto err;
3942 }
3943
3944 for_all_vfs(adapter, vf_cfg, vf) {
3945 /* Allow VFs to programs MAC/VLAN filters */
3946 status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges,
3947 vf + 1);
3948 if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
3949 status = be_cmd_set_fn_privileges(adapter,
3950 vf_cfg->privileges |
3951 BE_PRIV_FILTMGMT,
3952 vf + 1);
3953 if (!status) {
3954 vf_cfg->privileges |= BE_PRIV_FILTMGMT;
3955 dev_info(dev, "VF%d has FILTMGMT privilege\n",
3956 vf);
3957 }
3958 }
3959
3960 /* Allow full available bandwidth */
3961 if (!old_vfs)
3962 be_cmd_config_qos(adapter, 0, 0, vf + 1);
3963
3964 status = be_cmd_get_hsw_config(adapter, NULL, vf + 1,
3965 vf_cfg->if_handle, NULL,
3966 &spoofchk);
3967 if (!status)
3968 vf_cfg->spoofchk = spoofchk;
3969
3970 if (!old_vfs) {
3971 be_cmd_enable_vf(adapter, vf + 1);
3972 be_cmd_set_logical_link_config(adapter,
3973 IFLA_VF_LINK_STATE_AUTO,
3974 vf+1);
3975 }
3976 }
3977
3978 if (!old_vfs) {
3979 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
3980 if (status) {
3981 dev_err(dev, "SRIOV enable failed\n");
3982 adapter->num_vfs = 0;
3983 goto err;
3984 }
3985 }
3986
3987 adapter->flags |= BE_FLAGS_SRIOV_ENABLED;
3988 return 0;
3989 err:
3990 dev_err(dev, "VF setup failed\n");
3991 be_vf_clear(adapter);
3992 return status;
3993 }
3994
3995 /* Converting function_mode bits on BE3 to SH mc_type enums */
3996
3997 static u8 be_convert_mc_type(u32 function_mode)
3998 {
3999 if (function_mode & VNIC_MODE && function_mode & QNQ_MODE)
4000 return vNIC1;
4001 else if (function_mode & QNQ_MODE)
4002 return FLEX10;
4003 else if (function_mode & VNIC_MODE)
4004 return vNIC2;
4005 else if (function_mode & UMC_ENABLED)
4006 return UMC;
4007 else
4008 return MC_NONE;
4009 }
4010
4011 /* On BE2/BE3 FW does not suggest the supported limits */
4012 static void BEx_get_resources(struct be_adapter *adapter,
4013 struct be_resources *res)
4014 {
4015 bool use_sriov = adapter->num_vfs ? 1 : 0;
4016
4017 if (be_physfn(adapter))
4018 res->max_uc_mac = BE_UC_PMAC_COUNT;
4019 else
4020 res->max_uc_mac = BE_VF_UC_PMAC_COUNT;
4021
4022 adapter->mc_type = be_convert_mc_type(adapter->function_mode);
4023
4024 if (be_is_mc(adapter)) {
4025 /* Assuming that there are 4 channels per port,
4026 * when multi-channel is enabled
4027 */
4028 if (be_is_qnq_mode(adapter))
4029 res->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
4030 else
4031 /* In a non-qnq multichannel mode, the pvid
4032 * takes up one vlan entry
4033 */
4034 res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1;
4035 } else {
4036 res->max_vlans = BE_NUM_VLANS_SUPPORTED;
4037 }
4038
4039 res->max_mcast_mac = BE_MAX_MC;
4040
4041 /* 1) For BE3 1Gb ports, FW does not support multiple TXQs
4042 * 2) Create multiple TX rings on a BE3-R multi-channel interface
4043 * *only* if it is RSS-capable.
4044 */
4045 if (BE2_chip(adapter) || use_sriov || (adapter->port_num > 1) ||
4046 be_virtfn(adapter) ||
4047 (be_is_mc(adapter) &&
4048 !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) {
4049 res->max_tx_qs = 1;
4050 } else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) {
4051 struct be_resources super_nic_res = {0};
4052
4053 /* On a SuperNIC profile, the driver needs to use the
4054 * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits
4055 */
4056 be_cmd_get_profile_config(adapter, &super_nic_res,
4057 RESOURCE_LIMITS, 0);
4058 /* Some old versions of BE3 FW don't report max_tx_qs value */
4059 res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS;
4060 } else {
4061 res->max_tx_qs = BE3_MAX_TX_QS;
4062 }
4063
4064 if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
4065 !use_sriov && be_physfn(adapter))
4066 res->max_rss_qs = (adapter->be3_native) ?
4067 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
4068 res->max_rx_qs = res->max_rss_qs + 1;
4069
4070 if (be_physfn(adapter))
4071 res->max_evt_qs = (be_max_vfs(adapter) > 0) ?
4072 BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS;
4073 else
4074 res->max_evt_qs = 1;
4075
4076 res->if_cap_flags = BE_IF_CAP_FLAGS_WANT;
4077 res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS;
4078 if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS))
4079 res->if_cap_flags &= ~BE_IF_FLAGS_RSS;
4080 }
4081
4082 static void be_setup_init(struct be_adapter *adapter)
4083 {
4084 adapter->vlan_prio_bmap = 0xff;
4085 adapter->phy.link_speed = -1;
4086 adapter->if_handle = -1;
4087 adapter->be3_native = false;
4088 adapter->if_flags = 0;
4089 if (be_physfn(adapter))
4090 adapter->cmd_privileges = MAX_PRIVILEGES;
4091 else
4092 adapter->cmd_privileges = MIN_PRIVILEGES;
4093 }
4094
4095 static int be_get_sriov_config(struct be_adapter *adapter)
4096 {
4097 struct be_resources res = {0};
4098 int max_vfs, old_vfs;
4099
4100 be_cmd_get_profile_config(adapter, &res, RESOURCE_LIMITS, 0);
4101
4102 /* Some old versions of BE3 FW don't report max_vfs value */
4103 if (BE3_chip(adapter) && !res.max_vfs) {
4104 max_vfs = pci_sriov_get_totalvfs(adapter->pdev);
4105 res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0;
4106 }
4107
4108 adapter->pool_res = res;
4109
4110 /* If during previous unload of the driver, the VFs were not disabled,
4111 * then we cannot rely on the PF POOL limits for the TotalVFs value.
4112 * Instead use the TotalVFs value stored in the pci-dev struct.
4113 */
4114 old_vfs = pci_num_vf(adapter->pdev);
4115 if (old_vfs) {
4116 dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n",
4117 old_vfs);
4118
4119 adapter->pool_res.max_vfs =
4120 pci_sriov_get_totalvfs(adapter->pdev);
4121 adapter->num_vfs = old_vfs;
4122 }
4123
4124 return 0;
4125 }
4126
4127 static void be_alloc_sriov_res(struct be_adapter *adapter)
4128 {
4129 int old_vfs = pci_num_vf(adapter->pdev);
4130 u16 num_vf_qs;
4131 int status;
4132
4133 be_get_sriov_config(adapter);
4134
4135 if (!old_vfs)
4136 pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter));
4137
4138 /* When the HW is in SRIOV capable configuration, the PF-pool
4139 * resources are given to PF during driver load, if there are no
4140 * old VFs. This facility is not available in BE3 FW.
4141 * Also, this is done by FW in Lancer chip.
4142 */
4143 if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) {
4144 num_vf_qs = be_calculate_vf_qs(adapter, 0);
4145 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0,
4146 num_vf_qs);
4147 if (status)
4148 dev_err(&adapter->pdev->dev,
4149 "Failed to optimize SRIOV resources\n");
4150 }
4151 }
4152
4153 static int be_get_resources(struct be_adapter *adapter)
4154 {
4155 struct device *dev = &adapter->pdev->dev;
4156 struct be_resources res = {0};
4157 int status;
4158
4159 if (BEx_chip(adapter)) {
4160 BEx_get_resources(adapter, &res);
4161 adapter->res = res;
4162 }
4163
4164 /* For Lancer, SH etc read per-function resource limits from FW.
4165 * GET_FUNC_CONFIG returns per function guaranteed limits.
4166 * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits
4167 */
4168 if (!BEx_chip(adapter)) {
4169 status = be_cmd_get_func_config(adapter, &res);
4170 if (status)
4171 return status;
4172
4173 /* If a deafault RXQ must be created, we'll use up one RSSQ*/
4174 if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs &&
4175 !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS))
4176 res.max_rss_qs -= 1;
4177
4178 /* If RoCE may be enabled stash away half the EQs for RoCE */
4179 if (be_roce_supported(adapter))
4180 res.max_evt_qs /= 2;
4181 adapter->res = res;
4182 }
4183
4184 /* If FW supports RSS default queue, then skip creating non-RSS
4185 * queue for non-IP traffic.
4186 */
4187 adapter->need_def_rxq = (be_if_cap_flags(adapter) &
4188 BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1;
4189
4190 dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n",
4191 be_max_txqs(adapter), be_max_rxqs(adapter),
4192 be_max_rss(adapter), be_max_eqs(adapter),
4193 be_max_vfs(adapter));
4194 dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n",
4195 be_max_uc(adapter), be_max_mc(adapter),
4196 be_max_vlans(adapter));
4197
4198 /* Sanitize cfg_num_qs based on HW and platform limits */
4199 adapter->cfg_num_qs = min_t(u16, netif_get_num_default_rss_queues(),
4200 be_max_qs(adapter));
4201 return 0;
4202 }
4203
4204 static int be_get_config(struct be_adapter *adapter)
4205 {
4206 int status, level;
4207 u16 profile_id;
4208
4209 status = be_cmd_query_fw_cfg(adapter);
4210 if (status)
4211 return status;
4212
4213 if (BEx_chip(adapter)) {
4214 level = be_cmd_get_fw_log_level(adapter);
4215 adapter->msg_enable =
4216 level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
4217 }
4218
4219 be_cmd_get_acpi_wol_cap(adapter);
4220
4221 be_cmd_query_port_name(adapter);
4222
4223 if (be_physfn(adapter)) {
4224 status = be_cmd_get_active_profile(adapter, &profile_id);
4225 if (!status)
4226 dev_info(&adapter->pdev->dev,
4227 "Using profile 0x%x\n", profile_id);
4228 }
4229
4230 status = be_get_resources(adapter);
4231 if (status)
4232 return status;
4233
4234 adapter->pmac_id = kcalloc(be_max_uc(adapter),
4235 sizeof(*adapter->pmac_id), GFP_KERNEL);
4236 if (!adapter->pmac_id)
4237 return -ENOMEM;
4238
4239 return 0;
4240 }
4241
4242 static int be_mac_setup(struct be_adapter *adapter)
4243 {
4244 u8 mac[ETH_ALEN];
4245 int status;
4246
4247 if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
4248 status = be_cmd_get_perm_mac(adapter, mac);
4249 if (status)
4250 return status;
4251
4252 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
4253 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
4254 }
4255
4256 return 0;
4257 }
4258
4259 static void be_schedule_worker(struct be_adapter *adapter)
4260 {
4261 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
4262 adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
4263 }
4264
4265 static void be_schedule_err_detection(struct be_adapter *adapter)
4266 {
4267 schedule_delayed_work(&adapter->be_err_detection_work,
4268 msecs_to_jiffies(1000));
4269 adapter->flags |= BE_FLAGS_ERR_DETECTION_SCHEDULED;
4270 }
4271
4272 static int be_setup_queues(struct be_adapter *adapter)
4273 {
4274 struct net_device *netdev = adapter->netdev;
4275 int status;
4276
4277 status = be_evt_queues_create(adapter);
4278 if (status)
4279 goto err;
4280
4281 status = be_tx_qs_create(adapter);
4282 if (status)
4283 goto err;
4284
4285 status = be_rx_cqs_create(adapter);
4286 if (status)
4287 goto err;
4288
4289 status = be_mcc_queues_create(adapter);
4290 if (status)
4291 goto err;
4292
4293 status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs);
4294 if (status)
4295 goto err;
4296
4297 status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs);
4298 if (status)
4299 goto err;
4300
4301 return 0;
4302 err:
4303 dev_err(&adapter->pdev->dev, "queue_setup failed\n");
4304 return status;
4305 }
4306
4307 int be_update_queues(struct be_adapter *adapter)
4308 {
4309 struct net_device *netdev = adapter->netdev;
4310 int status;
4311
4312 if (netif_running(netdev))
4313 be_close(netdev);
4314
4315 be_cancel_worker(adapter);
4316
4317 /* If any vectors have been shared with RoCE we cannot re-program
4318 * the MSIx table.
4319 */
4320 if (!adapter->num_msix_roce_vec)
4321 be_msix_disable(adapter);
4322
4323 be_clear_queues(adapter);
4324
4325 if (!msix_enabled(adapter)) {
4326 status = be_msix_enable(adapter);
4327 if (status)
4328 return status;
4329 }
4330
4331 status = be_setup_queues(adapter);
4332 if (status)
4333 return status;
4334
4335 be_schedule_worker(adapter);
4336
4337 if (netif_running(netdev))
4338 status = be_open(netdev);
4339
4340 return status;
4341 }
4342
4343 static inline int fw_major_num(const char *fw_ver)
4344 {
4345 int fw_major = 0, i;
4346
4347 i = sscanf(fw_ver, "%d.", &fw_major);
4348 if (i != 1)
4349 return 0;
4350
4351 return fw_major;
4352 }
4353
4354 /* If any VFs are already enabled don't FLR the PF */
4355 static bool be_reset_required(struct be_adapter *adapter)
4356 {
4357 return pci_num_vf(adapter->pdev) ? false : true;
4358 }
4359
4360 /* Wait for the FW to be ready and perform the required initialization */
4361 static int be_func_init(struct be_adapter *adapter)
4362 {
4363 int status;
4364
4365 status = be_fw_wait_ready(adapter);
4366 if (status)
4367 return status;
4368
4369 if (be_reset_required(adapter)) {
4370 status = be_cmd_reset_function(adapter);
4371 if (status)
4372 return status;
4373
4374 /* Wait for interrupts to quiesce after an FLR */
4375 msleep(100);
4376
4377 /* We can clear all errors when function reset succeeds */
4378 be_clear_error(adapter, BE_CLEAR_ALL);
4379 }
4380
4381 /* Tell FW we're ready to fire cmds */
4382 status = be_cmd_fw_init(adapter);
4383 if (status)
4384 return status;
4385
4386 /* Allow interrupts for other ULPs running on NIC function */
4387 be_intr_set(adapter, true);
4388
4389 return 0;
4390 }
4391
4392 static int be_setup(struct be_adapter *adapter)
4393 {
4394 struct device *dev = &adapter->pdev->dev;
4395 u32 en_flags;
4396 int status;
4397
4398 status = be_func_init(adapter);
4399 if (status)
4400 return status;
4401
4402 be_setup_init(adapter);
4403
4404 if (!lancer_chip(adapter))
4405 be_cmd_req_native_mode(adapter);
4406
4407 /* Need to invoke this cmd first to get the PCI Function Number */
4408 status = be_cmd_get_cntl_attributes(adapter);
4409 if (status)
4410 return status;
4411
4412 if (!BE2_chip(adapter) && be_physfn(adapter))
4413 be_alloc_sriov_res(adapter);
4414
4415 status = be_get_config(adapter);
4416 if (status)
4417 goto err;
4418
4419 status = be_msix_enable(adapter);
4420 if (status)
4421 goto err;
4422
4423 /* will enable all the needed filter flags in be_open() */
4424 en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS;
4425 en_flags = en_flags & be_if_cap_flags(adapter);
4426 status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
4427 &adapter->if_handle, 0);
4428 if (status)
4429 goto err;
4430
4431 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
4432 rtnl_lock();
4433 status = be_setup_queues(adapter);
4434 rtnl_unlock();
4435 if (status)
4436 goto err;
4437
4438 be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
4439
4440 status = be_mac_setup(adapter);
4441 if (status)
4442 goto err;
4443
4444 be_cmd_get_fw_ver(adapter);
4445 dev_info(dev, "FW version is %s\n", adapter->fw_ver);
4446
4447 if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) {
4448 dev_err(dev, "Firmware on card is old(%s), IRQs may not work",
4449 adapter->fw_ver);
4450 dev_err(dev, "Please upgrade firmware to version >= 4.0\n");
4451 }
4452
4453 status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
4454 adapter->rx_fc);
4455 if (status)
4456 be_cmd_get_flow_control(adapter, &adapter->tx_fc,
4457 &adapter->rx_fc);
4458
4459 dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n",
4460 adapter->tx_fc, adapter->rx_fc);
4461
4462 if (be_physfn(adapter))
4463 be_cmd_set_logical_link_config(adapter,
4464 IFLA_VF_LINK_STATE_AUTO, 0);
4465
4466 if (adapter->num_vfs)
4467 be_vf_setup(adapter);
4468
4469 status = be_cmd_get_phy_info(adapter);
4470 if (!status && be_pause_supported(adapter))
4471 adapter->phy.fc_autoneg = 1;
4472
4473 be_schedule_worker(adapter);
4474 adapter->flags |= BE_FLAGS_SETUP_DONE;
4475 return 0;
4476 err:
4477 be_clear(adapter);
4478 return status;
4479 }
4480
4481 #ifdef CONFIG_NET_POLL_CONTROLLER
4482 static void be_netpoll(struct net_device *netdev)
4483 {
4484 struct be_adapter *adapter = netdev_priv(netdev);
4485 struct be_eq_obj *eqo;
4486 int i;
4487
4488 for_all_evt_queues(adapter, eqo, i) {
4489 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
4490 napi_schedule(&eqo->napi);
4491 }
4492 }
4493 #endif
4494
4495 static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
4496
4497 static bool phy_flashing_required(struct be_adapter *adapter)
4498 {
4499 return (adapter->phy.phy_type == PHY_TYPE_TN_8022 &&
4500 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
4501 }
4502
4503 static bool is_comp_in_ufi(struct be_adapter *adapter,
4504 struct flash_section_info *fsec, int type)
4505 {
4506 int i = 0, img_type = 0;
4507 struct flash_section_info_g2 *fsec_g2 = NULL;
4508
4509 if (BE2_chip(adapter))
4510 fsec_g2 = (struct flash_section_info_g2 *)fsec;
4511
4512 for (i = 0; i < MAX_FLASH_COMP; i++) {
4513 if (fsec_g2)
4514 img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
4515 else
4516 img_type = le32_to_cpu(fsec->fsec_entry[i].type);
4517
4518 if (img_type == type)
4519 return true;
4520 }
4521 return false;
4522
4523 }
4524
4525 static struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
4526 int header_size,
4527 const struct firmware *fw)
4528 {
4529 struct flash_section_info *fsec = NULL;
4530 const u8 *p = fw->data;
4531
4532 p += header_size;
4533 while (p < (fw->data + fw->size)) {
4534 fsec = (struct flash_section_info *)p;
4535 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
4536 return fsec;
4537 p += 32;
4538 }
4539 return NULL;
4540 }
4541
4542 static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
4543 u32 img_offset, u32 img_size, int hdr_size,
4544 u16 img_optype, bool *crc_match)
4545 {
4546 u32 crc_offset;
4547 int status;
4548 u8 crc[4];
4549
4550 status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset,
4551 img_size - 4);
4552 if (status)
4553 return status;
4554
4555 crc_offset = hdr_size + img_offset + img_size - 4;
4556
4557 /* Skip flashing, if crc of flashed region matches */
4558 if (!memcmp(crc, p + crc_offset, 4))
4559 *crc_match = true;
4560 else
4561 *crc_match = false;
4562
4563 return status;
4564 }
4565
4566 static int be_flash(struct be_adapter *adapter, const u8 *img,
4567 struct be_dma_mem *flash_cmd, int optype, int img_size,
4568 u32 img_offset)
4569 {
4570 u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0;
4571 struct be_cmd_write_flashrom *req = flash_cmd->va;
4572 int status;
4573
4574 while (total_bytes) {
4575 num_bytes = min_t(u32, 32*1024, total_bytes);
4576
4577 total_bytes -= num_bytes;
4578
4579 if (!total_bytes) {
4580 if (optype == OPTYPE_PHY_FW)
4581 flash_op = FLASHROM_OPER_PHY_FLASH;
4582 else
4583 flash_op = FLASHROM_OPER_FLASH;
4584 } else {
4585 if (optype == OPTYPE_PHY_FW)
4586 flash_op = FLASHROM_OPER_PHY_SAVE;
4587 else
4588 flash_op = FLASHROM_OPER_SAVE;
4589 }
4590
4591 memcpy(req->data_buf, img, num_bytes);
4592 img += num_bytes;
4593 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
4594 flash_op, img_offset +
4595 bytes_sent, num_bytes);
4596 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST &&
4597 optype == OPTYPE_PHY_FW)
4598 break;
4599 else if (status)
4600 return status;
4601
4602 bytes_sent += num_bytes;
4603 }
4604 return 0;
4605 }
4606
4607 /* For BE2, BE3 and BE3-R */
4608 static int be_flash_BEx(struct be_adapter *adapter,
4609 const struct firmware *fw,
4610 struct be_dma_mem *flash_cmd, int num_of_images)
4611 {
4612 int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
4613 struct device *dev = &adapter->pdev->dev;
4614 struct flash_section_info *fsec = NULL;
4615 int status, i, filehdr_size, num_comp;
4616 const struct flash_comp *pflashcomp;
4617 bool crc_match;
4618 const u8 *p;
4619
4620 struct flash_comp gen3_flash_types[] = {
4621 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
4622 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
4623 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
4624 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
4625 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
4626 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
4627 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
4628 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
4629 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
4630 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
4631 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
4632 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
4633 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
4634 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
4635 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
4636 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
4637 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
4638 FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
4639 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
4640 FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
4641 };
4642
4643 struct flash_comp gen2_flash_types[] = {
4644 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
4645 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
4646 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
4647 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
4648 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
4649 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
4650 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
4651 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
4652 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
4653 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
4654 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
4655 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
4656 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
4657 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
4658 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
4659 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
4660 };
4661
4662 if (BE3_chip(adapter)) {
4663 pflashcomp = gen3_flash_types;
4664 filehdr_size = sizeof(struct flash_file_hdr_g3);
4665 num_comp = ARRAY_SIZE(gen3_flash_types);
4666 } else {
4667 pflashcomp = gen2_flash_types;
4668 filehdr_size = sizeof(struct flash_file_hdr_g2);
4669 num_comp = ARRAY_SIZE(gen2_flash_types);
4670 img_hdrs_size = 0;
4671 }
4672
4673 /* Get flash section info*/
4674 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4675 if (!fsec) {
4676 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4677 return -1;
4678 }
4679 for (i = 0; i < num_comp; i++) {
4680 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
4681 continue;
4682
4683 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
4684 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
4685 continue;
4686
4687 if (pflashcomp[i].optype == OPTYPE_PHY_FW &&
4688 !phy_flashing_required(adapter))
4689 continue;
4690
4691 if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
4692 status = be_check_flash_crc(adapter, fw->data,
4693 pflashcomp[i].offset,
4694 pflashcomp[i].size,
4695 filehdr_size +
4696 img_hdrs_size,
4697 OPTYPE_REDBOOT, &crc_match);
4698 if (status) {
4699 dev_err(dev,
4700 "Could not get CRC for 0x%x region\n",
4701 pflashcomp[i].optype);
4702 continue;
4703 }
4704
4705 if (crc_match)
4706 continue;
4707 }
4708
4709 p = fw->data + filehdr_size + pflashcomp[i].offset +
4710 img_hdrs_size;
4711 if (p + pflashcomp[i].size > fw->data + fw->size)
4712 return -1;
4713
4714 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
4715 pflashcomp[i].size, 0);
4716 if (status) {
4717 dev_err(dev, "Flashing section type 0x%x failed\n",
4718 pflashcomp[i].img_type);
4719 return status;
4720 }
4721 }
4722 return 0;
4723 }
4724
4725 static u16 be_get_img_optype(struct flash_section_entry fsec_entry)
4726 {
4727 u32 img_type = le32_to_cpu(fsec_entry.type);
4728 u16 img_optype = le16_to_cpu(fsec_entry.optype);
4729
4730 if (img_optype != 0xFFFF)
4731 return img_optype;
4732
4733 switch (img_type) {
4734 case IMAGE_FIRMWARE_iSCSI:
4735 img_optype = OPTYPE_ISCSI_ACTIVE;
4736 break;
4737 case IMAGE_BOOT_CODE:
4738 img_optype = OPTYPE_REDBOOT;
4739 break;
4740 case IMAGE_OPTION_ROM_ISCSI:
4741 img_optype = OPTYPE_BIOS;
4742 break;
4743 case IMAGE_OPTION_ROM_PXE:
4744 img_optype = OPTYPE_PXE_BIOS;
4745 break;
4746 case IMAGE_OPTION_ROM_FCoE:
4747 img_optype = OPTYPE_FCOE_BIOS;
4748 break;
4749 case IMAGE_FIRMWARE_BACKUP_iSCSI:
4750 img_optype = OPTYPE_ISCSI_BACKUP;
4751 break;
4752 case IMAGE_NCSI:
4753 img_optype = OPTYPE_NCSI_FW;
4754 break;
4755 case IMAGE_FLASHISM_JUMPVECTOR:
4756 img_optype = OPTYPE_FLASHISM_JUMPVECTOR;
4757 break;
4758 case IMAGE_FIRMWARE_PHY:
4759 img_optype = OPTYPE_SH_PHY_FW;
4760 break;
4761 case IMAGE_REDBOOT_DIR:
4762 img_optype = OPTYPE_REDBOOT_DIR;
4763 break;
4764 case IMAGE_REDBOOT_CONFIG:
4765 img_optype = OPTYPE_REDBOOT_CONFIG;
4766 break;
4767 case IMAGE_UFI_DIR:
4768 img_optype = OPTYPE_UFI_DIR;
4769 break;
4770 default:
4771 break;
4772 }
4773
4774 return img_optype;
4775 }
4776
4777 static int be_flash_skyhawk(struct be_adapter *adapter,
4778 const struct firmware *fw,
4779 struct be_dma_mem *flash_cmd, int num_of_images)
4780 {
4781 int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
4782 bool crc_match, old_fw_img, flash_offset_support = true;
4783 struct device *dev = &adapter->pdev->dev;
4784 struct flash_section_info *fsec = NULL;
4785 u32 img_offset, img_size, img_type;
4786 u16 img_optype, flash_optype;
4787 int status, i, filehdr_size;
4788 const u8 *p;
4789
4790 filehdr_size = sizeof(struct flash_file_hdr_g3);
4791 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4792 if (!fsec) {
4793 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4794 return -EINVAL;
4795 }
4796
4797 retry_flash:
4798 for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
4799 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
4800 img_size = le32_to_cpu(fsec->fsec_entry[i].pad_size);
4801 img_type = le32_to_cpu(fsec->fsec_entry[i].type);
4802 img_optype = be_get_img_optype(fsec->fsec_entry[i]);
4803 old_fw_img = fsec->fsec_entry[i].optype == 0xFFFF;
4804
4805 if (img_optype == 0xFFFF)
4806 continue;
4807
4808 if (flash_offset_support)
4809 flash_optype = OPTYPE_OFFSET_SPECIFIED;
4810 else
4811 flash_optype = img_optype;
4812
4813 /* Don't bother verifying CRC if an old FW image is being
4814 * flashed
4815 */
4816 if (old_fw_img)
4817 goto flash;
4818
4819 status = be_check_flash_crc(adapter, fw->data, img_offset,
4820 img_size, filehdr_size +
4821 img_hdrs_size, flash_optype,
4822 &crc_match);
4823 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST ||
4824 base_status(status) == MCC_STATUS_ILLEGAL_FIELD) {
4825 /* The current FW image on the card does not support
4826 * OFFSET based flashing. Retry using older mechanism
4827 * of OPTYPE based flashing
4828 */
4829 if (flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4830 flash_offset_support = false;
4831 goto retry_flash;
4832 }
4833
4834 /* The current FW image on the card does not recognize
4835 * the new FLASH op_type. The FW download is partially
4836 * complete. Reboot the server now to enable FW image
4837 * to recognize the new FLASH op_type. To complete the
4838 * remaining process, download the same FW again after
4839 * the reboot.
4840 */
4841 dev_err(dev, "Flash incomplete. Reset the server\n");
4842 dev_err(dev, "Download FW image again after reset\n");
4843 return -EAGAIN;
4844 } else if (status) {
4845 dev_err(dev, "Could not get CRC for 0x%x region\n",
4846 img_optype);
4847 return -EFAULT;
4848 }
4849
4850 if (crc_match)
4851 continue;
4852
4853 flash:
4854 p = fw->data + filehdr_size + img_offset + img_hdrs_size;
4855 if (p + img_size > fw->data + fw->size)
4856 return -1;
4857
4858 status = be_flash(adapter, p, flash_cmd, flash_optype, img_size,
4859 img_offset);
4860
4861 /* The current FW image on the card does not support OFFSET
4862 * based flashing. Retry using older mechanism of OPTYPE based
4863 * flashing
4864 */
4865 if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD &&
4866 flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4867 flash_offset_support = false;
4868 goto retry_flash;
4869 }
4870
4871 /* For old FW images ignore ILLEGAL_FIELD error or errors on
4872 * UFI_DIR region
4873 */
4874 if (old_fw_img &&
4875 (base_status(status) == MCC_STATUS_ILLEGAL_FIELD ||
4876 (img_optype == OPTYPE_UFI_DIR &&
4877 base_status(status) == MCC_STATUS_FAILED))) {
4878 continue;
4879 } else if (status) {
4880 dev_err(dev, "Flashing section type 0x%x failed\n",
4881 img_type);
4882 return -EFAULT;
4883 }
4884 }
4885 return 0;
4886 }
4887
4888 static int lancer_fw_download(struct be_adapter *adapter,
4889 const struct firmware *fw)
4890 {
4891 #define LANCER_FW_DOWNLOAD_CHUNK (32 * 1024)
4892 #define LANCER_FW_DOWNLOAD_LOCATION "/prg"
4893 struct device *dev = &adapter->pdev->dev;
4894 struct be_dma_mem flash_cmd;
4895 const u8 *data_ptr = NULL;
4896 u8 *dest_image_ptr = NULL;
4897 size_t image_size = 0;
4898 u32 chunk_size = 0;
4899 u32 data_written = 0;
4900 u32 offset = 0;
4901 int status = 0;
4902 u8 add_status = 0;
4903 u8 change_status;
4904
4905 if (!IS_ALIGNED(fw->size, sizeof(u32))) {
4906 dev_err(dev, "FW image size should be multiple of 4\n");
4907 return -EINVAL;
4908 }
4909
4910 flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
4911 + LANCER_FW_DOWNLOAD_CHUNK;
4912 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
4913 &flash_cmd.dma, GFP_KERNEL);
4914 if (!flash_cmd.va)
4915 return -ENOMEM;
4916
4917 dest_image_ptr = flash_cmd.va +
4918 sizeof(struct lancer_cmd_req_write_object);
4919 image_size = fw->size;
4920 data_ptr = fw->data;
4921
4922 while (image_size) {
4923 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
4924
4925 /* Copy the image chunk content. */
4926 memcpy(dest_image_ptr, data_ptr, chunk_size);
4927
4928 status = lancer_cmd_write_object(adapter, &flash_cmd,
4929 chunk_size, offset,
4930 LANCER_FW_DOWNLOAD_LOCATION,
4931 &data_written, &change_status,
4932 &add_status);
4933 if (status)
4934 break;
4935
4936 offset += data_written;
4937 data_ptr += data_written;
4938 image_size -= data_written;
4939 }
4940
4941 if (!status) {
4942 /* Commit the FW written */
4943 status = lancer_cmd_write_object(adapter, &flash_cmd,
4944 0, offset,
4945 LANCER_FW_DOWNLOAD_LOCATION,
4946 &data_written, &change_status,
4947 &add_status);
4948 }
4949
4950 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
4951 if (status) {
4952 dev_err(dev, "Firmware load error\n");
4953 return be_cmd_status(status);
4954 }
4955
4956 dev_info(dev, "Firmware flashed successfully\n");
4957
4958 if (change_status == LANCER_FW_RESET_NEEDED) {
4959 dev_info(dev, "Resetting adapter to activate new FW\n");
4960 status = lancer_physdev_ctrl(adapter,
4961 PHYSDEV_CONTROL_FW_RESET_MASK);
4962 if (status) {
4963 dev_err(dev, "Adapter busy, could not reset FW\n");
4964 dev_err(dev, "Reboot server to activate new FW\n");
4965 }
4966 } else if (change_status != LANCER_NO_RESET_NEEDED) {
4967 dev_info(dev, "Reboot server to activate new FW\n");
4968 }
4969
4970 return 0;
4971 }
4972
4973 /* Check if the flash image file is compatible with the adapter that
4974 * is being flashed.
4975 */
4976 static bool be_check_ufi_compatibility(struct be_adapter *adapter,
4977 struct flash_file_hdr_g3 *fhdr)
4978 {
4979 if (!fhdr) {
4980 dev_err(&adapter->pdev->dev, "Invalid FW UFI file");
4981 return false;
4982 }
4983
4984 /* First letter of the build version is used to identify
4985 * which chip this image file is meant for.
4986 */
4987 switch (fhdr->build[0]) {
4988 case BLD_STR_UFI_TYPE_SH:
4989 if (!skyhawk_chip(adapter))
4990 return false;
4991 break;
4992 case BLD_STR_UFI_TYPE_BE3:
4993 if (!BE3_chip(adapter))
4994 return false;
4995 break;
4996 case BLD_STR_UFI_TYPE_BE2:
4997 if (!BE2_chip(adapter))
4998 return false;
4999 break;
5000 default:
5001 return false;
5002 }
5003
5004 /* In BE3 FW images the "asic_type_rev" field doesn't track the
5005 * asic_rev of the chips it is compatible with.
5006 * When asic_type_rev is 0 the image is compatible only with
5007 * pre-BE3-R chips (asic_rev < 0x10)
5008 */
5009 if (BEx_chip(adapter) && fhdr->asic_type_rev == 0)
5010 return adapter->asic_rev < 0x10;
5011 else
5012 return (fhdr->asic_type_rev >= adapter->asic_rev);
5013 }
5014
5015 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
5016 {
5017 struct device *dev = &adapter->pdev->dev;
5018 struct flash_file_hdr_g3 *fhdr3;
5019 struct image_hdr *img_hdr_ptr;
5020 int status = 0, i, num_imgs;
5021 struct be_dma_mem flash_cmd;
5022
5023 fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
5024 if (!be_check_ufi_compatibility(adapter, fhdr3)) {
5025 dev_err(dev, "Flash image is not compatible with adapter\n");
5026 return -EINVAL;
5027 }
5028
5029 flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
5030 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
5031 GFP_KERNEL);
5032 if (!flash_cmd.va)
5033 return -ENOMEM;
5034
5035 num_imgs = le32_to_cpu(fhdr3->num_imgs);
5036 for (i = 0; i < num_imgs; i++) {
5037 img_hdr_ptr = (struct image_hdr *)(fw->data +
5038 (sizeof(struct flash_file_hdr_g3) +
5039 i * sizeof(struct image_hdr)));
5040 if (!BE2_chip(adapter) &&
5041 le32_to_cpu(img_hdr_ptr->imageid) != 1)
5042 continue;
5043
5044 if (skyhawk_chip(adapter))
5045 status = be_flash_skyhawk(adapter, fw, &flash_cmd,
5046 num_imgs);
5047 else
5048 status = be_flash_BEx(adapter, fw, &flash_cmd,
5049 num_imgs);
5050 }
5051
5052 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
5053 if (!status)
5054 dev_info(dev, "Firmware flashed successfully\n");
5055
5056 return status;
5057 }
5058
5059 int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
5060 {
5061 const struct firmware *fw;
5062 int status;
5063
5064 if (!netif_running(adapter->netdev)) {
5065 dev_err(&adapter->pdev->dev,
5066 "Firmware load not allowed (interface is down)\n");
5067 return -ENETDOWN;
5068 }
5069
5070 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
5071 if (status)
5072 goto fw_exit;
5073
5074 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
5075
5076 if (lancer_chip(adapter))
5077 status = lancer_fw_download(adapter, fw);
5078 else
5079 status = be_fw_download(adapter, fw);
5080
5081 if (!status)
5082 be_cmd_get_fw_ver(adapter);
5083
5084 fw_exit:
5085 release_firmware(fw);
5086 return status;
5087 }
5088
5089 static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
5090 u16 flags)
5091 {
5092 struct be_adapter *adapter = netdev_priv(dev);
5093 struct nlattr *attr, *br_spec;
5094 int rem;
5095 int status = 0;
5096 u16 mode = 0;
5097
5098 if (!sriov_enabled(adapter))
5099 return -EOPNOTSUPP;
5100
5101 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5102 if (!br_spec)
5103 return -EINVAL;
5104
5105 nla_for_each_nested(attr, br_spec, rem) {
5106 if (nla_type(attr) != IFLA_BRIDGE_MODE)
5107 continue;
5108
5109 if (nla_len(attr) < sizeof(mode))
5110 return -EINVAL;
5111
5112 mode = nla_get_u16(attr);
5113 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
5114 return -EINVAL;
5115
5116 status = be_cmd_set_hsw_config(adapter, 0, 0,
5117 adapter->if_handle,
5118 mode == BRIDGE_MODE_VEPA ?
5119 PORT_FWD_TYPE_VEPA :
5120 PORT_FWD_TYPE_VEB, 0);
5121 if (status)
5122 goto err;
5123
5124 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n",
5125 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5126
5127 return status;
5128 }
5129 err:
5130 dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n",
5131 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5132
5133 return status;
5134 }
5135
5136 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
5137 struct net_device *dev, u32 filter_mask,
5138 int nlflags)
5139 {
5140 struct be_adapter *adapter = netdev_priv(dev);
5141 int status = 0;
5142 u8 hsw_mode;
5143
5144 /* BE and Lancer chips support VEB mode only */
5145 if (BEx_chip(adapter) || lancer_chip(adapter)) {
5146 hsw_mode = PORT_FWD_TYPE_VEB;
5147 } else {
5148 status = be_cmd_get_hsw_config(adapter, NULL, 0,
5149 adapter->if_handle, &hsw_mode,
5150 NULL);
5151 if (status)
5152 return 0;
5153
5154 if (hsw_mode == PORT_FWD_TYPE_PASSTHRU)
5155 return 0;
5156 }
5157
5158 return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
5159 hsw_mode == PORT_FWD_TYPE_VEPA ?
5160 BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB,
5161 0, 0, nlflags, filter_mask, NULL);
5162 }
5163
5164 #ifdef CONFIG_BE2NET_VXLAN
5165 /* VxLAN offload Notes:
5166 *
5167 * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't
5168 * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload
5169 * is expected to work across all types of IP tunnels once exported. Skyhawk
5170 * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN
5171 * offloads in hw_enc_features only when a VxLAN port is added. If other (non
5172 * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for
5173 * those other tunnels are unexported on the fly through ndo_features_check().
5174 *
5175 * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack
5176 * adds more than one port, disable offloads and don't re-enable them again
5177 * until after all the tunnels are removed.
5178 */
5179 static void be_add_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5180 __be16 port)
5181 {
5182 struct be_adapter *adapter = netdev_priv(netdev);
5183 struct device *dev = &adapter->pdev->dev;
5184 int status;
5185
5186 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5187 return;
5188
5189 if (adapter->vxlan_port == port && adapter->vxlan_port_count) {
5190 adapter->vxlan_port_aliases++;
5191 return;
5192 }
5193
5194 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) {
5195 dev_info(dev,
5196 "Only one UDP port supported for VxLAN offloads\n");
5197 dev_info(dev, "Disabling VxLAN offloads\n");
5198 adapter->vxlan_port_count++;
5199 goto err;
5200 }
5201
5202 if (adapter->vxlan_port_count++ >= 1)
5203 return;
5204
5205 status = be_cmd_manage_iface(adapter, adapter->if_handle,
5206 OP_CONVERT_NORMAL_TO_TUNNEL);
5207 if (status) {
5208 dev_warn(dev, "Failed to convert normal interface to tunnel\n");
5209 goto err;
5210 }
5211
5212 status = be_cmd_set_vxlan_port(adapter, port);
5213 if (status) {
5214 dev_warn(dev, "Failed to add VxLAN port\n");
5215 goto err;
5216 }
5217 adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS;
5218 adapter->vxlan_port = port;
5219
5220 netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
5221 NETIF_F_TSO | NETIF_F_TSO6 |
5222 NETIF_F_GSO_UDP_TUNNEL;
5223 netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
5224 netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
5225
5226 dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n",
5227 be16_to_cpu(port));
5228 return;
5229 err:
5230 be_disable_vxlan_offloads(adapter);
5231 }
5232
5233 static void be_del_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5234 __be16 port)
5235 {
5236 struct be_adapter *adapter = netdev_priv(netdev);
5237
5238 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5239 return;
5240
5241 if (adapter->vxlan_port != port)
5242 goto done;
5243
5244 if (adapter->vxlan_port_aliases) {
5245 adapter->vxlan_port_aliases--;
5246 return;
5247 }
5248
5249 be_disable_vxlan_offloads(adapter);
5250
5251 dev_info(&adapter->pdev->dev,
5252 "Disabled VxLAN offloads for UDP port %d\n",
5253 be16_to_cpu(port));
5254 done:
5255 adapter->vxlan_port_count--;
5256 }
5257
5258 static netdev_features_t be_features_check(struct sk_buff *skb,
5259 struct net_device *dev,
5260 netdev_features_t features)
5261 {
5262 struct be_adapter *adapter = netdev_priv(dev);
5263 u8 l4_hdr = 0;
5264
5265 /* The code below restricts offload features for some tunneled packets.
5266 * Offload features for normal (non tunnel) packets are unchanged.
5267 */
5268 if (!skb->encapsulation ||
5269 !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS))
5270 return features;
5271
5272 /* It's an encapsulated packet and VxLAN offloads are enabled. We
5273 * should disable tunnel offload features if it's not a VxLAN packet,
5274 * as tunnel offloads have been enabled only for VxLAN. This is done to
5275 * allow other tunneled traffic like GRE work fine while VxLAN
5276 * offloads are configured in Skyhawk-R.
5277 */
5278 switch (vlan_get_protocol(skb)) {
5279 case htons(ETH_P_IP):
5280 l4_hdr = ip_hdr(skb)->protocol;
5281 break;
5282 case htons(ETH_P_IPV6):
5283 l4_hdr = ipv6_hdr(skb)->nexthdr;
5284 break;
5285 default:
5286 return features;
5287 }
5288
5289 if (l4_hdr != IPPROTO_UDP ||
5290 skb->inner_protocol_type != ENCAP_TYPE_ETHER ||
5291 skb->inner_protocol != htons(ETH_P_TEB) ||
5292 skb_inner_mac_header(skb) - skb_transport_header(skb) !=
5293 sizeof(struct udphdr) + sizeof(struct vxlanhdr))
5294 return features & ~(NETIF_F_ALL_CSUM | NETIF_F_GSO_MASK);
5295
5296 return features;
5297 }
5298 #endif
5299
5300 static int be_get_phys_port_id(struct net_device *dev,
5301 struct netdev_phys_item_id *ppid)
5302 {
5303 int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1;
5304 struct be_adapter *adapter = netdev_priv(dev);
5305 u8 *id;
5306
5307 if (MAX_PHYS_ITEM_ID_LEN < id_len)
5308 return -ENOSPC;
5309
5310 ppid->id[0] = adapter->hba_port_num + 1;
5311 id = &ppid->id[1];
5312 for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0;
5313 i--, id += CNTL_SERIAL_NUM_WORD_SZ)
5314 memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ);
5315
5316 ppid->id_len = id_len;
5317
5318 return 0;
5319 }
5320
5321 static const struct net_device_ops be_netdev_ops = {
5322 .ndo_open = be_open,
5323 .ndo_stop = be_close,
5324 .ndo_start_xmit = be_xmit,
5325 .ndo_set_rx_mode = be_set_rx_mode,
5326 .ndo_set_mac_address = be_mac_addr_set,
5327 .ndo_change_mtu = be_change_mtu,
5328 .ndo_get_stats64 = be_get_stats64,
5329 .ndo_validate_addr = eth_validate_addr,
5330 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
5331 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
5332 .ndo_set_vf_mac = be_set_vf_mac,
5333 .ndo_set_vf_vlan = be_set_vf_vlan,
5334 .ndo_set_vf_rate = be_set_vf_tx_rate,
5335 .ndo_get_vf_config = be_get_vf_config,
5336 .ndo_set_vf_link_state = be_set_vf_link_state,
5337 .ndo_set_vf_spoofchk = be_set_vf_spoofchk,
5338 #ifdef CONFIG_NET_POLL_CONTROLLER
5339 .ndo_poll_controller = be_netpoll,
5340 #endif
5341 .ndo_bridge_setlink = be_ndo_bridge_setlink,
5342 .ndo_bridge_getlink = be_ndo_bridge_getlink,
5343 #ifdef CONFIG_NET_RX_BUSY_POLL
5344 .ndo_busy_poll = be_busy_poll,
5345 #endif
5346 #ifdef CONFIG_BE2NET_VXLAN
5347 .ndo_add_vxlan_port = be_add_vxlan_port,
5348 .ndo_del_vxlan_port = be_del_vxlan_port,
5349 .ndo_features_check = be_features_check,
5350 #endif
5351 .ndo_get_phys_port_id = be_get_phys_port_id,
5352 };
5353
5354 static void be_netdev_init(struct net_device *netdev)
5355 {
5356 struct be_adapter *adapter = netdev_priv(netdev);
5357
5358 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5359 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
5360 NETIF_F_HW_VLAN_CTAG_TX;
5361 if (be_multi_rxq(adapter))
5362 netdev->hw_features |= NETIF_F_RXHASH;
5363
5364 netdev->features |= netdev->hw_features |
5365 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
5366
5367 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5368 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
5369
5370 netdev->priv_flags |= IFF_UNICAST_FLT;
5371
5372 netdev->flags |= IFF_MULTICAST;
5373
5374 netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
5375
5376 netdev->netdev_ops = &be_netdev_ops;
5377
5378 netdev->ethtool_ops = &be_ethtool_ops;
5379 }
5380
5381 static void be_cleanup(struct be_adapter *adapter)
5382 {
5383 struct net_device *netdev = adapter->netdev;
5384
5385 rtnl_lock();
5386 netif_device_detach(netdev);
5387 if (netif_running(netdev))
5388 be_close(netdev);
5389 rtnl_unlock();
5390
5391 be_clear(adapter);
5392 }
5393
5394 static int be_resume(struct be_adapter *adapter)
5395 {
5396 struct net_device *netdev = adapter->netdev;
5397 int status;
5398
5399 status = be_setup(adapter);
5400 if (status)
5401 return status;
5402
5403 if (netif_running(netdev)) {
5404 status = be_open(netdev);
5405 if (status)
5406 return status;
5407 }
5408
5409 netif_device_attach(netdev);
5410
5411 return 0;
5412 }
5413
5414 static int be_err_recover(struct be_adapter *adapter)
5415 {
5416 struct device *dev = &adapter->pdev->dev;
5417 int status;
5418
5419 status = be_resume(adapter);
5420 if (status)
5421 goto err;
5422
5423 dev_info(dev, "Adapter recovery successful\n");
5424 return 0;
5425 err:
5426 if (be_physfn(adapter))
5427 dev_err(dev, "Adapter recovery failed\n");
5428 else
5429 dev_err(dev, "Re-trying adapter recovery\n");
5430
5431 return status;
5432 }
5433
5434 static void be_err_detection_task(struct work_struct *work)
5435 {
5436 struct be_adapter *adapter =
5437 container_of(work, struct be_adapter,
5438 be_err_detection_work.work);
5439 int status = 0;
5440
5441 be_detect_error(adapter);
5442
5443 if (be_check_error(adapter, BE_ERROR_HW)) {
5444 be_cleanup(adapter);
5445
5446 /* As of now error recovery support is in Lancer only */
5447 if (lancer_chip(adapter))
5448 status = be_err_recover(adapter);
5449 }
5450
5451 /* Always attempt recovery on VFs */
5452 if (!status || be_virtfn(adapter))
5453 be_schedule_err_detection(adapter);
5454 }
5455
5456 static void be_log_sfp_info(struct be_adapter *adapter)
5457 {
5458 int status;
5459
5460 status = be_cmd_query_sfp_info(adapter);
5461 if (!status) {
5462 dev_err(&adapter->pdev->dev,
5463 "Unqualified SFP+ detected on %c from %s part no: %s",
5464 adapter->port_name, adapter->phy.vendor_name,
5465 adapter->phy.vendor_pn);
5466 }
5467 adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP;
5468 }
5469
5470 static void be_worker(struct work_struct *work)
5471 {
5472 struct be_adapter *adapter =
5473 container_of(work, struct be_adapter, work.work);
5474 struct be_rx_obj *rxo;
5475 int i;
5476
5477 /* when interrupts are not yet enabled, just reap any pending
5478 * mcc completions
5479 */
5480 if (!netif_running(adapter->netdev)) {
5481 local_bh_disable();
5482 be_process_mcc(adapter);
5483 local_bh_enable();
5484 goto reschedule;
5485 }
5486
5487 if (!adapter->stats_cmd_sent) {
5488 if (lancer_chip(adapter))
5489 lancer_cmd_get_pport_stats(adapter,
5490 &adapter->stats_cmd);
5491 else
5492 be_cmd_get_stats(adapter, &adapter->stats_cmd);
5493 }
5494
5495 if (be_physfn(adapter) &&
5496 MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
5497 be_cmd_get_die_temperature(adapter);
5498
5499 for_all_rx_queues(adapter, rxo, i) {
5500 /* Replenish RX-queues starved due to memory
5501 * allocation failures.
5502 */
5503 if (rxo->rx_post_starved)
5504 be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST);
5505 }
5506
5507 /* EQ-delay update for Skyhawk is done while notifying EQ */
5508 if (!skyhawk_chip(adapter))
5509 be_eqd_update(adapter, false);
5510
5511 if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP)
5512 be_log_sfp_info(adapter);
5513
5514 reschedule:
5515 adapter->work_counter++;
5516 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
5517 }
5518
5519 static void be_unmap_pci_bars(struct be_adapter *adapter)
5520 {
5521 if (adapter->csr)
5522 pci_iounmap(adapter->pdev, adapter->csr);
5523 if (adapter->db)
5524 pci_iounmap(adapter->pdev, adapter->db);
5525 }
5526
5527 static int db_bar(struct be_adapter *adapter)
5528 {
5529 if (lancer_chip(adapter) || be_virtfn(adapter))
5530 return 0;
5531 else
5532 return 4;
5533 }
5534
5535 static int be_roce_map_pci_bars(struct be_adapter *adapter)
5536 {
5537 if (skyhawk_chip(adapter)) {
5538 adapter->roce_db.size = 4096;
5539 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
5540 db_bar(adapter));
5541 adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
5542 db_bar(adapter));
5543 }
5544 return 0;
5545 }
5546
5547 static int be_map_pci_bars(struct be_adapter *adapter)
5548 {
5549 struct pci_dev *pdev = adapter->pdev;
5550 u8 __iomem *addr;
5551 u32 sli_intf;
5552
5553 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
5554 adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
5555 SLI_INTF_FAMILY_SHIFT;
5556 adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
5557
5558 if (BEx_chip(adapter) && be_physfn(adapter)) {
5559 adapter->csr = pci_iomap(pdev, 2, 0);
5560 if (!adapter->csr)
5561 return -ENOMEM;
5562 }
5563
5564 addr = pci_iomap(pdev, db_bar(adapter), 0);
5565 if (!addr)
5566 goto pci_map_err;
5567 adapter->db = addr;
5568
5569 if (skyhawk_chip(adapter) || BEx_chip(adapter)) {
5570 if (be_physfn(adapter)) {
5571 /* PCICFG is the 2nd BAR in BE2 */
5572 addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0);
5573 if (!addr)
5574 goto pci_map_err;
5575 adapter->pcicfg = addr;
5576 } else {
5577 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
5578 }
5579 }
5580
5581 be_roce_map_pci_bars(adapter);
5582 return 0;
5583
5584 pci_map_err:
5585 dev_err(&pdev->dev, "Error in mapping PCI BARs\n");
5586 be_unmap_pci_bars(adapter);
5587 return -ENOMEM;
5588 }
5589
5590 static void be_drv_cleanup(struct be_adapter *adapter)
5591 {
5592 struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
5593 struct device *dev = &adapter->pdev->dev;
5594
5595 if (mem->va)
5596 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5597
5598 mem = &adapter->rx_filter;
5599 if (mem->va)
5600 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5601
5602 mem = &adapter->stats_cmd;
5603 if (mem->va)
5604 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5605 }
5606
5607 /* Allocate and initialize various fields in be_adapter struct */
5608 static int be_drv_init(struct be_adapter *adapter)
5609 {
5610 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
5611 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
5612 struct be_dma_mem *rx_filter = &adapter->rx_filter;
5613 struct be_dma_mem *stats_cmd = &adapter->stats_cmd;
5614 struct device *dev = &adapter->pdev->dev;
5615 int status = 0;
5616
5617 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
5618 mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
5619 &mbox_mem_alloc->dma,
5620 GFP_KERNEL);
5621 if (!mbox_mem_alloc->va)
5622 return -ENOMEM;
5623
5624 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
5625 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
5626 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
5627
5628 rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
5629 rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
5630 &rx_filter->dma, GFP_KERNEL);
5631 if (!rx_filter->va) {
5632 status = -ENOMEM;
5633 goto free_mbox;
5634 }
5635
5636 if (lancer_chip(adapter))
5637 stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
5638 else if (BE2_chip(adapter))
5639 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
5640 else if (BE3_chip(adapter))
5641 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
5642 else
5643 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
5644 stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
5645 &stats_cmd->dma, GFP_KERNEL);
5646 if (!stats_cmd->va) {
5647 status = -ENOMEM;
5648 goto free_rx_filter;
5649 }
5650
5651 mutex_init(&adapter->mbox_lock);
5652 spin_lock_init(&adapter->mcc_lock);
5653 spin_lock_init(&adapter->mcc_cq_lock);
5654 init_completion(&adapter->et_cmd_compl);
5655
5656 pci_save_state(adapter->pdev);
5657
5658 INIT_DELAYED_WORK(&adapter->work, be_worker);
5659 INIT_DELAYED_WORK(&adapter->be_err_detection_work,
5660 be_err_detection_task);
5661
5662 adapter->rx_fc = true;
5663 adapter->tx_fc = true;
5664
5665 /* Must be a power of 2 or else MODULO will BUG_ON */
5666 adapter->be_get_temp_freq = 64;
5667
5668 return 0;
5669
5670 free_rx_filter:
5671 dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma);
5672 free_mbox:
5673 dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va,
5674 mbox_mem_alloc->dma);
5675 return status;
5676 }
5677
5678 static void be_remove(struct pci_dev *pdev)
5679 {
5680 struct be_adapter *adapter = pci_get_drvdata(pdev);
5681
5682 if (!adapter)
5683 return;
5684
5685 be_roce_dev_remove(adapter);
5686 be_intr_set(adapter, false);
5687
5688 be_cancel_err_detection(adapter);
5689
5690 unregister_netdev(adapter->netdev);
5691
5692 be_clear(adapter);
5693
5694 /* tell fw we're done with firing cmds */
5695 be_cmd_fw_clean(adapter);
5696
5697 be_unmap_pci_bars(adapter);
5698 be_drv_cleanup(adapter);
5699
5700 pci_disable_pcie_error_reporting(pdev);
5701
5702 pci_release_regions(pdev);
5703 pci_disable_device(pdev);
5704
5705 free_netdev(adapter->netdev);
5706 }
5707
5708 static ssize_t be_hwmon_show_temp(struct device *dev,
5709 struct device_attribute *dev_attr,
5710 char *buf)
5711 {
5712 struct be_adapter *adapter = dev_get_drvdata(dev);
5713
5714 /* Unit: millidegree Celsius */
5715 if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP)
5716 return -EIO;
5717 else
5718 return sprintf(buf, "%u\n",
5719 adapter->hwmon_info.be_on_die_temp * 1000);
5720 }
5721
5722 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
5723 be_hwmon_show_temp, NULL, 1);
5724
5725 static struct attribute *be_hwmon_attrs[] = {
5726 &sensor_dev_attr_temp1_input.dev_attr.attr,
5727 NULL
5728 };
5729
5730 ATTRIBUTE_GROUPS(be_hwmon);
5731
5732 static char *mc_name(struct be_adapter *adapter)
5733 {
5734 char *str = ""; /* default */
5735
5736 switch (adapter->mc_type) {
5737 case UMC:
5738 str = "UMC";
5739 break;
5740 case FLEX10:
5741 str = "FLEX10";
5742 break;
5743 case vNIC1:
5744 str = "vNIC-1";
5745 break;
5746 case nPAR:
5747 str = "nPAR";
5748 break;
5749 case UFP:
5750 str = "UFP";
5751 break;
5752 case vNIC2:
5753 str = "vNIC-2";
5754 break;
5755 default:
5756 str = "";
5757 }
5758
5759 return str;
5760 }
5761
5762 static inline char *func_name(struct be_adapter *adapter)
5763 {
5764 return be_physfn(adapter) ? "PF" : "VF";
5765 }
5766
5767 static inline char *nic_name(struct pci_dev *pdev)
5768 {
5769 switch (pdev->device) {
5770 case OC_DEVICE_ID1:
5771 return OC_NAME;
5772 case OC_DEVICE_ID2:
5773 return OC_NAME_BE;
5774 case OC_DEVICE_ID3:
5775 case OC_DEVICE_ID4:
5776 return OC_NAME_LANCER;
5777 case BE_DEVICE_ID2:
5778 return BE3_NAME;
5779 case OC_DEVICE_ID5:
5780 case OC_DEVICE_ID6:
5781 return OC_NAME_SH;
5782 default:
5783 return BE_NAME;
5784 }
5785 }
5786
5787 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
5788 {
5789 struct be_adapter *adapter;
5790 struct net_device *netdev;
5791 int status = 0;
5792
5793 dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER);
5794
5795 status = pci_enable_device(pdev);
5796 if (status)
5797 goto do_none;
5798
5799 status = pci_request_regions(pdev, DRV_NAME);
5800 if (status)
5801 goto disable_dev;
5802 pci_set_master(pdev);
5803
5804 netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
5805 if (!netdev) {
5806 status = -ENOMEM;
5807 goto rel_reg;
5808 }
5809 adapter = netdev_priv(netdev);
5810 adapter->pdev = pdev;
5811 pci_set_drvdata(pdev, adapter);
5812 adapter->netdev = netdev;
5813 SET_NETDEV_DEV(netdev, &pdev->dev);
5814
5815 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
5816 if (!status) {
5817 netdev->features |= NETIF_F_HIGHDMA;
5818 } else {
5819 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
5820 if (status) {
5821 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
5822 goto free_netdev;
5823 }
5824 }
5825
5826 status = pci_enable_pcie_error_reporting(pdev);
5827 if (!status)
5828 dev_info(&pdev->dev, "PCIe error reporting enabled\n");
5829
5830 status = be_map_pci_bars(adapter);
5831 if (status)
5832 goto free_netdev;
5833
5834 status = be_drv_init(adapter);
5835 if (status)
5836 goto unmap_bars;
5837
5838 status = be_setup(adapter);
5839 if (status)
5840 goto drv_cleanup;
5841
5842 be_netdev_init(netdev);
5843 status = register_netdev(netdev);
5844 if (status != 0)
5845 goto unsetup;
5846
5847 be_roce_dev_add(adapter);
5848
5849 be_schedule_err_detection(adapter);
5850
5851 /* On Die temperature not supported for VF. */
5852 if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) {
5853 adapter->hwmon_info.hwmon_dev =
5854 devm_hwmon_device_register_with_groups(&pdev->dev,
5855 DRV_NAME,
5856 adapter,
5857 be_hwmon_groups);
5858 adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP;
5859 }
5860
5861 dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
5862 func_name(adapter), mc_name(adapter), adapter->port_name);
5863
5864 return 0;
5865
5866 unsetup:
5867 be_clear(adapter);
5868 drv_cleanup:
5869 be_drv_cleanup(adapter);
5870 unmap_bars:
5871 be_unmap_pci_bars(adapter);
5872 free_netdev:
5873 free_netdev(netdev);
5874 rel_reg:
5875 pci_release_regions(pdev);
5876 disable_dev:
5877 pci_disable_device(pdev);
5878 do_none:
5879 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
5880 return status;
5881 }
5882
5883 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
5884 {
5885 struct be_adapter *adapter = pci_get_drvdata(pdev);
5886
5887 if (adapter->wol_en)
5888 be_setup_wol(adapter, true);
5889
5890 be_intr_set(adapter, false);
5891 be_cancel_err_detection(adapter);
5892
5893 be_cleanup(adapter);
5894
5895 pci_save_state(pdev);
5896 pci_disable_device(pdev);
5897 pci_set_power_state(pdev, pci_choose_state(pdev, state));
5898 return 0;
5899 }
5900
5901 static int be_pci_resume(struct pci_dev *pdev)
5902 {
5903 struct be_adapter *adapter = pci_get_drvdata(pdev);
5904 int status = 0;
5905
5906 status = pci_enable_device(pdev);
5907 if (status)
5908 return status;
5909
5910 pci_restore_state(pdev);
5911
5912 status = be_resume(adapter);
5913 if (status)
5914 return status;
5915
5916 be_schedule_err_detection(adapter);
5917
5918 if (adapter->wol_en)
5919 be_setup_wol(adapter, false);
5920
5921 return 0;
5922 }
5923
5924 /*
5925 * An FLR will stop BE from DMAing any data.
5926 */
5927 static void be_shutdown(struct pci_dev *pdev)
5928 {
5929 struct be_adapter *adapter = pci_get_drvdata(pdev);
5930
5931 if (!adapter)
5932 return;
5933
5934 be_roce_dev_shutdown(adapter);
5935 cancel_delayed_work_sync(&adapter->work);
5936 be_cancel_err_detection(adapter);
5937
5938 netif_device_detach(adapter->netdev);
5939
5940 be_cmd_reset_function(adapter);
5941
5942 pci_disable_device(pdev);
5943 }
5944
5945 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
5946 pci_channel_state_t state)
5947 {
5948 struct be_adapter *adapter = pci_get_drvdata(pdev);
5949
5950 dev_err(&adapter->pdev->dev, "EEH error detected\n");
5951
5952 if (!be_check_error(adapter, BE_ERROR_EEH)) {
5953 be_set_error(adapter, BE_ERROR_EEH);
5954
5955 be_cancel_err_detection(adapter);
5956
5957 be_cleanup(adapter);
5958 }
5959
5960 if (state == pci_channel_io_perm_failure)
5961 return PCI_ERS_RESULT_DISCONNECT;
5962
5963 pci_disable_device(pdev);
5964
5965 /* The error could cause the FW to trigger a flash debug dump.
5966 * Resetting the card while flash dump is in progress
5967 * can cause it not to recover; wait for it to finish.
5968 * Wait only for first function as it is needed only once per
5969 * adapter.
5970 */
5971 if (pdev->devfn == 0)
5972 ssleep(30);
5973
5974 return PCI_ERS_RESULT_NEED_RESET;
5975 }
5976
5977 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
5978 {
5979 struct be_adapter *adapter = pci_get_drvdata(pdev);
5980 int status;
5981
5982 dev_info(&adapter->pdev->dev, "EEH reset\n");
5983
5984 status = pci_enable_device(pdev);
5985 if (status)
5986 return PCI_ERS_RESULT_DISCONNECT;
5987
5988 pci_set_master(pdev);
5989 pci_restore_state(pdev);
5990
5991 /* Check if card is ok and fw is ready */
5992 dev_info(&adapter->pdev->dev,
5993 "Waiting for FW to be ready after EEH reset\n");
5994 status = be_fw_wait_ready(adapter);
5995 if (status)
5996 return PCI_ERS_RESULT_DISCONNECT;
5997
5998 pci_cleanup_aer_uncorrect_error_status(pdev);
5999 be_clear_error(adapter, BE_CLEAR_ALL);
6000 return PCI_ERS_RESULT_RECOVERED;
6001 }
6002
6003 static void be_eeh_resume(struct pci_dev *pdev)
6004 {
6005 int status = 0;
6006 struct be_adapter *adapter = pci_get_drvdata(pdev);
6007
6008 dev_info(&adapter->pdev->dev, "EEH resume\n");
6009
6010 pci_save_state(pdev);
6011
6012 status = be_resume(adapter);
6013 if (status)
6014 goto err;
6015
6016 be_schedule_err_detection(adapter);
6017 return;
6018 err:
6019 dev_err(&adapter->pdev->dev, "EEH resume failed\n");
6020 }
6021
6022 static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
6023 {
6024 struct be_adapter *adapter = pci_get_drvdata(pdev);
6025 u16 num_vf_qs;
6026 int status;
6027
6028 if (!num_vfs)
6029 be_vf_clear(adapter);
6030
6031 adapter->num_vfs = num_vfs;
6032
6033 if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) {
6034 dev_warn(&pdev->dev,
6035 "Cannot disable VFs while they are assigned\n");
6036 return -EBUSY;
6037 }
6038
6039 /* When the HW is in SRIOV capable configuration, the PF-pool resources
6040 * are equally distributed across the max-number of VFs. The user may
6041 * request only a subset of the max-vfs to be enabled.
6042 * Based on num_vfs, redistribute the resources across num_vfs so that
6043 * each VF will have access to more number of resources.
6044 * This facility is not available in BE3 FW.
6045 * Also, this is done by FW in Lancer chip.
6046 */
6047 if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) {
6048 num_vf_qs = be_calculate_vf_qs(adapter, adapter->num_vfs);
6049 status = be_cmd_set_sriov_config(adapter, adapter->pool_res,
6050 adapter->num_vfs, num_vf_qs);
6051 if (status)
6052 dev_err(&pdev->dev,
6053 "Failed to optimize SR-IOV resources\n");
6054 }
6055
6056 status = be_get_resources(adapter);
6057 if (status)
6058 return be_cmd_status(status);
6059
6060 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
6061 rtnl_lock();
6062 status = be_update_queues(adapter);
6063 rtnl_unlock();
6064 if (status)
6065 return be_cmd_status(status);
6066
6067 if (adapter->num_vfs)
6068 status = be_vf_setup(adapter);
6069
6070 if (!status)
6071 return adapter->num_vfs;
6072
6073 return 0;
6074 }
6075
6076 static const struct pci_error_handlers be_eeh_handlers = {
6077 .error_detected = be_eeh_err_detected,
6078 .slot_reset = be_eeh_reset,
6079 .resume = be_eeh_resume,
6080 };
6081
6082 static struct pci_driver be_driver = {
6083 .name = DRV_NAME,
6084 .id_table = be_dev_ids,
6085 .probe = be_probe,
6086 .remove = be_remove,
6087 .suspend = be_suspend,
6088 .resume = be_pci_resume,
6089 .shutdown = be_shutdown,
6090 .sriov_configure = be_pci_sriov_configure,
6091 .err_handler = &be_eeh_handlers
6092 };
6093
6094 static int __init be_init_module(void)
6095 {
6096 if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
6097 rx_frag_size != 2048) {
6098 printk(KERN_WARNING DRV_NAME
6099 " : Module param rx_frag_size must be 2048/4096/8192."
6100 " Using 2048\n");
6101 rx_frag_size = 2048;
6102 }
6103
6104 if (num_vfs > 0) {
6105 pr_info(DRV_NAME " : Module param num_vfs is obsolete.");
6106 pr_info(DRV_NAME " : Use sysfs method to enable VFs\n");
6107 }
6108
6109 return pci_register_driver(&be_driver);
6110 }
6111 module_init(be_init_module);
6112
6113 static void __exit be_exit_module(void)
6114 {
6115 pci_unregister_driver(&be_driver);
6116 }
6117 module_exit(be_exit_module);
ubuntu-zesty-kernel mirror