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