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
be_queue_free(struct be_adapter * adapter,struct be_queue_info * q)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
be_queue_alloc(struct be_adapter * adapter,struct be_queue_info * q,u16 len,u16 entry_size)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
be_reg_intr_set(struct be_adapter * adapter,bool enable)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 ®);
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
be_intr_set(struct be_adapter * adapter,bool enable)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
be_rxq_notify(struct be_adapter * adapter,u16 qid,u16 posted)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
be_txq_notify(struct be_adapter * adapter,struct be_tx_obj * txo,u16 posted)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
be_eq_notify(struct be_adapter * adapter,u16 qid,bool arm,bool clear_int,u16 num_popped,u32 eq_delay_mult_enc)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
be_cq_notify(struct be_adapter * adapter,u16 qid,bool arm,u16 num_popped)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
be_mac_addr_set(struct net_device * netdev,void * p)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 */
hw_stats_from_cmd(struct be_adapter * adapter)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 */
be_erx_stats_from_cmd(struct be_adapter * adapter)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
populate_be_v0_stats(struct be_adapter * adapter)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
populate_be_v1_stats(struct be_adapter * adapter)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
populate_be_v2_stats(struct be_adapter * adapter)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
populate_lancer_stats(struct be_adapter * adapter)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
accumulate_16bit_val(u32 * acc,u16 val)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
populate_erx_stats(struct be_adapter * adapter,struct be_rx_obj * rxo,u32 erx_stat)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
be_parse_stats(struct be_adapter * adapter)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
be_get_stats64(struct net_device * netdev,struct rtnl_link_stats64 * stats)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
be_link_status_update(struct be_adapter * adapter,u8 link_status)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
be_tx_stats_update(struct be_tx_obj * txo,struct sk_buff * skb)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 */
skb_wrb_cnt(struct sk_buff * 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
wrb_fill(struct be_eth_wrb * wrb,u64 addr,int len)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 */
wrb_fill_dummy(struct be_eth_wrb * wrb)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
be_get_tx_vlan_tag(struct be_adapter * adapter,struct sk_buff * skb)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 */
skb_inner_ip_proto(struct sk_buff * skb)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
skb_ip_proto(struct sk_buff * skb)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
be_is_txq_full(struct be_tx_obj * txo)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
be_can_txq_wake(struct be_tx_obj * txo)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
be_is_tx_compl_pending(struct be_tx_obj * txo)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
be_get_wrb_params_from_skb(struct be_adapter * adapter,struct sk_buff * skb,struct be_wrb_params * wrb_params)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
wrb_fill_hdr(struct be_adapter * adapter,struct be_eth_hdr_wrb * hdr,struct be_wrb_params * wrb_params,struct sk_buff * skb)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
unmap_tx_frag(struct device * dev,struct be_eth_wrb * wrb,bool unmap_single)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 */
be_tx_get_wrb_hdr(struct be_tx_obj * txo)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 */
be_tx_setup_wrb_hdr(struct be_adapter * adapter,struct be_tx_obj * txo,struct be_wrb_params * wrb_params,struct sk_buff * skb,u16 head)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 */
be_tx_setup_wrb_frag(struct be_tx_obj * txo,dma_addr_t busaddr,int len)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 */
be_xmit_restore(struct be_adapter * adapter,struct be_tx_obj * txo,u16 head,bool map_single,u32 copied)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 */
be_xmit_enqueue(struct be_adapter * adapter,struct be_tx_obj * txo,struct sk_buff * skb,struct be_wrb_params * wrb_params)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
qnq_async_evt_rcvd(struct be_adapter * adapter)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
be_insert_vlan_in_pkt(struct be_adapter * adapter,struct sk_buff * skb,struct be_wrb_params * wrb_params)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
be_ipv6_exthdr_check(struct sk_buff * skb)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
be_vlan_tag_tx_chk(struct be_adapter * adapter,struct sk_buff * skb)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
be_ipv6_tx_stall_chk(struct be_adapter * adapter,struct sk_buff * skb)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
be_lancer_xmit_workarounds(struct be_adapter * adapter,struct sk_buff * skb,struct be_wrb_params * wrb_params)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
be_xmit_workarounds(struct be_adapter * adapter,struct sk_buff * skb,struct be_wrb_params * wrb_params)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
be_xmit_flush(struct be_adapter * adapter,struct be_tx_obj * txo)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
be_send_pkt_to_bmc(struct be_adapter * adapter,struct sk_buff ** skb)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
be_xmit(struct sk_buff * skb,struct net_device * netdev)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
be_change_mtu(struct net_device * netdev,int new_mtu)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
be_in_all_promisc(struct be_adapter * adapter)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
be_set_vlan_promisc(struct be_adapter * adapter)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
be_clear_vlan_promisc(struct be_adapter * adapter)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 */
be_vid_config(struct be_adapter * adapter)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
be_vlan_add_vid(struct net_device * netdev,__be16 proto,u16 vid)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
be_vlan_rem_vid(struct net_device * netdev,__be16 proto,u16 vid)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
be_clear_all_promisc(struct be_adapter * adapter)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
be_set_all_promisc(struct be_adapter * adapter)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
be_set_mc_promisc(struct be_adapter * adapter)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
be_set_mc_list(struct be_adapter * adapter)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
be_set_uc_list(struct be_adapter * adapter)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
be_clear_uc_list(struct be_adapter * adapter)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
be_set_rx_mode(struct net_device * netdev)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
be_set_vf_mac(struct net_device * netdev,int vf,u8 * mac)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
be_get_vf_config(struct net_device * netdev,int vf,struct ifla_vf_info * vi)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
be_set_vf_tvt(struct be_adapter * adapter,int vf,u16 vlan)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
be_clear_vf_tvt(struct be_adapter * adapter,int vf)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
be_set_vf_vlan(struct net_device * netdev,int vf,u16 vlan,u8 qos)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
be_set_vf_tx_rate(struct net_device * netdev,int vf,int min_tx_rate,int max_tx_rate)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
be_set_vf_link_state(struct net_device * netdev,int vf,int link_state)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
be_set_vf_spoofchk(struct net_device * netdev,int vf,bool enable)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
be_aic_update(struct be_aic_obj * aic,u64 rx_pkts,u64 tx_pkts,ulong now)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
be_get_new_eqd(struct be_eq_obj * eqo)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 */
be_get_eq_delay_mult_enc(struct be_eq_obj * eqo)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
be_eqd_update(struct be_adapter * adapter,bool force_update)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
be_rx_stats_update(struct be_rx_obj * rxo,struct be_rx_compl_info * rxcp)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
csum_passed(struct be_rx_compl_info * rxcp)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
get_rx_page_info(struct be_rx_obj * rxo)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 */
be_rx_compl_discard(struct be_rx_obj * rxo,struct be_rx_compl_info * rxcp)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 */
skb_fill_rx_data(struct be_rx_obj * rxo,struct sk_buff * skb,struct be_rx_compl_info * rxcp)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 */
be_rx_compl_process(struct be_rx_obj * rxo,struct napi_struct * napi,struct be_rx_compl_info * rxcp)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 */
be_rx_compl_process_gro(struct be_rx_obj * rxo,struct napi_struct * napi,struct be_rx_compl_info * rxcp)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
be_parse_rx_compl_v1(struct be_eth_rx_compl * compl,struct be_rx_compl_info * rxcp)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
be_parse_rx_compl_v0(struct be_eth_rx_compl * compl,struct be_rx_compl_info * rxcp)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
be_rx_compl_get(struct be_rx_obj * rxo)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
be_alloc_pages(u32 size,gfp_t gfp)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 */
be_post_rx_frags(struct be_rx_obj * rxo,gfp_t gfp,u32 frags_needed)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
be_tx_compl_get(struct be_tx_obj * txo)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
be_tx_compl_process(struct be_adapter * adapter,struct be_tx_obj * txo,u16 last_index)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 */
events_get(struct be_eq_obj * eqo)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 */
be_eq_clean(struct be_eq_obj * eqo)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 */
be_rxq_clean(struct be_rx_obj * rxo)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
be_rx_cq_clean(struct be_rx_obj * rxo)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
be_tx_compl_clean(struct be_adapter * adapter)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
be_evt_queues_destroy(struct be_adapter * adapter)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
be_evt_queues_create(struct be_adapter * adapter)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
be_mcc_queues_destroy(struct be_adapter * adapter)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 */
be_mcc_queues_create(struct be_adapter * adapter)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
be_tx_queues_destroy(struct be_adapter * adapter)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
be_tx_qs_create(struct be_adapter * adapter)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
be_rx_cqs_destroy(struct be_adapter * adapter)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
be_rx_cqs_create(struct be_adapter * adapter)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
be_intx(int irq,void * dev)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
be_msix(int irq,void * dev)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
do_gro(struct be_rx_compl_info * rxcp)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
be_process_rx(struct be_rx_obj * rxo,struct napi_struct * napi,int budget,int polling)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
be_update_tx_err(struct be_tx_obj * txo,u8 status)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
lancer_update_tx_err(struct be_tx_obj * txo,u8 status)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
be_process_tx(struct be_adapter * adapter,struct be_tx_obj * txo,int idx)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
be_lock_napi(struct be_eq_obj * eqo)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
be_unlock_napi(struct be_eq_obj * eqo)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
be_lock_busy_poll(struct be_eq_obj * eqo)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
be_unlock_busy_poll(struct be_eq_obj * eqo)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
be_enable_busy_poll(struct be_eq_obj * eqo)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
be_disable_busy_poll(struct be_eq_obj * eqo)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
be_lock_napi(struct be_eq_obj * eqo)3058 static inline bool be_lock_napi(struct be_eq_obj *eqo)
3059 {
3060 return true;
3061 }
3062
be_unlock_napi(struct be_eq_obj * eqo)3063 static inline void be_unlock_napi(struct be_eq_obj *eqo)
3064 {
3065 }
3066
be_lock_busy_poll(struct be_eq_obj * eqo)3067 static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)
3068 {
3069 return false;
3070 }
3071
be_unlock_busy_poll(struct be_eq_obj * eqo)3072 static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)
3073 {
3074 }
3075
be_enable_busy_poll(struct be_eq_obj * eqo)3076 static inline void be_enable_busy_poll(struct be_eq_obj *eqo)
3077 {
3078 }
3079
be_disable_busy_poll(struct be_eq_obj * eqo)3080 static inline void be_disable_busy_poll(struct be_eq_obj *eqo)
3081 {
3082 }
3083 #endif /* CONFIG_NET_RX_BUSY_POLL */
3084
be_poll(struct napi_struct * napi,int budget)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
be_busy_poll(struct napi_struct * napi)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
be_detect_error(struct be_adapter * adapter)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
be_msix_disable(struct be_adapter * adapter)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
be_msix_enable(struct be_adapter * adapter)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
be_msix_vec_get(struct be_adapter * adapter,struct be_eq_obj * eqo)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
be_msix_register(struct be_adapter * adapter)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--; i >= 0; i--) {
3303 eqo = &adapter->eq_obj[i];
3304 free_irq(be_msix_vec_get(adapter, eqo), eqo);
3305 }
3306 dev_warn(&adapter->pdev->dev, "MSIX Request IRQ failed - err %d\n",
3307 status);
3308 be_msix_disable(adapter);
3309 return status;
3310 }
3311
be_irq_register(struct be_adapter * adapter)3312 static int be_irq_register(struct be_adapter *adapter)
3313 {
3314 struct net_device *netdev = adapter->netdev;
3315 int status;
3316
3317 if (msix_enabled(adapter)) {
3318 status = be_msix_register(adapter);
3319 if (status == 0)
3320 goto done;
3321 /* INTx is not supported for VF */
3322 if (be_virtfn(adapter))
3323 return status;
3324 }
3325
3326 /* INTx: only the first EQ is used */
3327 netdev->irq = adapter->pdev->irq;
3328 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
3329 &adapter->eq_obj[0]);
3330 if (status) {
3331 dev_err(&adapter->pdev->dev,
3332 "INTx request IRQ failed - err %d\n", status);
3333 return status;
3334 }
3335 done:
3336 adapter->isr_registered = true;
3337 return 0;
3338 }
3339
be_irq_unregister(struct be_adapter * adapter)3340 static void be_irq_unregister(struct be_adapter *adapter)
3341 {
3342 struct net_device *netdev = adapter->netdev;
3343 struct be_eq_obj *eqo;
3344 int i, vec;
3345
3346 if (!adapter->isr_registered)
3347 return;
3348
3349 /* INTx */
3350 if (!msix_enabled(adapter)) {
3351 free_irq(netdev->irq, &adapter->eq_obj[0]);
3352 goto done;
3353 }
3354
3355 /* MSIx */
3356 for_all_evt_queues(adapter, eqo, i) {
3357 vec = be_msix_vec_get(adapter, eqo);
3358 irq_set_affinity_hint(vec, NULL);
3359 free_irq(vec, eqo);
3360 }
3361
3362 done:
3363 adapter->isr_registered = false;
3364 }
3365
be_rx_qs_destroy(struct be_adapter * adapter)3366 static void be_rx_qs_destroy(struct be_adapter *adapter)
3367 {
3368 struct be_queue_info *q;
3369 struct be_rx_obj *rxo;
3370 int i;
3371
3372 for_all_rx_queues(adapter, rxo, i) {
3373 q = &rxo->q;
3374 if (q->created) {
3375 /* If RXQs are destroyed while in an "out of buffer"
3376 * state, there is a possibility of an HW stall on
3377 * Lancer. So, post 64 buffers to each queue to relieve
3378 * the "out of buffer" condition.
3379 * Make sure there's space in the RXQ before posting.
3380 */
3381 if (lancer_chip(adapter)) {
3382 be_rx_cq_clean(rxo);
3383 if (atomic_read(&q->used) == 0)
3384 be_post_rx_frags(rxo, GFP_KERNEL,
3385 MAX_RX_POST);
3386 }
3387
3388 be_cmd_rxq_destroy(adapter, q);
3389 be_rx_cq_clean(rxo);
3390 be_rxq_clean(rxo);
3391 }
3392 be_queue_free(adapter, q);
3393 }
3394 }
3395
be_disable_if_filters(struct be_adapter * adapter)3396 static void be_disable_if_filters(struct be_adapter *adapter)
3397 {
3398 be_cmd_pmac_del(adapter, adapter->if_handle,
3399 adapter->pmac_id[0], 0);
3400
3401 be_clear_uc_list(adapter);
3402
3403 /* The IFACE flags are enabled in the open path and cleared
3404 * in the close path. When a VF gets detached from the host and
3405 * assigned to a VM the following happens:
3406 * - VF's IFACE flags get cleared in the detach path
3407 * - IFACE create is issued by the VF in the attach path
3408 * Due to a bug in the BE3/Skyhawk-R FW
3409 * (Lancer FW doesn't have the bug), the IFACE capability flags
3410 * specified along with the IFACE create cmd issued by a VF are not
3411 * honoured by FW. As a consequence, if a *new* driver
3412 * (that enables/disables IFACE flags in open/close)
3413 * is loaded in the host and an *old* driver is * used by a VM/VF,
3414 * the IFACE gets created *without* the needed flags.
3415 * To avoid this, disable RX-filter flags only for Lancer.
3416 */
3417 if (lancer_chip(adapter)) {
3418 be_cmd_rx_filter(adapter, BE_IF_ALL_FILT_FLAGS, OFF);
3419 adapter->if_flags &= ~BE_IF_ALL_FILT_FLAGS;
3420 }
3421 }
3422
be_close(struct net_device * netdev)3423 static int be_close(struct net_device *netdev)
3424 {
3425 struct be_adapter *adapter = netdev_priv(netdev);
3426 struct be_eq_obj *eqo;
3427 int i;
3428
3429 /* This protection is needed as be_close() may be called even when the
3430 * adapter is in cleared state (after eeh perm failure)
3431 */
3432 if (!(adapter->flags & BE_FLAGS_SETUP_DONE))
3433 return 0;
3434
3435 be_disable_if_filters(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
be_rx_qs_create(struct be_adapter * adapter)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
be_enable_if_filters(struct be_adapter * adapter)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
be_open(struct net_device * netdev)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 #ifdef CONFIG_BE2NET_VXLAN
3605 if (skyhawk_chip(adapter))
3606 vxlan_get_rx_port(netdev);
3607 #endif
3608
3609 return 0;
3610 err:
3611 be_close(adapter->netdev);
3612 return -EIO;
3613 }
3614
be_setup_wol(struct be_adapter * adapter,bool enable)3615 static int be_setup_wol(struct be_adapter *adapter, bool enable)
3616 {
3617 struct device *dev = &adapter->pdev->dev;
3618 struct be_dma_mem cmd;
3619 u8 mac[ETH_ALEN];
3620 int status;
3621
3622 eth_zero_addr(mac);
3623
3624 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
3625 cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
3626 if (!cmd.va)
3627 return -ENOMEM;
3628
3629 if (enable) {
3630 status = pci_write_config_dword(adapter->pdev,
3631 PCICFG_PM_CONTROL_OFFSET,
3632 PCICFG_PM_CONTROL_MASK);
3633 if (status) {
3634 dev_err(dev, "Could not enable Wake-on-lan\n");
3635 goto err;
3636 }
3637 } else {
3638 ether_addr_copy(mac, adapter->netdev->dev_addr);
3639 }
3640
3641 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
3642 pci_enable_wake(adapter->pdev, PCI_D3hot, enable);
3643 pci_enable_wake(adapter->pdev, PCI_D3cold, enable);
3644 err:
3645 dma_free_coherent(dev, cmd.size, cmd.va, cmd.dma);
3646 return status;
3647 }
3648
be_vf_eth_addr_generate(struct be_adapter * adapter,u8 * mac)3649 static void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)
3650 {
3651 u32 addr;
3652
3653 addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);
3654
3655 mac[5] = (u8)(addr & 0xFF);
3656 mac[4] = (u8)((addr >> 8) & 0xFF);
3657 mac[3] = (u8)((addr >> 16) & 0xFF);
3658 /* Use the OUI from the current MAC address */
3659 memcpy(mac, adapter->netdev->dev_addr, 3);
3660 }
3661
3662 /*
3663 * Generate a seed MAC address from the PF MAC Address using jhash.
3664 * MAC Address for VFs are assigned incrementally starting from the seed.
3665 * These addresses are programmed in the ASIC by the PF and the VF driver
3666 * queries for the MAC address during its probe.
3667 */
be_vf_eth_addr_config(struct be_adapter * adapter)3668 static int be_vf_eth_addr_config(struct be_adapter *adapter)
3669 {
3670 u32 vf;
3671 int status = 0;
3672 u8 mac[ETH_ALEN];
3673 struct be_vf_cfg *vf_cfg;
3674
3675 be_vf_eth_addr_generate(adapter, mac);
3676
3677 for_all_vfs(adapter, vf_cfg, vf) {
3678 if (BEx_chip(adapter))
3679 status = be_cmd_pmac_add(adapter, mac,
3680 vf_cfg->if_handle,
3681 &vf_cfg->pmac_id, vf + 1);
3682 else
3683 status = be_cmd_set_mac(adapter, mac, vf_cfg->if_handle,
3684 vf + 1);
3685
3686 if (status)
3687 dev_err(&adapter->pdev->dev,
3688 "Mac address assignment failed for VF %d\n",
3689 vf);
3690 else
3691 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3692
3693 mac[5] += 1;
3694 }
3695 return status;
3696 }
3697
be_vfs_mac_query(struct be_adapter * adapter)3698 static int be_vfs_mac_query(struct be_adapter *adapter)
3699 {
3700 int status, vf;
3701 u8 mac[ETH_ALEN];
3702 struct be_vf_cfg *vf_cfg;
3703
3704 for_all_vfs(adapter, vf_cfg, vf) {
3705 status = be_cmd_get_active_mac(adapter, vf_cfg->pmac_id,
3706 mac, vf_cfg->if_handle,
3707 false, vf+1);
3708 if (status)
3709 return status;
3710 memcpy(vf_cfg->mac_addr, mac, ETH_ALEN);
3711 }
3712 return 0;
3713 }
3714
be_vf_clear(struct be_adapter * adapter)3715 static void be_vf_clear(struct be_adapter *adapter)
3716 {
3717 struct be_vf_cfg *vf_cfg;
3718 u32 vf;
3719
3720 if (pci_vfs_assigned(adapter->pdev)) {
3721 dev_warn(&adapter->pdev->dev,
3722 "VFs are assigned to VMs: not disabling VFs\n");
3723 goto done;
3724 }
3725
3726 pci_disable_sriov(adapter->pdev);
3727
3728 for_all_vfs(adapter, vf_cfg, vf) {
3729 if (BEx_chip(adapter))
3730 be_cmd_pmac_del(adapter, vf_cfg->if_handle,
3731 vf_cfg->pmac_id, vf + 1);
3732 else
3733 be_cmd_set_mac(adapter, NULL, vf_cfg->if_handle,
3734 vf + 1);
3735
3736 be_cmd_if_destroy(adapter, vf_cfg->if_handle, vf + 1);
3737 }
3738 done:
3739 kfree(adapter->vf_cfg);
3740 adapter->num_vfs = 0;
3741 adapter->flags &= ~BE_FLAGS_SRIOV_ENABLED;
3742 }
3743
be_clear_queues(struct be_adapter * adapter)3744 static void be_clear_queues(struct be_adapter *adapter)
3745 {
3746 be_mcc_queues_destroy(adapter);
3747 be_rx_cqs_destroy(adapter);
3748 be_tx_queues_destroy(adapter);
3749 be_evt_queues_destroy(adapter);
3750 }
3751
be_cancel_worker(struct be_adapter * adapter)3752 static void be_cancel_worker(struct be_adapter *adapter)
3753 {
3754 if (adapter->flags & BE_FLAGS_WORKER_SCHEDULED) {
3755 cancel_delayed_work_sync(&adapter->work);
3756 adapter->flags &= ~BE_FLAGS_WORKER_SCHEDULED;
3757 }
3758 }
3759
be_cancel_err_detection(struct be_adapter * adapter)3760 static void be_cancel_err_detection(struct be_adapter *adapter)
3761 {
3762 if (adapter->flags & BE_FLAGS_ERR_DETECTION_SCHEDULED) {
3763 cancel_delayed_work_sync(&adapter->be_err_detection_work);
3764 adapter->flags &= ~BE_FLAGS_ERR_DETECTION_SCHEDULED;
3765 }
3766 }
3767
3768 #ifdef CONFIG_BE2NET_VXLAN
be_disable_vxlan_offloads(struct be_adapter * adapter)3769 static void be_disable_vxlan_offloads(struct be_adapter *adapter)
3770 {
3771 struct net_device *netdev = adapter->netdev;
3772
3773 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS)
3774 be_cmd_manage_iface(adapter, adapter->if_handle,
3775 OP_CONVERT_TUNNEL_TO_NORMAL);
3776
3777 if (adapter->vxlan_port)
3778 be_cmd_set_vxlan_port(adapter, 0);
3779
3780 adapter->flags &= ~BE_FLAGS_VXLAN_OFFLOADS;
3781 adapter->vxlan_port = 0;
3782
3783 netdev->hw_enc_features = 0;
3784 netdev->hw_features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3785 netdev->features &= ~(NETIF_F_GSO_UDP_TUNNEL);
3786 }
3787 #endif
3788
be_calculate_vf_qs(struct be_adapter * adapter,u16 num_vfs)3789 static u16 be_calculate_vf_qs(struct be_adapter *adapter, u16 num_vfs)
3790 {
3791 struct be_resources res = adapter->pool_res;
3792 u16 num_vf_qs = 1;
3793
3794 /* Distribute the queue resources equally among the PF and it's VFs
3795 * Do not distribute queue resources in multi-channel configuration.
3796 */
3797 if (num_vfs && !be_is_mc(adapter)) {
3798 /* If number of VFs requested is 8 less than max supported,
3799 * assign 8 queue pairs to the PF and divide the remaining
3800 * resources evenly among the VFs
3801 */
3802 if (num_vfs < (be_max_vfs(adapter) - 8))
3803 num_vf_qs = (res.max_rss_qs - 8) / num_vfs;
3804 else
3805 num_vf_qs = res.max_rss_qs / num_vfs;
3806
3807 /* Skyhawk-R chip supports only MAX_RSS_IFACES RSS capable
3808 * interfaces per port. Provide RSS on VFs, only if number
3809 * of VFs requested is less than MAX_RSS_IFACES limit.
3810 */
3811 if (num_vfs >= MAX_RSS_IFACES)
3812 num_vf_qs = 1;
3813 }
3814 return num_vf_qs;
3815 }
3816
be_clear(struct be_adapter * adapter)3817 static int be_clear(struct be_adapter *adapter)
3818 {
3819 struct pci_dev *pdev = adapter->pdev;
3820 u16 num_vf_qs;
3821
3822 be_cancel_worker(adapter);
3823
3824 if (sriov_enabled(adapter))
3825 be_vf_clear(adapter);
3826
3827 /* Re-configure FW to distribute resources evenly across max-supported
3828 * number of VFs, only when VFs are not already enabled.
3829 */
3830 if (skyhawk_chip(adapter) && be_physfn(adapter) &&
3831 !pci_vfs_assigned(pdev)) {
3832 num_vf_qs = be_calculate_vf_qs(adapter,
3833 pci_sriov_get_totalvfs(pdev));
3834 be_cmd_set_sriov_config(adapter, adapter->pool_res,
3835 pci_sriov_get_totalvfs(pdev),
3836 num_vf_qs);
3837 }
3838
3839 #ifdef CONFIG_BE2NET_VXLAN
3840 be_disable_vxlan_offloads(adapter);
3841 #endif
3842 kfree(adapter->pmac_id);
3843 adapter->pmac_id = NULL;
3844
3845 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
3846
3847 be_clear_queues(adapter);
3848
3849 be_msix_disable(adapter);
3850 adapter->flags &= ~BE_FLAGS_SETUP_DONE;
3851 return 0;
3852 }
3853
be_vfs_if_create(struct be_adapter * adapter)3854 static int be_vfs_if_create(struct be_adapter *adapter)
3855 {
3856 struct be_resources res = {0};
3857 u32 cap_flags, en_flags, vf;
3858 struct be_vf_cfg *vf_cfg;
3859 int status;
3860
3861 /* If a FW profile exists, then cap_flags are updated */
3862 cap_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST |
3863 BE_IF_FLAGS_MULTICAST | BE_IF_FLAGS_PASS_L3L4_ERRORS;
3864
3865 for_all_vfs(adapter, vf_cfg, vf) {
3866 if (!BE3_chip(adapter)) {
3867 status = be_cmd_get_profile_config(adapter, &res,
3868 RESOURCE_LIMITS,
3869 vf + 1);
3870 if (!status) {
3871 cap_flags = res.if_cap_flags;
3872 /* Prevent VFs from enabling VLAN promiscuous
3873 * mode
3874 */
3875 cap_flags &= ~BE_IF_FLAGS_VLAN_PROMISCUOUS;
3876 }
3877 }
3878
3879 en_flags = cap_flags & (BE_IF_FLAGS_UNTAGGED |
3880 BE_IF_FLAGS_BROADCAST |
3881 BE_IF_FLAGS_MULTICAST |
3882 BE_IF_FLAGS_PASS_L3L4_ERRORS);
3883 status = be_cmd_if_create(adapter, cap_flags, en_flags,
3884 &vf_cfg->if_handle, vf + 1);
3885 if (status)
3886 return status;
3887 }
3888
3889 return 0;
3890 }
3891
be_vf_setup_init(struct be_adapter * adapter)3892 static int be_vf_setup_init(struct be_adapter *adapter)
3893 {
3894 struct be_vf_cfg *vf_cfg;
3895 int vf;
3896
3897 adapter->vf_cfg = kcalloc(adapter->num_vfs, sizeof(*vf_cfg),
3898 GFP_KERNEL);
3899 if (!adapter->vf_cfg)
3900 return -ENOMEM;
3901
3902 for_all_vfs(adapter, vf_cfg, vf) {
3903 vf_cfg->if_handle = -1;
3904 vf_cfg->pmac_id = -1;
3905 }
3906 return 0;
3907 }
3908
be_vf_setup(struct be_adapter * adapter)3909 static int be_vf_setup(struct be_adapter *adapter)
3910 {
3911 struct device *dev = &adapter->pdev->dev;
3912 struct be_vf_cfg *vf_cfg;
3913 int status, old_vfs, vf;
3914 bool spoofchk;
3915
3916 old_vfs = pci_num_vf(adapter->pdev);
3917
3918 status = be_vf_setup_init(adapter);
3919 if (status)
3920 goto err;
3921
3922 if (old_vfs) {
3923 for_all_vfs(adapter, vf_cfg, vf) {
3924 status = be_cmd_get_if_id(adapter, vf_cfg, vf);
3925 if (status)
3926 goto err;
3927 }
3928
3929 status = be_vfs_mac_query(adapter);
3930 if (status)
3931 goto err;
3932 } else {
3933 status = be_vfs_if_create(adapter);
3934 if (status)
3935 goto err;
3936
3937 status = be_vf_eth_addr_config(adapter);
3938 if (status)
3939 goto err;
3940 }
3941
3942 for_all_vfs(adapter, vf_cfg, vf) {
3943 /* Allow VFs to programs MAC/VLAN filters */
3944 status = be_cmd_get_fn_privileges(adapter, &vf_cfg->privileges,
3945 vf + 1);
3946 if (!status && !(vf_cfg->privileges & BE_PRIV_FILTMGMT)) {
3947 status = be_cmd_set_fn_privileges(adapter,
3948 vf_cfg->privileges |
3949 BE_PRIV_FILTMGMT,
3950 vf + 1);
3951 if (!status) {
3952 vf_cfg->privileges |= BE_PRIV_FILTMGMT;
3953 dev_info(dev, "VF%d has FILTMGMT privilege\n",
3954 vf);
3955 }
3956 }
3957
3958 /* Allow full available bandwidth */
3959 if (!old_vfs)
3960 be_cmd_config_qos(adapter, 0, 0, vf + 1);
3961
3962 status = be_cmd_get_hsw_config(adapter, NULL, vf + 1,
3963 vf_cfg->if_handle, NULL,
3964 &spoofchk);
3965 if (!status)
3966 vf_cfg->spoofchk = spoofchk;
3967
3968 if (!old_vfs) {
3969 be_cmd_enable_vf(adapter, vf + 1);
3970 be_cmd_set_logical_link_config(adapter,
3971 IFLA_VF_LINK_STATE_AUTO,
3972 vf+1);
3973 }
3974 }
3975
3976 if (!old_vfs) {
3977 status = pci_enable_sriov(adapter->pdev, adapter->num_vfs);
3978 if (status) {
3979 dev_err(dev, "SRIOV enable failed\n");
3980 adapter->num_vfs = 0;
3981 goto err;
3982 }
3983 }
3984
3985 adapter->flags |= BE_FLAGS_SRIOV_ENABLED;
3986 return 0;
3987 err:
3988 dev_err(dev, "VF setup failed\n");
3989 be_vf_clear(adapter);
3990 return status;
3991 }
3992
3993 /* Converting function_mode bits on BE3 to SH mc_type enums */
3994
be_convert_mc_type(u32 function_mode)3995 static u8 be_convert_mc_type(u32 function_mode)
3996 {
3997 if (function_mode & VNIC_MODE && function_mode & QNQ_MODE)
3998 return vNIC1;
3999 else if (function_mode & QNQ_MODE)
4000 return FLEX10;
4001 else if (function_mode & VNIC_MODE)
4002 return vNIC2;
4003 else if (function_mode & UMC_ENABLED)
4004 return UMC;
4005 else
4006 return MC_NONE;
4007 }
4008
4009 /* On BE2/BE3 FW does not suggest the supported limits */
BEx_get_resources(struct be_adapter * adapter,struct be_resources * res)4010 static void BEx_get_resources(struct be_adapter *adapter,
4011 struct be_resources *res)
4012 {
4013 bool use_sriov = adapter->num_vfs ? 1 : 0;
4014
4015 if (be_physfn(adapter))
4016 res->max_uc_mac = BE_UC_PMAC_COUNT;
4017 else
4018 res->max_uc_mac = BE_VF_UC_PMAC_COUNT;
4019
4020 adapter->mc_type = be_convert_mc_type(adapter->function_mode);
4021
4022 if (be_is_mc(adapter)) {
4023 /* Assuming that there are 4 channels per port,
4024 * when multi-channel is enabled
4025 */
4026 if (be_is_qnq_mode(adapter))
4027 res->max_vlans = BE_NUM_VLANS_SUPPORTED/8;
4028 else
4029 /* In a non-qnq multichannel mode, the pvid
4030 * takes up one vlan entry
4031 */
4032 res->max_vlans = (BE_NUM_VLANS_SUPPORTED / 4) - 1;
4033 } else {
4034 res->max_vlans = BE_NUM_VLANS_SUPPORTED;
4035 }
4036
4037 res->max_mcast_mac = BE_MAX_MC;
4038
4039 /* 1) For BE3 1Gb ports, FW does not support multiple TXQs
4040 * 2) Create multiple TX rings on a BE3-R multi-channel interface
4041 * *only* if it is RSS-capable.
4042 */
4043 if (BE2_chip(adapter) || use_sriov || (adapter->port_num > 1) ||
4044 be_virtfn(adapter) ||
4045 (be_is_mc(adapter) &&
4046 !(adapter->function_caps & BE_FUNCTION_CAPS_RSS))) {
4047 res->max_tx_qs = 1;
4048 } else if (adapter->function_caps & BE_FUNCTION_CAPS_SUPER_NIC) {
4049 struct be_resources super_nic_res = {0};
4050
4051 /* On a SuperNIC profile, the driver needs to use the
4052 * GET_PROFILE_CONFIG cmd to query the per-function TXQ limits
4053 */
4054 be_cmd_get_profile_config(adapter, &super_nic_res,
4055 RESOURCE_LIMITS, 0);
4056 /* Some old versions of BE3 FW don't report max_tx_qs value */
4057 res->max_tx_qs = super_nic_res.max_tx_qs ? : BE3_MAX_TX_QS;
4058 } else {
4059 res->max_tx_qs = BE3_MAX_TX_QS;
4060 }
4061
4062 if ((adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
4063 !use_sriov && be_physfn(adapter))
4064 res->max_rss_qs = (adapter->be3_native) ?
4065 BE3_MAX_RSS_QS : BE2_MAX_RSS_QS;
4066 res->max_rx_qs = res->max_rss_qs + 1;
4067
4068 if (be_physfn(adapter))
4069 res->max_evt_qs = (be_max_vfs(adapter) > 0) ?
4070 BE3_SRIOV_MAX_EVT_QS : BE3_MAX_EVT_QS;
4071 else
4072 res->max_evt_qs = 1;
4073
4074 res->if_cap_flags = BE_IF_CAP_FLAGS_WANT;
4075 res->if_cap_flags &= ~BE_IF_FLAGS_DEFQ_RSS;
4076 if (!(adapter->function_caps & BE_FUNCTION_CAPS_RSS))
4077 res->if_cap_flags &= ~BE_IF_FLAGS_RSS;
4078 }
4079
be_setup_init(struct be_adapter * adapter)4080 static void be_setup_init(struct be_adapter *adapter)
4081 {
4082 adapter->vlan_prio_bmap = 0xff;
4083 adapter->phy.link_speed = -1;
4084 adapter->if_handle = -1;
4085 adapter->be3_native = false;
4086 adapter->if_flags = 0;
4087 if (be_physfn(adapter))
4088 adapter->cmd_privileges = MAX_PRIVILEGES;
4089 else
4090 adapter->cmd_privileges = MIN_PRIVILEGES;
4091 }
4092
be_get_sriov_config(struct be_adapter * adapter)4093 static int be_get_sriov_config(struct be_adapter *adapter)
4094 {
4095 struct be_resources res = {0};
4096 int max_vfs, old_vfs;
4097
4098 be_cmd_get_profile_config(adapter, &res, RESOURCE_LIMITS, 0);
4099
4100 /* Some old versions of BE3 FW don't report max_vfs value */
4101 if (BE3_chip(adapter) && !res.max_vfs) {
4102 max_vfs = pci_sriov_get_totalvfs(adapter->pdev);
4103 res.max_vfs = max_vfs > 0 ? min(MAX_VFS, max_vfs) : 0;
4104 }
4105
4106 adapter->pool_res = res;
4107
4108 /* If during previous unload of the driver, the VFs were not disabled,
4109 * then we cannot rely on the PF POOL limits for the TotalVFs value.
4110 * Instead use the TotalVFs value stored in the pci-dev struct.
4111 */
4112 old_vfs = pci_num_vf(adapter->pdev);
4113 if (old_vfs) {
4114 dev_info(&adapter->pdev->dev, "%d VFs are already enabled\n",
4115 old_vfs);
4116
4117 adapter->pool_res.max_vfs =
4118 pci_sriov_get_totalvfs(adapter->pdev);
4119 adapter->num_vfs = old_vfs;
4120 }
4121
4122 return 0;
4123 }
4124
be_alloc_sriov_res(struct be_adapter * adapter)4125 static void be_alloc_sriov_res(struct be_adapter *adapter)
4126 {
4127 int old_vfs = pci_num_vf(adapter->pdev);
4128 u16 num_vf_qs;
4129 int status;
4130
4131 be_get_sriov_config(adapter);
4132
4133 if (!old_vfs)
4134 pci_sriov_set_totalvfs(adapter->pdev, be_max_vfs(adapter));
4135
4136 /* When the HW is in SRIOV capable configuration, the PF-pool
4137 * resources are given to PF during driver load, if there are no
4138 * old VFs. This facility is not available in BE3 FW.
4139 * Also, this is done by FW in Lancer chip.
4140 */
4141 if (skyhawk_chip(adapter) && be_max_vfs(adapter) && !old_vfs) {
4142 num_vf_qs = be_calculate_vf_qs(adapter, 0);
4143 status = be_cmd_set_sriov_config(adapter, adapter->pool_res, 0,
4144 num_vf_qs);
4145 if (status)
4146 dev_err(&adapter->pdev->dev,
4147 "Failed to optimize SRIOV resources\n");
4148 }
4149 }
4150
be_get_resources(struct be_adapter * adapter)4151 static int be_get_resources(struct be_adapter *adapter)
4152 {
4153 struct device *dev = &adapter->pdev->dev;
4154 struct be_resources res = {0};
4155 int status;
4156
4157 if (BEx_chip(adapter)) {
4158 BEx_get_resources(adapter, &res);
4159 adapter->res = res;
4160 }
4161
4162 /* For Lancer, SH etc read per-function resource limits from FW.
4163 * GET_FUNC_CONFIG returns per function guaranteed limits.
4164 * GET_PROFILE_CONFIG returns PCI-E related limits PF-pool limits
4165 */
4166 if (!BEx_chip(adapter)) {
4167 status = be_cmd_get_func_config(adapter, &res);
4168 if (status)
4169 return status;
4170
4171 /* If a deafault RXQ must be created, we'll use up one RSSQ*/
4172 if (res.max_rss_qs && res.max_rss_qs == res.max_rx_qs &&
4173 !(res.if_cap_flags & BE_IF_FLAGS_DEFQ_RSS))
4174 res.max_rss_qs -= 1;
4175
4176 /* If RoCE may be enabled stash away half the EQs for RoCE */
4177 if (be_roce_supported(adapter))
4178 res.max_evt_qs /= 2;
4179 adapter->res = res;
4180 }
4181
4182 /* If FW supports RSS default queue, then skip creating non-RSS
4183 * queue for non-IP traffic.
4184 */
4185 adapter->need_def_rxq = (be_if_cap_flags(adapter) &
4186 BE_IF_FLAGS_DEFQ_RSS) ? 0 : 1;
4187
4188 dev_info(dev, "Max: txqs %d, rxqs %d, rss %d, eqs %d, vfs %d\n",
4189 be_max_txqs(adapter), be_max_rxqs(adapter),
4190 be_max_rss(adapter), be_max_eqs(adapter),
4191 be_max_vfs(adapter));
4192 dev_info(dev, "Max: uc-macs %d, mc-macs %d, vlans %d\n",
4193 be_max_uc(adapter), be_max_mc(adapter),
4194 be_max_vlans(adapter));
4195
4196 /* Sanitize cfg_num_qs based on HW and platform limits */
4197 adapter->cfg_num_qs = min_t(u16, netif_get_num_default_rss_queues(),
4198 be_max_qs(adapter));
4199 return 0;
4200 }
4201
be_get_config(struct be_adapter * adapter)4202 static int be_get_config(struct be_adapter *adapter)
4203 {
4204 int status, level;
4205 u16 profile_id;
4206
4207 status = be_cmd_query_fw_cfg(adapter);
4208 if (status)
4209 return status;
4210
4211 if (BEx_chip(adapter)) {
4212 level = be_cmd_get_fw_log_level(adapter);
4213 adapter->msg_enable =
4214 level <= FW_LOG_LEVEL_DEFAULT ? NETIF_MSG_HW : 0;
4215 }
4216
4217 be_cmd_get_acpi_wol_cap(adapter);
4218
4219 be_cmd_query_port_name(adapter);
4220
4221 if (be_physfn(adapter)) {
4222 status = be_cmd_get_active_profile(adapter, &profile_id);
4223 if (!status)
4224 dev_info(&adapter->pdev->dev,
4225 "Using profile 0x%x\n", profile_id);
4226 }
4227
4228 status = be_get_resources(adapter);
4229 if (status)
4230 return status;
4231
4232 adapter->pmac_id = kcalloc(be_max_uc(adapter),
4233 sizeof(*adapter->pmac_id), GFP_KERNEL);
4234 if (!adapter->pmac_id)
4235 return -ENOMEM;
4236
4237 return 0;
4238 }
4239
be_mac_setup(struct be_adapter * adapter)4240 static int be_mac_setup(struct be_adapter *adapter)
4241 {
4242 u8 mac[ETH_ALEN];
4243 int status;
4244
4245 if (is_zero_ether_addr(adapter->netdev->dev_addr)) {
4246 status = be_cmd_get_perm_mac(adapter, mac);
4247 if (status)
4248 return status;
4249
4250 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
4251 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
4252 }
4253
4254 return 0;
4255 }
4256
be_schedule_worker(struct be_adapter * adapter)4257 static void be_schedule_worker(struct be_adapter *adapter)
4258 {
4259 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
4260 adapter->flags |= BE_FLAGS_WORKER_SCHEDULED;
4261 }
4262
be_schedule_err_detection(struct be_adapter * adapter)4263 static void be_schedule_err_detection(struct be_adapter *adapter)
4264 {
4265 schedule_delayed_work(&adapter->be_err_detection_work,
4266 msecs_to_jiffies(1000));
4267 adapter->flags |= BE_FLAGS_ERR_DETECTION_SCHEDULED;
4268 }
4269
be_setup_queues(struct be_adapter * adapter)4270 static int be_setup_queues(struct be_adapter *adapter)
4271 {
4272 struct net_device *netdev = adapter->netdev;
4273 int status;
4274
4275 status = be_evt_queues_create(adapter);
4276 if (status)
4277 goto err;
4278
4279 status = be_tx_qs_create(adapter);
4280 if (status)
4281 goto err;
4282
4283 status = be_rx_cqs_create(adapter);
4284 if (status)
4285 goto err;
4286
4287 status = be_mcc_queues_create(adapter);
4288 if (status)
4289 goto err;
4290
4291 status = netif_set_real_num_rx_queues(netdev, adapter->num_rx_qs);
4292 if (status)
4293 goto err;
4294
4295 status = netif_set_real_num_tx_queues(netdev, adapter->num_tx_qs);
4296 if (status)
4297 goto err;
4298
4299 return 0;
4300 err:
4301 dev_err(&adapter->pdev->dev, "queue_setup failed\n");
4302 return status;
4303 }
4304
be_update_queues(struct be_adapter * adapter)4305 int be_update_queues(struct be_adapter *adapter)
4306 {
4307 struct net_device *netdev = adapter->netdev;
4308 int status;
4309
4310 if (netif_running(netdev))
4311 be_close(netdev);
4312
4313 be_cancel_worker(adapter);
4314
4315 /* If any vectors have been shared with RoCE we cannot re-program
4316 * the MSIx table.
4317 */
4318 if (!adapter->num_msix_roce_vec)
4319 be_msix_disable(adapter);
4320
4321 be_clear_queues(adapter);
4322
4323 if (!msix_enabled(adapter)) {
4324 status = be_msix_enable(adapter);
4325 if (status)
4326 return status;
4327 }
4328
4329 status = be_setup_queues(adapter);
4330 if (status)
4331 return status;
4332
4333 be_schedule_worker(adapter);
4334
4335 if (netif_running(netdev))
4336 status = be_open(netdev);
4337
4338 return status;
4339 }
4340
fw_major_num(const char * fw_ver)4341 static inline int fw_major_num(const char *fw_ver)
4342 {
4343 int fw_major = 0, i;
4344
4345 i = sscanf(fw_ver, "%d.", &fw_major);
4346 if (i != 1)
4347 return 0;
4348
4349 return fw_major;
4350 }
4351
4352 /* If any VFs are already enabled don't FLR the PF */
be_reset_required(struct be_adapter * adapter)4353 static bool be_reset_required(struct be_adapter *adapter)
4354 {
4355 return pci_num_vf(adapter->pdev) ? false : true;
4356 }
4357
4358 /* Wait for the FW to be ready and perform the required initialization */
be_func_init(struct be_adapter * adapter)4359 static int be_func_init(struct be_adapter *adapter)
4360 {
4361 int status;
4362
4363 status = be_fw_wait_ready(adapter);
4364 if (status)
4365 return status;
4366
4367 if (be_reset_required(adapter)) {
4368 status = be_cmd_reset_function(adapter);
4369 if (status)
4370 return status;
4371
4372 /* Wait for interrupts to quiesce after an FLR */
4373 msleep(100);
4374
4375 /* We can clear all errors when function reset succeeds */
4376 be_clear_error(adapter, BE_CLEAR_ALL);
4377 }
4378
4379 /* Tell FW we're ready to fire cmds */
4380 status = be_cmd_fw_init(adapter);
4381 if (status)
4382 return status;
4383
4384 /* Allow interrupts for other ULPs running on NIC function */
4385 be_intr_set(adapter, true);
4386
4387 return 0;
4388 }
4389
be_setup(struct be_adapter * adapter)4390 static int be_setup(struct be_adapter *adapter)
4391 {
4392 struct device *dev = &adapter->pdev->dev;
4393 u32 en_flags;
4394 int status;
4395
4396 status = be_func_init(adapter);
4397 if (status)
4398 return status;
4399
4400 be_setup_init(adapter);
4401
4402 if (!lancer_chip(adapter))
4403 be_cmd_req_native_mode(adapter);
4404
4405 /* Need to invoke this cmd first to get the PCI Function Number */
4406 status = be_cmd_get_cntl_attributes(adapter);
4407 if (status)
4408 return status;
4409
4410 if (!BE2_chip(adapter) && be_physfn(adapter))
4411 be_alloc_sriov_res(adapter);
4412
4413 status = be_get_config(adapter);
4414 if (status)
4415 goto err;
4416
4417 status = be_msix_enable(adapter);
4418 if (status)
4419 goto err;
4420
4421 /* will enable all the needed filter flags in be_open() */
4422 en_flags = BE_IF_FLAGS_RSS | BE_IF_FLAGS_DEFQ_RSS;
4423 en_flags = en_flags & be_if_cap_flags(adapter);
4424 status = be_cmd_if_create(adapter, be_if_cap_flags(adapter), en_flags,
4425 &adapter->if_handle, 0);
4426 if (status)
4427 goto err;
4428
4429 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
4430 rtnl_lock();
4431 status = be_setup_queues(adapter);
4432 rtnl_unlock();
4433 if (status)
4434 goto err;
4435
4436 be_cmd_get_fn_privileges(adapter, &adapter->cmd_privileges, 0);
4437
4438 status = be_mac_setup(adapter);
4439 if (status)
4440 goto err;
4441
4442 be_cmd_get_fw_ver(adapter);
4443 dev_info(dev, "FW version is %s\n", adapter->fw_ver);
4444
4445 if (BE2_chip(adapter) && fw_major_num(adapter->fw_ver) < 4) {
4446 dev_err(dev, "Firmware on card is old(%s), IRQs may not work",
4447 adapter->fw_ver);
4448 dev_err(dev, "Please upgrade firmware to version >= 4.0\n");
4449 }
4450
4451 status = be_cmd_set_flow_control(adapter, adapter->tx_fc,
4452 adapter->rx_fc);
4453 if (status)
4454 be_cmd_get_flow_control(adapter, &adapter->tx_fc,
4455 &adapter->rx_fc);
4456
4457 dev_info(&adapter->pdev->dev, "HW Flow control - TX:%d RX:%d\n",
4458 adapter->tx_fc, adapter->rx_fc);
4459
4460 if (be_physfn(adapter))
4461 be_cmd_set_logical_link_config(adapter,
4462 IFLA_VF_LINK_STATE_AUTO, 0);
4463
4464 if (adapter->num_vfs)
4465 be_vf_setup(adapter);
4466
4467 status = be_cmd_get_phy_info(adapter);
4468 if (!status && be_pause_supported(adapter))
4469 adapter->phy.fc_autoneg = 1;
4470
4471 be_schedule_worker(adapter);
4472 adapter->flags |= BE_FLAGS_SETUP_DONE;
4473 return 0;
4474 err:
4475 be_clear(adapter);
4476 return status;
4477 }
4478
4479 #ifdef CONFIG_NET_POLL_CONTROLLER
be_netpoll(struct net_device * netdev)4480 static void be_netpoll(struct net_device *netdev)
4481 {
4482 struct be_adapter *adapter = netdev_priv(netdev);
4483 struct be_eq_obj *eqo;
4484 int i;
4485
4486 for_all_evt_queues(adapter, eqo, i) {
4487 be_eq_notify(eqo->adapter, eqo->q.id, false, true, 0, 0);
4488 napi_schedule(&eqo->napi);
4489 }
4490 }
4491 #endif
4492
4493 static char flash_cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "};
4494
phy_flashing_required(struct be_adapter * adapter)4495 static bool phy_flashing_required(struct be_adapter *adapter)
4496 {
4497 return (adapter->phy.phy_type == PHY_TYPE_TN_8022 &&
4498 adapter->phy.interface_type == PHY_TYPE_BASET_10GB);
4499 }
4500
is_comp_in_ufi(struct be_adapter * adapter,struct flash_section_info * fsec,int type)4501 static bool is_comp_in_ufi(struct be_adapter *adapter,
4502 struct flash_section_info *fsec, int type)
4503 {
4504 int i = 0, img_type = 0;
4505 struct flash_section_info_g2 *fsec_g2 = NULL;
4506
4507 if (BE2_chip(adapter))
4508 fsec_g2 = (struct flash_section_info_g2 *)fsec;
4509
4510 for (i = 0; i < MAX_FLASH_COMP; i++) {
4511 if (fsec_g2)
4512 img_type = le32_to_cpu(fsec_g2->fsec_entry[i].type);
4513 else
4514 img_type = le32_to_cpu(fsec->fsec_entry[i].type);
4515
4516 if (img_type == type)
4517 return true;
4518 }
4519 return false;
4520
4521 }
4522
get_fsec_info(struct be_adapter * adapter,int header_size,const struct firmware * fw)4523 static struct flash_section_info *get_fsec_info(struct be_adapter *adapter,
4524 int header_size,
4525 const struct firmware *fw)
4526 {
4527 struct flash_section_info *fsec = NULL;
4528 const u8 *p = fw->data;
4529
4530 p += header_size;
4531 while (p < (fw->data + fw->size)) {
4532 fsec = (struct flash_section_info *)p;
4533 if (!memcmp(flash_cookie, fsec->cookie, sizeof(flash_cookie)))
4534 return fsec;
4535 p += 32;
4536 }
4537 return NULL;
4538 }
4539
be_check_flash_crc(struct be_adapter * adapter,const u8 * p,u32 img_offset,u32 img_size,int hdr_size,u16 img_optype,bool * crc_match)4540 static int be_check_flash_crc(struct be_adapter *adapter, const u8 *p,
4541 u32 img_offset, u32 img_size, int hdr_size,
4542 u16 img_optype, bool *crc_match)
4543 {
4544 u32 crc_offset;
4545 int status;
4546 u8 crc[4];
4547
4548 status = be_cmd_get_flash_crc(adapter, crc, img_optype, img_offset,
4549 img_size - 4);
4550 if (status)
4551 return status;
4552
4553 crc_offset = hdr_size + img_offset + img_size - 4;
4554
4555 /* Skip flashing, if crc of flashed region matches */
4556 if (!memcmp(crc, p + crc_offset, 4))
4557 *crc_match = true;
4558 else
4559 *crc_match = false;
4560
4561 return status;
4562 }
4563
be_flash(struct be_adapter * adapter,const u8 * img,struct be_dma_mem * flash_cmd,int optype,int img_size,u32 img_offset)4564 static int be_flash(struct be_adapter *adapter, const u8 *img,
4565 struct be_dma_mem *flash_cmd, int optype, int img_size,
4566 u32 img_offset)
4567 {
4568 u32 flash_op, num_bytes, total_bytes = img_size, bytes_sent = 0;
4569 struct be_cmd_write_flashrom *req = flash_cmd->va;
4570 int status;
4571
4572 while (total_bytes) {
4573 num_bytes = min_t(u32, 32*1024, total_bytes);
4574
4575 total_bytes -= num_bytes;
4576
4577 if (!total_bytes) {
4578 if (optype == OPTYPE_PHY_FW)
4579 flash_op = FLASHROM_OPER_PHY_FLASH;
4580 else
4581 flash_op = FLASHROM_OPER_FLASH;
4582 } else {
4583 if (optype == OPTYPE_PHY_FW)
4584 flash_op = FLASHROM_OPER_PHY_SAVE;
4585 else
4586 flash_op = FLASHROM_OPER_SAVE;
4587 }
4588
4589 memcpy(req->data_buf, img, num_bytes);
4590 img += num_bytes;
4591 status = be_cmd_write_flashrom(adapter, flash_cmd, optype,
4592 flash_op, img_offset +
4593 bytes_sent, num_bytes);
4594 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST &&
4595 optype == OPTYPE_PHY_FW)
4596 break;
4597 else if (status)
4598 return status;
4599
4600 bytes_sent += num_bytes;
4601 }
4602 return 0;
4603 }
4604
4605 /* For BE2, BE3 and BE3-R */
be_flash_BEx(struct be_adapter * adapter,const struct firmware * fw,struct be_dma_mem * flash_cmd,int num_of_images)4606 static int be_flash_BEx(struct be_adapter *adapter,
4607 const struct firmware *fw,
4608 struct be_dma_mem *flash_cmd, int num_of_images)
4609 {
4610 int img_hdrs_size = (num_of_images * sizeof(struct image_hdr));
4611 struct device *dev = &adapter->pdev->dev;
4612 struct flash_section_info *fsec = NULL;
4613 int status, i, filehdr_size, num_comp;
4614 const struct flash_comp *pflashcomp;
4615 bool crc_match;
4616 const u8 *p;
4617
4618 struct flash_comp gen3_flash_types[] = {
4619 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, OPTYPE_ISCSI_ACTIVE,
4620 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_iSCSI},
4621 { FLASH_REDBOOT_START_g3, OPTYPE_REDBOOT,
4622 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3, IMAGE_BOOT_CODE},
4623 { FLASH_iSCSI_BIOS_START_g3, OPTYPE_BIOS,
4624 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_ISCSI},
4625 { FLASH_PXE_BIOS_START_g3, OPTYPE_PXE_BIOS,
4626 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_PXE},
4627 { FLASH_FCoE_BIOS_START_g3, OPTYPE_FCOE_BIOS,
4628 FLASH_BIOS_IMAGE_MAX_SIZE_g3, IMAGE_OPTION_ROM_FCoE},
4629 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, OPTYPE_ISCSI_BACKUP,
4630 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_iSCSI},
4631 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, OPTYPE_FCOE_FW_ACTIVE,
4632 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_FCoE},
4633 { FLASH_FCoE_BACKUP_IMAGE_START_g3, OPTYPE_FCOE_FW_BACKUP,
4634 FLASH_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_BACKUP_FCoE},
4635 { FLASH_NCSI_START_g3, OPTYPE_NCSI_FW,
4636 FLASH_NCSI_IMAGE_MAX_SIZE_g3, IMAGE_NCSI},
4637 { FLASH_PHY_FW_START_g3, OPTYPE_PHY_FW,
4638 FLASH_PHY_FW_IMAGE_MAX_SIZE_g3, IMAGE_FIRMWARE_PHY}
4639 };
4640
4641 struct flash_comp gen2_flash_types[] = {
4642 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, OPTYPE_ISCSI_ACTIVE,
4643 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_iSCSI},
4644 { FLASH_REDBOOT_START_g2, OPTYPE_REDBOOT,
4645 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2, IMAGE_BOOT_CODE},
4646 { FLASH_iSCSI_BIOS_START_g2, OPTYPE_BIOS,
4647 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_ISCSI},
4648 { FLASH_PXE_BIOS_START_g2, OPTYPE_PXE_BIOS,
4649 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_PXE},
4650 { FLASH_FCoE_BIOS_START_g2, OPTYPE_FCOE_BIOS,
4651 FLASH_BIOS_IMAGE_MAX_SIZE_g2, IMAGE_OPTION_ROM_FCoE},
4652 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, OPTYPE_ISCSI_BACKUP,
4653 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_iSCSI},
4654 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, OPTYPE_FCOE_FW_ACTIVE,
4655 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_FCoE},
4656 { FLASH_FCoE_BACKUP_IMAGE_START_g2, OPTYPE_FCOE_FW_BACKUP,
4657 FLASH_IMAGE_MAX_SIZE_g2, IMAGE_FIRMWARE_BACKUP_FCoE}
4658 };
4659
4660 if (BE3_chip(adapter)) {
4661 pflashcomp = gen3_flash_types;
4662 filehdr_size = sizeof(struct flash_file_hdr_g3);
4663 num_comp = ARRAY_SIZE(gen3_flash_types);
4664 } else {
4665 pflashcomp = gen2_flash_types;
4666 filehdr_size = sizeof(struct flash_file_hdr_g2);
4667 num_comp = ARRAY_SIZE(gen2_flash_types);
4668 img_hdrs_size = 0;
4669 }
4670
4671 /* Get flash section info*/
4672 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4673 if (!fsec) {
4674 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4675 return -1;
4676 }
4677 for (i = 0; i < num_comp; i++) {
4678 if (!is_comp_in_ufi(adapter, fsec, pflashcomp[i].img_type))
4679 continue;
4680
4681 if ((pflashcomp[i].optype == OPTYPE_NCSI_FW) &&
4682 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
4683 continue;
4684
4685 if (pflashcomp[i].optype == OPTYPE_PHY_FW &&
4686 !phy_flashing_required(adapter))
4687 continue;
4688
4689 if (pflashcomp[i].optype == OPTYPE_REDBOOT) {
4690 status = be_check_flash_crc(adapter, fw->data,
4691 pflashcomp[i].offset,
4692 pflashcomp[i].size,
4693 filehdr_size +
4694 img_hdrs_size,
4695 OPTYPE_REDBOOT, &crc_match);
4696 if (status) {
4697 dev_err(dev,
4698 "Could not get CRC for 0x%x region\n",
4699 pflashcomp[i].optype);
4700 continue;
4701 }
4702
4703 if (crc_match)
4704 continue;
4705 }
4706
4707 p = fw->data + filehdr_size + pflashcomp[i].offset +
4708 img_hdrs_size;
4709 if (p + pflashcomp[i].size > fw->data + fw->size)
4710 return -1;
4711
4712 status = be_flash(adapter, p, flash_cmd, pflashcomp[i].optype,
4713 pflashcomp[i].size, 0);
4714 if (status) {
4715 dev_err(dev, "Flashing section type 0x%x failed\n",
4716 pflashcomp[i].img_type);
4717 return status;
4718 }
4719 }
4720 return 0;
4721 }
4722
be_get_img_optype(struct flash_section_entry fsec_entry)4723 static u16 be_get_img_optype(struct flash_section_entry fsec_entry)
4724 {
4725 u32 img_type = le32_to_cpu(fsec_entry.type);
4726 u16 img_optype = le16_to_cpu(fsec_entry.optype);
4727
4728 if (img_optype != 0xFFFF)
4729 return img_optype;
4730
4731 switch (img_type) {
4732 case IMAGE_FIRMWARE_iSCSI:
4733 img_optype = OPTYPE_ISCSI_ACTIVE;
4734 break;
4735 case IMAGE_BOOT_CODE:
4736 img_optype = OPTYPE_REDBOOT;
4737 break;
4738 case IMAGE_OPTION_ROM_ISCSI:
4739 img_optype = OPTYPE_BIOS;
4740 break;
4741 case IMAGE_OPTION_ROM_PXE:
4742 img_optype = OPTYPE_PXE_BIOS;
4743 break;
4744 case IMAGE_OPTION_ROM_FCoE:
4745 img_optype = OPTYPE_FCOE_BIOS;
4746 break;
4747 case IMAGE_FIRMWARE_BACKUP_iSCSI:
4748 img_optype = OPTYPE_ISCSI_BACKUP;
4749 break;
4750 case IMAGE_NCSI:
4751 img_optype = OPTYPE_NCSI_FW;
4752 break;
4753 case IMAGE_FLASHISM_JUMPVECTOR:
4754 img_optype = OPTYPE_FLASHISM_JUMPVECTOR;
4755 break;
4756 case IMAGE_FIRMWARE_PHY:
4757 img_optype = OPTYPE_SH_PHY_FW;
4758 break;
4759 case IMAGE_REDBOOT_DIR:
4760 img_optype = OPTYPE_REDBOOT_DIR;
4761 break;
4762 case IMAGE_REDBOOT_CONFIG:
4763 img_optype = OPTYPE_REDBOOT_CONFIG;
4764 break;
4765 case IMAGE_UFI_DIR:
4766 img_optype = OPTYPE_UFI_DIR;
4767 break;
4768 default:
4769 break;
4770 }
4771
4772 return img_optype;
4773 }
4774
be_flash_skyhawk(struct be_adapter * adapter,const struct firmware * fw,struct be_dma_mem * flash_cmd,int num_of_images)4775 static int be_flash_skyhawk(struct be_adapter *adapter,
4776 const struct firmware *fw,
4777 struct be_dma_mem *flash_cmd, int num_of_images)
4778 {
4779 int img_hdrs_size = num_of_images * sizeof(struct image_hdr);
4780 bool crc_match, old_fw_img, flash_offset_support = true;
4781 struct device *dev = &adapter->pdev->dev;
4782 struct flash_section_info *fsec = NULL;
4783 u32 img_offset, img_size, img_type;
4784 u16 img_optype, flash_optype;
4785 int status, i, filehdr_size;
4786 const u8 *p;
4787
4788 filehdr_size = sizeof(struct flash_file_hdr_g3);
4789 fsec = get_fsec_info(adapter, filehdr_size + img_hdrs_size, fw);
4790 if (!fsec) {
4791 dev_err(dev, "Invalid Cookie. FW image may be corrupted\n");
4792 return -EINVAL;
4793 }
4794
4795 retry_flash:
4796 for (i = 0; i < le32_to_cpu(fsec->fsec_hdr.num_images); i++) {
4797 img_offset = le32_to_cpu(fsec->fsec_entry[i].offset);
4798 img_size = le32_to_cpu(fsec->fsec_entry[i].pad_size);
4799 img_type = le32_to_cpu(fsec->fsec_entry[i].type);
4800 img_optype = be_get_img_optype(fsec->fsec_entry[i]);
4801 old_fw_img = fsec->fsec_entry[i].optype == 0xFFFF;
4802
4803 if (img_optype == 0xFFFF)
4804 continue;
4805
4806 if (flash_offset_support)
4807 flash_optype = OPTYPE_OFFSET_SPECIFIED;
4808 else
4809 flash_optype = img_optype;
4810
4811 /* Don't bother verifying CRC if an old FW image is being
4812 * flashed
4813 */
4814 if (old_fw_img)
4815 goto flash;
4816
4817 status = be_check_flash_crc(adapter, fw->data, img_offset,
4818 img_size, filehdr_size +
4819 img_hdrs_size, flash_optype,
4820 &crc_match);
4821 if (base_status(status) == MCC_STATUS_ILLEGAL_REQUEST ||
4822 base_status(status) == MCC_STATUS_ILLEGAL_FIELD) {
4823 /* The current FW image on the card does not support
4824 * OFFSET based flashing. Retry using older mechanism
4825 * of OPTYPE based flashing
4826 */
4827 if (flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4828 flash_offset_support = false;
4829 goto retry_flash;
4830 }
4831
4832 /* The current FW image on the card does not recognize
4833 * the new FLASH op_type. The FW download is partially
4834 * complete. Reboot the server now to enable FW image
4835 * to recognize the new FLASH op_type. To complete the
4836 * remaining process, download the same FW again after
4837 * the reboot.
4838 */
4839 dev_err(dev, "Flash incomplete. Reset the server\n");
4840 dev_err(dev, "Download FW image again after reset\n");
4841 return -EAGAIN;
4842 } else if (status) {
4843 dev_err(dev, "Could not get CRC for 0x%x region\n",
4844 img_optype);
4845 return -EFAULT;
4846 }
4847
4848 if (crc_match)
4849 continue;
4850
4851 flash:
4852 p = fw->data + filehdr_size + img_offset + img_hdrs_size;
4853 if (p + img_size > fw->data + fw->size)
4854 return -1;
4855
4856 status = be_flash(adapter, p, flash_cmd, flash_optype, img_size,
4857 img_offset);
4858
4859 /* The current FW image on the card does not support OFFSET
4860 * based flashing. Retry using older mechanism of OPTYPE based
4861 * flashing
4862 */
4863 if (base_status(status) == MCC_STATUS_ILLEGAL_FIELD &&
4864 flash_optype == OPTYPE_OFFSET_SPECIFIED) {
4865 flash_offset_support = false;
4866 goto retry_flash;
4867 }
4868
4869 /* For old FW images ignore ILLEGAL_FIELD error or errors on
4870 * UFI_DIR region
4871 */
4872 if (old_fw_img &&
4873 (base_status(status) == MCC_STATUS_ILLEGAL_FIELD ||
4874 (img_optype == OPTYPE_UFI_DIR &&
4875 base_status(status) == MCC_STATUS_FAILED))) {
4876 continue;
4877 } else if (status) {
4878 dev_err(dev, "Flashing section type 0x%x failed\n",
4879 img_type);
4880 return -EFAULT;
4881 }
4882 }
4883 return 0;
4884 }
4885
lancer_fw_download(struct be_adapter * adapter,const struct firmware * fw)4886 static int lancer_fw_download(struct be_adapter *adapter,
4887 const struct firmware *fw)
4888 {
4889 #define LANCER_FW_DOWNLOAD_CHUNK (32 * 1024)
4890 #define LANCER_FW_DOWNLOAD_LOCATION "/prg"
4891 struct device *dev = &adapter->pdev->dev;
4892 struct be_dma_mem flash_cmd;
4893 const u8 *data_ptr = NULL;
4894 u8 *dest_image_ptr = NULL;
4895 size_t image_size = 0;
4896 u32 chunk_size = 0;
4897 u32 data_written = 0;
4898 u32 offset = 0;
4899 int status = 0;
4900 u8 add_status = 0;
4901 u8 change_status;
4902
4903 if (!IS_ALIGNED(fw->size, sizeof(u32))) {
4904 dev_err(dev, "FW image size should be multiple of 4\n");
4905 return -EINVAL;
4906 }
4907
4908 flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
4909 + LANCER_FW_DOWNLOAD_CHUNK;
4910 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
4911 &flash_cmd.dma, GFP_KERNEL);
4912 if (!flash_cmd.va)
4913 return -ENOMEM;
4914
4915 dest_image_ptr = flash_cmd.va +
4916 sizeof(struct lancer_cmd_req_write_object);
4917 image_size = fw->size;
4918 data_ptr = fw->data;
4919
4920 while (image_size) {
4921 chunk_size = min_t(u32, image_size, LANCER_FW_DOWNLOAD_CHUNK);
4922
4923 /* Copy the image chunk content. */
4924 memcpy(dest_image_ptr, data_ptr, chunk_size);
4925
4926 status = lancer_cmd_write_object(adapter, &flash_cmd,
4927 chunk_size, offset,
4928 LANCER_FW_DOWNLOAD_LOCATION,
4929 &data_written, &change_status,
4930 &add_status);
4931 if (status)
4932 break;
4933
4934 offset += data_written;
4935 data_ptr += data_written;
4936 image_size -= data_written;
4937 }
4938
4939 if (!status) {
4940 /* Commit the FW written */
4941 status = lancer_cmd_write_object(adapter, &flash_cmd,
4942 0, offset,
4943 LANCER_FW_DOWNLOAD_LOCATION,
4944 &data_written, &change_status,
4945 &add_status);
4946 }
4947
4948 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
4949 if (status) {
4950 dev_err(dev, "Firmware load error\n");
4951 return be_cmd_status(status);
4952 }
4953
4954 dev_info(dev, "Firmware flashed successfully\n");
4955
4956 if (change_status == LANCER_FW_RESET_NEEDED) {
4957 dev_info(dev, "Resetting adapter to activate new FW\n");
4958 status = lancer_physdev_ctrl(adapter,
4959 PHYSDEV_CONTROL_FW_RESET_MASK);
4960 if (status) {
4961 dev_err(dev, "Adapter busy, could not reset FW\n");
4962 dev_err(dev, "Reboot server to activate new FW\n");
4963 }
4964 } else if (change_status != LANCER_NO_RESET_NEEDED) {
4965 dev_info(dev, "Reboot server to activate new FW\n");
4966 }
4967
4968 return 0;
4969 }
4970
4971 /* Check if the flash image file is compatible with the adapter that
4972 * is being flashed.
4973 */
be_check_ufi_compatibility(struct be_adapter * adapter,struct flash_file_hdr_g3 * fhdr)4974 static bool be_check_ufi_compatibility(struct be_adapter *adapter,
4975 struct flash_file_hdr_g3 *fhdr)
4976 {
4977 if (!fhdr) {
4978 dev_err(&adapter->pdev->dev, "Invalid FW UFI file");
4979 return false;
4980 }
4981
4982 /* First letter of the build version is used to identify
4983 * which chip this image file is meant for.
4984 */
4985 switch (fhdr->build[0]) {
4986 case BLD_STR_UFI_TYPE_SH:
4987 if (!skyhawk_chip(adapter))
4988 return false;
4989 break;
4990 case BLD_STR_UFI_TYPE_BE3:
4991 if (!BE3_chip(adapter))
4992 return false;
4993 break;
4994 case BLD_STR_UFI_TYPE_BE2:
4995 if (!BE2_chip(adapter))
4996 return false;
4997 break;
4998 default:
4999 return false;
5000 }
5001
5002 /* In BE3 FW images the "asic_type_rev" field doesn't track the
5003 * asic_rev of the chips it is compatible with.
5004 * When asic_type_rev is 0 the image is compatible only with
5005 * pre-BE3-R chips (asic_rev < 0x10)
5006 */
5007 if (BEx_chip(adapter) && fhdr->asic_type_rev == 0)
5008 return adapter->asic_rev < 0x10;
5009 else
5010 return (fhdr->asic_type_rev >= adapter->asic_rev);
5011 }
5012
be_fw_download(struct be_adapter * adapter,const struct firmware * fw)5013 static int be_fw_download(struct be_adapter *adapter, const struct firmware* fw)
5014 {
5015 struct device *dev = &adapter->pdev->dev;
5016 struct flash_file_hdr_g3 *fhdr3;
5017 struct image_hdr *img_hdr_ptr;
5018 int status = 0, i, num_imgs;
5019 struct be_dma_mem flash_cmd;
5020
5021 fhdr3 = (struct flash_file_hdr_g3 *)fw->data;
5022 if (!be_check_ufi_compatibility(adapter, fhdr3)) {
5023 dev_err(dev, "Flash image is not compatible with adapter\n");
5024 return -EINVAL;
5025 }
5026
5027 flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
5028 flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
5029 GFP_KERNEL);
5030 if (!flash_cmd.va)
5031 return -ENOMEM;
5032
5033 num_imgs = le32_to_cpu(fhdr3->num_imgs);
5034 for (i = 0; i < num_imgs; i++) {
5035 img_hdr_ptr = (struct image_hdr *)(fw->data +
5036 (sizeof(struct flash_file_hdr_g3) +
5037 i * sizeof(struct image_hdr)));
5038 if (!BE2_chip(adapter) &&
5039 le32_to_cpu(img_hdr_ptr->imageid) != 1)
5040 continue;
5041
5042 if (skyhawk_chip(adapter))
5043 status = be_flash_skyhawk(adapter, fw, &flash_cmd,
5044 num_imgs);
5045 else
5046 status = be_flash_BEx(adapter, fw, &flash_cmd,
5047 num_imgs);
5048 }
5049
5050 dma_free_coherent(dev, flash_cmd.size, flash_cmd.va, flash_cmd.dma);
5051 if (!status)
5052 dev_info(dev, "Firmware flashed successfully\n");
5053
5054 return status;
5055 }
5056
be_load_fw(struct be_adapter * adapter,u8 * fw_file)5057 int be_load_fw(struct be_adapter *adapter, u8 *fw_file)
5058 {
5059 const struct firmware *fw;
5060 int status;
5061
5062 if (!netif_running(adapter->netdev)) {
5063 dev_err(&adapter->pdev->dev,
5064 "Firmware load not allowed (interface is down)\n");
5065 return -ENETDOWN;
5066 }
5067
5068 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
5069 if (status)
5070 goto fw_exit;
5071
5072 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
5073
5074 if (lancer_chip(adapter))
5075 status = lancer_fw_download(adapter, fw);
5076 else
5077 status = be_fw_download(adapter, fw);
5078
5079 if (!status)
5080 be_cmd_get_fw_ver(adapter);
5081
5082 fw_exit:
5083 release_firmware(fw);
5084 return status;
5085 }
5086
be_ndo_bridge_setlink(struct net_device * dev,struct nlmsghdr * nlh,u16 flags)5087 static int be_ndo_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
5088 u16 flags)
5089 {
5090 struct be_adapter *adapter = netdev_priv(dev);
5091 struct nlattr *attr, *br_spec;
5092 int rem;
5093 int status = 0;
5094 u16 mode = 0;
5095
5096 if (!sriov_enabled(adapter))
5097 return -EOPNOTSUPP;
5098
5099 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
5100 if (!br_spec)
5101 return -EINVAL;
5102
5103 nla_for_each_nested(attr, br_spec, rem) {
5104 if (nla_type(attr) != IFLA_BRIDGE_MODE)
5105 continue;
5106
5107 if (nla_len(attr) < sizeof(mode))
5108 return -EINVAL;
5109
5110 mode = nla_get_u16(attr);
5111 if (mode != BRIDGE_MODE_VEPA && mode != BRIDGE_MODE_VEB)
5112 return -EINVAL;
5113
5114 status = be_cmd_set_hsw_config(adapter, 0, 0,
5115 adapter->if_handle,
5116 mode == BRIDGE_MODE_VEPA ?
5117 PORT_FWD_TYPE_VEPA :
5118 PORT_FWD_TYPE_VEB, 0);
5119 if (status)
5120 goto err;
5121
5122 dev_info(&adapter->pdev->dev, "enabled switch mode: %s\n",
5123 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5124
5125 return status;
5126 }
5127 err:
5128 dev_err(&adapter->pdev->dev, "Failed to set switch mode %s\n",
5129 mode == BRIDGE_MODE_VEPA ? "VEPA" : "VEB");
5130
5131 return status;
5132 }
5133
be_ndo_bridge_getlink(struct sk_buff * skb,u32 pid,u32 seq,struct net_device * dev,u32 filter_mask,int nlflags)5134 static int be_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
5135 struct net_device *dev, u32 filter_mask,
5136 int nlflags)
5137 {
5138 struct be_adapter *adapter = netdev_priv(dev);
5139 int status = 0;
5140 u8 hsw_mode;
5141
5142 /* BE and Lancer chips support VEB mode only */
5143 if (BEx_chip(adapter) || lancer_chip(adapter)) {
5144 hsw_mode = PORT_FWD_TYPE_VEB;
5145 } else {
5146 status = be_cmd_get_hsw_config(adapter, NULL, 0,
5147 adapter->if_handle, &hsw_mode,
5148 NULL);
5149 if (status)
5150 return 0;
5151
5152 if (hsw_mode == PORT_FWD_TYPE_PASSTHRU)
5153 return 0;
5154 }
5155
5156 return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
5157 hsw_mode == PORT_FWD_TYPE_VEPA ?
5158 BRIDGE_MODE_VEPA : BRIDGE_MODE_VEB,
5159 0, 0, nlflags, filter_mask, NULL);
5160 }
5161
5162 #ifdef CONFIG_BE2NET_VXLAN
5163 /* VxLAN offload Notes:
5164 *
5165 * The stack defines tunnel offload flags (hw_enc_features) for IP and doesn't
5166 * distinguish various types of transports (VxLAN, GRE, NVGRE ..). So, offload
5167 * is expected to work across all types of IP tunnels once exported. Skyhawk
5168 * supports offloads for either VxLAN or NVGRE, exclusively. So we export VxLAN
5169 * offloads in hw_enc_features only when a VxLAN port is added. If other (non
5170 * VxLAN) tunnels are configured while VxLAN offloads are enabled, offloads for
5171 * those other tunnels are unexported on the fly through ndo_features_check().
5172 *
5173 * Skyhawk supports VxLAN offloads only for one UDP dport. So, if the stack
5174 * adds more than one port, disable offloads and don't re-enable them again
5175 * until after all the tunnels are removed.
5176 */
be_add_vxlan_port(struct net_device * netdev,sa_family_t sa_family,__be16 port)5177 static void be_add_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5178 __be16 port)
5179 {
5180 struct be_adapter *adapter = netdev_priv(netdev);
5181 struct device *dev = &adapter->pdev->dev;
5182 int status;
5183
5184 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5185 return;
5186
5187 if (adapter->vxlan_port == port && adapter->vxlan_port_count) {
5188 adapter->vxlan_port_aliases++;
5189 return;
5190 }
5191
5192 if (adapter->flags & BE_FLAGS_VXLAN_OFFLOADS) {
5193 dev_info(dev,
5194 "Only one UDP port supported for VxLAN offloads\n");
5195 dev_info(dev, "Disabling VxLAN offloads\n");
5196 adapter->vxlan_port_count++;
5197 goto err;
5198 }
5199
5200 if (adapter->vxlan_port_count++ >= 1)
5201 return;
5202
5203 status = be_cmd_manage_iface(adapter, adapter->if_handle,
5204 OP_CONVERT_NORMAL_TO_TUNNEL);
5205 if (status) {
5206 dev_warn(dev, "Failed to convert normal interface to tunnel\n");
5207 goto err;
5208 }
5209
5210 status = be_cmd_set_vxlan_port(adapter, port);
5211 if (status) {
5212 dev_warn(dev, "Failed to add VxLAN port\n");
5213 goto err;
5214 }
5215 adapter->flags |= BE_FLAGS_VXLAN_OFFLOADS;
5216 adapter->vxlan_port = port;
5217
5218 netdev->hw_enc_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
5219 NETIF_F_TSO | NETIF_F_TSO6 |
5220 NETIF_F_GSO_UDP_TUNNEL;
5221 netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
5222 netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
5223
5224 dev_info(dev, "Enabled VxLAN offloads for UDP port %d\n",
5225 be16_to_cpu(port));
5226 return;
5227 err:
5228 be_disable_vxlan_offloads(adapter);
5229 }
5230
be_del_vxlan_port(struct net_device * netdev,sa_family_t sa_family,__be16 port)5231 static void be_del_vxlan_port(struct net_device *netdev, sa_family_t sa_family,
5232 __be16 port)
5233 {
5234 struct be_adapter *adapter = netdev_priv(netdev);
5235
5236 if (lancer_chip(adapter) || BEx_chip(adapter) || be_is_mc(adapter))
5237 return;
5238
5239 if (adapter->vxlan_port != port)
5240 goto done;
5241
5242 if (adapter->vxlan_port_aliases) {
5243 adapter->vxlan_port_aliases--;
5244 return;
5245 }
5246
5247 be_disable_vxlan_offloads(adapter);
5248
5249 dev_info(&adapter->pdev->dev,
5250 "Disabled VxLAN offloads for UDP port %d\n",
5251 be16_to_cpu(port));
5252 done:
5253 adapter->vxlan_port_count--;
5254 }
5255
be_features_check(struct sk_buff * skb,struct net_device * dev,netdev_features_t features)5256 static netdev_features_t be_features_check(struct sk_buff *skb,
5257 struct net_device *dev,
5258 netdev_features_t features)
5259 {
5260 struct be_adapter *adapter = netdev_priv(dev);
5261 u8 l4_hdr = 0;
5262
5263 /* The code below restricts offload features for some tunneled packets.
5264 * Offload features for normal (non tunnel) packets are unchanged.
5265 */
5266 if (!skb->encapsulation ||
5267 !(adapter->flags & BE_FLAGS_VXLAN_OFFLOADS))
5268 return features;
5269
5270 /* It's an encapsulated packet and VxLAN offloads are enabled. We
5271 * should disable tunnel offload features if it's not a VxLAN packet,
5272 * as tunnel offloads have been enabled only for VxLAN. This is done to
5273 * allow other tunneled traffic like GRE work fine while VxLAN
5274 * offloads are configured in Skyhawk-R.
5275 */
5276 switch (vlan_get_protocol(skb)) {
5277 case htons(ETH_P_IP):
5278 l4_hdr = ip_hdr(skb)->protocol;
5279 break;
5280 case htons(ETH_P_IPV6):
5281 l4_hdr = ipv6_hdr(skb)->nexthdr;
5282 break;
5283 default:
5284 return features;
5285 }
5286
5287 if (l4_hdr != IPPROTO_UDP ||
5288 skb->inner_protocol_type != ENCAP_TYPE_ETHER ||
5289 skb->inner_protocol != htons(ETH_P_TEB) ||
5290 skb_inner_mac_header(skb) - skb_transport_header(skb) !=
5291 sizeof(struct udphdr) + sizeof(struct vxlanhdr))
5292 return features & ~(NETIF_F_ALL_CSUM | NETIF_F_GSO_MASK);
5293
5294 return features;
5295 }
5296 #endif
5297
be_get_phys_port_id(struct net_device * dev,struct netdev_phys_item_id * ppid)5298 static int be_get_phys_port_id(struct net_device *dev,
5299 struct netdev_phys_item_id *ppid)
5300 {
5301 int i, id_len = CNTL_SERIAL_NUM_WORDS * CNTL_SERIAL_NUM_WORD_SZ + 1;
5302 struct be_adapter *adapter = netdev_priv(dev);
5303 u8 *id;
5304
5305 if (MAX_PHYS_ITEM_ID_LEN < id_len)
5306 return -ENOSPC;
5307
5308 ppid->id[0] = adapter->hba_port_num + 1;
5309 id = &ppid->id[1];
5310 for (i = CNTL_SERIAL_NUM_WORDS - 1; i >= 0;
5311 i--, id += CNTL_SERIAL_NUM_WORD_SZ)
5312 memcpy(id, &adapter->serial_num[i], CNTL_SERIAL_NUM_WORD_SZ);
5313
5314 ppid->id_len = id_len;
5315
5316 return 0;
5317 }
5318
5319 static const struct net_device_ops be_netdev_ops = {
5320 .ndo_open = be_open,
5321 .ndo_stop = be_close,
5322 .ndo_start_xmit = be_xmit,
5323 .ndo_set_rx_mode = be_set_rx_mode,
5324 .ndo_set_mac_address = be_mac_addr_set,
5325 .ndo_change_mtu = be_change_mtu,
5326 .ndo_get_stats64 = be_get_stats64,
5327 .ndo_validate_addr = eth_validate_addr,
5328 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
5329 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
5330 .ndo_set_vf_mac = be_set_vf_mac,
5331 .ndo_set_vf_vlan = be_set_vf_vlan,
5332 .ndo_set_vf_rate = be_set_vf_tx_rate,
5333 .ndo_get_vf_config = be_get_vf_config,
5334 .ndo_set_vf_link_state = be_set_vf_link_state,
5335 .ndo_set_vf_spoofchk = be_set_vf_spoofchk,
5336 #ifdef CONFIG_NET_POLL_CONTROLLER
5337 .ndo_poll_controller = be_netpoll,
5338 #endif
5339 .ndo_bridge_setlink = be_ndo_bridge_setlink,
5340 .ndo_bridge_getlink = be_ndo_bridge_getlink,
5341 #ifdef CONFIG_NET_RX_BUSY_POLL
5342 .ndo_busy_poll = be_busy_poll,
5343 #endif
5344 #ifdef CONFIG_BE2NET_VXLAN
5345 .ndo_add_vxlan_port = be_add_vxlan_port,
5346 .ndo_del_vxlan_port = be_del_vxlan_port,
5347 .ndo_features_check = be_features_check,
5348 #endif
5349 .ndo_get_phys_port_id = be_get_phys_port_id,
5350 };
5351
be_netdev_init(struct net_device * netdev)5352 static void be_netdev_init(struct net_device *netdev)
5353 {
5354 struct be_adapter *adapter = netdev_priv(netdev);
5355
5356 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5357 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
5358 NETIF_F_HW_VLAN_CTAG_TX;
5359 if (be_multi_rxq(adapter))
5360 netdev->hw_features |= NETIF_F_RXHASH;
5361
5362 netdev->features |= netdev->hw_features |
5363 NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_CTAG_FILTER;
5364
5365 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
5366 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
5367
5368 netdev->priv_flags |= IFF_UNICAST_FLT;
5369
5370 netdev->flags |= IFF_MULTICAST;
5371
5372 netif_set_gso_max_size(netdev, 65535 - ETH_HLEN);
5373
5374 netdev->netdev_ops = &be_netdev_ops;
5375
5376 netdev->ethtool_ops = &be_ethtool_ops;
5377 }
5378
be_cleanup(struct be_adapter * adapter)5379 static void be_cleanup(struct be_adapter *adapter)
5380 {
5381 struct net_device *netdev = adapter->netdev;
5382
5383 rtnl_lock();
5384 netif_device_detach(netdev);
5385 if (netif_running(netdev))
5386 be_close(netdev);
5387 rtnl_unlock();
5388
5389 be_clear(adapter);
5390 }
5391
be_resume(struct be_adapter * adapter)5392 static int be_resume(struct be_adapter *adapter)
5393 {
5394 struct net_device *netdev = adapter->netdev;
5395 int status;
5396
5397 status = be_setup(adapter);
5398 if (status)
5399 return status;
5400
5401 if (netif_running(netdev)) {
5402 status = be_open(netdev);
5403 if (status)
5404 return status;
5405 }
5406
5407 netif_device_attach(netdev);
5408
5409 return 0;
5410 }
5411
be_err_recover(struct be_adapter * adapter)5412 static int be_err_recover(struct be_adapter *adapter)
5413 {
5414 struct device *dev = &adapter->pdev->dev;
5415 int status;
5416
5417 status = be_resume(adapter);
5418 if (status)
5419 goto err;
5420
5421 dev_info(dev, "Adapter recovery successful\n");
5422 return 0;
5423 err:
5424 if (be_physfn(adapter))
5425 dev_err(dev, "Adapter recovery failed\n");
5426 else
5427 dev_err(dev, "Re-trying adapter recovery\n");
5428
5429 return status;
5430 }
5431
be_err_detection_task(struct work_struct * work)5432 static void be_err_detection_task(struct work_struct *work)
5433 {
5434 struct be_adapter *adapter =
5435 container_of(work, struct be_adapter,
5436 be_err_detection_work.work);
5437 int status = 0;
5438
5439 be_detect_error(adapter);
5440
5441 if (be_check_error(adapter, BE_ERROR_HW)) {
5442 be_cleanup(adapter);
5443
5444 /* As of now error recovery support is in Lancer only */
5445 if (lancer_chip(adapter))
5446 status = be_err_recover(adapter);
5447 }
5448
5449 /* Always attempt recovery on VFs */
5450 if (!status || be_virtfn(adapter))
5451 be_schedule_err_detection(adapter);
5452 }
5453
be_log_sfp_info(struct be_adapter * adapter)5454 static void be_log_sfp_info(struct be_adapter *adapter)
5455 {
5456 int status;
5457
5458 status = be_cmd_query_sfp_info(adapter);
5459 if (!status) {
5460 dev_err(&adapter->pdev->dev,
5461 "Unqualified SFP+ detected on %c from %s part no: %s",
5462 adapter->port_name, adapter->phy.vendor_name,
5463 adapter->phy.vendor_pn);
5464 }
5465 adapter->flags &= ~BE_FLAGS_EVT_INCOMPATIBLE_SFP;
5466 }
5467
be_worker(struct work_struct * work)5468 static void be_worker(struct work_struct *work)
5469 {
5470 struct be_adapter *adapter =
5471 container_of(work, struct be_adapter, work.work);
5472 struct be_rx_obj *rxo;
5473 int i;
5474
5475 /* when interrupts are not yet enabled, just reap any pending
5476 * mcc completions
5477 */
5478 if (!netif_running(adapter->netdev)) {
5479 local_bh_disable();
5480 be_process_mcc(adapter);
5481 local_bh_enable();
5482 goto reschedule;
5483 }
5484
5485 if (!adapter->stats_cmd_sent) {
5486 if (lancer_chip(adapter))
5487 lancer_cmd_get_pport_stats(adapter,
5488 &adapter->stats_cmd);
5489 else
5490 be_cmd_get_stats(adapter, &adapter->stats_cmd);
5491 }
5492
5493 if (be_physfn(adapter) &&
5494 MODULO(adapter->work_counter, adapter->be_get_temp_freq) == 0)
5495 be_cmd_get_die_temperature(adapter);
5496
5497 for_all_rx_queues(adapter, rxo, i) {
5498 /* Replenish RX-queues starved due to memory
5499 * allocation failures.
5500 */
5501 if (rxo->rx_post_starved)
5502 be_post_rx_frags(rxo, GFP_KERNEL, MAX_RX_POST);
5503 }
5504
5505 /* EQ-delay update for Skyhawk is done while notifying EQ */
5506 if (!skyhawk_chip(adapter))
5507 be_eqd_update(adapter, false);
5508
5509 if (adapter->flags & BE_FLAGS_EVT_INCOMPATIBLE_SFP)
5510 be_log_sfp_info(adapter);
5511
5512 reschedule:
5513 adapter->work_counter++;
5514 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
5515 }
5516
be_unmap_pci_bars(struct be_adapter * adapter)5517 static void be_unmap_pci_bars(struct be_adapter *adapter)
5518 {
5519 if (adapter->csr)
5520 pci_iounmap(adapter->pdev, adapter->csr);
5521 if (adapter->db)
5522 pci_iounmap(adapter->pdev, adapter->db);
5523 }
5524
db_bar(struct be_adapter * adapter)5525 static int db_bar(struct be_adapter *adapter)
5526 {
5527 if (lancer_chip(adapter) || be_virtfn(adapter))
5528 return 0;
5529 else
5530 return 4;
5531 }
5532
be_roce_map_pci_bars(struct be_adapter * adapter)5533 static int be_roce_map_pci_bars(struct be_adapter *adapter)
5534 {
5535 if (skyhawk_chip(adapter)) {
5536 adapter->roce_db.size = 4096;
5537 adapter->roce_db.io_addr = pci_resource_start(adapter->pdev,
5538 db_bar(adapter));
5539 adapter->roce_db.total_size = pci_resource_len(adapter->pdev,
5540 db_bar(adapter));
5541 }
5542 return 0;
5543 }
5544
be_map_pci_bars(struct be_adapter * adapter)5545 static int be_map_pci_bars(struct be_adapter *adapter)
5546 {
5547 struct pci_dev *pdev = adapter->pdev;
5548 u8 __iomem *addr;
5549 u32 sli_intf;
5550
5551 pci_read_config_dword(adapter->pdev, SLI_INTF_REG_OFFSET, &sli_intf);
5552 adapter->sli_family = (sli_intf & SLI_INTF_FAMILY_MASK) >>
5553 SLI_INTF_FAMILY_SHIFT;
5554 adapter->virtfn = (sli_intf & SLI_INTF_FT_MASK) ? 1 : 0;
5555
5556 if (BEx_chip(adapter) && be_physfn(adapter)) {
5557 adapter->csr = pci_iomap(pdev, 2, 0);
5558 if (!adapter->csr)
5559 return -ENOMEM;
5560 }
5561
5562 addr = pci_iomap(pdev, db_bar(adapter), 0);
5563 if (!addr)
5564 goto pci_map_err;
5565 adapter->db = addr;
5566
5567 if (skyhawk_chip(adapter) || BEx_chip(adapter)) {
5568 if (be_physfn(adapter)) {
5569 /* PCICFG is the 2nd BAR in BE2 */
5570 addr = pci_iomap(pdev, BE2_chip(adapter) ? 1 : 0, 0);
5571 if (!addr)
5572 goto pci_map_err;
5573 adapter->pcicfg = addr;
5574 } else {
5575 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
5576 }
5577 }
5578
5579 be_roce_map_pci_bars(adapter);
5580 return 0;
5581
5582 pci_map_err:
5583 dev_err(&pdev->dev, "Error in mapping PCI BARs\n");
5584 be_unmap_pci_bars(adapter);
5585 return -ENOMEM;
5586 }
5587
be_drv_cleanup(struct be_adapter * adapter)5588 static void be_drv_cleanup(struct be_adapter *adapter)
5589 {
5590 struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
5591 struct device *dev = &adapter->pdev->dev;
5592
5593 if (mem->va)
5594 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5595
5596 mem = &adapter->rx_filter;
5597 if (mem->va)
5598 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5599
5600 mem = &adapter->stats_cmd;
5601 if (mem->va)
5602 dma_free_coherent(dev, mem->size, mem->va, mem->dma);
5603 }
5604
5605 /* Allocate and initialize various fields in be_adapter struct */
be_drv_init(struct be_adapter * adapter)5606 static int be_drv_init(struct be_adapter *adapter)
5607 {
5608 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
5609 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
5610 struct be_dma_mem *rx_filter = &adapter->rx_filter;
5611 struct be_dma_mem *stats_cmd = &adapter->stats_cmd;
5612 struct device *dev = &adapter->pdev->dev;
5613 int status = 0;
5614
5615 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
5616 mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
5617 &mbox_mem_alloc->dma,
5618 GFP_KERNEL);
5619 if (!mbox_mem_alloc->va)
5620 return -ENOMEM;
5621
5622 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
5623 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
5624 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
5625
5626 rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
5627 rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
5628 &rx_filter->dma, GFP_KERNEL);
5629 if (!rx_filter->va) {
5630 status = -ENOMEM;
5631 goto free_mbox;
5632 }
5633
5634 if (lancer_chip(adapter))
5635 stats_cmd->size = sizeof(struct lancer_cmd_req_pport_stats);
5636 else if (BE2_chip(adapter))
5637 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v0);
5638 else if (BE3_chip(adapter))
5639 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
5640 else
5641 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
5642 stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
5643 &stats_cmd->dma, GFP_KERNEL);
5644 if (!stats_cmd->va) {
5645 status = -ENOMEM;
5646 goto free_rx_filter;
5647 }
5648
5649 mutex_init(&adapter->mbox_lock);
5650 spin_lock_init(&adapter->mcc_lock);
5651 spin_lock_init(&adapter->mcc_cq_lock);
5652 init_completion(&adapter->et_cmd_compl);
5653
5654 pci_save_state(adapter->pdev);
5655
5656 INIT_DELAYED_WORK(&adapter->work, be_worker);
5657 INIT_DELAYED_WORK(&adapter->be_err_detection_work,
5658 be_err_detection_task);
5659
5660 adapter->rx_fc = true;
5661 adapter->tx_fc = true;
5662
5663 /* Must be a power of 2 or else MODULO will BUG_ON */
5664 adapter->be_get_temp_freq = 64;
5665
5666 return 0;
5667
5668 free_rx_filter:
5669 dma_free_coherent(dev, rx_filter->size, rx_filter->va, rx_filter->dma);
5670 free_mbox:
5671 dma_free_coherent(dev, mbox_mem_alloc->size, mbox_mem_alloc->va,
5672 mbox_mem_alloc->dma);
5673 return status;
5674 }
5675
be_remove(struct pci_dev * pdev)5676 static void be_remove(struct pci_dev *pdev)
5677 {
5678 struct be_adapter *adapter = pci_get_drvdata(pdev);
5679
5680 if (!adapter)
5681 return;
5682
5683 be_roce_dev_remove(adapter);
5684 be_intr_set(adapter, false);
5685
5686 be_cancel_err_detection(adapter);
5687
5688 unregister_netdev(adapter->netdev);
5689
5690 be_clear(adapter);
5691
5692 /* tell fw we're done with firing cmds */
5693 be_cmd_fw_clean(adapter);
5694
5695 be_unmap_pci_bars(adapter);
5696 be_drv_cleanup(adapter);
5697
5698 pci_disable_pcie_error_reporting(pdev);
5699
5700 pci_release_regions(pdev);
5701 pci_disable_device(pdev);
5702
5703 free_netdev(adapter->netdev);
5704 }
5705
be_hwmon_show_temp(struct device * dev,struct device_attribute * dev_attr,char * buf)5706 static ssize_t be_hwmon_show_temp(struct device *dev,
5707 struct device_attribute *dev_attr,
5708 char *buf)
5709 {
5710 struct be_adapter *adapter = dev_get_drvdata(dev);
5711
5712 /* Unit: millidegree Celsius */
5713 if (adapter->hwmon_info.be_on_die_temp == BE_INVALID_DIE_TEMP)
5714 return -EIO;
5715 else
5716 return sprintf(buf, "%u\n",
5717 adapter->hwmon_info.be_on_die_temp * 1000);
5718 }
5719
5720 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
5721 be_hwmon_show_temp, NULL, 1);
5722
5723 static struct attribute *be_hwmon_attrs[] = {
5724 &sensor_dev_attr_temp1_input.dev_attr.attr,
5725 NULL
5726 };
5727
5728 ATTRIBUTE_GROUPS(be_hwmon);
5729
mc_name(struct be_adapter * adapter)5730 static char *mc_name(struct be_adapter *adapter)
5731 {
5732 char *str = ""; /* default */
5733
5734 switch (adapter->mc_type) {
5735 case UMC:
5736 str = "UMC";
5737 break;
5738 case FLEX10:
5739 str = "FLEX10";
5740 break;
5741 case vNIC1:
5742 str = "vNIC-1";
5743 break;
5744 case nPAR:
5745 str = "nPAR";
5746 break;
5747 case UFP:
5748 str = "UFP";
5749 break;
5750 case vNIC2:
5751 str = "vNIC-2";
5752 break;
5753 default:
5754 str = "";
5755 }
5756
5757 return str;
5758 }
5759
func_name(struct be_adapter * adapter)5760 static inline char *func_name(struct be_adapter *adapter)
5761 {
5762 return be_physfn(adapter) ? "PF" : "VF";
5763 }
5764
nic_name(struct pci_dev * pdev)5765 static inline char *nic_name(struct pci_dev *pdev)
5766 {
5767 switch (pdev->device) {
5768 case OC_DEVICE_ID1:
5769 return OC_NAME;
5770 case OC_DEVICE_ID2:
5771 return OC_NAME_BE;
5772 case OC_DEVICE_ID3:
5773 case OC_DEVICE_ID4:
5774 return OC_NAME_LANCER;
5775 case BE_DEVICE_ID2:
5776 return BE3_NAME;
5777 case OC_DEVICE_ID5:
5778 case OC_DEVICE_ID6:
5779 return OC_NAME_SH;
5780 default:
5781 return BE_NAME;
5782 }
5783 }
5784
be_probe(struct pci_dev * pdev,const struct pci_device_id * pdev_id)5785 static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
5786 {
5787 struct be_adapter *adapter;
5788 struct net_device *netdev;
5789 int status = 0;
5790
5791 dev_info(&pdev->dev, "%s version is %s\n", DRV_NAME, DRV_VER);
5792
5793 status = pci_enable_device(pdev);
5794 if (status)
5795 goto do_none;
5796
5797 status = pci_request_regions(pdev, DRV_NAME);
5798 if (status)
5799 goto disable_dev;
5800 pci_set_master(pdev);
5801
5802 netdev = alloc_etherdev_mqs(sizeof(*adapter), MAX_TX_QS, MAX_RX_QS);
5803 if (!netdev) {
5804 status = -ENOMEM;
5805 goto rel_reg;
5806 }
5807 adapter = netdev_priv(netdev);
5808 adapter->pdev = pdev;
5809 pci_set_drvdata(pdev, adapter);
5810 adapter->netdev = netdev;
5811 SET_NETDEV_DEV(netdev, &pdev->dev);
5812
5813 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
5814 if (!status) {
5815 netdev->features |= NETIF_F_HIGHDMA;
5816 } else {
5817 status = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
5818 if (status) {
5819 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
5820 goto free_netdev;
5821 }
5822 }
5823
5824 status = pci_enable_pcie_error_reporting(pdev);
5825 if (!status)
5826 dev_info(&pdev->dev, "PCIe error reporting enabled\n");
5827
5828 status = be_map_pci_bars(adapter);
5829 if (status)
5830 goto free_netdev;
5831
5832 status = be_drv_init(adapter);
5833 if (status)
5834 goto unmap_bars;
5835
5836 status = be_setup(adapter);
5837 if (status)
5838 goto drv_cleanup;
5839
5840 be_netdev_init(netdev);
5841 status = register_netdev(netdev);
5842 if (status != 0)
5843 goto unsetup;
5844
5845 be_roce_dev_add(adapter);
5846
5847 be_schedule_err_detection(adapter);
5848
5849 /* On Die temperature not supported for VF. */
5850 if (be_physfn(adapter) && IS_ENABLED(CONFIG_BE2NET_HWMON)) {
5851 adapter->hwmon_info.hwmon_dev =
5852 devm_hwmon_device_register_with_groups(&pdev->dev,
5853 DRV_NAME,
5854 adapter,
5855 be_hwmon_groups);
5856 adapter->hwmon_info.be_on_die_temp = BE_INVALID_DIE_TEMP;
5857 }
5858
5859 dev_info(&pdev->dev, "%s: %s %s port %c\n", nic_name(pdev),
5860 func_name(adapter), mc_name(adapter), adapter->port_name);
5861
5862 return 0;
5863
5864 unsetup:
5865 be_clear(adapter);
5866 drv_cleanup:
5867 be_drv_cleanup(adapter);
5868 unmap_bars:
5869 be_unmap_pci_bars(adapter);
5870 free_netdev:
5871 free_netdev(netdev);
5872 rel_reg:
5873 pci_release_regions(pdev);
5874 disable_dev:
5875 pci_disable_device(pdev);
5876 do_none:
5877 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
5878 return status;
5879 }
5880
be_suspend(struct pci_dev * pdev,pm_message_t state)5881 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
5882 {
5883 struct be_adapter *adapter = pci_get_drvdata(pdev);
5884
5885 if (adapter->wol_en)
5886 be_setup_wol(adapter, true);
5887
5888 be_intr_set(adapter, false);
5889 be_cancel_err_detection(adapter);
5890
5891 be_cleanup(adapter);
5892
5893 pci_save_state(pdev);
5894 pci_disable_device(pdev);
5895 pci_set_power_state(pdev, pci_choose_state(pdev, state));
5896 return 0;
5897 }
5898
be_pci_resume(struct pci_dev * pdev)5899 static int be_pci_resume(struct pci_dev *pdev)
5900 {
5901 struct be_adapter *adapter = pci_get_drvdata(pdev);
5902 int status = 0;
5903
5904 status = pci_enable_device(pdev);
5905 if (status)
5906 return status;
5907
5908 pci_restore_state(pdev);
5909
5910 status = be_resume(adapter);
5911 if (status)
5912 return status;
5913
5914 be_schedule_err_detection(adapter);
5915
5916 if (adapter->wol_en)
5917 be_setup_wol(adapter, false);
5918
5919 return 0;
5920 }
5921
5922 /*
5923 * An FLR will stop BE from DMAing any data.
5924 */
be_shutdown(struct pci_dev * pdev)5925 static void be_shutdown(struct pci_dev *pdev)
5926 {
5927 struct be_adapter *adapter = pci_get_drvdata(pdev);
5928
5929 if (!adapter)
5930 return;
5931
5932 be_roce_dev_shutdown(adapter);
5933 cancel_delayed_work_sync(&adapter->work);
5934 be_cancel_err_detection(adapter);
5935
5936 netif_device_detach(adapter->netdev);
5937
5938 be_cmd_reset_function(adapter);
5939
5940 pci_disable_device(pdev);
5941 }
5942
be_eeh_err_detected(struct pci_dev * pdev,pci_channel_state_t state)5943 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
5944 pci_channel_state_t state)
5945 {
5946 struct be_adapter *adapter = pci_get_drvdata(pdev);
5947
5948 dev_err(&adapter->pdev->dev, "EEH error detected\n");
5949
5950 if (!be_check_error(adapter, BE_ERROR_EEH)) {
5951 be_set_error(adapter, BE_ERROR_EEH);
5952
5953 be_cancel_err_detection(adapter);
5954
5955 be_cleanup(adapter);
5956 }
5957
5958 if (state == pci_channel_io_perm_failure)
5959 return PCI_ERS_RESULT_DISCONNECT;
5960
5961 pci_disable_device(pdev);
5962
5963 /* The error could cause the FW to trigger a flash debug dump.
5964 * Resetting the card while flash dump is in progress
5965 * can cause it not to recover; wait for it to finish.
5966 * Wait only for first function as it is needed only once per
5967 * adapter.
5968 */
5969 if (pdev->devfn == 0)
5970 ssleep(30);
5971
5972 return PCI_ERS_RESULT_NEED_RESET;
5973 }
5974
be_eeh_reset(struct pci_dev * pdev)5975 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
5976 {
5977 struct be_adapter *adapter = pci_get_drvdata(pdev);
5978 int status;
5979
5980 dev_info(&adapter->pdev->dev, "EEH reset\n");
5981
5982 status = pci_enable_device(pdev);
5983 if (status)
5984 return PCI_ERS_RESULT_DISCONNECT;
5985
5986 pci_set_master(pdev);
5987 pci_restore_state(pdev);
5988
5989 /* Check if card is ok and fw is ready */
5990 dev_info(&adapter->pdev->dev,
5991 "Waiting for FW to be ready after EEH reset\n");
5992 status = be_fw_wait_ready(adapter);
5993 if (status)
5994 return PCI_ERS_RESULT_DISCONNECT;
5995
5996 pci_cleanup_aer_uncorrect_error_status(pdev);
5997 be_clear_error(adapter, BE_CLEAR_ALL);
5998 return PCI_ERS_RESULT_RECOVERED;
5999 }
6000
be_eeh_resume(struct pci_dev * pdev)6001 static void be_eeh_resume(struct pci_dev *pdev)
6002 {
6003 int status = 0;
6004 struct be_adapter *adapter = pci_get_drvdata(pdev);
6005
6006 dev_info(&adapter->pdev->dev, "EEH resume\n");
6007
6008 pci_save_state(pdev);
6009
6010 status = be_resume(adapter);
6011 if (status)
6012 goto err;
6013
6014 be_schedule_err_detection(adapter);
6015 return;
6016 err:
6017 dev_err(&adapter->pdev->dev, "EEH resume failed\n");
6018 }
6019
be_pci_sriov_configure(struct pci_dev * pdev,int num_vfs)6020 static int be_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
6021 {
6022 struct be_adapter *adapter = pci_get_drvdata(pdev);
6023 u16 num_vf_qs;
6024 int status;
6025
6026 if (!num_vfs)
6027 be_vf_clear(adapter);
6028
6029 adapter->num_vfs = num_vfs;
6030
6031 if (adapter->num_vfs == 0 && pci_vfs_assigned(pdev)) {
6032 dev_warn(&pdev->dev,
6033 "Cannot disable VFs while they are assigned\n");
6034 return -EBUSY;
6035 }
6036
6037 /* When the HW is in SRIOV capable configuration, the PF-pool resources
6038 * are equally distributed across the max-number of VFs. The user may
6039 * request only a subset of the max-vfs to be enabled.
6040 * Based on num_vfs, redistribute the resources across num_vfs so that
6041 * each VF will have access to more number of resources.
6042 * This facility is not available in BE3 FW.
6043 * Also, this is done by FW in Lancer chip.
6044 */
6045 if (skyhawk_chip(adapter) && !pci_num_vf(pdev)) {
6046 num_vf_qs = be_calculate_vf_qs(adapter, adapter->num_vfs);
6047 status = be_cmd_set_sriov_config(adapter, adapter->pool_res,
6048 adapter->num_vfs, num_vf_qs);
6049 if (status)
6050 dev_err(&pdev->dev,
6051 "Failed to optimize SR-IOV resources\n");
6052 }
6053
6054 status = be_get_resources(adapter);
6055 if (status)
6056 return be_cmd_status(status);
6057
6058 /* Updating real_num_tx/rx_queues() requires rtnl_lock() */
6059 rtnl_lock();
6060 status = be_update_queues(adapter);
6061 rtnl_unlock();
6062 if (status)
6063 return be_cmd_status(status);
6064
6065 if (adapter->num_vfs)
6066 status = be_vf_setup(adapter);
6067
6068 if (!status)
6069 return adapter->num_vfs;
6070
6071 return 0;
6072 }
6073
6074 static const struct pci_error_handlers be_eeh_handlers = {
6075 .error_detected = be_eeh_err_detected,
6076 .slot_reset = be_eeh_reset,
6077 .resume = be_eeh_resume,
6078 };
6079
6080 static struct pci_driver be_driver = {
6081 .name = DRV_NAME,
6082 .id_table = be_dev_ids,
6083 .probe = be_probe,
6084 .remove = be_remove,
6085 .suspend = be_suspend,
6086 .resume = be_pci_resume,
6087 .shutdown = be_shutdown,
6088 .sriov_configure = be_pci_sriov_configure,
6089 .err_handler = &be_eeh_handlers
6090 };
6091
be_init_module(void)6092 static int __init be_init_module(void)
6093 {
6094 if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
6095 rx_frag_size != 2048) {
6096 printk(KERN_WARNING DRV_NAME
6097 " : Module param rx_frag_size must be 2048/4096/8192."
6098 " Using 2048\n");
6099 rx_frag_size = 2048;
6100 }
6101
6102 if (num_vfs > 0) {
6103 pr_info(DRV_NAME " : Module param num_vfs is obsolete.");
6104 pr_info(DRV_NAME " : Use sysfs method to enable VFs\n");
6105 }
6106
6107 return pci_register_driver(&be_driver);
6108 }
6109 module_init(be_init_module);
6110
be_exit_module(void)6111 static void __exit be_exit_module(void)
6112 {
6113 pci_unregister_driver(&be_driver);
6114 }
6115 module_exit(be_exit_module);
6116