?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bnx2x: use proper constants for dma_unmap* calls
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / bnx2x / bnx2x_cmn.c
blob7ee9af020ed60f745948ffdff4b7199920161fe1
1 /* bnx2x_cmn.c: Broadcom Everest network driver.
2 *
3 * Copyright (c) 2007-2010 Broadcom Corporation
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation.
8 *
9 * Maintained by: Eilon Greenstein <eilong@broadcom.com>
10 * Written by: Eliezer Tamir
11 * Based on code from Michael Chan's bnx2 driver
12 * UDP CSUM errata workaround by Arik Gendelman
13 * Slowpath and fastpath rework by Vladislav Zolotarov
14 * Statistics and Link management by Yitchak Gertner
15 *
16 */
17
18
19 #include <linux/etherdevice.h>
20 #include <linux/ip.h>
21 #include <net/ipv6.h>
22 #include <net/ip6_checksum.h>
23 #include <linux/firmware.h>
24 #include "bnx2x_cmn.h"
25
26 #ifdef BCM_VLAN
27 #include <linux/if_vlan.h>
28 #endif
29
30 #include "bnx2x_init.h"
31
32 static int bnx2x_poll(struct napi_struct *napi, int budget);
33
34 /* free skb in the packet ring at pos idx
35 * return idx of last bd freed
36 */
37 static u16 bnx2x_free_tx_pkt(struct bnx2x *bp, struct bnx2x_fastpath *fp,
38 u16 idx)
39 {
40 struct sw_tx_bd *tx_buf = &fp->tx_buf_ring[idx];
41 struct eth_tx_start_bd *tx_start_bd;
42 struct eth_tx_bd *tx_data_bd;
43 struct sk_buff *skb = tx_buf->skb;
44 u16 bd_idx = TX_BD(tx_buf->first_bd), new_cons;
45 int nbd;
46
47 /* prefetch skb end pointer to speedup dev_kfree_skb() */
48 prefetch(&skb->end);
49
50 DP(BNX2X_MSG_OFF, "pkt_idx %d buff @(%p)->skb %p\n",
51 idx, tx_buf, skb);
52
53 /* unmap first bd */
54 DP(BNX2X_MSG_OFF, "free bd_idx %d\n", bd_idx);
55 tx_start_bd = &fp->tx_desc_ring[bd_idx].start_bd;
56 dma_unmap_single(&bp->pdev->dev, BD_UNMAP_ADDR(tx_start_bd),
57 BD_UNMAP_LEN(tx_start_bd), DMA_TO_DEVICE);
58
59 nbd = le16_to_cpu(tx_start_bd->nbd) - 1;
60 #ifdef BNX2X_STOP_ON_ERROR
61 if ((nbd - 1) > (MAX_SKB_FRAGS + 2)) {
62 BNX2X_ERR("BAD nbd!\n");
63 bnx2x_panic();
64 }
65 #endif
66 new_cons = nbd + tx_buf->first_bd;
67
68 /* Get the next bd */
69 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
70
71 /* Skip a parse bd... */
72 --nbd;
73 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
74
75 /* ...and the TSO split header bd since they have no mapping */
76 if (tx_buf->flags & BNX2X_TSO_SPLIT_BD) {
77 --nbd;
78 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
79 }
80
81 /* now free frags */
82 while (nbd > 0) {
83
84 DP(BNX2X_MSG_OFF, "free frag bd_idx %d\n", bd_idx);
85 tx_data_bd = &fp->tx_desc_ring[bd_idx].reg_bd;
86 dma_unmap_page(&bp->pdev->dev, BD_UNMAP_ADDR(tx_data_bd),
87 BD_UNMAP_LEN(tx_data_bd), DMA_TO_DEVICE);
88 if (--nbd)
89 bd_idx = TX_BD(NEXT_TX_IDX(bd_idx));
90 }
91
92 /* release skb */
93 WARN_ON(!skb);
94 dev_kfree_skb(skb);
95 tx_buf->first_bd = 0;
96 tx_buf->skb = NULL;
97
98 return new_cons;
99 }
100
101 int bnx2x_tx_int(struct bnx2x_fastpath *fp)
102 {
103 struct bnx2x *bp = fp->bp;
104 struct netdev_queue *txq;
105 u16 hw_cons, sw_cons, bd_cons = fp->tx_bd_cons;
106
107 #ifdef BNX2X_STOP_ON_ERROR
108 if (unlikely(bp->panic))
109 return -1;
110 #endif
111
112 txq = netdev_get_tx_queue(bp->dev, fp->index);
113 hw_cons = le16_to_cpu(*fp->tx_cons_sb);
114 sw_cons = fp->tx_pkt_cons;
115
116 while (sw_cons != hw_cons) {
117 u16 pkt_cons;
118
119 pkt_cons = TX_BD(sw_cons);
120
121 DP(NETIF_MSG_TX_DONE, "queue[%d]: hw_cons %u sw_cons %u "
122 " pkt_cons %u\n",
123 fp->index, hw_cons, sw_cons, pkt_cons);
124
125 bd_cons = bnx2x_free_tx_pkt(bp, fp, pkt_cons);
126 sw_cons++;
127 }
128
129 fp->tx_pkt_cons = sw_cons;
130 fp->tx_bd_cons = bd_cons;
131
132 /* Need to make the tx_bd_cons update visible to start_xmit()
133 * before checking for netif_tx_queue_stopped(). Without the
134 * memory barrier, there is a small possibility that
135 * start_xmit() will miss it and cause the queue to be stopped
136 * forever.
137 */
138 smp_mb();
139
140 /* TBD need a thresh? */
141 if (unlikely(netif_tx_queue_stopped(txq))) {
142 /* Taking tx_lock() is needed to prevent reenabling the queue
143 * while it's empty. This could have happen if rx_action() gets
144 * suspended in bnx2x_tx_int() after the condition before
145 * netif_tx_wake_queue(), while tx_action (bnx2x_start_xmit()):
146 *
147 * stops the queue->sees fresh tx_bd_cons->releases the queue->
148 * sends some packets consuming the whole queue again->
149 * stops the queue
150 */
151
152 __netif_tx_lock(txq, smp_processor_id());
153
154 if ((netif_tx_queue_stopped(txq)) &&
155 (bp->state == BNX2X_STATE_OPEN) &&
156 (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3))
157 netif_tx_wake_queue(txq);
158
159 __netif_tx_unlock(txq);
160 }
161 return 0;
162 }
163
164 static inline void bnx2x_update_last_max_sge(struct bnx2x_fastpath *fp,
165 u16 idx)
166 {
167 u16 last_max = fp->last_max_sge;
168
169 if (SUB_S16(idx, last_max) > 0)
170 fp->last_max_sge = idx;
171 }
172
173 static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
174 struct eth_fast_path_rx_cqe *fp_cqe)
175 {
176 struct bnx2x *bp = fp->bp;
177 u16 sge_len = SGE_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
178 le16_to_cpu(fp_cqe->len_on_bd)) >>
179 SGE_PAGE_SHIFT;
180 u16 last_max, last_elem, first_elem;
181 u16 delta = 0;
182 u16 i;
183
184 if (!sge_len)
185 return;
186
187 /* First mark all used pages */
188 for (i = 0; i < sge_len; i++)
189 SGE_MASK_CLEAR_BIT(fp,
190 RX_SGE(le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[i])));
191
192 DP(NETIF_MSG_RX_STATUS, "fp_cqe->sgl[%d] = %d\n",
193 sge_len - 1, le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[sge_len - 1]));
194
195 /* Here we assume that the last SGE index is the biggest */
196 prefetch((void *)(fp->sge_mask));
197 bnx2x_update_last_max_sge(fp,
198 le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[sge_len - 1]));
199
200 last_max = RX_SGE(fp->last_max_sge);
201 last_elem = last_max >> RX_SGE_MASK_ELEM_SHIFT;
202 first_elem = RX_SGE(fp->rx_sge_prod) >> RX_SGE_MASK_ELEM_SHIFT;
203
204 /* If ring is not full */
205 if (last_elem + 1 != first_elem)
206 last_elem++;
207
208 /* Now update the prod */
209 for (i = first_elem; i != last_elem; i = NEXT_SGE_MASK_ELEM(i)) {
210 if (likely(fp->sge_mask[i]))
211 break;
212
213 fp->sge_mask[i] = RX_SGE_MASK_ELEM_ONE_MASK;
214 delta += RX_SGE_MASK_ELEM_SZ;
215 }
216
217 if (delta > 0) {
218 fp->rx_sge_prod += delta;
219 /* clear page-end entries */
220 bnx2x_clear_sge_mask_next_elems(fp);
221 }
222
223 DP(NETIF_MSG_RX_STATUS,
224 "fp->last_max_sge = %d fp->rx_sge_prod = %d\n",
225 fp->last_max_sge, fp->rx_sge_prod);
226 }
227
228 static void bnx2x_tpa_start(struct bnx2x_fastpath *fp, u16 queue,
229 struct sk_buff *skb, u16 cons, u16 prod)
230 {
231 struct bnx2x *bp = fp->bp;
232 struct sw_rx_bd *cons_rx_buf = &fp->rx_buf_ring[cons];
233 struct sw_rx_bd *prod_rx_buf = &fp->rx_buf_ring[prod];
234 struct eth_rx_bd *prod_bd = &fp->rx_desc_ring[prod];
235 dma_addr_t mapping;
236
237 /* move empty skb from pool to prod and map it */
238 prod_rx_buf->skb = fp->tpa_pool[queue].skb;
239 mapping = dma_map_single(&bp->pdev->dev, fp->tpa_pool[queue].skb->data,
240 bp->rx_buf_size, DMA_FROM_DEVICE);
241 dma_unmap_addr_set(prod_rx_buf, mapping, mapping);
242
243 /* move partial skb from cons to pool (don't unmap yet) */
244 fp->tpa_pool[queue] = *cons_rx_buf;
245
246 /* mark bin state as start - print error if current state != stop */
247 if (fp->tpa_state[queue] != BNX2X_TPA_STOP)
248 BNX2X_ERR("start of bin not in stop [%d]\n", queue);
249
250 fp->tpa_state[queue] = BNX2X_TPA_START;
251
252 /* point prod_bd to new skb */
253 prod_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
254 prod_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
255
256 #ifdef BNX2X_STOP_ON_ERROR
257 fp->tpa_queue_used |= (1 << queue);
258 #ifdef _ASM_GENERIC_INT_L64_H
259 DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%lx\n",
260 #else
261 DP(NETIF_MSG_RX_STATUS, "fp->tpa_queue_used = 0x%llx\n",
262 #endif
263 fp->tpa_queue_used);
264 #endif
265 }
266
267 static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
268 struct sk_buff *skb,
269 struct eth_fast_path_rx_cqe *fp_cqe,
270 u16 cqe_idx)
271 {
272 struct sw_rx_page *rx_pg, old_rx_pg;
273 u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
274 u32 i, frag_len, frag_size, pages;
275 int err;
276 int j;
277
278 frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
279 pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
280
281 /* This is needed in order to enable forwarding support */
282 if (frag_size)
283 skb_shinfo(skb)->gso_size = min((u32)SGE_PAGE_SIZE,
284 max(frag_size, (u32)len_on_bd));
285
286 #ifdef BNX2X_STOP_ON_ERROR
287 if (pages > min_t(u32, 8, MAX_SKB_FRAGS)*SGE_PAGE_SIZE*PAGES_PER_SGE) {
288 BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
289 pages, cqe_idx);
290 BNX2X_ERR("fp_cqe->pkt_len = %d fp_cqe->len_on_bd = %d\n",
291 fp_cqe->pkt_len, len_on_bd);
292 bnx2x_panic();
293 return -EINVAL;
294 }
295 #endif
296
297 /* Run through the SGL and compose the fragmented skb */
298 for (i = 0, j = 0; i < pages; i += PAGES_PER_SGE, j++) {
299 u16 sge_idx =
300 RX_SGE(le16_to_cpu(fp_cqe->sgl_or_raw_data.sgl[j]));
301
302 /* FW gives the indices of the SGE as if the ring is an array
303 (meaning that "next" element will consume 2 indices) */
304 frag_len = min(frag_size, (u32)(SGE_PAGE_SIZE*PAGES_PER_SGE));
305 rx_pg = &fp->rx_page_ring[sge_idx];
306 old_rx_pg = *rx_pg;
307
308 /* If we fail to allocate a substitute page, we simply stop
309 where we are and drop the whole packet */
310 err = bnx2x_alloc_rx_sge(bp, fp, sge_idx);
311 if (unlikely(err)) {
312 fp->eth_q_stats.rx_skb_alloc_failed++;
313 return err;
314 }
315
316 /* Unmap the page as we r going to pass it to the stack */
317 dma_unmap_page(&bp->pdev->dev,
318 dma_unmap_addr(&old_rx_pg, mapping),
319 SGE_PAGE_SIZE*PAGES_PER_SGE, DMA_FROM_DEVICE);
320
321 /* Add one frag and update the appropriate fields in the skb */
322 skb_fill_page_desc(skb, j, old_rx_pg.page, 0, frag_len);
323
324 skb->data_len += frag_len;
325 skb->truesize += frag_len;
326 skb->len += frag_len;
327
328 frag_size -= frag_len;
329 }
330
331 return 0;
332 }
333
334 static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
335 u16 queue, int pad, int len, union eth_rx_cqe *cqe,
336 u16 cqe_idx)
337 {
338 struct sw_rx_bd *rx_buf = &fp->tpa_pool[queue];
339 struct sk_buff *skb = rx_buf->skb;
340 /* alloc new skb */
341 struct sk_buff *new_skb = netdev_alloc_skb(bp->dev, bp->rx_buf_size);
342
343 /* Unmap skb in the pool anyway, as we are going to change
344 pool entry status to BNX2X_TPA_STOP even if new skb allocation
345 fails. */
346 dma_unmap_single(&bp->pdev->dev, dma_unmap_addr(rx_buf, mapping),
347 bp->rx_buf_size, DMA_FROM_DEVICE);
348
349 if (likely(new_skb)) {
350 /* fix ip xsum and give it to the stack */
351 /* (no need to map the new skb) */
352 #ifdef BCM_VLAN
353 int is_vlan_cqe =
354 (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
355 PARSING_FLAGS_VLAN);
356 int is_not_hwaccel_vlan_cqe =
357 (is_vlan_cqe && (!(bp->flags & HW_VLAN_RX_FLAG)));
358 #endif
359
360 prefetch(skb);
361 prefetch(((char *)(skb)) + 128);
362
363 #ifdef BNX2X_STOP_ON_ERROR
364 if (pad + len > bp->rx_buf_size) {
365 BNX2X_ERR("skb_put is about to fail... "
366 "pad %d len %d rx_buf_size %d\n",
367 pad, len, bp->rx_buf_size);
368 bnx2x_panic();
369 return;
370 }
371 #endif
372
373 skb_reserve(skb, pad);
374 skb_put(skb, len);
375
376 skb->protocol = eth_type_trans(skb, bp->dev);
377 skb->ip_summed = CHECKSUM_UNNECESSARY;
378
379 {
380 struct iphdr *iph;
381
382 iph = (struct iphdr *)skb->data;
383 #ifdef BCM_VLAN
384 /* If there is no Rx VLAN offloading -
385 take VLAN tag into an account */
386 if (unlikely(is_not_hwaccel_vlan_cqe))
387 iph = (struct iphdr *)((u8 *)iph + VLAN_HLEN);
388 #endif
389 iph->check = 0;
390 iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
391 }
392
393 if (!bnx2x_fill_frag_skb(bp, fp, skb,
394 &cqe->fast_path_cqe, cqe_idx)) {
395 #ifdef BCM_VLAN
396 if ((bp->vlgrp != NULL) &&
397 (le16_to_cpu(cqe->fast_path_cqe.
398 pars_flags.flags) & PARSING_FLAGS_VLAN))
399 vlan_gro_receive(&fp->napi, bp->vlgrp,
400 le16_to_cpu(cqe->fast_path_cqe.
401 vlan_tag), skb);
402 else
403 #endif
404 napi_gro_receive(&fp->napi, skb);
405 } else {
406 DP(NETIF_MSG_RX_STATUS, "Failed to allocate new pages"
407 " - dropping packet!\n");
408 dev_kfree_skb(skb);
409 }
410
411
412 /* put new skb in bin */
413 fp->tpa_pool[queue].skb = new_skb;
414
415 } else {
416 /* else drop the packet and keep the buffer in the bin */
417 DP(NETIF_MSG_RX_STATUS,
418 "Failed to allocate new skb - dropping packet!\n");
419 fp->eth_q_stats.rx_skb_alloc_failed++;
420 }
421
422 fp->tpa_state[queue] = BNX2X_TPA_STOP;
423 }
424
425 /* Set Toeplitz hash value in the skb using the value from the
426 * CQE (calculated by HW).
427 */
428 static inline void bnx2x_set_skb_rxhash(struct bnx2x *bp, union eth_rx_cqe *cqe,
429 struct sk_buff *skb)
430 {
431 /* Set Toeplitz hash from CQE */
432 if ((bp->dev->features & NETIF_F_RXHASH) &&
433 (cqe->fast_path_cqe.status_flags &
434 ETH_FAST_PATH_RX_CQE_RSS_HASH_FLG))
435 skb->rxhash =
436 le32_to_cpu(cqe->fast_path_cqe.rss_hash_result);
437 }
438
439 int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
440 {
441 struct bnx2x *bp = fp->bp;
442 u16 bd_cons, bd_prod, bd_prod_fw, comp_ring_cons;
443 u16 hw_comp_cons, sw_comp_cons, sw_comp_prod;
444 int rx_pkt = 0;
445
446 #ifdef BNX2X_STOP_ON_ERROR
447 if (unlikely(bp->panic))
448 return 0;
449 #endif
450
451 /* CQ "next element" is of the size of the regular element,
452 that's why it's ok here */
453 hw_comp_cons = le16_to_cpu(*fp->rx_cons_sb);
454 if ((hw_comp_cons & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
455 hw_comp_cons++;
456
457 bd_cons = fp->rx_bd_cons;
458 bd_prod = fp->rx_bd_prod;
459 bd_prod_fw = bd_prod;
460 sw_comp_cons = fp->rx_comp_cons;
461 sw_comp_prod = fp->rx_comp_prod;
462
463 /* Memory barrier necessary as speculative reads of the rx
464 * buffer can be ahead of the index in the status block
465 */
466 rmb();
467
468 DP(NETIF_MSG_RX_STATUS,
469 "queue[%d]: hw_comp_cons %u sw_comp_cons %u\n",
470 fp->index, hw_comp_cons, sw_comp_cons);
471
472 while (sw_comp_cons != hw_comp_cons) {
473 struct sw_rx_bd *rx_buf = NULL;
474 struct sk_buff *skb;
475 union eth_rx_cqe *cqe;
476 u8 cqe_fp_flags;
477 u16 len, pad;
478
479 comp_ring_cons = RCQ_BD(sw_comp_cons);
480 bd_prod = RX_BD(bd_prod);
481 bd_cons = RX_BD(bd_cons);
482
483 /* Prefetch the page containing the BD descriptor
484 at producer's index. It will be needed when new skb is
485 allocated */
486 prefetch((void *)(PAGE_ALIGN((unsigned long)
487 (&fp->rx_desc_ring[bd_prod])) -
488 PAGE_SIZE + 1));
489
490 cqe = &fp->rx_comp_ring[comp_ring_cons];
491 cqe_fp_flags = cqe->fast_path_cqe.type_error_flags;
492
493 DP(NETIF_MSG_RX_STATUS, "CQE type %x err %x status %x"
494 " queue %x vlan %x len %u\n", CQE_TYPE(cqe_fp_flags),
495 cqe_fp_flags, cqe->fast_path_cqe.status_flags,
496 le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
497 le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
498 le16_to_cpu(cqe->fast_path_cqe.pkt_len));
499
500 /* is this a slowpath msg? */
501 if (unlikely(CQE_TYPE(cqe_fp_flags))) {
502 bnx2x_sp_event(fp, cqe);
503 goto next_cqe;
504
505 /* this is an rx packet */
506 } else {
507 rx_buf = &fp->rx_buf_ring[bd_cons];
508 skb = rx_buf->skb;
509 prefetch(skb);
510 len = le16_to_cpu(cqe->fast_path_cqe.pkt_len);
511 pad = cqe->fast_path_cqe.placement_offset;
512
513 /* If CQE is marked both TPA_START and TPA_END
514 it is a non-TPA CQE */
515 if ((!fp->disable_tpa) &&
516 (TPA_TYPE(cqe_fp_flags) !=
517 (TPA_TYPE_START | TPA_TYPE_END))) {
518 u16 queue = cqe->fast_path_cqe.queue_index;
519
520 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_START) {
521 DP(NETIF_MSG_RX_STATUS,
522 "calling tpa_start on queue %d\n",
523 queue);
524
525 bnx2x_tpa_start(fp, queue, skb,
526 bd_cons, bd_prod);
527
528 /* Set Toeplitz hash for an LRO skb */
529 bnx2x_set_skb_rxhash(bp, cqe, skb);
530
531 goto next_rx;
532 }
533
534 if (TPA_TYPE(cqe_fp_flags) == TPA_TYPE_END) {
535 DP(NETIF_MSG_RX_STATUS,
536 "calling tpa_stop on queue %d\n",
537 queue);
538
539 if (!BNX2X_RX_SUM_FIX(cqe))
540 BNX2X_ERR("STOP on none TCP "
541 "data\n");
542
543 /* This is a size of the linear data
544 on this skb */
545 len = le16_to_cpu(cqe->fast_path_cqe.
546 len_on_bd);
547 bnx2x_tpa_stop(bp, fp, queue, pad,
548 len, cqe, comp_ring_cons);
549 #ifdef BNX2X_STOP_ON_ERROR
550 if (bp->panic)
551 return 0;
552 #endif
553
554 bnx2x_update_sge_prod(fp,
555 &cqe->fast_path_cqe);
556 goto next_cqe;
557 }
558 }
559
560 dma_sync_single_for_device(&bp->pdev->dev,
561 dma_unmap_addr(rx_buf, mapping),
562 pad + RX_COPY_THRESH,
563 DMA_FROM_DEVICE);
564 prefetch(((char *)(skb)) + 128);
565
566 /* is this an error packet? */
567 if (unlikely(cqe_fp_flags & ETH_RX_ERROR_FALGS)) {
568 DP(NETIF_MSG_RX_ERR,
569 "ERROR flags %x rx packet %u\n",
570 cqe_fp_flags, sw_comp_cons);
571 fp->eth_q_stats.rx_err_discard_pkt++;
572 goto reuse_rx;
573 }
574
575 /* Since we don't have a jumbo ring
576 * copy small packets if mtu > 1500
577 */
578 if ((bp->dev->mtu > ETH_MAX_PACKET_SIZE) &&
579 (len <= RX_COPY_THRESH)) {
580 struct sk_buff *new_skb;
581
582 new_skb = netdev_alloc_skb(bp->dev,
583 len + pad);
584 if (new_skb == NULL) {
585 DP(NETIF_MSG_RX_ERR,
586 "ERROR packet dropped "
587 "because of alloc failure\n");
588 fp->eth_q_stats.rx_skb_alloc_failed++;
589 goto reuse_rx;
590 }
591
592 /* aligned copy */
593 skb_copy_from_linear_data_offset(skb, pad,
594 new_skb->data + pad, len);
595 skb_reserve(new_skb, pad);
596 skb_put(new_skb, len);
597
598 bnx2x_reuse_rx_skb(fp, bd_cons, bd_prod);
599
600 skb = new_skb;
601
602 } else
603 if (likely(bnx2x_alloc_rx_skb(bp, fp, bd_prod) == 0)) {
604 dma_unmap_single(&bp->pdev->dev,
605 dma_unmap_addr(rx_buf, mapping),
606 bp->rx_buf_size,
607 DMA_FROM_DEVICE);
608 skb_reserve(skb, pad);
609 skb_put(skb, len);
610
611 } else {
612 DP(NETIF_MSG_RX_ERR,
613 "ERROR packet dropped because "
614 "of alloc failure\n");
615 fp->eth_q_stats.rx_skb_alloc_failed++;
616 reuse_rx:
617 bnx2x_reuse_rx_skb(fp, bd_cons, bd_prod);
618 goto next_rx;
619 }
620
621 skb->protocol = eth_type_trans(skb, bp->dev);
622
623 /* Set Toeplitz hash for a none-LRO skb */
624 bnx2x_set_skb_rxhash(bp, cqe, skb);
625
626 skb_checksum_none_assert(skb);
627 if (bp->rx_csum) {
628 if (likely(BNX2X_RX_CSUM_OK(cqe)))
629 skb->ip_summed = CHECKSUM_UNNECESSARY;
630 else
631 fp->eth_q_stats.hw_csum_err++;
632 }
633 }
634
635 skb_record_rx_queue(skb, fp->index);
636
637 #ifdef BCM_VLAN
638 if ((bp->vlgrp != NULL) && (bp->flags & HW_VLAN_RX_FLAG) &&
639 (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
640 PARSING_FLAGS_VLAN))
641 vlan_gro_receive(&fp->napi, bp->vlgrp,
642 le16_to_cpu(cqe->fast_path_cqe.vlan_tag), skb);
643 else
644 #endif
645 napi_gro_receive(&fp->napi, skb);
646
647
648 next_rx:
649 rx_buf->skb = NULL;
650
651 bd_cons = NEXT_RX_IDX(bd_cons);
652 bd_prod = NEXT_RX_IDX(bd_prod);
653 bd_prod_fw = NEXT_RX_IDX(bd_prod_fw);
654 rx_pkt++;
655 next_cqe:
656 sw_comp_prod = NEXT_RCQ_IDX(sw_comp_prod);
657 sw_comp_cons = NEXT_RCQ_IDX(sw_comp_cons);
658
659 if (rx_pkt == budget)
660 break;
661 } /* while */
662
663 fp->rx_bd_cons = bd_cons;
664 fp->rx_bd_prod = bd_prod_fw;
665 fp->rx_comp_cons = sw_comp_cons;
666 fp->rx_comp_prod = sw_comp_prod;
667
668 /* Update producers */
669 bnx2x_update_rx_prod(bp, fp, bd_prod_fw, sw_comp_prod,
670 fp->rx_sge_prod);
671
672 fp->rx_pkt += rx_pkt;
673 fp->rx_calls++;
674
675 return rx_pkt;
676 }
677
678 static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
679 {
680 struct bnx2x_fastpath *fp = fp_cookie;
681 struct bnx2x *bp = fp->bp;
682
683 /* Return here if interrupt is disabled */
684 if (unlikely(atomic_read(&bp->intr_sem) != 0)) {
685 DP(NETIF_MSG_INTR, "called but intr_sem not 0, returning\n");
686 return IRQ_HANDLED;
687 }
688
689 DP(BNX2X_MSG_FP, "got an MSI-X interrupt on IDX:SB "
690 "[fp %d fw_sd %d igusb %d]\n",
691 fp->index, fp->fw_sb_id, fp->igu_sb_id);
692 bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_DISABLE, 0);
693
694 #ifdef BNX2X_STOP_ON_ERROR
695 if (unlikely(bp->panic))
696 return IRQ_HANDLED;
697 #endif
698
699 /* Handle Rx and Tx according to MSI-X vector */
700 prefetch(fp->rx_cons_sb);
701 prefetch(fp->tx_cons_sb);
702 prefetch(&fp->sb_running_index[SM_RX_ID]);
703 napi_schedule(&bnx2x_fp(bp, fp->index, napi));
704
705 return IRQ_HANDLED;
706 }
707
708
709 /* HW Lock for shared dual port PHYs */
710 void bnx2x_acquire_phy_lock(struct bnx2x *bp)
711 {
712 mutex_lock(&bp->port.phy_mutex);
713
714 if (bp->port.need_hw_lock)
715 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
716 }
717
718 void bnx2x_release_phy_lock(struct bnx2x *bp)
719 {
720 if (bp->port.need_hw_lock)
721 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
722
723 mutex_unlock(&bp->port.phy_mutex);
724 }
725
726 void bnx2x_link_report(struct bnx2x *bp)
727 {
728 if (bp->flags & MF_FUNC_DIS) {
729 netif_carrier_off(bp->dev);
730 netdev_err(bp->dev, "NIC Link is Down\n");
731 return;
732 }
733
734 if (bp->link_vars.link_up) {
735 u16 line_speed;
736
737 if (bp->state == BNX2X_STATE_OPEN)
738 netif_carrier_on(bp->dev);
739 netdev_info(bp->dev, "NIC Link is Up, ");
740
741 line_speed = bp->link_vars.line_speed;
742 if (IS_MF(bp)) {
743 u16 vn_max_rate;
744
745 vn_max_rate =
746 ((bp->mf_config[BP_VN(bp)] &
747 FUNC_MF_CFG_MAX_BW_MASK) >>
748 FUNC_MF_CFG_MAX_BW_SHIFT) * 100;
749 if (vn_max_rate < line_speed)
750 line_speed = vn_max_rate;
751 }
752 pr_cont("%d Mbps ", line_speed);
753
754 if (bp->link_vars.duplex == DUPLEX_FULL)
755 pr_cont("full duplex");
756 else
757 pr_cont("half duplex");
758
759 if (bp->link_vars.flow_ctrl != BNX2X_FLOW_CTRL_NONE) {
760 if (bp->link_vars.flow_ctrl & BNX2X_FLOW_CTRL_RX) {
761 pr_cont(", receive ");
762 if (bp->link_vars.flow_ctrl &
763 BNX2X_FLOW_CTRL_TX)
764 pr_cont("& transmit ");
765 } else {
766 pr_cont(", transmit ");
767 }
768 pr_cont("flow control ON");
769 }
770 pr_cont("\n");
771
772 } else { /* link_down */
773 netif_carrier_off(bp->dev);
774 netdev_err(bp->dev, "NIC Link is Down\n");
775 }
776 }
777
778 /* Returns the number of actually allocated BDs */
779 static inline int bnx2x_alloc_rx_bds(struct bnx2x_fastpath *fp,
780 int rx_ring_size)
781 {
782 struct bnx2x *bp = fp->bp;
783 u16 ring_prod, cqe_ring_prod;
784 int i;
785
786 fp->rx_comp_cons = 0;
787 cqe_ring_prod = ring_prod = 0;
788 for (i = 0; i < rx_ring_size; i++) {
789 if (bnx2x_alloc_rx_skb(bp, fp, ring_prod) < 0) {
790 BNX2X_ERR("was only able to allocate "
791 "%d rx skbs on queue[%d]\n", i, fp->index);
792 fp->eth_q_stats.rx_skb_alloc_failed++;
793 break;
794 }
795 ring_prod = NEXT_RX_IDX(ring_prod);
796 cqe_ring_prod = NEXT_RCQ_IDX(cqe_ring_prod);
797 WARN_ON(ring_prod <= i);
798 }
799
800 fp->rx_bd_prod = ring_prod;
801 /* Limit the CQE producer by the CQE ring size */
802 fp->rx_comp_prod = min_t(u16, NUM_RCQ_RINGS*RCQ_DESC_CNT,
803 cqe_ring_prod);
804 fp->rx_pkt = fp->rx_calls = 0;
805
806 return i;
807 }
808
809 static inline void bnx2x_alloc_rx_bd_ring(struct bnx2x_fastpath *fp)
810 {
811 struct bnx2x *bp = fp->bp;
812 int rx_ring_size = bp->rx_ring_size ? bp->rx_ring_size :
813 MAX_RX_AVAIL/bp->num_queues;
814
815 rx_ring_size = max_t(int, MIN_RX_AVAIL, rx_ring_size);
816
817 bnx2x_alloc_rx_bds(fp, rx_ring_size);
818
819 /* Warning!
820 * this will generate an interrupt (to the TSTORM)
821 * must only be done after chip is initialized
822 */
823 bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
824 fp->rx_sge_prod);
825 }
826
827 void bnx2x_init_rx_rings(struct bnx2x *bp)
828 {
829 int func = BP_FUNC(bp);
830 int max_agg_queues = CHIP_IS_E1(bp) ? ETH_MAX_AGGREGATION_QUEUES_E1 :
831 ETH_MAX_AGGREGATION_QUEUES_E1H;
832 u16 ring_prod;
833 int i, j;
834
835 bp->rx_buf_size = bp->dev->mtu + ETH_OVREHEAD + BNX2X_RX_ALIGN +
836 BNX2X_FW_IP_HDR_ALIGN_PAD;
837
838 DP(NETIF_MSG_IFUP,
839 "mtu %d rx_buf_size %d\n", bp->dev->mtu, bp->rx_buf_size);
840
841 for_each_queue(bp, j) {
842 struct bnx2x_fastpath *fp = &bp->fp[j];
843
844 if (!fp->disable_tpa) {
845 for (i = 0; i < max_agg_queues; i++) {
846 fp->tpa_pool[i].skb =
847 netdev_alloc_skb(bp->dev, bp->rx_buf_size);
848 if (!fp->tpa_pool[i].skb) {
849 BNX2X_ERR("Failed to allocate TPA "
850 "skb pool for queue[%d] - "
851 "disabling TPA on this "
852 "queue!\n", j);
853 bnx2x_free_tpa_pool(bp, fp, i);
854 fp->disable_tpa = 1;
855 break;
856 }
857 dma_unmap_addr_set((struct sw_rx_bd *)
858 &bp->fp->tpa_pool[i],
859 mapping, 0);
860 fp->tpa_state[i] = BNX2X_TPA_STOP;
861 }
862
863 /* "next page" elements initialization */
864 bnx2x_set_next_page_sgl(fp);
865
866 /* set SGEs bit mask */
867 bnx2x_init_sge_ring_bit_mask(fp);
868
869 /* Allocate SGEs and initialize the ring elements */
870 for (i = 0, ring_prod = 0;
871 i < MAX_RX_SGE_CNT*NUM_RX_SGE_PAGES; i++) {
872
873 if (bnx2x_alloc_rx_sge(bp, fp, ring_prod) < 0) {
874 BNX2X_ERR("was only able to allocate "
875 "%d rx sges\n", i);
876 BNX2X_ERR("disabling TPA for"
877 " queue[%d]\n", j);
878 /* Cleanup already allocated elements */
879 bnx2x_free_rx_sge_range(bp,
880 fp, ring_prod);
881 bnx2x_free_tpa_pool(bp,
882 fp, max_agg_queues);
883 fp->disable_tpa = 1;
884 ring_prod = 0;
885 break;
886 }
887 ring_prod = NEXT_SGE_IDX(ring_prod);
888 }
889
890 fp->rx_sge_prod = ring_prod;
891 }
892 }
893
894 for_each_queue(bp, j) {
895 struct bnx2x_fastpath *fp = &bp->fp[j];
896
897 fp->rx_bd_cons = 0;
898
899 bnx2x_set_next_page_rx_bd(fp);
900
901 /* CQ ring */
902 bnx2x_set_next_page_rx_cq(fp);
903
904 /* Allocate BDs and initialize BD ring */
905 bnx2x_alloc_rx_bd_ring(fp);
906
907 if (j != 0)
908 continue;
909
910 if (!CHIP_IS_E2(bp)) {
911 REG_WR(bp, BAR_USTRORM_INTMEM +
912 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func),
913 U64_LO(fp->rx_comp_mapping));
914 REG_WR(bp, BAR_USTRORM_INTMEM +
915 USTORM_MEM_WORKAROUND_ADDRESS_OFFSET(func) + 4,
916 U64_HI(fp->rx_comp_mapping));
917 }
918 }
919 }
920 static void bnx2x_free_tx_skbs(struct bnx2x *bp)
921 {
922 int i;
923
924 for_each_queue(bp, i) {
925 struct bnx2x_fastpath *fp = &bp->fp[i];
926
927 u16 bd_cons = fp->tx_bd_cons;
928 u16 sw_prod = fp->tx_pkt_prod;
929 u16 sw_cons = fp->tx_pkt_cons;
930
931 while (sw_cons != sw_prod) {
932 bd_cons = bnx2x_free_tx_pkt(bp, fp, TX_BD(sw_cons));
933 sw_cons++;
934 }
935 }
936 }
937
938 static void bnx2x_free_rx_skbs(struct bnx2x *bp)
939 {
940 int i, j;
941
942 for_each_queue(bp, j) {
943 struct bnx2x_fastpath *fp = &bp->fp[j];
944
945 for (i = 0; i < NUM_RX_BD; i++) {
946 struct sw_rx_bd *rx_buf = &fp->rx_buf_ring[i];
947 struct sk_buff *skb = rx_buf->skb;
948
949 if (skb == NULL)
950 continue;
951
952 dma_unmap_single(&bp->pdev->dev,
953 dma_unmap_addr(rx_buf, mapping),
954 bp->rx_buf_size, DMA_FROM_DEVICE);
955
956 rx_buf->skb = NULL;
957 dev_kfree_skb(skb);
958 }
959 if (!fp->disable_tpa)
960 bnx2x_free_tpa_pool(bp, fp, CHIP_IS_E1(bp) ?
961 ETH_MAX_AGGREGATION_QUEUES_E1 :
962 ETH_MAX_AGGREGATION_QUEUES_E1H);
963 }
964 }
965
966 void bnx2x_free_skbs(struct bnx2x *bp)
967 {
968 bnx2x_free_tx_skbs(bp);
969 bnx2x_free_rx_skbs(bp);
970 }
971
972 static void bnx2x_free_msix_irqs(struct bnx2x *bp)
973 {
974 int i, offset = 1;
975
976 free_irq(bp->msix_table[0].vector, bp->dev);
977 DP(NETIF_MSG_IFDOWN, "released sp irq (%d)\n",
978 bp->msix_table[0].vector);
979
980 #ifdef BCM_CNIC
981 offset++;
982 #endif
983 for_each_queue(bp, i) {
984 DP(NETIF_MSG_IFDOWN, "about to release fp #%d->%d irq "
985 "state %x\n", i, bp->msix_table[i + offset].vector,
986 bnx2x_fp(bp, i, state));
987
988 free_irq(bp->msix_table[i + offset].vector, &bp->fp[i]);
989 }
990 }
991
992 void bnx2x_free_irq(struct bnx2x *bp, bool disable_only)
993 {
994 if (bp->flags & USING_MSIX_FLAG) {
995 if (!disable_only)
996 bnx2x_free_msix_irqs(bp);
997 pci_disable_msix(bp->pdev);
998 bp->flags &= ~USING_MSIX_FLAG;
999
1000 } else if (bp->flags & USING_MSI_FLAG) {
1001 if (!disable_only)
1002 free_irq(bp->pdev->irq, bp->dev);
1003 pci_disable_msi(bp->pdev);
1004 bp->flags &= ~USING_MSI_FLAG;
1005
1006 } else if (!disable_only)
1007 free_irq(bp->pdev->irq, bp->dev);
1008 }
1009
1010 static int bnx2x_enable_msix(struct bnx2x *bp)
1011 {
1012 int i, rc, offset = 1;
1013 int igu_vec = 0;
1014
1015 bp->msix_table[0].entry = igu_vec;
1016 DP(NETIF_MSG_IFUP, "msix_table[0].entry = %d (slowpath)\n", igu_vec);
1017
1018 #ifdef BCM_CNIC
1019 igu_vec = BP_L_ID(bp) + offset;
1020 bp->msix_table[1].entry = igu_vec;
1021 DP(NETIF_MSG_IFUP, "msix_table[1].entry = %d (CNIC)\n", igu_vec);
1022 offset++;
1023 #endif
1024 for_each_queue(bp, i) {
1025 igu_vec = BP_L_ID(bp) + offset + i;
1026 bp->msix_table[i + offset].entry = igu_vec;
1027 DP(NETIF_MSG_IFUP, "msix_table[%d].entry = %d "
1028 "(fastpath #%u)\n", i + offset, igu_vec, i);
1029 }
1030
1031 rc = pci_enable_msix(bp->pdev, &bp->msix_table[0],
1032 BNX2X_NUM_QUEUES(bp) + offset);
1033
1034 /*
1035 * reconfigure number of tx/rx queues according to available
1036 * MSI-X vectors
1037 */
1038 if (rc >= BNX2X_MIN_MSIX_VEC_CNT) {
1039 /* vectors available for FP */
1040 int fp_vec = rc - BNX2X_MSIX_VEC_FP_START;
1041
1042 DP(NETIF_MSG_IFUP,
1043 "Trying to use less MSI-X vectors: %d\n", rc);
1044
1045 rc = pci_enable_msix(bp->pdev, &bp->msix_table[0], rc);
1046
1047 if (rc) {
1048 DP(NETIF_MSG_IFUP,
1049 "MSI-X is not attainable rc %d\n", rc);
1050 return rc;
1051 }
1052
1053 bp->num_queues = min(bp->num_queues, fp_vec);
1054
1055 DP(NETIF_MSG_IFUP, "New queue configuration set: %d\n",
1056 bp->num_queues);
1057 } else if (rc) {
1058 DP(NETIF_MSG_IFUP, "MSI-X is not attainable rc %d\n", rc);
1059 return rc;
1060 }
1061
1062 bp->flags |= USING_MSIX_FLAG;
1063
1064 return 0;
1065 }
1066
1067 static int bnx2x_req_msix_irqs(struct bnx2x *bp)
1068 {
1069 int i, rc, offset = 1;
1070
1071 rc = request_irq(bp->msix_table[0].vector, bnx2x_msix_sp_int, 0,
1072 bp->dev->name, bp->dev);
1073 if (rc) {
1074 BNX2X_ERR("request sp irq failed\n");
1075 return -EBUSY;
1076 }
1077
1078 #ifdef BCM_CNIC
1079 offset++;
1080 #endif
1081 for_each_queue(bp, i) {
1082 struct bnx2x_fastpath *fp = &bp->fp[i];
1083 snprintf(fp->name, sizeof(fp->name), "%s-fp-%d",
1084 bp->dev->name, i);
1085
1086 rc = request_irq(bp->msix_table[i + offset].vector,
1087 bnx2x_msix_fp_int, 0, fp->name, fp);
1088 if (rc) {
1089 BNX2X_ERR("request fp #%d irq failed rc %d\n", i, rc);
1090 bnx2x_free_msix_irqs(bp);
1091 return -EBUSY;
1092 }
1093
1094 fp->state = BNX2X_FP_STATE_IRQ;
1095 }
1096
1097 i = BNX2X_NUM_QUEUES(bp);
1098 netdev_info(bp->dev, "using MSI-X IRQs: sp %d fp[%d] %d"
1099 " ... fp[%d] %d\n",
1100 bp->msix_table[0].vector,
1101 0, bp->msix_table[offset].vector,
1102 i - 1, bp->msix_table[offset + i - 1].vector);
1103
1104 return 0;
1105 }
1106
1107 static int bnx2x_enable_msi(struct bnx2x *bp)
1108 {
1109 int rc;
1110
1111 rc = pci_enable_msi(bp->pdev);
1112 if (rc) {
1113 DP(NETIF_MSG_IFUP, "MSI is not attainable\n");
1114 return -1;
1115 }
1116 bp->flags |= USING_MSI_FLAG;
1117
1118 return 0;
1119 }
1120
1121 static int bnx2x_req_irq(struct bnx2x *bp)
1122 {
1123 unsigned long flags;
1124 int rc;
1125
1126 if (bp->flags & USING_MSI_FLAG)
1127 flags = 0;
1128 else
1129 flags = IRQF_SHARED;
1130
1131 rc = request_irq(bp->pdev->irq, bnx2x_interrupt, flags,
1132 bp->dev->name, bp->dev);
1133 if (!rc)
1134 bnx2x_fp(bp, 0, state) = BNX2X_FP_STATE_IRQ;
1135
1136 return rc;
1137 }
1138
1139 static void bnx2x_napi_enable(struct bnx2x *bp)
1140 {
1141 int i;
1142
1143 for_each_queue(bp, i)
1144 napi_enable(&bnx2x_fp(bp, i, napi));
1145 }
1146
1147 static void bnx2x_napi_disable(struct bnx2x *bp)
1148 {
1149 int i;
1150
1151 for_each_queue(bp, i)
1152 napi_disable(&bnx2x_fp(bp, i, napi));
1153 }
1154
1155 void bnx2x_netif_start(struct bnx2x *bp)
1156 {
1157 int intr_sem;
1158
1159 intr_sem = atomic_dec_and_test(&bp->intr_sem);
1160 smp_wmb(); /* Ensure that bp->intr_sem update is SMP-safe */
1161
1162 if (intr_sem) {
1163 if (netif_running(bp->dev)) {
1164 bnx2x_napi_enable(bp);
1165 bnx2x_int_enable(bp);
1166 if (bp->state == BNX2X_STATE_OPEN)
1167 netif_tx_wake_all_queues(bp->dev);
1168 }
1169 }
1170 }
1171
1172 void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
1173 {
1174 bnx2x_int_disable_sync(bp, disable_hw);
1175 bnx2x_napi_disable(bp);
1176 netif_tx_disable(bp->dev);
1177 }
1178 static int bnx2x_set_num_queues(struct bnx2x *bp)
1179 {
1180 int rc = 0;
1181
1182 switch (bp->int_mode) {
1183 case INT_MODE_MSI:
1184 bnx2x_enable_msi(bp);
1185 /* falling through... */
1186 case INT_MODE_INTx:
1187 bp->num_queues = 1;
1188 DP(NETIF_MSG_IFUP, "set number of queues to 1\n");
1189 break;
1190 default:
1191 /* Set number of queues according to bp->multi_mode value */
1192 bnx2x_set_num_queues_msix(bp);
1193
1194 DP(NETIF_MSG_IFUP, "set number of queues to %d\n",
1195 bp->num_queues);
1196
1197 /* if we can't use MSI-X we only need one fp,
1198 * so try to enable MSI-X with the requested number of fp's
1199 * and fallback to MSI or legacy INTx with one fp
1200 */
1201 rc = bnx2x_enable_msix(bp);
1202 if (rc) {
1203 /* failed to enable MSI-X */
1204 bp->num_queues = 1;
1205
1206 /* Fall to INTx if failed to enable MSI-X due to lack of
1207 * memory (in bnx2x_set_num_queues()) */
1208 if ((rc != -ENOMEM) && (bp->int_mode != INT_MODE_INTx))
1209 bnx2x_enable_msi(bp);
1210 }
1211
1212 break;
1213 }
1214 netif_set_real_num_tx_queues(bp->dev, bp->num_queues);
1215 return netif_set_real_num_rx_queues(bp->dev, bp->num_queues);
1216 }
1217
1218 static void bnx2x_release_firmware(struct bnx2x *bp)
1219 {
1220 kfree(bp->init_ops_offsets);
1221 kfree(bp->init_ops);
1222 kfree(bp->init_data);
1223 release_firmware(bp->firmware);
1224 }
1225
1226 /* must be called with rtnl_lock */
1227 int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
1228 {
1229 u32 load_code;
1230 int i, rc;
1231
1232 /* Set init arrays */
1233 rc = bnx2x_init_firmware(bp);
1234 if (rc) {
1235 BNX2X_ERR("Error loading firmware\n");
1236 return rc;
1237 }
1238
1239 #ifdef BNX2X_STOP_ON_ERROR
1240 if (unlikely(bp->panic))
1241 return -EPERM;
1242 #endif
1243
1244 bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
1245
1246 rc = bnx2x_set_num_queues(bp);
1247 if (rc)
1248 return rc;
1249
1250 /* must be called before memory allocation and HW init */
1251 bnx2x_ilt_set_info(bp);
1252
1253 if (bnx2x_alloc_mem(bp)) {
1254 bnx2x_free_irq(bp, true);
1255 return -ENOMEM;
1256 }
1257
1258 for_each_queue(bp, i)
1259 bnx2x_fp(bp, i, disable_tpa) =
1260 ((bp->flags & TPA_ENABLE_FLAG) == 0);
1261
1262 for_each_queue(bp, i)
1263 netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
1264 bnx2x_poll, 128);
1265
1266 bnx2x_napi_enable(bp);
1267
1268 if (bp->flags & USING_MSIX_FLAG) {
1269 rc = bnx2x_req_msix_irqs(bp);
1270 if (rc) {
1271 bnx2x_free_irq(bp, true);
1272 goto load_error1;
1273 }
1274 } else {
1275 bnx2x_ack_int(bp);
1276 rc = bnx2x_req_irq(bp);
1277 if (rc) {
1278 BNX2X_ERR("IRQ request failed rc %d, aborting\n", rc);
1279 bnx2x_free_irq(bp, true);
1280 goto load_error1;
1281 }
1282 if (bp->flags & USING_MSI_FLAG) {
1283 bp->dev->irq = bp->pdev->irq;
1284 netdev_info(bp->dev, "using MSI IRQ %d\n",
1285 bp->pdev->irq);
1286 }
1287 }
1288
1289 /* Send LOAD_REQUEST command to MCP
1290 Returns the type of LOAD command:
1291 if it is the first port to be initialized
1292 common blocks should be initialized, otherwise - not
1293 */
1294 if (!BP_NOMCP(bp)) {
1295 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ, 0);
1296 if (!load_code) {
1297 BNX2X_ERR("MCP response failure, aborting\n");
1298 rc = -EBUSY;
1299 goto load_error2;
1300 }
1301 if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
1302 rc = -EBUSY; /* other port in diagnostic mode */
1303 goto load_error2;
1304 }
1305
1306 } else {
1307 int path = BP_PATH(bp);
1308 int port = BP_PORT(bp);
1309
1310 DP(NETIF_MSG_IFUP, "NO MCP - load counts[%d] %d, %d, %d\n",
1311 path, load_count[path][0], load_count[path][1],
1312 load_count[path][2]);
1313 load_count[path][0]++;
1314 load_count[path][1 + port]++;
1315 DP(NETIF_MSG_IFUP, "NO MCP - new load counts[%d] %d, %d, %d\n",
1316 path, load_count[path][0], load_count[path][1],
1317 load_count[path][2]);
1318 if (load_count[path][0] == 1)
1319 load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
1320 else if (load_count[path][1 + port] == 1)
1321 load_code = FW_MSG_CODE_DRV_LOAD_PORT;
1322 else
1323 load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
1324 }
1325
1326 if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
1327 (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
1328 (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
1329 bp->port.pmf = 1;
1330 else
1331 bp->port.pmf = 0;
1332 DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
1333
1334 /* Initialize HW */
1335 rc = bnx2x_init_hw(bp, load_code);
1336 if (rc) {
1337 BNX2X_ERR("HW init failed, aborting\n");
1338 bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE, 0);
1339 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP, 0);
1340 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
1341 goto load_error2;
1342 }
1343
1344 if (rc) {
1345 bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE, 0);
1346 goto load_error2;
1347 }
1348
1349 /* Setup NIC internals and enable interrupts */
1350 bnx2x_nic_init(bp, load_code);
1351
1352 if (((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
1353 (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP)) &&
1354 (bp->common.shmem2_base))
1355 SHMEM2_WR(bp, dcc_support,
1356 (SHMEM_DCC_SUPPORT_DISABLE_ENABLE_PF_TLV |
1357 SHMEM_DCC_SUPPORT_BANDWIDTH_ALLOCATION_TLV));
1358
1359 /* Send LOAD_DONE command to MCP */
1360 if (!BP_NOMCP(bp)) {
1361 load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_DONE, 0);
1362 if (!load_code) {
1363 BNX2X_ERR("MCP response failure, aborting\n");
1364 rc = -EBUSY;
1365 goto load_error3;
1366 }
1367 }
1368
1369 bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
1370
1371 rc = bnx2x_func_start(bp);
1372 if (rc) {
1373 BNX2X_ERR("Function start failed!\n");
1374 #ifndef BNX2X_STOP_ON_ERROR
1375 goto load_error3;
1376 #else
1377 bp->panic = 1;
1378 return -EBUSY;
1379 #endif
1380 }
1381
1382 rc = bnx2x_setup_client(bp, &bp->fp[0], 1 /* Leading */);
1383 if (rc) {
1384 BNX2X_ERR("Setup leading failed!\n");
1385 #ifndef BNX2X_STOP_ON_ERROR
1386 goto load_error3;
1387 #else
1388 bp->panic = 1;
1389 return -EBUSY;
1390 #endif
1391 }
1392
1393 if (!CHIP_IS_E1(bp) &&
1394 (bp->mf_config[BP_VN(bp)] & FUNC_MF_CFG_FUNC_DISABLED)) {
1395 DP(NETIF_MSG_IFUP, "mf_cfg function disabled\n");
1396 bp->flags |= MF_FUNC_DIS;
1397 }
1398
1399 #ifdef BCM_CNIC
1400 /* Enable Timer scan */
1401 REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + BP_PORT(bp)*4, 1);
1402 #endif
1403 for_each_nondefault_queue(bp, i) {
1404 rc = bnx2x_setup_client(bp, &bp->fp[i], 0);
1405 if (rc)
1406 #ifdef BCM_CNIC
1407 goto load_error4;
1408 #else
1409 goto load_error3;
1410 #endif
1411 }
1412
1413 /* Now when Clients are configured we are ready to work */
1414 bp->state = BNX2X_STATE_OPEN;
1415
1416 bnx2x_set_eth_mac(bp, 1);
1417
1418 #ifdef BCM_CNIC
1419 /* Set iSCSI L2 MAC */
1420 mutex_lock(&bp->cnic_mutex);
1421 if (bp->cnic_eth_dev.drv_state & CNIC_DRV_STATE_REGD) {
1422 bnx2x_set_iscsi_eth_mac_addr(bp, 1);
1423 bp->cnic_flags |= BNX2X_CNIC_FLAG_MAC_SET;
1424 bnx2x_init_sb(bp, bp->cnic_sb_mapping,
1425 BNX2X_VF_ID_INVALID, false,
1426 CNIC_SB_ID(bp), CNIC_IGU_SB_ID(bp));
1427 }
1428 mutex_unlock(&bp->cnic_mutex);
1429 #endif
1430
1431 if (bp->port.pmf)
1432 bnx2x_initial_phy_init(bp, load_mode);
1433
1434 /* Start fast path */
1435 switch (load_mode) {
1436 case LOAD_NORMAL:
1437 /* Tx queue should be only reenabled */
1438 netif_tx_wake_all_queues(bp->dev);
1439 /* Initialize the receive filter. */
1440 bnx2x_set_rx_mode(bp->dev);
1441 break;
1442
1443 case LOAD_OPEN:
1444 netif_tx_start_all_queues(bp->dev);
1445 smp_mb__after_clear_bit();
1446 /* Initialize the receive filter. */
1447 bnx2x_set_rx_mode(bp->dev);
1448 break;
1449
1450 case LOAD_DIAG:
1451 /* Initialize the receive filter. */
1452 bnx2x_set_rx_mode(bp->dev);
1453 bp->state = BNX2X_STATE_DIAG;
1454 break;
1455
1456 default:
1457 break;
1458 }
1459
1460 if (!bp->port.pmf)
1461 bnx2x__link_status_update(bp);
1462
1463 /* start the timer */
1464 mod_timer(&bp->timer, jiffies + bp->current_interval);
1465
1466 #ifdef BCM_CNIC
1467 bnx2x_setup_cnic_irq_info(bp);
1468 if (bp->state == BNX2X_STATE_OPEN)
1469 bnx2x_cnic_notify(bp, CNIC_CTL_START_CMD);
1470 #endif
1471 bnx2x_inc_load_cnt(bp);
1472
1473 bnx2x_release_firmware(bp);
1474
1475 return 0;
1476
1477 #ifdef BCM_CNIC
1478 load_error4:
1479 /* Disable Timer scan */
1480 REG_WR(bp, TM_REG_EN_LINEAR0_TIMER + BP_PORT(bp)*4, 0);
1481 #endif
1482 load_error3:
1483 bnx2x_int_disable_sync(bp, 1);
1484 if (!BP_NOMCP(bp)) {
1485 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP, 0);
1486 bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE, 0);
1487 }
1488 bp->port.pmf = 0;
1489 /* Free SKBs, SGEs, TPA pool and driver internals */
1490 bnx2x_free_skbs(bp);
1491 for_each_queue(bp, i)
1492 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
1493 load_error2:
1494 /* Release IRQs */
1495 bnx2x_free_irq(bp, false);
1496 load_error1:
1497 bnx2x_napi_disable(bp);
1498 for_each_queue(bp, i)
1499 netif_napi_del(&bnx2x_fp(bp, i, napi));
1500 bnx2x_free_mem(bp);
1501
1502 bnx2x_release_firmware(bp);
1503
1504 return rc;
1505 }
1506
1507 /* must be called with rtnl_lock */
1508 int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
1509 {
1510 int i;
1511
1512 if (bp->state == BNX2X_STATE_CLOSED) {
1513 /* Interface has been removed - nothing to recover */
1514 bp->recovery_state = BNX2X_RECOVERY_DONE;
1515 bp->is_leader = 0;
1516 bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_RESERVED_08);
1517 smp_wmb();
1518
1519 return -EINVAL;
1520 }
1521
1522 #ifdef BCM_CNIC
1523 bnx2x_cnic_notify(bp, CNIC_CTL_STOP_CMD);
1524 #endif
1525 bp->state = BNX2X_STATE_CLOSING_WAIT4_HALT;
1526
1527 /* Set "drop all" */
1528 bp->rx_mode = BNX2X_RX_MODE_NONE;
1529 bnx2x_set_storm_rx_mode(bp);
1530
1531 /* Stop Tx */
1532 bnx2x_tx_disable(bp);
1533 del_timer_sync(&bp->timer);
1534 SHMEM_WR(bp, func_mb[BP_FW_MB_IDX(bp)].drv_pulse_mb,
1535 (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
1536 bnx2x_stats_handle(bp, STATS_EVENT_STOP);
1537
1538
1539 /* Cleanup the chip if needed */
1540 if (unload_mode != UNLOAD_RECOVERY)
1541 bnx2x_chip_cleanup(bp, unload_mode);
1542 else {
1543 /* Disable HW interrupts, NAPI and Tx */
1544 bnx2x_netif_stop(bp, 1);
1545
1546 /* Release IRQs */
1547 bnx2x_free_irq(bp, false);
1548 }
1549
1550 bp->port.pmf = 0;
1551
1552 /* Free SKBs, SGEs, TPA pool and driver internals */
1553 bnx2x_free_skbs(bp);
1554 for_each_queue(bp, i)
1555 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
1556 for_each_queue(bp, i)
1557 netif_napi_del(&bnx2x_fp(bp, i, napi));
1558 bnx2x_free_mem(bp);
1559
1560 bp->state = BNX2X_STATE_CLOSED;
1561
1562 /* The last driver must disable a "close the gate" if there is no
1563 * parity attention or "process kill" pending.
1564 */
1565 if ((!bnx2x_dec_load_cnt(bp)) && (!bnx2x_chk_parity_attn(bp)) &&
1566 bnx2x_reset_is_done(bp))
1567 bnx2x_disable_close_the_gate(bp);
1568
1569 /* Reset MCP mail box sequence if there is on going recovery */
1570 if (unload_mode == UNLOAD_RECOVERY)
1571 bp->fw_seq = 0;
1572
1573 return 0;
1574 }
1575 int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
1576 {
1577 u16 pmcsr;
1578
1579 pci_read_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL, &pmcsr);
1580
1581 switch (state) {
1582 case PCI_D0:
1583 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
1584 ((pmcsr & ~PCI_PM_CTRL_STATE_MASK) |
1585 PCI_PM_CTRL_PME_STATUS));
1586
1587 if (pmcsr & PCI_PM_CTRL_STATE_MASK)
1588 /* delay required during transition out of D3hot */
1589 msleep(20);
1590 break;
1591
1592 case PCI_D3hot:
1593 /* If there are other clients above don't
1594 shut down the power */
1595 if (atomic_read(&bp->pdev->enable_cnt) != 1)
1596 return 0;
1597 /* Don't shut down the power for emulation and FPGA */
1598 if (CHIP_REV_IS_SLOW(bp))
1599 return 0;
1600
1601 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
1602 pmcsr |= 3;
1603
1604 if (bp->wol)
1605 pmcsr |= PCI_PM_CTRL_PME_ENABLE;
1606
1607 pci_write_config_word(bp->pdev, bp->pm_cap + PCI_PM_CTRL,
1608 pmcsr);
1609
1610 /* No more memory access after this point until
1611 * device is brought back to D0.
1612 */
1613 break;
1614
1615 default:
1616 return -EINVAL;
1617 }
1618 return 0;
1619 }
1620
1621
1622
1623 /*
1624 * net_device service functions
1625 */
1626
1627 static int bnx2x_poll(struct napi_struct *napi, int budget)
1628 {
1629 int work_done = 0;
1630 struct bnx2x_fastpath *fp = container_of(napi, struct bnx2x_fastpath,
1631 napi);
1632 struct bnx2x *bp = fp->bp;
1633
1634 while (1) {
1635 #ifdef BNX2X_STOP_ON_ERROR
1636 if (unlikely(bp->panic)) {
1637 napi_complete(napi);
1638 return 0;
1639 }
1640 #endif
1641
1642 if (bnx2x_has_tx_work(fp))
1643 bnx2x_tx_int(fp);
1644
1645 if (bnx2x_has_rx_work(fp)) {
1646 work_done += bnx2x_rx_int(fp, budget - work_done);
1647
1648 /* must not complete if we consumed full budget */
1649 if (work_done >= budget)
1650 break;
1651 }
1652
1653 /* Fall out from the NAPI loop if needed */
1654 if (!(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
1655 bnx2x_update_fpsb_idx(fp);
1656 /* bnx2x_has_rx_work() reads the status block,
1657 * thus we need to ensure that status block indices
1658 * have been actually read (bnx2x_update_fpsb_idx)
1659 * prior to this check (bnx2x_has_rx_work) so that
1660 * we won't write the "newer" value of the status block
1661 * to IGU (if there was a DMA right after
1662 * bnx2x_has_rx_work and if there is no rmb, the memory
1663 * reading (bnx2x_update_fpsb_idx) may be postponed
1664 * to right before bnx2x_ack_sb). In this case there
1665 * will never be another interrupt until there is
1666 * another update of the status block, while there
1667 * is still unhandled work.
1668 */
1669 rmb();
1670
1671 if (!(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) {
1672 napi_complete(napi);
1673 /* Re-enable interrupts */
1674 DP(NETIF_MSG_HW,
1675 "Update index to %d\n", fp->fp_hc_idx);
1676 bnx2x_ack_sb(bp, fp->igu_sb_id, USTORM_ID,
1677 le16_to_cpu(fp->fp_hc_idx),
1678 IGU_INT_ENABLE, 1);
1679 break;
1680 }
1681 }
1682 }
1683
1684 return work_done;
1685 }
1686
1687
1688 /* we split the first BD into headers and data BDs
1689 * to ease the pain of our fellow microcode engineers
1690 * we use one mapping for both BDs
1691 * So far this has only been observed to happen
1692 * in Other Operating Systems(TM)
1693 */
1694 static noinline u16 bnx2x_tx_split(struct bnx2x *bp,
1695 struct bnx2x_fastpath *fp,
1696 struct sw_tx_bd *tx_buf,
1697 struct eth_tx_start_bd **tx_bd, u16 hlen,
1698 u16 bd_prod, int nbd)
1699 {
1700 struct eth_tx_start_bd *h_tx_bd = *tx_bd;
1701 struct eth_tx_bd *d_tx_bd;
1702 dma_addr_t mapping;
1703 int old_len = le16_to_cpu(h_tx_bd->nbytes);
1704
1705 /* first fix first BD */
1706 h_tx_bd->nbd = cpu_to_le16(nbd);
1707 h_tx_bd->nbytes = cpu_to_le16(hlen);
1708
1709 DP(NETIF_MSG_TX_QUEUED, "TSO split header size is %d "
1710 "(%x:%x) nbd %d\n", h_tx_bd->nbytes, h_tx_bd->addr_hi,
1711 h_tx_bd->addr_lo, h_tx_bd->nbd);
1712
1713 /* now get a new data BD
1714 * (after the pbd) and fill it */
1715 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
1716 d_tx_bd = &fp->tx_desc_ring[bd_prod].reg_bd;
1717
1718 mapping = HILO_U64(le32_to_cpu(h_tx_bd->addr_hi),
1719 le32_to_cpu(h_tx_bd->addr_lo)) + hlen;
1720
1721 d_tx_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
1722 d_tx_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
1723 d_tx_bd->nbytes = cpu_to_le16(old_len - hlen);
1724
1725 /* this marks the BD as one that has no individual mapping */
1726 tx_buf->flags |= BNX2X_TSO_SPLIT_BD;
1727
1728 DP(NETIF_MSG_TX_QUEUED,
1729 "TSO split data size is %d (%x:%x)\n",
1730 d_tx_bd->nbytes, d_tx_bd->addr_hi, d_tx_bd->addr_lo);
1731
1732 /* update tx_bd */
1733 *tx_bd = (struct eth_tx_start_bd *)d_tx_bd;
1734
1735 return bd_prod;
1736 }
1737
1738 static inline u16 bnx2x_csum_fix(unsigned char *t_header, u16 csum, s8 fix)
1739 {
1740 if (fix > 0)
1741 csum = (u16) ~csum_fold(csum_sub(csum,
1742 csum_partial(t_header - fix, fix, 0)));
1743
1744 else if (fix < 0)
1745 csum = (u16) ~csum_fold(csum_add(csum,
1746 csum_partial(t_header, -fix, 0)));
1747
1748 return swab16(csum);
1749 }
1750
1751 static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
1752 {
1753 u32 rc;
1754
1755 if (skb->ip_summed != CHECKSUM_PARTIAL)
1756 rc = XMIT_PLAIN;
1757
1758 else {
1759 if (skb->protocol == htons(ETH_P_IPV6)) {
1760 rc = XMIT_CSUM_V6;
1761 if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
1762 rc |= XMIT_CSUM_TCP;
1763
1764 } else {
1765 rc = XMIT_CSUM_V4;
1766 if (ip_hdr(skb)->protocol == IPPROTO_TCP)
1767 rc |= XMIT_CSUM_TCP;
1768 }
1769 }
1770
1771 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4)
1772 rc |= (XMIT_GSO_V4 | XMIT_CSUM_V4 | XMIT_CSUM_TCP);
1773
1774 else if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6)
1775 rc |= (XMIT_GSO_V6 | XMIT_CSUM_TCP | XMIT_CSUM_V6);
1776
1777 return rc;
1778 }
1779
1780 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
1781 /* check if packet requires linearization (packet is too fragmented)
1782 no need to check fragmentation if page size > 8K (there will be no
1783 violation to FW restrictions) */
1784 static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
1785 u32 xmit_type)
1786 {
1787 int to_copy = 0;
1788 int hlen = 0;
1789 int first_bd_sz = 0;
1790
1791 /* 3 = 1 (for linear data BD) + 2 (for PBD and last BD) */
1792 if (skb_shinfo(skb)->nr_frags >= (MAX_FETCH_BD - 3)) {
1793
1794 if (xmit_type & XMIT_GSO) {
1795 unsigned short lso_mss = skb_shinfo(skb)->gso_size;
1796 /* Check if LSO packet needs to be copied:
1797 3 = 1 (for headers BD) + 2 (for PBD and last BD) */
1798 int wnd_size = MAX_FETCH_BD - 3;
1799 /* Number of windows to check */
1800 int num_wnds = skb_shinfo(skb)->nr_frags - wnd_size;
1801 int wnd_idx = 0;
1802 int frag_idx = 0;
1803 u32 wnd_sum = 0;
1804
1805 /* Headers length */
1806 hlen = (int)(skb_transport_header(skb) - skb->data) +
1807 tcp_hdrlen(skb);
1808
1809 /* Amount of data (w/o headers) on linear part of SKB*/
1810 first_bd_sz = skb_headlen(skb) - hlen;
1811
1812 wnd_sum = first_bd_sz;
1813
1814 /* Calculate the first sum - it's special */
1815 for (frag_idx = 0; frag_idx < wnd_size - 1; frag_idx++)
1816 wnd_sum +=
1817 skb_shinfo(skb)->frags[frag_idx].size;
1818
1819 /* If there was data on linear skb data - check it */
1820 if (first_bd_sz > 0) {
1821 if (unlikely(wnd_sum < lso_mss)) {
1822 to_copy = 1;
1823 goto exit_lbl;
1824 }
1825
1826 wnd_sum -= first_bd_sz;
1827 }
1828
1829 /* Others are easier: run through the frag list and
1830 check all windows */
1831 for (wnd_idx = 0; wnd_idx <= num_wnds; wnd_idx++) {
1832 wnd_sum +=
1833 skb_shinfo(skb)->frags[wnd_idx + wnd_size - 1].size;
1834
1835 if (unlikely(wnd_sum < lso_mss)) {
1836 to_copy = 1;
1837 break;
1838 }
1839 wnd_sum -=
1840 skb_shinfo(skb)->frags[wnd_idx].size;
1841 }
1842 } else {
1843 /* in non-LSO too fragmented packet should always
1844 be linearized */
1845 to_copy = 1;
1846 }
1847 }
1848
1849 exit_lbl:
1850 if (unlikely(to_copy))
1851 DP(NETIF_MSG_TX_QUEUED,
1852 "Linearization IS REQUIRED for %s packet. "
1853 "num_frags %d hlen %d first_bd_sz %d\n",
1854 (xmit_type & XMIT_GSO) ? "LSO" : "non-LSO",
1855 skb_shinfo(skb)->nr_frags, hlen, first_bd_sz);
1856
1857 return to_copy;
1858 }
1859 #endif
1860
1861 static inline void bnx2x_set_pbd_gso_e2(struct sk_buff *skb,
1862 struct eth_tx_parse_bd_e2 *pbd,
1863 u32 xmit_type)
1864 {
1865 pbd->parsing_data |= cpu_to_le16(skb_shinfo(skb)->gso_size) <<
1866 ETH_TX_PARSE_BD_E2_LSO_MSS_SHIFT;
1867 if ((xmit_type & XMIT_GSO_V6) &&
1868 (ipv6_hdr(skb)->nexthdr == NEXTHDR_IPV6))
1869 pbd->parsing_data |= ETH_TX_PARSE_BD_E2_IPV6_WITH_EXT_HDR;
1870 }
1871
1872 /**
1873 * Update PBD in GSO case.
1874 *
1875 * @param skb
1876 * @param tx_start_bd
1877 * @param pbd
1878 * @param xmit_type
1879 */
1880 static inline void bnx2x_set_pbd_gso(struct sk_buff *skb,
1881 struct eth_tx_parse_bd_e1x *pbd,
1882 u32 xmit_type)
1883 {
1884 pbd->lso_mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1885 pbd->tcp_send_seq = swab32(tcp_hdr(skb)->seq);
1886 pbd->tcp_flags = pbd_tcp_flags(skb);
1887
1888 if (xmit_type & XMIT_GSO_V4) {
1889 pbd->ip_id = swab16(ip_hdr(skb)->id);
1890 pbd->tcp_pseudo_csum =
1891 swab16(~csum_tcpudp_magic(ip_hdr(skb)->saddr,
1892 ip_hdr(skb)->daddr,
1893 0, IPPROTO_TCP, 0));
1894
1895 } else
1896 pbd->tcp_pseudo_csum =
1897 swab16(~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
1898 &ipv6_hdr(skb)->daddr,
1899 0, IPPROTO_TCP, 0));
1900
1901 pbd->global_data |= ETH_TX_PARSE_BD_E1X_PSEUDO_CS_WITHOUT_LEN;
1902 }
1903 /**
1904 *
1905 * @param skb
1906 * @param tx_start_bd
1907 * @param pbd_e2
1908 * @param xmit_type
1909 *
1910 * @return header len
1911 */
1912 static inline u8 bnx2x_set_pbd_csum_e2(struct bnx2x *bp, struct sk_buff *skb,
1913 struct eth_tx_parse_bd_e2 *pbd,
1914 u32 xmit_type)
1915 {
1916 pbd->parsing_data |= cpu_to_le16(tcp_hdrlen(skb)/4) <<
1917 ETH_TX_PARSE_BD_E2_TCP_HDR_LENGTH_DW_SHIFT;
1918
1919 pbd->parsing_data |= cpu_to_le16(((unsigned char *)tcp_hdr(skb) -
1920 skb->data) / 2) <<
1921 ETH_TX_PARSE_BD_E2_TCP_HDR_START_OFFSET_W_SHIFT;
1922
1923 return skb_transport_header(skb) + tcp_hdrlen(skb) - skb->data;
1924 }
1925
1926 /**
1927 *
1928 * @param skb
1929 * @param tx_start_bd
1930 * @param pbd
1931 * @param xmit_type
1932 *
1933 * @return Header length
1934 */
1935 static inline u8 bnx2x_set_pbd_csum(struct bnx2x *bp, struct sk_buff *skb,
1936 struct eth_tx_parse_bd_e1x *pbd,
1937 u32 xmit_type)
1938 {
1939 u8 hlen = (skb_network_header(skb) - skb->data) / 2;
1940
1941 /* for now NS flag is not used in Linux */
1942 pbd->global_data =
1943 (hlen | ((skb->protocol == cpu_to_be16(ETH_P_8021Q)) <<
1944 ETH_TX_PARSE_BD_E1X_LLC_SNAP_EN_SHIFT));
1945
1946 pbd->ip_hlen_w = (skb_transport_header(skb) -
1947 skb_network_header(skb)) / 2;
1948
1949 hlen += pbd->ip_hlen_w + tcp_hdrlen(skb) / 2;
1950
1951 pbd->total_hlen_w = cpu_to_le16(hlen);
1952 hlen = hlen*2;
1953
1954 if (xmit_type & XMIT_CSUM_TCP) {
1955 pbd->tcp_pseudo_csum = swab16(tcp_hdr(skb)->check);
1956
1957 } else {
1958 s8 fix = SKB_CS_OFF(skb); /* signed! */
1959
1960 DP(NETIF_MSG_TX_QUEUED,
1961 "hlen %d fix %d csum before fix %x\n",
1962 le16_to_cpu(pbd->total_hlen_w), fix, SKB_CS(skb));
1963
1964 /* HW bug: fixup the CSUM */
1965 pbd->tcp_pseudo_csum =
1966 bnx2x_csum_fix(skb_transport_header(skb),
1967 SKB_CS(skb), fix);
1968
1969 DP(NETIF_MSG_TX_QUEUED, "csum after fix %x\n",
1970 pbd->tcp_pseudo_csum);
1971 }
1972
1973 return hlen;
1974 }
1975 /* called with netif_tx_lock
1976 * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
1977 * netif_wake_queue()
1978 */
1979 netdev_tx_t bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
1980 {
1981 struct bnx2x *bp = netdev_priv(dev);
1982 struct bnx2x_fastpath *fp;
1983 struct netdev_queue *txq;
1984 struct sw_tx_bd *tx_buf;
1985 struct eth_tx_start_bd *tx_start_bd;
1986 struct eth_tx_bd *tx_data_bd, *total_pkt_bd = NULL;
1987 struct eth_tx_parse_bd_e1x *pbd_e1x = NULL;
1988 struct eth_tx_parse_bd_e2 *pbd_e2 = NULL;
1989 u16 pkt_prod, bd_prod;
1990 int nbd, fp_index;
1991 dma_addr_t mapping;
1992 u32 xmit_type = bnx2x_xmit_type(bp, skb);
1993 int i;
1994 u8 hlen = 0;
1995 __le16 pkt_size = 0;
1996 struct ethhdr *eth;
1997 u8 mac_type = UNICAST_ADDRESS;
1998
1999 #ifdef BNX2X_STOP_ON_ERROR
2000 if (unlikely(bp->panic))
2001 return NETDEV_TX_BUSY;
2002 #endif
2003
2004 fp_index = skb_get_queue_mapping(skb);
2005 txq = netdev_get_tx_queue(dev, fp_index);
2006
2007 fp = &bp->fp[fp_index];
2008
2009 if (unlikely(bnx2x_tx_avail(fp) < (skb_shinfo(skb)->nr_frags + 3))) {
2010 fp->eth_q_stats.driver_xoff++;
2011 netif_tx_stop_queue(txq);
2012 BNX2X_ERR("BUG! Tx ring full when queue awake!\n");
2013 return NETDEV_TX_BUSY;
2014 }
2015
2016 DP(NETIF_MSG_TX_QUEUED, "queue[%d]: SKB: summed %x protocol %x "
2017 "protocol(%x,%x) gso type %x xmit_type %x\n",
2018 fp_index, skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
2019 ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
2020
2021 eth = (struct ethhdr *)skb->data;
2022
2023 /* set flag according to packet type (UNICAST_ADDRESS is default)*/
2024 if (unlikely(is_multicast_ether_addr(eth->h_dest))) {
2025 if (is_broadcast_ether_addr(eth->h_dest))
2026 mac_type = BROADCAST_ADDRESS;
2027 else
2028 mac_type = MULTICAST_ADDRESS;
2029 }
2030
2031 #if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
2032 /* First, check if we need to linearize the skb (due to FW
2033 restrictions). No need to check fragmentation if page size > 8K
2034 (there will be no violation to FW restrictions) */
2035 if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
2036 /* Statistics of linearization */
2037 bp->lin_cnt++;
2038 if (skb_linearize(skb) != 0) {
2039 DP(NETIF_MSG_TX_QUEUED, "SKB linearization failed - "
2040 "silently dropping this SKB\n");
2041 dev_kfree_skb_any(skb);
2042 return NETDEV_TX_OK;
2043 }
2044 }
2045 #endif
2046
2047 /*
2048 Please read carefully. First we use one BD which we mark as start,
2049 then we have a parsing info BD (used for TSO or xsum),
2050 and only then we have the rest of the TSO BDs.
2051 (don't forget to mark the last one as last,
2052 and to unmap only AFTER you write to the BD ...)
2053 And above all, all pdb sizes are in words - NOT DWORDS!
2054 */
2055
2056 pkt_prod = fp->tx_pkt_prod++;
2057 bd_prod = TX_BD(fp->tx_bd_prod);
2058
2059 /* get a tx_buf and first BD */
2060 tx_buf = &fp->tx_buf_ring[TX_BD(pkt_prod)];
2061 tx_start_bd = &fp->tx_desc_ring[bd_prod].start_bd;
2062
2063 tx_start_bd->bd_flags.as_bitfield = ETH_TX_BD_FLAGS_START_BD;
2064 SET_FLAG(tx_start_bd->general_data,
2065 ETH_TX_START_BD_ETH_ADDR_TYPE,
2066 mac_type);
2067 /* header nbd */
2068 SET_FLAG(tx_start_bd->general_data,
2069 ETH_TX_START_BD_HDR_NBDS,
2070 1);
2071
2072 /* remember the first BD of the packet */
2073 tx_buf->first_bd = fp->tx_bd_prod;
2074 tx_buf->skb = skb;
2075 tx_buf->flags = 0;
2076
2077 DP(NETIF_MSG_TX_QUEUED,
2078 "sending pkt %u @%p next_idx %u bd %u @%p\n",
2079 pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_start_bd);
2080
2081 #ifdef BCM_VLAN
2082 if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb) &&
2083 (bp->flags & HW_VLAN_TX_FLAG)) {
2084 tx_start_bd->vlan_or_ethertype =
2085 cpu_to_le16(vlan_tx_tag_get(skb));
2086 tx_start_bd->bd_flags.as_bitfield |=
2087 (X_ETH_OUTBAND_VLAN << ETH_TX_BD_FLAGS_VLAN_MODE_SHIFT);
2088 } else
2089 #endif
2090 tx_start_bd->vlan_or_ethertype = cpu_to_le16(pkt_prod);
2091
2092 /* turn on parsing and get a BD */
2093 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
2094
2095 if (xmit_type & XMIT_CSUM) {
2096 tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_L4_CSUM;
2097
2098 if (xmit_type & XMIT_CSUM_V4)
2099 tx_start_bd->bd_flags.as_bitfield |=
2100 ETH_TX_BD_FLAGS_IP_CSUM;
2101 else
2102 tx_start_bd->bd_flags.as_bitfield |=
2103 ETH_TX_BD_FLAGS_IPV6;
2104
2105 if (!(xmit_type & XMIT_CSUM_TCP))
2106 tx_start_bd->bd_flags.as_bitfield |=
2107 ETH_TX_BD_FLAGS_IS_UDP;
2108 }
2109
2110 if (CHIP_IS_E2(bp)) {
2111 pbd_e2 = &fp->tx_desc_ring[bd_prod].parse_bd_e2;
2112 memset(pbd_e2, 0, sizeof(struct eth_tx_parse_bd_e2));
2113 /* Set PBD in checksum offload case */
2114 if (xmit_type & XMIT_CSUM)
2115 hlen = bnx2x_set_pbd_csum_e2(bp,
2116 skb, pbd_e2, xmit_type);
2117 } else {
2118 pbd_e1x = &fp->tx_desc_ring[bd_prod].parse_bd_e1x;
2119 memset(pbd_e1x, 0, sizeof(struct eth_tx_parse_bd_e1x));
2120 /* Set PBD in checksum offload case */
2121 if (xmit_type & XMIT_CSUM)
2122 hlen = bnx2x_set_pbd_csum(bp, skb, pbd_e1x, xmit_type);
2123
2124 }
2125
2126 mapping = dma_map_single(&bp->pdev->dev, skb->data,
2127 skb_headlen(skb), DMA_TO_DEVICE);
2128
2129 tx_start_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
2130 tx_start_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
2131 nbd = skb_shinfo(skb)->nr_frags + 2; /* start_bd + pbd + frags */
2132 tx_start_bd->nbd = cpu_to_le16(nbd);
2133 tx_start_bd->nbytes = cpu_to_le16(skb_headlen(skb));
2134 pkt_size = tx_start_bd->nbytes;
2135
2136 DP(NETIF_MSG_TX_QUEUED, "first bd @%p addr (%x:%x) nbd %d"
2137 " nbytes %d flags %x vlan %x\n",
2138 tx_start_bd, tx_start_bd->addr_hi, tx_start_bd->addr_lo,
2139 le16_to_cpu(tx_start_bd->nbd), le16_to_cpu(tx_start_bd->nbytes),
2140 tx_start_bd->bd_flags.as_bitfield,
2141 le16_to_cpu(tx_start_bd->vlan_or_ethertype));
2142
2143 if (xmit_type & XMIT_GSO) {
2144
2145 DP(NETIF_MSG_TX_QUEUED,
2146 "TSO packet len %d hlen %d total len %d tso size %d\n",
2147 skb->len, hlen, skb_headlen(skb),
2148 skb_shinfo(skb)->gso_size);
2149
2150 tx_start_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_SW_LSO;
2151
2152 if (unlikely(skb_headlen(skb) > hlen))
2153 bd_prod = bnx2x_tx_split(bp, fp, tx_buf, &tx_start_bd,
2154 hlen, bd_prod, ++nbd);
2155 if (CHIP_IS_E2(bp))
2156 bnx2x_set_pbd_gso_e2(skb, pbd_e2, xmit_type);
2157 else
2158 bnx2x_set_pbd_gso(skb, pbd_e1x, xmit_type);
2159 }
2160 tx_data_bd = (struct eth_tx_bd *)tx_start_bd;
2161
2162 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2163 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2164
2165 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
2166 tx_data_bd = &fp->tx_desc_ring[bd_prod].reg_bd;
2167 if (total_pkt_bd == NULL)
2168 total_pkt_bd = &fp->tx_desc_ring[bd_prod].reg_bd;
2169
2170 mapping = dma_map_page(&bp->pdev->dev, frag->page,
2171 frag->page_offset,
2172 frag->size, DMA_TO_DEVICE);
2173
2174 tx_data_bd->addr_hi = cpu_to_le32(U64_HI(mapping));
2175 tx_data_bd->addr_lo = cpu_to_le32(U64_LO(mapping));
2176 tx_data_bd->nbytes = cpu_to_le16(frag->size);
2177 le16_add_cpu(&pkt_size, frag->size);
2178
2179 DP(NETIF_MSG_TX_QUEUED,
2180 "frag %d bd @%p addr (%x:%x) nbytes %d\n",
2181 i, tx_data_bd, tx_data_bd->addr_hi, tx_data_bd->addr_lo,
2182 le16_to_cpu(tx_data_bd->nbytes));
2183 }
2184
2185 DP(NETIF_MSG_TX_QUEUED, "last bd @%p\n", tx_data_bd);
2186
2187 bd_prod = TX_BD(NEXT_TX_IDX(bd_prod));
2188
2189 /* now send a tx doorbell, counting the next BD
2190 * if the packet contains or ends with it
2191 */
2192 if (TX_BD_POFF(bd_prod) < nbd)
2193 nbd++;
2194
2195 if (total_pkt_bd != NULL)
2196 total_pkt_bd->total_pkt_bytes = pkt_size;
2197
2198 if (pbd_e1x)
2199 DP(NETIF_MSG_TX_QUEUED,
2200 "PBD (E1X) @%p ip_data %x ip_hlen %u ip_id %u lso_mss %u"
2201 " tcp_flags %x xsum %x seq %u hlen %u\n",
2202 pbd_e1x, pbd_e1x->global_data, pbd_e1x->ip_hlen_w,
2203 pbd_e1x->ip_id, pbd_e1x->lso_mss, pbd_e1x->tcp_flags,
2204 pbd_e1x->tcp_pseudo_csum, pbd_e1x->tcp_send_seq,
2205 le16_to_cpu(pbd_e1x->total_hlen_w));
2206 if (pbd_e2)
2207 DP(NETIF_MSG_TX_QUEUED,
2208 "PBD (E2) @%p dst %x %x %x src %x %x %x parsing_data %x\n",
2209 pbd_e2, pbd_e2->dst_mac_addr_hi, pbd_e2->dst_mac_addr_mid,
2210 pbd_e2->dst_mac_addr_lo, pbd_e2->src_mac_addr_hi,
2211 pbd_e2->src_mac_addr_mid, pbd_e2->src_mac_addr_lo,
2212 pbd_e2->parsing_data);
2213 DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d bd %u\n", nbd, bd_prod);
2214
2215 /*
2216 * Make sure that the BD data is updated before updating the producer
2217 * since FW might read the BD right after the producer is updated.
2218 * This is only applicable for weak-ordered memory model archs such
2219 * as IA-64. The following barrier is also mandatory since FW will
2220 * assumes packets must have BDs.
2221 */
2222 wmb();
2223
2224 fp->tx_db.data.prod += nbd;
2225 barrier();
2226 DOORBELL(bp, fp->cid, fp->tx_db.raw);
2227
2228 mmiowb();
2229
2230 fp->tx_bd_prod += nbd;
2231
2232 if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
2233 netif_tx_stop_queue(txq);
2234
2235 /* paired memory barrier is in bnx2x_tx_int(), we have to keep
2236 * ordering of set_bit() in netif_tx_stop_queue() and read of
2237 * fp->bd_tx_cons */
2238 smp_mb();
2239
2240 fp->eth_q_stats.driver_xoff++;
2241 if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
2242 netif_tx_wake_queue(txq);
2243 }
2244 fp->tx_pkt++;
2245
2246 return NETDEV_TX_OK;
2247 }
2248 /* called with rtnl_lock */
2249 int bnx2x_change_mac_addr(struct net_device *dev, void *p)
2250 {
2251 struct sockaddr *addr = p;
2252 struct bnx2x *bp = netdev_priv(dev);
2253
2254 if (!is_valid_ether_addr((u8 *)(addr->sa_data)))
2255 return -EINVAL;
2256
2257 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
2258 if (netif_running(dev))
2259 bnx2x_set_eth_mac(bp, 1);
2260
2261 return 0;
2262 }
2263
2264 void bnx2x_free_mem_bp(struct bnx2x *bp)
2265 {
2266 kfree(bp->fp);
2267 kfree(bp->msix_table);
2268 kfree(bp->ilt);
2269 }
2270
2271 int __devinit bnx2x_alloc_mem_bp(struct bnx2x *bp)
2272 {
2273 struct bnx2x_fastpath *fp;
2274 struct msix_entry *tbl;
2275 struct bnx2x_ilt *ilt;
2276
2277 /* fp array */
2278 fp = kzalloc(L2_FP_COUNT(bp->l2_cid_count)*sizeof(*fp), GFP_KERNEL);
2279 if (!fp)
2280 goto alloc_err;
2281 bp->fp = fp;
2282
2283 /* msix table */
2284 tbl = kzalloc((bp->l2_cid_count + 1) * sizeof(*tbl),
2285 GFP_KERNEL);
2286 if (!tbl)
2287 goto alloc_err;
2288 bp->msix_table = tbl;
2289
2290 /* ilt */
2291 ilt = kzalloc(sizeof(*ilt), GFP_KERNEL);
2292 if (!ilt)
2293 goto alloc_err;
2294 bp->ilt = ilt;
2295
2296 return 0;
2297 alloc_err:
2298 bnx2x_free_mem_bp(bp);
2299 return -ENOMEM;
2300
2301 }
2302
2303 /* called with rtnl_lock */
2304 int bnx2x_change_mtu(struct net_device *dev, int new_mtu)
2305 {
2306 struct bnx2x *bp = netdev_priv(dev);
2307 int rc = 0;
2308
2309 if (bp->recovery_state != BNX2X_RECOVERY_DONE) {
2310 printk(KERN_ERR "Handling parity error recovery. Try again later\n");
2311 return -EAGAIN;
2312 }
2313
2314 if ((new_mtu > ETH_MAX_JUMBO_PACKET_SIZE) ||
2315 ((new_mtu + ETH_HLEN) < ETH_MIN_PACKET_SIZE))
2316 return -EINVAL;
2317
2318 /* This does not race with packet allocation
2319 * because the actual alloc size is
2320 * only updated as part of load
2321 */
2322 dev->mtu = new_mtu;
2323
2324 if (netif_running(dev)) {
2325 bnx2x_nic_unload(bp, UNLOAD_NORMAL);
2326 rc = bnx2x_nic_load(bp, LOAD_NORMAL);
2327 }
2328
2329 return rc;
2330 }
2331
2332 void bnx2x_tx_timeout(struct net_device *dev)
2333 {
2334 struct bnx2x *bp = netdev_priv(dev);
2335
2336 #ifdef BNX2X_STOP_ON_ERROR
2337 if (!bp->panic)
2338 bnx2x_panic();
2339 #endif
2340 /* This allows the netif to be shutdown gracefully before resetting */
2341 schedule_delayed_work(&bp->reset_task, 0);
2342 }
2343
2344 #ifdef BCM_VLAN
2345 /* called with rtnl_lock */
2346 void bnx2x_vlan_rx_register(struct net_device *dev,
2347 struct vlan_group *vlgrp)
2348 {
2349 struct bnx2x *bp = netdev_priv(dev);
2350
2351 bp->vlgrp = vlgrp;
2352 }
2353
2354 #endif
2355 int bnx2x_suspend(struct pci_dev *pdev, pm_message_t state)
2356 {
2357 struct net_device *dev = pci_get_drvdata(pdev);
2358 struct bnx2x *bp;
2359
2360 if (!dev) {
2361 dev_err(&pdev->dev, "BAD net device from bnx2x_init_one\n");
2362 return -ENODEV;
2363 }
2364 bp = netdev_priv(dev);
2365
2366 rtnl_lock();
2367
2368 pci_save_state(pdev);
2369
2370 if (!netif_running(dev)) {
2371 rtnl_unlock();
2372 return 0;
2373 }
2374
2375 netif_device_detach(dev);
2376
2377 bnx2x_nic_unload(bp, UNLOAD_CLOSE);
2378
2379 bnx2x_set_power_state(bp, pci_choose_state(pdev, state));
2380
2381 rtnl_unlock();
2382
2383 return 0;
2384 }
2385
2386 int bnx2x_resume(struct pci_dev *pdev)
2387 {
2388 struct net_device *dev = pci_get_drvdata(pdev);
2389 struct bnx2x *bp;
2390 int rc;
2391
2392 if (!dev) {
2393 dev_err(&pdev->dev, "BAD net device from bnx2x_init_one\n");
2394 return -ENODEV;
2395 }
2396 bp = netdev_priv(dev);
2397
2398 if (bp->recovery_state != BNX2X_RECOVERY_DONE) {
2399 printk(KERN_ERR "Handling parity error recovery. Try again later\n");
2400 return -EAGAIN;
2401 }
2402
2403 rtnl_lock();
2404
2405 pci_restore_state(pdev);
2406
2407 if (!netif_running(dev)) {
2408 rtnl_unlock();
2409 return 0;
2410 }
2411
2412 bnx2x_set_power_state(bp, PCI_D0);
2413 netif_device_attach(dev);
2414
2415 /* Since the chip was reset, clear the FW sequence number */
2416 bp->fw_seq = 0;
2417 rc = bnx2x_nic_load(bp, LOAD_OPEN);
2418
2419 rtnl_unlock();
2420
2421 return rc;
2422 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree