projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
drivers/net: use vzalloc()
[deliverable/linux.git] / drivers / net / qlcnic / qlcnic_init.c
1 /*
2 * Copyright (C) 2009 - QLogic Corporation.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 * MA 02111-1307, USA.
19 *
20 * The full GNU General Public License is included in this distribution
21 * in the file called "COPYING".
22 *
23 */
24
25 #include <linux/netdevice.h>
26 #include <linux/delay.h>
27 #include <linux/slab.h>
28 #include <linux/if_vlan.h>
29 #include "qlcnic.h"
30
31 struct crb_addr_pair {
32 u32 addr;
33 u32 data;
34 };
35
36 #define QLCNIC_MAX_CRB_XFORM 60
37 static unsigned int crb_addr_xform[QLCNIC_MAX_CRB_XFORM];
38
39 #define crb_addr_transform(name) \
40 (crb_addr_xform[QLCNIC_HW_PX_MAP_CRB_##name] = \
41 QLCNIC_HW_CRB_HUB_AGT_ADR_##name << 20)
42
43 #define QLCNIC_ADDR_ERROR (0xffffffff)
44
45 static void
46 qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter *adapter,
47 struct qlcnic_host_rds_ring *rds_ring);
48
49 static int
50 qlcnic_check_fw_hearbeat(struct qlcnic_adapter *adapter);
51
52 static void crb_addr_transform_setup(void)
53 {
54 crb_addr_transform(XDMA);
55 crb_addr_transform(TIMR);
56 crb_addr_transform(SRE);
57 crb_addr_transform(SQN3);
58 crb_addr_transform(SQN2);
59 crb_addr_transform(SQN1);
60 crb_addr_transform(SQN0);
61 crb_addr_transform(SQS3);
62 crb_addr_transform(SQS2);
63 crb_addr_transform(SQS1);
64 crb_addr_transform(SQS0);
65 crb_addr_transform(RPMX7);
66 crb_addr_transform(RPMX6);
67 crb_addr_transform(RPMX5);
68 crb_addr_transform(RPMX4);
69 crb_addr_transform(RPMX3);
70 crb_addr_transform(RPMX2);
71 crb_addr_transform(RPMX1);
72 crb_addr_transform(RPMX0);
73 crb_addr_transform(ROMUSB);
74 crb_addr_transform(SN);
75 crb_addr_transform(QMN);
76 crb_addr_transform(QMS);
77 crb_addr_transform(PGNI);
78 crb_addr_transform(PGND);
79 crb_addr_transform(PGN3);
80 crb_addr_transform(PGN2);
81 crb_addr_transform(PGN1);
82 crb_addr_transform(PGN0);
83 crb_addr_transform(PGSI);
84 crb_addr_transform(PGSD);
85 crb_addr_transform(PGS3);
86 crb_addr_transform(PGS2);
87 crb_addr_transform(PGS1);
88 crb_addr_transform(PGS0);
89 crb_addr_transform(PS);
90 crb_addr_transform(PH);
91 crb_addr_transform(NIU);
92 crb_addr_transform(I2Q);
93 crb_addr_transform(EG);
94 crb_addr_transform(MN);
95 crb_addr_transform(MS);
96 crb_addr_transform(CAS2);
97 crb_addr_transform(CAS1);
98 crb_addr_transform(CAS0);
99 crb_addr_transform(CAM);
100 crb_addr_transform(C2C1);
101 crb_addr_transform(C2C0);
102 crb_addr_transform(SMB);
103 crb_addr_transform(OCM0);
104 crb_addr_transform(I2C0);
105 }
106
107 void qlcnic_release_rx_buffers(struct qlcnic_adapter *adapter)
108 {
109 struct qlcnic_recv_context *recv_ctx;
110 struct qlcnic_host_rds_ring *rds_ring;
111 struct qlcnic_rx_buffer *rx_buf;
112 int i, ring;
113
114 recv_ctx = &adapter->recv_ctx;
115 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
116 rds_ring = &recv_ctx->rds_rings[ring];
117 for (i = 0; i < rds_ring->num_desc; ++i) {
118 rx_buf = &(rds_ring->rx_buf_arr[i]);
119 if (rx_buf->skb == NULL)
120 continue;
121
122 pci_unmap_single(adapter->pdev,
123 rx_buf->dma,
124 rds_ring->dma_size,
125 PCI_DMA_FROMDEVICE);
126
127 dev_kfree_skb_any(rx_buf->skb);
128 }
129 }
130 }
131
132 void qlcnic_reset_rx_buffers_list(struct qlcnic_adapter *adapter)
133 {
134 struct qlcnic_recv_context *recv_ctx;
135 struct qlcnic_host_rds_ring *rds_ring;
136 struct qlcnic_rx_buffer *rx_buf;
137 int i, ring;
138
139 recv_ctx = &adapter->recv_ctx;
140 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
141 rds_ring = &recv_ctx->rds_rings[ring];
142
143 INIT_LIST_HEAD(&rds_ring->free_list);
144
145 rx_buf = rds_ring->rx_buf_arr;
146 for (i = 0; i < rds_ring->num_desc; i++) {
147 list_add_tail(&rx_buf->list,
148 &rds_ring->free_list);
149 rx_buf++;
150 }
151 }
152 }
153
154 void qlcnic_release_tx_buffers(struct qlcnic_adapter *adapter)
155 {
156 struct qlcnic_cmd_buffer *cmd_buf;
157 struct qlcnic_skb_frag *buffrag;
158 int i, j;
159 struct qlcnic_host_tx_ring *tx_ring = adapter->tx_ring;
160
161 cmd_buf = tx_ring->cmd_buf_arr;
162 for (i = 0; i < tx_ring->num_desc; i++) {
163 buffrag = cmd_buf->frag_array;
164 if (buffrag->dma) {
165 pci_unmap_single(adapter->pdev, buffrag->dma,
166 buffrag->length, PCI_DMA_TODEVICE);
167 buffrag->dma = 0ULL;
168 }
169 for (j = 0; j < cmd_buf->frag_count; j++) {
170 buffrag++;
171 if (buffrag->dma) {
172 pci_unmap_page(adapter->pdev, buffrag->dma,
173 buffrag->length,
174 PCI_DMA_TODEVICE);
175 buffrag->dma = 0ULL;
176 }
177 }
178 if (cmd_buf->skb) {
179 dev_kfree_skb_any(cmd_buf->skb);
180 cmd_buf->skb = NULL;
181 }
182 cmd_buf++;
183 }
184 }
185
186 void qlcnic_free_sw_resources(struct qlcnic_adapter *adapter)
187 {
188 struct qlcnic_recv_context *recv_ctx;
189 struct qlcnic_host_rds_ring *rds_ring;
190 struct qlcnic_host_tx_ring *tx_ring;
191 int ring;
192
193 recv_ctx = &adapter->recv_ctx;
194
195 if (recv_ctx->rds_rings == NULL)
196 goto skip_rds;
197
198 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
199 rds_ring = &recv_ctx->rds_rings[ring];
200 vfree(rds_ring->rx_buf_arr);
201 rds_ring->rx_buf_arr = NULL;
202 }
203 kfree(recv_ctx->rds_rings);
204
205 skip_rds:
206 if (adapter->tx_ring == NULL)
207 return;
208
209 tx_ring = adapter->tx_ring;
210 vfree(tx_ring->cmd_buf_arr);
211 tx_ring->cmd_buf_arr = NULL;
212 kfree(adapter->tx_ring);
213 adapter->tx_ring = NULL;
214 }
215
216 int qlcnic_alloc_sw_resources(struct qlcnic_adapter *adapter)
217 {
218 struct qlcnic_recv_context *recv_ctx;
219 struct qlcnic_host_rds_ring *rds_ring;
220 struct qlcnic_host_sds_ring *sds_ring;
221 struct qlcnic_host_tx_ring *tx_ring;
222 struct qlcnic_rx_buffer *rx_buf;
223 int ring, i, size;
224
225 struct qlcnic_cmd_buffer *cmd_buf_arr;
226 struct net_device *netdev = adapter->netdev;
227
228 size = sizeof(struct qlcnic_host_tx_ring);
229 tx_ring = kzalloc(size, GFP_KERNEL);
230 if (tx_ring == NULL) {
231 dev_err(&netdev->dev, "failed to allocate tx ring struct\n");
232 return -ENOMEM;
233 }
234 adapter->tx_ring = tx_ring;
235
236 tx_ring->num_desc = adapter->num_txd;
237 tx_ring->txq = netdev_get_tx_queue(netdev, 0);
238
239 cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
240 if (cmd_buf_arr == NULL) {
241 dev_err(&netdev->dev, "failed to allocate cmd buffer ring\n");
242 goto err_out;
243 }
244 tx_ring->cmd_buf_arr = cmd_buf_arr;
245
246 recv_ctx = &adapter->recv_ctx;
247
248 size = adapter->max_rds_rings * sizeof(struct qlcnic_host_rds_ring);
249 rds_ring = kzalloc(size, GFP_KERNEL);
250 if (rds_ring == NULL) {
251 dev_err(&netdev->dev, "failed to allocate rds ring struct\n");
252 goto err_out;
253 }
254 recv_ctx->rds_rings = rds_ring;
255
256 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
257 rds_ring = &recv_ctx->rds_rings[ring];
258 switch (ring) {
259 case RCV_RING_NORMAL:
260 rds_ring->num_desc = adapter->num_rxd;
261 rds_ring->dma_size = QLCNIC_P3P_RX_BUF_MAX_LEN;
262 rds_ring->skb_size = rds_ring->dma_size + NET_IP_ALIGN;
263 break;
264
265 case RCV_RING_JUMBO:
266 rds_ring->num_desc = adapter->num_jumbo_rxd;
267 rds_ring->dma_size =
268 QLCNIC_P3P_RX_JUMBO_BUF_MAX_LEN;
269
270 if (adapter->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
271 rds_ring->dma_size += QLCNIC_LRO_BUFFER_EXTRA;
272
273 rds_ring->skb_size =
274 rds_ring->dma_size + NET_IP_ALIGN;
275 break;
276 }
277 rds_ring->rx_buf_arr = (struct qlcnic_rx_buffer *)
278 vzalloc(RCV_BUFF_RINGSIZE(rds_ring));
279 if (rds_ring->rx_buf_arr == NULL) {
280 dev_err(&netdev->dev, "Failed to allocate "
281 "rx buffer ring %d\n", ring);
282 goto err_out;
283 }
284 INIT_LIST_HEAD(&rds_ring->free_list);
285 /*
286 * Now go through all of them, set reference handles
287 * and put them in the queues.
288 */
289 rx_buf = rds_ring->rx_buf_arr;
290 for (i = 0; i < rds_ring->num_desc; i++) {
291 list_add_tail(&rx_buf->list,
292 &rds_ring->free_list);
293 rx_buf->ref_handle = i;
294 rx_buf++;
295 }
296 spin_lock_init(&rds_ring->lock);
297 }
298
299 for (ring = 0; ring < adapter->max_sds_rings; ring++) {
300 sds_ring = &recv_ctx->sds_rings[ring];
301 sds_ring->irq = adapter->msix_entries[ring].vector;
302 sds_ring->adapter = adapter;
303 sds_ring->num_desc = adapter->num_rxd;
304
305 for (i = 0; i < NUM_RCV_DESC_RINGS; i++)
306 INIT_LIST_HEAD(&sds_ring->free_list[i]);
307 }
308
309 return 0;
310
311 err_out:
312 qlcnic_free_sw_resources(adapter);
313 return -ENOMEM;
314 }
315
316 /*
317 * Utility to translate from internal Phantom CRB address
318 * to external PCI CRB address.
319 */
320 static u32 qlcnic_decode_crb_addr(u32 addr)
321 {
322 int i;
323 u32 base_addr, offset, pci_base;
324
325 crb_addr_transform_setup();
326
327 pci_base = QLCNIC_ADDR_ERROR;
328 base_addr = addr & 0xfff00000;
329 offset = addr & 0x000fffff;
330
331 for (i = 0; i < QLCNIC_MAX_CRB_XFORM; i++) {
332 if (crb_addr_xform[i] == base_addr) {
333 pci_base = i << 20;
334 break;
335 }
336 }
337 if (pci_base == QLCNIC_ADDR_ERROR)
338 return pci_base;
339 else
340 return pci_base + offset;
341 }
342
343 #define QLCNIC_MAX_ROM_WAIT_USEC 100
344
345 static int qlcnic_wait_rom_done(struct qlcnic_adapter *adapter)
346 {
347 long timeout = 0;
348 long done = 0;
349
350 cond_resched();
351
352 while (done == 0) {
353 done = QLCRD32(adapter, QLCNIC_ROMUSB_GLB_STATUS);
354 done &= 2;
355 if (++timeout >= QLCNIC_MAX_ROM_WAIT_USEC) {
356 dev_err(&adapter->pdev->dev,
357 "Timeout reached waiting for rom done");
358 return -EIO;
359 }
360 udelay(1);
361 }
362 return 0;
363 }
364
365 static int do_rom_fast_read(struct qlcnic_adapter *adapter,
366 int addr, int *valp)
367 {
368 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ADDRESS, addr);
369 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
370 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ABYTE_CNT, 3);
371 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_INSTR_OPCODE, 0xb);
372 if (qlcnic_wait_rom_done(adapter)) {
373 dev_err(&adapter->pdev->dev, "Error waiting for rom done\n");
374 return -EIO;
375 }
376 /* reset abyte_cnt and dummy_byte_cnt */
377 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ABYTE_CNT, 0);
378 udelay(10);
379 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
380
381 *valp = QLCRD32(adapter, QLCNIC_ROMUSB_ROM_RDATA);
382 return 0;
383 }
384
385 static int do_rom_fast_read_words(struct qlcnic_adapter *adapter, int addr,
386 u8 *bytes, size_t size)
387 {
388 int addridx;
389 int ret = 0;
390
391 for (addridx = addr; addridx < (addr + size); addridx += 4) {
392 int v;
393 ret = do_rom_fast_read(adapter, addridx, &v);
394 if (ret != 0)
395 break;
396 *(__le32 *)bytes = cpu_to_le32(v);
397 bytes += 4;
398 }
399
400 return ret;
401 }
402
403 int
404 qlcnic_rom_fast_read_words(struct qlcnic_adapter *adapter, int addr,
405 u8 *bytes, size_t size)
406 {
407 int ret;
408
409 ret = qlcnic_rom_lock(adapter);
410 if (ret < 0)
411 return ret;
412
413 ret = do_rom_fast_read_words(adapter, addr, bytes, size);
414
415 qlcnic_rom_unlock(adapter);
416 return ret;
417 }
418
419 int qlcnic_rom_fast_read(struct qlcnic_adapter *adapter, int addr, int *valp)
420 {
421 int ret;
422
423 if (qlcnic_rom_lock(adapter) != 0)
424 return -EIO;
425
426 ret = do_rom_fast_read(adapter, addr, valp);
427 qlcnic_rom_unlock(adapter);
428 return ret;
429 }
430
431 int qlcnic_pinit_from_rom(struct qlcnic_adapter *adapter)
432 {
433 int addr, val;
434 int i, n, init_delay;
435 struct crb_addr_pair *buf;
436 unsigned offset;
437 u32 off;
438 struct pci_dev *pdev = adapter->pdev;
439
440 QLCWR32(adapter, CRB_CMDPEG_STATE, 0);
441 QLCWR32(adapter, CRB_RCVPEG_STATE, 0);
442
443 qlcnic_rom_lock(adapter);
444 QLCWR32(adapter, QLCNIC_ROMUSB_GLB_SW_RESET, 0xfeffffff);
445 qlcnic_rom_unlock(adapter);
446
447 /* Init HW CRB block */
448 if (qlcnic_rom_fast_read(adapter, 0, &n) != 0 || (n != 0xcafecafe) ||
449 qlcnic_rom_fast_read(adapter, 4, &n) != 0) {
450 dev_err(&pdev->dev, "ERROR Reading crb_init area: val:%x\n", n);
451 return -EIO;
452 }
453 offset = n & 0xffffU;
454 n = (n >> 16) & 0xffffU;
455
456 if (n >= 1024) {
457 dev_err(&pdev->dev, "QLOGIC card flash not initialized.\n");
458 return -EIO;
459 }
460
461 buf = kcalloc(n, sizeof(struct crb_addr_pair), GFP_KERNEL);
462 if (buf == NULL) {
463 dev_err(&pdev->dev, "Unable to calloc memory for rom read.\n");
464 return -ENOMEM;
465 }
466
467 for (i = 0; i < n; i++) {
468 if (qlcnic_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
469 qlcnic_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
470 kfree(buf);
471 return -EIO;
472 }
473
474 buf[i].addr = addr;
475 buf[i].data = val;
476 }
477
478 for (i = 0; i < n; i++) {
479
480 off = qlcnic_decode_crb_addr(buf[i].addr);
481 if (off == QLCNIC_ADDR_ERROR) {
482 dev_err(&pdev->dev, "CRB init value out of range %x\n",
483 buf[i].addr);
484 continue;
485 }
486 off += QLCNIC_PCI_CRBSPACE;
487
488 if (off & 1)
489 continue;
490
491 /* skipping cold reboot MAGIC */
492 if (off == QLCNIC_CAM_RAM(0x1fc))
493 continue;
494 if (off == (QLCNIC_CRB_I2C0 + 0x1c))
495 continue;
496 if (off == (ROMUSB_GLB + 0xbc)) /* do not reset PCI */
497 continue;
498 if (off == (ROMUSB_GLB + 0xa8))
499 continue;
500 if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
501 continue;
502 if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
503 continue;
504 if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
505 continue;
506 if ((off & 0x0ff00000) == QLCNIC_CRB_DDR_NET)
507 continue;
508 /* skip the function enable register */
509 if (off == QLCNIC_PCIE_REG(PCIE_SETUP_FUNCTION))
510 continue;
511 if (off == QLCNIC_PCIE_REG(PCIE_SETUP_FUNCTION2))
512 continue;
513 if ((off & 0x0ff00000) == QLCNIC_CRB_SMB)
514 continue;
515
516 init_delay = 1;
517 /* After writing this register, HW needs time for CRB */
518 /* to quiet down (else crb_window returns 0xffffffff) */
519 if (off == QLCNIC_ROMUSB_GLB_SW_RESET)
520 init_delay = 1000;
521
522 QLCWR32(adapter, off, buf[i].data);
523
524 msleep(init_delay);
525 }
526 kfree(buf);
527
528 /* Initialize protocol process engine */
529 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_D + 0xec, 0x1e);
530 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_D + 0x4c, 8);
531 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_I + 0x4c, 8);
532 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x8, 0);
533 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0xc, 0);
534 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x8, 0);
535 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_1 + 0xc, 0);
536 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x8, 0);
537 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_2 + 0xc, 0);
538 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x8, 0);
539 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_3 + 0xc, 0);
540 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x8, 0);
541 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_4 + 0xc, 0);
542 msleep(1);
543 QLCWR32(adapter, QLCNIC_PEG_HALT_STATUS1, 0);
544 QLCWR32(adapter, QLCNIC_PEG_HALT_STATUS2, 0);
545 return 0;
546 }
547
548 static int qlcnic_cmd_peg_ready(struct qlcnic_adapter *adapter)
549 {
550 u32 val;
551 int retries = QLCNIC_CMDPEG_CHECK_RETRY_COUNT;
552
553 do {
554 val = QLCRD32(adapter, CRB_CMDPEG_STATE);
555
556 switch (val) {
557 case PHAN_INITIALIZE_COMPLETE:
558 case PHAN_INITIALIZE_ACK:
559 return 0;
560 case PHAN_INITIALIZE_FAILED:
561 goto out_err;
562 default:
563 break;
564 }
565
566 msleep(QLCNIC_CMDPEG_CHECK_DELAY);
567
568 } while (--retries);
569
570 QLCWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
571
572 out_err:
573 dev_err(&adapter->pdev->dev, "Command Peg initialization not "
574 "complete, state: 0x%x.\n", val);
575 return -EIO;
576 }
577
578 static int
579 qlcnic_receive_peg_ready(struct qlcnic_adapter *adapter)
580 {
581 u32 val;
582 int retries = QLCNIC_RCVPEG_CHECK_RETRY_COUNT;
583
584 do {
585 val = QLCRD32(adapter, CRB_RCVPEG_STATE);
586
587 if (val == PHAN_PEG_RCV_INITIALIZED)
588 return 0;
589
590 msleep(QLCNIC_RCVPEG_CHECK_DELAY);
591
592 } while (--retries);
593
594 if (!retries) {
595 dev_err(&adapter->pdev->dev, "Receive Peg initialization not "
596 "complete, state: 0x%x.\n", val);
597 return -EIO;
598 }
599
600 return 0;
601 }
602
603 int
604 qlcnic_check_fw_status(struct qlcnic_adapter *adapter)
605 {
606 int err;
607
608 err = qlcnic_cmd_peg_ready(adapter);
609 if (err)
610 return err;
611
612 err = qlcnic_receive_peg_ready(adapter);
613 if (err)
614 return err;
615
616 QLCWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
617
618 return err;
619 }
620
621 int
622 qlcnic_setup_idc_param(struct qlcnic_adapter *adapter) {
623
624 int timeo;
625 u32 val;
626
627 val = QLCRD32(adapter, QLCNIC_CRB_DEV_PARTITION_INFO);
628 val = QLC_DEV_GET_DRV(val, adapter->portnum);
629 if ((val & 0x3) != QLCNIC_TYPE_NIC) {
630 dev_err(&adapter->pdev->dev,
631 "Not an Ethernet NIC func=%u\n", val);
632 return -EIO;
633 }
634 adapter->physical_port = (val >> 2);
635 if (qlcnic_rom_fast_read(adapter, QLCNIC_ROM_DEV_INIT_TIMEOUT, &timeo))
636 timeo = QLCNIC_INIT_TIMEOUT_SECS;
637
638 adapter->dev_init_timeo = timeo;
639
640 if (qlcnic_rom_fast_read(adapter, QLCNIC_ROM_DRV_RESET_TIMEOUT, &timeo))
641 timeo = QLCNIC_RESET_TIMEOUT_SECS;
642
643 adapter->reset_ack_timeo = timeo;
644
645 return 0;
646 }
647
648 int
649 qlcnic_check_flash_fw_ver(struct qlcnic_adapter *adapter)
650 {
651 u32 ver = -1, min_ver;
652
653 qlcnic_rom_fast_read(adapter, QLCNIC_FW_VERSION_OFFSET, (int *)&ver);
654
655 ver = QLCNIC_DECODE_VERSION(ver);
656 min_ver = QLCNIC_MIN_FW_VERSION;
657
658 if (ver < min_ver) {
659 dev_err(&adapter->pdev->dev,
660 "firmware version %d.%d.%d unsupported."
661 "Min supported version %d.%d.%d\n",
662 _major(ver), _minor(ver), _build(ver),
663 _major(min_ver), _minor(min_ver), _build(min_ver));
664 return -EINVAL;
665 }
666
667 return 0;
668 }
669
670 static int
671 qlcnic_has_mn(struct qlcnic_adapter *adapter)
672 {
673 u32 capability;
674 capability = 0;
675
676 capability = QLCRD32(adapter, QLCNIC_PEG_TUNE_CAPABILITY);
677 if (capability & QLCNIC_PEG_TUNE_MN_PRESENT)
678 return 1;
679
680 return 0;
681 }
682
683 static
684 struct uni_table_desc *qlcnic_get_table_desc(const u8 *unirom, int section)
685 {
686 u32 i;
687 struct uni_table_desc *directory = (struct uni_table_desc *) &unirom[0];
688 __le32 entries = cpu_to_le32(directory->num_entries);
689
690 for (i = 0; i < entries; i++) {
691
692 __le32 offs = cpu_to_le32(directory->findex) +
693 (i * cpu_to_le32(directory->entry_size));
694 __le32 tab_type = cpu_to_le32(*((u32 *)&unirom[offs] + 8));
695
696 if (tab_type == section)
697 return (struct uni_table_desc *) &unirom[offs];
698 }
699
700 return NULL;
701 }
702
703 #define FILEHEADER_SIZE (14 * 4)
704
705 static int
706 qlcnic_validate_header(struct qlcnic_adapter *adapter)
707 {
708 const u8 *unirom = adapter->fw->data;
709 struct uni_table_desc *directory = (struct uni_table_desc *) &unirom[0];
710 __le32 fw_file_size = adapter->fw->size;
711 __le32 entries;
712 __le32 entry_size;
713 __le32 tab_size;
714
715 if (fw_file_size < FILEHEADER_SIZE)
716 return -EINVAL;
717
718 entries = cpu_to_le32(directory->num_entries);
719 entry_size = cpu_to_le32(directory->entry_size);
720 tab_size = cpu_to_le32(directory->findex) + (entries * entry_size);
721
722 if (fw_file_size < tab_size)
723 return -EINVAL;
724
725 return 0;
726 }
727
728 static int
729 qlcnic_validate_bootld(struct qlcnic_adapter *adapter)
730 {
731 struct uni_table_desc *tab_desc;
732 struct uni_data_desc *descr;
733 const u8 *unirom = adapter->fw->data;
734 int idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
735 QLCNIC_UNI_BOOTLD_IDX_OFF));
736 __le32 offs;
737 __le32 tab_size;
738 __le32 data_size;
739
740 tab_desc = qlcnic_get_table_desc(unirom, QLCNIC_UNI_DIR_SECT_BOOTLD);
741
742 if (!tab_desc)
743 return -EINVAL;
744
745 tab_size = cpu_to_le32(tab_desc->findex) +
746 (cpu_to_le32(tab_desc->entry_size) * (idx + 1));
747
748 if (adapter->fw->size < tab_size)
749 return -EINVAL;
750
751 offs = cpu_to_le32(tab_desc->findex) +
752 (cpu_to_le32(tab_desc->entry_size) * (idx));
753 descr = (struct uni_data_desc *)&unirom[offs];
754
755 data_size = cpu_to_le32(descr->findex) + cpu_to_le32(descr->size);
756
757 if (adapter->fw->size < data_size)
758 return -EINVAL;
759
760 return 0;
761 }
762
763 static int
764 qlcnic_validate_fw(struct qlcnic_adapter *adapter)
765 {
766 struct uni_table_desc *tab_desc;
767 struct uni_data_desc *descr;
768 const u8 *unirom = adapter->fw->data;
769 int idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
770 QLCNIC_UNI_FIRMWARE_IDX_OFF));
771 __le32 offs;
772 __le32 tab_size;
773 __le32 data_size;
774
775 tab_desc = qlcnic_get_table_desc(unirom, QLCNIC_UNI_DIR_SECT_FW);
776
777 if (!tab_desc)
778 return -EINVAL;
779
780 tab_size = cpu_to_le32(tab_desc->findex) +
781 (cpu_to_le32(tab_desc->entry_size) * (idx + 1));
782
783 if (adapter->fw->size < tab_size)
784 return -EINVAL;
785
786 offs = cpu_to_le32(tab_desc->findex) +
787 (cpu_to_le32(tab_desc->entry_size) * (idx));
788 descr = (struct uni_data_desc *)&unirom[offs];
789 data_size = cpu_to_le32(descr->findex) + cpu_to_le32(descr->size);
790
791 if (adapter->fw->size < data_size)
792 return -EINVAL;
793
794 return 0;
795 }
796
797 static int
798 qlcnic_validate_product_offs(struct qlcnic_adapter *adapter)
799 {
800 struct uni_table_desc *ptab_descr;
801 const u8 *unirom = adapter->fw->data;
802 int mn_present = qlcnic_has_mn(adapter);
803 __le32 entries;
804 __le32 entry_size;
805 __le32 tab_size;
806 u32 i;
807
808 ptab_descr = qlcnic_get_table_desc(unirom,
809 QLCNIC_UNI_DIR_SECT_PRODUCT_TBL);
810 if (!ptab_descr)
811 return -EINVAL;
812
813 entries = cpu_to_le32(ptab_descr->num_entries);
814 entry_size = cpu_to_le32(ptab_descr->entry_size);
815 tab_size = cpu_to_le32(ptab_descr->findex) + (entries * entry_size);
816
817 if (adapter->fw->size < tab_size)
818 return -EINVAL;
819
820 nomn:
821 for (i = 0; i < entries; i++) {
822
823 __le32 flags, file_chiprev, offs;
824 u8 chiprev = adapter->ahw.revision_id;
825 u32 flagbit;
826
827 offs = cpu_to_le32(ptab_descr->findex) +
828 (i * cpu_to_le32(ptab_descr->entry_size));
829 flags = cpu_to_le32(*((int *)&unirom[offs] +
830 QLCNIC_UNI_FLAGS_OFF));
831 file_chiprev = cpu_to_le32(*((int *)&unirom[offs] +
832 QLCNIC_UNI_CHIP_REV_OFF));
833
834 flagbit = mn_present ? 1 : 2;
835
836 if ((chiprev == file_chiprev) &&
837 ((1ULL << flagbit) & flags)) {
838 adapter->file_prd_off = offs;
839 return 0;
840 }
841 }
842 if (mn_present) {
843 mn_present = 0;
844 goto nomn;
845 }
846 return -EINVAL;
847 }
848
849 static int
850 qlcnic_validate_unified_romimage(struct qlcnic_adapter *adapter)
851 {
852 if (qlcnic_validate_header(adapter)) {
853 dev_err(&adapter->pdev->dev,
854 "unified image: header validation failed\n");
855 return -EINVAL;
856 }
857
858 if (qlcnic_validate_product_offs(adapter)) {
859 dev_err(&adapter->pdev->dev,
860 "unified image: product validation failed\n");
861 return -EINVAL;
862 }
863
864 if (qlcnic_validate_bootld(adapter)) {
865 dev_err(&adapter->pdev->dev,
866 "unified image: bootld validation failed\n");
867 return -EINVAL;
868 }
869
870 if (qlcnic_validate_fw(adapter)) {
871 dev_err(&adapter->pdev->dev,
872 "unified image: firmware validation failed\n");
873 return -EINVAL;
874 }
875
876 return 0;
877 }
878
879 static
880 struct uni_data_desc *qlcnic_get_data_desc(struct qlcnic_adapter *adapter,
881 u32 section, u32 idx_offset)
882 {
883 const u8 *unirom = adapter->fw->data;
884 int idx = cpu_to_le32(*((int *)&unirom[adapter->file_prd_off] +
885 idx_offset));
886 struct uni_table_desc *tab_desc;
887 __le32 offs;
888
889 tab_desc = qlcnic_get_table_desc(unirom, section);
890
891 if (tab_desc == NULL)
892 return NULL;
893
894 offs = cpu_to_le32(tab_desc->findex) +
895 (cpu_to_le32(tab_desc->entry_size) * idx);
896
897 return (struct uni_data_desc *)&unirom[offs];
898 }
899
900 static u8 *
901 qlcnic_get_bootld_offs(struct qlcnic_adapter *adapter)
902 {
903 u32 offs = QLCNIC_BOOTLD_START;
904
905 if (adapter->fw_type == QLCNIC_UNIFIED_ROMIMAGE)
906 offs = cpu_to_le32((qlcnic_get_data_desc(adapter,
907 QLCNIC_UNI_DIR_SECT_BOOTLD,
908 QLCNIC_UNI_BOOTLD_IDX_OFF))->findex);
909
910 return (u8 *)&adapter->fw->data[offs];
911 }
912
913 static u8 *
914 qlcnic_get_fw_offs(struct qlcnic_adapter *adapter)
915 {
916 u32 offs = QLCNIC_IMAGE_START;
917
918 if (adapter->fw_type == QLCNIC_UNIFIED_ROMIMAGE)
919 offs = cpu_to_le32((qlcnic_get_data_desc(adapter,
920 QLCNIC_UNI_DIR_SECT_FW,
921 QLCNIC_UNI_FIRMWARE_IDX_OFF))->findex);
922
923 return (u8 *)&adapter->fw->data[offs];
924 }
925
926 static __le32
927 qlcnic_get_fw_size(struct qlcnic_adapter *adapter)
928 {
929 if (adapter->fw_type == QLCNIC_UNIFIED_ROMIMAGE)
930 return cpu_to_le32((qlcnic_get_data_desc(adapter,
931 QLCNIC_UNI_DIR_SECT_FW,
932 QLCNIC_UNI_FIRMWARE_IDX_OFF))->size);
933 else
934 return cpu_to_le32(
935 *(u32 *)&adapter->fw->data[QLCNIC_FW_SIZE_OFFSET]);
936 }
937
938 static __le32
939 qlcnic_get_fw_version(struct qlcnic_adapter *adapter)
940 {
941 struct uni_data_desc *fw_data_desc;
942 const struct firmware *fw = adapter->fw;
943 __le32 major, minor, sub;
944 const u8 *ver_str;
945 int i, ret;
946
947 if (adapter->fw_type != QLCNIC_UNIFIED_ROMIMAGE)
948 return cpu_to_le32(*(u32 *)&fw->data[QLCNIC_FW_VERSION_OFFSET]);
949
950 fw_data_desc = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_FW,
951 QLCNIC_UNI_FIRMWARE_IDX_OFF);
952 ver_str = fw->data + cpu_to_le32(fw_data_desc->findex) +
953 cpu_to_le32(fw_data_desc->size) - 17;
954
955 for (i = 0; i < 12; i++) {
956 if (!strncmp(&ver_str[i], "REV=", 4)) {
957 ret = sscanf(&ver_str[i+4], "%u.%u.%u ",
958 &major, &minor, &sub);
959 if (ret != 3)
960 return 0;
961 else
962 return major + (minor << 8) + (sub << 16);
963 }
964 }
965
966 return 0;
967 }
968
969 static __le32
970 qlcnic_get_bios_version(struct qlcnic_adapter *adapter)
971 {
972 const struct firmware *fw = adapter->fw;
973 __le32 bios_ver, prd_off = adapter->file_prd_off;
974
975 if (adapter->fw_type != QLCNIC_UNIFIED_ROMIMAGE)
976 return cpu_to_le32(
977 *(u32 *)&fw->data[QLCNIC_BIOS_VERSION_OFFSET]);
978
979 bios_ver = cpu_to_le32(*((u32 *) (&fw->data[prd_off])
980 + QLCNIC_UNI_BIOS_VERSION_OFF));
981
982 return (bios_ver << 16) + ((bios_ver >> 8) & 0xff00) + (bios_ver >> 24);
983 }
984
985 static void qlcnic_rom_lock_recovery(struct qlcnic_adapter *adapter)
986 {
987 if (qlcnic_pcie_sem_lock(adapter, 2, QLCNIC_ROM_LOCK_ID))
988 dev_info(&adapter->pdev->dev, "Resetting rom_lock\n");
989
990 qlcnic_pcie_sem_unlock(adapter, 2);
991 }
992
993 static int
994 qlcnic_check_fw_hearbeat(struct qlcnic_adapter *adapter)
995 {
996 u32 heartbeat, ret = -EIO;
997 int retries = QLCNIC_HEARTBEAT_CHECK_RETRY_COUNT;
998
999 adapter->heartbeat = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
1000
1001 do {
1002 msleep(QLCNIC_HEARTBEAT_PERIOD_MSECS);
1003 heartbeat = QLCRD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
1004 if (heartbeat != adapter->heartbeat) {
1005 ret = QLCNIC_RCODE_SUCCESS;
1006 break;
1007 }
1008 } while (--retries);
1009
1010 return ret;
1011 }
1012
1013 int
1014 qlcnic_need_fw_reset(struct qlcnic_adapter *adapter)
1015 {
1016 if (qlcnic_check_fw_hearbeat(adapter)) {
1017 qlcnic_rom_lock_recovery(adapter);
1018 return 1;
1019 }
1020
1021 if (adapter->need_fw_reset)
1022 return 1;
1023
1024 if (adapter->fw)
1025 return 1;
1026
1027 return 0;
1028 }
1029
1030 static const char *fw_name[] = {
1031 QLCNIC_UNIFIED_ROMIMAGE_NAME,
1032 QLCNIC_FLASH_ROMIMAGE_NAME,
1033 };
1034
1035 int
1036 qlcnic_load_firmware(struct qlcnic_adapter *adapter)
1037 {
1038 u64 *ptr64;
1039 u32 i, flashaddr, size;
1040 const struct firmware *fw = adapter->fw;
1041 struct pci_dev *pdev = adapter->pdev;
1042
1043 dev_info(&pdev->dev, "loading firmware from %s\n",
1044 fw_name[adapter->fw_type]);
1045
1046 if (fw) {
1047 __le64 data;
1048
1049 size = (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START) / 8;
1050
1051 ptr64 = (u64 *)qlcnic_get_bootld_offs(adapter);
1052 flashaddr = QLCNIC_BOOTLD_START;
1053
1054 for (i = 0; i < size; i++) {
1055 data = cpu_to_le64(ptr64[i]);
1056
1057 if (qlcnic_pci_mem_write_2M(adapter, flashaddr, data))
1058 return -EIO;
1059
1060 flashaddr += 8;
1061 }
1062
1063 size = (__force u32)qlcnic_get_fw_size(adapter) / 8;
1064
1065 ptr64 = (u64 *)qlcnic_get_fw_offs(adapter);
1066 flashaddr = QLCNIC_IMAGE_START;
1067
1068 for (i = 0; i < size; i++) {
1069 data = cpu_to_le64(ptr64[i]);
1070
1071 if (qlcnic_pci_mem_write_2M(adapter,
1072 flashaddr, data))
1073 return -EIO;
1074
1075 flashaddr += 8;
1076 }
1077
1078 size = (__force u32)qlcnic_get_fw_size(adapter) % 8;
1079 if (size) {
1080 data = cpu_to_le64(ptr64[i]);
1081
1082 if (qlcnic_pci_mem_write_2M(adapter,
1083 flashaddr, data))
1084 return -EIO;
1085 }
1086
1087 } else {
1088 u64 data;
1089 u32 hi, lo;
1090
1091 size = (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START) / 8;
1092 flashaddr = QLCNIC_BOOTLD_START;
1093
1094 for (i = 0; i < size; i++) {
1095 if (qlcnic_rom_fast_read(adapter,
1096 flashaddr, (int *)&lo) != 0)
1097 return -EIO;
1098 if (qlcnic_rom_fast_read(adapter,
1099 flashaddr + 4, (int *)&hi) != 0)
1100 return -EIO;
1101
1102 data = (((u64)hi << 32) | lo);
1103
1104 if (qlcnic_pci_mem_write_2M(adapter,
1105 flashaddr, data))
1106 return -EIO;
1107
1108 flashaddr += 8;
1109 }
1110 }
1111 msleep(1);
1112
1113 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x18, 0x1020);
1114 QLCWR32(adapter, QLCNIC_ROMUSB_GLB_SW_RESET, 0x80001e);
1115 return 0;
1116 }
1117
1118 static int
1119 qlcnic_validate_firmware(struct qlcnic_adapter *adapter)
1120 {
1121 __le32 val;
1122 u32 ver, bios, min_size;
1123 struct pci_dev *pdev = adapter->pdev;
1124 const struct firmware *fw = adapter->fw;
1125 u8 fw_type = adapter->fw_type;
1126
1127 if (fw_type == QLCNIC_UNIFIED_ROMIMAGE) {
1128 if (qlcnic_validate_unified_romimage(adapter))
1129 return -EINVAL;
1130
1131 min_size = QLCNIC_UNI_FW_MIN_SIZE;
1132 } else {
1133 val = cpu_to_le32(*(u32 *)&fw->data[QLCNIC_FW_MAGIC_OFFSET]);
1134 if ((__force u32)val != QLCNIC_BDINFO_MAGIC)
1135 return -EINVAL;
1136
1137 min_size = QLCNIC_FW_MIN_SIZE;
1138 }
1139
1140 if (fw->size < min_size)
1141 return -EINVAL;
1142
1143 val = qlcnic_get_fw_version(adapter);
1144 ver = QLCNIC_DECODE_VERSION(val);
1145
1146 if (ver < QLCNIC_MIN_FW_VERSION) {
1147 dev_err(&pdev->dev,
1148 "%s: firmware version %d.%d.%d unsupported\n",
1149 fw_name[fw_type], _major(ver), _minor(ver), _build(ver));
1150 return -EINVAL;
1151 }
1152
1153 val = qlcnic_get_bios_version(adapter);
1154 qlcnic_rom_fast_read(adapter, QLCNIC_BIOS_VERSION_OFFSET, (int *)&bios);
1155 if ((__force u32)val != bios) {
1156 dev_err(&pdev->dev, "%s: firmware bios is incompatible\n",
1157 fw_name[fw_type]);
1158 return -EINVAL;
1159 }
1160
1161 QLCWR32(adapter, QLCNIC_CAM_RAM(0x1fc), QLCNIC_BDINFO_MAGIC);
1162 return 0;
1163 }
1164
1165 static void
1166 qlcnic_get_next_fwtype(struct qlcnic_adapter *adapter)
1167 {
1168 u8 fw_type;
1169
1170 switch (adapter->fw_type) {
1171 case QLCNIC_UNKNOWN_ROMIMAGE:
1172 fw_type = QLCNIC_UNIFIED_ROMIMAGE;
1173 break;
1174
1175 case QLCNIC_UNIFIED_ROMIMAGE:
1176 default:
1177 fw_type = QLCNIC_FLASH_ROMIMAGE;
1178 break;
1179 }
1180
1181 adapter->fw_type = fw_type;
1182 }
1183
1184
1185
1186 void qlcnic_request_firmware(struct qlcnic_adapter *adapter)
1187 {
1188 struct pci_dev *pdev = adapter->pdev;
1189 int rc;
1190
1191 adapter->fw_type = QLCNIC_UNKNOWN_ROMIMAGE;
1192
1193 next:
1194 qlcnic_get_next_fwtype(adapter);
1195
1196 if (adapter->fw_type == QLCNIC_FLASH_ROMIMAGE) {
1197 adapter->fw = NULL;
1198 } else {
1199 rc = request_firmware(&adapter->fw,
1200 fw_name[adapter->fw_type], &pdev->dev);
1201 if (rc != 0)
1202 goto next;
1203
1204 rc = qlcnic_validate_firmware(adapter);
1205 if (rc != 0) {
1206 release_firmware(adapter->fw);
1207 msleep(1);
1208 goto next;
1209 }
1210 }
1211 }
1212
1213
1214 void
1215 qlcnic_release_firmware(struct qlcnic_adapter *adapter)
1216 {
1217 if (adapter->fw)
1218 release_firmware(adapter->fw);
1219 adapter->fw = NULL;
1220 }
1221
1222 static void
1223 qlcnic_handle_linkevent(struct qlcnic_adapter *adapter,
1224 struct qlcnic_fw_msg *msg)
1225 {
1226 u32 cable_OUI;
1227 u16 cable_len;
1228 u16 link_speed;
1229 u8 link_status, module, duplex, autoneg;
1230 struct net_device *netdev = adapter->netdev;
1231
1232 adapter->has_link_events = 1;
1233
1234 cable_OUI = msg->body[1] & 0xffffffff;
1235 cable_len = (msg->body[1] >> 32) & 0xffff;
1236 link_speed = (msg->body[1] >> 48) & 0xffff;
1237
1238 link_status = msg->body[2] & 0xff;
1239 duplex = (msg->body[2] >> 16) & 0xff;
1240 autoneg = (msg->body[2] >> 24) & 0xff;
1241
1242 module = (msg->body[2] >> 8) & 0xff;
1243 if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE)
1244 dev_info(&netdev->dev, "unsupported cable: OUI 0x%x, "
1245 "length %d\n", cable_OUI, cable_len);
1246 else if (module == LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN)
1247 dev_info(&netdev->dev, "unsupported cable length %d\n",
1248 cable_len);
1249
1250 qlcnic_advert_link_change(adapter, link_status);
1251
1252 if (duplex == LINKEVENT_FULL_DUPLEX)
1253 adapter->link_duplex = DUPLEX_FULL;
1254 else
1255 adapter->link_duplex = DUPLEX_HALF;
1256
1257 adapter->module_type = module;
1258 adapter->link_autoneg = autoneg;
1259 adapter->link_speed = link_speed;
1260 }
1261
1262 static void
1263 qlcnic_handle_fw_message(int desc_cnt, int index,
1264 struct qlcnic_host_sds_ring *sds_ring)
1265 {
1266 struct qlcnic_fw_msg msg;
1267 struct status_desc *desc;
1268 int i = 0, opcode;
1269
1270 while (desc_cnt > 0 && i < 8) {
1271 desc = &sds_ring->desc_head[index];
1272 msg.words[i++] = le64_to_cpu(desc->status_desc_data[0]);
1273 msg.words[i++] = le64_to_cpu(desc->status_desc_data[1]);
1274
1275 index = get_next_index(index, sds_ring->num_desc);
1276 desc_cnt--;
1277 }
1278
1279 opcode = qlcnic_get_nic_msg_opcode(msg.body[0]);
1280 switch (opcode) {
1281 case QLCNIC_C2H_OPCODE_GET_LINKEVENT_RESPONSE:
1282 qlcnic_handle_linkevent(sds_ring->adapter, &msg);
1283 break;
1284 default:
1285 break;
1286 }
1287 }
1288
1289 static int
1290 qlcnic_alloc_rx_skb(struct qlcnic_adapter *adapter,
1291 struct qlcnic_host_rds_ring *rds_ring,
1292 struct qlcnic_rx_buffer *buffer)
1293 {
1294 struct sk_buff *skb;
1295 dma_addr_t dma;
1296 struct pci_dev *pdev = adapter->pdev;
1297
1298 skb = dev_alloc_skb(rds_ring->skb_size);
1299 if (!skb) {
1300 adapter->stats.skb_alloc_failure++;
1301 return -ENOMEM;
1302 }
1303
1304 skb_reserve(skb, NET_IP_ALIGN);
1305
1306 dma = pci_map_single(pdev, skb->data,
1307 rds_ring->dma_size, PCI_DMA_FROMDEVICE);
1308
1309 if (pci_dma_mapping_error(pdev, dma)) {
1310 adapter->stats.rx_dma_map_error++;
1311 dev_kfree_skb_any(skb);
1312 return -ENOMEM;
1313 }
1314
1315 buffer->skb = skb;
1316 buffer->dma = dma;
1317
1318 return 0;
1319 }
1320
1321 static struct sk_buff *qlcnic_process_rxbuf(struct qlcnic_adapter *adapter,
1322 struct qlcnic_host_rds_ring *rds_ring, u16 index, u16 cksum)
1323 {
1324 struct qlcnic_rx_buffer *buffer;
1325 struct sk_buff *skb;
1326
1327 buffer = &rds_ring->rx_buf_arr[index];
1328
1329 if (unlikely(buffer->skb == NULL)) {
1330 WARN_ON(1);
1331 return NULL;
1332 }
1333
1334 pci_unmap_single(adapter->pdev, buffer->dma, rds_ring->dma_size,
1335 PCI_DMA_FROMDEVICE);
1336
1337 skb = buffer->skb;
1338
1339 if (likely(adapter->rx_csum && (cksum == STATUS_CKSUM_OK ||
1340 cksum == STATUS_CKSUM_LOOP))) {
1341 adapter->stats.csummed++;
1342 skb->ip_summed = CHECKSUM_UNNECESSARY;
1343 } else {
1344 skb_checksum_none_assert(skb);
1345 }
1346
1347 skb->dev = adapter->netdev;
1348
1349 buffer->skb = NULL;
1350
1351 return skb;
1352 }
1353
1354 static int
1355 qlcnic_check_rx_tagging(struct qlcnic_adapter *adapter, struct sk_buff *skb,
1356 u16 *vlan_tag)
1357 {
1358 struct ethhdr *eth_hdr;
1359
1360 if (!__vlan_get_tag(skb, vlan_tag)) {
1361 eth_hdr = (struct ethhdr *) skb->data;
1362 memmove(skb->data + VLAN_HLEN, eth_hdr, ETH_ALEN * 2);
1363 skb_pull(skb, VLAN_HLEN);
1364 }
1365 if (!adapter->pvid)
1366 return 0;
1367
1368 if (*vlan_tag == adapter->pvid) {
1369 /* Outer vlan tag. Packet should follow non-vlan path */
1370 *vlan_tag = 0xffff;
1371 return 0;
1372 }
1373 if (adapter->flags & QLCNIC_TAGGING_ENABLED)
1374 return 0;
1375
1376 return -EINVAL;
1377 }
1378
1379 static struct qlcnic_rx_buffer *
1380 qlcnic_process_rcv(struct qlcnic_adapter *adapter,
1381 struct qlcnic_host_sds_ring *sds_ring,
1382 int ring, u64 sts_data0)
1383 {
1384 struct net_device *netdev = adapter->netdev;
1385 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1386 struct qlcnic_rx_buffer *buffer;
1387 struct sk_buff *skb;
1388 struct qlcnic_host_rds_ring *rds_ring;
1389 int index, length, cksum, pkt_offset;
1390 u16 vid = 0xffff;
1391
1392 if (unlikely(ring >= adapter->max_rds_rings))
1393 return NULL;
1394
1395 rds_ring = &recv_ctx->rds_rings[ring];
1396
1397 index = qlcnic_get_sts_refhandle(sts_data0);
1398 if (unlikely(index >= rds_ring->num_desc))
1399 return NULL;
1400
1401 buffer = &rds_ring->rx_buf_arr[index];
1402
1403 length = qlcnic_get_sts_totallength(sts_data0);
1404 cksum = qlcnic_get_sts_status(sts_data0);
1405 pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
1406
1407 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1408 if (!skb)
1409 return buffer;
1410
1411 if (length > rds_ring->skb_size)
1412 skb_put(skb, rds_ring->skb_size);
1413 else
1414 skb_put(skb, length);
1415
1416 if (pkt_offset)
1417 skb_pull(skb, pkt_offset);
1418
1419 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1420 adapter->stats.rxdropped++;
1421 dev_kfree_skb(skb);
1422 return buffer;
1423 }
1424
1425 skb->protocol = eth_type_trans(skb, netdev);
1426
1427 if ((vid != 0xffff) && adapter->vlgrp)
1428 vlan_gro_receive(&sds_ring->napi, adapter->vlgrp, vid, skb);
1429 else
1430 napi_gro_receive(&sds_ring->napi, skb);
1431
1432 adapter->stats.rx_pkts++;
1433 adapter->stats.rxbytes += length;
1434
1435 return buffer;
1436 }
1437
1438 #define QLC_TCP_HDR_SIZE 20
1439 #define QLC_TCP_TS_OPTION_SIZE 12
1440 #define QLC_TCP_TS_HDR_SIZE (QLC_TCP_HDR_SIZE + QLC_TCP_TS_OPTION_SIZE)
1441
1442 static struct qlcnic_rx_buffer *
1443 qlcnic_process_lro(struct qlcnic_adapter *adapter,
1444 struct qlcnic_host_sds_ring *sds_ring,
1445 int ring, u64 sts_data0, u64 sts_data1)
1446 {
1447 struct net_device *netdev = adapter->netdev;
1448 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1449 struct qlcnic_rx_buffer *buffer;
1450 struct sk_buff *skb;
1451 struct qlcnic_host_rds_ring *rds_ring;
1452 struct iphdr *iph;
1453 struct tcphdr *th;
1454 bool push, timestamp;
1455 int l2_hdr_offset, l4_hdr_offset;
1456 int index;
1457 u16 lro_length, length, data_offset;
1458 u32 seq_number;
1459 u16 vid = 0xffff;
1460
1461 if (unlikely(ring > adapter->max_rds_rings))
1462 return NULL;
1463
1464 rds_ring = &recv_ctx->rds_rings[ring];
1465
1466 index = qlcnic_get_lro_sts_refhandle(sts_data0);
1467 if (unlikely(index > rds_ring->num_desc))
1468 return NULL;
1469
1470 buffer = &rds_ring->rx_buf_arr[index];
1471
1472 timestamp = qlcnic_get_lro_sts_timestamp(sts_data0);
1473 lro_length = qlcnic_get_lro_sts_length(sts_data0);
1474 l2_hdr_offset = qlcnic_get_lro_sts_l2_hdr_offset(sts_data0);
1475 l4_hdr_offset = qlcnic_get_lro_sts_l4_hdr_offset(sts_data0);
1476 push = qlcnic_get_lro_sts_push_flag(sts_data0);
1477 seq_number = qlcnic_get_lro_sts_seq_number(sts_data1);
1478
1479 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, STATUS_CKSUM_OK);
1480 if (!skb)
1481 return buffer;
1482
1483 if (timestamp)
1484 data_offset = l4_hdr_offset + QLC_TCP_TS_HDR_SIZE;
1485 else
1486 data_offset = l4_hdr_offset + QLC_TCP_HDR_SIZE;
1487
1488 skb_put(skb, lro_length + data_offset);
1489
1490 skb_pull(skb, l2_hdr_offset);
1491
1492 if (unlikely(qlcnic_check_rx_tagging(adapter, skb, &vid))) {
1493 adapter->stats.rxdropped++;
1494 dev_kfree_skb(skb);
1495 return buffer;
1496 }
1497
1498 skb->protocol = eth_type_trans(skb, netdev);
1499
1500 iph = (struct iphdr *)skb->data;
1501 th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
1502
1503 length = (iph->ihl << 2) + (th->doff << 2) + lro_length;
1504 iph->tot_len = htons(length);
1505 iph->check = 0;
1506 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
1507 th->psh = push;
1508 th->seq = htonl(seq_number);
1509
1510 length = skb->len;
1511
1512 if ((vid != 0xffff) && adapter->vlgrp)
1513 vlan_hwaccel_receive_skb(skb, adapter->vlgrp, vid);
1514 else
1515 netif_receive_skb(skb);
1516
1517 adapter->stats.lro_pkts++;
1518 adapter->stats.lrobytes += length;
1519
1520 return buffer;
1521 }
1522
1523 int
1524 qlcnic_process_rcv_ring(struct qlcnic_host_sds_ring *sds_ring, int max)
1525 {
1526 struct qlcnic_adapter *adapter = sds_ring->adapter;
1527 struct list_head *cur;
1528 struct status_desc *desc;
1529 struct qlcnic_rx_buffer *rxbuf;
1530 u64 sts_data0, sts_data1;
1531
1532 int count = 0;
1533 int opcode, ring, desc_cnt;
1534 u32 consumer = sds_ring->consumer;
1535
1536 while (count < max) {
1537 desc = &sds_ring->desc_head[consumer];
1538 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1539
1540 if (!(sts_data0 & STATUS_OWNER_HOST))
1541 break;
1542
1543 desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1544 opcode = qlcnic_get_sts_opcode(sts_data0);
1545
1546 switch (opcode) {
1547 case QLCNIC_RXPKT_DESC:
1548 case QLCNIC_OLD_RXPKT_DESC:
1549 case QLCNIC_SYN_OFFLOAD:
1550 ring = qlcnic_get_sts_type(sts_data0);
1551 rxbuf = qlcnic_process_rcv(adapter, sds_ring,
1552 ring, sts_data0);
1553 break;
1554 case QLCNIC_LRO_DESC:
1555 ring = qlcnic_get_lro_sts_type(sts_data0);
1556 sts_data1 = le64_to_cpu(desc->status_desc_data[1]);
1557 rxbuf = qlcnic_process_lro(adapter, sds_ring,
1558 ring, sts_data0, sts_data1);
1559 break;
1560 case QLCNIC_RESPONSE_DESC:
1561 qlcnic_handle_fw_message(desc_cnt, consumer, sds_ring);
1562 default:
1563 goto skip;
1564 }
1565
1566 WARN_ON(desc_cnt > 1);
1567
1568 if (likely(rxbuf))
1569 list_add_tail(&rxbuf->list, &sds_ring->free_list[ring]);
1570 else
1571 adapter->stats.null_rxbuf++;
1572
1573 skip:
1574 for (; desc_cnt > 0; desc_cnt--) {
1575 desc = &sds_ring->desc_head[consumer];
1576 desc->status_desc_data[0] =
1577 cpu_to_le64(STATUS_OWNER_PHANTOM);
1578 consumer = get_next_index(consumer, sds_ring->num_desc);
1579 }
1580 count++;
1581 }
1582
1583 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1584 struct qlcnic_host_rds_ring *rds_ring =
1585 &adapter->recv_ctx.rds_rings[ring];
1586
1587 if (!list_empty(&sds_ring->free_list[ring])) {
1588 list_for_each(cur, &sds_ring->free_list[ring]) {
1589 rxbuf = list_entry(cur,
1590 struct qlcnic_rx_buffer, list);
1591 qlcnic_alloc_rx_skb(adapter, rds_ring, rxbuf);
1592 }
1593 spin_lock(&rds_ring->lock);
1594 list_splice_tail_init(&sds_ring->free_list[ring],
1595 &rds_ring->free_list);
1596 spin_unlock(&rds_ring->lock);
1597 }
1598
1599 qlcnic_post_rx_buffers_nodb(adapter, rds_ring);
1600 }
1601
1602 if (count) {
1603 sds_ring->consumer = consumer;
1604 writel(consumer, sds_ring->crb_sts_consumer);
1605 }
1606
1607 return count;
1608 }
1609
1610 void
1611 qlcnic_post_rx_buffers(struct qlcnic_adapter *adapter, u32 ringid,
1612 struct qlcnic_host_rds_ring *rds_ring)
1613 {
1614 struct rcv_desc *pdesc;
1615 struct qlcnic_rx_buffer *buffer;
1616 int producer, count = 0;
1617 struct list_head *head;
1618
1619 producer = rds_ring->producer;
1620
1621 head = &rds_ring->free_list;
1622 while (!list_empty(head)) {
1623
1624 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
1625
1626 if (!buffer->skb) {
1627 if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
1628 break;
1629 }
1630
1631 count++;
1632 list_del(&buffer->list);
1633
1634 /* make a rcv descriptor */
1635 pdesc = &rds_ring->desc_head[producer];
1636 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1637 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1638 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1639
1640 producer = get_next_index(producer, rds_ring->num_desc);
1641 }
1642
1643 if (count) {
1644 rds_ring->producer = producer;
1645 writel((producer-1) & (rds_ring->num_desc-1),
1646 rds_ring->crb_rcv_producer);
1647 }
1648 }
1649
1650 static void
1651 qlcnic_post_rx_buffers_nodb(struct qlcnic_adapter *adapter,
1652 struct qlcnic_host_rds_ring *rds_ring)
1653 {
1654 struct rcv_desc *pdesc;
1655 struct qlcnic_rx_buffer *buffer;
1656 int producer, count = 0;
1657 struct list_head *head;
1658
1659 if (!spin_trylock(&rds_ring->lock))
1660 return;
1661
1662 producer = rds_ring->producer;
1663
1664 head = &rds_ring->free_list;
1665 while (!list_empty(head)) {
1666
1667 buffer = list_entry(head->next, struct qlcnic_rx_buffer, list);
1668
1669 if (!buffer->skb) {
1670 if (qlcnic_alloc_rx_skb(adapter, rds_ring, buffer))
1671 break;
1672 }
1673
1674 count++;
1675 list_del(&buffer->list);
1676
1677 /* make a rcv descriptor */
1678 pdesc = &rds_ring->desc_head[producer];
1679 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
1680 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
1681 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
1682
1683 producer = get_next_index(producer, rds_ring->num_desc);
1684 }
1685
1686 if (count) {
1687 rds_ring->producer = producer;
1688 writel((producer - 1) & (rds_ring->num_desc - 1),
1689 rds_ring->crb_rcv_producer);
1690 }
1691 spin_unlock(&rds_ring->lock);
1692 }
1693
1694 static void dump_skb(struct sk_buff *skb)
1695 {
1696 int i;
1697 unsigned char *data = skb->data;
1698
1699 for (i = 0; i < skb->len; i++) {
1700 printk("%02x ", data[i]);
1701 if ((i & 0x0f) == 8)
1702 printk("\n");
1703 }
1704 }
1705
1706 static struct qlcnic_rx_buffer *
1707 qlcnic_process_rcv_diag(struct qlcnic_adapter *adapter,
1708 struct qlcnic_host_sds_ring *sds_ring,
1709 int ring, u64 sts_data0)
1710 {
1711 struct qlcnic_recv_context *recv_ctx = &adapter->recv_ctx;
1712 struct qlcnic_rx_buffer *buffer;
1713 struct sk_buff *skb;
1714 struct qlcnic_host_rds_ring *rds_ring;
1715 int index, length, cksum, pkt_offset;
1716
1717 if (unlikely(ring >= adapter->max_rds_rings))
1718 return NULL;
1719
1720 rds_ring = &recv_ctx->rds_rings[ring];
1721
1722 index = qlcnic_get_sts_refhandle(sts_data0);
1723 if (unlikely(index >= rds_ring->num_desc))
1724 return NULL;
1725
1726 buffer = &rds_ring->rx_buf_arr[index];
1727
1728 length = qlcnic_get_sts_totallength(sts_data0);
1729 cksum = qlcnic_get_sts_status(sts_data0);
1730 pkt_offset = qlcnic_get_sts_pkt_offset(sts_data0);
1731
1732 skb = qlcnic_process_rxbuf(adapter, rds_ring, index, cksum);
1733 if (!skb)
1734 return buffer;
1735
1736 if (length > rds_ring->skb_size)
1737 skb_put(skb, rds_ring->skb_size);
1738 else
1739 skb_put(skb, length);
1740
1741 if (pkt_offset)
1742 skb_pull(skb, pkt_offset);
1743
1744 if (!qlcnic_check_loopback_buff(skb->data))
1745 adapter->diag_cnt++;
1746 else
1747 dump_skb(skb);
1748
1749 dev_kfree_skb_any(skb);
1750 adapter->stats.rx_pkts++;
1751 adapter->stats.rxbytes += length;
1752
1753 return buffer;
1754 }
1755
1756 void
1757 qlcnic_process_rcv_ring_diag(struct qlcnic_host_sds_ring *sds_ring)
1758 {
1759 struct qlcnic_adapter *adapter = sds_ring->adapter;
1760 struct status_desc *desc;
1761 struct qlcnic_rx_buffer *rxbuf;
1762 u64 sts_data0;
1763
1764 int opcode, ring, desc_cnt;
1765 u32 consumer = sds_ring->consumer;
1766
1767 desc = &sds_ring->desc_head[consumer];
1768 sts_data0 = le64_to_cpu(desc->status_desc_data[0]);
1769
1770 if (!(sts_data0 & STATUS_OWNER_HOST))
1771 return;
1772
1773 desc_cnt = qlcnic_get_sts_desc_cnt(sts_data0);
1774 opcode = qlcnic_get_sts_opcode(sts_data0);
1775
1776 ring = qlcnic_get_sts_type(sts_data0);
1777 rxbuf = qlcnic_process_rcv_diag(adapter, sds_ring,
1778 ring, sts_data0);
1779
1780 desc->status_desc_data[0] = cpu_to_le64(STATUS_OWNER_PHANTOM);
1781 consumer = get_next_index(consumer, sds_ring->num_desc);
1782
1783 sds_ring->consumer = consumer;
1784 writel(consumer, sds_ring->crb_sts_consumer);
1785 }
1786
1787 void
1788 qlcnic_fetch_mac(struct qlcnic_adapter *adapter, u32 off1, u32 off2,
1789 u8 alt_mac, u8 *mac)
1790 {
1791 u32 mac_low, mac_high;
1792 int i;
1793
1794 mac_low = QLCRD32(adapter, off1);
1795 mac_high = QLCRD32(adapter, off2);
1796
1797 if (alt_mac) {
1798 mac_low |= (mac_low >> 16) | (mac_high << 16);
1799 mac_high >>= 16;
1800 }
1801
1802 for (i = 0; i < 2; i++)
1803 mac[i] = (u8)(mac_high >> ((1 - i) * 8));
1804 for (i = 2; i < 6; i++)
1805 mac[i] = (u8)(mac_low >> ((5 - i) * 8));
1806 }
Linux kernel - Deliverables
This page took 0.097137 seconds and 5 git commands to generate.