projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'tipc-May10-2011' of git://git.kernel.org/pub/scm/linux/kernel/git/paulg...
[deliverable/linux.git] / drivers / net / benet / be_main.c
1 /*
2 * Copyright (C) 2005 - 2011 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 "be.h"
19 #include "be_cmds.h"
20 #include <asm/div64.h>
21
22 MODULE_VERSION(DRV_VER);
23 MODULE_DEVICE_TABLE(pci, be_dev_ids);
24 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
25 MODULE_AUTHOR("ServerEngines Corporation");
26 MODULE_LICENSE("GPL");
27
28 static ushort rx_frag_size = 2048;
29 static unsigned int num_vfs;
30 module_param(rx_frag_size, ushort, S_IRUGO);
31 module_param(num_vfs, uint, S_IRUGO);
32 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
33 MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
34
35 static bool multi_rxq = true;
36 module_param(multi_rxq, bool, S_IRUGO | S_IWUSR);
37 MODULE_PARM_DESC(multi_rxq, "Multi Rx Queue support. Enabled by default");
38
39 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
40 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
41 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
42 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
43 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
44 { PCI_DEVICE(EMULEX_VENDOR_ID, OC_DEVICE_ID3)},
45 { 0 }
46 };
47 MODULE_DEVICE_TABLE(pci, be_dev_ids);
48 /* UE Status Low CSR */
49 static char *ue_status_low_desc[] = {
50 "CEV",
51 "CTX",
52 "DBUF",
53 "ERX",
54 "Host",
55 "MPU",
56 "NDMA",
57 "PTC ",
58 "RDMA ",
59 "RXF ",
60 "RXIPS ",
61 "RXULP0 ",
62 "RXULP1 ",
63 "RXULP2 ",
64 "TIM ",
65 "TPOST ",
66 "TPRE ",
67 "TXIPS ",
68 "TXULP0 ",
69 "TXULP1 ",
70 "UC ",
71 "WDMA ",
72 "TXULP2 ",
73 "HOST1 ",
74 "P0_OB_LINK ",
75 "P1_OB_LINK ",
76 "HOST_GPIO ",
77 "MBOX ",
78 "AXGMAC0",
79 "AXGMAC1",
80 "JTAG",
81 "MPU_INTPEND"
82 };
83 /* UE Status High CSR */
84 static char *ue_status_hi_desc[] = {
85 "LPCMEMHOST",
86 "MGMT_MAC",
87 "PCS0ONLINE",
88 "MPU_IRAM",
89 "PCS1ONLINE",
90 "PCTL0",
91 "PCTL1",
92 "PMEM",
93 "RR",
94 "TXPB",
95 "RXPP",
96 "XAUI",
97 "TXP",
98 "ARM",
99 "IPC",
100 "HOST2",
101 "HOST3",
102 "HOST4",
103 "HOST5",
104 "HOST6",
105 "HOST7",
106 "HOST8",
107 "HOST9",
108 "NETC"
109 "Unknown",
110 "Unknown",
111 "Unknown",
112 "Unknown",
113 "Unknown",
114 "Unknown",
115 "Unknown",
116 "Unknown"
117 };
118
119 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
120 {
121 struct be_dma_mem *mem = &q->dma_mem;
122 if (mem->va)
123 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
124 mem->dma);
125 }
126
127 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
128 u16 len, u16 entry_size)
129 {
130 struct be_dma_mem *mem = &q->dma_mem;
131
132 memset(q, 0, sizeof(*q));
133 q->len = len;
134 q->entry_size = entry_size;
135 mem->size = len * entry_size;
136 mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
137 GFP_KERNEL);
138 if (!mem->va)
139 return -1;
140 memset(mem->va, 0, mem->size);
141 return 0;
142 }
143
144 static void be_intr_set(struct be_adapter *adapter, bool enable)
145 {
146 u8 __iomem *addr = adapter->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET;
147 u32 reg = ioread32(addr);
148 u32 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
149
150 if (adapter->eeh_err)
151 return;
152
153 if (!enabled && enable)
154 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
155 else if (enabled && !enable)
156 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
157 else
158 return;
159
160 iowrite32(reg, addr);
161 }
162
163 static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
164 {
165 u32 val = 0;
166 val |= qid & DB_RQ_RING_ID_MASK;
167 val |= posted << DB_RQ_NUM_POSTED_SHIFT;
168
169 wmb();
170 iowrite32(val, adapter->db + DB_RQ_OFFSET);
171 }
172
173 static void be_txq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
174 {
175 u32 val = 0;
176 val |= qid & DB_TXULP_RING_ID_MASK;
177 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
178
179 wmb();
180 iowrite32(val, adapter->db + DB_TXULP1_OFFSET);
181 }
182
183 static void be_eq_notify(struct be_adapter *adapter, u16 qid,
184 bool arm, bool clear_int, u16 num_popped)
185 {
186 u32 val = 0;
187 val |= qid & DB_EQ_RING_ID_MASK;
188 val |= ((qid & DB_EQ_RING_ID_EXT_MASK) <<
189 DB_EQ_RING_ID_EXT_MASK_SHIFT);
190
191 if (adapter->eeh_err)
192 return;
193
194 if (arm)
195 val |= 1 << DB_EQ_REARM_SHIFT;
196 if (clear_int)
197 val |= 1 << DB_EQ_CLR_SHIFT;
198 val |= 1 << DB_EQ_EVNT_SHIFT;
199 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
200 iowrite32(val, adapter->db + DB_EQ_OFFSET);
201 }
202
203 void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
204 {
205 u32 val = 0;
206 val |= qid & DB_CQ_RING_ID_MASK;
207 val |= ((qid & DB_CQ_RING_ID_EXT_MASK) <<
208 DB_CQ_RING_ID_EXT_MASK_SHIFT);
209
210 if (adapter->eeh_err)
211 return;
212
213 if (arm)
214 val |= 1 << DB_CQ_REARM_SHIFT;
215 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
216 iowrite32(val, adapter->db + DB_CQ_OFFSET);
217 }
218
219 static int be_mac_addr_set(struct net_device *netdev, void *p)
220 {
221 struct be_adapter *adapter = netdev_priv(netdev);
222 struct sockaddr *addr = p;
223 int status = 0;
224
225 if (!is_valid_ether_addr(addr->sa_data))
226 return -EADDRNOTAVAIL;
227
228 /* MAC addr configuration will be done in hardware for VFs
229 * by their corresponding PFs. Just copy to netdev addr here
230 */
231 if (!be_physfn(adapter))
232 goto netdev_addr;
233
234 status = be_cmd_pmac_del(adapter, adapter->if_handle,
235 adapter->pmac_id, 0);
236 if (status)
237 return status;
238
239 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
240 adapter->if_handle, &adapter->pmac_id, 0);
241 netdev_addr:
242 if (!status)
243 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
244
245 return status;
246 }
247
248 void netdev_stats_update(struct be_adapter *adapter)
249 {
250 struct be_hw_stats *hw_stats = hw_stats_from_cmd(adapter->stats_cmd.va);
251 struct be_rxf_stats *rxf_stats = &hw_stats->rxf;
252 struct be_port_rxf_stats *port_stats =
253 &rxf_stats->port[adapter->port_num];
254 struct net_device_stats *dev_stats = &adapter->netdev->stats;
255 struct be_erx_stats *erx_stats = &hw_stats->erx;
256 struct be_rx_obj *rxo;
257 int i;
258
259 memset(dev_stats, 0, sizeof(*dev_stats));
260 for_all_rx_queues(adapter, rxo, i) {
261 dev_stats->rx_packets += rx_stats(rxo)->rx_pkts;
262 dev_stats->rx_bytes += rx_stats(rxo)->rx_bytes;
263 dev_stats->multicast += rx_stats(rxo)->rx_mcast_pkts;
264 /* no space in linux buffers: best possible approximation */
265 dev_stats->rx_dropped +=
266 erx_stats->rx_drops_no_fragments[rxo->q.id];
267 }
268
269 dev_stats->tx_packets = tx_stats(adapter)->be_tx_pkts;
270 dev_stats->tx_bytes = tx_stats(adapter)->be_tx_bytes;
271
272 /* bad pkts received */
273 dev_stats->rx_errors = port_stats->rx_crc_errors +
274 port_stats->rx_alignment_symbol_errors +
275 port_stats->rx_in_range_errors +
276 port_stats->rx_out_range_errors +
277 port_stats->rx_frame_too_long +
278 port_stats->rx_dropped_too_small +
279 port_stats->rx_dropped_too_short +
280 port_stats->rx_dropped_header_too_small +
281 port_stats->rx_dropped_tcp_length +
282 port_stats->rx_dropped_runt +
283 port_stats->rx_tcp_checksum_errs +
284 port_stats->rx_ip_checksum_errs +
285 port_stats->rx_udp_checksum_errs;
286
287 /* detailed rx errors */
288 dev_stats->rx_length_errors = port_stats->rx_in_range_errors +
289 port_stats->rx_out_range_errors +
290 port_stats->rx_frame_too_long;
291
292 dev_stats->rx_crc_errors = port_stats->rx_crc_errors;
293
294 /* frame alignment errors */
295 dev_stats->rx_frame_errors = port_stats->rx_alignment_symbol_errors;
296
297 /* receiver fifo overrun */
298 /* drops_no_pbuf is no per i/f, it's per BE card */
299 dev_stats->rx_fifo_errors = port_stats->rx_fifo_overflow +
300 port_stats->rx_input_fifo_overflow +
301 rxf_stats->rx_drops_no_pbuf;
302 }
303
304 void be_link_status_update(struct be_adapter *adapter, bool link_up)
305 {
306 struct net_device *netdev = adapter->netdev;
307
308 /* If link came up or went down */
309 if (adapter->link_up != link_up) {
310 adapter->link_speed = -1;
311 if (link_up) {
312 netif_carrier_on(netdev);
313 printk(KERN_INFO "%s: Link up\n", netdev->name);
314 } else {
315 netif_carrier_off(netdev);
316 printk(KERN_INFO "%s: Link down\n", netdev->name);
317 }
318 adapter->link_up = link_up;
319 }
320 }
321
322 /* Update the EQ delay n BE based on the RX frags consumed / sec */
323 static void be_rx_eqd_update(struct be_adapter *adapter, struct be_rx_obj *rxo)
324 {
325 struct be_eq_obj *rx_eq = &rxo->rx_eq;
326 struct be_rx_stats *stats = &rxo->stats;
327 ulong now = jiffies;
328 u32 eqd;
329
330 if (!rx_eq->enable_aic)
331 return;
332
333 /* Wrapped around */
334 if (time_before(now, stats->rx_fps_jiffies)) {
335 stats->rx_fps_jiffies = now;
336 return;
337 }
338
339 /* Update once a second */
340 if ((now - stats->rx_fps_jiffies) < HZ)
341 return;
342
343 stats->rx_fps = (stats->rx_frags - stats->prev_rx_frags) /
344 ((now - stats->rx_fps_jiffies) / HZ);
345
346 stats->rx_fps_jiffies = now;
347 stats->prev_rx_frags = stats->rx_frags;
348 eqd = stats->rx_fps / 110000;
349 eqd = eqd << 3;
350 if (eqd > rx_eq->max_eqd)
351 eqd = rx_eq->max_eqd;
352 if (eqd < rx_eq->min_eqd)
353 eqd = rx_eq->min_eqd;
354 if (eqd < 10)
355 eqd = 0;
356 if (eqd != rx_eq->cur_eqd)
357 be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);
358
359 rx_eq->cur_eqd = eqd;
360 }
361
362 static u32 be_calc_rate(u64 bytes, unsigned long ticks)
363 {
364 u64 rate = bytes;
365
366 do_div(rate, ticks / HZ);
367 rate <<= 3; /* bytes/sec -> bits/sec */
368 do_div(rate, 1000000ul); /* MB/Sec */
369
370 return rate;
371 }
372
373 static void be_tx_rate_update(struct be_adapter *adapter)
374 {
375 struct be_tx_stats *stats = tx_stats(adapter);
376 ulong now = jiffies;
377
378 /* Wrapped around? */
379 if (time_before(now, stats->be_tx_jiffies)) {
380 stats->be_tx_jiffies = now;
381 return;
382 }
383
384 /* Update tx rate once in two seconds */
385 if ((now - stats->be_tx_jiffies) > 2 * HZ) {
386 stats->be_tx_rate = be_calc_rate(stats->be_tx_bytes
387 - stats->be_tx_bytes_prev,
388 now - stats->be_tx_jiffies);
389 stats->be_tx_jiffies = now;
390 stats->be_tx_bytes_prev = stats->be_tx_bytes;
391 }
392 }
393
394 static void be_tx_stats_update(struct be_adapter *adapter,
395 u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
396 {
397 struct be_tx_stats *stats = tx_stats(adapter);
398 stats->be_tx_reqs++;
399 stats->be_tx_wrbs += wrb_cnt;
400 stats->be_tx_bytes += copied;
401 stats->be_tx_pkts += (gso_segs ? gso_segs : 1);
402 if (stopped)
403 stats->be_tx_stops++;
404 }
405
406 /* Determine number of WRB entries needed to xmit data in an skb */
407 static u32 wrb_cnt_for_skb(struct be_adapter *adapter, struct sk_buff *skb,
408 bool *dummy)
409 {
410 int cnt = (skb->len > skb->data_len);
411
412 cnt += skb_shinfo(skb)->nr_frags;
413
414 /* to account for hdr wrb */
415 cnt++;
416 if (lancer_chip(adapter) || !(cnt & 1)) {
417 *dummy = false;
418 } else {
419 /* add a dummy to make it an even num */
420 cnt++;
421 *dummy = true;
422 }
423 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
424 return cnt;
425 }
426
427 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
428 {
429 wrb->frag_pa_hi = upper_32_bits(addr);
430 wrb->frag_pa_lo = addr & 0xFFFFFFFF;
431 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
432 }
433
434 static void wrb_fill_hdr(struct be_adapter *adapter, struct be_eth_hdr_wrb *hdr,
435 struct sk_buff *skb, u32 wrb_cnt, u32 len)
436 {
437 u8 vlan_prio = 0;
438 u16 vlan_tag = 0;
439
440 memset(hdr, 0, sizeof(*hdr));
441
442 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
443
444 if (skb_is_gso(skb)) {
445 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
446 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
447 hdr, skb_shinfo(skb)->gso_size);
448 if (skb_is_gso_v6(skb) && !lancer_chip(adapter))
449 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
450 if (lancer_chip(adapter) && adapter->sli_family ==
451 LANCER_A0_SLI_FAMILY) {
452 AMAP_SET_BITS(struct amap_eth_hdr_wrb, ipcs, hdr, 1);
453 if (is_tcp_pkt(skb))
454 AMAP_SET_BITS(struct amap_eth_hdr_wrb,
455 tcpcs, hdr, 1);
456 else if (is_udp_pkt(skb))
457 AMAP_SET_BITS(struct amap_eth_hdr_wrb,
458 udpcs, hdr, 1);
459 }
460 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
461 if (is_tcp_pkt(skb))
462 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
463 else if (is_udp_pkt(skb))
464 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
465 }
466
467 if (adapter->vlan_grp && vlan_tx_tag_present(skb)) {
468 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
469 vlan_tag = vlan_tx_tag_get(skb);
470 vlan_prio = (vlan_tag & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
471 /* If vlan priority provided by OS is NOT in available bmap */
472 if (!(adapter->vlan_prio_bmap & (1 << vlan_prio)))
473 vlan_tag = (vlan_tag & ~VLAN_PRIO_MASK) |
474 adapter->recommended_prio;
475 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag, hdr, vlan_tag);
476 }
477
478 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
479 AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, 1);
480 AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
481 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
482 }
483
484 static void unmap_tx_frag(struct device *dev, struct be_eth_wrb *wrb,
485 bool unmap_single)
486 {
487 dma_addr_t dma;
488
489 be_dws_le_to_cpu(wrb, sizeof(*wrb));
490
491 dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
492 if (wrb->frag_len) {
493 if (unmap_single)
494 dma_unmap_single(dev, dma, wrb->frag_len,
495 DMA_TO_DEVICE);
496 else
497 dma_unmap_page(dev, dma, wrb->frag_len, DMA_TO_DEVICE);
498 }
499 }
500
501 static int make_tx_wrbs(struct be_adapter *adapter,
502 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
503 {
504 dma_addr_t busaddr;
505 int i, copied = 0;
506 struct device *dev = &adapter->pdev->dev;
507 struct sk_buff *first_skb = skb;
508 struct be_queue_info *txq = &adapter->tx_obj.q;
509 struct be_eth_wrb *wrb;
510 struct be_eth_hdr_wrb *hdr;
511 bool map_single = false;
512 u16 map_head;
513
514 hdr = queue_head_node(txq);
515 queue_head_inc(txq);
516 map_head = txq->head;
517
518 if (skb->len > skb->data_len) {
519 int len = skb_headlen(skb);
520 busaddr = dma_map_single(dev, skb->data, len, DMA_TO_DEVICE);
521 if (dma_mapping_error(dev, busaddr))
522 goto dma_err;
523 map_single = true;
524 wrb = queue_head_node(txq);
525 wrb_fill(wrb, busaddr, len);
526 be_dws_cpu_to_le(wrb, sizeof(*wrb));
527 queue_head_inc(txq);
528 copied += len;
529 }
530
531 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
532 struct skb_frag_struct *frag =
533 &skb_shinfo(skb)->frags[i];
534 busaddr = dma_map_page(dev, frag->page, frag->page_offset,
535 frag->size, DMA_TO_DEVICE);
536 if (dma_mapping_error(dev, busaddr))
537 goto dma_err;
538 wrb = queue_head_node(txq);
539 wrb_fill(wrb, busaddr, frag->size);
540 be_dws_cpu_to_le(wrb, sizeof(*wrb));
541 queue_head_inc(txq);
542 copied += frag->size;
543 }
544
545 if (dummy_wrb) {
546 wrb = queue_head_node(txq);
547 wrb_fill(wrb, 0, 0);
548 be_dws_cpu_to_le(wrb, sizeof(*wrb));
549 queue_head_inc(txq);
550 }
551
552 wrb_fill_hdr(adapter, hdr, first_skb, wrb_cnt, copied);
553 be_dws_cpu_to_le(hdr, sizeof(*hdr));
554
555 return copied;
556 dma_err:
557 txq->head = map_head;
558 while (copied) {
559 wrb = queue_head_node(txq);
560 unmap_tx_frag(dev, wrb, map_single);
561 map_single = false;
562 copied -= wrb->frag_len;
563 queue_head_inc(txq);
564 }
565 return 0;
566 }
567
568 static netdev_tx_t be_xmit(struct sk_buff *skb,
569 struct net_device *netdev)
570 {
571 struct be_adapter *adapter = netdev_priv(netdev);
572 struct be_tx_obj *tx_obj = &adapter->tx_obj;
573 struct be_queue_info *txq = &tx_obj->q;
574 u32 wrb_cnt = 0, copied = 0;
575 u32 start = txq->head;
576 bool dummy_wrb, stopped = false;
577
578 wrb_cnt = wrb_cnt_for_skb(adapter, skb, &dummy_wrb);
579
580 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
581 if (copied) {
582 /* record the sent skb in the sent_skb table */
583 BUG_ON(tx_obj->sent_skb_list[start]);
584 tx_obj->sent_skb_list[start] = skb;
585
586 /* Ensure txq has space for the next skb; Else stop the queue
587 * *BEFORE* ringing the tx doorbell, so that we serialze the
588 * tx compls of the current transmit which'll wake up the queue
589 */
590 atomic_add(wrb_cnt, &txq->used);
591 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
592 txq->len) {
593 netif_stop_queue(netdev);
594 stopped = true;
595 }
596
597 be_txq_notify(adapter, txq->id, wrb_cnt);
598
599 be_tx_stats_update(adapter, wrb_cnt, copied,
600 skb_shinfo(skb)->gso_segs, stopped);
601 } else {
602 txq->head = start;
603 dev_kfree_skb_any(skb);
604 }
605 return NETDEV_TX_OK;
606 }
607
608 static int be_change_mtu(struct net_device *netdev, int new_mtu)
609 {
610 struct be_adapter *adapter = netdev_priv(netdev);
611 if (new_mtu < BE_MIN_MTU ||
612 new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
613 (ETH_HLEN + ETH_FCS_LEN))) {
614 dev_info(&adapter->pdev->dev,
615 "MTU must be between %d and %d bytes\n",
616 BE_MIN_MTU,
617 (BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
618 return -EINVAL;
619 }
620 dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
621 netdev->mtu, new_mtu);
622 netdev->mtu = new_mtu;
623 return 0;
624 }
625
626 /*
627 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
628 * If the user configures more, place BE in vlan promiscuous mode.
629 */
630 static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
631 {
632 u16 vtag[BE_NUM_VLANS_SUPPORTED];
633 u16 ntags = 0, i;
634 int status = 0;
635 u32 if_handle;
636
637 if (vf) {
638 if_handle = adapter->vf_cfg[vf_num].vf_if_handle;
639 vtag[0] = cpu_to_le16(adapter->vf_cfg[vf_num].vf_vlan_tag);
640 status = be_cmd_vlan_config(adapter, if_handle, vtag, 1, 1, 0);
641 }
642
643 if (adapter->vlans_added <= adapter->max_vlans) {
644 /* Construct VLAN Table to give to HW */
645 for (i = 0; i < VLAN_N_VID; i++) {
646 if (adapter->vlan_tag[i]) {
647 vtag[ntags] = cpu_to_le16(i);
648 ntags++;
649 }
650 }
651 status = be_cmd_vlan_config(adapter, adapter->if_handle,
652 vtag, ntags, 1, 0);
653 } else {
654 status = be_cmd_vlan_config(adapter, adapter->if_handle,
655 NULL, 0, 1, 1);
656 }
657
658 return status;
659 }
660
661 static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp)
662 {
663 struct be_adapter *adapter = netdev_priv(netdev);
664
665 adapter->vlan_grp = grp;
666 }
667
668 static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
669 {
670 struct be_adapter *adapter = netdev_priv(netdev);
671
672 adapter->vlans_added++;
673 if (!be_physfn(adapter))
674 return;
675
676 adapter->vlan_tag[vid] = 1;
677 if (adapter->vlans_added <= (adapter->max_vlans + 1))
678 be_vid_config(adapter, false, 0);
679 }
680
681 static void be_vlan_rem_vid(struct net_device *netdev, u16 vid)
682 {
683 struct be_adapter *adapter = netdev_priv(netdev);
684
685 adapter->vlans_added--;
686 vlan_group_set_device(adapter->vlan_grp, vid, NULL);
687
688 if (!be_physfn(adapter))
689 return;
690
691 adapter->vlan_tag[vid] = 0;
692 if (adapter->vlans_added <= adapter->max_vlans)
693 be_vid_config(adapter, false, 0);
694 }
695
696 static void be_set_multicast_list(struct net_device *netdev)
697 {
698 struct be_adapter *adapter = netdev_priv(netdev);
699
700 if (netdev->flags & IFF_PROMISC) {
701 be_cmd_promiscuous_config(adapter, adapter->port_num, 1);
702 adapter->promiscuous = true;
703 goto done;
704 }
705
706 /* BE was previously in promiscuous mode; disable it */
707 if (adapter->promiscuous) {
708 adapter->promiscuous = false;
709 be_cmd_promiscuous_config(adapter, adapter->port_num, 0);
710 }
711
712 /* Enable multicast promisc if num configured exceeds what we support */
713 if (netdev->flags & IFF_ALLMULTI ||
714 netdev_mc_count(netdev) > BE_MAX_MC) {
715 be_cmd_multicast_set(adapter, adapter->if_handle, NULL,
716 &adapter->mc_cmd_mem);
717 goto done;
718 }
719
720 be_cmd_multicast_set(adapter, adapter->if_handle, netdev,
721 &adapter->mc_cmd_mem);
722 done:
723 return;
724 }
725
726 static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
727 {
728 struct be_adapter *adapter = netdev_priv(netdev);
729 int status;
730
731 if (!adapter->sriov_enabled)
732 return -EPERM;
733
734 if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
735 return -EINVAL;
736
737 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
738 status = be_cmd_pmac_del(adapter,
739 adapter->vf_cfg[vf].vf_if_handle,
740 adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
741
742 status = be_cmd_pmac_add(adapter, mac,
743 adapter->vf_cfg[vf].vf_if_handle,
744 &adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
745
746 if (status)
747 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
748 mac, vf);
749 else
750 memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
751
752 return status;
753 }
754
755 static int be_get_vf_config(struct net_device *netdev, int vf,
756 struct ifla_vf_info *vi)
757 {
758 struct be_adapter *adapter = netdev_priv(netdev);
759
760 if (!adapter->sriov_enabled)
761 return -EPERM;
762
763 if (vf >= num_vfs)
764 return -EINVAL;
765
766 vi->vf = vf;
767 vi->tx_rate = adapter->vf_cfg[vf].vf_tx_rate;
768 vi->vlan = adapter->vf_cfg[vf].vf_vlan_tag;
769 vi->qos = 0;
770 memcpy(&vi->mac, adapter->vf_cfg[vf].vf_mac_addr, ETH_ALEN);
771
772 return 0;
773 }
774
775 static int be_set_vf_vlan(struct net_device *netdev,
776 int vf, u16 vlan, u8 qos)
777 {
778 struct be_adapter *adapter = netdev_priv(netdev);
779 int status = 0;
780
781 if (!adapter->sriov_enabled)
782 return -EPERM;
783
784 if ((vf >= num_vfs) || (vlan > 4095))
785 return -EINVAL;
786
787 if (vlan) {
788 adapter->vf_cfg[vf].vf_vlan_tag = vlan;
789 adapter->vlans_added++;
790 } else {
791 adapter->vf_cfg[vf].vf_vlan_tag = 0;
792 adapter->vlans_added--;
793 }
794
795 status = be_vid_config(adapter, true, vf);
796
797 if (status)
798 dev_info(&adapter->pdev->dev,
799 "VLAN %d config on VF %d failed\n", vlan, vf);
800 return status;
801 }
802
803 static int be_set_vf_tx_rate(struct net_device *netdev,
804 int vf, int rate)
805 {
806 struct be_adapter *adapter = netdev_priv(netdev);
807 int status = 0;
808
809 if (!adapter->sriov_enabled)
810 return -EPERM;
811
812 if ((vf >= num_vfs) || (rate < 0))
813 return -EINVAL;
814
815 if (rate > 10000)
816 rate = 10000;
817
818 adapter->vf_cfg[vf].vf_tx_rate = rate;
819 status = be_cmd_set_qos(adapter, rate / 10, vf + 1);
820
821 if (status)
822 dev_info(&adapter->pdev->dev,
823 "tx rate %d on VF %d failed\n", rate, vf);
824 return status;
825 }
826
827 static void be_rx_rate_update(struct be_rx_obj *rxo)
828 {
829 struct be_rx_stats *stats = &rxo->stats;
830 ulong now = jiffies;
831
832 /* Wrapped around */
833 if (time_before(now, stats->rx_jiffies)) {
834 stats->rx_jiffies = now;
835 return;
836 }
837
838 /* Update the rate once in two seconds */
839 if ((now - stats->rx_jiffies) < 2 * HZ)
840 return;
841
842 stats->rx_rate = be_calc_rate(stats->rx_bytes - stats->rx_bytes_prev,
843 now - stats->rx_jiffies);
844 stats->rx_jiffies = now;
845 stats->rx_bytes_prev = stats->rx_bytes;
846 }
847
848 static void be_rx_stats_update(struct be_rx_obj *rxo,
849 struct be_rx_compl_info *rxcp)
850 {
851 struct be_rx_stats *stats = &rxo->stats;
852
853 stats->rx_compl++;
854 stats->rx_frags += rxcp->num_rcvd;
855 stats->rx_bytes += rxcp->pkt_size;
856 stats->rx_pkts++;
857 if (rxcp->pkt_type == BE_MULTICAST_PACKET)
858 stats->rx_mcast_pkts++;
859 if (rxcp->err)
860 stats->rxcp_err++;
861 }
862
863 static inline bool csum_passed(struct be_rx_compl_info *rxcp)
864 {
865 /* L4 checksum is not reliable for non TCP/UDP packets.
866 * Also ignore ipcksm for ipv6 pkts */
867 return (rxcp->tcpf || rxcp->udpf) && rxcp->l4_csum &&
868 (rxcp->ip_csum || rxcp->ipv6);
869 }
870
871 static struct be_rx_page_info *
872 get_rx_page_info(struct be_adapter *adapter,
873 struct be_rx_obj *rxo,
874 u16 frag_idx)
875 {
876 struct be_rx_page_info *rx_page_info;
877 struct be_queue_info *rxq = &rxo->q;
878
879 rx_page_info = &rxo->page_info_tbl[frag_idx];
880 BUG_ON(!rx_page_info->page);
881
882 if (rx_page_info->last_page_user) {
883 dma_unmap_page(&adapter->pdev->dev,
884 dma_unmap_addr(rx_page_info, bus),
885 adapter->big_page_size, DMA_FROM_DEVICE);
886 rx_page_info->last_page_user = false;
887 }
888
889 atomic_dec(&rxq->used);
890 return rx_page_info;
891 }
892
893 /* Throwaway the data in the Rx completion */
894 static void be_rx_compl_discard(struct be_adapter *adapter,
895 struct be_rx_obj *rxo,
896 struct be_rx_compl_info *rxcp)
897 {
898 struct be_queue_info *rxq = &rxo->q;
899 struct be_rx_page_info *page_info;
900 u16 i, num_rcvd = rxcp->num_rcvd;
901
902 for (i = 0; i < num_rcvd; i++) {
903 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
904 put_page(page_info->page);
905 memset(page_info, 0, sizeof(*page_info));
906 index_inc(&rxcp->rxq_idx, rxq->len);
907 }
908 }
909
910 /*
911 * skb_fill_rx_data forms a complete skb for an ether frame
912 * indicated by rxcp.
913 */
914 static void skb_fill_rx_data(struct be_adapter *adapter, struct be_rx_obj *rxo,
915 struct sk_buff *skb, struct be_rx_compl_info *rxcp)
916 {
917 struct be_queue_info *rxq = &rxo->q;
918 struct be_rx_page_info *page_info;
919 u16 i, j;
920 u16 hdr_len, curr_frag_len, remaining;
921 u8 *start;
922
923 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
924 start = page_address(page_info->page) + page_info->page_offset;
925 prefetch(start);
926
927 /* Copy data in the first descriptor of this completion */
928 curr_frag_len = min(rxcp->pkt_size, rx_frag_size);
929
930 /* Copy the header portion into skb_data */
931 hdr_len = min(BE_HDR_LEN, curr_frag_len);
932 memcpy(skb->data, start, hdr_len);
933 skb->len = curr_frag_len;
934 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
935 /* Complete packet has now been moved to data */
936 put_page(page_info->page);
937 skb->data_len = 0;
938 skb->tail += curr_frag_len;
939 } else {
940 skb_shinfo(skb)->nr_frags = 1;
941 skb_shinfo(skb)->frags[0].page = page_info->page;
942 skb_shinfo(skb)->frags[0].page_offset =
943 page_info->page_offset + hdr_len;
944 skb_shinfo(skb)->frags[0].size = curr_frag_len - hdr_len;
945 skb->data_len = curr_frag_len - hdr_len;
946 skb->tail += hdr_len;
947 }
948 page_info->page = NULL;
949
950 if (rxcp->pkt_size <= rx_frag_size) {
951 BUG_ON(rxcp->num_rcvd != 1);
952 return;
953 }
954
955 /* More frags present for this completion */
956 index_inc(&rxcp->rxq_idx, rxq->len);
957 remaining = rxcp->pkt_size - curr_frag_len;
958 for (i = 1, j = 0; i < rxcp->num_rcvd; i++) {
959 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
960 curr_frag_len = min(remaining, rx_frag_size);
961
962 /* Coalesce all frags from the same physical page in one slot */
963 if (page_info->page_offset == 0) {
964 /* Fresh page */
965 j++;
966 skb_shinfo(skb)->frags[j].page = page_info->page;
967 skb_shinfo(skb)->frags[j].page_offset =
968 page_info->page_offset;
969 skb_shinfo(skb)->frags[j].size = 0;
970 skb_shinfo(skb)->nr_frags++;
971 } else {
972 put_page(page_info->page);
973 }
974
975 skb_shinfo(skb)->frags[j].size += curr_frag_len;
976 skb->len += curr_frag_len;
977 skb->data_len += curr_frag_len;
978
979 remaining -= curr_frag_len;
980 index_inc(&rxcp->rxq_idx, rxq->len);
981 page_info->page = NULL;
982 }
983 BUG_ON(j > MAX_SKB_FRAGS);
984 }
985
986 /* Process the RX completion indicated by rxcp when GRO is disabled */
987 static void be_rx_compl_process(struct be_adapter *adapter,
988 struct be_rx_obj *rxo,
989 struct be_rx_compl_info *rxcp)
990 {
991 struct net_device *netdev = adapter->netdev;
992 struct sk_buff *skb;
993
994 skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);
995 if (unlikely(!skb)) {
996 if (net_ratelimit())
997 dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
998 be_rx_compl_discard(adapter, rxo, rxcp);
999 return;
1000 }
1001
1002 skb_fill_rx_data(adapter, rxo, skb, rxcp);
1003
1004 if (likely((netdev->features & NETIF_F_RXCSUM) && csum_passed(rxcp)))
1005 skb->ip_summed = CHECKSUM_UNNECESSARY;
1006 else
1007 skb_checksum_none_assert(skb);
1008
1009 skb->truesize = skb->len + sizeof(struct sk_buff);
1010 skb->protocol = eth_type_trans(skb, netdev);
1011 if (adapter->netdev->features & NETIF_F_RXHASH)
1012 skb->rxhash = rxcp->rss_hash;
1013
1014
1015 if (unlikely(rxcp->vlanf)) {
1016 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
1017 kfree_skb(skb);
1018 return;
1019 }
1020 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp, rxcp->vid);
1021 } else {
1022 netif_receive_skb(skb);
1023 }
1024 }
1025
1026 /* Process the RX completion indicated by rxcp when GRO is enabled */
1027 static void be_rx_compl_process_gro(struct be_adapter *adapter,
1028 struct be_rx_obj *rxo,
1029 struct be_rx_compl_info *rxcp)
1030 {
1031 struct be_rx_page_info *page_info;
1032 struct sk_buff *skb = NULL;
1033 struct be_queue_info *rxq = &rxo->q;
1034 struct be_eq_obj *eq_obj = &rxo->rx_eq;
1035 u16 remaining, curr_frag_len;
1036 u16 i, j;
1037
1038 skb = napi_get_frags(&eq_obj->napi);
1039 if (!skb) {
1040 be_rx_compl_discard(adapter, rxo, rxcp);
1041 return;
1042 }
1043
1044 remaining = rxcp->pkt_size;
1045 for (i = 0, j = -1; i < rxcp->num_rcvd; i++) {
1046 page_info = get_rx_page_info(adapter, rxo, rxcp->rxq_idx);
1047
1048 curr_frag_len = min(remaining, rx_frag_size);
1049
1050 /* Coalesce all frags from the same physical page in one slot */
1051 if (i == 0 || page_info->page_offset == 0) {
1052 /* First frag or Fresh page */
1053 j++;
1054 skb_shinfo(skb)->frags[j].page = page_info->page;
1055 skb_shinfo(skb)->frags[j].page_offset =
1056 page_info->page_offset;
1057 skb_shinfo(skb)->frags[j].size = 0;
1058 } else {
1059 put_page(page_info->page);
1060 }
1061 skb_shinfo(skb)->frags[j].size += curr_frag_len;
1062
1063 remaining -= curr_frag_len;
1064 index_inc(&rxcp->rxq_idx, rxq->len);
1065 memset(page_info, 0, sizeof(*page_info));
1066 }
1067 BUG_ON(j > MAX_SKB_FRAGS);
1068
1069 skb_shinfo(skb)->nr_frags = j + 1;
1070 skb->len = rxcp->pkt_size;
1071 skb->data_len = rxcp->pkt_size;
1072 skb->truesize += rxcp->pkt_size;
1073 skb->ip_summed = CHECKSUM_UNNECESSARY;
1074 if (adapter->netdev->features & NETIF_F_RXHASH)
1075 skb->rxhash = rxcp->rss_hash;
1076
1077 if (likely(!rxcp->vlanf))
1078 napi_gro_frags(&eq_obj->napi);
1079 else
1080 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, rxcp->vid);
1081 }
1082
1083 static void be_parse_rx_compl_v1(struct be_adapter *adapter,
1084 struct be_eth_rx_compl *compl,
1085 struct be_rx_compl_info *rxcp)
1086 {
1087 rxcp->pkt_size =
1088 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, pktsize, compl);
1089 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtp, compl);
1090 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, err, compl);
1091 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, tcpf, compl);
1092 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, udpf, compl);
1093 rxcp->ip_csum =
1094 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ipcksm, compl);
1095 rxcp->l4_csum =
1096 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, l4_cksm, compl);
1097 rxcp->ipv6 =
1098 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, ip_version, compl);
1099 rxcp->rxq_idx =
1100 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, fragndx, compl);
1101 rxcp->num_rcvd =
1102 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, numfrags, compl);
1103 rxcp->pkt_type =
1104 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, cast_enc, compl);
1105 rxcp->rss_hash =
1106 AMAP_GET_BITS(struct amap_eth_rx_compl_v1, rsshash, rxcp);
1107 if (rxcp->vlanf) {
1108 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vtm,
1109 compl);
1110 rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v1, vlan_tag,
1111 compl);
1112 }
1113 }
1114
1115 static void be_parse_rx_compl_v0(struct be_adapter *adapter,
1116 struct be_eth_rx_compl *compl,
1117 struct be_rx_compl_info *rxcp)
1118 {
1119 rxcp->pkt_size =
1120 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, pktsize, compl);
1121 rxcp->vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtp, compl);
1122 rxcp->err = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, err, compl);
1123 rxcp->tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, tcpf, compl);
1124 rxcp->udpf = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, udpf, compl);
1125 rxcp->ip_csum =
1126 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ipcksm, compl);
1127 rxcp->l4_csum =
1128 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, l4_cksm, compl);
1129 rxcp->ipv6 =
1130 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, ip_version, compl);
1131 rxcp->rxq_idx =
1132 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, fragndx, compl);
1133 rxcp->num_rcvd =
1134 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, numfrags, compl);
1135 rxcp->pkt_type =
1136 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, cast_enc, compl);
1137 rxcp->rss_hash =
1138 AMAP_GET_BITS(struct amap_eth_rx_compl_v0, rsshash, rxcp);
1139 if (rxcp->vlanf) {
1140 rxcp->vtm = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vtm,
1141 compl);
1142 rxcp->vid = AMAP_GET_BITS(struct amap_eth_rx_compl_v0, vlan_tag,
1143 compl);
1144 }
1145 }
1146
1147 static struct be_rx_compl_info *be_rx_compl_get(struct be_rx_obj *rxo)
1148 {
1149 struct be_eth_rx_compl *compl = queue_tail_node(&rxo->cq);
1150 struct be_rx_compl_info *rxcp = &rxo->rxcp;
1151 struct be_adapter *adapter = rxo->adapter;
1152
1153 /* For checking the valid bit it is Ok to use either definition as the
1154 * valid bit is at the same position in both v0 and v1 Rx compl */
1155 if (compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] == 0)
1156 return NULL;
1157
1158 rmb();
1159 be_dws_le_to_cpu(compl, sizeof(*compl));
1160
1161 if (adapter->be3_native)
1162 be_parse_rx_compl_v1(adapter, compl, rxcp);
1163 else
1164 be_parse_rx_compl_v0(adapter, compl, rxcp);
1165
1166 if (rxcp->vlanf) {
1167 /* vlanf could be wrongly set in some cards.
1168 * ignore if vtm is not set */
1169 if ((adapter->function_mode & 0x400) && !rxcp->vtm)
1170 rxcp->vlanf = 0;
1171
1172 if (!lancer_chip(adapter))
1173 rxcp->vid = swab16(rxcp->vid);
1174
1175 if ((adapter->pvid == rxcp->vid) &&
1176 !adapter->vlan_tag[rxcp->vid])
1177 rxcp->vlanf = 0;
1178 }
1179
1180 /* As the compl has been parsed, reset it; we wont touch it again */
1181 compl->dw[offsetof(struct amap_eth_rx_compl_v1, valid) / 32] = 0;
1182
1183 queue_tail_inc(&rxo->cq);
1184 return rxcp;
1185 }
1186
1187 static inline struct page *be_alloc_pages(u32 size, gfp_t gfp)
1188 {
1189 u32 order = get_order(size);
1190
1191 if (order > 0)
1192 gfp |= __GFP_COMP;
1193 return alloc_pages(gfp, order);
1194 }
1195
1196 /*
1197 * Allocate a page, split it to fragments of size rx_frag_size and post as
1198 * receive buffers to BE
1199 */
1200 static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
1201 {
1202 struct be_adapter *adapter = rxo->adapter;
1203 struct be_rx_page_info *page_info_tbl = rxo->page_info_tbl;
1204 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
1205 struct be_queue_info *rxq = &rxo->q;
1206 struct page *pagep = NULL;
1207 struct be_eth_rx_d *rxd;
1208 u64 page_dmaaddr = 0, frag_dmaaddr;
1209 u32 posted, page_offset = 0;
1210
1211 page_info = &rxo->page_info_tbl[rxq->head];
1212 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1213 if (!pagep) {
1214 pagep = be_alloc_pages(adapter->big_page_size, gfp);
1215 if (unlikely(!pagep)) {
1216 rxo->stats.rx_post_fail++;
1217 break;
1218 }
1219 page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
1220 0, adapter->big_page_size,
1221 DMA_FROM_DEVICE);
1222 page_info->page_offset = 0;
1223 } else {
1224 get_page(pagep);
1225 page_info->page_offset = page_offset + rx_frag_size;
1226 }
1227 page_offset = page_info->page_offset;
1228 page_info->page = pagep;
1229 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
1230 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
1231
1232 rxd = queue_head_node(rxq);
1233 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
1234 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
1235
1236 /* Any space left in the current big page for another frag? */
1237 if ((page_offset + rx_frag_size + rx_frag_size) >
1238 adapter->big_page_size) {
1239 pagep = NULL;
1240 page_info->last_page_user = true;
1241 }
1242
1243 prev_page_info = page_info;
1244 queue_head_inc(rxq);
1245 page_info = &page_info_tbl[rxq->head];
1246 }
1247 if (pagep)
1248 prev_page_info->last_page_user = true;
1249
1250 if (posted) {
1251 atomic_add(posted, &rxq->used);
1252 be_rxq_notify(adapter, rxq->id, posted);
1253 } else if (atomic_read(&rxq->used) == 0) {
1254 /* Let be_worker replenish when memory is available */
1255 rxo->rx_post_starved = true;
1256 }
1257 }
1258
1259 static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
1260 {
1261 struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
1262
1263 if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
1264 return NULL;
1265
1266 rmb();
1267 be_dws_le_to_cpu(txcp, sizeof(*txcp));
1268
1269 txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
1270
1271 queue_tail_inc(tx_cq);
1272 return txcp;
1273 }
1274
1275 static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
1276 {
1277 struct be_queue_info *txq = &adapter->tx_obj.q;
1278 struct be_eth_wrb *wrb;
1279 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1280 struct sk_buff *sent_skb;
1281 u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
1282 bool unmap_skb_hdr = true;
1283
1284 sent_skb = sent_skbs[txq->tail];
1285 BUG_ON(!sent_skb);
1286 sent_skbs[txq->tail] = NULL;
1287
1288 /* skip header wrb */
1289 queue_tail_inc(txq);
1290
1291 do {
1292 cur_index = txq->tail;
1293 wrb = queue_tail_node(txq);
1294 unmap_tx_frag(&adapter->pdev->dev, wrb,
1295 (unmap_skb_hdr && skb_headlen(sent_skb)));
1296 unmap_skb_hdr = false;
1297
1298 num_wrbs++;
1299 queue_tail_inc(txq);
1300 } while (cur_index != last_index);
1301
1302 atomic_sub(num_wrbs, &txq->used);
1303
1304 kfree_skb(sent_skb);
1305 }
1306
1307 static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj)
1308 {
1309 struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
1310
1311 if (!eqe->evt)
1312 return NULL;
1313
1314 rmb();
1315 eqe->evt = le32_to_cpu(eqe->evt);
1316 queue_tail_inc(&eq_obj->q);
1317 return eqe;
1318 }
1319
1320 static int event_handle(struct be_adapter *adapter,
1321 struct be_eq_obj *eq_obj)
1322 {
1323 struct be_eq_entry *eqe;
1324 u16 num = 0;
1325
1326 while ((eqe = event_get(eq_obj)) != NULL) {
1327 eqe->evt = 0;
1328 num++;
1329 }
1330
1331 /* Deal with any spurious interrupts that come
1332 * without events
1333 */
1334 be_eq_notify(adapter, eq_obj->q.id, true, true, num);
1335 if (num)
1336 napi_schedule(&eq_obj->napi);
1337
1338 return num;
1339 }
1340
1341 /* Just read and notify events without processing them.
1342 * Used at the time of destroying event queues */
1343 static void be_eq_clean(struct be_adapter *adapter,
1344 struct be_eq_obj *eq_obj)
1345 {
1346 struct be_eq_entry *eqe;
1347 u16 num = 0;
1348
1349 while ((eqe = event_get(eq_obj)) != NULL) {
1350 eqe->evt = 0;
1351 num++;
1352 }
1353
1354 if (num)
1355 be_eq_notify(adapter, eq_obj->q.id, false, true, num);
1356 }
1357
1358 static void be_rx_q_clean(struct be_adapter *adapter, struct be_rx_obj *rxo)
1359 {
1360 struct be_rx_page_info *page_info;
1361 struct be_queue_info *rxq = &rxo->q;
1362 struct be_queue_info *rx_cq = &rxo->cq;
1363 struct be_rx_compl_info *rxcp;
1364 u16 tail;
1365
1366 /* First cleanup pending rx completions */
1367 while ((rxcp = be_rx_compl_get(rxo)) != NULL) {
1368 be_rx_compl_discard(adapter, rxo, rxcp);
1369 be_cq_notify(adapter, rx_cq->id, false, 1);
1370 }
1371
1372 /* Then free posted rx buffer that were not used */
1373 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
1374 for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
1375 page_info = get_rx_page_info(adapter, rxo, tail);
1376 put_page(page_info->page);
1377 memset(page_info, 0, sizeof(*page_info));
1378 }
1379 BUG_ON(atomic_read(&rxq->used));
1380 }
1381
1382 static void be_tx_compl_clean(struct be_adapter *adapter)
1383 {
1384 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1385 struct be_queue_info *txq = &adapter->tx_obj.q;
1386 struct be_eth_tx_compl *txcp;
1387 u16 end_idx, cmpl = 0, timeo = 0;
1388 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1389 struct sk_buff *sent_skb;
1390 bool dummy_wrb;
1391
1392 /* Wait for a max of 200ms for all the tx-completions to arrive. */
1393 do {
1394 while ((txcp = be_tx_compl_get(tx_cq))) {
1395 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1396 wrb_index, txcp);
1397 be_tx_compl_process(adapter, end_idx);
1398 cmpl++;
1399 }
1400 if (cmpl) {
1401 be_cq_notify(adapter, tx_cq->id, false, cmpl);
1402 cmpl = 0;
1403 }
1404
1405 if (atomic_read(&txq->used) == 0 || ++timeo > 200)
1406 break;
1407
1408 mdelay(1);
1409 } while (true);
1410
1411 if (atomic_read(&txq->used))
1412 dev_err(&adapter->pdev->dev, "%d pending tx-completions\n",
1413 atomic_read(&txq->used));
1414
1415 /* free posted tx for which compls will never arrive */
1416 while (atomic_read(&txq->used)) {
1417 sent_skb = sent_skbs[txq->tail];
1418 end_idx = txq->tail;
1419 index_adv(&end_idx,
1420 wrb_cnt_for_skb(adapter, sent_skb, &dummy_wrb) - 1,
1421 txq->len);
1422 be_tx_compl_process(adapter, end_idx);
1423 }
1424 }
1425
1426 static void be_mcc_queues_destroy(struct be_adapter *adapter)
1427 {
1428 struct be_queue_info *q;
1429
1430 q = &adapter->mcc_obj.q;
1431 if (q->created)
1432 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
1433 be_queue_free(adapter, q);
1434
1435 q = &adapter->mcc_obj.cq;
1436 if (q->created)
1437 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1438 be_queue_free(adapter, q);
1439 }
1440
1441 /* Must be called only after TX qs are created as MCC shares TX EQ */
1442 static int be_mcc_queues_create(struct be_adapter *adapter)
1443 {
1444 struct be_queue_info *q, *cq;
1445
1446 /* Alloc MCC compl queue */
1447 cq = &adapter->mcc_obj.cq;
1448 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1449 sizeof(struct be_mcc_compl)))
1450 goto err;
1451
1452 /* Ask BE to create MCC compl queue; share TX's eq */
1453 if (be_cmd_cq_create(adapter, cq, &adapter->tx_eq.q, false, true, 0))
1454 goto mcc_cq_free;
1455
1456 /* Alloc MCC queue */
1457 q = &adapter->mcc_obj.q;
1458 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1459 goto mcc_cq_destroy;
1460
1461 /* Ask BE to create MCC queue */
1462 if (be_cmd_mccq_create(adapter, q, cq))
1463 goto mcc_q_free;
1464
1465 return 0;
1466
1467 mcc_q_free:
1468 be_queue_free(adapter, q);
1469 mcc_cq_destroy:
1470 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1471 mcc_cq_free:
1472 be_queue_free(adapter, cq);
1473 err:
1474 return -1;
1475 }
1476
1477 static void be_tx_queues_destroy(struct be_adapter *adapter)
1478 {
1479 struct be_queue_info *q;
1480
1481 q = &adapter->tx_obj.q;
1482 if (q->created)
1483 be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
1484 be_queue_free(adapter, q);
1485
1486 q = &adapter->tx_obj.cq;
1487 if (q->created)
1488 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1489 be_queue_free(adapter, q);
1490
1491 /* Clear any residual events */
1492 be_eq_clean(adapter, &adapter->tx_eq);
1493
1494 q = &adapter->tx_eq.q;
1495 if (q->created)
1496 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
1497 be_queue_free(adapter, q);
1498 }
1499
1500 static int be_tx_queues_create(struct be_adapter *adapter)
1501 {
1502 struct be_queue_info *eq, *q, *cq;
1503
1504 adapter->tx_eq.max_eqd = 0;
1505 adapter->tx_eq.min_eqd = 0;
1506 adapter->tx_eq.cur_eqd = 96;
1507 adapter->tx_eq.enable_aic = false;
1508 /* Alloc Tx Event queue */
1509 eq = &adapter->tx_eq.q;
1510 if (be_queue_alloc(adapter, eq, EVNT_Q_LEN, sizeof(struct be_eq_entry)))
1511 return -1;
1512
1513 /* Ask BE to create Tx Event queue */
1514 if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd))
1515 goto tx_eq_free;
1516
1517 adapter->tx_eq.eq_idx = adapter->eq_next_idx++;
1518
1519
1520 /* Alloc TX eth compl queue */
1521 cq = &adapter->tx_obj.cq;
1522 if (be_queue_alloc(adapter, cq, TX_CQ_LEN,
1523 sizeof(struct be_eth_tx_compl)))
1524 goto tx_eq_destroy;
1525
1526 /* Ask BE to create Tx eth compl queue */
1527 if (be_cmd_cq_create(adapter, cq, eq, false, false, 3))
1528 goto tx_cq_free;
1529
1530 /* Alloc TX eth queue */
1531 q = &adapter->tx_obj.q;
1532 if (be_queue_alloc(adapter, q, TX_Q_LEN, sizeof(struct be_eth_wrb)))
1533 goto tx_cq_destroy;
1534
1535 /* Ask BE to create Tx eth queue */
1536 if (be_cmd_txq_create(adapter, q, cq))
1537 goto tx_q_free;
1538 return 0;
1539
1540 tx_q_free:
1541 be_queue_free(adapter, q);
1542 tx_cq_destroy:
1543 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
1544 tx_cq_free:
1545 be_queue_free(adapter, cq);
1546 tx_eq_destroy:
1547 be_cmd_q_destroy(adapter, eq, QTYPE_EQ);
1548 tx_eq_free:
1549 be_queue_free(adapter, eq);
1550 return -1;
1551 }
1552
1553 static void be_rx_queues_destroy(struct be_adapter *adapter)
1554 {
1555 struct be_queue_info *q;
1556 struct be_rx_obj *rxo;
1557 int i;
1558
1559 for_all_rx_queues(adapter, rxo, i) {
1560 q = &rxo->q;
1561 if (q->created) {
1562 be_cmd_q_destroy(adapter, q, QTYPE_RXQ);
1563 /* After the rxq is invalidated, wait for a grace time
1564 * of 1ms for all dma to end and the flush compl to
1565 * arrive
1566 */
1567 mdelay(1);
1568 be_rx_q_clean(adapter, rxo);
1569 }
1570 be_queue_free(adapter, q);
1571
1572 q = &rxo->cq;
1573 if (q->created)
1574 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
1575 be_queue_free(adapter, q);
1576
1577 /* Clear any residual events */
1578 q = &rxo->rx_eq.q;
1579 if (q->created) {
1580 be_eq_clean(adapter, &rxo->rx_eq);
1581 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
1582 }
1583 be_queue_free(adapter, q);
1584 }
1585 }
1586
1587 static u32 be_num_rxqs_want(struct be_adapter *adapter)
1588 {
1589 if (multi_rxq && (adapter->function_caps & BE_FUNCTION_CAPS_RSS) &&
1590 !adapter->sriov_enabled && !(adapter->function_mode & 0x400)) {
1591 return 1 + MAX_RSS_QS; /* one default non-RSS queue */
1592 } else {
1593 dev_warn(&adapter->pdev->dev,
1594 "No support for multiple RX queues\n");
1595 return 1;
1596 }
1597 }
1598
1599 static int be_rx_queues_create(struct be_adapter *adapter)
1600 {
1601 struct be_queue_info *eq, *q, *cq;
1602 struct be_rx_obj *rxo;
1603 int rc, i;
1604
1605 adapter->num_rx_qs = min(be_num_rxqs_want(adapter),
1606 msix_enabled(adapter) ?
1607 adapter->num_msix_vec - 1 : 1);
1608 if (adapter->num_rx_qs != MAX_RX_QS)
1609 dev_warn(&adapter->pdev->dev,
1610 "Can create only %d RX queues", adapter->num_rx_qs);
1611
1612 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1613 for_all_rx_queues(adapter, rxo, i) {
1614 rxo->adapter = adapter;
1615 rxo->rx_eq.max_eqd = BE_MAX_EQD;
1616 rxo->rx_eq.enable_aic = true;
1617
1618 /* EQ */
1619 eq = &rxo->rx_eq.q;
1620 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1621 sizeof(struct be_eq_entry));
1622 if (rc)
1623 goto err;
1624
1625 rc = be_cmd_eq_create(adapter, eq, rxo->rx_eq.cur_eqd);
1626 if (rc)
1627 goto err;
1628
1629 rxo->rx_eq.eq_idx = adapter->eq_next_idx++;
1630
1631 /* CQ */
1632 cq = &rxo->cq;
1633 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
1634 sizeof(struct be_eth_rx_compl));
1635 if (rc)
1636 goto err;
1637
1638 rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3);
1639 if (rc)
1640 goto err;
1641 /* Rx Q */
1642 q = &rxo->q;
1643 rc = be_queue_alloc(adapter, q, RX_Q_LEN,
1644 sizeof(struct be_eth_rx_d));
1645 if (rc)
1646 goto err;
1647
1648 rc = be_cmd_rxq_create(adapter, q, cq->id, rx_frag_size,
1649 BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle,
1650 (i > 0) ? 1 : 0/* rss enable */, &rxo->rss_id);
1651 if (rc)
1652 goto err;
1653 }
1654
1655 if (be_multi_rxq(adapter)) {
1656 u8 rsstable[MAX_RSS_QS];
1657
1658 for_all_rss_queues(adapter, rxo, i)
1659 rsstable[i] = rxo->rss_id;
1660
1661 rc = be_cmd_rss_config(adapter, rsstable,
1662 adapter->num_rx_qs - 1);
1663 if (rc)
1664 goto err;
1665 }
1666
1667 return 0;
1668 err:
1669 be_rx_queues_destroy(adapter);
1670 return -1;
1671 }
1672
1673 static bool event_peek(struct be_eq_obj *eq_obj)
1674 {
1675 struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
1676 if (!eqe->evt)
1677 return false;
1678 else
1679 return true;
1680 }
1681
1682 static irqreturn_t be_intx(int irq, void *dev)
1683 {
1684 struct be_adapter *adapter = dev;
1685 struct be_rx_obj *rxo;
1686 int isr, i, tx = 0 , rx = 0;
1687
1688 if (lancer_chip(adapter)) {
1689 if (event_peek(&adapter->tx_eq))
1690 tx = event_handle(adapter, &adapter->tx_eq);
1691 for_all_rx_queues(adapter, rxo, i) {
1692 if (event_peek(&rxo->rx_eq))
1693 rx |= event_handle(adapter, &rxo->rx_eq);
1694 }
1695
1696 if (!(tx || rx))
1697 return IRQ_NONE;
1698
1699 } else {
1700 isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
1701 (adapter->tx_eq.q.id / 8) * CEV_ISR_SIZE);
1702 if (!isr)
1703 return IRQ_NONE;
1704
1705 if ((1 << adapter->tx_eq.eq_idx & isr))
1706 event_handle(adapter, &adapter->tx_eq);
1707
1708 for_all_rx_queues(adapter, rxo, i) {
1709 if ((1 << rxo->rx_eq.eq_idx & isr))
1710 event_handle(adapter, &rxo->rx_eq);
1711 }
1712 }
1713
1714 return IRQ_HANDLED;
1715 }
1716
1717 static irqreturn_t be_msix_rx(int irq, void *dev)
1718 {
1719 struct be_rx_obj *rxo = dev;
1720 struct be_adapter *adapter = rxo->adapter;
1721
1722 event_handle(adapter, &rxo->rx_eq);
1723
1724 return IRQ_HANDLED;
1725 }
1726
1727 static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
1728 {
1729 struct be_adapter *adapter = dev;
1730
1731 event_handle(adapter, &adapter->tx_eq);
1732
1733 return IRQ_HANDLED;
1734 }
1735
1736 static inline bool do_gro(struct be_rx_compl_info *rxcp)
1737 {
1738 return (rxcp->tcpf && !rxcp->err) ? true : false;
1739 }
1740
1741 static int be_poll_rx(struct napi_struct *napi, int budget)
1742 {
1743 struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1744 struct be_rx_obj *rxo = container_of(rx_eq, struct be_rx_obj, rx_eq);
1745 struct be_adapter *adapter = rxo->adapter;
1746 struct be_queue_info *rx_cq = &rxo->cq;
1747 struct be_rx_compl_info *rxcp;
1748 u32 work_done;
1749
1750 rxo->stats.rx_polls++;
1751 for (work_done = 0; work_done < budget; work_done++) {
1752 rxcp = be_rx_compl_get(rxo);
1753 if (!rxcp)
1754 break;
1755
1756 /* Ignore flush completions */
1757 if (rxcp->num_rcvd) {
1758 if (do_gro(rxcp))
1759 be_rx_compl_process_gro(adapter, rxo, rxcp);
1760 else
1761 be_rx_compl_process(adapter, rxo, rxcp);
1762 }
1763 be_rx_stats_update(rxo, rxcp);
1764 }
1765
1766 /* Refill the queue */
1767 if (atomic_read(&rxo->q.used) < RX_FRAGS_REFILL_WM)
1768 be_post_rx_frags(rxo, GFP_ATOMIC);
1769
1770 /* All consumed */
1771 if (work_done < budget) {
1772 napi_complete(napi);
1773 be_cq_notify(adapter, rx_cq->id, true, work_done);
1774 } else {
1775 /* More to be consumed; continue with interrupts disabled */
1776 be_cq_notify(adapter, rx_cq->id, false, work_done);
1777 }
1778 return work_done;
1779 }
1780
1781 /* As TX and MCC share the same EQ check for both TX and MCC completions.
1782 * For TX/MCC we don't honour budget; consume everything
1783 */
1784 static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1785 {
1786 struct be_eq_obj *tx_eq = container_of(napi, struct be_eq_obj, napi);
1787 struct be_adapter *adapter =
1788 container_of(tx_eq, struct be_adapter, tx_eq);
1789 struct be_queue_info *txq = &adapter->tx_obj.q;
1790 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1791 struct be_eth_tx_compl *txcp;
1792 int tx_compl = 0, mcc_compl, status = 0;
1793 u16 end_idx;
1794
1795 while ((txcp = be_tx_compl_get(tx_cq))) {
1796 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1797 wrb_index, txcp);
1798 be_tx_compl_process(adapter, end_idx);
1799 tx_compl++;
1800 }
1801
1802 mcc_compl = be_process_mcc(adapter, &status);
1803
1804 napi_complete(napi);
1805
1806 if (mcc_compl) {
1807 struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
1808 be_cq_notify(adapter, mcc_obj->cq.id, true, mcc_compl);
1809 }
1810
1811 if (tx_compl) {
1812 be_cq_notify(adapter, adapter->tx_obj.cq.id, true, tx_compl);
1813
1814 /* As Tx wrbs have been freed up, wake up netdev queue if
1815 * it was stopped due to lack of tx wrbs.
1816 */
1817 if (netif_queue_stopped(adapter->netdev) &&
1818 atomic_read(&txq->used) < txq->len / 2) {
1819 netif_wake_queue(adapter->netdev);
1820 }
1821
1822 tx_stats(adapter)->be_tx_events++;
1823 tx_stats(adapter)->be_tx_compl += tx_compl;
1824 }
1825
1826 return 1;
1827 }
1828
1829 void be_detect_dump_ue(struct be_adapter *adapter)
1830 {
1831 u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
1832 u32 i;
1833
1834 pci_read_config_dword(adapter->pdev,
1835 PCICFG_UE_STATUS_LOW, &ue_status_lo);
1836 pci_read_config_dword(adapter->pdev,
1837 PCICFG_UE_STATUS_HIGH, &ue_status_hi);
1838 pci_read_config_dword(adapter->pdev,
1839 PCICFG_UE_STATUS_LOW_MASK, &ue_status_lo_mask);
1840 pci_read_config_dword(adapter->pdev,
1841 PCICFG_UE_STATUS_HI_MASK, &ue_status_hi_mask);
1842
1843 ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
1844 ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));
1845
1846 if (ue_status_lo || ue_status_hi) {
1847 adapter->ue_detected = true;
1848 adapter->eeh_err = true;
1849 dev_err(&adapter->pdev->dev, "UE Detected!!\n");
1850 }
1851
1852 if (ue_status_lo) {
1853 for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
1854 if (ue_status_lo & 1)
1855 dev_err(&adapter->pdev->dev,
1856 "UE: %s bit set\n", ue_status_low_desc[i]);
1857 }
1858 }
1859 if (ue_status_hi) {
1860 for (i = 0; ue_status_hi; ue_status_hi >>= 1, i++) {
1861 if (ue_status_hi & 1)
1862 dev_err(&adapter->pdev->dev,
1863 "UE: %s bit set\n", ue_status_hi_desc[i]);
1864 }
1865 }
1866
1867 }
1868
1869 static void be_worker(struct work_struct *work)
1870 {
1871 struct be_adapter *adapter =
1872 container_of(work, struct be_adapter, work.work);
1873 struct be_rx_obj *rxo;
1874 int i;
1875
1876 if (!adapter->ue_detected && !lancer_chip(adapter))
1877 be_detect_dump_ue(adapter);
1878
1879 /* when interrupts are not yet enabled, just reap any pending
1880 * mcc completions */
1881 if (!netif_running(adapter->netdev)) {
1882 int mcc_compl, status = 0;
1883
1884 mcc_compl = be_process_mcc(adapter, &status);
1885
1886 if (mcc_compl) {
1887 struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
1888 be_cq_notify(adapter, mcc_obj->cq.id, false, mcc_compl);
1889 }
1890
1891 goto reschedule;
1892 }
1893
1894 if (!adapter->stats_cmd_sent)
1895 be_cmd_get_stats(adapter, &adapter->stats_cmd);
1896
1897 be_tx_rate_update(adapter);
1898
1899 for_all_rx_queues(adapter, rxo, i) {
1900 be_rx_rate_update(rxo);
1901 be_rx_eqd_update(adapter, rxo);
1902
1903 if (rxo->rx_post_starved) {
1904 rxo->rx_post_starved = false;
1905 be_post_rx_frags(rxo, GFP_KERNEL);
1906 }
1907 }
1908
1909 reschedule:
1910 adapter->work_counter++;
1911 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
1912 }
1913
1914 static void be_msix_disable(struct be_adapter *adapter)
1915 {
1916 if (msix_enabled(adapter)) {
1917 pci_disable_msix(adapter->pdev);
1918 adapter->num_msix_vec = 0;
1919 }
1920 }
1921
1922 static void be_msix_enable(struct be_adapter *adapter)
1923 {
1924 #define BE_MIN_MSIX_VECTORS (1 + 1) /* Rx + Tx */
1925 int i, status, num_vec;
1926
1927 num_vec = be_num_rxqs_want(adapter) + 1;
1928
1929 for (i = 0; i < num_vec; i++)
1930 adapter->msix_entries[i].entry = i;
1931
1932 status = pci_enable_msix(adapter->pdev, adapter->msix_entries, num_vec);
1933 if (status == 0) {
1934 goto done;
1935 } else if (status >= BE_MIN_MSIX_VECTORS) {
1936 num_vec = status;
1937 if (pci_enable_msix(adapter->pdev, adapter->msix_entries,
1938 num_vec) == 0)
1939 goto done;
1940 }
1941 return;
1942 done:
1943 adapter->num_msix_vec = num_vec;
1944 return;
1945 }
1946
1947 static void be_sriov_enable(struct be_adapter *adapter)
1948 {
1949 be_check_sriov_fn_type(adapter);
1950 #ifdef CONFIG_PCI_IOV
1951 if (be_physfn(adapter) && num_vfs) {
1952 int status, pos;
1953 u16 nvfs;
1954
1955 pos = pci_find_ext_capability(adapter->pdev,
1956 PCI_EXT_CAP_ID_SRIOV);
1957 pci_read_config_word(adapter->pdev,
1958 pos + PCI_SRIOV_TOTAL_VF, &nvfs);
1959
1960 if (num_vfs > nvfs) {
1961 dev_info(&adapter->pdev->dev,
1962 "Device supports %d VFs and not %d\n",
1963 nvfs, num_vfs);
1964 num_vfs = nvfs;
1965 }
1966
1967 status = pci_enable_sriov(adapter->pdev, num_vfs);
1968 adapter->sriov_enabled = status ? false : true;
1969 }
1970 #endif
1971 }
1972
1973 static void be_sriov_disable(struct be_adapter *adapter)
1974 {
1975 #ifdef CONFIG_PCI_IOV
1976 if (adapter->sriov_enabled) {
1977 pci_disable_sriov(adapter->pdev);
1978 adapter->sriov_enabled = false;
1979 }
1980 #endif
1981 }
1982
1983 static inline int be_msix_vec_get(struct be_adapter *adapter,
1984 struct be_eq_obj *eq_obj)
1985 {
1986 return adapter->msix_entries[eq_obj->eq_idx].vector;
1987 }
1988
1989 static int be_request_irq(struct be_adapter *adapter,
1990 struct be_eq_obj *eq_obj,
1991 void *handler, char *desc, void *context)
1992 {
1993 struct net_device *netdev = adapter->netdev;
1994 int vec;
1995
1996 sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
1997 vec = be_msix_vec_get(adapter, eq_obj);
1998 return request_irq(vec, handler, 0, eq_obj->desc, context);
1999 }
2000
2001 static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj,
2002 void *context)
2003 {
2004 int vec = be_msix_vec_get(adapter, eq_obj);
2005 free_irq(vec, context);
2006 }
2007
2008 static int be_msix_register(struct be_adapter *adapter)
2009 {
2010 struct be_rx_obj *rxo;
2011 int status, i;
2012 char qname[10];
2013
2014 status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx",
2015 adapter);
2016 if (status)
2017 goto err;
2018
2019 for_all_rx_queues(adapter, rxo, i) {
2020 sprintf(qname, "rxq%d", i);
2021 status = be_request_irq(adapter, &rxo->rx_eq, be_msix_rx,
2022 qname, rxo);
2023 if (status)
2024 goto err_msix;
2025 }
2026
2027 return 0;
2028
2029 err_msix:
2030 be_free_irq(adapter, &adapter->tx_eq, adapter);
2031
2032 for (i--, rxo = &adapter->rx_obj[i]; i >= 0; i--, rxo--)
2033 be_free_irq(adapter, &rxo->rx_eq, rxo);
2034
2035 err:
2036 dev_warn(&adapter->pdev->dev,
2037 "MSIX Request IRQ failed - err %d\n", status);
2038 be_msix_disable(adapter);
2039 return status;
2040 }
2041
2042 static int be_irq_register(struct be_adapter *adapter)
2043 {
2044 struct net_device *netdev = adapter->netdev;
2045 int status;
2046
2047 if (msix_enabled(adapter)) {
2048 status = be_msix_register(adapter);
2049 if (status == 0)
2050 goto done;
2051 /* INTx is not supported for VF */
2052 if (!be_physfn(adapter))
2053 return status;
2054 }
2055
2056 /* INTx */
2057 netdev->irq = adapter->pdev->irq;
2058 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
2059 adapter);
2060 if (status) {
2061 dev_err(&adapter->pdev->dev,
2062 "INTx request IRQ failed - err %d\n", status);
2063 return status;
2064 }
2065 done:
2066 adapter->isr_registered = true;
2067 return 0;
2068 }
2069
2070 static void be_irq_unregister(struct be_adapter *adapter)
2071 {
2072 struct net_device *netdev = adapter->netdev;
2073 struct be_rx_obj *rxo;
2074 int i;
2075
2076 if (!adapter->isr_registered)
2077 return;
2078
2079 /* INTx */
2080 if (!msix_enabled(adapter)) {
2081 free_irq(netdev->irq, adapter);
2082 goto done;
2083 }
2084
2085 /* MSIx */
2086 be_free_irq(adapter, &adapter->tx_eq, adapter);
2087
2088 for_all_rx_queues(adapter, rxo, i)
2089 be_free_irq(adapter, &rxo->rx_eq, rxo);
2090
2091 done:
2092 adapter->isr_registered = false;
2093 }
2094
2095 static int be_close(struct net_device *netdev)
2096 {
2097 struct be_adapter *adapter = netdev_priv(netdev);
2098 struct be_rx_obj *rxo;
2099 struct be_eq_obj *tx_eq = &adapter->tx_eq;
2100 int vec, i;
2101
2102 be_async_mcc_disable(adapter);
2103
2104 netif_carrier_off(netdev);
2105 adapter->link_up = false;
2106
2107 if (!lancer_chip(adapter))
2108 be_intr_set(adapter, false);
2109
2110 for_all_rx_queues(adapter, rxo, i)
2111 napi_disable(&rxo->rx_eq.napi);
2112
2113 napi_disable(&tx_eq->napi);
2114
2115 if (lancer_chip(adapter)) {
2116 be_cq_notify(adapter, adapter->tx_obj.cq.id, false, 0);
2117 be_cq_notify(adapter, adapter->mcc_obj.cq.id, false, 0);
2118 for_all_rx_queues(adapter, rxo, i)
2119 be_cq_notify(adapter, rxo->cq.id, false, 0);
2120 }
2121
2122 if (msix_enabled(adapter)) {
2123 vec = be_msix_vec_get(adapter, tx_eq);
2124 synchronize_irq(vec);
2125
2126 for_all_rx_queues(adapter, rxo, i) {
2127 vec = be_msix_vec_get(adapter, &rxo->rx_eq);
2128 synchronize_irq(vec);
2129 }
2130 } else {
2131 synchronize_irq(netdev->irq);
2132 }
2133 be_irq_unregister(adapter);
2134
2135 /* Wait for all pending tx completions to arrive so that
2136 * all tx skbs are freed.
2137 */
2138 be_tx_compl_clean(adapter);
2139
2140 return 0;
2141 }
2142
2143 static int be_open(struct net_device *netdev)
2144 {
2145 struct be_adapter *adapter = netdev_priv(netdev);
2146 struct be_eq_obj *tx_eq = &adapter->tx_eq;
2147 struct be_rx_obj *rxo;
2148 bool link_up;
2149 int status, i;
2150 u8 mac_speed;
2151 u16 link_speed;
2152
2153 for_all_rx_queues(adapter, rxo, i) {
2154 be_post_rx_frags(rxo, GFP_KERNEL);
2155 napi_enable(&rxo->rx_eq.napi);
2156 }
2157 napi_enable(&tx_eq->napi);
2158
2159 be_irq_register(adapter);
2160
2161 if (!lancer_chip(adapter))
2162 be_intr_set(adapter, true);
2163
2164 /* The evt queues are created in unarmed state; arm them */
2165 for_all_rx_queues(adapter, rxo, i) {
2166 be_eq_notify(adapter, rxo->rx_eq.q.id, true, false, 0);
2167 be_cq_notify(adapter, rxo->cq.id, true, 0);
2168 }
2169 be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
2170
2171 /* Now that interrupts are on we can process async mcc */
2172 be_async_mcc_enable(adapter);
2173
2174 status = be_cmd_link_status_query(adapter, &link_up, &mac_speed,
2175 &link_speed, 0);
2176 if (status)
2177 goto err;
2178 be_link_status_update(adapter, link_up);
2179
2180 if (be_physfn(adapter)) {
2181 status = be_vid_config(adapter, false, 0);
2182 if (status)
2183 goto err;
2184
2185 status = be_cmd_set_flow_control(adapter,
2186 adapter->tx_fc, adapter->rx_fc);
2187 if (status)
2188 goto err;
2189 }
2190
2191 return 0;
2192 err:
2193 be_close(adapter->netdev);
2194 return -EIO;
2195 }
2196
2197 static int be_setup_wol(struct be_adapter *adapter, bool enable)
2198 {
2199 struct be_dma_mem cmd;
2200 int status = 0;
2201 u8 mac[ETH_ALEN];
2202
2203 memset(mac, 0, ETH_ALEN);
2204
2205 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2206 cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
2207 GFP_KERNEL);
2208 if (cmd.va == NULL)
2209 return -1;
2210 memset(cmd.va, 0, cmd.size);
2211
2212 if (enable) {
2213 status = pci_write_config_dword(adapter->pdev,
2214 PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
2215 if (status) {
2216 dev_err(&adapter->pdev->dev,
2217 "Could not enable Wake-on-lan\n");
2218 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va,
2219 cmd.dma);
2220 return status;
2221 }
2222 status = be_cmd_enable_magic_wol(adapter,
2223 adapter->netdev->dev_addr, &cmd);
2224 pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
2225 pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
2226 } else {
2227 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
2228 pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
2229 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2230 }
2231
2232 dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);
2233 return status;
2234 }
2235
2236 /*
2237 * Generate a seed MAC address from the PF MAC Address using jhash.
2238 * MAC Address for VFs are assigned incrementally starting from the seed.
2239 * These addresses are programmed in the ASIC by the PF and the VF driver
2240 * queries for the MAC address during its probe.
2241 */
2242 static inline int be_vf_eth_addr_config(struct be_adapter *adapter)
2243 {
2244 u32 vf = 0;
2245 int status = 0;
2246 u8 mac[ETH_ALEN];
2247
2248 be_vf_eth_addr_generate(adapter, mac);
2249
2250 for (vf = 0; vf < num_vfs; vf++) {
2251 status = be_cmd_pmac_add(adapter, mac,
2252 adapter->vf_cfg[vf].vf_if_handle,
2253 &adapter->vf_cfg[vf].vf_pmac_id,
2254 vf + 1);
2255 if (status)
2256 dev_err(&adapter->pdev->dev,
2257 "Mac address add failed for VF %d\n", vf);
2258 else
2259 memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
2260
2261 mac[5] += 1;
2262 }
2263 return status;
2264 }
2265
2266 static inline void be_vf_eth_addr_rem(struct be_adapter *adapter)
2267 {
2268 u32 vf;
2269
2270 for (vf = 0; vf < num_vfs; vf++) {
2271 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
2272 be_cmd_pmac_del(adapter,
2273 adapter->vf_cfg[vf].vf_if_handle,
2274 adapter->vf_cfg[vf].vf_pmac_id, vf + 1);
2275 }
2276 }
2277
2278 static int be_setup(struct be_adapter *adapter)
2279 {
2280 struct net_device *netdev = adapter->netdev;
2281 u32 cap_flags, en_flags, vf = 0;
2282 int status;
2283 u8 mac[ETH_ALEN];
2284
2285 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED |
2286 BE_IF_FLAGS_BROADCAST |
2287 BE_IF_FLAGS_MULTICAST;
2288
2289 if (be_physfn(adapter)) {
2290 cap_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS |
2291 BE_IF_FLAGS_PROMISCUOUS |
2292 BE_IF_FLAGS_PASS_L3L4_ERRORS;
2293 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS;
2294
2295 if (adapter->function_caps & BE_FUNCTION_CAPS_RSS) {
2296 cap_flags |= BE_IF_FLAGS_RSS;
2297 en_flags |= BE_IF_FLAGS_RSS;
2298 }
2299 }
2300
2301 status = be_cmd_if_create(adapter, cap_flags, en_flags,
2302 netdev->dev_addr, false/* pmac_invalid */,
2303 &adapter->if_handle, &adapter->pmac_id, 0);
2304 if (status != 0)
2305 goto do_none;
2306
2307 if (be_physfn(adapter)) {
2308 if (adapter->sriov_enabled) {
2309 while (vf < num_vfs) {
2310 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED |
2311 BE_IF_FLAGS_BROADCAST;
2312 status = be_cmd_if_create(adapter, cap_flags,
2313 en_flags, mac, true,
2314 &adapter->vf_cfg[vf].vf_if_handle,
2315 NULL, vf+1);
2316 if (status) {
2317 dev_err(&adapter->pdev->dev,
2318 "Interface Create failed for VF %d\n",
2319 vf);
2320 goto if_destroy;
2321 }
2322 adapter->vf_cfg[vf].vf_pmac_id =
2323 BE_INVALID_PMAC_ID;
2324 vf++;
2325 }
2326 }
2327 } else {
2328 status = be_cmd_mac_addr_query(adapter, mac,
2329 MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
2330 if (!status) {
2331 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2332 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2333 }
2334 }
2335
2336 status = be_tx_queues_create(adapter);
2337 if (status != 0)
2338 goto if_destroy;
2339
2340 status = be_rx_queues_create(adapter);
2341 if (status != 0)
2342 goto tx_qs_destroy;
2343
2344 status = be_mcc_queues_create(adapter);
2345 if (status != 0)
2346 goto rx_qs_destroy;
2347
2348 adapter->link_speed = -1;
2349
2350 return 0;
2351
2352 rx_qs_destroy:
2353 be_rx_queues_destroy(adapter);
2354 tx_qs_destroy:
2355 be_tx_queues_destroy(adapter);
2356 if_destroy:
2357 if (be_physfn(adapter) && adapter->sriov_enabled)
2358 for (vf = 0; vf < num_vfs; vf++)
2359 if (adapter->vf_cfg[vf].vf_if_handle)
2360 be_cmd_if_destroy(adapter,
2361 adapter->vf_cfg[vf].vf_if_handle,
2362 vf + 1);
2363 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
2364 do_none:
2365 return status;
2366 }
2367
2368 static int be_clear(struct be_adapter *adapter)
2369 {
2370 int vf;
2371
2372 if (be_physfn(adapter) && adapter->sriov_enabled)
2373 be_vf_eth_addr_rem(adapter);
2374
2375 be_mcc_queues_destroy(adapter);
2376 be_rx_queues_destroy(adapter);
2377 be_tx_queues_destroy(adapter);
2378 adapter->eq_next_idx = 0;
2379
2380 if (be_physfn(adapter) && adapter->sriov_enabled)
2381 for (vf = 0; vf < num_vfs; vf++)
2382 if (adapter->vf_cfg[vf].vf_if_handle)
2383 be_cmd_if_destroy(adapter,
2384 adapter->vf_cfg[vf].vf_if_handle,
2385 vf + 1);
2386
2387 be_cmd_if_destroy(adapter, adapter->if_handle, 0);
2388
2389 /* tell fw we're done with firing cmds */
2390 be_cmd_fw_clean(adapter);
2391 return 0;
2392 }
2393
2394
2395 #define FW_FILE_HDR_SIGN "ServerEngines Corp. "
2396 static bool be_flash_redboot(struct be_adapter *adapter,
2397 const u8 *p, u32 img_start, int image_size,
2398 int hdr_size)
2399 {
2400 u32 crc_offset;
2401 u8 flashed_crc[4];
2402 int status;
2403
2404 crc_offset = hdr_size + img_start + image_size - 4;
2405
2406 p += crc_offset;
2407
2408 status = be_cmd_get_flash_crc(adapter, flashed_crc,
2409 (image_size - 4));
2410 if (status) {
2411 dev_err(&adapter->pdev->dev,
2412 "could not get crc from flash, not flashing redboot\n");
2413 return false;
2414 }
2415
2416 /*update redboot only if crc does not match*/
2417 if (!memcmp(flashed_crc, p, 4))
2418 return false;
2419 else
2420 return true;
2421 }
2422
2423 static int be_flash_data(struct be_adapter *adapter,
2424 const struct firmware *fw,
2425 struct be_dma_mem *flash_cmd, int num_of_images)
2426
2427 {
2428 int status = 0, i, filehdr_size = 0;
2429 u32 total_bytes = 0, flash_op;
2430 int num_bytes;
2431 const u8 *p = fw->data;
2432 struct be_cmd_write_flashrom *req = flash_cmd->va;
2433 const struct flash_comp *pflashcomp;
2434 int num_comp;
2435
2436 static const struct flash_comp gen3_flash_types[9] = {
2437 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE,
2438 FLASH_IMAGE_MAX_SIZE_g3},
2439 { FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT,
2440 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3},
2441 { FLASH_iSCSI_BIOS_START_g3, IMG_TYPE_BIOS,
2442 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2443 { FLASH_PXE_BIOS_START_g3, IMG_TYPE_PXE_BIOS,
2444 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2445 { FLASH_FCoE_BIOS_START_g3, IMG_TYPE_FCOE_BIOS,
2446 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2447 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, IMG_TYPE_ISCSI_BACKUP,
2448 FLASH_IMAGE_MAX_SIZE_g3},
2449 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, IMG_TYPE_FCOE_FW_ACTIVE,
2450 FLASH_IMAGE_MAX_SIZE_g3},
2451 { FLASH_FCoE_BACKUP_IMAGE_START_g3, IMG_TYPE_FCOE_FW_BACKUP,
2452 FLASH_IMAGE_MAX_SIZE_g3},
2453 { FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2454 FLASH_NCSI_IMAGE_MAX_SIZE_g3}
2455 };
2456 static const struct flash_comp gen2_flash_types[8] = {
2457 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE,
2458 FLASH_IMAGE_MAX_SIZE_g2},
2459 { FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT,
2460 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2},
2461 { FLASH_iSCSI_BIOS_START_g2, IMG_TYPE_BIOS,
2462 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2463 { FLASH_PXE_BIOS_START_g2, IMG_TYPE_PXE_BIOS,
2464 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2465 { FLASH_FCoE_BIOS_START_g2, IMG_TYPE_FCOE_BIOS,
2466 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2467 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, IMG_TYPE_ISCSI_BACKUP,
2468 FLASH_IMAGE_MAX_SIZE_g2},
2469 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, IMG_TYPE_FCOE_FW_ACTIVE,
2470 FLASH_IMAGE_MAX_SIZE_g2},
2471 { FLASH_FCoE_BACKUP_IMAGE_START_g2, IMG_TYPE_FCOE_FW_BACKUP,
2472 FLASH_IMAGE_MAX_SIZE_g2}
2473 };
2474
2475 if (adapter->generation == BE_GEN3) {
2476 pflashcomp = gen3_flash_types;
2477 filehdr_size = sizeof(struct flash_file_hdr_g3);
2478 num_comp = ARRAY_SIZE(gen3_flash_types);
2479 } else {
2480 pflashcomp = gen2_flash_types;
2481 filehdr_size = sizeof(struct flash_file_hdr_g2);
2482 num_comp = ARRAY_SIZE(gen2_flash_types);
2483 }
2484 for (i = 0; i < num_comp; i++) {
2485 if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) &&
2486 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
2487 continue;
2488 if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
2489 (!be_flash_redboot(adapter, fw->data,
2490 pflashcomp[i].offset, pflashcomp[i].size, filehdr_size +
2491 (num_of_images * sizeof(struct image_hdr)))))
2492 continue;
2493 p = fw->data;
2494 p += filehdr_size + pflashcomp[i].offset
2495 + (num_of_images * sizeof(struct image_hdr));
2496 if (p + pflashcomp[i].size > fw->data + fw->size)
2497 return -1;
2498 total_bytes = pflashcomp[i].size;
2499 while (total_bytes) {
2500 if (total_bytes > 32*1024)
2501 num_bytes = 32*1024;
2502 else
2503 num_bytes = total_bytes;
2504 total_bytes -= num_bytes;
2505
2506 if (!total_bytes)
2507 flash_op = FLASHROM_OPER_FLASH;
2508 else
2509 flash_op = FLASHROM_OPER_SAVE;
2510 memcpy(req->params.data_buf, p, num_bytes);
2511 p += num_bytes;
2512 status = be_cmd_write_flashrom(adapter, flash_cmd,
2513 pflashcomp[i].optype, flash_op, num_bytes);
2514 if (status) {
2515 dev_err(&adapter->pdev->dev,
2516 "cmd to write to flash rom failed.\n");
2517 return -1;
2518 }
2519 yield();
2520 }
2521 }
2522 return 0;
2523 }
2524
2525 static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
2526 {
2527 if (fhdr == NULL)
2528 return 0;
2529 if (fhdr->build[0] == '3')
2530 return BE_GEN3;
2531 else if (fhdr->build[0] == '2')
2532 return BE_GEN2;
2533 else
2534 return 0;
2535 }
2536
2537 int be_load_fw(struct be_adapter *adapter, u8 *func)
2538 {
2539 char fw_file[ETHTOOL_FLASH_MAX_FILENAME];
2540 const struct firmware *fw;
2541 struct flash_file_hdr_g2 *fhdr;
2542 struct flash_file_hdr_g3 *fhdr3;
2543 struct image_hdr *img_hdr_ptr = NULL;
2544 struct be_dma_mem flash_cmd;
2545 int status, i = 0, num_imgs = 0;
2546 const u8 *p;
2547
2548 if (!netif_running(adapter->netdev)) {
2549 dev_err(&adapter->pdev->dev,
2550 "Firmware load not allowed (interface is down)\n");
2551 return -EPERM;
2552 }
2553
2554 strcpy(fw_file, func);
2555
2556 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
2557 if (status)
2558 goto fw_exit;
2559
2560 p = fw->data;
2561 fhdr = (struct flash_file_hdr_g2 *) p;
2562 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
2563
2564 flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
2565 flash_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, flash_cmd.size,
2566 &flash_cmd.dma, GFP_KERNEL);
2567 if (!flash_cmd.va) {
2568 status = -ENOMEM;
2569 dev_err(&adapter->pdev->dev,
2570 "Memory allocation failure while flashing\n");
2571 goto fw_exit;
2572 }
2573
2574 if ((adapter->generation == BE_GEN3) &&
2575 (get_ufigen_type(fhdr) == BE_GEN3)) {
2576 fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
2577 num_imgs = le32_to_cpu(fhdr3->num_imgs);
2578 for (i = 0; i < num_imgs; i++) {
2579 img_hdr_ptr = (struct image_hdr *) (fw->data +
2580 (sizeof(struct flash_file_hdr_g3) +
2581 i * sizeof(struct image_hdr)));
2582 if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
2583 status = be_flash_data(adapter, fw, &flash_cmd,
2584 num_imgs);
2585 }
2586 } else if ((adapter->generation == BE_GEN2) &&
2587 (get_ufigen_type(fhdr) == BE_GEN2)) {
2588 status = be_flash_data(adapter, fw, &flash_cmd, 0);
2589 } else {
2590 dev_err(&adapter->pdev->dev,
2591 "UFI and Interface are not compatible for flashing\n");
2592 status = -1;
2593 }
2594
2595 dma_free_coherent(&adapter->pdev->dev, flash_cmd.size, flash_cmd.va,
2596 flash_cmd.dma);
2597 if (status) {
2598 dev_err(&adapter->pdev->dev, "Firmware load error\n");
2599 goto fw_exit;
2600 }
2601
2602 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
2603
2604 fw_exit:
2605 release_firmware(fw);
2606 return status;
2607 }
2608
2609 static struct net_device_ops be_netdev_ops = {
2610 .ndo_open = be_open,
2611 .ndo_stop = be_close,
2612 .ndo_start_xmit = be_xmit,
2613 .ndo_set_rx_mode = be_set_multicast_list,
2614 .ndo_set_mac_address = be_mac_addr_set,
2615 .ndo_change_mtu = be_change_mtu,
2616 .ndo_validate_addr = eth_validate_addr,
2617 .ndo_vlan_rx_register = be_vlan_register,
2618 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
2619 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
2620 .ndo_set_vf_mac = be_set_vf_mac,
2621 .ndo_set_vf_vlan = be_set_vf_vlan,
2622 .ndo_set_vf_tx_rate = be_set_vf_tx_rate,
2623 .ndo_get_vf_config = be_get_vf_config
2624 };
2625
2626 static void be_netdev_init(struct net_device *netdev)
2627 {
2628 struct be_adapter *adapter = netdev_priv(netdev);
2629 struct be_rx_obj *rxo;
2630 int i;
2631
2632 netdev->hw_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_TSO6 |
2633 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
2634 NETIF_F_HW_VLAN_TX;
2635 if (be_multi_rxq(adapter))
2636 netdev->hw_features |= NETIF_F_RXHASH;
2637
2638 netdev->features |= netdev->hw_features |
2639 NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
2640
2641 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO |
2642 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
2643
2644 if (lancer_chip(adapter))
2645 netdev->vlan_features |= NETIF_F_TSO6;
2646
2647 netdev->flags |= IFF_MULTICAST;
2648
2649 /* Default settings for Rx and Tx flow control */
2650 adapter->rx_fc = true;
2651 adapter->tx_fc = true;
2652
2653 netif_set_gso_max_size(netdev, 65535);
2654
2655 BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
2656
2657 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
2658
2659 for_all_rx_queues(adapter, rxo, i)
2660 netif_napi_add(netdev, &rxo->rx_eq.napi, be_poll_rx,
2661 BE_NAPI_WEIGHT);
2662
2663 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
2664 BE_NAPI_WEIGHT);
2665 }
2666
2667 static void be_unmap_pci_bars(struct be_adapter *adapter)
2668 {
2669 if (adapter->csr)
2670 iounmap(adapter->csr);
2671 if (adapter->db)
2672 iounmap(adapter->db);
2673 if (adapter->pcicfg && be_physfn(adapter))
2674 iounmap(adapter->pcicfg);
2675 }
2676
2677 static int be_map_pci_bars(struct be_adapter *adapter)
2678 {
2679 u8 __iomem *addr;
2680 int pcicfg_reg, db_reg;
2681
2682 if (lancer_chip(adapter)) {
2683 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 0),
2684 pci_resource_len(adapter->pdev, 0));
2685 if (addr == NULL)
2686 return -ENOMEM;
2687 adapter->db = addr;
2688 return 0;
2689 }
2690
2691 if (be_physfn(adapter)) {
2692 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
2693 pci_resource_len(adapter->pdev, 2));
2694 if (addr == NULL)
2695 return -ENOMEM;
2696 adapter->csr = addr;
2697 }
2698
2699 if (adapter->generation == BE_GEN2) {
2700 pcicfg_reg = 1;
2701 db_reg = 4;
2702 } else {
2703 pcicfg_reg = 0;
2704 if (be_physfn(adapter))
2705 db_reg = 4;
2706 else
2707 db_reg = 0;
2708 }
2709 addr = ioremap_nocache(pci_resource_start(adapter->pdev, db_reg),
2710 pci_resource_len(adapter->pdev, db_reg));
2711 if (addr == NULL)
2712 goto pci_map_err;
2713 adapter->db = addr;
2714
2715 if (be_physfn(adapter)) {
2716 addr = ioremap_nocache(
2717 pci_resource_start(adapter->pdev, pcicfg_reg),
2718 pci_resource_len(adapter->pdev, pcicfg_reg));
2719 if (addr == NULL)
2720 goto pci_map_err;
2721 adapter->pcicfg = addr;
2722 } else
2723 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
2724
2725 return 0;
2726 pci_map_err:
2727 be_unmap_pci_bars(adapter);
2728 return -ENOMEM;
2729 }
2730
2731
2732 static void be_ctrl_cleanup(struct be_adapter *adapter)
2733 {
2734 struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
2735
2736 be_unmap_pci_bars(adapter);
2737
2738 if (mem->va)
2739 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
2740 mem->dma);
2741
2742 mem = &adapter->mc_cmd_mem;
2743 if (mem->va)
2744 dma_free_coherent(&adapter->pdev->dev, mem->size, mem->va,
2745 mem->dma);
2746 }
2747
2748 static int be_ctrl_init(struct be_adapter *adapter)
2749 {
2750 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
2751 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
2752 struct be_dma_mem *mc_cmd_mem = &adapter->mc_cmd_mem;
2753 int status;
2754
2755 status = be_map_pci_bars(adapter);
2756 if (status)
2757 goto done;
2758
2759 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
2760 mbox_mem_alloc->va = dma_alloc_coherent(&adapter->pdev->dev,
2761 mbox_mem_alloc->size,
2762 &mbox_mem_alloc->dma,
2763 GFP_KERNEL);
2764 if (!mbox_mem_alloc->va) {
2765 status = -ENOMEM;
2766 goto unmap_pci_bars;
2767 }
2768
2769 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
2770 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
2771 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
2772 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
2773
2774 mc_cmd_mem->size = sizeof(struct be_cmd_req_mcast_mac_config);
2775 mc_cmd_mem->va = dma_alloc_coherent(&adapter->pdev->dev,
2776 mc_cmd_mem->size, &mc_cmd_mem->dma,
2777 GFP_KERNEL);
2778 if (mc_cmd_mem->va == NULL) {
2779 status = -ENOMEM;
2780 goto free_mbox;
2781 }
2782 memset(mc_cmd_mem->va, 0, mc_cmd_mem->size);
2783
2784 mutex_init(&adapter->mbox_lock);
2785 spin_lock_init(&adapter->mcc_lock);
2786 spin_lock_init(&adapter->mcc_cq_lock);
2787
2788 init_completion(&adapter->flash_compl);
2789 pci_save_state(adapter->pdev);
2790 return 0;
2791
2792 free_mbox:
2793 dma_free_coherent(&adapter->pdev->dev, mbox_mem_alloc->size,
2794 mbox_mem_alloc->va, mbox_mem_alloc->dma);
2795
2796 unmap_pci_bars:
2797 be_unmap_pci_bars(adapter);
2798
2799 done:
2800 return status;
2801 }
2802
2803 static void be_stats_cleanup(struct be_adapter *adapter)
2804 {
2805 struct be_dma_mem *cmd = &adapter->stats_cmd;
2806
2807 if (cmd->va)
2808 dma_free_coherent(&adapter->pdev->dev, cmd->size,
2809 cmd->va, cmd->dma);
2810 }
2811
2812 static int be_stats_init(struct be_adapter *adapter)
2813 {
2814 struct be_dma_mem *cmd = &adapter->stats_cmd;
2815
2816 cmd->size = sizeof(struct be_cmd_req_get_stats);
2817 cmd->va = dma_alloc_coherent(&adapter->pdev->dev, cmd->size, &cmd->dma,
2818 GFP_KERNEL);
2819 if (cmd->va == NULL)
2820 return -1;
2821 memset(cmd->va, 0, cmd->size);
2822 return 0;
2823 }
2824
2825 static void __devexit be_remove(struct pci_dev *pdev)
2826 {
2827 struct be_adapter *adapter = pci_get_drvdata(pdev);
2828
2829 if (!adapter)
2830 return;
2831
2832 cancel_delayed_work_sync(&adapter->work);
2833
2834 unregister_netdev(adapter->netdev);
2835
2836 be_clear(adapter);
2837
2838 be_stats_cleanup(adapter);
2839
2840 be_ctrl_cleanup(adapter);
2841
2842 kfree(adapter->vf_cfg);
2843 be_sriov_disable(adapter);
2844
2845 be_msix_disable(adapter);
2846
2847 pci_set_drvdata(pdev, NULL);
2848 pci_release_regions(pdev);
2849 pci_disable_device(pdev);
2850
2851 free_netdev(adapter->netdev);
2852 }
2853
2854 static int be_get_config(struct be_adapter *adapter)
2855 {
2856 int status;
2857 u8 mac[ETH_ALEN];
2858
2859 status = be_cmd_get_fw_ver(adapter, adapter->fw_ver);
2860 if (status)
2861 return status;
2862
2863 status = be_cmd_query_fw_cfg(adapter, &adapter->port_num,
2864 &adapter->function_mode, &adapter->function_caps);
2865 if (status)
2866 return status;
2867
2868 memset(mac, 0, ETH_ALEN);
2869
2870 if (be_physfn(adapter)) {
2871 status = be_cmd_mac_addr_query(adapter, mac,
2872 MAC_ADDRESS_TYPE_NETWORK, true /*permanent */, 0);
2873
2874 if (status)
2875 return status;
2876
2877 if (!is_valid_ether_addr(mac))
2878 return -EADDRNOTAVAIL;
2879
2880 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2881 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2882 }
2883
2884 if (adapter->function_mode & 0x400)
2885 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/4;
2886 else
2887 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
2888
2889 status = be_cmd_get_cntl_attributes(adapter);
2890 if (status)
2891 return status;
2892
2893 be_cmd_check_native_mode(adapter);
2894 return 0;
2895 }
2896
2897 static int be_dev_family_check(struct be_adapter *adapter)
2898 {
2899 struct pci_dev *pdev = adapter->pdev;
2900 u32 sli_intf = 0, if_type;
2901
2902 switch (pdev->device) {
2903 case BE_DEVICE_ID1:
2904 case OC_DEVICE_ID1:
2905 adapter->generation = BE_GEN2;
2906 break;
2907 case BE_DEVICE_ID2:
2908 case OC_DEVICE_ID2:
2909 adapter->generation = BE_GEN3;
2910 break;
2911 case OC_DEVICE_ID3:
2912 pci_read_config_dword(pdev, SLI_INTF_REG_OFFSET, &sli_intf);
2913 if_type = (sli_intf & SLI_INTF_IF_TYPE_MASK) >>
2914 SLI_INTF_IF_TYPE_SHIFT;
2915
2916 if (((sli_intf & SLI_INTF_VALID_MASK) != SLI_INTF_VALID) ||
2917 if_type != 0x02) {
2918 dev_err(&pdev->dev, "SLI_INTF reg val is not valid\n");
2919 return -EINVAL;
2920 }
2921 if (num_vfs > 0) {
2922 dev_err(&pdev->dev, "VFs not supported\n");
2923 return -EINVAL;
2924 }
2925 adapter->sli_family = ((sli_intf & SLI_INTF_FAMILY_MASK) >>
2926 SLI_INTF_FAMILY_SHIFT);
2927 adapter->generation = BE_GEN3;
2928 break;
2929 default:
2930 adapter->generation = 0;
2931 }
2932 return 0;
2933 }
2934
2935 static int lancer_wait_ready(struct be_adapter *adapter)
2936 {
2937 #define SLIPORT_READY_TIMEOUT 500
2938 u32 sliport_status;
2939 int status = 0, i;
2940
2941 for (i = 0; i < SLIPORT_READY_TIMEOUT; i++) {
2942 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
2943 if (sliport_status & SLIPORT_STATUS_RDY_MASK)
2944 break;
2945
2946 msleep(20);
2947 }
2948
2949 if (i == SLIPORT_READY_TIMEOUT)
2950 status = -1;
2951
2952 return status;
2953 }
2954
2955 static int lancer_test_and_set_rdy_state(struct be_adapter *adapter)
2956 {
2957 int status;
2958 u32 sliport_status, err, reset_needed;
2959 status = lancer_wait_ready(adapter);
2960 if (!status) {
2961 sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);
2962 err = sliport_status & SLIPORT_STATUS_ERR_MASK;
2963 reset_needed = sliport_status & SLIPORT_STATUS_RN_MASK;
2964 if (err && reset_needed) {
2965 iowrite32(SLI_PORT_CONTROL_IP_MASK,
2966 adapter->db + SLIPORT_CONTROL_OFFSET);
2967
2968 /* check adapter has corrected the error */
2969 status = lancer_wait_ready(adapter);
2970 sliport_status = ioread32(adapter->db +
2971 SLIPORT_STATUS_OFFSET);
2972 sliport_status &= (SLIPORT_STATUS_ERR_MASK |
2973 SLIPORT_STATUS_RN_MASK);
2974 if (status || sliport_status)
2975 status = -1;
2976 } else if (err || reset_needed) {
2977 status = -1;
2978 }
2979 }
2980 return status;
2981 }
2982
2983 static int __devinit be_probe(struct pci_dev *pdev,
2984 const struct pci_device_id *pdev_id)
2985 {
2986 int status = 0;
2987 struct be_adapter *adapter;
2988 struct net_device *netdev;
2989
2990 status = pci_enable_device(pdev);
2991 if (status)
2992 goto do_none;
2993
2994 status = pci_request_regions(pdev, DRV_NAME);
2995 if (status)
2996 goto disable_dev;
2997 pci_set_master(pdev);
2998
2999 netdev = alloc_etherdev(sizeof(struct be_adapter));
3000 if (netdev == NULL) {
3001 status = -ENOMEM;
3002 goto rel_reg;
3003 }
3004 adapter = netdev_priv(netdev);
3005 adapter->pdev = pdev;
3006 pci_set_drvdata(pdev, adapter);
3007
3008 status = be_dev_family_check(adapter);
3009 if (status)
3010 goto free_netdev;
3011
3012 adapter->netdev = netdev;
3013 SET_NETDEV_DEV(netdev, &pdev->dev);
3014
3015 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
3016 if (!status) {
3017 netdev->features |= NETIF_F_HIGHDMA;
3018 } else {
3019 status = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
3020 if (status) {
3021 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
3022 goto free_netdev;
3023 }
3024 }
3025
3026 be_sriov_enable(adapter);
3027 if (adapter->sriov_enabled) {
3028 adapter->vf_cfg = kcalloc(num_vfs,
3029 sizeof(struct be_vf_cfg), GFP_KERNEL);
3030
3031 if (!adapter->vf_cfg)
3032 goto free_netdev;
3033 }
3034
3035 status = be_ctrl_init(adapter);
3036 if (status)
3037 goto free_vf_cfg;
3038
3039 if (lancer_chip(adapter)) {
3040 status = lancer_test_and_set_rdy_state(adapter);
3041 if (status) {
3042 dev_err(&pdev->dev, "Adapter in non recoverable error\n");
3043 goto ctrl_clean;
3044 }
3045 }
3046
3047 /* sync up with fw's ready state */
3048 if (be_physfn(adapter)) {
3049 status = be_cmd_POST(adapter);
3050 if (status)
3051 goto ctrl_clean;
3052 }
3053
3054 /* tell fw we're ready to fire cmds */
3055 status = be_cmd_fw_init(adapter);
3056 if (status)
3057 goto ctrl_clean;
3058
3059 status = be_cmd_reset_function(adapter);
3060 if (status)
3061 goto ctrl_clean;
3062
3063 status = be_stats_init(adapter);
3064 if (status)
3065 goto ctrl_clean;
3066
3067 status = be_get_config(adapter);
3068 if (status)
3069 goto stats_clean;
3070
3071 be_msix_enable(adapter);
3072
3073 INIT_DELAYED_WORK(&adapter->work, be_worker);
3074
3075 status = be_setup(adapter);
3076 if (status)
3077 goto msix_disable;
3078
3079 be_netdev_init(netdev);
3080 status = register_netdev(netdev);
3081 if (status != 0)
3082 goto unsetup;
3083 netif_carrier_off(netdev);
3084
3085 if (be_physfn(adapter) && adapter->sriov_enabled) {
3086 u8 mac_speed;
3087 bool link_up;
3088 u16 vf, lnk_speed;
3089
3090 status = be_vf_eth_addr_config(adapter);
3091 if (status)
3092 goto unreg_netdev;
3093
3094 for (vf = 0; vf < num_vfs; vf++) {
3095 status = be_cmd_link_status_query(adapter, &link_up,
3096 &mac_speed, &lnk_speed, vf + 1);
3097 if (!status)
3098 adapter->vf_cfg[vf].vf_tx_rate = lnk_speed * 10;
3099 else
3100 goto unreg_netdev;
3101 }
3102 }
3103
3104 dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
3105 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
3106 return 0;
3107
3108 unreg_netdev:
3109 unregister_netdev(netdev);
3110 unsetup:
3111 be_clear(adapter);
3112 msix_disable:
3113 be_msix_disable(adapter);
3114 stats_clean:
3115 be_stats_cleanup(adapter);
3116 ctrl_clean:
3117 be_ctrl_cleanup(adapter);
3118 free_vf_cfg:
3119 kfree(adapter->vf_cfg);
3120 free_netdev:
3121 be_sriov_disable(adapter);
3122 free_netdev(netdev);
3123 pci_set_drvdata(pdev, NULL);
3124 rel_reg:
3125 pci_release_regions(pdev);
3126 disable_dev:
3127 pci_disable_device(pdev);
3128 do_none:
3129 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
3130 return status;
3131 }
3132
3133 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
3134 {
3135 struct be_adapter *adapter = pci_get_drvdata(pdev);
3136 struct net_device *netdev = adapter->netdev;
3137
3138 cancel_delayed_work_sync(&adapter->work);
3139 if (adapter->wol)
3140 be_setup_wol(adapter, true);
3141
3142 netif_device_detach(netdev);
3143 if (netif_running(netdev)) {
3144 rtnl_lock();
3145 be_close(netdev);
3146 rtnl_unlock();
3147 }
3148 be_cmd_get_flow_control(adapter, &adapter->tx_fc, &adapter->rx_fc);
3149 be_clear(adapter);
3150
3151 be_msix_disable(adapter);
3152 pci_save_state(pdev);
3153 pci_disable_device(pdev);
3154 pci_set_power_state(pdev, pci_choose_state(pdev, state));
3155 return 0;
3156 }
3157
3158 static int be_resume(struct pci_dev *pdev)
3159 {
3160 int status = 0;
3161 struct be_adapter *adapter = pci_get_drvdata(pdev);
3162 struct net_device *netdev = adapter->netdev;
3163
3164 netif_device_detach(netdev);
3165
3166 status = pci_enable_device(pdev);
3167 if (status)
3168 return status;
3169
3170 pci_set_power_state(pdev, 0);
3171 pci_restore_state(pdev);
3172
3173 be_msix_enable(adapter);
3174 /* tell fw we're ready to fire cmds */
3175 status = be_cmd_fw_init(adapter);
3176 if (status)
3177 return status;
3178
3179 be_setup(adapter);
3180 if (netif_running(netdev)) {
3181 rtnl_lock();
3182 be_open(netdev);
3183 rtnl_unlock();
3184 }
3185 netif_device_attach(netdev);
3186
3187 if (adapter->wol)
3188 be_setup_wol(adapter, false);
3189
3190 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
3191 return 0;
3192 }
3193
3194 /*
3195 * An FLR will stop BE from DMAing any data.
3196 */
3197 static void be_shutdown(struct pci_dev *pdev)
3198 {
3199 struct be_adapter *adapter = pci_get_drvdata(pdev);
3200
3201 if (!adapter)
3202 return;
3203
3204 cancel_delayed_work_sync(&adapter->work);
3205
3206 netif_device_detach(adapter->netdev);
3207
3208 if (adapter->wol)
3209 be_setup_wol(adapter, true);
3210
3211 be_cmd_reset_function(adapter);
3212
3213 pci_disable_device(pdev);
3214 }
3215
3216 static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
3217 pci_channel_state_t state)
3218 {
3219 struct be_adapter *adapter = pci_get_drvdata(pdev);
3220 struct net_device *netdev = adapter->netdev;
3221
3222 dev_err(&adapter->pdev->dev, "EEH error detected\n");
3223
3224 adapter->eeh_err = true;
3225
3226 netif_device_detach(netdev);
3227
3228 if (netif_running(netdev)) {
3229 rtnl_lock();
3230 be_close(netdev);
3231 rtnl_unlock();
3232 }
3233 be_clear(adapter);
3234
3235 if (state == pci_channel_io_perm_failure)
3236 return PCI_ERS_RESULT_DISCONNECT;
3237
3238 pci_disable_device(pdev);
3239
3240 return PCI_ERS_RESULT_NEED_RESET;
3241 }
3242
3243 static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
3244 {
3245 struct be_adapter *adapter = pci_get_drvdata(pdev);
3246 int status;
3247
3248 dev_info(&adapter->pdev->dev, "EEH reset\n");
3249 adapter->eeh_err = false;
3250
3251 status = pci_enable_device(pdev);
3252 if (status)
3253 return PCI_ERS_RESULT_DISCONNECT;
3254
3255 pci_set_master(pdev);
3256 pci_set_power_state(pdev, 0);
3257 pci_restore_state(pdev);
3258
3259 /* Check if card is ok and fw is ready */
3260 status = be_cmd_POST(adapter);
3261 if (status)
3262 return PCI_ERS_RESULT_DISCONNECT;
3263
3264 return PCI_ERS_RESULT_RECOVERED;
3265 }
3266
3267 static void be_eeh_resume(struct pci_dev *pdev)
3268 {
3269 int status = 0;
3270 struct be_adapter *adapter = pci_get_drvdata(pdev);
3271 struct net_device *netdev = adapter->netdev;
3272
3273 dev_info(&adapter->pdev->dev, "EEH resume\n");
3274
3275 pci_save_state(pdev);
3276
3277 /* tell fw we're ready to fire cmds */
3278 status = be_cmd_fw_init(adapter);
3279 if (status)
3280 goto err;
3281
3282 status = be_setup(adapter);
3283 if (status)
3284 goto err;
3285
3286 if (netif_running(netdev)) {
3287 status = be_open(netdev);
3288 if (status)
3289 goto err;
3290 }
3291 netif_device_attach(netdev);
3292 return;
3293 err:
3294 dev_err(&adapter->pdev->dev, "EEH resume failed\n");
3295 }
3296
3297 static struct pci_error_handlers be_eeh_handlers = {
3298 .error_detected = be_eeh_err_detected,
3299 .slot_reset = be_eeh_reset,
3300 .resume = be_eeh_resume,
3301 };
3302
3303 static struct pci_driver be_driver = {
3304 .name = DRV_NAME,
3305 .id_table = be_dev_ids,
3306 .probe = be_probe,
3307 .remove = be_remove,
3308 .suspend = be_suspend,
3309 .resume = be_resume,
3310 .shutdown = be_shutdown,
3311 .err_handler = &be_eeh_handlers
3312 };
3313
3314 static int __init be_init_module(void)
3315 {
3316 if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
3317 rx_frag_size != 2048) {
3318 printk(KERN_WARNING DRV_NAME
3319 " : Module param rx_frag_size must be 2048/4096/8192."
3320 " Using 2048\n");
3321 rx_frag_size = 2048;
3322 }
3323
3324 return pci_register_driver(&be_driver);
3325 }
3326 module_init(be_init_module);
3327
3328 static void __exit be_exit_module(void)
3329 {
3330 pci_unregister_driver(&be_driver);
3331 }
3332 module_exit(be_exit_module);
Linux kernel - Deliverables
This page took 0.134106 seconds and 5 git commands to generate.