1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * QLogic qlcnic NIC Driver
4 * Copyright (c) 2009-2013 QLogic Corporation
5 */
6
7 #include "qlcnic.h"
8 #include "qlcnic_hw.h"
9 #include <linux/unaligned.h>
10
11 struct crb_addr_pair {
12 u32 addr;
13 u32 data;
14 };
15
16 #define QLCNIC_MAX_CRB_XFORM 60
17 static unsigned int crb_addr_xform[QLCNIC_MAX_CRB_XFORM];
18
19 #define crb_addr_transform(name) \
20 (crb_addr_xform[QLCNIC_HW_PX_MAP_CRB_##name] = \
21 QLCNIC_HW_CRB_HUB_AGT_ADR_##name << 20)
22
23 #define QLCNIC_ADDR_ERROR (0xffffffff)
24
25 static int
26 qlcnic_check_fw_hearbeat(struct qlcnic_adapter *adapter);
27
crb_addr_transform_setup(void)28 static void crb_addr_transform_setup(void)
29 {
30 crb_addr_transform(XDMA);
31 crb_addr_transform(TIMR);
32 crb_addr_transform(SRE);
33 crb_addr_transform(SQN3);
34 crb_addr_transform(SQN2);
35 crb_addr_transform(SQN1);
36 crb_addr_transform(SQN0);
37 crb_addr_transform(SQS3);
38 crb_addr_transform(SQS2);
39 crb_addr_transform(SQS1);
40 crb_addr_transform(SQS0);
41 crb_addr_transform(RPMX7);
42 crb_addr_transform(RPMX6);
43 crb_addr_transform(RPMX5);
44 crb_addr_transform(RPMX4);
45 crb_addr_transform(RPMX3);
46 crb_addr_transform(RPMX2);
47 crb_addr_transform(RPMX1);
48 crb_addr_transform(RPMX0);
49 crb_addr_transform(ROMUSB);
50 crb_addr_transform(SN);
51 crb_addr_transform(QMN);
52 crb_addr_transform(QMS);
53 crb_addr_transform(PGNI);
54 crb_addr_transform(PGND);
55 crb_addr_transform(PGN3);
56 crb_addr_transform(PGN2);
57 crb_addr_transform(PGN1);
58 crb_addr_transform(PGN0);
59 crb_addr_transform(PGSI);
60 crb_addr_transform(PGSD);
61 crb_addr_transform(PGS3);
62 crb_addr_transform(PGS2);
63 crb_addr_transform(PGS1);
64 crb_addr_transform(PGS0);
65 crb_addr_transform(PS);
66 crb_addr_transform(PH);
67 crb_addr_transform(NIU);
68 crb_addr_transform(I2Q);
69 crb_addr_transform(EG);
70 crb_addr_transform(MN);
71 crb_addr_transform(MS);
72 crb_addr_transform(CAS2);
73 crb_addr_transform(CAS1);
74 crb_addr_transform(CAS0);
75 crb_addr_transform(CAM);
76 crb_addr_transform(C2C1);
77 crb_addr_transform(C2C0);
78 crb_addr_transform(SMB);
79 crb_addr_transform(OCM0);
80 crb_addr_transform(I2C0);
81 }
82
qlcnic_release_rx_buffers(struct qlcnic_adapter * adapter)83 void qlcnic_release_rx_buffers(struct qlcnic_adapter *adapter)
84 {
85 struct qlcnic_recv_context *recv_ctx;
86 struct qlcnic_host_rds_ring *rds_ring;
87 struct qlcnic_rx_buffer *rx_buf;
88 int i, ring;
89
90 recv_ctx = adapter->recv_ctx;
91 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
92 rds_ring = &recv_ctx->rds_rings[ring];
93 for (i = 0; i < rds_ring->num_desc; ++i) {
94 rx_buf = &(rds_ring->rx_buf_arr[i]);
95 if (rx_buf->skb == NULL)
96 continue;
97
98 dma_unmap_single(&adapter->pdev->dev, rx_buf->dma,
99 rds_ring->dma_size, DMA_FROM_DEVICE);
100
101 dev_kfree_skb_any(rx_buf->skb);
102 }
103 }
104 }
105
qlcnic_reset_rx_buffers_list(struct qlcnic_adapter * adapter)106 void qlcnic_reset_rx_buffers_list(struct qlcnic_adapter *adapter)
107 {
108 struct qlcnic_recv_context *recv_ctx;
109 struct qlcnic_host_rds_ring *rds_ring;
110 struct qlcnic_rx_buffer *rx_buf;
111 int i, ring;
112
113 recv_ctx = adapter->recv_ctx;
114 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
115 rds_ring = &recv_ctx->rds_rings[ring];
116
117 INIT_LIST_HEAD(&rds_ring->free_list);
118
119 rx_buf = rds_ring->rx_buf_arr;
120 for (i = 0; i < rds_ring->num_desc; i++) {
121 list_add_tail(&rx_buf->list,
122 &rds_ring->free_list);
123 rx_buf++;
124 }
125 }
126 }
127
qlcnic_release_tx_buffers(struct qlcnic_adapter * adapter,struct qlcnic_host_tx_ring * tx_ring)128 void qlcnic_release_tx_buffers(struct qlcnic_adapter *adapter,
129 struct qlcnic_host_tx_ring *tx_ring)
130 {
131 struct qlcnic_cmd_buffer *cmd_buf;
132 struct qlcnic_skb_frag *buffrag;
133 int i, j;
134
135 spin_lock(&tx_ring->tx_clean_lock);
136
137 cmd_buf = tx_ring->cmd_buf_arr;
138 for (i = 0; i < tx_ring->num_desc; i++) {
139 buffrag = cmd_buf->frag_array;
140 if (buffrag->dma) {
141 dma_unmap_single(&adapter->pdev->dev, buffrag->dma,
142 buffrag->length, DMA_TO_DEVICE);
143 buffrag->dma = 0ULL;
144 }
145 for (j = 1; j < cmd_buf->frag_count; j++) {
146 buffrag++;
147 if (buffrag->dma) {
148 dma_unmap_page(&adapter->pdev->dev,
149 buffrag->dma, buffrag->length,
150 DMA_TO_DEVICE);
151 buffrag->dma = 0ULL;
152 }
153 }
154 if (cmd_buf->skb) {
155 dev_kfree_skb_any(cmd_buf->skb);
156 cmd_buf->skb = NULL;
157 }
158 cmd_buf++;
159 }
160
161 spin_unlock(&tx_ring->tx_clean_lock);
162 }
163
qlcnic_free_sw_resources(struct qlcnic_adapter * adapter)164 void qlcnic_free_sw_resources(struct qlcnic_adapter *adapter)
165 {
166 struct qlcnic_recv_context *recv_ctx;
167 struct qlcnic_host_rds_ring *rds_ring;
168 int ring;
169
170 recv_ctx = adapter->recv_ctx;
171
172 if (recv_ctx->rds_rings == NULL)
173 return;
174
175 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
176 rds_ring = &recv_ctx->rds_rings[ring];
177 vfree(rds_ring->rx_buf_arr);
178 rds_ring->rx_buf_arr = NULL;
179 }
180 kfree(recv_ctx->rds_rings);
181 }
182
qlcnic_alloc_sw_resources(struct qlcnic_adapter * adapter)183 int qlcnic_alloc_sw_resources(struct qlcnic_adapter *adapter)
184 {
185 struct qlcnic_recv_context *recv_ctx;
186 struct qlcnic_host_rds_ring *rds_ring;
187 struct qlcnic_host_sds_ring *sds_ring;
188 struct qlcnic_rx_buffer *rx_buf;
189 int ring, i;
190
191 recv_ctx = adapter->recv_ctx;
192
193 rds_ring = kzalloc_objs(struct qlcnic_host_rds_ring,
194 adapter->max_rds_rings);
195 if (rds_ring == NULL)
196 goto err_out;
197
198 recv_ctx->rds_rings = rds_ring;
199
200 for (ring = 0; ring < adapter->max_rds_rings; ring++) {
201 rds_ring = &recv_ctx->rds_rings[ring];
202 switch (ring) {
203 case RCV_RING_NORMAL:
204 rds_ring->num_desc = adapter->num_rxd;
205 rds_ring->dma_size = QLCNIC_P3P_RX_BUF_MAX_LEN;
206 rds_ring->skb_size = rds_ring->dma_size + NET_IP_ALIGN;
207 break;
208
209 case RCV_RING_JUMBO:
210 rds_ring->num_desc = adapter->num_jumbo_rxd;
211 rds_ring->dma_size =
212 QLCNIC_P3P_RX_JUMBO_BUF_MAX_LEN;
213
214 if (adapter->ahw->capabilities &
215 QLCNIC_FW_CAPABILITY_HW_LRO)
216 rds_ring->dma_size += QLCNIC_LRO_BUFFER_EXTRA;
217
218 rds_ring->skb_size =
219 rds_ring->dma_size + NET_IP_ALIGN;
220 break;
221 }
222 rds_ring->rx_buf_arr = vzalloc(RCV_BUFF_RINGSIZE(rds_ring));
223 if (rds_ring->rx_buf_arr == NULL)
224 goto err_out;
225
226 INIT_LIST_HEAD(&rds_ring->free_list);
227 /*
228 * Now go through all of them, set reference handles
229 * and put them in the queues.
230 */
231 rx_buf = rds_ring->rx_buf_arr;
232 for (i = 0; i < rds_ring->num_desc; i++) {
233 list_add_tail(&rx_buf->list,
234 &rds_ring->free_list);
235 rx_buf->ref_handle = i;
236 rx_buf++;
237 }
238 spin_lock_init(&rds_ring->lock);
239 }
240
241 for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
242 sds_ring = &recv_ctx->sds_rings[ring];
243 sds_ring->irq = adapter->msix_entries[ring].vector;
244 sds_ring->adapter = adapter;
245 sds_ring->num_desc = adapter->num_rxd;
246 if (qlcnic_82xx_check(adapter)) {
247 if (qlcnic_check_multi_tx(adapter) &&
248 !adapter->ahw->diag_test)
249 sds_ring->tx_ring = &adapter->tx_ring[ring];
250 else
251 sds_ring->tx_ring = &adapter->tx_ring[0];
252 }
253 for (i = 0; i < NUM_RCV_DESC_RINGS; i++)
254 INIT_LIST_HEAD(&sds_ring->free_list[i]);
255 }
256
257 return 0;
258
259 err_out:
260 qlcnic_free_sw_resources(adapter);
261 return -ENOMEM;
262 }
263
264 /*
265 * Utility to translate from internal Phantom CRB address
266 * to external PCI CRB address.
267 */
qlcnic_decode_crb_addr(u32 addr)268 static u32 qlcnic_decode_crb_addr(u32 addr)
269 {
270 int i;
271 u32 base_addr, offset, pci_base;
272
273 crb_addr_transform_setup();
274
275 pci_base = QLCNIC_ADDR_ERROR;
276 base_addr = addr & 0xfff00000;
277 offset = addr & 0x000fffff;
278
279 for (i = 0; i < QLCNIC_MAX_CRB_XFORM; i++) {
280 if (crb_addr_xform[i] == base_addr) {
281 pci_base = i << 20;
282 break;
283 }
284 }
285 if (pci_base == QLCNIC_ADDR_ERROR)
286 return pci_base;
287 else
288 return pci_base + offset;
289 }
290
291 #define QLCNIC_MAX_ROM_WAIT_USEC 100
292
qlcnic_wait_rom_done(struct qlcnic_adapter * adapter)293 static int qlcnic_wait_rom_done(struct qlcnic_adapter *adapter)
294 {
295 long timeout = 0;
296 long done = 0;
297 int err = 0;
298
299 cond_resched();
300 while (done == 0) {
301 done = QLCRD32(adapter, QLCNIC_ROMUSB_GLB_STATUS, &err);
302 done &= 2;
303 if (++timeout >= QLCNIC_MAX_ROM_WAIT_USEC) {
304 dev_err(&adapter->pdev->dev,
305 "Timeout reached waiting for rom done");
306 return -EIO;
307 }
308 udelay(1);
309 }
310 return 0;
311 }
312
do_rom_fast_read(struct qlcnic_adapter * adapter,u32 addr,u32 * valp)313 static int do_rom_fast_read(struct qlcnic_adapter *adapter,
314 u32 addr, u32 *valp)
315 {
316 int err = 0;
317
318 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ADDRESS, addr);
319 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
320 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ABYTE_CNT, 3);
321 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_INSTR_OPCODE, 0xb);
322 if (qlcnic_wait_rom_done(adapter)) {
323 dev_err(&adapter->pdev->dev, "Error waiting for rom done\n");
324 return -EIO;
325 }
326 /* reset abyte_cnt and dummy_byte_cnt */
327 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_ABYTE_CNT, 0);
328 udelay(10);
329 QLCWR32(adapter, QLCNIC_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
330
331 *valp = QLCRD32(adapter, QLCNIC_ROMUSB_ROM_RDATA, &err);
332 if (err == -EIO)
333 return err;
334 return 0;
335 }
336
do_rom_fast_read_words(struct qlcnic_adapter * adapter,int addr,u8 * bytes,size_t size)337 static int do_rom_fast_read_words(struct qlcnic_adapter *adapter, int addr,
338 u8 *bytes, size_t size)
339 {
340 int addridx;
341 int ret = 0;
342
343 for (addridx = addr; addridx < (addr + size); addridx += 4) {
344 int v;
345 ret = do_rom_fast_read(adapter, addridx, &v);
346 if (ret != 0)
347 break;
348 *(__le32 *)bytes = cpu_to_le32(v);
349 bytes += 4;
350 }
351
352 return ret;
353 }
354
355 int
qlcnic_rom_fast_read_words(struct qlcnic_adapter * adapter,int addr,u8 * bytes,size_t size)356 qlcnic_rom_fast_read_words(struct qlcnic_adapter *adapter, int addr,
357 u8 *bytes, size_t size)
358 {
359 int ret;
360
361 ret = qlcnic_rom_lock(adapter);
362 if (ret < 0)
363 return ret;
364
365 ret = do_rom_fast_read_words(adapter, addr, bytes, size);
366
367 qlcnic_rom_unlock(adapter);
368 return ret;
369 }
370
qlcnic_rom_fast_read(struct qlcnic_adapter * adapter,u32 addr,u32 * valp)371 int qlcnic_rom_fast_read(struct qlcnic_adapter *adapter, u32 addr, u32 *valp)
372 {
373 int ret;
374
375 if (qlcnic_rom_lock(adapter) != 0)
376 return -EIO;
377
378 ret = do_rom_fast_read(adapter, addr, valp);
379 qlcnic_rom_unlock(adapter);
380 return ret;
381 }
382
qlcnic_pinit_from_rom(struct qlcnic_adapter * adapter)383 int qlcnic_pinit_from_rom(struct qlcnic_adapter *adapter)
384 {
385 int addr, err = 0;
386 int i, n, init_delay;
387 struct crb_addr_pair *buf;
388 unsigned offset;
389 u32 off, val;
390 struct pci_dev *pdev = adapter->pdev;
391
392 QLC_SHARED_REG_WR32(adapter, QLCNIC_CMDPEG_STATE, 0);
393 QLC_SHARED_REG_WR32(adapter, QLCNIC_RCVPEG_STATE, 0);
394
395 /* Halt all the indiviual PEGs and other blocks */
396 /* disable all I2Q */
397 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x10, 0x0);
398 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x14, 0x0);
399 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x18, 0x0);
400 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x1c, 0x0);
401 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x20, 0x0);
402 QLCWR32(adapter, QLCNIC_CRB_I2Q + 0x24, 0x0);
403
404 /* disable all niu interrupts */
405 QLCWR32(adapter, QLCNIC_CRB_NIU + 0x40, 0xff);
406 /* disable xge rx/tx */
407 QLCWR32(adapter, QLCNIC_CRB_NIU + 0x70000, 0x00);
408 /* disable xg1 rx/tx */
409 QLCWR32(adapter, QLCNIC_CRB_NIU + 0x80000, 0x00);
410 /* disable sideband mac */
411 QLCWR32(adapter, QLCNIC_CRB_NIU + 0x90000, 0x00);
412 /* disable ap0 mac */
413 QLCWR32(adapter, QLCNIC_CRB_NIU + 0xa0000, 0x00);
414 /* disable ap1 mac */
415 QLCWR32(adapter, QLCNIC_CRB_NIU + 0xb0000, 0x00);
416
417 /* halt sre */
418 val = QLCRD32(adapter, QLCNIC_CRB_SRE + 0x1000, &err);
419 if (err == -EIO)
420 return err;
421 QLCWR32(adapter, QLCNIC_CRB_SRE + 0x1000, val & (~(0x1)));
422
423 /* halt epg */
424 QLCWR32(adapter, QLCNIC_CRB_EPG + 0x1300, 0x1);
425
426 /* halt timers */
427 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x0, 0x0);
428 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x8, 0x0);
429 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x10, 0x0);
430 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x18, 0x0);
431 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x100, 0x0);
432 QLCWR32(adapter, QLCNIC_CRB_TIMER + 0x200, 0x0);
433 /* halt pegs */
434 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c, 1);
435 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c, 1);
436 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c, 1);
437 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c, 1);
438 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c, 1);
439 msleep(20);
440
441 /* big hammer don't reset CAM block on reset */
442 QLCWR32(adapter, QLCNIC_ROMUSB_GLB_SW_RESET, 0xfeffffff);
443
444 /* Init HW CRB block */
445 if (qlcnic_rom_fast_read(adapter, 0, &n) != 0 || (n != 0xcafecafe) ||
446 qlcnic_rom_fast_read(adapter, 4, &n) != 0) {
447 dev_err(&pdev->dev, "ERROR Reading crb_init area: val:%x\n", n);
448 return -EIO;
449 }
450 offset = n & 0xffffU;
451 n = (n >> 16) & 0xffffU;
452
453 if (n >= 1024) {
454 dev_err(&pdev->dev, "QLOGIC card flash not initialized.\n");
455 return -EIO;
456 }
457
458 buf = kzalloc_objs(struct crb_addr_pair, n);
459 if (buf == NULL)
460 return -ENOMEM;
461
462 for (i = 0; i < n; i++) {
463 if (qlcnic_rom_fast_read(adapter, 8*i + 4*offset, &val) != 0 ||
464 qlcnic_rom_fast_read(adapter, 8*i + 4*offset + 4, &addr) != 0) {
465 kfree(buf);
466 return -EIO;
467 }
468
469 buf[i].addr = addr;
470 buf[i].data = val;
471 }
472
473 for (i = 0; i < n; i++) {
474
475 off = qlcnic_decode_crb_addr(buf[i].addr);
476 if (off == QLCNIC_ADDR_ERROR) {
477 dev_err(&pdev->dev, "CRB init value out of range %x\n",
478 buf[i].addr);
479 continue;
480 }
481 off += QLCNIC_PCI_CRBSPACE;
482
483 if (off & 1)
484 continue;
485
486 /* skipping cold reboot MAGIC */
487 if (off == QLCNIC_CAM_RAM(0x1fc))
488 continue;
489 if (off == (QLCNIC_CRB_I2C0 + 0x1c))
490 continue;
491 if (off == (ROMUSB_GLB + 0xbc)) /* do not reset PCI */
492 continue;
493 if (off == (ROMUSB_GLB + 0xa8))
494 continue;
495 if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
496 continue;
497 if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
498 continue;
499 if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
500 continue;
501 if ((off & 0x0ff00000) == QLCNIC_CRB_DDR_NET)
502 continue;
503 /* skip the function enable register */
504 if (off == QLCNIC_PCIE_REG(PCIE_SETUP_FUNCTION))
505 continue;
506 if (off == QLCNIC_PCIE_REG(PCIE_SETUP_FUNCTION2))
507 continue;
508 if ((off & 0x0ff00000) == QLCNIC_CRB_SMB)
509 continue;
510
511 init_delay = 1;
512 /* After writing this register, HW needs time for CRB */
513 /* to quiet down (else crb_window returns 0xffffffff) */
514 if (off == QLCNIC_ROMUSB_GLB_SW_RESET)
515 init_delay = 1000;
516
517 QLCWR32(adapter, off, buf[i].data);
518
519 msleep(init_delay);
520 }
521 kfree(buf);
522
523 /* Initialize protocol process engine */
524 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_D + 0xec, 0x1e);
525 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_D + 0x4c, 8);
526 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_I + 0x4c, 8);
527 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x8, 0);
528 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0xc, 0);
529 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x8, 0);
530 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_1 + 0xc, 0);
531 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x8, 0);
532 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_2 + 0xc, 0);
533 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x8, 0);
534 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_3 + 0xc, 0);
535 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x8, 0);
536 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_4 + 0xc, 0);
537 usleep_range(1000, 1500);
538
539 QLC_SHARED_REG_WR32(adapter, QLCNIC_PEG_HALT_STATUS1, 0);
540 QLC_SHARED_REG_WR32(adapter, QLCNIC_PEG_HALT_STATUS2, 0);
541
542 return 0;
543 }
544
qlcnic_cmd_peg_ready(struct qlcnic_adapter * adapter)545 static int qlcnic_cmd_peg_ready(struct qlcnic_adapter *adapter)
546 {
547 u32 val;
548 int retries = QLCNIC_CMDPEG_CHECK_RETRY_COUNT;
549
550 do {
551 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CMDPEG_STATE);
552
553 switch (val) {
554 case PHAN_INITIALIZE_COMPLETE:
555 case PHAN_INITIALIZE_ACK:
556 return 0;
557 case PHAN_INITIALIZE_FAILED:
558 goto out_err;
559 default:
560 break;
561 }
562
563 msleep(QLCNIC_CMDPEG_CHECK_DELAY);
564
565 } while (--retries);
566
567 QLC_SHARED_REG_WR32(adapter, QLCNIC_CMDPEG_STATE,
568 PHAN_INITIALIZE_FAILED);
569
570 out_err:
571 dev_err(&adapter->pdev->dev, "Command Peg initialization not "
572 "complete, state: 0x%x.\n", val);
573 return -EIO;
574 }
575
576 static int
qlcnic_receive_peg_ready(struct qlcnic_adapter * adapter)577 qlcnic_receive_peg_ready(struct qlcnic_adapter *adapter)
578 {
579 u32 val;
580 int retries = QLCNIC_RCVPEG_CHECK_RETRY_COUNT;
581
582 do {
583 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_RCVPEG_STATE);
584
585 if (val == PHAN_PEG_RCV_INITIALIZED)
586 return 0;
587
588 msleep(QLCNIC_RCVPEG_CHECK_DELAY);
589
590 } while (--retries);
591
592 dev_err(&adapter->pdev->dev, "Receive Peg initialization not complete, state: 0x%x.\n",
593 val);
594 return -EIO;
595 }
596
597 int
qlcnic_check_fw_status(struct qlcnic_adapter * adapter)598 qlcnic_check_fw_status(struct qlcnic_adapter *adapter)
599 {
600 int err;
601
602 err = qlcnic_cmd_peg_ready(adapter);
603 if (err)
604 return err;
605
606 err = qlcnic_receive_peg_ready(adapter);
607 if (err)
608 return err;
609
610 QLC_SHARED_REG_WR32(adapter, QLCNIC_CMDPEG_STATE, PHAN_INITIALIZE_ACK);
611
612 return err;
613 }
614
615 int
qlcnic_setup_idc_param(struct qlcnic_adapter * adapter)616 qlcnic_setup_idc_param(struct qlcnic_adapter *adapter) {
617
618 int timeo;
619 u32 val;
620
621 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_PARTITION_INFO);
622 val = QLC_DEV_GET_DRV(val, adapter->portnum);
623 if ((val & 0x3) != QLCNIC_TYPE_NIC) {
624 dev_err(&adapter->pdev->dev,
625 "Not an Ethernet NIC func=%u\n", val);
626 return -EIO;
627 }
628 adapter->ahw->physical_port = (val >> 2);
629 if (qlcnic_rom_fast_read(adapter, QLCNIC_ROM_DEV_INIT_TIMEOUT, &timeo))
630 timeo = QLCNIC_INIT_TIMEOUT_SECS;
631
632 adapter->dev_init_timeo = timeo;
633
634 if (qlcnic_rom_fast_read(adapter, QLCNIC_ROM_DRV_RESET_TIMEOUT, &timeo))
635 timeo = QLCNIC_RESET_TIMEOUT_SECS;
636
637 adapter->reset_ack_timeo = timeo;
638
639 return 0;
640 }
641
qlcnic_get_flt_entry(struct qlcnic_adapter * adapter,u8 region,struct qlcnic_flt_entry * region_entry)642 static int qlcnic_get_flt_entry(struct qlcnic_adapter *adapter, u8 region,
643 struct qlcnic_flt_entry *region_entry)
644 {
645 struct qlcnic_flt_header flt_hdr;
646 struct qlcnic_flt_entry *flt_entry;
647 int i = 0, ret;
648 u32 entry_size;
649
650 memset(region_entry, 0, sizeof(struct qlcnic_flt_entry));
651 ret = qlcnic_rom_fast_read_words(adapter, QLCNIC_FLT_LOCATION,
652 (u8 *)&flt_hdr,
653 sizeof(struct qlcnic_flt_header));
654 if (ret) {
655 dev_warn(&adapter->pdev->dev,
656 "error reading flash layout header\n");
657 return -EIO;
658 }
659
660 entry_size = flt_hdr.len - sizeof(struct qlcnic_flt_header);
661 flt_entry = vzalloc(entry_size);
662 if (flt_entry == NULL)
663 return -EIO;
664
665 ret = qlcnic_rom_fast_read_words(adapter, QLCNIC_FLT_LOCATION +
666 sizeof(struct qlcnic_flt_header),
667 (u8 *)flt_entry, entry_size);
668 if (ret) {
669 dev_warn(&adapter->pdev->dev,
670 "error reading flash layout entries\n");
671 goto err_out;
672 }
673
674 while (i < (entry_size/sizeof(struct qlcnic_flt_entry))) {
675 if (flt_entry[i].region == region)
676 break;
677 i++;
678 }
679 if (i >= (entry_size/sizeof(struct qlcnic_flt_entry))) {
680 dev_warn(&adapter->pdev->dev,
681 "region=%x not found in %d regions\n", region, i);
682 ret = -EIO;
683 goto err_out;
684 }
685 memcpy(region_entry, &flt_entry[i], sizeof(struct qlcnic_flt_entry));
686
687 err_out:
688 vfree(flt_entry);
689 return ret;
690 }
691
692 int
qlcnic_check_flash_fw_ver(struct qlcnic_adapter * adapter)693 qlcnic_check_flash_fw_ver(struct qlcnic_adapter *adapter)
694 {
695 struct qlcnic_flt_entry fw_entry;
696 u32 ver = -1, min_ver;
697 int ret;
698
699 if (adapter->ahw->revision_id == QLCNIC_P3P_C0)
700 ret = qlcnic_get_flt_entry(adapter, QLCNIC_C0_FW_IMAGE_REGION,
701 &fw_entry);
702 else
703 ret = qlcnic_get_flt_entry(adapter, QLCNIC_B0_FW_IMAGE_REGION,
704 &fw_entry);
705
706 if (!ret)
707 /* 0-4:-signature, 4-8:-fw version */
708 qlcnic_rom_fast_read(adapter, fw_entry.start_addr + 4,
709 (int *)&ver);
710 else
711 qlcnic_rom_fast_read(adapter, QLCNIC_FW_VERSION_OFFSET,
712 (int *)&ver);
713
714 ver = QLCNIC_DECODE_VERSION(ver);
715 min_ver = QLCNIC_MIN_FW_VERSION;
716
717 if (ver < min_ver) {
718 dev_err(&adapter->pdev->dev,
719 "firmware version %d.%d.%d unsupported."
720 "Min supported version %d.%d.%d\n",
721 _major(ver), _minor(ver), _build(ver),
722 _major(min_ver), _minor(min_ver), _build(min_ver));
723 return -EINVAL;
724 }
725
726 return 0;
727 }
728
729 static int
qlcnic_has_mn(struct qlcnic_adapter * adapter)730 qlcnic_has_mn(struct qlcnic_adapter *adapter)
731 {
732 u32 capability = 0;
733 int err = 0;
734
735 capability = QLCRD32(adapter, QLCNIC_PEG_TUNE_CAPABILITY, &err);
736 if (err == -EIO)
737 return err;
738 if (capability & QLCNIC_PEG_TUNE_MN_PRESENT)
739 return 1;
740
741 return 0;
742 }
743
744 #define FILEHEADER_SIZE (14 * 4)
745 #define QLCNIC_UNI_DIR_TYPE_OFF (8 * sizeof(__le32))
746 #define QLCNIC_UNI_DIR_ENTRY_MIN_SIZE (9 * sizeof(__le32))
747 #define QLCNIC_UNI_PRODUCT_ENTRY_MIN_SIZE \
748 ((QLCNIC_UNI_FIRMWARE_IDX_OFF + 1) * sizeof(__le32))
749 #define QLCNIC_UNI_VERSION_TAIL_SIZE 17
750 #define QLCNIC_UNI_BOOTLD_SIZE \
751 (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START)
752
753 struct qlcnic_uni_data {
754 u32 offset;
755 u32 size;
756 };
757
qlcnic_rom_range_valid(size_t size,size_t offset,size_t len)758 static bool qlcnic_rom_range_valid(size_t size, size_t offset, size_t len)
759 {
760 return offset <= size && len <= size - offset;
761 }
762
qlcnic_rom_table_valid(size_t size,u32 offset,u32 entries,u32 entry_size,u32 min_entry_size)763 static bool qlcnic_rom_table_valid(size_t size, u32 offset, u32 entries,
764 u32 entry_size, u32 min_entry_size)
765 {
766 if (entry_size < min_entry_size || offset > size)
767 return false;
768
769 return entries <= (size - offset) / entry_size;
770 }
771
qlcnic_get_directory(struct qlcnic_adapter * adapter,size_t * offset,u32 * entries,u32 * entry_size)772 static int qlcnic_get_directory(struct qlcnic_adapter *adapter,
773 size_t *offset, u32 *entries, u32 *entry_size)
774 {
775 const struct firmware *fw = adapter->fw;
776 const u8 *directory = fw->data;
777
778 if (fw->size < FILEHEADER_SIZE)
779 return -EINVAL;
780
781 *offset = get_unaligned_le32(directory +
782 offsetof(struct uni_table_desc, findex));
783 *entries = get_unaligned_le32(directory +
784 offsetof(struct uni_table_desc, num_entries));
785 *entry_size = get_unaligned_le32(directory +
786 offsetof(struct uni_table_desc, entry_size));
787
788 if (!qlcnic_rom_table_valid(fw->size, *offset, *entries, *entry_size,
789 QLCNIC_UNI_DIR_ENTRY_MIN_SIZE))
790 return -EINVAL;
791
792 return 0;
793 }
794
qlcnic_get_table_desc(struct qlcnic_adapter * adapter,int section,size_t * desc_offset)795 static int qlcnic_get_table_desc(struct qlcnic_adapter *adapter, int section,
796 size_t *desc_offset)
797 {
798 const u8 *unirom = adapter->fw->data;
799 size_t directory_offset;
800 u32 entries, entry_size;
801 size_t i;
802 int ret;
803
804 ret = qlcnic_get_directory(adapter, &directory_offset, &entries,
805 &entry_size);
806 if (ret)
807 return ret;
808
809 for (i = 0; i < entries; i++) {
810 size_t offset = directory_offset + i * entry_size;
811 u32 table_type;
812
813 table_type = get_unaligned_le32(unirom + offset +
814 QLCNIC_UNI_DIR_TYPE_OFF);
815 if (table_type == section) {
816 *desc_offset = offset;
817 return 0;
818 }
819 }
820
821 return -ENOENT;
822 }
823
824 static int
qlcnic_validate_header(struct qlcnic_adapter * adapter)825 qlcnic_validate_header(struct qlcnic_adapter *adapter)
826 {
827 u32 entries, entry_size;
828 size_t offset;
829
830 return qlcnic_get_directory(adapter, &offset, &entries, &entry_size);
831 }
832
qlcnic_get_data_desc(struct qlcnic_adapter * adapter,u32 section,u32 index_offset,struct qlcnic_uni_data * data)833 static int qlcnic_get_data_desc(struct qlcnic_adapter *adapter, u32 section,
834 u32 index_offset, struct qlcnic_uni_data *data)
835 {
836 size_t table_desc_offset, table_offset, desc_offset;
837 const struct firmware *fw = adapter->fw;
838 const u8 *unirom = fw->data;
839 size_t product_index_offset;
840 u32 entries, entry_size, idx;
841 int ret;
842
843 product_index_offset = adapter->file_prd_off +
844 (size_t)index_offset * sizeof(__le32);
845 if (!qlcnic_rom_range_valid(fw->size, product_index_offset,
846 sizeof(__le32)))
847 return -EINVAL;
848
849 idx = get_unaligned_le32(unirom + product_index_offset);
850 ret = qlcnic_get_table_desc(adapter, section, &table_desc_offset);
851 if (ret)
852 return ret;
853
854 table_offset = get_unaligned_le32(unirom + table_desc_offset +
855 offsetof(struct uni_table_desc, findex));
856 entries = get_unaligned_le32(unirom + table_desc_offset +
857 offsetof(struct uni_table_desc, num_entries));
858 entry_size = get_unaligned_le32(unirom + table_desc_offset +
859 offsetof(struct uni_table_desc, entry_size));
860 if (!qlcnic_rom_table_valid(fw->size, table_offset, entries,
861 entry_size, sizeof(struct uni_data_desc)) ||
862 idx >= entries)
863 return -EINVAL;
864
865 desc_offset = table_offset + (size_t)idx * entry_size;
866 data->offset = get_unaligned_le32(unirom + desc_offset +
867 offsetof(struct uni_data_desc, findex));
868 data->size = get_unaligned_le32(unirom + desc_offset +
869 offsetof(struct uni_data_desc, size));
870
871 if (!qlcnic_rom_range_valid(fw->size, data->offset, data->size))
872 return -EINVAL;
873
874 return 0;
875 }
876
qlcnic_validate_bootld(struct qlcnic_adapter * adapter)877 static int qlcnic_validate_bootld(struct qlcnic_adapter *adapter)
878 {
879 struct qlcnic_uni_data data;
880 int ret;
881
882 ret = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_BOOTLD,
883 QLCNIC_UNI_BOOTLD_IDX_OFF, &data);
884 if (ret)
885 return ret;
886
887 return data.size < QLCNIC_UNI_BOOTLD_SIZE ? -EINVAL : 0;
888 }
889
qlcnic_validate_fw(struct qlcnic_adapter * adapter)890 static int qlcnic_validate_fw(struct qlcnic_adapter *adapter)
891 {
892 struct qlcnic_uni_data data;
893 int ret;
894
895 ret = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_FW,
896 QLCNIC_UNI_FIRMWARE_IDX_OFF, &data);
897 if (ret)
898 return ret;
899
900 return data.size < QLCNIC_UNI_VERSION_TAIL_SIZE ? -EINVAL : 0;
901 }
902
903 static int
qlcnic_validate_product_offs(struct qlcnic_adapter * adapter)904 qlcnic_validate_product_offs(struct qlcnic_adapter *adapter)
905 {
906 size_t table_desc_offset, table_offset;
907 const u8 *unirom = adapter->fw->data;
908 int mn_present = qlcnic_has_mn(adapter);
909 u32 entries, entry_size;
910 size_t i;
911 int ret;
912
913 ret = qlcnic_get_table_desc(adapter, QLCNIC_UNI_DIR_SECT_PRODUCT_TBL,
914 &table_desc_offset);
915 if (ret)
916 return ret;
917
918 table_offset = get_unaligned_le32(unirom + table_desc_offset +
919 offsetof(struct uni_table_desc, findex));
920 entries = get_unaligned_le32(unirom + table_desc_offset +
921 offsetof(struct uni_table_desc, num_entries));
922 entry_size = get_unaligned_le32(unirom + table_desc_offset +
923 offsetof(struct uni_table_desc, entry_size));
924 if (!qlcnic_rom_table_valid(adapter->fw->size, table_offset, entries,
925 entry_size,
926 QLCNIC_UNI_PRODUCT_ENTRY_MIN_SIZE))
927 return -EINVAL;
928
929 nomn:
930 for (i = 0; i < entries; i++) {
931 size_t offset = table_offset + i * entry_size;
932 u8 chiprev = adapter->ahw->revision_id;
933 u32 flags, file_chiprev;
934 u32 flagbit;
935
936 flags = get_unaligned_le32(unirom + offset +
937 QLCNIC_UNI_FLAGS_OFF * sizeof(__le32));
938 file_chiprev = get_unaligned_le32(unirom + offset +
939 QLCNIC_UNI_CHIP_REV_OFF *
940 sizeof(__le32));
941
942 flagbit = mn_present ? 1 : 2;
943
944 if ((chiprev == file_chiprev) &&
945 ((1ULL << flagbit) & flags)) {
946 if (offset > U32_MAX)
947 return -EINVAL;
948
949 adapter->file_prd_off = offset;
950 return 0;
951 }
952 }
953 if (mn_present) {
954 mn_present = 0;
955 goto nomn;
956 }
957 return -EINVAL;
958 }
959
960 static int
qlcnic_validate_unified_romimage(struct qlcnic_adapter * adapter)961 qlcnic_validate_unified_romimage(struct qlcnic_adapter *adapter)
962 {
963 if (qlcnic_validate_header(adapter)) {
964 dev_err(&adapter->pdev->dev,
965 "unified image: header validation failed\n");
966 return -EINVAL;
967 }
968
969 if (qlcnic_validate_product_offs(adapter)) {
970 dev_err(&adapter->pdev->dev,
971 "unified image: product validation failed\n");
972 return -EINVAL;
973 }
974
975 if (qlcnic_validate_bootld(adapter)) {
976 dev_err(&adapter->pdev->dev,
977 "unified image: bootld validation failed\n");
978 return -EINVAL;
979 }
980
981 if (qlcnic_validate_fw(adapter)) {
982 dev_err(&adapter->pdev->dev,
983 "unified image: firmware validation failed\n");
984 return -EINVAL;
985 }
986
987 return 0;
988 }
989
qlcnic_get_bootld_data(struct qlcnic_adapter * adapter,const u8 ** bootld)990 static int qlcnic_get_bootld_data(struct qlcnic_adapter *adapter,
991 const u8 **bootld)
992 {
993 u32 offs = QLCNIC_BOOTLD_START;
994 struct qlcnic_uni_data data;
995 int ret;
996
997 if (adapter->ahw->fw_type == QLCNIC_UNIFIED_ROMIMAGE) {
998 ret = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_BOOTLD,
999 QLCNIC_UNI_BOOTLD_IDX_OFF, &data);
1000 if (ret || data.size < QLCNIC_UNI_BOOTLD_SIZE)
1001 return -EINVAL;
1002 offs = data.offset;
1003 } else if (!qlcnic_rom_range_valid(adapter->fw->size, offs,
1004 QLCNIC_UNI_BOOTLD_SIZE)) {
1005 return -EINVAL;
1006 }
1007
1008 *bootld = adapter->fw->data + offs;
1009 return 0;
1010 }
1011
qlcnic_get_fw_data(struct qlcnic_adapter * adapter,const u8 ** image,u32 * image_size)1012 static int qlcnic_get_fw_data(struct qlcnic_adapter *adapter,
1013 const u8 **image, u32 *image_size)
1014 {
1015 u32 offs = QLCNIC_IMAGE_START;
1016 struct qlcnic_uni_data data;
1017 int ret;
1018
1019 if (adapter->ahw->fw_type == QLCNIC_UNIFIED_ROMIMAGE) {
1020 ret = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_FW,
1021 QLCNIC_UNI_FIRMWARE_IDX_OFF, &data);
1022 if (ret)
1023 return ret;
1024 offs = data.offset;
1025 *image_size = data.size;
1026 } else {
1027 if (!qlcnic_rom_range_valid(adapter->fw->size,
1028 QLCNIC_FW_SIZE_OFFSET,
1029 sizeof(__le32)))
1030 return -EINVAL;
1031 *image_size = get_unaligned_le32(adapter->fw->data +
1032 QLCNIC_FW_SIZE_OFFSET);
1033 }
1034
1035 if (!qlcnic_rom_range_valid(adapter->fw->size, offs, *image_size))
1036 return -EINVAL;
1037
1038 *image = adapter->fw->data + offs;
1039 return 0;
1040 }
1041
qlcnic_get_fw_version(struct qlcnic_adapter * adapter)1042 static u32 qlcnic_get_fw_version(struct qlcnic_adapter *adapter)
1043 {
1044 char ver_str[QLCNIC_UNI_VERSION_TAIL_SIZE + 1];
1045 const struct firmware *fw = adapter->fw;
1046 struct qlcnic_uni_data data;
1047 u32 major, minor, sub;
1048 int i, ret;
1049
1050 if (adapter->ahw->fw_type != QLCNIC_UNIFIED_ROMIMAGE)
1051 return get_unaligned_le32(fw->data + QLCNIC_FW_VERSION_OFFSET);
1052
1053 ret = qlcnic_get_data_desc(adapter, QLCNIC_UNI_DIR_SECT_FW,
1054 QLCNIC_UNI_FIRMWARE_IDX_OFF, &data);
1055 if (ret || data.size < QLCNIC_UNI_VERSION_TAIL_SIZE)
1056 return 0;
1057
1058 memcpy(ver_str, fw->data + data.offset + data.size -
1059 QLCNIC_UNI_VERSION_TAIL_SIZE,
1060 QLCNIC_UNI_VERSION_TAIL_SIZE);
1061 ver_str[QLCNIC_UNI_VERSION_TAIL_SIZE] = '\0';
1062
1063 for (i = 0; i < 12; i++) {
1064 if (!strncmp(ver_str + i, "REV=", 4)) {
1065 ret = sscanf(&ver_str[i+4], "%u.%u.%u ",
1066 &major, &minor, &sub);
1067 if (ret != 3)
1068 return 0;
1069 else
1070 return major + (minor << 8) + (sub << 16);
1071 }
1072 }
1073
1074 return 0;
1075 }
1076
qlcnic_get_bios_version(struct qlcnic_adapter * adapter)1077 static u32 qlcnic_get_bios_version(struct qlcnic_adapter *adapter)
1078 {
1079 u32 bios_ver, prd_off = adapter->file_prd_off;
1080 const struct firmware *fw = adapter->fw;
1081
1082 if (adapter->ahw->fw_type != QLCNIC_UNIFIED_ROMIMAGE)
1083 return get_unaligned_le32(fw->data + QLCNIC_BIOS_VERSION_OFFSET);
1084
1085 bios_ver = get_unaligned_le32(fw->data + prd_off +
1086 QLCNIC_UNI_BIOS_VERSION_OFF *
1087 sizeof(__le32));
1088
1089 return (bios_ver << 16) + ((bios_ver >> 8) & 0xff00) + (bios_ver >> 24);
1090 }
1091
qlcnic_rom_lock_recovery(struct qlcnic_adapter * adapter)1092 static void qlcnic_rom_lock_recovery(struct qlcnic_adapter *adapter)
1093 {
1094 if (qlcnic_pcie_sem_lock(adapter, 2, QLCNIC_ROM_LOCK_ID))
1095 dev_info(&adapter->pdev->dev, "Resetting rom_lock\n");
1096
1097 qlcnic_pcie_sem_unlock(adapter, 2);
1098 }
1099
1100 static int
qlcnic_check_fw_hearbeat(struct qlcnic_adapter * adapter)1101 qlcnic_check_fw_hearbeat(struct qlcnic_adapter *adapter)
1102 {
1103 u32 heartbeat, ret = -EIO;
1104 int retries = QLCNIC_HEARTBEAT_CHECK_RETRY_COUNT;
1105
1106 adapter->heartbeat = QLC_SHARED_REG_RD32(adapter,
1107 QLCNIC_PEG_ALIVE_COUNTER);
1108
1109 do {
1110 msleep(QLCNIC_HEARTBEAT_PERIOD_MSECS);
1111 heartbeat = QLC_SHARED_REG_RD32(adapter,
1112 QLCNIC_PEG_ALIVE_COUNTER);
1113 if (heartbeat != adapter->heartbeat) {
1114 ret = QLCNIC_RCODE_SUCCESS;
1115 break;
1116 }
1117 } while (--retries);
1118
1119 return ret;
1120 }
1121
1122 int
qlcnic_need_fw_reset(struct qlcnic_adapter * adapter)1123 qlcnic_need_fw_reset(struct qlcnic_adapter *adapter)
1124 {
1125 if ((adapter->flags & QLCNIC_FW_HANG) ||
1126 qlcnic_check_fw_hearbeat(adapter)) {
1127 qlcnic_rom_lock_recovery(adapter);
1128 return 1;
1129 }
1130
1131 if (adapter->need_fw_reset)
1132 return 1;
1133
1134 if (adapter->fw)
1135 return 1;
1136
1137 return 0;
1138 }
1139
1140 static const char *fw_name[] = {
1141 QLCNIC_UNIFIED_ROMIMAGE_NAME,
1142 QLCNIC_FLASH_ROMIMAGE_NAME,
1143 };
1144
1145 int
qlcnic_load_firmware(struct qlcnic_adapter * adapter)1146 qlcnic_load_firmware(struct qlcnic_adapter *adapter)
1147 {
1148 const struct firmware *fw = adapter->fw;
1149 struct pci_dev *pdev = adapter->pdev;
1150 const u8 *bootld, *image;
1151 u32 i, flashaddr, image_size;
1152 int ret;
1153
1154 dev_info(&pdev->dev, "loading firmware from %s\n",
1155 fw_name[adapter->ahw->fw_type]);
1156
1157 if (fw) {
1158 u32 words, remainder;
1159 u64 data;
1160
1161 ret = qlcnic_get_bootld_data(adapter, &bootld);
1162 if (ret)
1163 return ret;
1164 flashaddr = QLCNIC_BOOTLD_START;
1165
1166 for (i = 0; i < QLCNIC_UNI_BOOTLD_SIZE / sizeof(u64); i++) {
1167 data = get_unaligned_le64(bootld + i * sizeof(u64));
1168
1169 if (qlcnic_pci_mem_write_2M(adapter, flashaddr, data))
1170 return -EIO;
1171
1172 flashaddr += 8;
1173 }
1174
1175 ret = qlcnic_get_fw_data(adapter, &image, &image_size);
1176 if (ret)
1177 return ret;
1178 words = image_size / sizeof(u64);
1179 remainder = image_size % sizeof(u64);
1180 flashaddr = QLCNIC_IMAGE_START;
1181
1182 for (i = 0; i < words; i++) {
1183 data = get_unaligned_le64(image + i * sizeof(u64));
1184
1185 if (qlcnic_pci_mem_write_2M(adapter,
1186 flashaddr, data))
1187 return -EIO;
1188
1189 flashaddr += 8;
1190 }
1191
1192 if (remainder) {
1193 __le64 tail = 0;
1194
1195 memcpy(&tail, image + words * sizeof(u64), remainder);
1196 data = le64_to_cpu(tail);
1197
1198 if (qlcnic_pci_mem_write_2M(adapter,
1199 flashaddr, data))
1200 return -EIO;
1201 }
1202
1203 } else {
1204 struct qlcnic_flt_entry bootld_entry;
1205 u32 hi, lo, size;
1206 u64 data;
1207
1208 ret = qlcnic_get_flt_entry(adapter, QLCNIC_BOOTLD_REGION,
1209 &bootld_entry);
1210 if (!ret) {
1211 size = bootld_entry.size / 8;
1212 flashaddr = bootld_entry.start_addr;
1213 } else {
1214 size = (QLCNIC_IMAGE_START - QLCNIC_BOOTLD_START) / 8;
1215 flashaddr = QLCNIC_BOOTLD_START;
1216 dev_info(&pdev->dev,
1217 "using legacy method to get flash fw region");
1218 }
1219
1220 for (i = 0; i < size; i++) {
1221 if (qlcnic_rom_fast_read(adapter,
1222 flashaddr, (int *)&lo) != 0)
1223 return -EIO;
1224 if (qlcnic_rom_fast_read(adapter,
1225 flashaddr + 4, (int *)&hi) != 0)
1226 return -EIO;
1227
1228 data = (((u64)hi << 32) | lo);
1229
1230 if (qlcnic_pci_mem_write_2M(adapter,
1231 flashaddr, data))
1232 return -EIO;
1233
1234 flashaddr += 8;
1235 }
1236 }
1237 usleep_range(1000, 1500);
1238
1239 QLCWR32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x18, 0x1020);
1240 QLCWR32(adapter, QLCNIC_ROMUSB_GLB_SW_RESET, 0x80001e);
1241 return 0;
1242 }
1243
1244 static int
qlcnic_validate_firmware(struct qlcnic_adapter * adapter)1245 qlcnic_validate_firmware(struct qlcnic_adapter *adapter)
1246 {
1247 const struct firmware *fw = adapter->fw;
1248 struct pci_dev *pdev = adapter->pdev;
1249 u8 fw_type = adapter->ahw->fw_type;
1250 u32 ver, bios, min_size;
1251 const u8 *data;
1252 u32 data_size;
1253 u32 val;
1254
1255 if (fw_type == QLCNIC_UNIFIED_ROMIMAGE)
1256 min_size = QLCNIC_UNI_FW_MIN_SIZE;
1257 else
1258 min_size = QLCNIC_FW_MIN_SIZE;
1259
1260 if (fw->size < min_size)
1261 return -EINVAL;
1262
1263 if (fw_type == QLCNIC_UNIFIED_ROMIMAGE) {
1264 if (qlcnic_validate_unified_romimage(adapter))
1265 return -EINVAL;
1266 } else {
1267 val = get_unaligned_le32(fw->data + QLCNIC_FW_MAGIC_OFFSET);
1268 if (val != QLCNIC_BDINFO_MAGIC)
1269 return -EINVAL;
1270 }
1271
1272 if (qlcnic_get_bootld_data(adapter, &data) ||
1273 qlcnic_get_fw_data(adapter, &data, &data_size))
1274 return -EINVAL;
1275
1276 val = qlcnic_get_fw_version(adapter);
1277 ver = QLCNIC_DECODE_VERSION(val);
1278
1279 if (ver < QLCNIC_MIN_FW_VERSION) {
1280 dev_err(&pdev->dev,
1281 "%s: firmware version %d.%d.%d unsupported\n",
1282 fw_name[fw_type], _major(ver), _minor(ver), _build(ver));
1283 return -EINVAL;
1284 }
1285
1286 val = qlcnic_get_bios_version(adapter);
1287 qlcnic_rom_fast_read(adapter, QLCNIC_BIOS_VERSION_OFFSET, (int *)&bios);
1288 if (val != bios) {
1289 dev_err(&pdev->dev, "%s: firmware bios is incompatible\n",
1290 fw_name[fw_type]);
1291 return -EINVAL;
1292 }
1293
1294 QLC_SHARED_REG_WR32(adapter, QLCNIC_FW_IMG_VALID, QLCNIC_BDINFO_MAGIC);
1295 return 0;
1296 }
1297
1298 static void
qlcnic_get_next_fwtype(struct qlcnic_adapter * adapter)1299 qlcnic_get_next_fwtype(struct qlcnic_adapter *adapter)
1300 {
1301 u8 fw_type;
1302
1303 switch (adapter->ahw->fw_type) {
1304 case QLCNIC_UNKNOWN_ROMIMAGE:
1305 fw_type = QLCNIC_UNIFIED_ROMIMAGE;
1306 break;
1307
1308 case QLCNIC_UNIFIED_ROMIMAGE:
1309 default:
1310 fw_type = QLCNIC_FLASH_ROMIMAGE;
1311 break;
1312 }
1313
1314 adapter->ahw->fw_type = fw_type;
1315 }
1316
1317
1318
qlcnic_request_firmware(struct qlcnic_adapter * adapter)1319 void qlcnic_request_firmware(struct qlcnic_adapter *adapter)
1320 {
1321 struct pci_dev *pdev = adapter->pdev;
1322 int rc;
1323
1324 adapter->ahw->fw_type = QLCNIC_UNKNOWN_ROMIMAGE;
1325
1326 next:
1327 qlcnic_get_next_fwtype(adapter);
1328
1329 if (adapter->ahw->fw_type == QLCNIC_FLASH_ROMIMAGE) {
1330 adapter->fw = NULL;
1331 } else {
1332 rc = request_firmware(&adapter->fw,
1333 fw_name[adapter->ahw->fw_type],
1334 &pdev->dev);
1335 if (rc != 0)
1336 goto next;
1337
1338 rc = qlcnic_validate_firmware(adapter);
1339 if (rc != 0) {
1340 release_firmware(adapter->fw);
1341 usleep_range(1000, 1500);
1342 goto next;
1343 }
1344 }
1345 }
1346
1347
1348 void
qlcnic_release_firmware(struct qlcnic_adapter * adapter)1349 qlcnic_release_firmware(struct qlcnic_adapter *adapter)
1350 {
1351 release_firmware(adapter->fw);
1352 adapter->fw = NULL;
1353 }
1354