blob: b89bae029620eaf81d4c560b3231fb084dc7ac5f [file] [log] [blame]
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001/*
Ajit Khaparde294aedc2010-02-19 13:54:58 +00002 * Copyright (C) 2005 - 2010 ServerEngines
Sathya Perla6b7c5b92009-03-11 23:32:03 -07003 * 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"
Sathya Perla8788fdc2009-07-27 22:52:03 +000019#include "be_cmds.h"
Stephen Hemminger65f71b82009-03-27 00:25:24 -070020#include <asm/div64.h>
Sathya Perla6b7c5b92009-03-11 23:32:03 -070021
22MODULE_VERSION(DRV_VER);
23MODULE_DEVICE_TABLE(pci, be_dev_ids);
24MODULE_DESCRIPTION(DRV_DESC " " DRV_VER);
25MODULE_AUTHOR("ServerEngines Corporation");
26MODULE_LICENSE("GPL");
27
28static unsigned int rx_frag_size = 2048;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +000029static unsigned int num_vfs;
Sathya Perla6b7c5b92009-03-11 23:32:03 -070030module_param(rx_frag_size, uint, S_IRUGO);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +000031module_param(num_vfs, uint, S_IRUGO);
Sathya Perla6b7c5b92009-03-11 23:32:03 -070032MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data.");
Sarveshwar Bandiba343c72010-03-31 02:56:12 +000033MODULE_PARM_DESC(num_vfs, "Number of PCI VFs to initialize");
Sathya Perla6b7c5b92009-03-11 23:32:03 -070034
Sathya Perla6b7c5b92009-03-11 23:32:03 -070035static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = {
Ajit Khapardec4ca2372009-05-18 15:38:55 -070036 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
Ajit Khaparde59fd5d82009-10-29 01:11:06 -070037 { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
Ajit Khapardec4ca2372009-05-18 15:38:55 -070038 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
39 { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
Sathya Perla6b7c5b92009-03-11 23:32:03 -070040 { 0 }
41};
42MODULE_DEVICE_TABLE(pci, be_dev_ids);
Ajit Khaparde7c185272010-07-29 06:16:33 +000043/* UE Status Low CSR */
44static char *ue_status_low_desc[] = {
45 "CEV",
46 "CTX",
47 "DBUF",
48 "ERX",
49 "Host",
50 "MPU",
51 "NDMA",
52 "PTC ",
53 "RDMA ",
54 "RXF ",
55 "RXIPS ",
56 "RXULP0 ",
57 "RXULP1 ",
58 "RXULP2 ",
59 "TIM ",
60 "TPOST ",
61 "TPRE ",
62 "TXIPS ",
63 "TXULP0 ",
64 "TXULP1 ",
65 "UC ",
66 "WDMA ",
67 "TXULP2 ",
68 "HOST1 ",
69 "P0_OB_LINK ",
70 "P1_OB_LINK ",
71 "HOST_GPIO ",
72 "MBOX ",
73 "AXGMAC0",
74 "AXGMAC1",
75 "JTAG",
76 "MPU_INTPEND"
77};
78/* UE Status High CSR */
79static char *ue_status_hi_desc[] = {
80 "LPCMEMHOST",
81 "MGMT_MAC",
82 "PCS0ONLINE",
83 "MPU_IRAM",
84 "PCS1ONLINE",
85 "PCTL0",
86 "PCTL1",
87 "PMEM",
88 "RR",
89 "TXPB",
90 "RXPP",
91 "XAUI",
92 "TXP",
93 "ARM",
94 "IPC",
95 "HOST2",
96 "HOST3",
97 "HOST4",
98 "HOST5",
99 "HOST6",
100 "HOST7",
101 "HOST8",
102 "HOST9",
103 "NETC"
104 "Unknown",
105 "Unknown",
106 "Unknown",
107 "Unknown",
108 "Unknown",
109 "Unknown",
110 "Unknown",
111 "Unknown"
112};
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700113
114static void be_queue_free(struct be_adapter *adapter, struct be_queue_info *q)
115{
116 struct be_dma_mem *mem = &q->dma_mem;
117 if (mem->va)
118 pci_free_consistent(adapter->pdev, mem->size,
119 mem->va, mem->dma);
120}
121
122static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
123 u16 len, u16 entry_size)
124{
125 struct be_dma_mem *mem = &q->dma_mem;
126
127 memset(q, 0, sizeof(*q));
128 q->len = len;
129 q->entry_size = entry_size;
130 mem->size = len * entry_size;
131 mem->va = pci_alloc_consistent(adapter->pdev, mem->size, &mem->dma);
132 if (!mem->va)
133 return -1;
134 memset(mem->va, 0, mem->size);
135 return 0;
136}
137
Sathya Perla8788fdc2009-07-27 22:52:03 +0000138static void be_intr_set(struct be_adapter *adapter, bool enable)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700139{
Sathya Perla8788fdc2009-07-27 22:52:03 +0000140 u8 __iomem *addr = adapter->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700141 u32 reg = ioread32(addr);
142 u32 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
Sathya Perla5f0b8492009-07-27 22:52:56 +0000143
Sathya Perlacf588472010-02-14 21:22:01 +0000144 if (adapter->eeh_err)
145 return;
146
Sathya Perla5f0b8492009-07-27 22:52:56 +0000147 if (!enabled && enable)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700148 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
Sathya Perla5f0b8492009-07-27 22:52:56 +0000149 else if (enabled && !enable)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700150 reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
Sathya Perla5f0b8492009-07-27 22:52:56 +0000151 else
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700152 return;
Sathya Perla5f0b8492009-07-27 22:52:56 +0000153
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700154 iowrite32(reg, addr);
155}
156
Sathya Perla8788fdc2009-07-27 22:52:03 +0000157static void be_rxq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700158{
159 u32 val = 0;
160 val |= qid & DB_RQ_RING_ID_MASK;
161 val |= posted << DB_RQ_NUM_POSTED_SHIFT;
Sathya Perlaf3eb62d2010-06-29 00:11:17 +0000162
163 wmb();
Sathya Perla8788fdc2009-07-27 22:52:03 +0000164 iowrite32(val, adapter->db + DB_RQ_OFFSET);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700165}
166
Sathya Perla8788fdc2009-07-27 22:52:03 +0000167static void be_txq_notify(struct be_adapter *adapter, u16 qid, u16 posted)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700168{
169 u32 val = 0;
170 val |= qid & DB_TXULP_RING_ID_MASK;
171 val |= (posted & DB_TXULP_NUM_POSTED_MASK) << DB_TXULP_NUM_POSTED_SHIFT;
Sathya Perlaf3eb62d2010-06-29 00:11:17 +0000172
173 wmb();
Sathya Perla8788fdc2009-07-27 22:52:03 +0000174 iowrite32(val, adapter->db + DB_TXULP1_OFFSET);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700175}
176
Sathya Perla8788fdc2009-07-27 22:52:03 +0000177static void be_eq_notify(struct be_adapter *adapter, u16 qid,
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700178 bool arm, bool clear_int, u16 num_popped)
179{
180 u32 val = 0;
181 val |= qid & DB_EQ_RING_ID_MASK;
Sathya Perlacf588472010-02-14 21:22:01 +0000182
183 if (adapter->eeh_err)
184 return;
185
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700186 if (arm)
187 val |= 1 << DB_EQ_REARM_SHIFT;
188 if (clear_int)
189 val |= 1 << DB_EQ_CLR_SHIFT;
190 val |= 1 << DB_EQ_EVNT_SHIFT;
191 val |= num_popped << DB_EQ_NUM_POPPED_SHIFT;
Sathya Perla8788fdc2009-07-27 22:52:03 +0000192 iowrite32(val, adapter->db + DB_EQ_OFFSET);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700193}
194
Sathya Perla8788fdc2009-07-27 22:52:03 +0000195void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm, u16 num_popped)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700196{
197 u32 val = 0;
198 val |= qid & DB_CQ_RING_ID_MASK;
Sathya Perlacf588472010-02-14 21:22:01 +0000199
200 if (adapter->eeh_err)
201 return;
202
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700203 if (arm)
204 val |= 1 << DB_CQ_REARM_SHIFT;
205 val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
Sathya Perla8788fdc2009-07-27 22:52:03 +0000206 iowrite32(val, adapter->db + DB_CQ_OFFSET);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700207}
208
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700209static int be_mac_addr_set(struct net_device *netdev, void *p)
210{
211 struct be_adapter *adapter = netdev_priv(netdev);
212 struct sockaddr *addr = p;
213 int status = 0;
214
Ajit Khapardeca9e4982009-11-29 17:56:26 +0000215 if (!is_valid_ether_addr(addr->sa_data))
216 return -EADDRNOTAVAIL;
217
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000218 /* MAC addr configuration will be done in hardware for VFs
219 * by their corresponding PFs. Just copy to netdev addr here
220 */
221 if (!be_physfn(adapter))
222 goto netdev_addr;
223
Sathya Perlaa65027e2009-08-17 00:58:04 +0000224 status = be_cmd_pmac_del(adapter, adapter->if_handle, adapter->pmac_id);
225 if (status)
226 return status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700227
Sathya Perlaa65027e2009-08-17 00:58:04 +0000228 status = be_cmd_pmac_add(adapter, (u8 *)addr->sa_data,
229 adapter->if_handle, &adapter->pmac_id);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000230netdev_addr:
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700231 if (!status)
232 memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
233
234 return status;
235}
236
Sathya Perlab31c50a2009-09-17 10:30:13 -0700237void netdev_stats_update(struct be_adapter *adapter)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700238{
239 struct be_hw_stats *hw_stats = hw_stats_from_cmd(adapter->stats.cmd.va);
240 struct be_rxf_stats *rxf_stats = &hw_stats->rxf;
241 struct be_port_rxf_stats *port_stats =
242 &rxf_stats->port[adapter->port_num];
Ajit Khaparde78122a52009-10-07 03:11:20 -0700243 struct net_device_stats *dev_stats = &adapter->netdev->stats;
Sathya Perla68110862009-06-10 02:21:16 +0000244 struct be_erx_stats *erx_stats = &hw_stats->erx;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700245
Ajit Khaparde91992e42010-02-19 13:57:12 +0000246 dev_stats->rx_packets = drvr_stats(adapter)->be_rx_pkts;
247 dev_stats->tx_packets = drvr_stats(adapter)->be_tx_pkts;
248 dev_stats->rx_bytes = drvr_stats(adapter)->be_rx_bytes;
249 dev_stats->tx_bytes = drvr_stats(adapter)->be_tx_bytes;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700250
251 /* bad pkts received */
252 dev_stats->rx_errors = port_stats->rx_crc_errors +
253 port_stats->rx_alignment_symbol_errors +
254 port_stats->rx_in_range_errors +
Sathya Perla68110862009-06-10 02:21:16 +0000255 port_stats->rx_out_range_errors +
256 port_stats->rx_frame_too_long +
257 port_stats->rx_dropped_too_small +
258 port_stats->rx_dropped_too_short +
259 port_stats->rx_dropped_header_too_small +
260 port_stats->rx_dropped_tcp_length +
261 port_stats->rx_dropped_runt +
262 port_stats->rx_tcp_checksum_errs +
263 port_stats->rx_ip_checksum_errs +
264 port_stats->rx_udp_checksum_errs;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700265
Sathya Perla68110862009-06-10 02:21:16 +0000266 /* no space in linux buffers: best possible approximation */
Sathya Perla01ed30d2009-11-22 22:01:31 +0000267 dev_stats->rx_dropped =
268 erx_stats->rx_drops_no_fragments[adapter->rx_obj.q.id];
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700269
270 /* detailed rx errors */
271 dev_stats->rx_length_errors = port_stats->rx_in_range_errors +
Sathya Perla68110862009-06-10 02:21:16 +0000272 port_stats->rx_out_range_errors +
273 port_stats->rx_frame_too_long;
274
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700275 /* receive ring buffer overflow */
276 dev_stats->rx_over_errors = 0;
Sathya Perla68110862009-06-10 02:21:16 +0000277
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700278 dev_stats->rx_crc_errors = port_stats->rx_crc_errors;
279
280 /* frame alignment errors */
281 dev_stats->rx_frame_errors = port_stats->rx_alignment_symbol_errors;
Sathya Perla68110862009-06-10 02:21:16 +0000282
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700283 /* receiver fifo overrun */
284 /* drops_no_pbuf is no per i/f, it's per BE card */
285 dev_stats->rx_fifo_errors = port_stats->rx_fifo_overflow +
286 port_stats->rx_input_fifo_overflow +
287 rxf_stats->rx_drops_no_pbuf;
288 /* receiver missed packetd */
289 dev_stats->rx_missed_errors = 0;
Sathya Perla68110862009-06-10 02:21:16 +0000290
291 /* packet transmit problems */
292 dev_stats->tx_errors = 0;
293
294 /* no space available in linux */
295 dev_stats->tx_dropped = 0;
296
Ajit Khapardec5b9b922009-10-05 02:21:51 +0000297 dev_stats->multicast = port_stats->rx_multicast_frames;
Sathya Perla68110862009-06-10 02:21:16 +0000298 dev_stats->collisions = 0;
299
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700300 /* detailed tx_errors */
301 dev_stats->tx_aborted_errors = 0;
302 dev_stats->tx_carrier_errors = 0;
303 dev_stats->tx_fifo_errors = 0;
304 dev_stats->tx_heartbeat_errors = 0;
305 dev_stats->tx_window_errors = 0;
306}
307
Sathya Perla8788fdc2009-07-27 22:52:03 +0000308void be_link_status_update(struct be_adapter *adapter, bool link_up)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700309{
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700310 struct net_device *netdev = adapter->netdev;
311
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700312 /* If link came up or went down */
Sathya Perlaa8f447b2009-06-18 00:10:27 +0000313 if (adapter->link_up != link_up) {
Ajit Khaparde0dffc832009-11-29 17:57:46 +0000314 adapter->link_speed = -1;
Sathya Perlaa8f447b2009-06-18 00:10:27 +0000315 if (link_up) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700316 netif_start_queue(netdev);
317 netif_carrier_on(netdev);
318 printk(KERN_INFO "%s: Link up\n", netdev->name);
Sathya Perlaa8f447b2009-06-18 00:10:27 +0000319 } else {
320 netif_stop_queue(netdev);
321 netif_carrier_off(netdev);
322 printk(KERN_INFO "%s: Link down\n", netdev->name);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700323 }
Sathya Perlaa8f447b2009-06-18 00:10:27 +0000324 adapter->link_up = link_up;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700325 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700326}
327
328/* Update the EQ delay n BE based on the RX frags consumed / sec */
329static void be_rx_eqd_update(struct be_adapter *adapter)
330{
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700331 struct be_eq_obj *rx_eq = &adapter->rx_eq;
332 struct be_drvr_stats *stats = &adapter->stats.drvr_stats;
Sathya Perla4097f662009-03-24 16:40:13 -0700333 ulong now = jiffies;
334 u32 eqd;
335
336 if (!rx_eq->enable_aic)
337 return;
338
339 /* Wrapped around */
340 if (time_before(now, stats->rx_fps_jiffies)) {
341 stats->rx_fps_jiffies = now;
342 return;
343 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700344
345 /* Update once a second */
Sathya Perla4097f662009-03-24 16:40:13 -0700346 if ((now - stats->rx_fps_jiffies) < HZ)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700347 return;
348
349 stats->be_rx_fps = (stats->be_rx_frags - stats->be_prev_rx_frags) /
Sathya Perla4097f662009-03-24 16:40:13 -0700350 ((now - stats->rx_fps_jiffies) / HZ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700351
Sathya Perla4097f662009-03-24 16:40:13 -0700352 stats->rx_fps_jiffies = now;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700353 stats->be_prev_rx_frags = stats->be_rx_frags;
354 eqd = stats->be_rx_fps / 110000;
355 eqd = eqd << 3;
356 if (eqd > rx_eq->max_eqd)
357 eqd = rx_eq->max_eqd;
358 if (eqd < rx_eq->min_eqd)
359 eqd = rx_eq->min_eqd;
360 if (eqd < 10)
361 eqd = 0;
362 if (eqd != rx_eq->cur_eqd)
Sathya Perla8788fdc2009-07-27 22:52:03 +0000363 be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700364
365 rx_eq->cur_eqd = eqd;
366}
367
Stephen Hemminger65f71b82009-03-27 00:25:24 -0700368static u32 be_calc_rate(u64 bytes, unsigned long ticks)
369{
370 u64 rate = bytes;
371
372 do_div(rate, ticks / HZ);
373 rate <<= 3; /* bytes/sec -> bits/sec */
374 do_div(rate, 1000000ul); /* MB/Sec */
375
376 return rate;
377}
378
Sathya Perla4097f662009-03-24 16:40:13 -0700379static void be_tx_rate_update(struct be_adapter *adapter)
380{
381 struct be_drvr_stats *stats = drvr_stats(adapter);
382 ulong now = jiffies;
383
384 /* Wrapped around? */
385 if (time_before(now, stats->be_tx_jiffies)) {
386 stats->be_tx_jiffies = now;
387 return;
388 }
389
390 /* Update tx rate once in two seconds */
391 if ((now - stats->be_tx_jiffies) > 2 * HZ) {
Stephen Hemminger65f71b82009-03-27 00:25:24 -0700392 stats->be_tx_rate = be_calc_rate(stats->be_tx_bytes
393 - stats->be_tx_bytes_prev,
394 now - stats->be_tx_jiffies);
Sathya Perla4097f662009-03-24 16:40:13 -0700395 stats->be_tx_jiffies = now;
396 stats->be_tx_bytes_prev = stats->be_tx_bytes;
397 }
398}
399
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700400static void be_tx_stats_update(struct be_adapter *adapter,
Ajit Khaparde91992e42010-02-19 13:57:12 +0000401 u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700402{
Sathya Perla4097f662009-03-24 16:40:13 -0700403 struct be_drvr_stats *stats = drvr_stats(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700404 stats->be_tx_reqs++;
405 stats->be_tx_wrbs += wrb_cnt;
406 stats->be_tx_bytes += copied;
Ajit Khaparde91992e42010-02-19 13:57:12 +0000407 stats->be_tx_pkts += (gso_segs ? gso_segs : 1);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700408 if (stopped)
409 stats->be_tx_stops++;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700410}
411
412/* Determine number of WRB entries needed to xmit data in an skb */
413static u32 wrb_cnt_for_skb(struct sk_buff *skb, bool *dummy)
414{
David S. Millerebc8d2a2009-06-09 01:01:31 -0700415 int cnt = (skb->len > skb->data_len);
416
417 cnt += skb_shinfo(skb)->nr_frags;
418
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700419 /* to account for hdr wrb */
420 cnt++;
421 if (cnt & 1) {
422 /* add a dummy to make it an even num */
423 cnt++;
424 *dummy = true;
425 } else
426 *dummy = false;
427 BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
428 return cnt;
429}
430
431static inline void wrb_fill(struct be_eth_wrb *wrb, u64 addr, int len)
432{
433 wrb->frag_pa_hi = upper_32_bits(addr);
434 wrb->frag_pa_lo = addr & 0xFFFFFFFF;
435 wrb->frag_len = len & ETH_WRB_FRAG_LEN_MASK;
436}
437
438static void wrb_fill_hdr(struct be_eth_hdr_wrb *hdr, struct sk_buff *skb,
439 bool vlan, u32 wrb_cnt, u32 len)
440{
441 memset(hdr, 0, sizeof(*hdr));
442
443 AMAP_SET_BITS(struct amap_eth_hdr_wrb, crc, hdr, 1);
444
Ajit Khaparde49e4b842010-06-14 04:56:07 +0000445 if (skb_is_gso(skb)) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700446 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso, hdr, 1);
447 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso_mss,
448 hdr, skb_shinfo(skb)->gso_size);
Ajit Khaparde49e4b842010-06-14 04:56:07 +0000449 if (skb_is_gso_v6(skb))
450 AMAP_SET_BITS(struct amap_eth_hdr_wrb, lso6, hdr, 1);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700451 } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
452 if (is_tcp_pkt(skb))
453 AMAP_SET_BITS(struct amap_eth_hdr_wrb, tcpcs, hdr, 1);
454 else if (is_udp_pkt(skb))
455 AMAP_SET_BITS(struct amap_eth_hdr_wrb, udpcs, hdr, 1);
456 }
457
458 if (vlan && vlan_tx_tag_present(skb)) {
459 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan, hdr, 1);
460 AMAP_SET_BITS(struct amap_eth_hdr_wrb, vlan_tag,
461 hdr, vlan_tx_tag_get(skb));
462 }
463
464 AMAP_SET_BITS(struct amap_eth_hdr_wrb, event, hdr, 1);
465 AMAP_SET_BITS(struct amap_eth_hdr_wrb, complete, hdr, 1);
466 AMAP_SET_BITS(struct amap_eth_hdr_wrb, num_wrb, hdr, wrb_cnt);
467 AMAP_SET_BITS(struct amap_eth_hdr_wrb, len, hdr, len);
468}
469
Sathya Perla7101e112010-03-22 20:41:12 +0000470static void unmap_tx_frag(struct pci_dev *pdev, struct be_eth_wrb *wrb,
471 bool unmap_single)
472{
473 dma_addr_t dma;
474
475 be_dws_le_to_cpu(wrb, sizeof(*wrb));
476
477 dma = (u64)wrb->frag_pa_hi << 32 | (u64)wrb->frag_pa_lo;
FUJITA Tomonorib681ee72010-04-04 21:40:18 +0000478 if (wrb->frag_len) {
Sathya Perla7101e112010-03-22 20:41:12 +0000479 if (unmap_single)
480 pci_unmap_single(pdev, dma, wrb->frag_len,
481 PCI_DMA_TODEVICE);
482 else
483 pci_unmap_page(pdev, dma, wrb->frag_len,
484 PCI_DMA_TODEVICE);
485 }
486}
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700487
488static int make_tx_wrbs(struct be_adapter *adapter,
489 struct sk_buff *skb, u32 wrb_cnt, bool dummy_wrb)
490{
Sathya Perla7101e112010-03-22 20:41:12 +0000491 dma_addr_t busaddr;
492 int i, copied = 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700493 struct pci_dev *pdev = adapter->pdev;
494 struct sk_buff *first_skb = skb;
495 struct be_queue_info *txq = &adapter->tx_obj.q;
496 struct be_eth_wrb *wrb;
497 struct be_eth_hdr_wrb *hdr;
Sathya Perla7101e112010-03-22 20:41:12 +0000498 bool map_single = false;
499 u16 map_head;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700500
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700501 hdr = queue_head_node(txq);
502 queue_head_inc(txq);
Sathya Perla7101e112010-03-22 20:41:12 +0000503 map_head = txq->head;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700504
David S. Millerebc8d2a2009-06-09 01:01:31 -0700505 if (skb->len > skb->data_len) {
Eric Dumazete743d312010-04-14 15:59:40 -0700506 int len = skb_headlen(skb);
Alexander Duycka73b7962009-12-02 16:48:18 +0000507 busaddr = pci_map_single(pdev, skb->data, len,
508 PCI_DMA_TODEVICE);
Sathya Perla7101e112010-03-22 20:41:12 +0000509 if (pci_dma_mapping_error(pdev, busaddr))
510 goto dma_err;
511 map_single = true;
David S. Millerebc8d2a2009-06-09 01:01:31 -0700512 wrb = queue_head_node(txq);
513 wrb_fill(wrb, busaddr, len);
514 be_dws_cpu_to_le(wrb, sizeof(*wrb));
515 queue_head_inc(txq);
516 copied += len;
517 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700518
David S. Millerebc8d2a2009-06-09 01:01:31 -0700519 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
520 struct skb_frag_struct *frag =
521 &skb_shinfo(skb)->frags[i];
Alexander Duycka73b7962009-12-02 16:48:18 +0000522 busaddr = pci_map_page(pdev, frag->page,
523 frag->page_offset,
524 frag->size, PCI_DMA_TODEVICE);
Sathya Perla7101e112010-03-22 20:41:12 +0000525 if (pci_dma_mapping_error(pdev, busaddr))
526 goto dma_err;
David S. Millerebc8d2a2009-06-09 01:01:31 -0700527 wrb = queue_head_node(txq);
528 wrb_fill(wrb, busaddr, frag->size);
529 be_dws_cpu_to_le(wrb, sizeof(*wrb));
530 queue_head_inc(txq);
531 copied += frag->size;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700532 }
533
534 if (dummy_wrb) {
535 wrb = queue_head_node(txq);
536 wrb_fill(wrb, 0, 0);
537 be_dws_cpu_to_le(wrb, sizeof(*wrb));
538 queue_head_inc(txq);
539 }
540
541 wrb_fill_hdr(hdr, first_skb, adapter->vlan_grp ? true : false,
542 wrb_cnt, copied);
543 be_dws_cpu_to_le(hdr, sizeof(*hdr));
544
545 return copied;
Sathya Perla7101e112010-03-22 20:41:12 +0000546dma_err:
547 txq->head = map_head;
548 while (copied) {
549 wrb = queue_head_node(txq);
550 unmap_tx_frag(pdev, wrb, map_single);
551 map_single = false;
552 copied -= wrb->frag_len;
553 queue_head_inc(txq);
554 }
555 return 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700556}
557
Stephen Hemminger613573252009-08-31 19:50:58 +0000558static netdev_tx_t be_xmit(struct sk_buff *skb,
Sathya Perlab31c50a2009-09-17 10:30:13 -0700559 struct net_device *netdev)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700560{
561 struct be_adapter *adapter = netdev_priv(netdev);
562 struct be_tx_obj *tx_obj = &adapter->tx_obj;
563 struct be_queue_info *txq = &tx_obj->q;
564 u32 wrb_cnt = 0, copied = 0;
565 u32 start = txq->head;
566 bool dummy_wrb, stopped = false;
567
568 wrb_cnt = wrb_cnt_for_skb(skb, &dummy_wrb);
569
570 copied = make_tx_wrbs(adapter, skb, wrb_cnt, dummy_wrb);
Ajit Khapardec190e3c2009-09-04 03:12:29 +0000571 if (copied) {
572 /* record the sent skb in the sent_skb table */
573 BUG_ON(tx_obj->sent_skb_list[start]);
574 tx_obj->sent_skb_list[start] = skb;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700575
Ajit Khapardec190e3c2009-09-04 03:12:29 +0000576 /* Ensure txq has space for the next skb; Else stop the queue
577 * *BEFORE* ringing the tx doorbell, so that we serialze the
578 * tx compls of the current transmit which'll wake up the queue
579 */
Sathya Perla7101e112010-03-22 20:41:12 +0000580 atomic_add(wrb_cnt, &txq->used);
Ajit Khapardec190e3c2009-09-04 03:12:29 +0000581 if ((BE_MAX_TX_FRAG_COUNT + atomic_read(&txq->used)) >=
582 txq->len) {
583 netif_stop_queue(netdev);
584 stopped = true;
585 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700586
Ajit Khapardec190e3c2009-09-04 03:12:29 +0000587 be_txq_notify(adapter, txq->id, wrb_cnt);
588
Ajit Khaparde91992e42010-02-19 13:57:12 +0000589 be_tx_stats_update(adapter, wrb_cnt, copied,
590 skb_shinfo(skb)->gso_segs, stopped);
Ajit Khapardec190e3c2009-09-04 03:12:29 +0000591 } else {
592 txq->head = start;
593 dev_kfree_skb_any(skb);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700594 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700595 return NETDEV_TX_OK;
596}
597
598static int be_change_mtu(struct net_device *netdev, int new_mtu)
599{
600 struct be_adapter *adapter = netdev_priv(netdev);
601 if (new_mtu < BE_MIN_MTU ||
Ajit Khaparde34a89b82010-02-09 01:32:43 +0000602 new_mtu > (BE_MAX_JUMBO_FRAME_SIZE -
603 (ETH_HLEN + ETH_FCS_LEN))) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700604 dev_info(&adapter->pdev->dev,
605 "MTU must be between %d and %d bytes\n",
Ajit Khaparde34a89b82010-02-09 01:32:43 +0000606 BE_MIN_MTU,
607 (BE_MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN)));
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700608 return -EINVAL;
609 }
610 dev_info(&adapter->pdev->dev, "MTU changed from %d to %d bytes\n",
611 netdev->mtu, new_mtu);
612 netdev->mtu = new_mtu;
613 return 0;
614}
615
616/*
Ajit Khaparde82903e42010-02-09 01:34:57 +0000617 * A max of 64 (BE_NUM_VLANS_SUPPORTED) vlans can be configured in BE.
618 * If the user configures more, place BE in vlan promiscuous mode.
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700619 */
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000620static int be_vid_config(struct be_adapter *adapter, bool vf, u32 vf_num)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700621{
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700622 u16 vtag[BE_NUM_VLANS_SUPPORTED];
623 u16 ntags = 0, i;
Ajit Khaparde82903e42010-02-09 01:34:57 +0000624 int status = 0;
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000625 u32 if_handle;
626
627 if (vf) {
628 if_handle = adapter->vf_cfg[vf_num].vf_if_handle;
629 vtag[0] = cpu_to_le16(adapter->vf_cfg[vf_num].vf_vlan_tag);
630 status = be_cmd_vlan_config(adapter, if_handle, vtag, 1, 1, 0);
631 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700632
Ajit Khaparde82903e42010-02-09 01:34:57 +0000633 if (adapter->vlans_added <= adapter->max_vlans) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700634 /* Construct VLAN Table to give to HW */
635 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
636 if (adapter->vlan_tag[i]) {
637 vtag[ntags] = cpu_to_le16(i);
638 ntags++;
639 }
640 }
Sathya Perlab31c50a2009-09-17 10:30:13 -0700641 status = be_cmd_vlan_config(adapter, adapter->if_handle,
642 vtag, ntags, 1, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700643 } else {
Sathya Perlab31c50a2009-09-17 10:30:13 -0700644 status = be_cmd_vlan_config(adapter, adapter->if_handle,
645 NULL, 0, 1, 1);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700646 }
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000647
Sathya Perlab31c50a2009-09-17 10:30:13 -0700648 return status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700649}
650
651static void be_vlan_register(struct net_device *netdev, struct vlan_group *grp)
652{
653 struct be_adapter *adapter = netdev_priv(netdev);
654 struct be_eq_obj *rx_eq = &adapter->rx_eq;
655 struct be_eq_obj *tx_eq = &adapter->tx_eq;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700656
Sathya Perla8788fdc2009-07-27 22:52:03 +0000657 be_eq_notify(adapter, rx_eq->q.id, false, false, 0);
658 be_eq_notify(adapter, tx_eq->q.id, false, false, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700659 adapter->vlan_grp = grp;
Sathya Perla8788fdc2009-07-27 22:52:03 +0000660 be_eq_notify(adapter, rx_eq->q.id, true, false, 0);
661 be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700662}
663
664static void be_vlan_add_vid(struct net_device *netdev, u16 vid)
665{
666 struct be_adapter *adapter = netdev_priv(netdev);
667
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000668 adapter->vlans_added++;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000669 if (!be_physfn(adapter))
670 return;
671
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700672 adapter->vlan_tag[vid] = 1;
Ajit Khaparde82903e42010-02-09 01:34:57 +0000673 if (adapter->vlans_added <= (adapter->max_vlans + 1))
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000674 be_vid_config(adapter, false, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700675}
676
677static void be_vlan_rem_vid(struct net_device *netdev, u16 vid)
678{
679 struct be_adapter *adapter = netdev_priv(netdev);
680
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000681 adapter->vlans_added--;
682 vlan_group_set_device(adapter->vlan_grp, vid, NULL);
683
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000684 if (!be_physfn(adapter))
685 return;
686
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700687 adapter->vlan_tag[vid] = 0;
Ajit Khaparde82903e42010-02-09 01:34:57 +0000688 if (adapter->vlans_added <= adapter->max_vlans)
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000689 be_vid_config(adapter, false, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700690}
691
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700692static void be_set_multicast_list(struct net_device *netdev)
693{
694 struct be_adapter *adapter = netdev_priv(netdev);
695
696 if (netdev->flags & IFF_PROMISC) {
Sathya Perla8788fdc2009-07-27 22:52:03 +0000697 be_cmd_promiscuous_config(adapter, adapter->port_num, 1);
Sathya Perla24307ee2009-06-18 00:09:25 +0000698 adapter->promiscuous = true;
699 goto done;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700700 }
Sathya Perla24307ee2009-06-18 00:09:25 +0000701
702 /* BE was previously in promiscous mode; disable it */
703 if (adapter->promiscuous) {
704 adapter->promiscuous = false;
Sathya Perla8788fdc2009-07-27 22:52:03 +0000705 be_cmd_promiscuous_config(adapter, adapter->port_num, 0);
Sathya Perla24307ee2009-06-18 00:09:25 +0000706 }
707
Sathya Perlae7b909a2009-11-22 22:01:10 +0000708 /* Enable multicast promisc if num configured exceeds what we support */
Jiri Pirko4cd24ea2010-02-08 04:30:35 +0000709 if (netdev->flags & IFF_ALLMULTI ||
710 netdev_mc_count(netdev) > BE_MAX_MC) {
Jiri Pirko0ddf4772010-02-20 00:13:58 +0000711 be_cmd_multicast_set(adapter, adapter->if_handle, NULL,
Sathya Perlae7b909a2009-11-22 22:01:10 +0000712 &adapter->mc_cmd_mem);
Sathya Perla24307ee2009-06-18 00:09:25 +0000713 goto done;
714 }
715
Jiri Pirko0ddf4772010-02-20 00:13:58 +0000716 be_cmd_multicast_set(adapter, adapter->if_handle, netdev,
Sathya Perlaf31e50a2010-03-02 03:56:39 -0800717 &adapter->mc_cmd_mem);
Sathya Perla24307ee2009-06-18 00:09:25 +0000718done:
719 return;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700720}
721
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000722static int be_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
723{
724 struct be_adapter *adapter = netdev_priv(netdev);
725 int status;
726
727 if (!adapter->sriov_enabled)
728 return -EPERM;
729
730 if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
731 return -EINVAL;
732
Ajit Khaparde64600ea2010-07-23 01:50:34 +0000733 if (adapter->vf_cfg[vf].vf_pmac_id != BE_INVALID_PMAC_ID)
734 status = be_cmd_pmac_del(adapter,
735 adapter->vf_cfg[vf].vf_if_handle,
736 adapter->vf_cfg[vf].vf_pmac_id);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000737
Ajit Khaparde64600ea2010-07-23 01:50:34 +0000738 status = be_cmd_pmac_add(adapter, mac,
739 adapter->vf_cfg[vf].vf_if_handle,
740 &adapter->vf_cfg[vf].vf_pmac_id);
741
742 if (status)
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000743 dev_err(&adapter->pdev->dev, "MAC %pM set on VF %d Failed\n",
744 mac, vf);
Ajit Khaparde64600ea2010-07-23 01:50:34 +0000745 else
746 memcpy(adapter->vf_cfg[vf].vf_mac_addr, mac, ETH_ALEN);
747
Sarveshwar Bandiba343c72010-03-31 02:56:12 +0000748 return status;
749}
750
Ajit Khaparde64600ea2010-07-23 01:50:34 +0000751static int be_get_vf_config(struct net_device *netdev, int vf,
752 struct ifla_vf_info *vi)
753{
754 struct be_adapter *adapter = netdev_priv(netdev);
755
756 if (!adapter->sriov_enabled)
757 return -EPERM;
758
759 if (vf >= num_vfs)
760 return -EINVAL;
761
762 vi->vf = vf;
Ajit Khapardee1d18732010-07-23 01:52:13 +0000763 vi->tx_rate = adapter->vf_cfg[vf].vf_tx_rate;
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000764 vi->vlan = adapter->vf_cfg[vf].vf_vlan_tag;
Ajit Khaparde64600ea2010-07-23 01:50:34 +0000765 vi->qos = 0;
766 memcpy(&vi->mac, adapter->vf_cfg[vf].vf_mac_addr, ETH_ALEN);
767
768 return 0;
769}
770
Ajit Khaparde1da87b72010-07-23 01:51:22 +0000771static int be_set_vf_vlan(struct net_device *netdev,
772 int vf, u16 vlan, u8 qos)
773{
774 struct be_adapter *adapter = netdev_priv(netdev);
775 int status = 0;
776
777 if (!adapter->sriov_enabled)
778 return -EPERM;
779
780 if ((vf >= num_vfs) || (vlan > 4095))
781 return -EINVAL;
782
783 if (vlan) {
784 adapter->vf_cfg[vf].vf_vlan_tag = vlan;
785 adapter->vlans_added++;
786 } else {
787 adapter->vf_cfg[vf].vf_vlan_tag = 0;
788 adapter->vlans_added--;
789 }
790
791 status = be_vid_config(adapter, true, vf);
792
793 if (status)
794 dev_info(&adapter->pdev->dev,
795 "VLAN %d config on VF %d failed\n", vlan, vf);
796 return status;
797}
798
Ajit Khapardee1d18732010-07-23 01:52:13 +0000799static int be_set_vf_tx_rate(struct net_device *netdev,
800 int vf, int rate)
801{
802 struct be_adapter *adapter = netdev_priv(netdev);
803 int status = 0;
804
805 if (!adapter->sriov_enabled)
806 return -EPERM;
807
808 if ((vf >= num_vfs) || (rate < 0))
809 return -EINVAL;
810
811 if (rate > 10000)
812 rate = 10000;
813
814 adapter->vf_cfg[vf].vf_tx_rate = rate;
815 status = be_cmd_set_qos(adapter, rate / 10, vf);
816
817 if (status)
818 dev_info(&adapter->pdev->dev,
819 "tx rate %d on VF %d failed\n", rate, vf);
820 return status;
821}
822
Sathya Perla4097f662009-03-24 16:40:13 -0700823static void be_rx_rate_update(struct be_adapter *adapter)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700824{
Sathya Perla4097f662009-03-24 16:40:13 -0700825 struct be_drvr_stats *stats = drvr_stats(adapter);
826 ulong now = jiffies;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700827
Sathya Perla4097f662009-03-24 16:40:13 -0700828 /* Wrapped around */
829 if (time_before(now, stats->be_rx_jiffies)) {
830 stats->be_rx_jiffies = now;
831 return;
832 }
833
834 /* Update the rate once in two seconds */
835 if ((now - stats->be_rx_jiffies) < 2 * HZ)
836 return;
837
Stephen Hemminger65f71b82009-03-27 00:25:24 -0700838 stats->be_rx_rate = be_calc_rate(stats->be_rx_bytes
839 - stats->be_rx_bytes_prev,
840 now - stats->be_rx_jiffies);
Sathya Perla4097f662009-03-24 16:40:13 -0700841 stats->be_rx_jiffies = now;
842 stats->be_rx_bytes_prev = stats->be_rx_bytes;
843}
844
845static void be_rx_stats_update(struct be_adapter *adapter,
846 u32 pktsize, u16 numfrags)
847{
848 struct be_drvr_stats *stats = drvr_stats(adapter);
849
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700850 stats->be_rx_compl++;
851 stats->be_rx_frags += numfrags;
852 stats->be_rx_bytes += pktsize;
Ajit Khaparde91992e42010-02-19 13:57:12 +0000853 stats->be_rx_pkts++;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700854}
855
Ajit Khaparde728a9972009-04-13 15:41:22 -0700856static inline bool do_pkt_csum(struct be_eth_rx_compl *rxcp, bool cso)
857{
858 u8 l4_cksm, ip_version, ipcksm, tcpf = 0, udpf = 0, ipv6_chk;
859
860 l4_cksm = AMAP_GET_BITS(struct amap_eth_rx_compl, l4_cksm, rxcp);
861 ipcksm = AMAP_GET_BITS(struct amap_eth_rx_compl, ipcksm, rxcp);
862 ip_version = AMAP_GET_BITS(struct amap_eth_rx_compl, ip_version, rxcp);
863 if (ip_version) {
864 tcpf = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
865 udpf = AMAP_GET_BITS(struct amap_eth_rx_compl, udpf, rxcp);
866 }
867 ipv6_chk = (ip_version && (tcpf || udpf));
868
869 return ((l4_cksm && ipv6_chk && ipcksm) && cso) ? false : true;
870}
871
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700872static struct be_rx_page_info *
873get_rx_page_info(struct be_adapter *adapter, u16 frag_idx)
874{
875 struct be_rx_page_info *rx_page_info;
876 struct be_queue_info *rxq = &adapter->rx_obj.q;
877
878 rx_page_info = &adapter->rx_obj.page_info_tbl[frag_idx];
879 BUG_ON(!rx_page_info->page);
880
Ajit Khaparde205859a2010-02-09 01:34:21 +0000881 if (rx_page_info->last_page_user) {
FUJITA Tomonorifac6da52010-04-01 16:53:22 +0000882 pci_unmap_page(adapter->pdev, dma_unmap_addr(rx_page_info, bus),
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700883 adapter->big_page_size, PCI_DMA_FROMDEVICE);
Ajit Khaparde205859a2010-02-09 01:34:21 +0000884 rx_page_info->last_page_user = false;
885 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700886
887 atomic_dec(&rxq->used);
888 return rx_page_info;
889}
890
891/* Throwaway the data in the Rx completion */
892static void be_rx_compl_discard(struct be_adapter *adapter,
893 struct be_eth_rx_compl *rxcp)
894{
895 struct be_queue_info *rxq = &adapter->rx_obj.q;
896 struct be_rx_page_info *page_info;
897 u16 rxq_idx, i, num_rcvd;
898
899 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
900 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
901
902 for (i = 0; i < num_rcvd; i++) {
903 page_info = get_rx_page_info(adapter, rxq_idx);
904 put_page(page_info->page);
905 memset(page_info, 0, sizeof(*page_info));
906 index_inc(&rxq_idx, rxq->len);
907 }
908}
909
910/*
911 * skb_fill_rx_data forms a complete skb for an ether frame
912 * indicated by rxcp.
913 */
914static void skb_fill_rx_data(struct be_adapter *adapter,
Sathya Perla89420422010-02-17 01:35:26 +0000915 struct sk_buff *skb, struct be_eth_rx_compl *rxcp,
916 u16 num_rcvd)
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700917{
918 struct be_queue_info *rxq = &adapter->rx_obj.q;
919 struct be_rx_page_info *page_info;
Sathya Perla89420422010-02-17 01:35:26 +0000920 u16 rxq_idx, i, j;
Ajit Khapardefa774062009-07-22 09:28:55 -0700921 u32 pktsize, hdr_len, curr_frag_len, size;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700922 u8 *start;
923
924 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
925 pktsize = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700926
927 page_info = get_rx_page_info(adapter, rxq_idx);
928
929 start = page_address(page_info->page) + page_info->page_offset;
930 prefetch(start);
931
932 /* Copy data in the first descriptor of this completion */
933 curr_frag_len = min(pktsize, rx_frag_size);
934
935 /* Copy the header portion into skb_data */
936 hdr_len = min((u32)BE_HDR_LEN, curr_frag_len);
937 memcpy(skb->data, start, hdr_len);
938 skb->len = curr_frag_len;
939 if (curr_frag_len <= BE_HDR_LEN) { /* tiny packet */
940 /* Complete packet has now been moved to data */
941 put_page(page_info->page);
942 skb->data_len = 0;
943 skb->tail += curr_frag_len;
944 } else {
945 skb_shinfo(skb)->nr_frags = 1;
946 skb_shinfo(skb)->frags[0].page = page_info->page;
947 skb_shinfo(skb)->frags[0].page_offset =
948 page_info->page_offset + hdr_len;
949 skb_shinfo(skb)->frags[0].size = curr_frag_len - hdr_len;
950 skb->data_len = curr_frag_len - hdr_len;
951 skb->tail += hdr_len;
952 }
Ajit Khaparde205859a2010-02-09 01:34:21 +0000953 page_info->page = NULL;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700954
955 if (pktsize <= rx_frag_size) {
956 BUG_ON(num_rcvd != 1);
Sathya Perla76fbb422009-06-10 02:21:56 +0000957 goto done;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700958 }
959
960 /* More frags present for this completion */
Ajit Khapardefa774062009-07-22 09:28:55 -0700961 size = pktsize;
Ajit Khapardebd46cb62009-06-26 02:51:07 +0000962 for (i = 1, j = 0; i < num_rcvd; i++) {
Ajit Khapardefa774062009-07-22 09:28:55 -0700963 size -= curr_frag_len;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700964 index_inc(&rxq_idx, rxq->len);
965 page_info = get_rx_page_info(adapter, rxq_idx);
966
Ajit Khapardefa774062009-07-22 09:28:55 -0700967 curr_frag_len = min(size, rx_frag_size);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700968
Ajit Khapardebd46cb62009-06-26 02:51:07 +0000969 /* Coalesce all frags from the same physical page in one slot */
970 if (page_info->page_offset == 0) {
971 /* Fresh page */
972 j++;
973 skb_shinfo(skb)->frags[j].page = page_info->page;
974 skb_shinfo(skb)->frags[j].page_offset =
975 page_info->page_offset;
976 skb_shinfo(skb)->frags[j].size = 0;
977 skb_shinfo(skb)->nr_frags++;
978 } else {
979 put_page(page_info->page);
980 }
981
982 skb_shinfo(skb)->frags[j].size += curr_frag_len;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700983 skb->len += curr_frag_len;
984 skb->data_len += curr_frag_len;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700985
Ajit Khaparde205859a2010-02-09 01:34:21 +0000986 page_info->page = NULL;
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700987 }
Ajit Khapardebd46cb62009-06-26 02:51:07 +0000988 BUG_ON(j > MAX_SKB_FRAGS);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700989
Sathya Perla76fbb422009-06-10 02:21:56 +0000990done:
Sathya Perla4097f662009-03-24 16:40:13 -0700991 be_rx_stats_update(adapter, pktsize, num_rcvd);
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700992}
993
Ajit Khaparde5be93b92009-07-21 12:36:19 -0700994/* Process the RX completion indicated by rxcp when GRO is disabled */
Sathya Perla6b7c5b92009-03-11 23:32:03 -0700995static void be_rx_compl_process(struct be_adapter *adapter,
996 struct be_eth_rx_compl *rxcp)
997{
998 struct sk_buff *skb;
Ajit Khapardedcb9b562009-09-30 21:58:22 -0700999 u32 vlanf, vid;
Sathya Perla89420422010-02-17 01:35:26 +00001000 u16 num_rcvd;
Ajit Khapardedcb9b562009-09-30 21:58:22 -07001001 u8 vtm;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001002
Sathya Perla89420422010-02-17 01:35:26 +00001003 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
1004 /* Is it a flush compl that has no data */
1005 if (unlikely(num_rcvd == 0))
1006 return;
1007
Eric Dumazet89d71a62009-10-13 05:34:20 +00001008 skb = netdev_alloc_skb_ip_align(adapter->netdev, BE_HDR_LEN);
Sathya Perlaa058a632010-02-17 01:34:22 +00001009 if (unlikely(!skb)) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001010 if (net_ratelimit())
1011 dev_warn(&adapter->pdev->dev, "skb alloc failed\n");
1012 be_rx_compl_discard(adapter, rxcp);
1013 return;
1014 }
1015
Sathya Perla89420422010-02-17 01:35:26 +00001016 skb_fill_rx_data(adapter, skb, rxcp, num_rcvd);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001017
Ajit Khaparde728a9972009-04-13 15:41:22 -07001018 if (do_pkt_csum(rxcp, adapter->rx_csum))
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001019 skb->ip_summed = CHECKSUM_NONE;
Ajit Khaparde728a9972009-04-13 15:41:22 -07001020 else
1021 skb->ip_summed = CHECKSUM_UNNECESSARY;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001022
1023 skb->truesize = skb->len + sizeof(struct sk_buff);
1024 skb->protocol = eth_type_trans(skb, adapter->netdev);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001025
Sathya Perlaa058a632010-02-17 01:34:22 +00001026 vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1027 vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1028
1029 /* vlanf could be wrongly set in some cards.
1030 * ignore if vtm is not set */
Ajit Khaparde3486be22010-07-23 02:04:54 +00001031 if ((adapter->function_mode & 0x400) && !vtm)
Sathya Perlaa058a632010-02-17 01:34:22 +00001032 vlanf = 0;
1033
1034 if (unlikely(vlanf)) {
Ajit Khaparde82903e42010-02-09 01:34:57 +00001035 if (!adapter->vlan_grp || adapter->vlans_added == 0) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001036 kfree_skb(skb);
1037 return;
1038 }
1039 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
Ajit Khaparde9cae9e42010-03-31 02:00:32 +00001040 vid = swab16(vid);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001041 vlan_hwaccel_receive_skb(skb, adapter->vlan_grp, vid);
1042 } else {
1043 netif_receive_skb(skb);
1044 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001045}
1046
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001047/* Process the RX completion indicated by rxcp when GRO is enabled */
1048static void be_rx_compl_process_gro(struct be_adapter *adapter,
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001049 struct be_eth_rx_compl *rxcp)
1050{
1051 struct be_rx_page_info *page_info;
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001052 struct sk_buff *skb = NULL;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001053 struct be_queue_info *rxq = &adapter->rx_obj.q;
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001054 struct be_eq_obj *eq_obj = &adapter->rx_eq;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001055 u32 num_rcvd, pkt_size, remaining, vlanf, curr_frag_len;
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001056 u16 i, rxq_idx = 0, vid, j;
Ajit Khapardedcb9b562009-09-30 21:58:22 -07001057 u8 vtm;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001058
1059 num_rcvd = AMAP_GET_BITS(struct amap_eth_rx_compl, numfrags, rxcp);
Sathya Perla89420422010-02-17 01:35:26 +00001060 /* Is it a flush compl that has no data */
1061 if (unlikely(num_rcvd == 0))
1062 return;
1063
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001064 pkt_size = AMAP_GET_BITS(struct amap_eth_rx_compl, pktsize, rxcp);
1065 vlanf = AMAP_GET_BITS(struct amap_eth_rx_compl, vtp, rxcp);
1066 rxq_idx = AMAP_GET_BITS(struct amap_eth_rx_compl, fragndx, rxcp);
Ajit Khapardedcb9b562009-09-30 21:58:22 -07001067 vtm = AMAP_GET_BITS(struct amap_eth_rx_compl, vtm, rxcp);
1068
1069 /* vlanf could be wrongly set in some cards.
1070 * ignore if vtm is not set */
Ajit Khaparde3486be22010-07-23 02:04:54 +00001071 if ((adapter->function_mode & 0x400) && !vtm)
Ajit Khapardedcb9b562009-09-30 21:58:22 -07001072 vlanf = 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001073
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001074 skb = napi_get_frags(&eq_obj->napi);
1075 if (!skb) {
1076 be_rx_compl_discard(adapter, rxcp);
1077 return;
1078 }
1079
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001080 remaining = pkt_size;
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001081 for (i = 0, j = -1; i < num_rcvd; i++) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001082 page_info = get_rx_page_info(adapter, rxq_idx);
1083
1084 curr_frag_len = min(remaining, rx_frag_size);
1085
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001086 /* Coalesce all frags from the same physical page in one slot */
1087 if (i == 0 || page_info->page_offset == 0) {
1088 /* First frag or Fresh page */
1089 j++;
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001090 skb_shinfo(skb)->frags[j].page = page_info->page;
1091 skb_shinfo(skb)->frags[j].page_offset =
1092 page_info->page_offset;
1093 skb_shinfo(skb)->frags[j].size = 0;
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001094 } else {
1095 put_page(page_info->page);
1096 }
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001097 skb_shinfo(skb)->frags[j].size += curr_frag_len;
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001098
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001099 remaining -= curr_frag_len;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001100 index_inc(&rxq_idx, rxq->len);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001101 memset(page_info, 0, sizeof(*page_info));
1102 }
Ajit Khapardebd46cb62009-06-26 02:51:07 +00001103 BUG_ON(j > MAX_SKB_FRAGS);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001104
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001105 skb_shinfo(skb)->nr_frags = j + 1;
1106 skb->len = pkt_size;
1107 skb->data_len = pkt_size;
1108 skb->truesize += pkt_size;
1109 skb->ip_summed = CHECKSUM_UNNECESSARY;
1110
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001111 if (likely(!vlanf)) {
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001112 napi_gro_frags(&eq_obj->napi);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001113 } else {
1114 vid = AMAP_GET_BITS(struct amap_eth_rx_compl, vlan_tag, rxcp);
Ajit Khaparde9cae9e42010-03-31 02:00:32 +00001115 vid = swab16(vid);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001116
Ajit Khaparde82903e42010-02-09 01:34:57 +00001117 if (!adapter->vlan_grp || adapter->vlans_added == 0)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001118 return;
1119
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001120 vlan_gro_frags(&eq_obj->napi, adapter->vlan_grp, vid);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001121 }
1122
Sathya Perla4097f662009-03-24 16:40:13 -07001123 be_rx_stats_update(adapter, pkt_size, num_rcvd);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001124}
1125
1126static struct be_eth_rx_compl *be_rx_compl_get(struct be_adapter *adapter)
1127{
1128 struct be_eth_rx_compl *rxcp = queue_tail_node(&adapter->rx_obj.cq);
1129
1130 if (rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] == 0)
1131 return NULL;
1132
Sathya Perlaf3eb62d2010-06-29 00:11:17 +00001133 rmb();
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001134 be_dws_le_to_cpu(rxcp, sizeof(*rxcp));
1135
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001136 queue_tail_inc(&adapter->rx_obj.cq);
1137 return rxcp;
1138}
1139
Sathya Perlaa7a0ef32009-06-10 02:23:28 +00001140/* To reset the valid bit, we need to reset the whole word as
1141 * when walking the queue the valid entries are little-endian
1142 * and invalid entries are host endian
1143 */
1144static inline void be_rx_compl_reset(struct be_eth_rx_compl *rxcp)
1145{
1146 rxcp->dw[offsetof(struct amap_eth_rx_compl, valid) / 32] = 0;
1147}
1148
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001149static inline struct page *be_alloc_pages(u32 size)
1150{
1151 gfp_t alloc_flags = GFP_ATOMIC;
1152 u32 order = get_order(size);
1153 if (order > 0)
1154 alloc_flags |= __GFP_COMP;
1155 return alloc_pages(alloc_flags, order);
1156}
1157
1158/*
1159 * Allocate a page, split it to fragments of size rx_frag_size and post as
1160 * receive buffers to BE
1161 */
1162static void be_post_rx_frags(struct be_adapter *adapter)
1163{
1164 struct be_rx_page_info *page_info_tbl = adapter->rx_obj.page_info_tbl;
Sathya Perla26d92f92010-01-21 22:52:08 -08001165 struct be_rx_page_info *page_info = NULL, *prev_page_info = NULL;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001166 struct be_queue_info *rxq = &adapter->rx_obj.q;
1167 struct page *pagep = NULL;
1168 struct be_eth_rx_d *rxd;
1169 u64 page_dmaaddr = 0, frag_dmaaddr;
1170 u32 posted, page_offset = 0;
1171
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001172 page_info = &page_info_tbl[rxq->head];
1173 for (posted = 0; posted < MAX_RX_POST && !page_info->page; posted++) {
1174 if (!pagep) {
1175 pagep = be_alloc_pages(adapter->big_page_size);
1176 if (unlikely(!pagep)) {
1177 drvr_stats(adapter)->be_ethrx_post_fail++;
1178 break;
1179 }
1180 page_dmaaddr = pci_map_page(adapter->pdev, pagep, 0,
1181 adapter->big_page_size,
1182 PCI_DMA_FROMDEVICE);
1183 page_info->page_offset = 0;
1184 } else {
1185 get_page(pagep);
1186 page_info->page_offset = page_offset + rx_frag_size;
1187 }
1188 page_offset = page_info->page_offset;
1189 page_info->page = pagep;
FUJITA Tomonorifac6da52010-04-01 16:53:22 +00001190 dma_unmap_addr_set(page_info, bus, page_dmaaddr);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001191 frag_dmaaddr = page_dmaaddr + page_info->page_offset;
1192
1193 rxd = queue_head_node(rxq);
1194 rxd->fragpa_lo = cpu_to_le32(frag_dmaaddr & 0xFFFFFFFF);
1195 rxd->fragpa_hi = cpu_to_le32(upper_32_bits(frag_dmaaddr));
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001196
1197 /* Any space left in the current big page for another frag? */
1198 if ((page_offset + rx_frag_size + rx_frag_size) >
1199 adapter->big_page_size) {
1200 pagep = NULL;
1201 page_info->last_page_user = true;
1202 }
Sathya Perla26d92f92010-01-21 22:52:08 -08001203
1204 prev_page_info = page_info;
1205 queue_head_inc(rxq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001206 page_info = &page_info_tbl[rxq->head];
1207 }
1208 if (pagep)
Sathya Perla26d92f92010-01-21 22:52:08 -08001209 prev_page_info->last_page_user = true;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001210
1211 if (posted) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001212 atomic_add(posted, &rxq->used);
Sathya Perla8788fdc2009-07-27 22:52:03 +00001213 be_rxq_notify(adapter, rxq->id, posted);
Sathya Perlaea1dae12009-03-19 23:56:20 -07001214 } else if (atomic_read(&rxq->used) == 0) {
1215 /* Let be_worker replenish when memory is available */
1216 adapter->rx_post_starved = true;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001217 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001218}
1219
Sathya Perla5fb379e2009-06-18 00:02:59 +00001220static struct be_eth_tx_compl *be_tx_compl_get(struct be_queue_info *tx_cq)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001221{
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001222 struct be_eth_tx_compl *txcp = queue_tail_node(tx_cq);
1223
1224 if (txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] == 0)
1225 return NULL;
1226
Sathya Perlaf3eb62d2010-06-29 00:11:17 +00001227 rmb();
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001228 be_dws_le_to_cpu(txcp, sizeof(*txcp));
1229
1230 txcp->dw[offsetof(struct amap_eth_tx_compl, valid) / 32] = 0;
1231
1232 queue_tail_inc(tx_cq);
1233 return txcp;
1234}
1235
1236static void be_tx_compl_process(struct be_adapter *adapter, u16 last_index)
1237{
1238 struct be_queue_info *txq = &adapter->tx_obj.q;
Alexander Duycka73b7962009-12-02 16:48:18 +00001239 struct be_eth_wrb *wrb;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001240 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1241 struct sk_buff *sent_skb;
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001242 u16 cur_index, num_wrbs = 1; /* account for hdr wrb */
1243 bool unmap_skb_hdr = true;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001244
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001245 sent_skb = sent_skbs[txq->tail];
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001246 BUG_ON(!sent_skb);
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001247 sent_skbs[txq->tail] = NULL;
1248
1249 /* skip header wrb */
Alexander Duycka73b7962009-12-02 16:48:18 +00001250 queue_tail_inc(txq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001251
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001252 do {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001253 cur_index = txq->tail;
Alexander Duycka73b7962009-12-02 16:48:18 +00001254 wrb = queue_tail_node(txq);
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001255 unmap_tx_frag(adapter->pdev, wrb, (unmap_skb_hdr &&
Eric Dumazete743d312010-04-14 15:59:40 -07001256 skb_headlen(sent_skb)));
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001257 unmap_skb_hdr = false;
1258
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001259 num_wrbs++;
1260 queue_tail_inc(txq);
Sathya Perlaec43b1a2010-03-22 20:41:34 +00001261 } while (cur_index != last_index);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001262
1263 atomic_sub(num_wrbs, &txq->used);
Alexander Duycka73b7962009-12-02 16:48:18 +00001264
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001265 kfree_skb(sent_skb);
1266}
1267
Sathya Perla859b1e42009-08-10 03:43:51 +00001268static inline struct be_eq_entry *event_get(struct be_eq_obj *eq_obj)
1269{
1270 struct be_eq_entry *eqe = queue_tail_node(&eq_obj->q);
1271
1272 if (!eqe->evt)
1273 return NULL;
1274
Sathya Perlaf3eb62d2010-06-29 00:11:17 +00001275 rmb();
Sathya Perla859b1e42009-08-10 03:43:51 +00001276 eqe->evt = le32_to_cpu(eqe->evt);
1277 queue_tail_inc(&eq_obj->q);
1278 return eqe;
1279}
1280
1281static int event_handle(struct be_adapter *adapter,
1282 struct be_eq_obj *eq_obj)
1283{
1284 struct be_eq_entry *eqe;
1285 u16 num = 0;
1286
1287 while ((eqe = event_get(eq_obj)) != NULL) {
1288 eqe->evt = 0;
1289 num++;
1290 }
1291
1292 /* Deal with any spurious interrupts that come
1293 * without events
1294 */
1295 be_eq_notify(adapter, eq_obj->q.id, true, true, num);
1296 if (num)
1297 napi_schedule(&eq_obj->napi);
1298
1299 return num;
1300}
1301
1302/* Just read and notify events without processing them.
1303 * Used at the time of destroying event queues */
1304static void be_eq_clean(struct be_adapter *adapter,
1305 struct be_eq_obj *eq_obj)
1306{
1307 struct be_eq_entry *eqe;
1308 u16 num = 0;
1309
1310 while ((eqe = event_get(eq_obj)) != NULL) {
1311 eqe->evt = 0;
1312 num++;
1313 }
1314
1315 if (num)
1316 be_eq_notify(adapter, eq_obj->q.id, false, true, num);
1317}
1318
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001319static void be_rx_q_clean(struct be_adapter *adapter)
1320{
1321 struct be_rx_page_info *page_info;
1322 struct be_queue_info *rxq = &adapter->rx_obj.q;
1323 struct be_queue_info *rx_cq = &adapter->rx_obj.cq;
1324 struct be_eth_rx_compl *rxcp;
1325 u16 tail;
1326
1327 /* First cleanup pending rx completions */
1328 while ((rxcp = be_rx_compl_get(adapter)) != NULL) {
1329 be_rx_compl_discard(adapter, rxcp);
Sathya Perlaa7a0ef32009-06-10 02:23:28 +00001330 be_rx_compl_reset(rxcp);
Sathya Perla8788fdc2009-07-27 22:52:03 +00001331 be_cq_notify(adapter, rx_cq->id, true, 1);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001332 }
1333
1334 /* Then free posted rx buffer that were not used */
1335 tail = (rxq->head + rxq->len - atomic_read(&rxq->used)) % rxq->len;
Sathya Perlacdab23b2009-08-10 03:43:23 +00001336 for (; atomic_read(&rxq->used) > 0; index_inc(&tail, rxq->len)) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001337 page_info = get_rx_page_info(adapter, tail);
1338 put_page(page_info->page);
1339 memset(page_info, 0, sizeof(*page_info));
1340 }
1341 BUG_ON(atomic_read(&rxq->used));
1342}
1343
Sathya Perlaa8e91792009-08-10 03:42:43 +00001344static void be_tx_compl_clean(struct be_adapter *adapter)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001345{
Sathya Perlaa8e91792009-08-10 03:42:43 +00001346 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001347 struct be_queue_info *txq = &adapter->tx_obj.q;
Sathya Perlaa8e91792009-08-10 03:42:43 +00001348 struct be_eth_tx_compl *txcp;
1349 u16 end_idx, cmpl = 0, timeo = 0;
Sathya Perlab03388d2010-02-18 00:37:17 +00001350 struct sk_buff **sent_skbs = adapter->tx_obj.sent_skb_list;
1351 struct sk_buff *sent_skb;
1352 bool dummy_wrb;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001353
Sathya Perlaa8e91792009-08-10 03:42:43 +00001354 /* Wait for a max of 200ms for all the tx-completions to arrive. */
1355 do {
1356 while ((txcp = be_tx_compl_get(tx_cq))) {
1357 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
1358 wrb_index, txcp);
1359 be_tx_compl_process(adapter, end_idx);
1360 cmpl++;
1361 }
1362 if (cmpl) {
1363 be_cq_notify(adapter, tx_cq->id, false, cmpl);
1364 cmpl = 0;
1365 }
1366
1367 if (atomic_read(&txq->used) == 0 || ++timeo > 200)
1368 break;
1369
1370 mdelay(1);
1371 } while (true);
1372
1373 if (atomic_read(&txq->used))
1374 dev_err(&adapter->pdev->dev, "%d pending tx-completions\n",
1375 atomic_read(&txq->used));
Sathya Perlab03388d2010-02-18 00:37:17 +00001376
1377 /* free posted tx for which compls will never arrive */
1378 while (atomic_read(&txq->used)) {
1379 sent_skb = sent_skbs[txq->tail];
1380 end_idx = txq->tail;
1381 index_adv(&end_idx,
1382 wrb_cnt_for_skb(sent_skb, &dummy_wrb) - 1, txq->len);
1383 be_tx_compl_process(adapter, end_idx);
1384 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001385}
1386
Sathya Perla5fb379e2009-06-18 00:02:59 +00001387static void be_mcc_queues_destroy(struct be_adapter *adapter)
1388{
1389 struct be_queue_info *q;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001390
Sathya Perla8788fdc2009-07-27 22:52:03 +00001391 q = &adapter->mcc_obj.q;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001392 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001393 be_cmd_q_destroy(adapter, q, QTYPE_MCCQ);
Sathya Perla5fb379e2009-06-18 00:02:59 +00001394 be_queue_free(adapter, q);
1395
Sathya Perla8788fdc2009-07-27 22:52:03 +00001396 q = &adapter->mcc_obj.cq;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001397 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001398 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
Sathya Perla5fb379e2009-06-18 00:02:59 +00001399 be_queue_free(adapter, q);
1400}
1401
1402/* Must be called only after TX qs are created as MCC shares TX EQ */
1403static int be_mcc_queues_create(struct be_adapter *adapter)
1404{
1405 struct be_queue_info *q, *cq;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001406
1407 /* Alloc MCC compl queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001408 cq = &adapter->mcc_obj.cq;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001409 if (be_queue_alloc(adapter, cq, MCC_CQ_LEN,
Sathya Perlaefd2e402009-07-27 22:53:10 +00001410 sizeof(struct be_mcc_compl)))
Sathya Perla5fb379e2009-06-18 00:02:59 +00001411 goto err;
1412
1413 /* Ask BE to create MCC compl queue; share TX's eq */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001414 if (be_cmd_cq_create(adapter, cq, &adapter->tx_eq.q, false, true, 0))
Sathya Perla5fb379e2009-06-18 00:02:59 +00001415 goto mcc_cq_free;
1416
1417 /* Alloc MCC queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001418 q = &adapter->mcc_obj.q;
Sathya Perla5fb379e2009-06-18 00:02:59 +00001419 if (be_queue_alloc(adapter, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
1420 goto mcc_cq_destroy;
1421
1422 /* Ask BE to create MCC queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001423 if (be_cmd_mccq_create(adapter, q, cq))
Sathya Perla5fb379e2009-06-18 00:02:59 +00001424 goto mcc_q_free;
1425
1426 return 0;
1427
1428mcc_q_free:
1429 be_queue_free(adapter, q);
1430mcc_cq_destroy:
Sathya Perla8788fdc2009-07-27 22:52:03 +00001431 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
Sathya Perla5fb379e2009-06-18 00:02:59 +00001432mcc_cq_free:
1433 be_queue_free(adapter, cq);
1434err:
1435 return -1;
1436}
1437
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001438static void be_tx_queues_destroy(struct be_adapter *adapter)
1439{
1440 struct be_queue_info *q;
1441
1442 q = &adapter->tx_obj.q;
Sathya Perlaa8e91792009-08-10 03:42:43 +00001443 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001444 be_cmd_q_destroy(adapter, q, QTYPE_TXQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001445 be_queue_free(adapter, q);
1446
1447 q = &adapter->tx_obj.cq;
1448 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001449 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001450 be_queue_free(adapter, q);
1451
Sathya Perla859b1e42009-08-10 03:43:51 +00001452 /* Clear any residual events */
1453 be_eq_clean(adapter, &adapter->tx_eq);
1454
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001455 q = &adapter->tx_eq.q;
1456 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001457 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001458 be_queue_free(adapter, q);
1459}
1460
1461static int be_tx_queues_create(struct be_adapter *adapter)
1462{
1463 struct be_queue_info *eq, *q, *cq;
1464
1465 adapter->tx_eq.max_eqd = 0;
1466 adapter->tx_eq.min_eqd = 0;
1467 adapter->tx_eq.cur_eqd = 96;
1468 adapter->tx_eq.enable_aic = false;
1469 /* Alloc Tx Event queue */
1470 eq = &adapter->tx_eq.q;
1471 if (be_queue_alloc(adapter, eq, EVNT_Q_LEN, sizeof(struct be_eq_entry)))
1472 return -1;
1473
1474 /* Ask BE to create Tx Event queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001475 if (be_cmd_eq_create(adapter, eq, adapter->tx_eq.cur_eqd))
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001476 goto tx_eq_free;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001477 adapter->base_eq_id = adapter->tx_eq.q.id;
1478
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001479 /* Alloc TX eth compl queue */
1480 cq = &adapter->tx_obj.cq;
1481 if (be_queue_alloc(adapter, cq, TX_CQ_LEN,
1482 sizeof(struct be_eth_tx_compl)))
1483 goto tx_eq_destroy;
1484
1485 /* Ask BE to create Tx eth compl queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001486 if (be_cmd_cq_create(adapter, cq, eq, false, false, 3))
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001487 goto tx_cq_free;
1488
1489 /* Alloc TX eth queue */
1490 q = &adapter->tx_obj.q;
1491 if (be_queue_alloc(adapter, q, TX_Q_LEN, sizeof(struct be_eth_wrb)))
1492 goto tx_cq_destroy;
1493
1494 /* Ask BE to create Tx eth queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001495 if (be_cmd_txq_create(adapter, q, cq))
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001496 goto tx_q_free;
1497 return 0;
1498
1499tx_q_free:
1500 be_queue_free(adapter, q);
1501tx_cq_destroy:
Sathya Perla8788fdc2009-07-27 22:52:03 +00001502 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001503tx_cq_free:
1504 be_queue_free(adapter, cq);
1505tx_eq_destroy:
Sathya Perla8788fdc2009-07-27 22:52:03 +00001506 be_cmd_q_destroy(adapter, eq, QTYPE_EQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001507tx_eq_free:
1508 be_queue_free(adapter, eq);
1509 return -1;
1510}
1511
1512static void be_rx_queues_destroy(struct be_adapter *adapter)
1513{
1514 struct be_queue_info *q;
1515
1516 q = &adapter->rx_obj.q;
1517 if (q->created) {
Sathya Perla8788fdc2009-07-27 22:52:03 +00001518 be_cmd_q_destroy(adapter, q, QTYPE_RXQ);
Sathya Perla89420422010-02-17 01:35:26 +00001519
1520 /* After the rxq is invalidated, wait for a grace time
1521 * of 1ms for all dma to end and the flush compl to arrive
1522 */
1523 mdelay(1);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001524 be_rx_q_clean(adapter);
1525 }
1526 be_queue_free(adapter, q);
1527
1528 q = &adapter->rx_obj.cq;
1529 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001530 be_cmd_q_destroy(adapter, q, QTYPE_CQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001531 be_queue_free(adapter, q);
1532
Sathya Perla859b1e42009-08-10 03:43:51 +00001533 /* Clear any residual events */
1534 be_eq_clean(adapter, &adapter->rx_eq);
1535
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001536 q = &adapter->rx_eq.q;
1537 if (q->created)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001538 be_cmd_q_destroy(adapter, q, QTYPE_EQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001539 be_queue_free(adapter, q);
1540}
1541
1542static int be_rx_queues_create(struct be_adapter *adapter)
1543{
1544 struct be_queue_info *eq, *q, *cq;
1545 int rc;
1546
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001547 adapter->big_page_size = (1 << get_order(rx_frag_size)) * PAGE_SIZE;
1548 adapter->rx_eq.max_eqd = BE_MAX_EQD;
1549 adapter->rx_eq.min_eqd = 0;
1550 adapter->rx_eq.cur_eqd = 0;
1551 adapter->rx_eq.enable_aic = true;
1552
1553 /* Alloc Rx Event queue */
1554 eq = &adapter->rx_eq.q;
1555 rc = be_queue_alloc(adapter, eq, EVNT_Q_LEN,
1556 sizeof(struct be_eq_entry));
1557 if (rc)
1558 return rc;
1559
1560 /* Ask BE to create Rx Event queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001561 rc = be_cmd_eq_create(adapter, eq, adapter->rx_eq.cur_eqd);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001562 if (rc)
1563 goto rx_eq_free;
1564
1565 /* Alloc RX eth compl queue */
1566 cq = &adapter->rx_obj.cq;
1567 rc = be_queue_alloc(adapter, cq, RX_CQ_LEN,
1568 sizeof(struct be_eth_rx_compl));
1569 if (rc)
1570 goto rx_eq_destroy;
1571
1572 /* Ask BE to create Rx eth compl queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001573 rc = be_cmd_cq_create(adapter, cq, eq, false, false, 3);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001574 if (rc)
1575 goto rx_cq_free;
1576
1577 /* Alloc RX eth queue */
1578 q = &adapter->rx_obj.q;
1579 rc = be_queue_alloc(adapter, q, RX_Q_LEN, sizeof(struct be_eth_rx_d));
1580 if (rc)
1581 goto rx_cq_destroy;
1582
1583 /* Ask BE to create Rx eth queue */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001584 rc = be_cmd_rxq_create(adapter, q, cq->id, rx_frag_size,
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001585 BE_MAX_JUMBO_FRAME_SIZE, adapter->if_handle, false);
1586 if (rc)
1587 goto rx_q_free;
1588
1589 return 0;
1590rx_q_free:
1591 be_queue_free(adapter, q);
1592rx_cq_destroy:
Sathya Perla8788fdc2009-07-27 22:52:03 +00001593 be_cmd_q_destroy(adapter, cq, QTYPE_CQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001594rx_cq_free:
1595 be_queue_free(adapter, cq);
1596rx_eq_destroy:
Sathya Perla8788fdc2009-07-27 22:52:03 +00001597 be_cmd_q_destroy(adapter, eq, QTYPE_EQ);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001598rx_eq_free:
1599 be_queue_free(adapter, eq);
1600 return rc;
1601}
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001602
Sathya Perlab628bde2009-08-17 00:58:26 +00001603/* There are 8 evt ids per func. Retruns the evt id's bit number */
1604static inline int be_evt_bit_get(struct be_adapter *adapter, u32 eq_id)
1605{
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001606 return eq_id - adapter->base_eq_id;
Sathya Perlab628bde2009-08-17 00:58:26 +00001607}
1608
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001609static irqreturn_t be_intx(int irq, void *dev)
1610{
1611 struct be_adapter *adapter = dev;
Sathya Perla8788fdc2009-07-27 22:52:03 +00001612 int isr;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001613
Sathya Perla8788fdc2009-07-27 22:52:03 +00001614 isr = ioread32(adapter->csr + CEV_ISR0_OFFSET +
Sathya Perla55bdeed2010-02-02 07:48:40 -08001615 (adapter->tx_eq.q.id/ 8) * CEV_ISR_SIZE);
Sathya Perlac001c212009-07-01 01:06:07 +00001616 if (!isr)
Sathya Perla8788fdc2009-07-27 22:52:03 +00001617 return IRQ_NONE;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001618
Sathya Perla8788fdc2009-07-27 22:52:03 +00001619 event_handle(adapter, &adapter->tx_eq);
1620 event_handle(adapter, &adapter->rx_eq);
Sathya Perlac001c212009-07-01 01:06:07 +00001621
Sathya Perla8788fdc2009-07-27 22:52:03 +00001622 return IRQ_HANDLED;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001623}
1624
1625static irqreturn_t be_msix_rx(int irq, void *dev)
1626{
1627 struct be_adapter *adapter = dev;
1628
Sathya Perla8788fdc2009-07-27 22:52:03 +00001629 event_handle(adapter, &adapter->rx_eq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001630
1631 return IRQ_HANDLED;
1632}
1633
Sathya Perla5fb379e2009-06-18 00:02:59 +00001634static irqreturn_t be_msix_tx_mcc(int irq, void *dev)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001635{
1636 struct be_adapter *adapter = dev;
1637
Sathya Perla8788fdc2009-07-27 22:52:03 +00001638 event_handle(adapter, &adapter->tx_eq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001639
1640 return IRQ_HANDLED;
1641}
1642
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001643static inline bool do_gro(struct be_adapter *adapter,
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001644 struct be_eth_rx_compl *rxcp)
1645{
1646 int err = AMAP_GET_BITS(struct amap_eth_rx_compl, err, rxcp);
1647 int tcp_frame = AMAP_GET_BITS(struct amap_eth_rx_compl, tcpf, rxcp);
1648
1649 if (err)
1650 drvr_stats(adapter)->be_rxcp_err++;
1651
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001652 return (tcp_frame && !err) ? true : false;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001653}
1654
1655int be_poll_rx(struct napi_struct *napi, int budget)
1656{
1657 struct be_eq_obj *rx_eq = container_of(napi, struct be_eq_obj, napi);
1658 struct be_adapter *adapter =
1659 container_of(rx_eq, struct be_adapter, rx_eq);
1660 struct be_queue_info *rx_cq = &adapter->rx_obj.cq;
1661 struct be_eth_rx_compl *rxcp;
1662 u32 work_done;
1663
Ajit Khapardeb7b83ac2009-11-29 17:57:22 +00001664 adapter->stats.drvr_stats.be_rx_polls++;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001665 for (work_done = 0; work_done < budget; work_done++) {
1666 rxcp = be_rx_compl_get(adapter);
1667 if (!rxcp)
1668 break;
1669
Ajit Khaparde5be93b92009-07-21 12:36:19 -07001670 if (do_gro(adapter, rxcp))
1671 be_rx_compl_process_gro(adapter, rxcp);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001672 else
1673 be_rx_compl_process(adapter, rxcp);
Sathya Perlaa7a0ef32009-06-10 02:23:28 +00001674
1675 be_rx_compl_reset(rxcp);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001676 }
1677
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001678 /* Refill the queue */
1679 if (atomic_read(&adapter->rx_obj.q.used) < RX_FRAGS_REFILL_WM)
1680 be_post_rx_frags(adapter);
1681
1682 /* All consumed */
1683 if (work_done < budget) {
1684 napi_complete(napi);
Sathya Perla8788fdc2009-07-27 22:52:03 +00001685 be_cq_notify(adapter, rx_cq->id, true, work_done);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001686 } else {
1687 /* More to be consumed; continue with interrupts disabled */
Sathya Perla8788fdc2009-07-27 22:52:03 +00001688 be_cq_notify(adapter, rx_cq->id, false, work_done);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001689 }
1690 return work_done;
1691}
1692
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001693/* As TX and MCC share the same EQ check for both TX and MCC completions.
1694 * For TX/MCC we don't honour budget; consume everything
1695 */
1696static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001697{
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001698 struct be_eq_obj *tx_eq = container_of(napi, struct be_eq_obj, napi);
1699 struct be_adapter *adapter =
1700 container_of(tx_eq, struct be_adapter, tx_eq);
Sathya Perla5fb379e2009-06-18 00:02:59 +00001701 struct be_queue_info *txq = &adapter->tx_obj.q;
1702 struct be_queue_info *tx_cq = &adapter->tx_obj.cq;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001703 struct be_eth_tx_compl *txcp;
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001704 int tx_compl = 0, mcc_compl, status = 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001705 u16 end_idx;
1706
Sathya Perla5fb379e2009-06-18 00:02:59 +00001707 while ((txcp = be_tx_compl_get(tx_cq))) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001708 end_idx = AMAP_GET_BITS(struct amap_eth_tx_compl,
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001709 wrb_index, txcp);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001710 be_tx_compl_process(adapter, end_idx);
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001711 tx_compl++;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001712 }
1713
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001714 mcc_compl = be_process_mcc(adapter, &status);
1715
1716 napi_complete(napi);
1717
1718 if (mcc_compl) {
1719 struct be_mcc_obj *mcc_obj = &adapter->mcc_obj;
1720 be_cq_notify(adapter, mcc_obj->cq.id, true, mcc_compl);
1721 }
1722
1723 if (tx_compl) {
1724 be_cq_notify(adapter, adapter->tx_obj.cq.id, true, tx_compl);
Sathya Perla5fb379e2009-06-18 00:02:59 +00001725
1726 /* As Tx wrbs have been freed up, wake up netdev queue if
1727 * it was stopped due to lack of tx wrbs.
1728 */
1729 if (netif_queue_stopped(adapter->netdev) &&
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001730 atomic_read(&txq->used) < txq->len / 2) {
Sathya Perla5fb379e2009-06-18 00:02:59 +00001731 netif_wake_queue(adapter->netdev);
1732 }
1733
1734 drvr_stats(adapter)->be_tx_events++;
Sathya Perlaf31e50a2010-03-02 03:56:39 -08001735 drvr_stats(adapter)->be_tx_compl += tx_compl;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001736 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001737
1738 return 1;
1739}
1740
Ajit Khaparde7c185272010-07-29 06:16:33 +00001741static inline bool be_detect_ue(struct be_adapter *adapter)
1742{
1743 u32 online0 = 0, online1 = 0;
1744
1745 pci_read_config_dword(adapter->pdev, PCICFG_ONLINE0, &online0);
1746
1747 pci_read_config_dword(adapter->pdev, PCICFG_ONLINE1, &online1);
1748
1749 if (!online0 || !online1) {
1750 adapter->ue_detected = true;
1751 dev_err(&adapter->pdev->dev,
1752 "UE Detected!! online0=%d online1=%d\n",
1753 online0, online1);
1754 return true;
1755 }
1756
1757 return false;
1758}
1759
1760void be_dump_ue(struct be_adapter *adapter)
1761{
1762 u32 ue_status_lo, ue_status_hi, ue_status_lo_mask, ue_status_hi_mask;
1763 u32 i;
1764
1765 pci_read_config_dword(adapter->pdev,
1766 PCICFG_UE_STATUS_LOW, &ue_status_lo);
1767 pci_read_config_dword(adapter->pdev,
1768 PCICFG_UE_STATUS_HIGH, &ue_status_hi);
1769 pci_read_config_dword(adapter->pdev,
1770 PCICFG_UE_STATUS_LOW_MASK, &ue_status_lo_mask);
1771 pci_read_config_dword(adapter->pdev,
1772 PCICFG_UE_STATUS_HI_MASK, &ue_status_hi_mask);
1773
1774 ue_status_lo = (ue_status_lo & (~ue_status_lo_mask));
1775 ue_status_hi = (ue_status_hi & (~ue_status_hi_mask));
1776
1777 if (ue_status_lo) {
1778 for (i = 0; ue_status_lo; ue_status_lo >>= 1, i++) {
1779 if (ue_status_lo & 1)
1780 dev_err(&adapter->pdev->dev,
1781 "UE: %s bit set\n", ue_status_low_desc[i]);
1782 }
1783 }
1784 if (ue_status_hi) {
1785 for (i = 0; ue_status_hi; ue_status_hi >>= 1, i++) {
1786 if (ue_status_hi & 1)
1787 dev_err(&adapter->pdev->dev,
1788 "UE: %s bit set\n", ue_status_hi_desc[i]);
1789 }
1790 }
1791
1792}
1793
Sathya Perlaea1dae12009-03-19 23:56:20 -07001794static void be_worker(struct work_struct *work)
1795{
1796 struct be_adapter *adapter =
1797 container_of(work, struct be_adapter, work.work);
Sathya Perlaea1dae12009-03-19 23:56:20 -07001798
Ajit Khaparde0fc48c32010-07-29 06:18:58 +00001799 if (!adapter->stats_ioctl_sent)
1800 be_cmd_get_stats(adapter, &adapter->stats.cmd);
Sathya Perlaea1dae12009-03-19 23:56:20 -07001801
1802 /* Set EQ delay */
1803 be_rx_eqd_update(adapter);
1804
Sathya Perla4097f662009-03-24 16:40:13 -07001805 be_tx_rate_update(adapter);
1806 be_rx_rate_update(adapter);
1807
Sathya Perlaea1dae12009-03-19 23:56:20 -07001808 if (adapter->rx_post_starved) {
1809 adapter->rx_post_starved = false;
1810 be_post_rx_frags(adapter);
1811 }
Ajit Khaparde7c185272010-07-29 06:16:33 +00001812 if (!adapter->ue_detected) {
1813 if (be_detect_ue(adapter))
1814 be_dump_ue(adapter);
1815 }
Sathya Perlaea1dae12009-03-19 23:56:20 -07001816
1817 schedule_delayed_work(&adapter->work, msecs_to_jiffies(1000));
1818}
1819
Sathya Perla8d56ff12009-11-22 22:02:26 +00001820static void be_msix_disable(struct be_adapter *adapter)
1821{
1822 if (adapter->msix_enabled) {
1823 pci_disable_msix(adapter->pdev);
1824 adapter->msix_enabled = false;
1825 }
1826}
1827
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001828static void be_msix_enable(struct be_adapter *adapter)
1829{
1830 int i, status;
1831
1832 for (i = 0; i < BE_NUM_MSIX_VECTORS; i++)
1833 adapter->msix_entries[i].entry = i;
1834
1835 status = pci_enable_msix(adapter->pdev, adapter->msix_entries,
1836 BE_NUM_MSIX_VECTORS);
1837 if (status == 0)
1838 adapter->msix_enabled = true;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001839}
1840
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001841static void be_sriov_enable(struct be_adapter *adapter)
1842{
Sarveshwar Bandi344dbf12010-07-09 01:43:55 +00001843 be_check_sriov_fn_type(adapter);
Ajit Khaparde6dedec82010-07-29 06:15:32 +00001844#ifdef CONFIG_PCI_IOV
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001845 if (be_physfn(adapter) && num_vfs) {
Ajit Khaparde6dedec82010-07-29 06:15:32 +00001846 int status;
1847
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001848 status = pci_enable_sriov(adapter->pdev, num_vfs);
1849 adapter->sriov_enabled = status ? false : true;
1850 }
1851#endif
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001852}
1853
1854static void be_sriov_disable(struct be_adapter *adapter)
1855{
1856#ifdef CONFIG_PCI_IOV
1857 if (adapter->sriov_enabled) {
1858 pci_disable_sriov(adapter->pdev);
1859 adapter->sriov_enabled = false;
1860 }
1861#endif
1862}
1863
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001864static inline int be_msix_vec_get(struct be_adapter *adapter, u32 eq_id)
1865{
Sathya Perlab628bde2009-08-17 00:58:26 +00001866 return adapter->msix_entries[
1867 be_evt_bit_get(adapter, eq_id)].vector;
1868}
1869
1870static int be_request_irq(struct be_adapter *adapter,
1871 struct be_eq_obj *eq_obj,
1872 void *handler, char *desc)
1873{
1874 struct net_device *netdev = adapter->netdev;
1875 int vec;
1876
1877 sprintf(eq_obj->desc, "%s-%s", netdev->name, desc);
1878 vec = be_msix_vec_get(adapter, eq_obj->q.id);
1879 return request_irq(vec, handler, 0, eq_obj->desc, adapter);
1880}
1881
1882static void be_free_irq(struct be_adapter *adapter, struct be_eq_obj *eq_obj)
1883{
1884 int vec = be_msix_vec_get(adapter, eq_obj->q.id);
1885 free_irq(vec, adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001886}
1887
1888static int be_msix_register(struct be_adapter *adapter)
1889{
Sathya Perlab628bde2009-08-17 00:58:26 +00001890 int status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001891
Sathya Perlab628bde2009-08-17 00:58:26 +00001892 status = be_request_irq(adapter, &adapter->tx_eq, be_msix_tx_mcc, "tx");
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001893 if (status)
1894 goto err;
1895
Sathya Perlab628bde2009-08-17 00:58:26 +00001896 status = be_request_irq(adapter, &adapter->rx_eq, be_msix_rx, "rx");
1897 if (status)
1898 goto free_tx_irq;
1899
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001900 return 0;
Sathya Perlab628bde2009-08-17 00:58:26 +00001901
1902free_tx_irq:
1903 be_free_irq(adapter, &adapter->tx_eq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001904err:
1905 dev_warn(&adapter->pdev->dev,
1906 "MSIX Request IRQ failed - err %d\n", status);
1907 pci_disable_msix(adapter->pdev);
1908 adapter->msix_enabled = false;
1909 return status;
1910}
1911
1912static int be_irq_register(struct be_adapter *adapter)
1913{
1914 struct net_device *netdev = adapter->netdev;
1915 int status;
1916
1917 if (adapter->msix_enabled) {
1918 status = be_msix_register(adapter);
1919 if (status == 0)
1920 goto done;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00001921 /* INTx is not supported for VF */
1922 if (!be_physfn(adapter))
1923 return status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001924 }
1925
1926 /* INTx */
1927 netdev->irq = adapter->pdev->irq;
1928 status = request_irq(netdev->irq, be_intx, IRQF_SHARED, netdev->name,
1929 adapter);
1930 if (status) {
1931 dev_err(&adapter->pdev->dev,
1932 "INTx request IRQ failed - err %d\n", status);
1933 return status;
1934 }
1935done:
1936 adapter->isr_registered = true;
1937 return 0;
1938}
1939
1940static void be_irq_unregister(struct be_adapter *adapter)
1941{
1942 struct net_device *netdev = adapter->netdev;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001943
1944 if (!adapter->isr_registered)
1945 return;
1946
1947 /* INTx */
1948 if (!adapter->msix_enabled) {
1949 free_irq(netdev->irq, adapter);
1950 goto done;
1951 }
1952
1953 /* MSIx */
Sathya Perlab628bde2009-08-17 00:58:26 +00001954 be_free_irq(adapter, &adapter->tx_eq);
1955 be_free_irq(adapter, &adapter->rx_eq);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001956done:
1957 adapter->isr_registered = false;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001958}
1959
Sathya Perla889cd4b2010-05-30 23:33:45 +00001960static int be_close(struct net_device *netdev)
1961{
1962 struct be_adapter *adapter = netdev_priv(netdev);
1963 struct be_eq_obj *rx_eq = &adapter->rx_eq;
1964 struct be_eq_obj *tx_eq = &adapter->tx_eq;
1965 int vec;
1966
1967 cancel_delayed_work_sync(&adapter->work);
1968
1969 be_async_mcc_disable(adapter);
1970
1971 netif_stop_queue(netdev);
1972 netif_carrier_off(netdev);
1973 adapter->link_up = false;
1974
1975 be_intr_set(adapter, false);
1976
1977 if (adapter->msix_enabled) {
1978 vec = be_msix_vec_get(adapter, tx_eq->q.id);
1979 synchronize_irq(vec);
1980 vec = be_msix_vec_get(adapter, rx_eq->q.id);
1981 synchronize_irq(vec);
1982 } else {
1983 synchronize_irq(netdev->irq);
1984 }
1985 be_irq_unregister(adapter);
1986
1987 napi_disable(&rx_eq->napi);
1988 napi_disable(&tx_eq->napi);
1989
1990 /* Wait for all pending tx completions to arrive so that
1991 * all tx skbs are freed.
1992 */
1993 be_tx_compl_clean(adapter);
1994
1995 return 0;
1996}
1997
Sathya Perla6b7c5b92009-03-11 23:32:03 -07001998static int be_open(struct net_device *netdev)
1999{
2000 struct be_adapter *adapter = netdev_priv(netdev);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002001 struct be_eq_obj *rx_eq = &adapter->rx_eq;
2002 struct be_eq_obj *tx_eq = &adapter->tx_eq;
Sathya Perlaa8f447b2009-06-18 00:10:27 +00002003 bool link_up;
2004 int status;
Sarveshwar Bandi0388f252009-10-28 04:15:20 -07002005 u8 mac_speed;
2006 u16 link_speed;
Sathya Perla5fb379e2009-06-18 00:02:59 +00002007
2008 /* First time posting */
2009 be_post_rx_frags(adapter);
2010
2011 napi_enable(&rx_eq->napi);
2012 napi_enable(&tx_eq->napi);
2013
2014 be_irq_register(adapter);
2015
Sathya Perla8788fdc2009-07-27 22:52:03 +00002016 be_intr_set(adapter, true);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002017
2018 /* The evt queues are created in unarmed state; arm them */
Sathya Perla8788fdc2009-07-27 22:52:03 +00002019 be_eq_notify(adapter, rx_eq->q.id, true, false, 0);
2020 be_eq_notify(adapter, tx_eq->q.id, true, false, 0);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002021
2022 /* Rx compl queue may be in unarmed state; rearm it */
Sathya Perla8788fdc2009-07-27 22:52:03 +00002023 be_cq_notify(adapter, adapter->rx_obj.cq.id, true, 0);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002024
Sathya Perla7a1e9b22010-02-17 01:35:11 +00002025 /* Now that interrupts are on we can process async mcc */
2026 be_async_mcc_enable(adapter);
2027
Sathya Perla889cd4b2010-05-30 23:33:45 +00002028 schedule_delayed_work(&adapter->work, msecs_to_jiffies(100));
2029
Sarveshwar Bandi0388f252009-10-28 04:15:20 -07002030 status = be_cmd_link_status_query(adapter, &link_up, &mac_speed,
2031 &link_speed);
Sathya Perlaa8f447b2009-06-18 00:10:27 +00002032 if (status)
Sathya Perla889cd4b2010-05-30 23:33:45 +00002033 goto err;
Sathya Perlaa8f447b2009-06-18 00:10:27 +00002034 be_link_status_update(adapter, link_up);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002035
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002036 if (be_physfn(adapter)) {
Ajit Khaparde1da87b72010-07-23 01:51:22 +00002037 status = be_vid_config(adapter, false, 0);
Sathya Perla889cd4b2010-05-30 23:33:45 +00002038 if (status)
2039 goto err;
2040
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002041 status = be_cmd_set_flow_control(adapter,
2042 adapter->tx_fc, adapter->rx_fc);
2043 if (status)
Sathya Perla889cd4b2010-05-30 23:33:45 +00002044 goto err;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002045 }
Ajit Khaparde4f2aa892009-11-06 02:07:32 +00002046
Sathya Perla889cd4b2010-05-30 23:33:45 +00002047 return 0;
2048err:
2049 be_close(adapter->netdev);
2050 return -EIO;
Sathya Perla5fb379e2009-06-18 00:02:59 +00002051}
2052
Ajit Khaparde71d8d1b2009-12-03 06:16:59 +00002053static int be_setup_wol(struct be_adapter *adapter, bool enable)
2054{
2055 struct be_dma_mem cmd;
2056 int status = 0;
2057 u8 mac[ETH_ALEN];
2058
2059 memset(mac, 0, ETH_ALEN);
2060
2061 cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
2062 cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);
2063 if (cmd.va == NULL)
2064 return -1;
2065 memset(cmd.va, 0, cmd.size);
2066
2067 if (enable) {
2068 status = pci_write_config_dword(adapter->pdev,
2069 PCICFG_PM_CONTROL_OFFSET, PCICFG_PM_CONTROL_MASK);
2070 if (status) {
2071 dev_err(&adapter->pdev->dev,
Frans Pop2381a552010-03-24 07:57:36 +00002072 "Could not enable Wake-on-lan\n");
Ajit Khaparde71d8d1b2009-12-03 06:16:59 +00002073 pci_free_consistent(adapter->pdev, cmd.size, cmd.va,
2074 cmd.dma);
2075 return status;
2076 }
2077 status = be_cmd_enable_magic_wol(adapter,
2078 adapter->netdev->dev_addr, &cmd);
2079 pci_enable_wake(adapter->pdev, PCI_D3hot, 1);
2080 pci_enable_wake(adapter->pdev, PCI_D3cold, 1);
2081 } else {
2082 status = be_cmd_enable_magic_wol(adapter, mac, &cmd);
2083 pci_enable_wake(adapter->pdev, PCI_D3hot, 0);
2084 pci_enable_wake(adapter->pdev, PCI_D3cold, 0);
2085 }
2086
2087 pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);
2088 return status;
2089}
2090
Sathya Perla5fb379e2009-06-18 00:02:59 +00002091static int be_setup(struct be_adapter *adapter)
2092{
Sathya Perla5fb379e2009-06-18 00:02:59 +00002093 struct net_device *netdev = adapter->netdev;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002094 u32 cap_flags, en_flags, vf = 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002095 int status;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002096 u8 mac[ETH_ALEN];
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002097
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002098 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED | BE_IF_FLAGS_BROADCAST;
2099
2100 if (be_physfn(adapter)) {
2101 cap_flags |= BE_IF_FLAGS_MCAST_PROMISCUOUS |
2102 BE_IF_FLAGS_PROMISCUOUS |
2103 BE_IF_FLAGS_PASS_L3L4_ERRORS;
2104 en_flags |= BE_IF_FLAGS_PASS_L3L4_ERRORS;
2105 }
Sathya Perla73d540f2009-10-14 20:20:42 +00002106
2107 status = be_cmd_if_create(adapter, cap_flags, en_flags,
2108 netdev->dev_addr, false/* pmac_invalid */,
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002109 &adapter->if_handle, &adapter->pmac_id, 0);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002110 if (status != 0)
2111 goto do_none;
2112
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002113 if (be_physfn(adapter)) {
2114 while (vf < num_vfs) {
2115 cap_flags = en_flags = BE_IF_FLAGS_UNTAGGED
2116 | BE_IF_FLAGS_BROADCAST;
2117 status = be_cmd_if_create(adapter, cap_flags, en_flags,
Ajit Khaparde64600ea2010-07-23 01:50:34 +00002118 mac, true,
2119 &adapter->vf_cfg[vf].vf_if_handle,
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002120 NULL, vf+1);
2121 if (status) {
2122 dev_err(&adapter->pdev->dev,
2123 "Interface Create failed for VF %d\n", vf);
2124 goto if_destroy;
2125 }
Ajit Khaparde64600ea2010-07-23 01:50:34 +00002126 adapter->vf_cfg[vf].vf_pmac_id = BE_INVALID_PMAC_ID;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002127 vf++;
Sarveshwar Bandi84e5b9f2010-05-27 16:28:15 -07002128 }
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002129 } else if (!be_physfn(adapter)) {
2130 status = be_cmd_mac_addr_query(adapter, mac,
2131 MAC_ADDRESS_TYPE_NETWORK, false, adapter->if_handle);
2132 if (!status) {
2133 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2134 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2135 }
2136 }
2137
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002138 status = be_tx_queues_create(adapter);
2139 if (status != 0)
2140 goto if_destroy;
2141
2142 status = be_rx_queues_create(adapter);
2143 if (status != 0)
2144 goto tx_qs_destroy;
2145
Sathya Perla5fb379e2009-06-18 00:02:59 +00002146 status = be_mcc_queues_create(adapter);
2147 if (status != 0)
2148 goto rx_qs_destroy;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002149
Ajit Khaparde0dffc832009-11-29 17:57:46 +00002150 adapter->link_speed = -1;
2151
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002152 return 0;
2153
Sathya Perla5fb379e2009-06-18 00:02:59 +00002154rx_qs_destroy:
2155 be_rx_queues_destroy(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002156tx_qs_destroy:
2157 be_tx_queues_destroy(adapter);
2158if_destroy:
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002159 for (vf = 0; vf < num_vfs; vf++)
Ajit Khaparde64600ea2010-07-23 01:50:34 +00002160 if (adapter->vf_cfg[vf].vf_if_handle)
2161 be_cmd_if_destroy(adapter,
2162 adapter->vf_cfg[vf].vf_if_handle);
Sathya Perla8788fdc2009-07-27 22:52:03 +00002163 be_cmd_if_destroy(adapter, adapter->if_handle);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002164do_none:
2165 return status;
2166}
2167
Sathya Perla5fb379e2009-06-18 00:02:59 +00002168static int be_clear(struct be_adapter *adapter)
2169{
Sathya Perla1a8887d2009-08-17 00:58:41 +00002170 be_mcc_queues_destroy(adapter);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002171 be_rx_queues_destroy(adapter);
2172 be_tx_queues_destroy(adapter);
2173
Sathya Perla8788fdc2009-07-27 22:52:03 +00002174 be_cmd_if_destroy(adapter, adapter->if_handle);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002175
Sathya Perla2243e2e2009-11-22 22:02:03 +00002176 /* tell fw we're done with firing cmds */
2177 be_cmd_fw_clean(adapter);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002178 return 0;
2179}
2180
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002181
Ajit Khaparde84517482009-09-04 03:12:16 +00002182#define FW_FILE_HDR_SIGN "ServerEngines Corp. "
2183char flash_cookie[2][16] = {"*** SE FLAS",
2184 "H DIRECTORY *** "};
Sarveshwar Bandifa9a6fe2009-11-20 14:23:47 -08002185
2186static bool be_flash_redboot(struct be_adapter *adapter,
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002187 const u8 *p, u32 img_start, int image_size,
2188 int hdr_size)
Sarveshwar Bandifa9a6fe2009-11-20 14:23:47 -08002189{
2190 u32 crc_offset;
2191 u8 flashed_crc[4];
2192 int status;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002193
2194 crc_offset = hdr_size + img_start + image_size - 4;
2195
Sarveshwar Bandifa9a6fe2009-11-20 14:23:47 -08002196 p += crc_offset;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002197
2198 status = be_cmd_get_flash_crc(adapter, flashed_crc,
Ajit Khapardef510fc62010-03-31 01:47:45 +00002199 (image_size - 4));
Sarveshwar Bandifa9a6fe2009-11-20 14:23:47 -08002200 if (status) {
2201 dev_err(&adapter->pdev->dev,
2202 "could not get crc from flash, not flashing redboot\n");
2203 return false;
2204 }
2205
2206 /*update redboot only if crc does not match*/
2207 if (!memcmp(flashed_crc, p, 4))
2208 return false;
2209 else
2210 return true;
Sarveshwar Bandifa9a6fe2009-11-20 14:23:47 -08002211}
2212
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002213static int be_flash_data(struct be_adapter *adapter,
Ajit Khaparde84517482009-09-04 03:12:16 +00002214 const struct firmware *fw,
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002215 struct be_dma_mem *flash_cmd, int num_of_images)
2216
Ajit Khaparde84517482009-09-04 03:12:16 +00002217{
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002218 int status = 0, i, filehdr_size = 0;
2219 u32 total_bytes = 0, flash_op;
Ajit Khaparde84517482009-09-04 03:12:16 +00002220 int num_bytes;
2221 const u8 *p = fw->data;
2222 struct be_cmd_write_flashrom *req = flash_cmd->va;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002223 struct flash_comp *pflashcomp;
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002224 int num_comp;
Ajit Khaparde84517482009-09-04 03:12:16 +00002225
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002226 struct flash_comp gen3_flash_types[9] = {
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002227 { FLASH_iSCSI_PRIMARY_IMAGE_START_g3, IMG_TYPE_ISCSI_ACTIVE,
2228 FLASH_IMAGE_MAX_SIZE_g3},
2229 { FLASH_REDBOOT_START_g3, IMG_TYPE_REDBOOT,
2230 FLASH_REDBOOT_IMAGE_MAX_SIZE_g3},
2231 { FLASH_iSCSI_BIOS_START_g3, IMG_TYPE_BIOS,
2232 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2233 { FLASH_PXE_BIOS_START_g3, IMG_TYPE_PXE_BIOS,
2234 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2235 { FLASH_FCoE_BIOS_START_g3, IMG_TYPE_FCOE_BIOS,
2236 FLASH_BIOS_IMAGE_MAX_SIZE_g3},
2237 { FLASH_iSCSI_BACKUP_IMAGE_START_g3, IMG_TYPE_ISCSI_BACKUP,
2238 FLASH_IMAGE_MAX_SIZE_g3},
2239 { FLASH_FCoE_PRIMARY_IMAGE_START_g3, IMG_TYPE_FCOE_FW_ACTIVE,
2240 FLASH_IMAGE_MAX_SIZE_g3},
2241 { FLASH_FCoE_BACKUP_IMAGE_START_g3, IMG_TYPE_FCOE_FW_BACKUP,
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002242 FLASH_IMAGE_MAX_SIZE_g3},
2243 { FLASH_NCSI_START_g3, IMG_TYPE_NCSI_FW,
2244 FLASH_NCSI_IMAGE_MAX_SIZE_g3}
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002245 };
2246 struct flash_comp gen2_flash_types[8] = {
2247 { FLASH_iSCSI_PRIMARY_IMAGE_START_g2, IMG_TYPE_ISCSI_ACTIVE,
2248 FLASH_IMAGE_MAX_SIZE_g2},
2249 { FLASH_REDBOOT_START_g2, IMG_TYPE_REDBOOT,
2250 FLASH_REDBOOT_IMAGE_MAX_SIZE_g2},
2251 { FLASH_iSCSI_BIOS_START_g2, IMG_TYPE_BIOS,
2252 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2253 { FLASH_PXE_BIOS_START_g2, IMG_TYPE_PXE_BIOS,
2254 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2255 { FLASH_FCoE_BIOS_START_g2, IMG_TYPE_FCOE_BIOS,
2256 FLASH_BIOS_IMAGE_MAX_SIZE_g2},
2257 { FLASH_iSCSI_BACKUP_IMAGE_START_g2, IMG_TYPE_ISCSI_BACKUP,
2258 FLASH_IMAGE_MAX_SIZE_g2},
2259 { FLASH_FCoE_PRIMARY_IMAGE_START_g2, IMG_TYPE_FCOE_FW_ACTIVE,
2260 FLASH_IMAGE_MAX_SIZE_g2},
2261 { FLASH_FCoE_BACKUP_IMAGE_START_g2, IMG_TYPE_FCOE_FW_BACKUP,
2262 FLASH_IMAGE_MAX_SIZE_g2}
2263 };
2264
2265 if (adapter->generation == BE_GEN3) {
2266 pflashcomp = gen3_flash_types;
2267 filehdr_size = sizeof(struct flash_file_hdr_g3);
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002268 num_comp = 9;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002269 } else {
2270 pflashcomp = gen2_flash_types;
2271 filehdr_size = sizeof(struct flash_file_hdr_g2);
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002272 num_comp = 8;
Ajit Khaparde84517482009-09-04 03:12:16 +00002273 }
Sarveshwar Bandi9fe96932010-03-02 22:37:28 +00002274 for (i = 0; i < num_comp; i++) {
2275 if ((pflashcomp[i].optype == IMG_TYPE_NCSI_FW) &&
2276 memcmp(adapter->fw_ver, "3.102.148.0", 11) < 0)
2277 continue;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002278 if ((pflashcomp[i].optype == IMG_TYPE_REDBOOT) &&
2279 (!be_flash_redboot(adapter, fw->data,
2280 pflashcomp[i].offset, pflashcomp[i].size,
2281 filehdr_size)))
2282 continue;
2283 p = fw->data;
2284 p += filehdr_size + pflashcomp[i].offset
2285 + (num_of_images * sizeof(struct image_hdr));
2286 if (p + pflashcomp[i].size > fw->data + fw->size)
Ajit Khaparde84517482009-09-04 03:12:16 +00002287 return -1;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002288 total_bytes = pflashcomp[i].size;
2289 while (total_bytes) {
2290 if (total_bytes > 32*1024)
2291 num_bytes = 32*1024;
2292 else
2293 num_bytes = total_bytes;
2294 total_bytes -= num_bytes;
Ajit Khaparde84517482009-09-04 03:12:16 +00002295
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002296 if (!total_bytes)
2297 flash_op = FLASHROM_OPER_FLASH;
2298 else
2299 flash_op = FLASHROM_OPER_SAVE;
2300 memcpy(req->params.data_buf, p, num_bytes);
2301 p += num_bytes;
2302 status = be_cmd_write_flashrom(adapter, flash_cmd,
2303 pflashcomp[i].optype, flash_op, num_bytes);
2304 if (status) {
2305 dev_err(&adapter->pdev->dev,
2306 "cmd to write to flash rom failed.\n");
2307 return -1;
2308 }
2309 yield();
Ajit Khaparde84517482009-09-04 03:12:16 +00002310 }
Ajit Khaparde84517482009-09-04 03:12:16 +00002311 }
Ajit Khaparde84517482009-09-04 03:12:16 +00002312 return 0;
2313}
2314
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002315static int get_ufigen_type(struct flash_file_hdr_g2 *fhdr)
2316{
2317 if (fhdr == NULL)
2318 return 0;
2319 if (fhdr->build[0] == '3')
2320 return BE_GEN3;
2321 else if (fhdr->build[0] == '2')
2322 return BE_GEN2;
2323 else
2324 return 0;
2325}
2326
Ajit Khaparde84517482009-09-04 03:12:16 +00002327int be_load_fw(struct be_adapter *adapter, u8 *func)
2328{
2329 char fw_file[ETHTOOL_FLASH_MAX_FILENAME];
2330 const struct firmware *fw;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002331 struct flash_file_hdr_g2 *fhdr;
2332 struct flash_file_hdr_g3 *fhdr3;
2333 struct image_hdr *img_hdr_ptr = NULL;
Ajit Khaparde84517482009-09-04 03:12:16 +00002334 struct be_dma_mem flash_cmd;
Ajit Khaparde8b93b712010-03-31 01:57:10 +00002335 int status, i = 0, num_imgs = 0;
Ajit Khaparde84517482009-09-04 03:12:16 +00002336 const u8 *p;
Ajit Khaparde84517482009-09-04 03:12:16 +00002337
Ajit Khaparde84517482009-09-04 03:12:16 +00002338 strcpy(fw_file, func);
2339
2340 status = request_firmware(&fw, fw_file, &adapter->pdev->dev);
2341 if (status)
2342 goto fw_exit;
2343
2344 p = fw->data;
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002345 fhdr = (struct flash_file_hdr_g2 *) p;
Ajit Khaparde84517482009-09-04 03:12:16 +00002346 dev_info(&adapter->pdev->dev, "Flashing firmware file %s\n", fw_file);
2347
Ajit Khaparde84517482009-09-04 03:12:16 +00002348 flash_cmd.size = sizeof(struct be_cmd_write_flashrom) + 32*1024;
2349 flash_cmd.va = pci_alloc_consistent(adapter->pdev, flash_cmd.size,
2350 &flash_cmd.dma);
2351 if (!flash_cmd.va) {
2352 status = -ENOMEM;
2353 dev_err(&adapter->pdev->dev,
2354 "Memory allocation failure while flashing\n");
2355 goto fw_exit;
2356 }
2357
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002358 if ((adapter->generation == BE_GEN3) &&
2359 (get_ufigen_type(fhdr) == BE_GEN3)) {
2360 fhdr3 = (struct flash_file_hdr_g3 *) fw->data;
Ajit Khaparde8b93b712010-03-31 01:57:10 +00002361 num_imgs = le32_to_cpu(fhdr3->num_imgs);
2362 for (i = 0; i < num_imgs; i++) {
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002363 img_hdr_ptr = (struct image_hdr *) (fw->data +
2364 (sizeof(struct flash_file_hdr_g3) +
Ajit Khaparde8b93b712010-03-31 01:57:10 +00002365 i * sizeof(struct image_hdr)));
2366 if (le32_to_cpu(img_hdr_ptr->imageid) == 1)
2367 status = be_flash_data(adapter, fw, &flash_cmd,
2368 num_imgs);
Ajit Khaparde3f0d4562010-02-09 01:30:35 +00002369 }
2370 } else if ((adapter->generation == BE_GEN2) &&
2371 (get_ufigen_type(fhdr) == BE_GEN2)) {
2372 status = be_flash_data(adapter, fw, &flash_cmd, 0);
2373 } else {
2374 dev_err(&adapter->pdev->dev,
2375 "UFI and Interface are not compatible for flashing\n");
2376 status = -1;
Ajit Khaparde84517482009-09-04 03:12:16 +00002377 }
2378
2379 pci_free_consistent(adapter->pdev, flash_cmd.size, flash_cmd.va,
2380 flash_cmd.dma);
2381 if (status) {
2382 dev_err(&adapter->pdev->dev, "Firmware load error\n");
2383 goto fw_exit;
2384 }
2385
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02002386 dev_info(&adapter->pdev->dev, "Firmware flashed successfully\n");
Ajit Khaparde84517482009-09-04 03:12:16 +00002387
2388fw_exit:
2389 release_firmware(fw);
2390 return status;
2391}
2392
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002393static struct net_device_ops be_netdev_ops = {
2394 .ndo_open = be_open,
2395 .ndo_stop = be_close,
2396 .ndo_start_xmit = be_xmit,
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002397 .ndo_set_rx_mode = be_set_multicast_list,
2398 .ndo_set_mac_address = be_mac_addr_set,
2399 .ndo_change_mtu = be_change_mtu,
2400 .ndo_validate_addr = eth_validate_addr,
2401 .ndo_vlan_rx_register = be_vlan_register,
2402 .ndo_vlan_rx_add_vid = be_vlan_add_vid,
2403 .ndo_vlan_rx_kill_vid = be_vlan_rem_vid,
Ajit Khaparde64600ea2010-07-23 01:50:34 +00002404 .ndo_set_vf_mac = be_set_vf_mac,
Ajit Khaparde1da87b72010-07-23 01:51:22 +00002405 .ndo_set_vf_vlan = be_set_vf_vlan,
Ajit Khapardee1d18732010-07-23 01:52:13 +00002406 .ndo_set_vf_tx_rate = be_set_vf_tx_rate,
Ajit Khaparde64600ea2010-07-23 01:50:34 +00002407 .ndo_get_vf_config = be_get_vf_config
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002408};
2409
2410static void be_netdev_init(struct net_device *netdev)
2411{
2412 struct be_adapter *adapter = netdev_priv(netdev);
2413
2414 netdev->features |= NETIF_F_SG | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
Ajit Khaparde583e3f32009-10-05 02:22:19 +00002415 NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_HW_CSUM |
Ajit Khaparde49e4b842010-06-14 04:56:07 +00002416 NETIF_F_GRO | NETIF_F_TSO6;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002417
Ajit Khaparde51c59872009-11-29 17:54:54 +00002418 netdev->vlan_features |= NETIF_F_SG | NETIF_F_TSO | NETIF_F_HW_CSUM;
2419
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002420 netdev->flags |= IFF_MULTICAST;
2421
Ajit Khaparde728a9972009-04-13 15:41:22 -07002422 adapter->rx_csum = true;
2423
Ajit Khaparde9e90c962009-11-06 02:06:59 +00002424 /* Default settings for Rx and Tx flow control */
2425 adapter->rx_fc = true;
2426 adapter->tx_fc = true;
2427
Ajit Khapardec190e3c2009-09-04 03:12:29 +00002428 netif_set_gso_max_size(netdev, 65535);
2429
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002430 BE_SET_NETDEV_OPS(netdev, &be_netdev_ops);
2431
2432 SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
2433
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002434 netif_napi_add(netdev, &adapter->rx_eq.napi, be_poll_rx,
2435 BE_NAPI_WEIGHT);
Sathya Perla5fb379e2009-06-18 00:02:59 +00002436 netif_napi_add(netdev, &adapter->tx_eq.napi, be_poll_tx_mcc,
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002437 BE_NAPI_WEIGHT);
2438
2439 netif_carrier_off(netdev);
2440 netif_stop_queue(netdev);
2441}
2442
2443static void be_unmap_pci_bars(struct be_adapter *adapter)
2444{
Sathya Perla8788fdc2009-07-27 22:52:03 +00002445 if (adapter->csr)
2446 iounmap(adapter->csr);
2447 if (adapter->db)
2448 iounmap(adapter->db);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002449 if (adapter->pcicfg && be_physfn(adapter))
Sathya Perla8788fdc2009-07-27 22:52:03 +00002450 iounmap(adapter->pcicfg);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002451}
2452
2453static int be_map_pci_bars(struct be_adapter *adapter)
2454{
2455 u8 __iomem *addr;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002456 int pcicfg_reg, db_reg;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002457
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002458 if (be_physfn(adapter)) {
2459 addr = ioremap_nocache(pci_resource_start(adapter->pdev, 2),
2460 pci_resource_len(adapter->pdev, 2));
2461 if (addr == NULL)
2462 return -ENOMEM;
2463 adapter->csr = addr;
2464 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002465
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002466 if (adapter->generation == BE_GEN2) {
2467 pcicfg_reg = 1;
2468 db_reg = 4;
2469 } else {
2470 pcicfg_reg = 0;
2471 if (be_physfn(adapter))
2472 db_reg = 4;
2473 else
2474 db_reg = 0;
2475 }
2476 addr = ioremap_nocache(pci_resource_start(adapter->pdev, db_reg),
2477 pci_resource_len(adapter->pdev, db_reg));
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002478 if (addr == NULL)
2479 goto pci_map_err;
Sathya Perla8788fdc2009-07-27 22:52:03 +00002480 adapter->db = addr;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002481
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002482 if (be_physfn(adapter)) {
2483 addr = ioremap_nocache(
2484 pci_resource_start(adapter->pdev, pcicfg_reg),
2485 pci_resource_len(adapter->pdev, pcicfg_reg));
2486 if (addr == NULL)
2487 goto pci_map_err;
2488 adapter->pcicfg = addr;
2489 } else
2490 adapter->pcicfg = adapter->db + SRIOV_VF_PCICFG_OFFSET;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002491
2492 return 0;
2493pci_map_err:
2494 be_unmap_pci_bars(adapter);
2495 return -ENOMEM;
2496}
2497
2498
2499static void be_ctrl_cleanup(struct be_adapter *adapter)
2500{
Sathya Perla8788fdc2009-07-27 22:52:03 +00002501 struct be_dma_mem *mem = &adapter->mbox_mem_alloced;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002502
2503 be_unmap_pci_bars(adapter);
2504
2505 if (mem->va)
2506 pci_free_consistent(adapter->pdev, mem->size,
2507 mem->va, mem->dma);
Sathya Perlae7b909a2009-11-22 22:01:10 +00002508
2509 mem = &adapter->mc_cmd_mem;
2510 if (mem->va)
2511 pci_free_consistent(adapter->pdev, mem->size,
2512 mem->va, mem->dma);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002513}
2514
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002515static int be_ctrl_init(struct be_adapter *adapter)
2516{
Sathya Perla8788fdc2009-07-27 22:52:03 +00002517 struct be_dma_mem *mbox_mem_alloc = &adapter->mbox_mem_alloced;
2518 struct be_dma_mem *mbox_mem_align = &adapter->mbox_mem;
Sathya Perlae7b909a2009-11-22 22:01:10 +00002519 struct be_dma_mem *mc_cmd_mem = &adapter->mc_cmd_mem;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002520 int status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002521
2522 status = be_map_pci_bars(adapter);
2523 if (status)
Sathya Perlae7b909a2009-11-22 22:01:10 +00002524 goto done;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002525
2526 mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
2527 mbox_mem_alloc->va = pci_alloc_consistent(adapter->pdev,
2528 mbox_mem_alloc->size, &mbox_mem_alloc->dma);
2529 if (!mbox_mem_alloc->va) {
Sathya Perlae7b909a2009-11-22 22:01:10 +00002530 status = -ENOMEM;
2531 goto unmap_pci_bars;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002532 }
Sathya Perlae7b909a2009-11-22 22:01:10 +00002533
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002534 mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
2535 mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
2536 mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
2537 memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
Sathya Perlae7b909a2009-11-22 22:01:10 +00002538
2539 mc_cmd_mem->size = sizeof(struct be_cmd_req_mcast_mac_config);
2540 mc_cmd_mem->va = pci_alloc_consistent(adapter->pdev, mc_cmd_mem->size,
2541 &mc_cmd_mem->dma);
2542 if (mc_cmd_mem->va == NULL) {
2543 status = -ENOMEM;
2544 goto free_mbox;
2545 }
2546 memset(mc_cmd_mem->va, 0, mc_cmd_mem->size);
2547
Sathya Perla8788fdc2009-07-27 22:52:03 +00002548 spin_lock_init(&adapter->mbox_lock);
2549 spin_lock_init(&adapter->mcc_lock);
2550 spin_lock_init(&adapter->mcc_cq_lock);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002551
Sarveshwar Bandidd131e72010-05-25 16:16:32 -07002552 init_completion(&adapter->flash_compl);
Sathya Perlacf588472010-02-14 21:22:01 +00002553 pci_save_state(adapter->pdev);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002554 return 0;
Sathya Perlae7b909a2009-11-22 22:01:10 +00002555
2556free_mbox:
2557 pci_free_consistent(adapter->pdev, mbox_mem_alloc->size,
2558 mbox_mem_alloc->va, mbox_mem_alloc->dma);
2559
2560unmap_pci_bars:
2561 be_unmap_pci_bars(adapter);
2562
2563done:
2564 return status;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002565}
2566
2567static void be_stats_cleanup(struct be_adapter *adapter)
2568{
2569 struct be_stats_obj *stats = &adapter->stats;
2570 struct be_dma_mem *cmd = &stats->cmd;
2571
2572 if (cmd->va)
2573 pci_free_consistent(adapter->pdev, cmd->size,
2574 cmd->va, cmd->dma);
2575}
2576
2577static int be_stats_init(struct be_adapter *adapter)
2578{
2579 struct be_stats_obj *stats = &adapter->stats;
2580 struct be_dma_mem *cmd = &stats->cmd;
2581
2582 cmd->size = sizeof(struct be_cmd_req_get_stats);
2583 cmd->va = pci_alloc_consistent(adapter->pdev, cmd->size, &cmd->dma);
2584 if (cmd->va == NULL)
2585 return -1;
David S. Millerd291b9a2010-01-28 21:36:21 -08002586 memset(cmd->va, 0, cmd->size);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002587 return 0;
2588}
2589
2590static void __devexit be_remove(struct pci_dev *pdev)
2591{
2592 struct be_adapter *adapter = pci_get_drvdata(pdev);
Sathya Perla8d56ff12009-11-22 22:02:26 +00002593
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002594 if (!adapter)
2595 return;
2596
2597 unregister_netdev(adapter->netdev);
2598
Sathya Perla5fb379e2009-06-18 00:02:59 +00002599 be_clear(adapter);
2600
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002601 be_stats_cleanup(adapter);
2602
2603 be_ctrl_cleanup(adapter);
2604
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002605 be_sriov_disable(adapter);
2606
Sathya Perla8d56ff12009-11-22 22:02:26 +00002607 be_msix_disable(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002608
2609 pci_set_drvdata(pdev, NULL);
2610 pci_release_regions(pdev);
2611 pci_disable_device(pdev);
2612
2613 free_netdev(adapter->netdev);
2614}
2615
Sathya Perla2243e2e2009-11-22 22:02:03 +00002616static int be_get_config(struct be_adapter *adapter)
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002617{
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002618 int status;
Sathya Perla2243e2e2009-11-22 22:02:03 +00002619 u8 mac[ETH_ALEN];
Sathya Perla43a04fdc2009-10-14 20:21:17 +00002620
Sathya Perla8788fdc2009-07-27 22:52:03 +00002621 status = be_cmd_get_fw_ver(adapter, adapter->fw_ver);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002622 if (status)
2623 return status;
2624
Ajit Khapardedcb9b562009-09-30 21:58:22 -07002625 status = be_cmd_query_fw_cfg(adapter,
Ajit Khaparde3486be22010-07-23 02:04:54 +00002626 &adapter->port_num, &adapter->function_mode);
Sathya Perla2243e2e2009-11-22 22:02:03 +00002627 if (status)
2628 return status;
2629
2630 memset(mac, 0, ETH_ALEN);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002631
2632 if (be_physfn(adapter)) {
2633 status = be_cmd_mac_addr_query(adapter, mac,
Sathya Perla2243e2e2009-11-22 22:02:03 +00002634 MAC_ADDRESS_TYPE_NETWORK, true /*permanent */, 0);
Ajit Khapardeca9e4982009-11-29 17:56:26 +00002635
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002636 if (status)
2637 return status;
Ajit Khapardeca9e4982009-11-29 17:56:26 +00002638
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002639 if (!is_valid_ether_addr(mac))
2640 return -EADDRNOTAVAIL;
2641
2642 memcpy(adapter->netdev->dev_addr, mac, ETH_ALEN);
2643 memcpy(adapter->netdev->perm_addr, mac, ETH_ALEN);
2644 }
Sathya Perla2243e2e2009-11-22 22:02:03 +00002645
Ajit Khaparde3486be22010-07-23 02:04:54 +00002646 if (adapter->function_mode & 0x400)
Ajit Khaparde82903e42010-02-09 01:34:57 +00002647 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED/4;
2648 else
2649 adapter->max_vlans = BE_NUM_VLANS_SUPPORTED;
2650
Sathya Perla2243e2e2009-11-22 22:02:03 +00002651 return 0;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002652}
2653
2654static int __devinit be_probe(struct pci_dev *pdev,
2655 const struct pci_device_id *pdev_id)
2656{
2657 int status = 0;
2658 struct be_adapter *adapter;
2659 struct net_device *netdev;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002660
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002661
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002662 status = pci_enable_device(pdev);
2663 if (status)
2664 goto do_none;
2665
2666 status = pci_request_regions(pdev, DRV_NAME);
2667 if (status)
2668 goto disable_dev;
2669 pci_set_master(pdev);
2670
2671 netdev = alloc_etherdev(sizeof(struct be_adapter));
2672 if (netdev == NULL) {
2673 status = -ENOMEM;
2674 goto rel_reg;
2675 }
2676 adapter = netdev_priv(netdev);
Ajit Khaparde7b139c82010-01-27 21:56:44 +00002677
2678 switch (pdev->device) {
2679 case BE_DEVICE_ID1:
2680 case OC_DEVICE_ID1:
2681 adapter->generation = BE_GEN2;
2682 break;
2683 case BE_DEVICE_ID2:
2684 case OC_DEVICE_ID2:
2685 adapter->generation = BE_GEN3;
2686 break;
2687 default:
2688 adapter->generation = 0;
2689 }
2690
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002691 adapter->pdev = pdev;
2692 pci_set_drvdata(pdev, adapter);
2693 adapter->netdev = netdev;
Sathya Perla2243e2e2009-11-22 22:02:03 +00002694 be_netdev_init(netdev);
2695 SET_NETDEV_DEV(netdev, &pdev->dev);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002696
2697 be_msix_enable(adapter);
2698
Yang Hongyange9304382009-04-13 14:40:14 -07002699 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002700 if (!status) {
2701 netdev->features |= NETIF_F_HIGHDMA;
2702 } else {
Yang Hongyange9304382009-04-13 14:40:14 -07002703 status = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002704 if (status) {
2705 dev_err(&pdev->dev, "Could not set PCI DMA Mask\n");
2706 goto free_netdev;
2707 }
2708 }
2709
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002710 be_sriov_enable(adapter);
2711
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002712 status = be_ctrl_init(adapter);
2713 if (status)
2714 goto free_netdev;
2715
Sathya Perla2243e2e2009-11-22 22:02:03 +00002716 /* sync up with fw's ready state */
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002717 if (be_physfn(adapter)) {
2718 status = be_cmd_POST(adapter);
2719 if (status)
2720 goto ctrl_clean;
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002721 }
Sathya Perla2243e2e2009-11-22 22:02:03 +00002722
2723 /* tell fw we're ready to fire cmds */
2724 status = be_cmd_fw_init(adapter);
2725 if (status)
2726 goto ctrl_clean;
2727
Sarveshwar Bandi556ae192010-05-24 18:38:25 -07002728 if (be_physfn(adapter)) {
2729 status = be_cmd_reset_function(adapter);
2730 if (status)
2731 goto ctrl_clean;
2732 }
2733
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002734 status = be_stats_init(adapter);
2735 if (status)
2736 goto ctrl_clean;
2737
Sathya Perla2243e2e2009-11-22 22:02:03 +00002738 status = be_get_config(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002739 if (status)
2740 goto stats_clean;
2741
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002742 INIT_DELAYED_WORK(&adapter->work, be_worker);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002743
Sathya Perla5fb379e2009-06-18 00:02:59 +00002744 status = be_setup(adapter);
2745 if (status)
2746 goto stats_clean;
Sathya Perla2243e2e2009-11-22 22:02:03 +00002747
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002748 status = register_netdev(netdev);
2749 if (status != 0)
Sathya Perla5fb379e2009-06-18 00:02:59 +00002750 goto unsetup;
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002751
Ajit Khapardec4ca2372009-05-18 15:38:55 -07002752 dev_info(&pdev->dev, "%s port %d\n", nic_name(pdev), adapter->port_num);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002753 return 0;
2754
Sathya Perla5fb379e2009-06-18 00:02:59 +00002755unsetup:
2756 be_clear(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002757stats_clean:
2758 be_stats_cleanup(adapter);
2759ctrl_clean:
2760 be_ctrl_cleanup(adapter);
2761free_netdev:
Sathya Perla8d56ff12009-11-22 22:02:26 +00002762 be_msix_disable(adapter);
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002763 be_sriov_disable(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002764 free_netdev(adapter->netdev);
Sathya Perla8d56ff12009-11-22 22:02:26 +00002765 pci_set_drvdata(pdev, NULL);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002766rel_reg:
2767 pci_release_regions(pdev);
2768disable_dev:
2769 pci_disable_device(pdev);
2770do_none:
Ajit Khapardec4ca2372009-05-18 15:38:55 -07002771 dev_err(&pdev->dev, "%s initialization failed\n", nic_name(pdev));
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002772 return status;
2773}
2774
2775static int be_suspend(struct pci_dev *pdev, pm_message_t state)
2776{
2777 struct be_adapter *adapter = pci_get_drvdata(pdev);
2778 struct net_device *netdev = adapter->netdev;
2779
Ajit Khaparde71d8d1b2009-12-03 06:16:59 +00002780 if (adapter->wol)
2781 be_setup_wol(adapter, true);
2782
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002783 netif_device_detach(netdev);
2784 if (netif_running(netdev)) {
2785 rtnl_lock();
2786 be_close(netdev);
2787 rtnl_unlock();
2788 }
Ajit Khaparde9e90c962009-11-06 02:06:59 +00002789 be_cmd_get_flow_control(adapter, &adapter->tx_fc, &adapter->rx_fc);
Sarveshwar Bandi9b0365f2009-08-12 21:01:29 +00002790 be_clear(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002791
2792 pci_save_state(pdev);
2793 pci_disable_device(pdev);
2794 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2795 return 0;
2796}
2797
2798static int be_resume(struct pci_dev *pdev)
2799{
2800 int status = 0;
2801 struct be_adapter *adapter = pci_get_drvdata(pdev);
2802 struct net_device *netdev = adapter->netdev;
2803
2804 netif_device_detach(netdev);
2805
2806 status = pci_enable_device(pdev);
2807 if (status)
2808 return status;
2809
2810 pci_set_power_state(pdev, 0);
2811 pci_restore_state(pdev);
2812
Sathya Perla2243e2e2009-11-22 22:02:03 +00002813 /* tell fw we're ready to fire cmds */
2814 status = be_cmd_fw_init(adapter);
2815 if (status)
2816 return status;
2817
Sarveshwar Bandi9b0365f2009-08-12 21:01:29 +00002818 be_setup(adapter);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002819 if (netif_running(netdev)) {
2820 rtnl_lock();
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002821 be_open(netdev);
2822 rtnl_unlock();
2823 }
2824 netif_device_attach(netdev);
Ajit Khaparde71d8d1b2009-12-03 06:16:59 +00002825
2826 if (adapter->wol)
2827 be_setup_wol(adapter, false);
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002828 return 0;
2829}
2830
Sathya Perla82456b02010-02-17 01:35:37 +00002831/*
2832 * An FLR will stop BE from DMAing any data.
2833 */
2834static void be_shutdown(struct pci_dev *pdev)
2835{
2836 struct be_adapter *adapter = pci_get_drvdata(pdev);
2837 struct net_device *netdev = adapter->netdev;
2838
2839 netif_device_detach(netdev);
2840
2841 be_cmd_reset_function(adapter);
2842
2843 if (adapter->wol)
2844 be_setup_wol(adapter, true);
2845
2846 pci_disable_device(pdev);
Sathya Perla82456b02010-02-17 01:35:37 +00002847}
2848
Sathya Perlacf588472010-02-14 21:22:01 +00002849static pci_ers_result_t be_eeh_err_detected(struct pci_dev *pdev,
2850 pci_channel_state_t state)
2851{
2852 struct be_adapter *adapter = pci_get_drvdata(pdev);
2853 struct net_device *netdev = adapter->netdev;
2854
2855 dev_err(&adapter->pdev->dev, "EEH error detected\n");
2856
2857 adapter->eeh_err = true;
2858
2859 netif_device_detach(netdev);
2860
2861 if (netif_running(netdev)) {
2862 rtnl_lock();
2863 be_close(netdev);
2864 rtnl_unlock();
2865 }
2866 be_clear(adapter);
2867
2868 if (state == pci_channel_io_perm_failure)
2869 return PCI_ERS_RESULT_DISCONNECT;
2870
2871 pci_disable_device(pdev);
2872
2873 return PCI_ERS_RESULT_NEED_RESET;
2874}
2875
2876static pci_ers_result_t be_eeh_reset(struct pci_dev *pdev)
2877{
2878 struct be_adapter *adapter = pci_get_drvdata(pdev);
2879 int status;
2880
2881 dev_info(&adapter->pdev->dev, "EEH reset\n");
2882 adapter->eeh_err = false;
2883
2884 status = pci_enable_device(pdev);
2885 if (status)
2886 return PCI_ERS_RESULT_DISCONNECT;
2887
2888 pci_set_master(pdev);
2889 pci_set_power_state(pdev, 0);
2890 pci_restore_state(pdev);
2891
2892 /* Check if card is ok and fw is ready */
2893 status = be_cmd_POST(adapter);
2894 if (status)
2895 return PCI_ERS_RESULT_DISCONNECT;
2896
2897 return PCI_ERS_RESULT_RECOVERED;
2898}
2899
2900static void be_eeh_resume(struct pci_dev *pdev)
2901{
2902 int status = 0;
2903 struct be_adapter *adapter = pci_get_drvdata(pdev);
2904 struct net_device *netdev = adapter->netdev;
2905
2906 dev_info(&adapter->pdev->dev, "EEH resume\n");
2907
2908 pci_save_state(pdev);
2909
2910 /* tell fw we're ready to fire cmds */
2911 status = be_cmd_fw_init(adapter);
2912 if (status)
2913 goto err;
2914
2915 status = be_setup(adapter);
2916 if (status)
2917 goto err;
2918
2919 if (netif_running(netdev)) {
2920 status = be_open(netdev);
2921 if (status)
2922 goto err;
2923 }
2924 netif_device_attach(netdev);
2925 return;
2926err:
2927 dev_err(&adapter->pdev->dev, "EEH resume failed\n");
Sathya Perlacf588472010-02-14 21:22:01 +00002928}
2929
2930static struct pci_error_handlers be_eeh_handlers = {
2931 .error_detected = be_eeh_err_detected,
2932 .slot_reset = be_eeh_reset,
2933 .resume = be_eeh_resume,
2934};
2935
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002936static struct pci_driver be_driver = {
2937 .name = DRV_NAME,
2938 .id_table = be_dev_ids,
2939 .probe = be_probe,
2940 .remove = be_remove,
2941 .suspend = be_suspend,
Sathya Perlacf588472010-02-14 21:22:01 +00002942 .resume = be_resume,
Sathya Perla82456b02010-02-17 01:35:37 +00002943 .shutdown = be_shutdown,
Sathya Perlacf588472010-02-14 21:22:01 +00002944 .err_handler = &be_eeh_handlers
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002945};
2946
2947static int __init be_init_module(void)
2948{
Joe Perches8e95a202009-12-03 07:58:21 +00002949 if (rx_frag_size != 8192 && rx_frag_size != 4096 &&
2950 rx_frag_size != 2048) {
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002951 printk(KERN_WARNING DRV_NAME
2952 " : Module param rx_frag_size must be 2048/4096/8192."
2953 " Using 2048\n");
2954 rx_frag_size = 2048;
2955 }
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002956
Sarveshwar Bandiba343c72010-03-31 02:56:12 +00002957 if (num_vfs > 32) {
2958 printk(KERN_WARNING DRV_NAME
2959 " : Module param num_vfs must not be greater than 32."
2960 "Using 32\n");
2961 num_vfs = 32;
2962 }
2963
Sathya Perla6b7c5b92009-03-11 23:32:03 -07002964 return pci_register_driver(&be_driver);
2965}
2966module_init(be_init_module);
2967
2968static void __exit be_exit_module(void)
2969{
2970 pci_unregister_driver(&be_driver);
2971}
2972module_exit(be_exit_module);