?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
be2net: cleanup multicast_set cmd to avoid mc_list copy
[linux-2.6/kvm.git] / drivers / net / benet / be_main.c
blob3dc68034c21d485dca632b8040b00a49eeadeade
1 /*
2 * Copyright (C) 2005 - 2009 ServerEngines
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@serverengines.com
12 *
13 * ServerEngines
14 * 209 N. Fair Oaks Ave
15 * Sunnyvale, CA 94085
16 */
17
18 #include "be.h"
19 #include <asm/div64.h>
20
21 MODULE_VERSION(DRV_VER);
22 MODULE_DEVICE_TABLE(pci, be_dev_ids);
23 MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
24 MODULE_AUTHOR("ServerEngines Corporation");
25 MODULE_LICENSE("GPL");
26
27 static unsigned int rx_frag_size = 2048;
28 module_param(rx_frag_size, uint, S_IRUGO);
29 MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
30
31 static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
32 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
33 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
34 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
35 { 0 }
36 };
37 MODULE_DEVICE_TABLE(pci, be_dev_ids);
38
39 static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
40 {
41 struct be_dma_mem *mem = &q->dma_mem;
42 if (mem->va)
43 pci_free_consistent(adapter->pdev, mem->size,
44 mem->va, mem->dma);
45 }
46
47 static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
48 u16 len, u16 entry_size)
49 {
50 struct be_dma_mem *mem = &q->dma_mem;
51
52 memset(q, 0, sizeof(*q));
53 q->len = len;
54 q->entry_size = entry_size;
55 mem->size = len * entry_size;
56 mem->va = pci_alloc_consistent(adapter->pdev, mem->size, &mem->dma);
57 if (!mem->va)
58 return -1;
59 memset(mem->va, 0, mem->size);
60 return 0;
61 }
62
63 static void be_intr_set(struct be_ctrl_info *ctrl, bool enable)
64 {
65 u8 __iomem *addr = ctrl->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET;
66 u32 reg = ioread32(addr);
67 u32 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
68 if (!enabled && enable) {
69 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
70 } else if (enabled && !enable) {
71 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
72 } else {
73 printk(KERN_WARNING DRV_NAME
74 ": bad value in membar_int_ctrl reg=0x%x\n", reg);
75 return;
76 }
77 iowrite32(reg, addr);
78 }
79
80 static void be_rxq_notify(struct be_ctrl_info *ctrl, u16 qid, u16 posted)
81 {
82 u32 val = 0;
83 val |= qid & DB_RQ_RING_ID_MASK;
84 val |= posted << DB_RQ_NUM_POSTED_SHIFT;
85 iowrite32(val, ctrl->db + DB_RQ_OFFSET);
86 }
87
88 static void be_txq_notify(struct be_ctrl_info *ctrl, u16 qid, u16 posted)
89 {
90 u32 val = 0;
91 val |= qid & DB_TXULP_RING_ID_MASK;
92 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
93 iowrite32(val, ctrl->db + DB_TXULP1_OFFSET);
94 }
95
96 static void be_eq_notify(struct be_ctrl_info *ctrl, u16 qid,
97 bool arm, bool clear_int, u16 num_popped)
98 {
99 u32 val = 0;
100 val |= qid & DB_EQ_RING_ID_MASK;
101 if (arm)
102 val |= 1 << DB_EQ_REARM_SHIFT;
103 if (clear_int)
104 val |= 1 << DB_EQ_CLR_SHIFT;
105 val |= 1 << DB_EQ_EVNT_SHIFT;
106 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
107 iowrite32(val, ctrl->db + DB_EQ_OFFSET);
108 }
109
110 void be_cq_notify(struct be_ctrl_info *ctrl, u16 qid,
111 bool arm, u16 num_popped)
112 {
113 u32 val = 0;
114 val |= qid & DB_CQ_RING_ID_MASK;
115 if (arm)
116 val |= 1 << DB_CQ_REARM_SHIFT;
117 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
118 iowrite32(val, ctrl->db + DB_CQ_OFFSET);
119 }
120
121
122 static int be_mac_addr_set(struct net_device *netdev, void *p)
123 {
124 struct be_adapter *adapter = netdev_priv(netdev);
125 struct sockaddr *addr = p;
126 int status = 0;
127
128 if (netif_running(netdev)) {
129 status = be_cmd_pmac_del(&adapter->ctrl, adapter->if_handle,
130 adapter->pmac_id);
131 if (status)
132 return status;
133
134 status = be_cmd_pmac_add(&adapter->ctrl, (u8 *)addr->sa_data,
135 adapter->if_handle, &adapter->pmac_id);
136 }
137
138 if (!status)
139 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
140
141 return status;
142 }
143
144 static void netdev_stats_update(struct be_adapter *adapter)
145 {
146 struct be_hw_stats *hw_stats = hw_stats_from_cmd(adapter->stats.cmd.va);
147 struct be_rxf_stats *rxf_stats = &hw_stats->rxf;
148 struct be_port_rxf_stats *port_stats =
149 &rxf_stats->port[adapter->port_num];
150 struct net_device_stats *dev_stats = &adapter->stats.net_stats;
151 struct be_erx_stats *erx_stats = &hw_stats->erx;
152
153 dev_stats->rx_packets = port_stats->rx_total_frames;
154 dev_stats->tx_packets = port_stats->tx_unicastframes +
155 port_stats->tx_multicastframes + port_stats->tx_broadcastframes;
156 dev_stats->rx_bytes = (u64) port_stats->rx_bytes_msd << 32 |
157 (u64) port_stats->rx_bytes_lsd;
158 dev_stats->tx_bytes = (u64) port_stats->tx_bytes_msd << 32 |
159 (u64) port_stats->tx_bytes_lsd;
160
161 /* bad pkts received */
162 dev_stats->rx_errors = port_stats->rx_crc_errors +
163 port_stats->rx_alignment_symbol_errors +
164 port_stats->rx_in_range_errors +
165 port_stats->rx_out_range_errors +
166 port_stats->rx_frame_too_long +
167 port_stats->rx_dropped_too_small +
168 port_stats->rx_dropped_too_short +
169 port_stats->rx_dropped_header_too_small +
170 port_stats->rx_dropped_tcp_length +
171 port_stats->rx_dropped_runt +
172 port_stats->rx_tcp_checksum_errs +
173 port_stats->rx_ip_checksum_errs +
174 port_stats->rx_udp_checksum_errs;
175
176 /* no space in linux buffers: best possible approximation */
177 dev_stats->rx_dropped = erx_stats->rx_drops_no_fragments[0];
178
179 /* detailed rx errors */
180 dev_stats->rx_length_errors = port_stats->rx_in_range_errors +
181 port_stats->rx_out_range_errors +
182 port_stats->rx_frame_too_long;
183
184 /* receive ring buffer overflow */
185 dev_stats->rx_over_errors = 0;
186
187 dev_stats->rx_crc_errors = port_stats->rx_crc_errors;
188
189 /* frame alignment errors */
190 dev_stats->rx_frame_errors = port_stats->rx_alignment_symbol_errors;
191
192 /* receiver fifo overrun */
193 /* drops_no_pbuf is no per i/f, it's per BE card */
194 dev_stats->rx_fifo_errors = port_stats->rx_fifo_overflow +
195 port_stats->rx_input_fifo_overflow +
196 rxf_stats->rx_drops_no_pbuf;
197 /* receiver missed packetd */
198 dev_stats->rx_missed_errors = 0;
199
200 /* packet transmit problems */
201 dev_stats->tx_errors = 0;
202
203 /* no space available in linux */
204 dev_stats->tx_dropped = 0;
205
206 dev_stats->multicast = port_stats->tx_multicastframes;
207 dev_stats->collisions = 0;
208
209 /* detailed tx_errors */
210 dev_stats->tx_aborted_errors = 0;
211 dev_stats->tx_carrier_errors = 0;
212 dev_stats->tx_fifo_errors = 0;
213 dev_stats->tx_heartbeat_errors = 0;
214 dev_stats->tx_window_errors = 0;
215 }
216
217 static void be_link_status_update(struct be_adapter *adapter)
218 {
219 struct be_link_info *prev = &adapter->link;
220 struct be_link_info now = { 0 };
221 struct net_device *netdev = adapter->netdev;
222
223 be_cmd_link_status_query(&adapter->ctrl, &now);
224
225 /* If link came up or went down */
226 if (now.speed != prev->speed && (now.speed == PHY_LINK_SPEED_ZERO ||
227 prev->speed == PHY_LINK_SPEED_ZERO)) {
228 if (now.speed == PHY_LINK_SPEED_ZERO) {
229 netif_stop_queue(netdev);
230 netif_carrier_off(netdev);
231 printk(KERN_INFO "%s: Link down\n", netdev->name);
232 } else {
233 netif_start_queue(netdev);
234 netif_carrier_on(netdev);
235 printk(KERN_INFO "%s: Link up\n", netdev->name);
236 }
237 }
238 *prev = now;
239 }
240
241 /* Update the EQ delay n BE based on the RX frags consumed / sec */
242 static void be_rx_eqd_update(struct be_adapter *adapter)
243 {
244 struct be_ctrl_info *ctrl = &adapter->ctrl;
245 struct be_eq_obj *rx_eq = &adapter->rx_eq;
246 struct be_drvr_stats *stats = &adapter->stats.drvr_stats;
247 ulong now = jiffies;
248 u32 eqd;
249
250 if (!rx_eq->enable_aic)
251 return;
252
253 /* Wrapped around */
254 if (time_before(now, stats->rx_fps_jiffies)) {
255 stats->rx_fps_jiffies = now;
256 return;
257 }
258
259 /* Update once a second */
260 if ((now - stats->rx_fps_jiffies) < HZ)
261 return;
262
263 stats->be_rx_fps = (stats->be_rx_frags - stats->be_prev_rx_frags) /
264 ((now - stats->rx_fps_jiffies) / HZ);
265
266 stats->rx_fps_jiffies = now;
267 stats->be_prev_rx_frags = stats->be_rx_frags;
268 eqd = stats->be_rx_fps / 110000;
269 eqd = eqd << 3;
270 if (eqd > rx_eq->max_eqd)
271 eqd = rx_eq->max_eqd;
272 if (eqd < rx_eq->min_eqd)
273 eqd = rx_eq->min_eqd;
274 if (eqd < 10)
275 eqd = 0;
276 if (eqd != rx_eq->cur_eqd)
277 be_cmd_modify_eqd(ctrl, rx_eq->q.id, eqd);
278
279 rx_eq->cur_eqd = eqd;
280 }
281
282 static struct net_device_stats *be_get_stats(struct net_device *dev)
283 {
284 struct be_adapter *adapter = netdev_priv(dev);
285
286 return &adapter->stats.net_stats;
287 }
288
289 static u32 be_calc_rate(u64 bytes, unsigned long ticks)
290 {
291 u64 rate = bytes;
292
293 do_div(rate, ticks / HZ);
294 rate <<= 3; /* bytes/sec -> bits/sec */
295 do_div(rate, 1000000ul); /* MB/Sec */
296
297 return rate;
298 }
299
300 static void be_tx_rate_update(struct be_adapter *adapter)
301 {
302 struct be_drvr_stats *stats = drvr_stats(adapter);
303 ulong now = jiffies;
304
305 /* Wrapped around? */
306 if (time_before(now, stats->be_tx_jiffies)) {
307 stats->be_tx_jiffies = now;
308 return;
309 }
310
311 /* Update tx rate once in two seconds */
312 if ((now - stats->be_tx_jiffies) > 2 * HZ) {
313 stats->be_tx_rate = be_calc_rate(stats->be_tx_bytes
314 - stats->be_tx_bytes_prev,
315 now - stats->be_tx_jiffies);
316 stats->be_tx_jiffies = now;
317 stats->be_tx_bytes_prev = stats->be_tx_bytes;
318 }
319 }
320
321 static void be_tx_stats_update(struct be_adapter *adapter,
322 u32 wrb_cnt, u32 copied, bool stopped)
323 {
324 struct be_drvr_stats *stats = drvr_stats(adapter);
325 stats->be_tx_reqs++;
326 stats->be_tx_wrbs += wrb_cnt;
327 stats->be_tx_bytes += copied;
328 if (stopped)
329 stats->be_tx_stops++;
330 }
331
332 /* Determine number of WRB entries needed to xmit data in an skb */
333 static u32 wrb_cnt_for_skb(struct sk_buff *skb, bool *dummy)
334 {
335 int cnt = (skb->len > skb->data_len);
336
337 cnt += skb_shinfo(skb)->nr_frags;
338
339 /* to account for hdr wrb */
340 cnt++;
341 if (cnt & 1) {
342 /* add a dummy to make it an even num */
343 cnt++;
344 *dummy = true;
345 } else
346 *dummy = false;
347 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
348 return cnt;
349 }
350
351 static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
352 {
353 wrb->frag_pa_hi = upper_32_bits(addr);
354 wrb->frag_pa_lo = addr & 0xFFFFFFFF;
355 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
356 }
357
358 static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb,
359 bool vlan, u32 wrb_cnt, u32 len)
360 {
361 memset(hdr, 0, sizeof(*hdr));
362
363 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
364
365 if (skb_shinfo(skb)->gso_segs > 1 && skb_shinfo(skb)->gso_size) {
366 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
367 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
368 hdr, skb_shinfo(skb)->gso_size);
369 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
370 if (is_tcp_pkt(skb))
371 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
372 else if (is_udp_pkt(skb))
373 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
374 }
375
376 if (vlan && vlan_tx_tag_present(skb)) {
377 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
378 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag,
379 hdr, vlan_tx_tag_get(skb));
380 }
381
382 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
383 AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, 1);
384 AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
385 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
386 }
387
388
389 static int make_tx_wrbs(struct be_adapter *adapter,
390 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
391 {
392 u64 busaddr;
393 u32 i, copied = 0;
394 struct pci_dev *pdev = adapter->pdev;
395 struct sk_buff *first_skb = skb;
396 struct be_queue_info *txq = &adapter->tx_obj.q;
397 struct be_eth_wrb *wrb;
398 struct be_eth_hdr_wrb *hdr;
399
400 atomic_add(wrb_cnt, &txq->used);
401 hdr = queue_head_node(txq);
402 queue_head_inc(txq);
403
404 if (skb->len > skb->data_len) {
405 int len = skb->len - skb->data_len;
406 busaddr = pci_map_single(pdev, skb->data, len,
407 PCI_DMA_TODEVICE);
408 wrb = queue_head_node(txq);
409 wrb_fill(wrb, busaddr, len);
410 be_dws_cpu_to_le(wrb, sizeof(*wrb));
411 queue_head_inc(txq);
412 copied += len;
413 }
414
415 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
416 struct skb_frag_struct *frag =
417 &skb_shinfo(skb)->frags[i];
418 busaddr = pci_map_page(pdev, frag->page,
419 frag->page_offset,
420 frag->size, PCI_DMA_TODEVICE);
421 wrb = queue_head_node(txq);
422 wrb_fill(wrb, busaddr, frag->size);
423 be_dws_cpu_to_le(wrb, sizeof(*wrb));
424 queue_head_inc(txq);
425 copied += frag->size;
426 }
427
428 if (dummy_wrb) {
429 wrb = queue_head_node(txq);
430 wrb_fill(wrb, 0, 0);
431 be_dws_cpu_to_le(wrb, sizeof(*wrb));
432 queue_head_inc(txq);
433 }
434
435 wrb_fill_hdr(hdr, first_skb, adapter->vlan_grp ? true : false,
436 wrb_cnt, copied);
437 be_dws_cpu_to_le(hdr, sizeof(*hdr));
438
439 return copied;
440 }
441
442 static int be_xmit(struct sk_buff *skb, struct net_device *netdev)
443 {
444 struct be_adapter *adapter = netdev_priv(netdev);
445 struct be_tx_obj *tx_obj = &adapter->tx_obj;
446 struct be_queue_info *txq = &tx_obj->q;
447 u32 wrb_cnt = 0, copied = 0;
448 u32 start = txq->head;
449 bool dummy_wrb, stopped = false;
450
451 wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb);
452
453 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
454
455 /* record the sent skb in the sent_skb table */
456 BUG_ON(tx_obj->sent_skb_list[start]);
457 tx_obj->sent_skb_list[start] = skb;
458
459 /* Ensure that txq has space for the next skb; Else stop the queue
460 * *BEFORE* ringing the tx doorbell, so that we serialze the
461 * tx compls of the current transmit which'll wake up the queue
462 */
463 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >= txq->len) {
464 netif_stop_queue(netdev);
465 stopped = true;
466 }
467
468 be_txq_notify(&adapter->ctrl, txq->id, wrb_cnt);
469
470 be_tx_stats_update(adapter, wrb_cnt, copied, stopped);
471 return NETDEV_TX_OK;
472 }
473
474 static int be_change_mtu(struct net_device *netdev, int new_mtu)
475 {
476 struct be_adapter *adapter = netdev_priv(netdev);
477 if (new_mtu < BE_MIN_MTU ||
478 new_mtu > BE_MAX_JUMBO_FRAME_SIZE) {
479 dev_info(&adapter->pdev->dev,
480 "MTU must be between %d and %d bytes\n",
481 BE_MIN_MTU, BE_MAX_JUMBO_FRAME_SIZE);
482 return -EINVAL;
483 }
484 dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
485 netdev->mtu, new_mtu);
486 netdev->mtu = new_mtu;
487 return 0;
488 }
489
490 /*
491 * if there are BE_NUM_VLANS_SUPPORTED or lesser number of VLANS configured,
492 * program them in BE. If more than BE_NUM_VLANS_SUPPORTED are configured,
493 * set the BE in promiscuous VLAN mode.
494 */
495 static void be_vid_config(struct net_device *netdev)
496 {
497 struct be_adapter *adapter = netdev_priv(netdev);
498 u16 vtag[BE_NUM_VLANS_SUPPORTED];
499 u16 ntags = 0, i;
500
501 if (adapter->num_vlans <= BE_NUM_VLANS_SUPPORTED) {
502 /* Construct VLAN Table to give to HW */
503 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
504 if (adapter->vlan_tag[i]) {
505 vtag[ntags] = cpu_to_le16(i);
506 ntags++;
507 }
508 }
509 be_cmd_vlan_config(&adapter->ctrl, adapter->if_handle,
510 vtag, ntags, 1, 0);
511 } else {
512 be_cmd_vlan_config(&adapter->ctrl, adapter->if_handle,
513 NULL, 0, 1, 1);
514 }
515 }
516
517 static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp)
518 {
519 struct be_adapter *adapter = netdev_priv(netdev);
520 struct be_eq_obj *rx_eq = &adapter->rx_eq;
521 struct be_eq_obj *tx_eq = &adapter->tx_eq;
522 struct be_ctrl_info *ctrl = &adapter->ctrl;
523
524 be_eq_notify(ctrl, rx_eq->q.id, false, false, 0);
525 be_eq_notify(ctrl, tx_eq->q.id, false, false, 0);
526 adapter->vlan_grp = grp;
527 be_eq_notify(ctrl, rx_eq->q.id, true, false, 0);
528 be_eq_notify(ctrl, tx_eq->q.id, true, false, 0);
529 }
530
531 static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
532 {
533 struct be_adapter *adapter = netdev_priv(netdev);
534
535 adapter->num_vlans++;
536 adapter->vlan_tag[vid] = 1;
537
538 be_vid_config(netdev);
539 }
540
541 static void be_vlan_rem_vid(struct net_device *netdev, u16 vid)
542 {
543 struct be_adapter *adapter = netdev_priv(netdev);
544
545 adapter->num_vlans--;
546 adapter->vlan_tag[vid] = 0;
547
548 vlan_group_set_device(adapter->vlan_grp, vid, NULL);
549 be_vid_config(netdev);
550 }
551
552 static void be_set_multicast_list(struct net_device *netdev)
553 {
554 struct be_adapter *adapter = netdev_priv(netdev);
555 struct be_ctrl_info *ctrl = &adapter->ctrl;
556
557 if (netdev->flags & IFF_PROMISC) {
558 be_cmd_promiscuous_config(ctrl, adapter->port_num, 1);
559 adapter->promiscuous = true;
560 goto done;
561 }
562
563 /* BE was previously in promiscous mode; disable it */
564 if (adapter->promiscuous) {
565 adapter->promiscuous = false;
566 be_cmd_promiscuous_config(ctrl, adapter->port_num, 0);
567 }
568
569 if (netdev->flags & IFF_ALLMULTI) {
570 be_cmd_multicast_set(ctrl, adapter->if_handle, NULL, 0);
571 goto done;
572 }
573
574 be_cmd_multicast_set(ctrl, adapter->if_handle, netdev->mc_list,
575 netdev->mc_count);
576 done:
577 return;
578 }
579
580 static void be_rx_rate_update(struct be_adapter *adapter)
581 {
582 struct be_drvr_stats *stats = drvr_stats(adapter);
583 ulong now = jiffies;
584
585 /* Wrapped around */
586 if (time_before(now, stats->be_rx_jiffies)) {
587 stats->be_rx_jiffies = now;
588 return;
589 }
590
591 /* Update the rate once in two seconds */
592 if ((now - stats->be_rx_jiffies) < 2 * HZ)
593 return;
594
595 stats->be_rx_rate = be_calc_rate(stats->be_rx_bytes
596 - stats->be_rx_bytes_prev,
597 now - stats->be_rx_jiffies);
598 stats->be_rx_jiffies = now;
599 stats->be_rx_bytes_prev = stats->be_rx_bytes;
600 }
601
602 static void be_rx_stats_update(struct be_adapter *adapter,
603 u32 pktsize, u16 numfrags)
604 {
605 struct be_drvr_stats *stats = drvr_stats(adapter);
606
607 stats->be_rx_compl++;
608 stats->be_rx_frags += numfrags;
609 stats->be_rx_bytes += pktsize;
610 }
611
612 static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso)
613 {
614 u8 l4_cksm, ip_version, ipcksm, tcpf = 0, udpf = 0, ipv6_chk;
615
616 l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp);
617 ipcksm = AMAP_GET_BITS(struct amap_eth_rx_compl, ipcksm, rxcp);
618 ip_version = AMAP_GET_BITS(struct amap_eth_rx_compl, ip_version, rxcp);
619 if (ip_version) {
620 tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
621 udpf = AMAP_GET_BITS(struct amap_eth_rx_compl, udpf, rxcp);
622 }
623 ipv6_chk = (ip_version && (tcpf || udpf));
624
625 return ((l4_cksm && ipv6_chk && ipcksm) && cso) ? false : true;
626 }
627
628 static struct be_rx_page_info *
629 get_rx_page_info(struct be_adapter *adapter, u16 frag_idx)
630 {
631 struct be_rx_page_info *rx_page_info;
632 struct be_queue_info *rxq = &adapter->rx_obj.q;
633
634 rx_page_info = &adapter->rx_obj.page_info_tbl[frag_idx];
635 BUG_ON(!rx_page_info->page);
636
637 if (rx_page_info->last_page_user)
638 pci_unmap_page(adapter->pdev, pci_unmap_addr(rx_page_info, bus),
639 adapter->big_page_size, PCI_DMA_FROMDEVICE);
640
641 atomic_dec(&rxq->used);
642 return rx_page_info;
643 }
644
645 /* Throwaway the data in the Rx completion */
646 static void be_rx_compl_discard(struct be_adapter *adapter,
647 struct be_eth_rx_compl *rxcp)
648 {
649 struct be_queue_info *rxq = &adapter->rx_obj.q;
650 struct be_rx_page_info *page_info;
651 u16 rxq_idx, i, num_rcvd;
652
653 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
654 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
655
656 for (i = 0; i < num_rcvd; i++) {
657 page_info = get_rx_page_info(adapter, rxq_idx);
658 put_page(page_info->page);
659 memset(page_info, 0, sizeof(*page_info));
660 index_inc(&rxq_idx, rxq->len);
661 }
662 }
663
664 /*
665 * skb_fill_rx_data forms a complete skb for an ether frame
666 * indicated by rxcp.
667 */
668 static void skb_fill_rx_data(struct be_adapter *adapter,
669 struct sk_buff *skb, struct be_eth_rx_compl *rxcp)
670 {
671 struct be_queue_info *rxq = &adapter->rx_obj.q;
672 struct be_rx_page_info *page_info;
673 u16 rxq_idx, i, num_rcvd;
674 u32 pktsize, hdr_len, curr_frag_len;
675 u8 *start;
676
677 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
678 pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
679 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
680
681 page_info = get_rx_page_info(adapter, rxq_idx);
682
683 start = page_address(page_info->page) + page_info->page_offset;
684 prefetch(start);
685
686 /* Copy data in the first descriptor of this completion */
687 curr_frag_len = min(pktsize, rx_frag_size);
688
689 /* Copy the header portion into skb_data */
690 hdr_len = min((u32)BE_HDR_LEN, curr_frag_len);
691 memcpy(skb->data, start, hdr_len);
692 skb->len = curr_frag_len;
693 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
694 /* Complete packet has now been moved to data */
695 put_page(page_info->page);
696 skb->data_len = 0;
697 skb->tail += curr_frag_len;
698 } else {
699 skb_shinfo(skb)->nr_frags = 1;
700 skb_shinfo(skb)->frags[0].page = page_info->page;
701 skb_shinfo(skb)->frags[0].page_offset =
702 page_info->page_offset + hdr_len;
703 skb_shinfo(skb)->frags[0].size = curr_frag_len - hdr_len;
704 skb->data_len = curr_frag_len - hdr_len;
705 skb->tail += hdr_len;
706 }
707 memset(page_info, 0, sizeof(*page_info));
708
709 if (pktsize <= rx_frag_size) {
710 BUG_ON(num_rcvd != 1);
711 goto done;
712 }
713
714 /* More frags present for this completion */
715 pktsize -= curr_frag_len; /* account for above copied frag */
716 for (i = 1; i < num_rcvd; i++) {
717 index_inc(&rxq_idx, rxq->len);
718 page_info = get_rx_page_info(adapter, rxq_idx);
719
720 curr_frag_len = min(pktsize, rx_frag_size);
721
722 skb_shinfo(skb)->frags[i].page = page_info->page;
723 skb_shinfo(skb)->frags[i].page_offset = page_info->page_offset;
724 skb_shinfo(skb)->frags[i].size = curr_frag_len;
725 skb->len += curr_frag_len;
726 skb->data_len += curr_frag_len;
727 skb_shinfo(skb)->nr_frags++;
728 pktsize -= curr_frag_len;
729
730 memset(page_info, 0, sizeof(*page_info));
731 }
732
733 done:
734 be_rx_stats_update(adapter, pktsize, num_rcvd);
735 return;
736 }
737
738 /* Process the RX completion indicated by rxcp when LRO is disabled */
739 static void be_rx_compl_process(struct be_adapter *adapter,
740 struct be_eth_rx_compl *rxcp)
741 {
742 struct sk_buff *skb;
743 u32 vtp, vid;
744
745 vtp = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
746
747 skb = netdev_alloc_skb(adapter->netdev, BE_HDR_LEN + NET_IP_ALIGN);
748 if (!skb) {
749 if (net_ratelimit())
750 dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
751 be_rx_compl_discard(adapter, rxcp);
752 return;
753 }
754
755 skb_reserve(skb, NET_IP_ALIGN);
756
757 skb_fill_rx_data(adapter, skb, rxcp);
758
759 if (do_pkt_csum(rxcp, adapter->rx_csum))
760 skb->ip_summed = CHECKSUM_NONE;
761 else
762 skb->ip_summed = CHECKSUM_UNNECESSARY;
763
764 skb->truesize = skb->len + sizeof(struct sk_buff);
765 skb->protocol = eth_type_trans(skb, adapter->netdev);
766 skb->dev = adapter->netdev;
767
768 if (vtp) {
769 if (!adapter->vlan_grp || adapter->num_vlans == 0) {
770 kfree_skb(skb);
771 return;
772 }
773 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
774 vid = be16_to_cpu(vid);
775 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp, vid);
776 } else {
777 netif_receive_skb(skb);
778 }
779
780 adapter->netdev->last_rx = jiffies;
781
782 return;
783 }
784
785 /* Process the RX completion indicated by rxcp when LRO is enabled */
786 static void be_rx_compl_process_lro(struct be_adapter *adapter,
787 struct be_eth_rx_compl *rxcp)
788 {
789 struct be_rx_page_info *page_info;
790 struct skb_frag_struct rx_frags[BE_MAX_FRAGS_PER_FRAME];
791 struct be_queue_info *rxq = &adapter->rx_obj.q;
792 u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
793 u16 i, rxq_idx = 0, vid;
794
795 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
796 pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
797 vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
798 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
799
800 remaining = pkt_size;
801 for (i = 0; i < num_rcvd; i++) {
802 page_info = get_rx_page_info(adapter, rxq_idx);
803
804 curr_frag_len = min(remaining, rx_frag_size);
805
806 rx_frags[i].page = page_info->page;
807 rx_frags[i].page_offset = page_info->page_offset;
808 rx_frags[i].size = curr_frag_len;
809 remaining -= curr_frag_len;
810
811 index_inc(&rxq_idx, rxq->len);
812
813 memset(page_info, 0, sizeof(*page_info));
814 }
815
816 if (likely(!vlanf)) {
817 lro_receive_frags(&adapter->rx_obj.lro_mgr, rx_frags, pkt_size,
818 pkt_size, NULL, 0);
819 } else {
820 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
821 vid = be16_to_cpu(vid);
822
823 if (!adapter->vlan_grp || adapter->num_vlans == 0)
824 return;
825
826 lro_vlan_hwaccel_receive_frags(&adapter->rx_obj.lro_mgr,
827 rx_frags, pkt_size, pkt_size, adapter->vlan_grp,
828 vid, NULL, 0);
829 }
830
831 be_rx_stats_update(adapter, pkt_size, num_rcvd);
832 return;
833 }
834
835 static struct be_eth_rx_compl *be_rx_compl_get(struct be_adapter *adapter)
836 {
837 struct be_eth_rx_compl *rxcp = queue_tail_node(&adapter->rx_obj.cq);
838
839 if (rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] == 0)
840 return NULL;
841
842 be_dws_le_to_cpu(rxcp, sizeof(*rxcp));
843
844 queue_tail_inc(&adapter->rx_obj.cq);
845 return rxcp;
846 }
847
848 /* To reset the valid bit, we need to reset the whole word as
849 * when walking the queue the valid entries are little-endian
850 * and invalid entries are host endian
851 */
852 static inline void be_rx_compl_reset(struct be_eth_rx_compl *rxcp)
853 {
854 rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] = 0;
855 }
856
857 static inline struct page *be_alloc_pages(u32 size)
858 {
859 gfp_t alloc_flags = GFP_ATOMIC;
860 u32 order = get_order(size);
861 if (order > 0)
862 alloc_flags |= __GFP_COMP;
863 return alloc_pages(alloc_flags, order);
864 }
865
866 /*
867 * Allocate a page, split it to fragments of size rx_frag_size and post as
868 * receive buffers to BE
869 */
870 static void be_post_rx_frags(struct be_adapter *adapter)
871 {
872 struct be_rx_page_info *page_info_tbl = adapter->rx_obj.page_info_tbl;
873 struct be_rx_page_info *page_info = NULL;
874 struct be_queue_info *rxq = &adapter->rx_obj.q;
875 struct page *pagep = NULL;
876 struct be_eth_rx_d *rxd;
877 u64 page_dmaaddr = 0, frag_dmaaddr;
878 u32 posted, page_offset = 0;
879
880 page_info = &page_info_tbl[rxq->head];
881 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
882 if (!pagep) {
883 pagep = be_alloc_pages(adapter->big_page_size);
884 if (unlikely(!pagep)) {
885 drvr_stats(adapter)->be_ethrx_post_fail++;
886 break;
887 }
888 page_dmaaddr = pci_map_page(adapter->pdev, pagep, 0,
889 adapter->big_page_size,
890 PCI_DMA_FROMDEVICE);
891 page_info->page_offset = 0;
892 } else {
893 get_page(pagep);
894 page_info->page_offset = page_offset + rx_frag_size;
895 }
896 page_offset = page_info->page_offset;
897 page_info->page = pagep;
898 pci_unmap_addr_set(page_info, bus, page_dmaaddr);
899 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
900
901 rxd = queue_head_node(rxq);
902 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
903 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
904 queue_head_inc(rxq);
905
906 /* Any space left in the current big page for another frag? */
907 if ((page_offset + rx_frag_size + rx_frag_size) >
908 adapter->big_page_size) {
909 pagep = NULL;
910 page_info->last_page_user = true;
911 }
912 page_info = &page_info_tbl[rxq->head];
913 }
914 if (pagep)
915 page_info->last_page_user = true;
916
917 if (posted) {
918 atomic_add(posted, &rxq->used);
919 be_rxq_notify(&adapter->ctrl, rxq->id, posted);
920 } else if (atomic_read(&rxq->used) == 0) {
921 /* Let be_worker replenish when memory is available */
922 adapter->rx_post_starved = true;
923 }
924
925 return;
926 }
927
928 static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
929 {
930 struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
931
932 if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
933 return NULL;
934
935 be_dws_le_to_cpu(txcp, sizeof(*txcp));
936
937 txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
938
939 queue_tail_inc(tx_cq);
940 return txcp;
941 }
942
943 static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
944 {
945 struct be_queue_info *txq = &adapter->tx_obj.q;
946 struct be_eth_wrb *wrb;
947 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
948 struct sk_buff *sent_skb;
949 u64 busaddr;
950 u16 cur_index, num_wrbs = 0;
951
952 cur_index = txq->tail;
953 sent_skb = sent_skbs[cur_index];
954 BUG_ON(!sent_skb);
955 sent_skbs[cur_index] = NULL;
956
957 do {
958 cur_index = txq->tail;
959 wrb = queue_tail_node(txq);
960 be_dws_le_to_cpu(wrb, sizeof(*wrb));
961 busaddr = ((u64)wrb->frag_pa_hi << 32) | (u64)wrb->frag_pa_lo;
962 if (busaddr != 0) {
963 pci_unmap_single(adapter->pdev, busaddr,
964 wrb->frag_len, PCI_DMA_TODEVICE);
965 }
966 num_wrbs++;
967 queue_tail_inc(txq);
968 } while (cur_index != last_index);
969
970 atomic_sub(num_wrbs, &txq->used);
971
972 kfree_skb(sent_skb);
973 }
974
975 static void be_rx_q_clean(struct be_adapter *adapter)
976 {
977 struct be_rx_page_info *page_info;
978 struct be_queue_info *rxq = &adapter->rx_obj.q;
979 struct be_queue_info *rx_cq = &adapter->rx_obj.cq;
980 struct be_eth_rx_compl *rxcp;
981 u16 tail;
982
983 /* First cleanup pending rx completions */
984 while ((rxcp = be_rx_compl_get(adapter)) != NULL) {
985 be_rx_compl_discard(adapter, rxcp);
986 be_rx_compl_reset(rxcp);
987 be_cq_notify(&adapter->ctrl, rx_cq->id, true, 1);
988 }
989
990 /* Then free posted rx buffer that were not used */
991 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
992 for (; tail != rxq->head; index_inc(&tail, rxq->len)) {
993 page_info = get_rx_page_info(adapter, tail);
994 put_page(page_info->page);
995 memset(page_info, 0, sizeof(*page_info));
996 }
997 BUG_ON(atomic_read(&rxq->used));
998 }
999
1000 static void be_tx_q_clean(struct be_adapter *adapter)
1001 {
1002 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1003 struct sk_buff *sent_skb;
1004 struct be_queue_info *txq = &adapter->tx_obj.q;
1005 u16 last_index;
1006 bool dummy_wrb;
1007
1008 while (atomic_read(&txq->used)) {
1009 sent_skb = sent_skbs[txq->tail];
1010 last_index = txq->tail;
1011 index_adv(&last_index,
1012 wrb_cnt_for_skb(sent_skb, &dummy_wrb) - 1, txq->len);
1013 be_tx_compl_process(adapter, last_index);
1014 }
1015 }
1016
1017 static void be_mcc_queues_destroy(struct be_adapter *adapter)
1018 {
1019 struct be_queue_info *q;
1020 struct be_ctrl_info *ctrl = &adapter->ctrl;
1021
1022 q = &ctrl->mcc_obj.q;
1023 if (q->created)
1024 be_cmd_q_destroy(ctrl, q, QTYPE_MCCQ);
1025 be_queue_free(adapter, q);
1026
1027 q = &ctrl->mcc_obj.cq;
1028 if (q->created)
1029 be_cmd_q_destroy(ctrl, q, QTYPE_CQ);
1030 be_queue_free(adapter, q);
1031 }
1032
1033 /* Must be called only after TX qs are created as MCC shares TX EQ */
1034 static int be_mcc_queues_create(struct be_adapter *adapter)
1035 {
1036 struct be_queue_info *q, *cq;
1037 struct be_ctrl_info *ctrl = &adapter->ctrl;
1038
1039 /* Alloc MCC compl queue */
1040 cq = &ctrl->mcc_obj.cq;
1041 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
1042 sizeof(struct be_mcc_cq_entry)))
1043 goto err;
1044
1045 /* Ask BE to create MCC compl queue; share TX's eq */
1046 if (be_cmd_cq_create(ctrl, cq, &adapter->tx_eq.q, false, true, 0))
1047 goto mcc_cq_free;
1048
1049 /* Alloc MCC queue */
1050 q = &ctrl->mcc_obj.q;
1051 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1052 goto mcc_cq_destroy;
1053
1054 /* Ask BE to create MCC queue */
1055 if (be_cmd_mccq_create(ctrl, q, cq))
1056 goto mcc_q_free;
1057
1058 return 0;
1059
1060 mcc_q_free:
1061 be_queue_free(adapter, q);
1062 mcc_cq_destroy:
1063 be_cmd_q_destroy(ctrl, cq, QTYPE_CQ);
1064 mcc_cq_free:
1065 be_queue_free(adapter, cq);
1066 err:
1067 return -1;
1068 }
1069
1070 static void be_tx_queues_destroy(struct be_adapter *adapter)
1071 {
1072 struct be_queue_info *q;
1073
1074 q = &adapter->tx_obj.q;
1075 if (q->created) {
1076 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_TXQ);
1077
1078 /* No more tx completions can be rcvd now; clean up if there
1079 * are any pending completions or pending tx requests */
1080 be_tx_q_clean(adapter);
1081 }
1082 be_queue_free(adapter, q);
1083
1084 q = &adapter->tx_obj.cq;
1085 if (q->created)
1086 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_CQ);
1087 be_queue_free(adapter, q);
1088
1089 q = &adapter->tx_eq.q;
1090 if (q->created)
1091 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_EQ);
1092 be_queue_free(adapter, q);
1093 }
1094
1095 static int be_tx_queues_create(struct be_adapter *adapter)
1096 {
1097 struct be_queue_info *eq, *q, *cq;
1098
1099 adapter->tx_eq.max_eqd = 0;
1100 adapter->tx_eq.min_eqd = 0;
1101 adapter->tx_eq.cur_eqd = 96;
1102 adapter->tx_eq.enable_aic = false;
1103 /* Alloc Tx Event queue */
1104 eq = &adapter->tx_eq.q;
1105 if (be_queue_alloc(adapter, eq, EVNT_Q_LEN, sizeof(struct be_eq_entry)))
1106 return -1;
1107
1108 /* Ask BE to create Tx Event queue */
1109 if (be_cmd_eq_create(&adapter->ctrl, eq, adapter->tx_eq.cur_eqd))
1110 goto tx_eq_free;
1111 /* Alloc TX eth compl queue */
1112 cq = &adapter->tx_obj.cq;
1113 if (be_queue_alloc(adapter, cq, TX_CQ_LEN,
1114 sizeof(struct be_eth_tx_compl)))
1115 goto tx_eq_destroy;
1116
1117 /* Ask BE to create Tx eth compl queue */
1118 if (be_cmd_cq_create(&adapter->ctrl, cq, eq, false, false, 3))
1119 goto tx_cq_free;
1120
1121 /* Alloc TX eth queue */
1122 q = &adapter->tx_obj.q;
1123 if (be_queue_alloc(adapter, q, TX_Q_LEN, sizeof(struct be_eth_wrb)))
1124 goto tx_cq_destroy;
1125
1126 /* Ask BE to create Tx eth queue */
1127 if (be_cmd_txq_create(&adapter->ctrl, q, cq))
1128 goto tx_q_free;
1129 return 0;
1130
1131 tx_q_free:
1132 be_queue_free(adapter, q);
1133 tx_cq_destroy:
1134 be_cmd_q_destroy(&adapter->ctrl, cq, QTYPE_CQ);
1135 tx_cq_free:
1136 be_queue_free(adapter, cq);
1137 tx_eq_destroy:
1138 be_cmd_q_destroy(&adapter->ctrl, eq, QTYPE_EQ);
1139 tx_eq_free:
1140 be_queue_free(adapter, eq);
1141 return -1;
1142 }
1143
1144 static void be_rx_queues_destroy(struct be_adapter *adapter)
1145 {
1146 struct be_queue_info *q;
1147
1148 q = &adapter->rx_obj.q;
1149 if (q->created) {
1150 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_RXQ);
1151 be_rx_q_clean(adapter);
1152 }
1153 be_queue_free(adapter, q);
1154
1155 q = &adapter->rx_obj.cq;
1156 if (q->created)
1157 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_CQ);
1158 be_queue_free(adapter, q);
1159
1160 q = &adapter->rx_eq.q;
1161 if (q->created)
1162 be_cmd_q_destroy(&adapter->ctrl, q, QTYPE_EQ);
1163 be_queue_free(adapter, q);
1164 }
1165
1166 static int be_rx_queues_create(struct be_adapter *adapter)
1167 {
1168 struct be_queue_info *eq, *q, *cq;
1169 int rc;
1170
1171 adapter->max_rx_coal = BE_MAX_FRAGS_PER_FRAME;
1172 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1173 adapter->rx_eq.max_eqd = BE_MAX_EQD;
1174 adapter->rx_eq.min_eqd = 0;
1175 adapter->rx_eq.cur_eqd = 0;
1176 adapter->rx_eq.enable_aic = true;
1177
1178 /* Alloc Rx Event queue */
1179 eq = &adapter->rx_eq.q;
1180 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1181 sizeof(struct be_eq_entry));
1182 if (rc)
1183 return rc;
1184
1185 /* Ask BE to create Rx Event queue */
1186 rc = be_cmd_eq_create(&adapter->ctrl, eq, adapter->rx_eq.cur_eqd);
1187 if (rc)
1188 goto rx_eq_free;
1189
1190 /* Alloc RX eth compl queue */
1191 cq = &adapter->rx_obj.cq;
1192 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
1193 sizeof(struct be_eth_rx_compl));
1194 if (rc)
1195 goto rx_eq_destroy;
1196
1197 /* Ask BE to create Rx eth compl queue */
1198 rc = be_cmd_cq_create(&adapter->ctrl, cq, eq, false, false, 3);
1199 if (rc)
1200 goto rx_cq_free;
1201
1202 /* Alloc RX eth queue */
1203 q = &adapter->rx_obj.q;
1204 rc = be_queue_alloc(adapter, q, RX_Q_LEN, sizeof(struct be_eth_rx_d));
1205 if (rc)
1206 goto rx_cq_destroy;
1207
1208 /* Ask BE to create Rx eth queue */
1209 rc = be_cmd_rxq_create(&adapter->ctrl, q, cq->id, rx_frag_size,
1210 BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle, false);
1211 if (rc)
1212 goto rx_q_free;
1213
1214 return 0;
1215 rx_q_free:
1216 be_queue_free(adapter, q);
1217 rx_cq_destroy:
1218 be_cmd_q_destroy(&adapter->ctrl, cq, QTYPE_CQ);
1219 rx_cq_free:
1220 be_queue_free(adapter, cq);
1221 rx_eq_destroy:
1222 be_cmd_q_destroy(&adapter->ctrl, eq, QTYPE_EQ);
1223 rx_eq_free:
1224 be_queue_free(adapter, eq);
1225 return rc;
1226 }
1227 static bool event_get(struct be_eq_obj *eq_obj, u16 *rid)
1228 {
1229 struct be_eq_entry *entry = queue_tail_node(&eq_obj->q);
1230 u32 evt = entry->evt;
1231
1232 if (!evt)
1233 return false;
1234
1235 evt = le32_to_cpu(evt);
1236 *rid = (evt >> EQ_ENTRY_RES_ID_SHIFT) & EQ_ENTRY_RES_ID_MASK;
1237 entry->evt = 0;
1238 queue_tail_inc(&eq_obj->q);
1239 return true;
1240 }
1241
1242 static int event_handle(struct be_ctrl_info *ctrl,
1243 struct be_eq_obj *eq_obj)
1244 {
1245 u16 rid = 0, num = 0;
1246
1247 while (event_get(eq_obj, &rid))
1248 num++;
1249
1250 /* We can see an interrupt and no event */
1251 be_eq_notify(ctrl, eq_obj->q.id, true, true, num);
1252 if (num)
1253 napi_schedule(&eq_obj->napi);
1254
1255 return num;
1256 }
1257
1258 static irqreturn_t be_intx(int irq, void *dev)
1259 {
1260 struct be_adapter *adapter = dev;
1261 struct be_ctrl_info *ctrl = &adapter->ctrl;
1262 int rx, tx;
1263
1264 tx = event_handle(ctrl, &adapter->tx_eq);
1265 rx = event_handle(ctrl, &adapter->rx_eq);
1266
1267 if (rx || tx)
1268 return IRQ_HANDLED;
1269 else
1270 return IRQ_NONE;
1271 }
1272
1273 static irqreturn_t be_msix_rx(int irq, void *dev)
1274 {
1275 struct be_adapter *adapter = dev;
1276
1277 event_handle(&adapter->ctrl, &adapter->rx_eq);
1278
1279 return IRQ_HANDLED;
1280 }
1281
1282 static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
1283 {
1284 struct be_adapter *adapter = dev;
1285
1286 event_handle(&adapter->ctrl, &adapter->tx_eq);
1287
1288 return IRQ_HANDLED;
1289 }
1290
1291 static inline bool do_lro(struct be_adapter *adapter,
1292 struct be_eth_rx_compl *rxcp)
1293 {
1294 int err = AMAP_GET_BITS(struct amap_eth_rx_compl, err, rxcp);
1295 int tcp_frame = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
1296
1297 if (err)
1298 drvr_stats(adapter)->be_rxcp_err++;
1299
1300 return (!tcp_frame || err || (adapter->max_rx_coal <= 1)) ?
1301 false : true;
1302 }
1303
1304 int be_poll_rx(struct napi_struct *napi, int budget)
1305 {
1306 struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1307 struct be_adapter *adapter =
1308 container_of(rx_eq, struct be_adapter, rx_eq);
1309 struct be_queue_info *rx_cq = &adapter->rx_obj.cq;
1310 struct be_eth_rx_compl *rxcp;
1311 u32 work_done;
1312
1313 for (work_done = 0; work_done < budget; work_done++) {
1314 rxcp = be_rx_compl_get(adapter);
1315 if (!rxcp)
1316 break;
1317
1318 if (do_lro(adapter, rxcp))
1319 be_rx_compl_process_lro(adapter, rxcp);
1320 else
1321 be_rx_compl_process(adapter, rxcp);
1322
1323 be_rx_compl_reset(rxcp);
1324 }
1325
1326 lro_flush_all(&adapter->rx_obj.lro_mgr);
1327
1328 /* Refill the queue */
1329 if (atomic_read(&adapter->rx_obj.q.used) < RX_FRAGS_REFILL_WM)
1330 be_post_rx_frags(adapter);
1331
1332 /* All consumed */
1333 if (work_done < budget) {
1334 napi_complete(napi);
1335 be_cq_notify(&adapter->ctrl, rx_cq->id, true, work_done);
1336 } else {
1337 /* More to be consumed; continue with interrupts disabled */
1338 be_cq_notify(&adapter->ctrl, rx_cq->id, false, work_done);
1339 }
1340 return work_done;
1341 }
1342
1343 void be_process_tx(struct be_adapter *adapter)
1344 {
1345 struct be_queue_info *txq = &adapter->tx_obj.q;
1346 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
1347 struct be_eth_tx_compl *txcp;
1348 u32 num_cmpl = 0;
1349 u16 end_idx;
1350
1351 while ((txcp = be_tx_compl_get(tx_cq))) {
1352 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1353 wrb_index, txcp);
1354 be_tx_compl_process(adapter, end_idx);
1355 num_cmpl++;
1356 }
1357
1358 if (num_cmpl) {
1359 be_cq_notify(&adapter->ctrl, tx_cq->id, true, num_cmpl);
1360
1361 /* As Tx wrbs have been freed up, wake up netdev queue if
1362 * it was stopped due to lack of tx wrbs.
1363 */
1364 if (netif_queue_stopped(adapter->netdev) &&
1365 atomic_read(&txq->used) < txq->len / 2) {
1366 netif_wake_queue(adapter->netdev);
1367 }
1368
1369 drvr_stats(adapter)->be_tx_events++;
1370 drvr_stats(adapter)->be_tx_compl += num_cmpl;
1371 }
1372 }
1373
1374 /* As TX and MCC share the same EQ check for both TX and MCC completions.
1375 * For TX/MCC we don't honour budget; consume everything
1376 */
1377 static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
1378 {
1379 struct be_eq_obj *tx_eq = container_of(napi, struct be_eq_obj, napi);
1380 struct be_adapter *adapter =
1381 container_of(tx_eq, struct be_adapter, tx_eq);
1382
1383 napi_complete(napi);
1384
1385 be_process_tx(adapter);
1386
1387 be_process_mcc(&adapter->ctrl);
1388
1389 return 1;
1390 }
1391
1392 static void be_worker(struct work_struct *work)
1393 {
1394 struct be_adapter *adapter =
1395 container_of(work, struct be_adapter, work.work);
1396 int status;
1397
1398 /* Check link */
1399 be_link_status_update(adapter);
1400
1401 /* Get Stats */
1402 status = be_cmd_get_stats(&adapter->ctrl, &adapter->stats.cmd);
1403 if (!status)
1404 netdev_stats_update(adapter);
1405
1406 /* Set EQ delay */
1407 be_rx_eqd_update(adapter);
1408
1409 be_tx_rate_update(adapter);
1410 be_rx_rate_update(adapter);
1411
1412 if (adapter->rx_post_starved) {
1413 adapter->rx_post_starved = false;
1414 be_post_rx_frags(adapter);
1415 }
1416
1417 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
1418 }
1419
1420 static void be_msix_enable(struct be_adapter *adapter)
1421 {
1422 int i, status;
1423
1424 for (i = 0; i < BE_NUM_MSIX_VECTORS; i++)
1425 adapter->msix_entries[i].entry = i;
1426
1427 status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
1428 BE_NUM_MSIX_VECTORS);
1429 if (status == 0)
1430 adapter->msix_enabled = true;
1431 return;
1432 }
1433
1434 static inline int be_msix_vec_get(struct be_adapter *adapter, u32 eq_id)
1435 {
1436 return adapter->msix_entries[eq_id -
1437 8 * adapter->ctrl.pci_func].vector;
1438 }
1439
1440 static int be_msix_register(struct be_adapter *adapter)
1441 {
1442 struct net_device *netdev = adapter->netdev;
1443 struct be_eq_obj *tx_eq = &adapter->tx_eq;
1444 struct be_eq_obj *rx_eq = &adapter->rx_eq;
1445 int status, vec;
1446
1447 sprintf(tx_eq->desc, "%s-tx", netdev->name);
1448 vec = be_msix_vec_get(adapter, tx_eq->q.id);
1449 status = request_irq(vec, be_msix_tx_mcc, 0, tx_eq->desc, adapter);
1450 if (status)
1451 goto err;
1452
1453 sprintf(rx_eq->desc, "%s-rx", netdev->name);
1454 vec = be_msix_vec_get(adapter, rx_eq->q.id);
1455 status = request_irq(vec, be_msix_rx, 0, rx_eq->desc, adapter);
1456 if (status) { /* Free TX IRQ */
1457 vec = be_msix_vec_get(adapter, tx_eq->q.id);
1458 free_irq(vec, adapter);
1459 goto err;
1460 }
1461 return 0;
1462 err:
1463 dev_warn(&adapter->pdev->dev,
1464 "MSIX Request IRQ failed - err %d\n", status);
1465 pci_disable_msix(adapter->pdev);
1466 adapter->msix_enabled = false;
1467 return status;
1468 }
1469
1470 static int be_irq_register(struct be_adapter *adapter)
1471 {
1472 struct net_device *netdev = adapter->netdev;
1473 int status;
1474
1475 if (adapter->msix_enabled) {
1476 status = be_msix_register(adapter);
1477 if (status == 0)
1478 goto done;
1479 }
1480
1481 /* INTx */
1482 netdev->irq = adapter->pdev->irq;
1483 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
1484 adapter);
1485 if (status) {
1486 dev_err(&adapter->pdev->dev,
1487 "INTx request IRQ failed - err %d\n", status);
1488 return status;
1489 }
1490 done:
1491 adapter->isr_registered = true;
1492 return 0;
1493 }
1494
1495 static void be_irq_unregister(struct be_adapter *adapter)
1496 {
1497 struct net_device *netdev = adapter->netdev;
1498 int vec;
1499
1500 if (!adapter->isr_registered)
1501 return;
1502
1503 /* INTx */
1504 if (!adapter->msix_enabled) {
1505 free_irq(netdev->irq, adapter);
1506 goto done;
1507 }
1508
1509 /* MSIx */
1510 vec = be_msix_vec_get(adapter, adapter->tx_eq.q.id);
1511 free_irq(vec, adapter);
1512 vec = be_msix_vec_get(adapter, adapter->rx_eq.q.id);
1513 free_irq(vec, adapter);
1514 done:
1515 adapter->isr_registered = false;
1516 return;
1517 }
1518
1519 static int be_open(struct net_device *netdev)
1520 {
1521 struct be_adapter *adapter = netdev_priv(netdev);
1522 struct be_ctrl_info *ctrl = &adapter->ctrl;
1523 struct be_eq_obj *rx_eq = &adapter->rx_eq;
1524 struct be_eq_obj *tx_eq = &adapter->tx_eq;
1525
1526 /* First time posting */
1527 be_post_rx_frags(adapter);
1528
1529 napi_enable(&rx_eq->napi);
1530 napi_enable(&tx_eq->napi);
1531
1532 be_irq_register(adapter);
1533
1534 be_intr_set(ctrl, true);
1535
1536 /* The evt queues are created in unarmed state; arm them */
1537 be_eq_notify(ctrl, rx_eq->q.id, true, false, 0);
1538 be_eq_notify(ctrl, tx_eq->q.id, true, false, 0);
1539
1540 /* Rx compl queue may be in unarmed state; rearm it */
1541 be_cq_notify(ctrl, adapter->rx_obj.cq.id, true, 0);
1542
1543 be_link_status_update(adapter);
1544
1545 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
1546 return 0;
1547 }
1548
1549 static int be_setup(struct be_adapter *adapter)
1550 {
1551 struct be_ctrl_info *ctrl = &adapter->ctrl;
1552 struct net_device *netdev = adapter->netdev;
1553 u32 if_flags;
1554 int status;
1555
1556 if_flags = BE_IF_FLAGS_BROADCAST | BE_IF_FLAGS_PROMISCUOUS |
1557 BE_IF_FLAGS_MCAST_PROMISCUOUS | BE_IF_FLAGS_UNTAGGED |
1558 BE_IF_FLAGS_PASS_L3L4_ERRORS;
1559 status = be_cmd_if_create(ctrl, if_flags, netdev->dev_addr,
1560 false/* pmac_invalid */, &adapter->if_handle,
1561 &adapter->pmac_id);
1562 if (status != 0)
1563 goto do_none;
1564
1565 be_vid_config(netdev);
1566
1567 status = be_cmd_set_flow_control(ctrl, true, true);
1568 if (status != 0)
1569 goto if_destroy;
1570
1571 status = be_tx_queues_create(adapter);
1572 if (status != 0)
1573 goto if_destroy;
1574
1575 status = be_rx_queues_create(adapter);
1576 if (status != 0)
1577 goto tx_qs_destroy;
1578
1579 status = be_mcc_queues_create(adapter);
1580 if (status != 0)
1581 goto rx_qs_destroy;
1582
1583 return 0;
1584
1585 rx_qs_destroy:
1586 be_rx_queues_destroy(adapter);
1587 tx_qs_destroy:
1588 be_tx_queues_destroy(adapter);
1589 if_destroy:
1590 be_cmd_if_destroy(ctrl, adapter->if_handle);
1591 do_none:
1592 return status;
1593 }
1594
1595 static int be_clear(struct be_adapter *adapter)
1596 {
1597 struct be_ctrl_info *ctrl = &adapter->ctrl;
1598
1599 be_rx_queues_destroy(adapter);
1600 be_tx_queues_destroy(adapter);
1601
1602 be_cmd_if_destroy(ctrl, adapter->if_handle);
1603
1604 be_mcc_queues_destroy(adapter);
1605 return 0;
1606 }
1607
1608 static int be_close(struct net_device *netdev)
1609 {
1610 struct be_adapter *adapter = netdev_priv(netdev);
1611 struct be_ctrl_info *ctrl = &adapter->ctrl;
1612 struct be_eq_obj *rx_eq = &adapter->rx_eq;
1613 struct be_eq_obj *tx_eq = &adapter->tx_eq;
1614 int vec;
1615
1616 cancel_delayed_work_sync(&adapter->work);
1617
1618 netif_stop_queue(netdev);
1619 netif_carrier_off(netdev);
1620 adapter->link.speed = PHY_LINK_SPEED_ZERO;
1621
1622 be_intr_set(ctrl, false);
1623
1624 if (adapter->msix_enabled) {
1625 vec = be_msix_vec_get(adapter, tx_eq->q.id);
1626 synchronize_irq(vec);
1627 vec = be_msix_vec_get(adapter, rx_eq->q.id);
1628 synchronize_irq(vec);
1629 } else {
1630 synchronize_irq(netdev->irq);
1631 }
1632 be_irq_unregister(adapter);
1633
1634 napi_disable(&rx_eq->napi);
1635 napi_disable(&tx_eq->napi);
1636
1637 return 0;
1638 }
1639
1640 static int be_get_frag_header(struct skb_frag_struct *frag, void **mac_hdr,
1641 void **ip_hdr, void **tcpudp_hdr,
1642 u64 *hdr_flags, void *priv)
1643 {
1644 struct ethhdr *eh;
1645 struct vlan_ethhdr *veh;
1646 struct iphdr *iph;
1647 u8 *va = page_address(frag->page) + frag->page_offset;
1648 unsigned long ll_hlen;
1649
1650 prefetch(va);
1651 eh = (struct ethhdr *)va;
1652 *mac_hdr = eh;
1653 ll_hlen = ETH_HLEN;
1654 if (eh->h_proto != htons(ETH_P_IP)) {
1655 if (eh->h_proto == htons(ETH_P_8021Q)) {
1656 veh = (struct vlan_ethhdr *)va;
1657 if (veh->h_vlan_encapsulated_proto != htons(ETH_P_IP))
1658 return -1;
1659
1660 ll_hlen += VLAN_HLEN;
1661 } else {
1662 return -1;
1663 }
1664 }
1665 *hdr_flags = LRO_IPV4;
1666 iph = (struct iphdr *)(va + ll_hlen);
1667 *ip_hdr = iph;
1668 if (iph->protocol != IPPROTO_TCP)
1669 return -1;
1670 *hdr_flags |= LRO_TCP;
1671 *tcpudp_hdr = (u8 *) (*ip_hdr) + (iph->ihl << 2);
1672
1673 return 0;
1674 }
1675
1676 static void be_lro_init(struct be_adapter *adapter, struct net_device *netdev)
1677 {
1678 struct net_lro_mgr *lro_mgr;
1679
1680 lro_mgr = &adapter->rx_obj.lro_mgr;
1681 lro_mgr->dev = netdev;
1682 lro_mgr->features = LRO_F_NAPI;
1683 lro_mgr->ip_summed = CHECKSUM_UNNECESSARY;
1684 lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY;
1685 lro_mgr->max_desc = BE_MAX_LRO_DESCRIPTORS;
1686 lro_mgr->lro_arr = adapter->rx_obj.lro_desc;
1687 lro_mgr->get_frag_header = be_get_frag_header;
1688 lro_mgr->max_aggr = BE_MAX_FRAGS_PER_FRAME;
1689 }
1690
1691 static struct net_device_ops be_netdev_ops = {
1692 .ndo_open = be_open,
1693 .ndo_stop = be_close,
1694 .ndo_start_xmit = be_xmit,
1695 .ndo_get_stats = be_get_stats,
1696 .ndo_set_rx_mode = be_set_multicast_list,
1697 .ndo_set_mac_address = be_mac_addr_set,
1698 .ndo_change_mtu = be_change_mtu,
1699 .ndo_validate_addr = eth_validate_addr,
1700 .ndo_vlan_rx_register = be_vlan_register,
1701 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
1702 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
1703 };
1704
1705 static void be_netdev_init(struct net_device *netdev)
1706 {
1707 struct be_adapter *adapter = netdev_priv(netdev);
1708
1709 netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
1710 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM |
1711 NETIF_F_IPV6_CSUM;
1712
1713 netdev->flags |= IFF_MULTICAST;
1714
1715 adapter->rx_csum = true;
1716
1717 BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
1718
1719 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
1720
1721 be_lro_init(adapter, netdev);
1722
1723 netif_napi_add(netdev, &adapter->rx_eq.napi, be_poll_rx,
1724 BE_NAPI_WEIGHT);
1725 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
1726 BE_NAPI_WEIGHT);
1727
1728 netif_carrier_off(netdev);
1729 netif_stop_queue(netdev);
1730 }
1731
1732 static void be_unmap_pci_bars(struct be_adapter *adapter)
1733 {
1734 struct be_ctrl_info *ctrl = &adapter->ctrl;
1735 if (ctrl->csr)
1736 iounmap(ctrl->csr);
1737 if (ctrl->db)
1738 iounmap(ctrl->db);
1739 if (ctrl->pcicfg)
1740 iounmap(ctrl->pcicfg);
1741 }
1742
1743 static int be_map_pci_bars(struct be_adapter *adapter)
1744 {
1745 u8 __iomem *addr;
1746
1747 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
1748 pci_resource_len(adapter->pdev, 2));
1749 if (addr == NULL)
1750 return -ENOMEM;
1751 adapter->ctrl.csr = addr;
1752
1753 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 4),
1754 128 * 1024);
1755 if (addr == NULL)
1756 goto pci_map_err;
1757 adapter->ctrl.db = addr;
1758
1759 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 1),
1760 pci_resource_len(adapter->pdev, 1));
1761 if (addr == NULL)
1762 goto pci_map_err;
1763 adapter->ctrl.pcicfg = addr;
1764
1765 return 0;
1766 pci_map_err:
1767 be_unmap_pci_bars(adapter);
1768 return -ENOMEM;
1769 }
1770
1771
1772 static void be_ctrl_cleanup(struct be_adapter *adapter)
1773 {
1774 struct be_dma_mem *mem = &adapter->ctrl.mbox_mem_alloced;
1775
1776 be_unmap_pci_bars(adapter);
1777
1778 if (mem->va)
1779 pci_free_consistent(adapter->pdev, mem->size,
1780 mem->va, mem->dma);
1781 }
1782
1783 /* Initialize the mbox required to send cmds to BE */
1784 static int be_ctrl_init(struct be_adapter *adapter)
1785 {
1786 struct be_ctrl_info *ctrl = &adapter->ctrl;
1787 struct be_dma_mem *mbox_mem_alloc = &ctrl->mbox_mem_alloced;
1788 struct be_dma_mem *mbox_mem_align = &ctrl->mbox_mem;
1789 int status;
1790 u32 val;
1791
1792 status = be_map_pci_bars(adapter);
1793 if (status)
1794 return status;
1795
1796 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
1797 mbox_mem_alloc->va = pci_alloc_consistent(adapter->pdev,
1798 mbox_mem_alloc->size, &mbox_mem_alloc->dma);
1799 if (!mbox_mem_alloc->va) {
1800 be_unmap_pci_bars(adapter);
1801 return -1;
1802 }
1803 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
1804 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
1805 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
1806 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
1807 spin_lock_init(&ctrl->mbox_lock);
1808 spin_lock_init(&ctrl->mcc_lock);
1809 spin_lock_init(&ctrl->mcc_cq_lock);
1810
1811 val = ioread32(ctrl->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
1812 ctrl->pci_func = (val >> MEMBAR_CTRL_INT_CTRL_PFUNC_SHIFT) &
1813 MEMBAR_CTRL_INT_CTRL_PFUNC_MASK;
1814 return 0;
1815 }
1816
1817 static void be_stats_cleanup(struct be_adapter *adapter)
1818 {
1819 struct be_stats_obj *stats = &adapter->stats;
1820 struct be_dma_mem *cmd = &stats->cmd;
1821
1822 if (cmd->va)
1823 pci_free_consistent(adapter->pdev, cmd->size,
1824 cmd->va, cmd->dma);
1825 }
1826
1827 static int be_stats_init(struct be_adapter *adapter)
1828 {
1829 struct be_stats_obj *stats = &adapter->stats;
1830 struct be_dma_mem *cmd = &stats->cmd;
1831
1832 cmd->size = sizeof(struct be_cmd_req_get_stats);
1833 cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma);
1834 if (cmd->va == NULL)
1835 return -1;
1836 return 0;
1837 }
1838
1839 static void __devexit be_remove(struct pci_dev *pdev)
1840 {
1841 struct be_adapter *adapter = pci_get_drvdata(pdev);
1842 if (!adapter)
1843 return;
1844
1845 unregister_netdev(adapter->netdev);
1846
1847 be_clear(adapter);
1848
1849 be_stats_cleanup(adapter);
1850
1851 be_ctrl_cleanup(adapter);
1852
1853 if (adapter->msix_enabled) {
1854 pci_disable_msix(adapter->pdev);
1855 adapter->msix_enabled = false;
1856 }
1857
1858 pci_set_drvdata(pdev, NULL);
1859 pci_release_regions(pdev);
1860 pci_disable_device(pdev);
1861
1862 free_netdev(adapter->netdev);
1863 }
1864
1865 static int be_hw_up(struct be_adapter *adapter)
1866 {
1867 struct be_ctrl_info *ctrl = &adapter->ctrl;
1868 int status;
1869
1870 status = be_cmd_POST(ctrl);
1871 if (status)
1872 return status;
1873
1874 status = be_cmd_get_fw_ver(ctrl, adapter->fw_ver);
1875 if (status)
1876 return status;
1877
1878 status = be_cmd_query_fw_cfg(ctrl, &adapter->port_num);
1879 return status;
1880 }
1881
1882 static int __devinit be_probe(struct pci_dev *pdev,
1883 const struct pci_device_id *pdev_id)
1884 {
1885 int status = 0;
1886 struct be_adapter *adapter;
1887 struct net_device *netdev;
1888 struct be_ctrl_info *ctrl;
1889 u8 mac[ETH_ALEN];
1890
1891 status = pci_enable_device(pdev);
1892 if (status)
1893 goto do_none;
1894
1895 status = pci_request_regions(pdev, DRV_NAME);
1896 if (status)
1897 goto disable_dev;
1898 pci_set_master(pdev);
1899
1900 netdev = alloc_etherdev(sizeof(struct be_adapter));
1901 if (netdev == NULL) {
1902 status = -ENOMEM;
1903 goto rel_reg;
1904 }
1905 adapter = netdev_priv(netdev);
1906 adapter->pdev = pdev;
1907 pci_set_drvdata(pdev, adapter);
1908 adapter->netdev = netdev;
1909
1910 be_msix_enable(adapter);
1911
1912 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
1913 if (!status) {
1914 netdev->features |= NETIF_F_HIGHDMA;
1915 } else {
1916 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1917 if (status) {
1918 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
1919 goto free_netdev;
1920 }
1921 }
1922
1923 ctrl = &adapter->ctrl;
1924 status = be_ctrl_init(adapter);
1925 if (status)
1926 goto free_netdev;
1927
1928 status = be_stats_init(adapter);
1929 if (status)
1930 goto ctrl_clean;
1931
1932 status = be_hw_up(adapter);
1933 if (status)
1934 goto stats_clean;
1935
1936 status = be_cmd_mac_addr_query(ctrl, mac, MAC_ADDRESS_TYPE_NETWORK,
1937 true /* permanent */, 0);
1938 if (status)
1939 goto stats_clean;
1940 memcpy(netdev->dev_addr, mac, ETH_ALEN);
1941
1942 INIT_DELAYED_WORK(&adapter->work, be_worker);
1943 be_netdev_init(netdev);
1944 SET_NETDEV_DEV(netdev, &adapter->pdev->dev);
1945
1946 status = be_setup(adapter);
1947 if (status)
1948 goto stats_clean;
1949 status = register_netdev(netdev);
1950 if (status != 0)
1951 goto unsetup;
1952
1953 dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
1954 return 0;
1955
1956 unsetup:
1957 be_clear(adapter);
1958 stats_clean:
1959 be_stats_cleanup(adapter);
1960 ctrl_clean:
1961 be_ctrl_cleanup(adapter);
1962 free_netdev:
1963 free_netdev(adapter->netdev);
1964 rel_reg:
1965 pci_release_regions(pdev);
1966 disable_dev:
1967 pci_disable_device(pdev);
1968 do_none:
1969 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
1970 return status;
1971 }
1972
1973 static int be_suspend(struct pci_dev *pdev, pm_message_t state)
1974 {
1975 struct be_adapter *adapter = pci_get_drvdata(pdev);
1976 struct net_device *netdev = adapter->netdev;
1977
1978 netif_device_detach(netdev);
1979 if (netif_running(netdev)) {
1980 rtnl_lock();
1981 be_close(netdev);
1982 be_clear(adapter);
1983 rtnl_unlock();
1984 }
1985
1986 pci_save_state(pdev);
1987 pci_disable_device(pdev);
1988 pci_set_power_state(pdev, pci_choose_state(pdev, state));
1989 return 0;
1990 }
1991
1992 static int be_resume(struct pci_dev *pdev)
1993 {
1994 int status = 0;
1995 struct be_adapter *adapter = pci_get_drvdata(pdev);
1996 struct net_device *netdev = adapter->netdev;
1997
1998 netif_device_detach(netdev);
1999
2000 status = pci_enable_device(pdev);
2001 if (status)
2002 return status;
2003
2004 pci_set_power_state(pdev, 0);
2005 pci_restore_state(pdev);
2006
2007 if (netif_running(netdev)) {
2008 rtnl_lock();
2009 be_setup(adapter);
2010 be_open(netdev);
2011 rtnl_unlock();
2012 }
2013 netif_device_attach(netdev);
2014 return 0;
2015 }
2016
2017 static struct pci_driver be_driver = {
2018 .name = DRV_NAME,
2019 .id_table = be_dev_ids,
2020 .probe = be_probe,
2021 .remove = be_remove,
2022 .suspend = be_suspend,
2023 .resume = be_resume
2024 };
2025
2026 static int __init be_init_module(void)
2027 {
2028 if (rx_frag_size != 8192 && rx_frag_size != 4096
2029 && rx_frag_size != 2048) {
2030 printk(KERN_WARNING DRV_NAME
2031 " : Module param rx_frag_size must be 2048/4096/8192."
2032 " Using 2048\n");
2033 rx_frag_size = 2048;
2034 }
2035 /* Ensure rx_frag_size is aligned to chache line */
2036 if (SKB_DATA_ALIGN(rx_frag_size) != rx_frag_size) {
2037 printk(KERN_WARNING DRV_NAME
2038 " : Bad module param rx_frag_size. Using 2048\n");
2039 rx_frag_size = 2048;
2040 }
2041
2042 return pci_register_driver(&be_driver);
2043 }
2044 module_init(be_init_module);
2045
2046 static void __exit be_exit_module(void)
2047 {
2048 pci_unregister_driver(&be_driver);
2049 }
2050 module_exit(be_exit_module);
kernel-based virtual machine