1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#include <linux/pci.h>
36#include <linux/pci_regs.h>
37#include <linux/firmware.h>
38#include <linux/stddef.h>
39#include <linux/delay.h>
40#include <linux/string.h>
41#include <linux/compiler.h>
42#include <linux/jiffies.h>
43#include <linux/kernel.h>
44#include <linux/log2.h>
45
46#include "csio_hw.h"
47#include "csio_lnode.h"
48#include "csio_rnode.h"
49
50int csio_dbg_level = 0xFEFF;
51unsigned int csio_port_mask = 0xf;
52
53
54static uint32_t csio_evtq_sz = CSIO_EVTQ_SIZE;
55
56
57int csio_msi = 2;
58
59
60static int dev_num;
61
62
63static const struct csio_adap_desc csio_t5_fcoe_adapters[] = {
64 {"T580-Dbg 10G", "Chelsio T580-Dbg 10G [FCoE]"},
65 {"T520-CR 10G", "Chelsio T520-CR 10G [FCoE]"},
66 {"T522-CR 10G/1G", "Chelsio T522-CR 10G/1G [FCoE]"},
67 {"T540-CR 10G", "Chelsio T540-CR 10G [FCoE]"},
68 {"T520-BCH 10G", "Chelsio T520-BCH 10G [FCoE]"},
69 {"T540-BCH 10G", "Chelsio T540-BCH 10G [FCoE]"},
70 {"T540-CH 10G", "Chelsio T540-CH 10G [FCoE]"},
71 {"T520-SO 10G", "Chelsio T520-SO 10G [FCoE]"},
72 {"T520-CX4 10G", "Chelsio T520-CX4 10G [FCoE]"},
73 {"T520-BT 10G", "Chelsio T520-BT 10G [FCoE]"},
74 {"T504-BT 1G", "Chelsio T504-BT 1G [FCoE]"},
75 {"B520-SR 10G", "Chelsio B520-SR 10G [FCoE]"},
76 {"B504-BT 1G", "Chelsio B504-BT 1G [FCoE]"},
77 {"T580-CR 10G", "Chelsio T580-CR 10G [FCoE]"},
78 {"T540-LP-CR 10G", "Chelsio T540-LP-CR 10G [FCoE]"},
79 {"AMSTERDAM 10G", "Chelsio AMSTERDAM 10G [FCoE]"},
80 {"T580-LP-CR 40G", "Chelsio T580-LP-CR 40G [FCoE]"},
81 {"T520-LL-CR 10G", "Chelsio T520-LL-CR 10G [FCoE]"},
82 {"T560-CR 40G", "Chelsio T560-CR 40G [FCoE]"},
83 {"T580-CR 40G", "Chelsio T580-CR 40G [FCoE]"},
84 {"T580-SO 40G", "Chelsio T580-SO 40G [FCoE]"},
85 {"T502-BT 1G", "Chelsio T502-BT 1G [FCoE]"}
86};
87
88static void csio_mgmtm_cleanup(struct csio_mgmtm *);
89static void csio_hw_mbm_cleanup(struct csio_hw *);
90
91
92static void csio_hws_uninit(struct csio_hw *, enum csio_hw_ev);
93static void csio_hws_configuring(struct csio_hw *, enum csio_hw_ev);
94static void csio_hws_initializing(struct csio_hw *, enum csio_hw_ev);
95static void csio_hws_ready(struct csio_hw *, enum csio_hw_ev);
96static void csio_hws_quiescing(struct csio_hw *, enum csio_hw_ev);
97static void csio_hws_quiesced(struct csio_hw *, enum csio_hw_ev);
98static void csio_hws_resetting(struct csio_hw *, enum csio_hw_ev);
99static void csio_hws_removing(struct csio_hw *, enum csio_hw_ev);
100static void csio_hws_pcierr(struct csio_hw *, enum csio_hw_ev);
101
102static void csio_hw_initialize(struct csio_hw *hw);
103static void csio_evtq_stop(struct csio_hw *hw);
104static void csio_evtq_start(struct csio_hw *hw);
105
106int csio_is_hw_ready(struct csio_hw *hw)
107{
108 return csio_match_state(hw, csio_hws_ready);
109}
110
111int csio_is_hw_removing(struct csio_hw *hw)
112{
113 return csio_match_state(hw, csio_hws_removing);
114}
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132int
133csio_hw_wait_op_done_val(struct csio_hw *hw, int reg, uint32_t mask,
134 int polarity, int attempts, int delay, uint32_t *valp)
135{
136 uint32_t val;
137 while (1) {
138 val = csio_rd_reg32(hw, reg);
139
140 if (!!(val & mask) == polarity) {
141 if (valp)
142 *valp = val;
143 return 0;
144 }
145
146 if (--attempts == 0)
147 return -EAGAIN;
148 if (delay)
149 udelay(delay);
150 }
151}
152
153
154
155
156
157
158
159
160
161
162void
163csio_hw_tp_wr_bits_indirect(struct csio_hw *hw, unsigned int addr,
164 unsigned int mask, unsigned int val)
165{
166 csio_wr_reg32(hw, addr, TP_PIO_ADDR_A);
167 val |= csio_rd_reg32(hw, TP_PIO_DATA_A) & ~mask;
168 csio_wr_reg32(hw, val, TP_PIO_DATA_A);
169}
170
171void
172csio_set_reg_field(struct csio_hw *hw, uint32_t reg, uint32_t mask,
173 uint32_t value)
174{
175 uint32_t val = csio_rd_reg32(hw, reg) & ~mask;
176
177 csio_wr_reg32(hw, val | value, reg);
178
179 csio_rd_reg32(hw, reg);
180
181}
182
183static int
184csio_memory_write(struct csio_hw *hw, int mtype, u32 addr, u32 len, u32 *buf)
185{
186 return hw->chip_ops->chip_memory_rw(hw, MEMWIN_CSIOSTOR, mtype,
187 addr, len, buf, 0);
188}
189
190
191
192
193#define EEPROM_MAX_RD_POLL 40
194#define EEPROM_MAX_WR_POLL 6
195#define EEPROM_STAT_ADDR 0x7bfc
196#define VPD_BASE 0x400
197#define VPD_BASE_OLD 0
198#define VPD_LEN 1024
199#define VPD_INFO_FLD_HDR_SIZE 3
200
201
202
203
204
205
206
207
208
209
210
211static int
212csio_hw_seeprom_read(struct csio_hw *hw, uint32_t addr, uint32_t *data)
213{
214 uint16_t val = 0;
215 int attempts = EEPROM_MAX_RD_POLL;
216 uint32_t base = hw->params.pci.vpd_cap_addr;
217
218 if (addr >= EEPROMVSIZE || (addr & 3))
219 return -EINVAL;
220
221 pci_write_config_word(hw->pdev, base + PCI_VPD_ADDR, (uint16_t)addr);
222
223 do {
224 udelay(10);
225 pci_read_config_word(hw->pdev, base + PCI_VPD_ADDR, &val);
226 } while (!(val & PCI_VPD_ADDR_F) && --attempts);
227
228 if (!(val & PCI_VPD_ADDR_F)) {
229 csio_err(hw, "reading EEPROM address 0x%x failed\n", addr);
230 return -EINVAL;
231 }
232
233 pci_read_config_dword(hw->pdev, base + PCI_VPD_DATA, data);
234 *data = le32_to_cpu(*(__le32 *)data);
235
236 return 0;
237}
238
239
240
241
242
243struct t4_vpd_hdr {
244 u8 id_tag;
245 u8 id_len[2];
246 u8 id_data[ID_LEN];
247 u8 vpdr_tag;
248 u8 vpdr_len[2];
249};
250
251
252
253
254
255
256
257
258
259
260static int
261csio_hw_get_vpd_keyword_val(const struct t4_vpd_hdr *v, const char *kw)
262{
263 int32_t i;
264 int32_t offset , len;
265 const uint8_t *buf = &v->id_tag;
266 const uint8_t *vpdr_len = &v->vpdr_tag;
267 offset = sizeof(struct t4_vpd_hdr);
268 len = (uint16_t)vpdr_len[1] + ((uint16_t)vpdr_len[2] << 8);
269
270 if (len + sizeof(struct t4_vpd_hdr) > VPD_LEN)
271 return -EINVAL;
272
273 for (i = offset; (i + VPD_INFO_FLD_HDR_SIZE) <= (offset + len);) {
274 if (memcmp(buf + i , kw, 2) == 0) {
275 i += VPD_INFO_FLD_HDR_SIZE;
276 return i;
277 }
278
279 i += VPD_INFO_FLD_HDR_SIZE + buf[i+2];
280 }
281
282 return -EINVAL;
283}
284
285static int
286csio_pci_capability(struct pci_dev *pdev, int cap, int *pos)
287{
288 *pos = pci_find_capability(pdev, cap);
289 if (*pos)
290 return 0;
291
292 return -1;
293}
294
295
296
297
298
299
300
301
302static int
303csio_hw_get_vpd_params(struct csio_hw *hw, struct csio_vpd *p)
304{
305 int i, ret, ec, sn, addr;
306 uint8_t *vpd, csum;
307 const struct t4_vpd_hdr *v;
308
309 char *s;
310
311 if (csio_is_valid_vpd(hw))
312 return 0;
313
314 ret = csio_pci_capability(hw->pdev, PCI_CAP_ID_VPD,
315 &hw->params.pci.vpd_cap_addr);
316 if (ret)
317 return -EINVAL;
318
319 vpd = kzalloc(VPD_LEN, GFP_ATOMIC);
320 if (vpd == NULL)
321 return -ENOMEM;
322
323
324
325
326
327 ret = csio_hw_seeprom_read(hw, VPD_BASE, (uint32_t *)(vpd));
328 addr = *vpd == 0x82 ? VPD_BASE : VPD_BASE_OLD;
329
330 for (i = 0; i < VPD_LEN; i += 4) {
331 ret = csio_hw_seeprom_read(hw, addr + i, (uint32_t *)(vpd + i));
332 if (ret) {
333 kfree(vpd);
334 return ret;
335 }
336 }
337
338
339 hw->flags &= (~CSIO_HWF_VPD_VALID);
340
341 v = (const struct t4_vpd_hdr *)vpd;
342
343#define FIND_VPD_KW(var, name) do { \
344 var = csio_hw_get_vpd_keyword_val(v, name); \
345 if (var < 0) { \
346 csio_err(hw, "missing VPD keyword " name "\n"); \
347 kfree(vpd); \
348 return -EINVAL; \
349 } \
350} while (0)
351
352 FIND_VPD_KW(i, "RV");
353 for (csum = 0; i >= 0; i--)
354 csum += vpd[i];
355
356 if (csum) {
357 csio_err(hw, "corrupted VPD EEPROM, actual csum %u\n", csum);
358 kfree(vpd);
359 return -EINVAL;
360 }
361 FIND_VPD_KW(ec, "EC");
362 FIND_VPD_KW(sn, "SN");
363#undef FIND_VPD_KW
364
365 memcpy(p->id, v->id_data, ID_LEN);
366 s = strstrip(p->id);
367 memcpy(p->ec, vpd + ec, EC_LEN);
368 s = strstrip(p->ec);
369 i = vpd[sn - VPD_INFO_FLD_HDR_SIZE + 2];
370 memcpy(p->sn, vpd + sn, min(i, SERNUM_LEN));
371 s = strstrip(p->sn);
372
373 csio_valid_vpd_copied(hw);
374
375 kfree(vpd);
376 return 0;
377}
378
379
380
381
382
383
384
385
386
387
388
389
390
391static int
392csio_hw_sf1_read(struct csio_hw *hw, uint32_t byte_cnt, int32_t cont,
393 int32_t lock, uint32_t *valp)
394{
395 int ret;
396
397 if (!byte_cnt || byte_cnt > 4)
398 return -EINVAL;
399 if (csio_rd_reg32(hw, SF_OP_A) & SF_BUSY_F)
400 return -EBUSY;
401
402 csio_wr_reg32(hw, SF_LOCK_V(lock) | SF_CONT_V(cont) |
403 BYTECNT_V(byte_cnt - 1), SF_OP_A);
404 ret = csio_hw_wait_op_done_val(hw, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS,
405 10, NULL);
406 if (!ret)
407 *valp = csio_rd_reg32(hw, SF_DATA_A);
408 return ret;
409}
410
411
412
413
414
415
416
417
418
419
420
421
422
423static int
424csio_hw_sf1_write(struct csio_hw *hw, uint32_t byte_cnt, uint32_t cont,
425 int32_t lock, uint32_t val)
426{
427 if (!byte_cnt || byte_cnt > 4)
428 return -EINVAL;
429 if (csio_rd_reg32(hw, SF_OP_A) & SF_BUSY_F)
430 return -EBUSY;
431
432 csio_wr_reg32(hw, val, SF_DATA_A);
433 csio_wr_reg32(hw, SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1) |
434 OP_V(1) | SF_LOCK_V(lock), SF_OP_A);
435
436 return csio_hw_wait_op_done_val(hw, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS,
437 10, NULL);
438}
439
440
441
442
443
444
445
446
447
448static int
449csio_hw_flash_wait_op(struct csio_hw *hw, int32_t attempts, int32_t delay)
450{
451 int ret;
452 uint32_t status;
453
454 while (1) {
455 ret = csio_hw_sf1_write(hw, 1, 1, 1, SF_RD_STATUS);
456 if (ret != 0)
457 return ret;
458
459 ret = csio_hw_sf1_read(hw, 1, 0, 1, &status);
460 if (ret != 0)
461 return ret;
462
463 if (!(status & 1))
464 return 0;
465 if (--attempts == 0)
466 return -EAGAIN;
467 if (delay)
468 msleep(delay);
469 }
470}
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485static int
486csio_hw_read_flash(struct csio_hw *hw, uint32_t addr, uint32_t nwords,
487 uint32_t *data, int32_t byte_oriented)
488{
489 int ret;
490
491 if (addr + nwords * sizeof(uint32_t) > hw->params.sf_size || (addr & 3))
492 return -EINVAL;
493
494 addr = swab32(addr) | SF_RD_DATA_FAST;
495
496 ret = csio_hw_sf1_write(hw, 4, 1, 0, addr);
497 if (ret != 0)
498 return ret;
499
500 ret = csio_hw_sf1_read(hw, 1, 1, 0, data);
501 if (ret != 0)
502 return ret;
503
504 for ( ; nwords; nwords--, data++) {
505 ret = csio_hw_sf1_read(hw, 4, nwords > 1, nwords == 1, data);
506 if (nwords == 1)
507 csio_wr_reg32(hw, 0, SF_OP_A);
508 if (ret)
509 return ret;
510 if (byte_oriented)
511 *data = (__force __u32) htonl(*data);
512 }
513 return 0;
514}
515
516
517
518
519
520
521
522
523
524
525
526static int
527csio_hw_write_flash(struct csio_hw *hw, uint32_t addr,
528 uint32_t n, const uint8_t *data)
529{
530 int ret = -EINVAL;
531 uint32_t buf[64];
532 uint32_t i, c, left, val, offset = addr & 0xff;
533
534 if (addr >= hw->params.sf_size || offset + n > SF_PAGE_SIZE)
535 return -EINVAL;
536
537 val = swab32(addr) | SF_PROG_PAGE;
538
539 ret = csio_hw_sf1_write(hw, 1, 0, 1, SF_WR_ENABLE);
540 if (ret != 0)
541 goto unlock;
542
543 ret = csio_hw_sf1_write(hw, 4, 1, 1, val);
544 if (ret != 0)
545 goto unlock;
546
547 for (left = n; left; left -= c) {
548 c = min(left, 4U);
549 for (val = 0, i = 0; i < c; ++i)
550 val = (val << 8) + *data++;
551
552 ret = csio_hw_sf1_write(hw, c, c != left, 1, val);
553 if (ret)
554 goto unlock;
555 }
556 ret = csio_hw_flash_wait_op(hw, 8, 1);
557 if (ret)
558 goto unlock;
559
560 csio_wr_reg32(hw, 0, SF_OP_A);
561
562
563 ret = csio_hw_read_flash(hw, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
564 if (ret)
565 return ret;
566
567 if (memcmp(data - n, (uint8_t *)buf + offset, n)) {
568 csio_err(hw,
569 "failed to correctly write the flash page at %#x\n",
570 addr);
571 return -EINVAL;
572 }
573
574 return 0;
575
576unlock:
577 csio_wr_reg32(hw, 0, SF_OP_A);
578 return ret;
579}
580
581
582
583
584
585
586
587
588
589static int
590csio_hw_flash_erase_sectors(struct csio_hw *hw, int32_t start, int32_t end)
591{
592 int ret = 0;
593
594 while (start <= end) {
595
596 ret = csio_hw_sf1_write(hw, 1, 0, 1, SF_WR_ENABLE);
597 if (ret != 0)
598 goto out;
599
600 ret = csio_hw_sf1_write(hw, 4, 0, 1,
601 SF_ERASE_SECTOR | (start << 8));
602 if (ret != 0)
603 goto out;
604
605 ret = csio_hw_flash_wait_op(hw, 14, 500);
606 if (ret != 0)
607 goto out;
608
609 start++;
610 }
611out:
612 if (ret)
613 csio_err(hw, "erase of flash sector %d failed, error %d\n",
614 start, ret);
615 csio_wr_reg32(hw, 0, SF_OP_A);
616 return 0;
617}
618
619static void
620csio_hw_print_fw_version(struct csio_hw *hw, char *str)
621{
622 csio_info(hw, "%s: %u.%u.%u.%u\n", str,
623 FW_HDR_FW_VER_MAJOR_G(hw->fwrev),
624 FW_HDR_FW_VER_MINOR_G(hw->fwrev),
625 FW_HDR_FW_VER_MICRO_G(hw->fwrev),
626 FW_HDR_FW_VER_BUILD_G(hw->fwrev));
627}
628
629
630
631
632
633
634
635
636static int
637csio_hw_get_fw_version(struct csio_hw *hw, uint32_t *vers)
638{
639 return csio_hw_read_flash(hw, FLASH_FW_START +
640 offsetof(struct fw_hdr, fw_ver), 1,
641 vers, 0);
642}
643
644
645
646
647
648
649
650
651static int
652csio_hw_get_tp_version(struct csio_hw *hw, u32 *vers)
653{
654 return csio_hw_read_flash(hw, FLASH_FW_START +
655 offsetof(struct fw_hdr, tp_microcode_ver), 1,
656 vers, 0);
657}
658
659
660
661
662
663
664
665
666
667static int
668csio_hw_fw_dload(struct csio_hw *hw, uint8_t *fw_data, uint32_t size)
669{
670 uint32_t csum;
671 int32_t addr;
672 int ret;
673 uint32_t i;
674 uint8_t first_page[SF_PAGE_SIZE];
675 const __be32 *p = (const __be32 *)fw_data;
676 struct fw_hdr *hdr = (struct fw_hdr *)fw_data;
677 uint32_t sf_sec_size;
678
679 if ((!hw->params.sf_size) || (!hw->params.sf_nsec)) {
680 csio_err(hw, "Serial Flash data invalid\n");
681 return -EINVAL;
682 }
683
684 if (!size) {
685 csio_err(hw, "FW image has no data\n");
686 return -EINVAL;
687 }
688
689 if (size & 511) {
690 csio_err(hw, "FW image size not multiple of 512 bytes\n");
691 return -EINVAL;
692 }
693
694 if (ntohs(hdr->len512) * 512 != size) {
695 csio_err(hw, "FW image size differs from size in FW header\n");
696 return -EINVAL;
697 }
698
699 if (size > FLASH_FW_MAX_SIZE) {
700 csio_err(hw, "FW image too large, max is %u bytes\n",
701 FLASH_FW_MAX_SIZE);
702 return -EINVAL;
703 }
704
705 for (csum = 0, i = 0; i < size / sizeof(csum); i++)
706 csum += ntohl(p[i]);
707
708 if (csum != 0xffffffff) {
709 csio_err(hw, "corrupted firmware image, checksum %#x\n", csum);
710 return -EINVAL;
711 }
712
713 sf_sec_size = hw->params.sf_size / hw->params.sf_nsec;
714 i = DIV_ROUND_UP(size, sf_sec_size);
715
716 csio_dbg(hw, "Erasing sectors... start:%d end:%d\n",
717 FLASH_FW_START_SEC, FLASH_FW_START_SEC + i - 1);
718
719 ret = csio_hw_flash_erase_sectors(hw, FLASH_FW_START_SEC,
720 FLASH_FW_START_SEC + i - 1);
721 if (ret) {
722 csio_err(hw, "Flash Erase failed\n");
723 goto out;
724 }
725
726
727
728
729
730
731 memcpy(first_page, fw_data, SF_PAGE_SIZE);
732 ((struct fw_hdr *)first_page)->fw_ver = htonl(0xffffffff);
733 ret = csio_hw_write_flash(hw, FLASH_FW_START, SF_PAGE_SIZE, first_page);
734 if (ret)
735 goto out;
736
737 csio_dbg(hw, "Writing Flash .. start:%d end:%d\n",
738 FW_IMG_START, FW_IMG_START + size);
739
740 addr = FLASH_FW_START;
741 for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) {
742 addr += SF_PAGE_SIZE;
743 fw_data += SF_PAGE_SIZE;
744 ret = csio_hw_write_flash(hw, addr, SF_PAGE_SIZE, fw_data);
745 if (ret)
746 goto out;
747 }
748
749 ret = csio_hw_write_flash(hw,
750 FLASH_FW_START +
751 offsetof(struct fw_hdr, fw_ver),
752 sizeof(hdr->fw_ver),
753 (const uint8_t *)&hdr->fw_ver);
754
755out:
756 if (ret)
757 csio_err(hw, "firmware download failed, error %d\n", ret);
758 return ret;
759}
760
761static int
762csio_hw_get_flash_params(struct csio_hw *hw)
763{
764 int ret;
765 uint32_t info = 0;
766
767 ret = csio_hw_sf1_write(hw, 1, 1, 0, SF_RD_ID);
768 if (!ret)
769 ret = csio_hw_sf1_read(hw, 3, 0, 1, &info);
770 csio_wr_reg32(hw, 0, SF_OP_A);
771 if (ret != 0)
772 return ret;
773
774 if ((info & 0xff) != 0x20)
775 return -EINVAL;
776 info >>= 16;
777 if (info >= 0x14 && info < 0x18)
778 hw->params.sf_nsec = 1 << (info - 16);
779 else if (info == 0x18)
780 hw->params.sf_nsec = 64;
781 else
782 return -EINVAL;
783 hw->params.sf_size = 1 << info;
784
785 return 0;
786}
787
788
789
790
791
792static int
793csio_hw_dev_ready(struct csio_hw *hw)
794{
795 uint32_t reg;
796 int cnt = 6;
797
798 while (((reg = csio_rd_reg32(hw, PL_WHOAMI_A)) == 0xFFFFFFFF) &&
799 (--cnt != 0))
800 mdelay(100);
801
802 if ((cnt == 0) && (((int32_t)(SOURCEPF_G(reg)) < 0) ||
803 (SOURCEPF_G(reg) >= CSIO_MAX_PFN))) {
804 csio_err(hw, "PL_WHOAMI returned 0x%x, cnt:%d\n", reg, cnt);
805 return -EIO;
806 }
807
808 hw->pfn = SOURCEPF_G(reg);
809
810 return 0;
811}
812
813
814
815
816
817
818
819
820static int
821csio_do_hello(struct csio_hw *hw, enum csio_dev_state *state)
822{
823 struct csio_mb *mbp;
824 int rv = 0;
825 enum fw_retval retval;
826 uint8_t mpfn;
827 char state_str[16];
828 int retries = FW_CMD_HELLO_RETRIES;
829
830 memset(state_str, 0, sizeof(state_str));
831
832 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
833 if (!mbp) {
834 rv = -ENOMEM;
835 CSIO_INC_STATS(hw, n_err_nomem);
836 goto out;
837 }
838
839retry:
840 csio_mb_hello(hw, mbp, CSIO_MB_DEFAULT_TMO, hw->pfn,
841 hw->pfn, CSIO_MASTER_MAY, NULL);
842
843 rv = csio_mb_issue(hw, mbp);
844 if (rv) {
845 csio_err(hw, "failed to issue HELLO cmd. ret:%d.\n", rv);
846 goto out_free_mb;
847 }
848
849 csio_mb_process_hello_rsp(hw, mbp, &retval, state, &mpfn);
850 if (retval != FW_SUCCESS) {
851 csio_err(hw, "HELLO cmd failed with ret: %d\n", retval);
852 rv = -EINVAL;
853 goto out_free_mb;
854 }
855
856
857 if (hw->pfn == mpfn) {
858 hw->flags |= CSIO_HWF_MASTER;
859 } else if (*state == CSIO_DEV_STATE_UNINIT) {
860
861
862
863
864
865
866
867
868
869
870
871
872
873 int waiting = FW_CMD_HELLO_TIMEOUT;
874
875
876
877
878
879
880
881
882 for (;;) {
883 uint32_t pcie_fw;
884
885 spin_unlock_irq(&hw->lock);
886 msleep(50);
887 spin_lock_irq(&hw->lock);
888 waiting -= 50;
889
890
891
892
893
894
895
896 pcie_fw = csio_rd_reg32(hw, PCIE_FW_A);
897 if (!(pcie_fw & (PCIE_FW_ERR_F|PCIE_FW_INIT_F))) {
898 if (waiting <= 0) {
899 if (retries-- > 0)
900 goto retry;
901
902 rv = -ETIMEDOUT;
903 break;
904 }
905 continue;
906 }
907
908
909
910
911
912 if (state) {
913 if (pcie_fw & PCIE_FW_ERR_F) {
914 *state = CSIO_DEV_STATE_ERR;
915 rv = -ETIMEDOUT;
916 } else if (pcie_fw & PCIE_FW_INIT_F)
917 *state = CSIO_DEV_STATE_INIT;
918 }
919
920
921
922
923
924
925 if (mpfn == PCIE_FW_MASTER_M &&
926 (pcie_fw & PCIE_FW_MASTER_VLD_F))
927 mpfn = PCIE_FW_MASTER_G(pcie_fw);
928 break;
929 }
930 hw->flags &= ~CSIO_HWF_MASTER;
931 }
932
933 switch (*state) {
934 case CSIO_DEV_STATE_UNINIT:
935 strcpy(state_str, "Initializing");
936 break;
937 case CSIO_DEV_STATE_INIT:
938 strcpy(state_str, "Initialized");
939 break;
940 case CSIO_DEV_STATE_ERR:
941 strcpy(state_str, "Error");
942 break;
943 default:
944 strcpy(state_str, "Unknown");
945 break;
946 }
947
948 if (hw->pfn == mpfn)
949 csio_info(hw, "PF: %d, Coming up as MASTER, HW state: %s\n",
950 hw->pfn, state_str);
951 else
952 csio_info(hw,
953 "PF: %d, Coming up as SLAVE, Master PF: %d, HW state: %s\n",
954 hw->pfn, mpfn, state_str);
955
956out_free_mb:
957 mempool_free(mbp, hw->mb_mempool);
958out:
959 return rv;
960}
961
962
963
964
965
966
967static int
968csio_do_bye(struct csio_hw *hw)
969{
970 struct csio_mb *mbp;
971 enum fw_retval retval;
972
973 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
974 if (!mbp) {
975 CSIO_INC_STATS(hw, n_err_nomem);
976 return -ENOMEM;
977 }
978
979 csio_mb_bye(hw, mbp, CSIO_MB_DEFAULT_TMO, NULL);
980
981 if (csio_mb_issue(hw, mbp)) {
982 csio_err(hw, "Issue of BYE command failed\n");
983 mempool_free(mbp, hw->mb_mempool);
984 return -EINVAL;
985 }
986
987 retval = csio_mb_fw_retval(mbp);
988 if (retval != FW_SUCCESS) {
989 mempool_free(mbp, hw->mb_mempool);
990 return -EINVAL;
991 }
992
993 mempool_free(mbp, hw->mb_mempool);
994
995 return 0;
996}
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007static int
1008csio_do_reset(struct csio_hw *hw, bool fw_rst)
1009{
1010 struct csio_mb *mbp;
1011 enum fw_retval retval;
1012
1013 if (!fw_rst) {
1014
1015 csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
1016 mdelay(2000);
1017 return 0;
1018 }
1019
1020 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1021 if (!mbp) {
1022 CSIO_INC_STATS(hw, n_err_nomem);
1023 return -ENOMEM;
1024 }
1025
1026 csio_mb_reset(hw, mbp, CSIO_MB_DEFAULT_TMO,
1027 PIORSTMODE_F | PIORST_F, 0, NULL);
1028
1029 if (csio_mb_issue(hw, mbp)) {
1030 csio_err(hw, "Issue of RESET command failed.n");
1031 mempool_free(mbp, hw->mb_mempool);
1032 return -EINVAL;
1033 }
1034
1035 retval = csio_mb_fw_retval(mbp);
1036 if (retval != FW_SUCCESS) {
1037 csio_err(hw, "RESET cmd failed with ret:0x%x.\n", retval);
1038 mempool_free(mbp, hw->mb_mempool);
1039 return -EINVAL;
1040 }
1041
1042 mempool_free(mbp, hw->mb_mempool);
1043
1044 return 0;
1045}
1046
1047static int
1048csio_hw_validate_caps(struct csio_hw *hw, struct csio_mb *mbp)
1049{
1050 struct fw_caps_config_cmd *rsp = (struct fw_caps_config_cmd *)mbp->mb;
1051 uint16_t caps;
1052
1053 caps = ntohs(rsp->fcoecaps);
1054
1055 if (!(caps & FW_CAPS_CONFIG_FCOE_INITIATOR)) {
1056 csio_err(hw, "No FCoE Initiator capability in the firmware.\n");
1057 return -EINVAL;
1058 }
1059
1060 if (!(caps & FW_CAPS_CONFIG_FCOE_CTRL_OFLD)) {
1061 csio_err(hw, "No FCoE Control Offload capability\n");
1062 return -EINVAL;
1063 }
1064
1065 return 0;
1066}
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084static int
1085csio_hw_fw_halt(struct csio_hw *hw, uint32_t mbox, int32_t force)
1086{
1087 enum fw_retval retval = 0;
1088
1089
1090
1091
1092
1093 if (mbox <= PCIE_FW_MASTER_M) {
1094 struct csio_mb *mbp;
1095
1096 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1097 if (!mbp) {
1098 CSIO_INC_STATS(hw, n_err_nomem);
1099 return -ENOMEM;
1100 }
1101
1102 csio_mb_reset(hw, mbp, CSIO_MB_DEFAULT_TMO,
1103 PIORSTMODE_F | PIORST_F, FW_RESET_CMD_HALT_F,
1104 NULL);
1105
1106 if (csio_mb_issue(hw, mbp)) {
1107 csio_err(hw, "Issue of RESET command failed!\n");
1108 mempool_free(mbp, hw->mb_mempool);
1109 return -EINVAL;
1110 }
1111
1112 retval = csio_mb_fw_retval(mbp);
1113 mempool_free(mbp, hw->mb_mempool);
1114 }
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129 if (retval == 0 || force) {
1130 csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, UPCRST_F);
1131 csio_set_reg_field(hw, PCIE_FW_A, PCIE_FW_HALT_F,
1132 PCIE_FW_HALT_F);
1133 }
1134
1135
1136
1137
1138
1139 return retval ? -EINVAL : 0;
1140}
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163static int
1164csio_hw_fw_restart(struct csio_hw *hw, uint32_t mbox, int32_t reset)
1165{
1166 if (reset) {
1167
1168
1169
1170
1171
1172 csio_set_reg_field(hw, PCIE_FW_A, PCIE_FW_HALT_F, 0);
1173
1174
1175
1176
1177
1178
1179
1180
1181 if (mbox <= PCIE_FW_MASTER_M) {
1182 csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, 0);
1183 msleep(100);
1184 if (csio_do_reset(hw, true) == 0)
1185 return 0;
1186 }
1187
1188 csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
1189 msleep(2000);
1190 } else {
1191 int ms;
1192
1193 csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, 0);
1194 for (ms = 0; ms < FW_CMD_MAX_TIMEOUT; ) {
1195 if (!(csio_rd_reg32(hw, PCIE_FW_A) & PCIE_FW_HALT_F))
1196 return 0;
1197 msleep(100);
1198 ms += 100;
1199 }
1200 return -ETIMEDOUT;
1201 }
1202 return 0;
1203}
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226static int
1227csio_hw_fw_upgrade(struct csio_hw *hw, uint32_t mbox,
1228 const u8 *fw_data, uint32_t size, int32_t force)
1229{
1230 const struct fw_hdr *fw_hdr = (const struct fw_hdr *)fw_data;
1231 int reset, ret;
1232
1233 ret = csio_hw_fw_halt(hw, mbox, force);
1234 if (ret != 0 && !force)
1235 return ret;
1236
1237 ret = csio_hw_fw_dload(hw, (uint8_t *) fw_data, size);
1238 if (ret != 0)
1239 return ret;
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249 reset = ((ntohl(fw_hdr->flags) & FW_HDR_FLAGS_RESET_HALT) == 0);
1250 return csio_hw_fw_restart(hw, mbox, reset);
1251}
1252
1253
1254
1255
1256
1257
1258static int
1259csio_get_device_params(struct csio_hw *hw)
1260{
1261 struct csio_wrm *wrm = csio_hw_to_wrm(hw);
1262 struct csio_mb *mbp;
1263 enum fw_retval retval;
1264 u32 param[6];
1265 int i, j = 0;
1266
1267
1268 for (i = 0; i < CSIO_MAX_PPORTS; i++)
1269 hw->pport[i].portid = -1;
1270
1271 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1272 if (!mbp) {
1273 CSIO_INC_STATS(hw, n_err_nomem);
1274 return -ENOMEM;
1275 }
1276
1277
1278 param[0] = FW_PARAM_DEV(PORTVEC);
1279
1280
1281 param[1] = FW_PARAM_DEV(CCLK);
1282
1283
1284 param[2] = FW_PARAM_PFVF(EQ_START);
1285 param[3] = FW_PARAM_PFVF(EQ_END);
1286
1287
1288 param[4] = FW_PARAM_PFVF(IQFLINT_START);
1289 param[5] = FW_PARAM_PFVF(IQFLINT_END);
1290
1291 csio_mb_params(hw, mbp, CSIO_MB_DEFAULT_TMO, hw->pfn, 0,
1292 ARRAY_SIZE(param), param, NULL, false, NULL);
1293 if (csio_mb_issue(hw, mbp)) {
1294 csio_err(hw, "Issue of FW_PARAMS_CMD(read) failed!\n");
1295 mempool_free(mbp, hw->mb_mempool);
1296 return -EINVAL;
1297 }
1298
1299 csio_mb_process_read_params_rsp(hw, mbp, &retval,
1300 ARRAY_SIZE(param), param);
1301 if (retval != FW_SUCCESS) {
1302 csio_err(hw, "FW_PARAMS_CMD(read) failed with ret:0x%x!\n",
1303 retval);
1304 mempool_free(mbp, hw->mb_mempool);
1305 return -EINVAL;
1306 }
1307
1308
1309 hw->port_vec = param[0];
1310 hw->vpd.cclk = param[1];
1311 wrm->fw_eq_start = param[2];
1312 wrm->fw_iq_start = param[4];
1313
1314
1315 if ((hw->flags & CSIO_HWF_USING_SOFT_PARAMS) ||
1316 !csio_is_hw_master(hw)) {
1317 hw->cfg_niq = param[5] - param[4] + 1;
1318 hw->cfg_neq = param[3] - param[2] + 1;
1319 csio_dbg(hw, "Using fwconfig max niqs %d neqs %d\n",
1320 hw->cfg_niq, hw->cfg_neq);
1321 }
1322
1323 hw->port_vec &= csio_port_mask;
1324
1325 hw->num_pports = hweight32(hw->port_vec);
1326
1327 csio_dbg(hw, "Port vector: 0x%x, #ports: %d\n",
1328 hw->port_vec, hw->num_pports);
1329
1330 for (i = 0; i < hw->num_pports; i++) {
1331 while ((hw->port_vec & (1 << j)) == 0)
1332 j++;
1333 hw->pport[i].portid = j++;
1334 csio_dbg(hw, "Found Port:%d\n", hw->pport[i].portid);
1335 }
1336 mempool_free(mbp, hw->mb_mempool);
1337
1338 return 0;
1339}
1340
1341
1342
1343
1344
1345
1346
1347static int
1348csio_config_device_caps(struct csio_hw *hw)
1349{
1350 struct csio_mb *mbp;
1351 enum fw_retval retval;
1352 int rv = -EINVAL;
1353
1354 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1355 if (!mbp) {
1356 CSIO_INC_STATS(hw, n_err_nomem);
1357 return -ENOMEM;
1358 }
1359
1360
1361 csio_mb_caps_config(hw, mbp, CSIO_MB_DEFAULT_TMO, 0, 0, 0, 0, NULL);
1362
1363 if (csio_mb_issue(hw, mbp)) {
1364 csio_err(hw, "Issue of FW_CAPS_CONFIG_CMD(r) failed!\n");
1365 goto out;
1366 }
1367
1368 retval = csio_mb_fw_retval(mbp);
1369 if (retval != FW_SUCCESS) {
1370 csio_err(hw, "FW_CAPS_CONFIG_CMD(r) returned %d!\n", retval);
1371 goto out;
1372 }
1373
1374
1375 rv = csio_hw_validate_caps(hw, mbp);
1376 if (rv != 0)
1377 goto out;
1378
1379
1380 if (hw->fw_state == CSIO_DEV_STATE_INIT) {
1381 rv = 0;
1382 goto out;
1383 }
1384
1385
1386 csio_mb_caps_config(hw, mbp, CSIO_MB_DEFAULT_TMO, true, true,
1387 false, true, NULL);
1388
1389 if (csio_mb_issue(hw, mbp)) {
1390 csio_err(hw, "Issue of FW_CAPS_CONFIG_CMD(w) failed!\n");
1391 goto out;
1392 }
1393
1394 retval = csio_mb_fw_retval(mbp);
1395 if (retval != FW_SUCCESS) {
1396 csio_err(hw, "FW_CAPS_CONFIG_CMD(w) returned %d!\n", retval);
1397 goto out;
1398 }
1399
1400 rv = 0;
1401out:
1402 mempool_free(mbp, hw->mb_mempool);
1403 return rv;
1404}
1405
1406
1407
1408
1409
1410
1411static int
1412csio_enable_ports(struct csio_hw *hw)
1413{
1414 struct csio_mb *mbp;
1415 enum fw_retval retval;
1416 uint8_t portid;
1417 int i;
1418
1419 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1420 if (!mbp) {
1421 CSIO_INC_STATS(hw, n_err_nomem);
1422 return -ENOMEM;
1423 }
1424
1425 for (i = 0; i < hw->num_pports; i++) {
1426 portid = hw->pport[i].portid;
1427
1428
1429 csio_mb_port(hw, mbp, CSIO_MB_DEFAULT_TMO, portid,
1430 false, 0, 0, NULL);
1431
1432 if (csio_mb_issue(hw, mbp)) {
1433 csio_err(hw, "failed to issue FW_PORT_CMD(r) port:%d\n",
1434 portid);
1435 mempool_free(mbp, hw->mb_mempool);
1436 return -EINVAL;
1437 }
1438
1439 csio_mb_process_read_port_rsp(hw, mbp, &retval,
1440 &hw->pport[i].pcap);
1441 if (retval != FW_SUCCESS) {
1442 csio_err(hw, "FW_PORT_CMD(r) port:%d failed: 0x%x\n",
1443 portid, retval);
1444 mempool_free(mbp, hw->mb_mempool);
1445 return -EINVAL;
1446 }
1447
1448
1449 csio_mb_port(hw, mbp, CSIO_MB_DEFAULT_TMO, portid, true,
1450 (PAUSE_RX | PAUSE_TX), hw->pport[i].pcap, NULL);
1451
1452 if (csio_mb_issue(hw, mbp)) {
1453 csio_err(hw, "failed to issue FW_PORT_CMD(w) port:%d\n",
1454 portid);
1455 mempool_free(mbp, hw->mb_mempool);
1456 return -EINVAL;
1457 }
1458
1459 retval = csio_mb_fw_retval(mbp);
1460 if (retval != FW_SUCCESS) {
1461 csio_err(hw, "FW_PORT_CMD(w) port:%d failed :0x%x\n",
1462 portid, retval);
1463 mempool_free(mbp, hw->mb_mempool);
1464 return -EINVAL;
1465 }
1466
1467 }
1468
1469 mempool_free(mbp, hw->mb_mempool);
1470
1471 return 0;
1472}
1473
1474
1475
1476
1477
1478
1479static int
1480csio_get_fcoe_resinfo(struct csio_hw *hw)
1481{
1482 struct csio_fcoe_res_info *res_info = &hw->fres_info;
1483 struct fw_fcoe_res_info_cmd *rsp;
1484 struct csio_mb *mbp;
1485 enum fw_retval retval;
1486
1487 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1488 if (!mbp) {
1489 CSIO_INC_STATS(hw, n_err_nomem);
1490 return -ENOMEM;
1491 }
1492
1493
1494 csio_fcoe_read_res_info_init_mb(hw, mbp, CSIO_MB_DEFAULT_TMO, NULL);
1495
1496 if (csio_mb_issue(hw, mbp)) {
1497 csio_err(hw, "failed to issue FW_FCOE_RES_INFO_CMD\n");
1498 mempool_free(mbp, hw->mb_mempool);
1499 return -EINVAL;
1500 }
1501
1502 rsp = (struct fw_fcoe_res_info_cmd *)(mbp->mb);
1503 retval = FW_CMD_RETVAL_G(ntohl(rsp->retval_len16));
1504 if (retval != FW_SUCCESS) {
1505 csio_err(hw, "FW_FCOE_RES_INFO_CMD failed with ret x%x\n",
1506 retval);
1507 mempool_free(mbp, hw->mb_mempool);
1508 return -EINVAL;
1509 }
1510
1511 res_info->e_d_tov = ntohs(rsp->e_d_tov);
1512 res_info->r_a_tov_seq = ntohs(rsp->r_a_tov_seq);
1513 res_info->r_a_tov_els = ntohs(rsp->r_a_tov_els);
1514 res_info->r_r_tov = ntohs(rsp->r_r_tov);
1515 res_info->max_xchgs = ntohl(rsp->max_xchgs);
1516 res_info->max_ssns = ntohl(rsp->max_ssns);
1517 res_info->used_xchgs = ntohl(rsp->used_xchgs);
1518 res_info->used_ssns = ntohl(rsp->used_ssns);
1519 res_info->max_fcfs = ntohl(rsp->max_fcfs);
1520 res_info->max_vnps = ntohl(rsp->max_vnps);
1521 res_info->used_fcfs = ntohl(rsp->used_fcfs);
1522 res_info->used_vnps = ntohl(rsp->used_vnps);
1523
1524 csio_dbg(hw, "max ssns:%d max xchgs:%d\n", res_info->max_ssns,
1525 res_info->max_xchgs);
1526 mempool_free(mbp, hw->mb_mempool);
1527
1528 return 0;
1529}
1530
1531static int
1532csio_hw_check_fwconfig(struct csio_hw *hw, u32 *param)
1533{
1534 struct csio_mb *mbp;
1535 enum fw_retval retval;
1536 u32 _param[1];
1537
1538 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1539 if (!mbp) {
1540 CSIO_INC_STATS(hw, n_err_nomem);
1541 return -ENOMEM;
1542 }
1543
1544
1545
1546
1547
1548 _param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
1549 FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_CF));
1550
1551 csio_mb_params(hw, mbp, CSIO_MB_DEFAULT_TMO, hw->pfn, 0,
1552 ARRAY_SIZE(_param), _param, NULL, false, NULL);
1553 if (csio_mb_issue(hw, mbp)) {
1554 csio_err(hw, "Issue of FW_PARAMS_CMD(read) failed!\n");
1555 mempool_free(mbp, hw->mb_mempool);
1556 return -EINVAL;
1557 }
1558
1559 csio_mb_process_read_params_rsp(hw, mbp, &retval,
1560 ARRAY_SIZE(_param), _param);
1561 if (retval != FW_SUCCESS) {
1562 csio_err(hw, "FW_PARAMS_CMD(read) failed with ret:0x%x!\n",
1563 retval);
1564 mempool_free(mbp, hw->mb_mempool);
1565 return -EINVAL;
1566 }
1567
1568 mempool_free(mbp, hw->mb_mempool);
1569 *param = _param[0];
1570
1571 return 0;
1572}
1573
1574static int
1575csio_hw_flash_config(struct csio_hw *hw, u32 *fw_cfg_param, char *path)
1576{
1577 int ret = 0;
1578 const struct firmware *cf;
1579 struct pci_dev *pci_dev = hw->pdev;
1580 struct device *dev = &pci_dev->dev;
1581 unsigned int mtype = 0, maddr = 0;
1582 uint32_t *cfg_data;
1583 int value_to_add = 0;
1584
1585 if (request_firmware(&cf, FW_CFG_NAME_T5, dev) < 0) {
1586 csio_err(hw, "could not find config file %s, err: %d\n",
1587 FW_CFG_NAME_T5, ret);
1588 return -ENOENT;
1589 }
1590
1591 if (cf->size%4 != 0)
1592 value_to_add = 4 - (cf->size % 4);
1593
1594 cfg_data = kzalloc(cf->size+value_to_add, GFP_KERNEL);
1595 if (cfg_data == NULL) {
1596 ret = -ENOMEM;
1597 goto leave;
1598 }
1599
1600 memcpy((void *)cfg_data, (const void *)cf->data, cf->size);
1601 if (csio_hw_check_fwconfig(hw, fw_cfg_param) != 0) {
1602 ret = -EINVAL;
1603 goto leave;
1604 }
1605
1606 mtype = FW_PARAMS_PARAM_Y_G(*fw_cfg_param);
1607 maddr = FW_PARAMS_PARAM_Z_G(*fw_cfg_param) << 16;
1608
1609 ret = csio_memory_write(hw, mtype, maddr,
1610 cf->size + value_to_add, cfg_data);
1611
1612 if ((ret == 0) && (value_to_add != 0)) {
1613 union {
1614 u32 word;
1615 char buf[4];
1616 } last;
1617 size_t size = cf->size & ~0x3;
1618 int i;
1619
1620 last.word = cfg_data[size >> 2];
1621 for (i = value_to_add; i < 4; i++)
1622 last.buf[i] = 0;
1623 ret = csio_memory_write(hw, mtype, maddr + size, 4, &last.word);
1624 }
1625 if (ret == 0) {
1626 csio_info(hw, "config file upgraded to %s\n",
1627 FW_CFG_NAME_T5);
1628 snprintf(path, 64, "%s%s", "/lib/firmware/", FW_CFG_NAME_T5);
1629 }
1630
1631leave:
1632 kfree(cfg_data);
1633 release_firmware(cf);
1634 return ret;
1635}
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653static int
1654csio_hw_use_fwconfig(struct csio_hw *hw, int reset, u32 *fw_cfg_param)
1655{
1656 struct csio_mb *mbp = NULL;
1657 struct fw_caps_config_cmd *caps_cmd;
1658 unsigned int mtype, maddr;
1659 int rv = -EINVAL;
1660 uint32_t finiver = 0, finicsum = 0, cfcsum = 0;
1661 char path[64];
1662 char *config_name = NULL;
1663
1664
1665
1666
1667 if (reset) {
1668 rv = csio_do_reset(hw, true);
1669 if (rv != 0)
1670 goto bye;
1671 }
1672
1673
1674
1675
1676
1677
1678 spin_unlock_irq(&hw->lock);
1679 rv = csio_hw_flash_config(hw, fw_cfg_param, path);
1680 spin_lock_irq(&hw->lock);
1681 if (rv != 0) {
1682
1683
1684
1685
1686 config_name = "On FLASH";
1687 mtype = FW_MEMTYPE_CF_FLASH;
1688 maddr = hw->chip_ops->chip_flash_cfg_addr(hw);
1689 } else {
1690 config_name = path;
1691 mtype = FW_PARAMS_PARAM_Y_G(*fw_cfg_param);
1692 maddr = FW_PARAMS_PARAM_Z_G(*fw_cfg_param) << 16;
1693 }
1694
1695 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
1696 if (!mbp) {
1697 CSIO_INC_STATS(hw, n_err_nomem);
1698 return -ENOMEM;
1699 }
1700
1701
1702
1703
1704
1705
1706 caps_cmd = (struct fw_caps_config_cmd *)(mbp->mb);
1707 CSIO_INIT_MBP(mbp, caps_cmd, CSIO_MB_DEFAULT_TMO, hw, NULL, 1);
1708 caps_cmd->op_to_write =
1709 htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
1710 FW_CMD_REQUEST_F |
1711 FW_CMD_READ_F);
1712 caps_cmd->cfvalid_to_len16 =
1713 htonl(FW_CAPS_CONFIG_CMD_CFVALID_F |
1714 FW_CAPS_CONFIG_CMD_MEMTYPE_CF_V(mtype) |
1715 FW_CAPS_CONFIG_CMD_MEMADDR64K_CF_V(maddr >> 16) |
1716 FW_LEN16(*caps_cmd));
1717
1718 if (csio_mb_issue(hw, mbp)) {
1719 rv = -EINVAL;
1720 goto bye;
1721 }
1722
1723 rv = csio_mb_fw_retval(mbp);
1724
1725
1726
1727
1728
1729
1730 if (rv == ENOENT) {
1731 CSIO_INIT_MBP(mbp, caps_cmd, CSIO_MB_DEFAULT_TMO, hw, NULL, 1);
1732 caps_cmd->op_to_write = htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
1733 FW_CMD_REQUEST_F |
1734 FW_CMD_READ_F);
1735 caps_cmd->cfvalid_to_len16 = htonl(FW_LEN16(*caps_cmd));
1736
1737 if (csio_mb_issue(hw, mbp)) {
1738 rv = -EINVAL;
1739 goto bye;
1740 }
1741
1742 rv = csio_mb_fw_retval(mbp);
1743 config_name = "Firmware Default";
1744 }
1745 if (rv != FW_SUCCESS)
1746 goto bye;
1747
1748 finiver = ntohl(caps_cmd->finiver);
1749 finicsum = ntohl(caps_cmd->finicsum);
1750 cfcsum = ntohl(caps_cmd->cfcsum);
1751
1752
1753
1754
1755 caps_cmd->op_to_write =
1756 htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
1757 FW_CMD_REQUEST_F |
1758 FW_CMD_WRITE_F);
1759 caps_cmd->cfvalid_to_len16 = htonl(FW_LEN16(*caps_cmd));
1760
1761 if (csio_mb_issue(hw, mbp)) {
1762 rv = -EINVAL;
1763 goto bye;
1764 }
1765
1766 rv = csio_mb_fw_retval(mbp);
1767 if (rv != FW_SUCCESS) {
1768 csio_dbg(hw, "FW_CAPS_CONFIG_CMD returned %d!\n", rv);
1769 goto bye;
1770 }
1771
1772 mempool_free(mbp, hw->mb_mempool);
1773 if (finicsum != cfcsum) {
1774 csio_warn(hw,
1775 "Config File checksum mismatch: csum=%#x, computed=%#x\n",
1776 finicsum, cfcsum);
1777 }
1778
1779
1780 rv = csio_hw_validate_caps(hw, mbp);
1781 if (rv != 0)
1782 goto bye;
1783
1784
1785
1786
1787
1788 hw->flags |= CSIO_HWF_USING_SOFT_PARAMS;
1789
1790
1791 rv = csio_get_device_params(hw);
1792 if (rv != 0)
1793 goto bye;
1794
1795
1796 csio_wr_sge_init(hw);
1797
1798
1799
1800
1801
1802
1803 csio_post_event(&hw->sm, CSIO_HWE_INIT);
1804
1805 csio_info(hw, "Successfully configure using Firmware "
1806 "Configuration File %s, version %#x, computed checksum %#x\n",
1807 config_name, finiver, cfcsum);
1808 return 0;
1809
1810
1811
1812
1813bye:
1814 if (mbp)
1815 mempool_free(mbp, hw->mb_mempool);
1816 hw->flags &= ~CSIO_HWF_USING_SOFT_PARAMS;
1817 csio_warn(hw, "Configuration file error %d\n", rv);
1818 return rv;
1819}
1820
1821
1822
1823
1824static int fw_compatible(const struct fw_hdr *hdr1, const struct fw_hdr *hdr2)
1825{
1826
1827
1828 if (hdr1->chip == hdr2->chip && hdr1->fw_ver == hdr2->fw_ver)
1829 return 1;
1830
1831#define SAME_INTF(x) (hdr1->intfver_##x == hdr2->intfver_##x)
1832 if (hdr1->chip == hdr2->chip && SAME_INTF(nic) && SAME_INTF(vnic) &&
1833 SAME_INTF(ri) && SAME_INTF(iscsi) && SAME_INTF(fcoe))
1834 return 1;
1835#undef SAME_INTF
1836
1837 return 0;
1838}
1839
1840
1841
1842
1843
1844static int csio_should_install_fs_fw(struct csio_hw *hw, int card_fw_usable,
1845 int k, int c)
1846{
1847 const char *reason;
1848
1849 if (!card_fw_usable) {
1850 reason = "incompatible or unusable";
1851 goto install;
1852 }
1853
1854 if (k > c) {
1855 reason = "older than the version supported with this driver";
1856 goto install;
1857 }
1858
1859 return 0;
1860
1861install:
1862 csio_err(hw, "firmware on card (%u.%u.%u.%u) is %s, "
1863 "installing firmware %u.%u.%u.%u on card.\n",
1864 FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
1865 FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c), reason,
1866 FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
1867 FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
1868
1869 return 1;
1870}
1871
1872static struct fw_info fw_info_array[] = {
1873 {
1874 .chip = CHELSIO_T5,
1875 .fs_name = FW_CFG_NAME_T5,
1876 .fw_mod_name = FW_FNAME_T5,
1877 .fw_hdr = {
1878 .chip = FW_HDR_CHIP_T5,
1879 .fw_ver = __cpu_to_be32(FW_VERSION(T5)),
1880 .intfver_nic = FW_INTFVER(T5, NIC),
1881 .intfver_vnic = FW_INTFVER(T5, VNIC),
1882 .intfver_ri = FW_INTFVER(T5, RI),
1883 .intfver_iscsi = FW_INTFVER(T5, ISCSI),
1884 .intfver_fcoe = FW_INTFVER(T5, FCOE),
1885 },
1886 }
1887};
1888
1889static struct fw_info *find_fw_info(int chip)
1890{
1891 int i;
1892
1893 for (i = 0; i < ARRAY_SIZE(fw_info_array); i++) {
1894 if (fw_info_array[i].chip == chip)
1895 return &fw_info_array[i];
1896 }
1897 return NULL;
1898}
1899
1900static int csio_hw_prep_fw(struct csio_hw *hw, struct fw_info *fw_info,
1901 const u8 *fw_data, unsigned int fw_size,
1902 struct fw_hdr *card_fw, enum csio_dev_state state,
1903 int *reset)
1904{
1905 int ret, card_fw_usable, fs_fw_usable;
1906 const struct fw_hdr *fs_fw;
1907 const struct fw_hdr *drv_fw;
1908
1909 drv_fw = &fw_info->fw_hdr;
1910
1911
1912 ret = csio_hw_read_flash(hw, FLASH_FW_START,
1913 sizeof(*card_fw) / sizeof(uint32_t),
1914 (uint32_t *)card_fw, 1);
1915 if (ret == 0) {
1916 card_fw_usable = fw_compatible(drv_fw, (const void *)card_fw);
1917 } else {
1918 csio_err(hw,
1919 "Unable to read card's firmware header: %d\n", ret);
1920 card_fw_usable = 0;
1921 }
1922
1923 if (fw_data != NULL) {
1924 fs_fw = (const void *)fw_data;
1925 fs_fw_usable = fw_compatible(drv_fw, fs_fw);
1926 } else {
1927 fs_fw = NULL;
1928 fs_fw_usable = 0;
1929 }
1930
1931 if (card_fw_usable && card_fw->fw_ver == drv_fw->fw_ver &&
1932 (!fs_fw_usable || fs_fw->fw_ver == drv_fw->fw_ver)) {
1933
1934
1935
1936
1937 } else if (fs_fw_usable && state == CSIO_DEV_STATE_UNINIT &&
1938 csio_should_install_fs_fw(hw, card_fw_usable,
1939 be32_to_cpu(fs_fw->fw_ver),
1940 be32_to_cpu(card_fw->fw_ver))) {
1941 ret = csio_hw_fw_upgrade(hw, hw->pfn, fw_data,
1942 fw_size, 0);
1943 if (ret != 0) {
1944 csio_err(hw,
1945 "failed to install firmware: %d\n", ret);
1946 goto bye;
1947 }
1948
1949
1950 memcpy(card_fw, fs_fw, sizeof(*card_fw));
1951 card_fw_usable = 1;
1952 *reset = 0;
1953 }
1954
1955 if (!card_fw_usable) {
1956 uint32_t d, c, k;
1957
1958 d = be32_to_cpu(drv_fw->fw_ver);
1959 c = be32_to_cpu(card_fw->fw_ver);
1960 k = fs_fw ? be32_to_cpu(fs_fw->fw_ver) : 0;
1961
1962 csio_err(hw, "Cannot find a usable firmware: "
1963 "chip state %d, "
1964 "driver compiled with %d.%d.%d.%d, "
1965 "card has %d.%d.%d.%d, filesystem has %d.%d.%d.%d\n",
1966 state,
1967 FW_HDR_FW_VER_MAJOR_G(d), FW_HDR_FW_VER_MINOR_G(d),
1968 FW_HDR_FW_VER_MICRO_G(d), FW_HDR_FW_VER_BUILD_G(d),
1969 FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
1970 FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c),
1971 FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
1972 FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
1973 ret = EINVAL;
1974 goto bye;
1975 }
1976
1977
1978 hw->fwrev = be32_to_cpu(card_fw->fw_ver);
1979 hw->tp_vers = be32_to_cpu(card_fw->tp_microcode_ver);
1980
1981bye:
1982 return ret;
1983}
1984
1985
1986
1987
1988
1989
1990
1991static int
1992csio_hw_flash_fw(struct csio_hw *hw, int *reset)
1993{
1994 int ret = -ECANCELED;
1995 const struct firmware *fw;
1996 struct fw_info *fw_info;
1997 struct fw_hdr *card_fw;
1998 struct pci_dev *pci_dev = hw->pdev;
1999 struct device *dev = &pci_dev->dev ;
2000 const u8 *fw_data = NULL;
2001 unsigned int fw_size = 0;
2002
2003
2004
2005
2006 fw_info = find_fw_info(CHELSIO_CHIP_VERSION(hw->chip_id));
2007 if (fw_info == NULL) {
2008 csio_err(hw,
2009 "unable to get firmware info for chip %d.\n",
2010 CHELSIO_CHIP_VERSION(hw->chip_id));
2011 return -EINVAL;
2012 }
2013
2014 if (request_firmware(&fw, FW_FNAME_T5, dev) < 0) {
2015 csio_err(hw, "could not find firmware image %s, err: %d\n",
2016 FW_FNAME_T5, ret);
2017 } else {
2018 fw_data = fw->data;
2019 fw_size = fw->size;
2020 }
2021
2022
2023
2024
2025 card_fw = kmalloc(sizeof(*card_fw), GFP_KERNEL);
2026
2027
2028 ret = csio_hw_prep_fw(hw, fw_info, fw_data, fw_size, card_fw,
2029 hw->fw_state, reset);
2030
2031
2032 if (fw != NULL)
2033 release_firmware(fw);
2034 kfree(card_fw);
2035 return ret;
2036}
2037
2038
2039
2040
2041
2042
2043static void
2044csio_hw_configure(struct csio_hw *hw)
2045{
2046 int reset = 1;
2047 int rv;
2048 u32 param[1];
2049
2050 rv = csio_hw_dev_ready(hw);
2051 if (rv != 0) {
2052 CSIO_INC_STATS(hw, n_err_fatal);
2053 csio_post_event(&hw->sm, CSIO_HWE_FATAL);
2054 goto out;
2055 }
2056
2057
2058 hw->chip_ver = (char)csio_rd_reg32(hw, PL_REV_A);
2059
2060
2061 rv = csio_hw_get_flash_params(hw);
2062 if (rv != 0) {
2063 csio_err(hw, "Failed to get serial flash params rv:%d\n", rv);
2064 csio_post_event(&hw->sm, CSIO_HWE_FATAL);
2065 goto out;
2066 }
2067
2068
2069 if (pci_is_pcie(hw->pdev))
2070 pcie_capability_clear_and_set_word(hw->pdev, PCI_EXP_DEVCTL2,
2071 PCI_EXP_DEVCTL2_COMP_TIMEOUT, 0xd);
2072
2073 hw->chip_ops->chip_set_mem_win(hw, MEMWIN_CSIOSTOR);
2074
2075 rv = csio_hw_get_fw_version(hw, &hw->fwrev);
2076 if (rv != 0)
2077 goto out;
2078
2079 csio_hw_print_fw_version(hw, "Firmware revision");
2080
2081 rv = csio_do_hello(hw, &hw->fw_state);
2082 if (rv != 0) {
2083 CSIO_INC_STATS(hw, n_err_fatal);
2084 csio_post_event(&hw->sm, CSIO_HWE_FATAL);
2085 goto out;
2086 }
2087
2088
2089 rv = csio_hw_get_vpd_params(hw, &hw->vpd);
2090 if (rv != 0)
2091 goto out;
2092
2093 csio_hw_get_fw_version(hw, &hw->fwrev);
2094 csio_hw_get_tp_version(hw, &hw->tp_vers);
2095 if (csio_is_hw_master(hw) && hw->fw_state != CSIO_DEV_STATE_INIT) {
2096
2097
2098 spin_unlock_irq(&hw->lock);
2099 rv = csio_hw_flash_fw(hw, &reset);
2100 spin_lock_irq(&hw->lock);
2101
2102 if (rv != 0)
2103 goto out;
2104
2105
2106
2107
2108 rv = csio_hw_check_fwconfig(hw, param);
2109 if (rv != 0) {
2110 csio_info(hw, "Firmware doesn't support "
2111 "Firmware Configuration files\n");
2112 goto out;
2113 }
2114
2115
2116
2117
2118
2119 rv = csio_hw_use_fwconfig(hw, reset, param);
2120 if (rv == -ENOENT) {
2121 csio_info(hw, "Could not initialize "
2122 "adapter, error%d\n", rv);
2123 goto out;
2124 }
2125 if (rv != 0) {
2126 csio_info(hw, "Could not initialize "
2127 "adapter, error%d\n", rv);
2128 goto out;
2129 }
2130
2131 } else {
2132 if (hw->fw_state == CSIO_DEV_STATE_INIT) {
2133
2134 hw->flags |= CSIO_HWF_USING_SOFT_PARAMS;
2135
2136
2137 rv = csio_get_device_params(hw);
2138 if (rv != 0)
2139 goto out;
2140
2141
2142 rv = csio_config_device_caps(hw);
2143 if (rv != 0)
2144 goto out;
2145
2146
2147 csio_wr_sge_init(hw);
2148
2149
2150 csio_post_event(&hw->sm, CSIO_HWE_INIT);
2151 goto out;
2152 }
2153 }
2154
2155out:
2156 return;
2157}
2158
2159
2160
2161
2162
2163
2164static void
2165csio_hw_initialize(struct csio_hw *hw)
2166{
2167 struct csio_mb *mbp;
2168 enum fw_retval retval;
2169 int rv;
2170 int i;
2171
2172 if (csio_is_hw_master(hw) && hw->fw_state != CSIO_DEV_STATE_INIT) {
2173 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
2174 if (!mbp)
2175 goto out;
2176
2177 csio_mb_initialize(hw, mbp, CSIO_MB_DEFAULT_TMO, NULL);
2178
2179 if (csio_mb_issue(hw, mbp)) {
2180 csio_err(hw, "Issue of FW_INITIALIZE_CMD failed!\n");
2181 goto free_and_out;
2182 }
2183
2184 retval = csio_mb_fw_retval(mbp);
2185 if (retval != FW_SUCCESS) {
2186 csio_err(hw, "FW_INITIALIZE_CMD returned 0x%x!\n",
2187 retval);
2188 goto free_and_out;
2189 }
2190
2191 mempool_free(mbp, hw->mb_mempool);
2192 }
2193
2194 rv = csio_get_fcoe_resinfo(hw);
2195 if (rv != 0) {
2196 csio_err(hw, "Failed to read fcoe resource info: %d\n", rv);
2197 goto out;
2198 }
2199
2200 spin_unlock_irq(&hw->lock);
2201 rv = csio_config_queues(hw);
2202 spin_lock_irq(&hw->lock);
2203
2204 if (rv != 0) {
2205 csio_err(hw, "Config of queues failed!: %d\n", rv);
2206 goto out;
2207 }
2208
2209 for (i = 0; i < hw->num_pports; i++)
2210 hw->pport[i].mod_type = FW_PORT_MOD_TYPE_NA;
2211
2212 if (csio_is_hw_master(hw) && hw->fw_state != CSIO_DEV_STATE_INIT) {
2213 rv = csio_enable_ports(hw);
2214 if (rv != 0) {
2215 csio_err(hw, "Failed to enable ports: %d\n", rv);
2216 goto out;
2217 }
2218 }
2219
2220 csio_post_event(&hw->sm, CSIO_HWE_INIT_DONE);
2221 return;
2222
2223free_and_out:
2224 mempool_free(mbp, hw->mb_mempool);
2225out:
2226 return;
2227}
2228
2229#define PF_INTR_MASK (PFSW_F | PFCIM_F)
2230
2231
2232
2233
2234
2235
2236
2237static void
2238csio_hw_intr_enable(struct csio_hw *hw)
2239{
2240 uint16_t vec = (uint16_t)csio_get_mb_intr_idx(csio_hw_to_mbm(hw));
2241 uint32_t pf = SOURCEPF_G(csio_rd_reg32(hw, PL_WHOAMI_A));
2242 uint32_t pl = csio_rd_reg32(hw, PL_INT_ENABLE_A);
2243
2244
2245
2246
2247
2248 if (hw->intr_mode == CSIO_IM_MSIX)
2249 csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG_A),
2250 AIVEC_V(AIVEC_M), vec);
2251 else if (hw->intr_mode == CSIO_IM_MSI)
2252 csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG_A),
2253 AIVEC_V(AIVEC_M), 0);
2254
2255 csio_wr_reg32(hw, PF_INTR_MASK, MYPF_REG(PL_PF_INT_ENABLE_A));
2256
2257
2258 csio_mb_intr_enable(hw);
2259
2260
2261 if (csio_is_hw_master(hw)) {
2262
2263
2264
2265 pl &= (~SF_F);
2266 csio_wr_reg32(hw, pl, PL_INT_ENABLE_A);
2267
2268 csio_wr_reg32(hw, ERR_CPL_EXCEED_IQE_SIZE_F |
2269 EGRESS_SIZE_ERR_F | ERR_INVALID_CIDX_INC_F |
2270 ERR_CPL_OPCODE_0_F | ERR_DROPPED_DB_F |
2271 ERR_DATA_CPL_ON_HIGH_QID1_F |
2272 ERR_DATA_CPL_ON_HIGH_QID0_F | ERR_BAD_DB_PIDX3_F |
2273 ERR_BAD_DB_PIDX2_F | ERR_BAD_DB_PIDX1_F |
2274 ERR_BAD_DB_PIDX0_F | ERR_ING_CTXT_PRIO_F |
2275 ERR_EGR_CTXT_PRIO_F | INGRESS_SIZE_ERR_F,
2276 SGE_INT_ENABLE3_A);
2277 csio_set_reg_field(hw, PL_INT_MAP0_A, 0, 1 << pf);
2278 }
2279
2280 hw->flags |= CSIO_HWF_HW_INTR_ENABLED;
2281
2282}
2283
2284
2285
2286
2287
2288
2289
2290void
2291csio_hw_intr_disable(struct csio_hw *hw)
2292{
2293 uint32_t pf = SOURCEPF_G(csio_rd_reg32(hw, PL_WHOAMI_A));
2294
2295 if (!(hw->flags & CSIO_HWF_HW_INTR_ENABLED))
2296 return;
2297
2298 hw->flags &= ~CSIO_HWF_HW_INTR_ENABLED;
2299
2300 csio_wr_reg32(hw, 0, MYPF_REG(PL_PF_INT_ENABLE_A));
2301 if (csio_is_hw_master(hw))
2302 csio_set_reg_field(hw, PL_INT_MAP0_A, 1 << pf, 0);
2303
2304
2305 csio_mb_intr_disable(hw);
2306
2307}
2308
2309void
2310csio_hw_fatal_err(struct csio_hw *hw)
2311{
2312 csio_set_reg_field(hw, SGE_CONTROL_A, GLOBALENABLE_F, 0);
2313 csio_hw_intr_disable(hw);
2314
2315
2316 csio_fatal(hw, "HW Fatal error encountered!\n");
2317}
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328static void
2329csio_hws_uninit(struct csio_hw *hw, enum csio_hw_ev evt)
2330{
2331 hw->prev_evt = hw->cur_evt;
2332 hw->cur_evt = evt;
2333 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2334
2335 switch (evt) {
2336 case CSIO_HWE_CFG:
2337 csio_set_state(&hw->sm, csio_hws_configuring);
2338 csio_hw_configure(hw);
2339 break;
2340
2341 default:
2342 CSIO_INC_STATS(hw, n_evt_unexp);
2343 break;
2344 }
2345}
2346
2347
2348
2349
2350
2351
2352
2353static void
2354csio_hws_configuring(struct csio_hw *hw, enum csio_hw_ev evt)
2355{
2356 hw->prev_evt = hw->cur_evt;
2357 hw->cur_evt = evt;
2358 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2359
2360 switch (evt) {
2361 case CSIO_HWE_INIT:
2362 csio_set_state(&hw->sm, csio_hws_initializing);
2363 csio_hw_initialize(hw);
2364 break;
2365
2366 case CSIO_HWE_INIT_DONE:
2367 csio_set_state(&hw->sm, csio_hws_ready);
2368
2369 csio_notify_lnodes(hw, CSIO_LN_NOTIFY_HWREADY);
2370 break;
2371
2372 case CSIO_HWE_FATAL:
2373 csio_set_state(&hw->sm, csio_hws_uninit);
2374 break;
2375
2376 case CSIO_HWE_PCI_REMOVE:
2377 csio_do_bye(hw);
2378 break;
2379 default:
2380 CSIO_INC_STATS(hw, n_evt_unexp);
2381 break;
2382 }
2383}
2384
2385
2386
2387
2388
2389
2390
2391static void
2392csio_hws_initializing(struct csio_hw *hw, enum csio_hw_ev evt)
2393{
2394 hw->prev_evt = hw->cur_evt;
2395 hw->cur_evt = evt;
2396 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2397
2398 switch (evt) {
2399 case CSIO_HWE_INIT_DONE:
2400 csio_set_state(&hw->sm, csio_hws_ready);
2401
2402
2403 csio_notify_lnodes(hw, CSIO_LN_NOTIFY_HWREADY);
2404
2405
2406 csio_hw_intr_enable(hw);
2407 break;
2408
2409 case CSIO_HWE_FATAL:
2410 csio_set_state(&hw->sm, csio_hws_uninit);
2411 break;
2412
2413 case CSIO_HWE_PCI_REMOVE:
2414 csio_do_bye(hw);
2415 break;
2416
2417 default:
2418 CSIO_INC_STATS(hw, n_evt_unexp);
2419 break;
2420 }
2421}
2422
2423
2424
2425
2426
2427
2428
2429static void
2430csio_hws_ready(struct csio_hw *hw, enum csio_hw_ev evt)
2431{
2432
2433 hw->evtflag = evt;
2434
2435 hw->prev_evt = hw->cur_evt;
2436 hw->cur_evt = evt;
2437 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2438
2439 switch (evt) {
2440 case CSIO_HWE_HBA_RESET:
2441 case CSIO_HWE_FW_DLOAD:
2442 case CSIO_HWE_SUSPEND:
2443 case CSIO_HWE_PCI_REMOVE:
2444 case CSIO_HWE_PCIERR_DETECTED:
2445 csio_set_state(&hw->sm, csio_hws_quiescing);
2446
2447 if (evt == CSIO_HWE_HBA_RESET ||
2448 evt == CSIO_HWE_PCIERR_DETECTED)
2449 csio_scsim_cleanup_io(csio_hw_to_scsim(hw), false);
2450 else
2451 csio_scsim_cleanup_io(csio_hw_to_scsim(hw), true);
2452
2453 csio_hw_intr_disable(hw);
2454 csio_hw_mbm_cleanup(hw);
2455 csio_evtq_stop(hw);
2456 csio_notify_lnodes(hw, CSIO_LN_NOTIFY_HWSTOP);
2457 csio_evtq_flush(hw);
2458 csio_mgmtm_cleanup(csio_hw_to_mgmtm(hw));
2459 csio_post_event(&hw->sm, CSIO_HWE_QUIESCED);
2460 break;
2461
2462 case CSIO_HWE_FATAL:
2463 csio_set_state(&hw->sm, csio_hws_uninit);
2464 break;
2465
2466 default:
2467 CSIO_INC_STATS(hw, n_evt_unexp);
2468 break;
2469 }
2470}
2471
2472
2473
2474
2475
2476
2477
2478static void
2479csio_hws_quiescing(struct csio_hw *hw, enum csio_hw_ev evt)
2480{
2481 hw->prev_evt = hw->cur_evt;
2482 hw->cur_evt = evt;
2483 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2484
2485 switch (evt) {
2486 case CSIO_HWE_QUIESCED:
2487 switch (hw->evtflag) {
2488 case CSIO_HWE_FW_DLOAD:
2489 csio_set_state(&hw->sm, csio_hws_resetting);
2490
2491
2492
2493 case CSIO_HWE_HBA_RESET:
2494 csio_set_state(&hw->sm, csio_hws_resetting);
2495
2496 csio_notify_lnodes(hw, CSIO_LN_NOTIFY_HWRESET);
2497 csio_wr_destroy_queues(hw, false);
2498 csio_do_reset(hw, false);
2499 csio_post_event(&hw->sm, CSIO_HWE_HBA_RESET_DONE);
2500 break;
2501
2502 case CSIO_HWE_PCI_REMOVE:
2503 csio_set_state(&hw->sm, csio_hws_removing);
2504 csio_notify_lnodes(hw, CSIO_LN_NOTIFY_HWREMOVE);
2505 csio_wr_destroy_queues(hw, true);
2506
2507 csio_do_bye(hw);
2508 break;
2509
2510 case CSIO_HWE_SUSPEND:
2511 csio_set_state(&hw->sm, csio_hws_quiesced);
2512 break;
2513
2514 case CSIO_HWE_PCIERR_DETECTED:
2515 csio_set_state(&hw->sm, csio_hws_pcierr);
2516 csio_wr_destroy_queues(hw, false);
2517 break;
2518
2519 default:
2520 CSIO_INC_STATS(hw, n_evt_unexp);
2521 break;
2522
2523 }
2524 break;
2525
2526 default:
2527 CSIO_INC_STATS(hw, n_evt_unexp);
2528 break;
2529 }
2530}
2531
2532
2533
2534
2535
2536
2537
2538static void
2539csio_hws_quiesced(struct csio_hw *hw, enum csio_hw_ev evt)
2540{
2541 hw->prev_evt = hw->cur_evt;
2542 hw->cur_evt = evt;
2543 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2544
2545 switch (evt) {
2546 case CSIO_HWE_RESUME:
2547 csio_set_state(&hw->sm, csio_hws_configuring);
2548 csio_hw_configure(hw);
2549 break;
2550
2551 default:
2552 CSIO_INC_STATS(hw, n_evt_unexp);
2553 break;
2554 }
2555}
2556
2557
2558
2559
2560
2561
2562
2563static void
2564csio_hws_resetting(struct csio_hw *hw, enum csio_hw_ev evt)
2565{
2566 hw->prev_evt = hw->cur_evt;
2567 hw->cur_evt = evt;
2568 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2569
2570 switch (evt) {
2571 case CSIO_HWE_HBA_RESET_DONE:
2572 csio_evtq_start(hw);
2573 csio_set_state(&hw->sm, csio_hws_configuring);
2574 csio_hw_configure(hw);
2575 break;
2576
2577 default:
2578 CSIO_INC_STATS(hw, n_evt_unexp);
2579 break;
2580 }
2581}
2582
2583
2584
2585
2586
2587
2588
2589static void
2590csio_hws_removing(struct csio_hw *hw, enum csio_hw_ev evt)
2591{
2592 hw->prev_evt = hw->cur_evt;
2593 hw->cur_evt = evt;
2594 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2595
2596 switch (evt) {
2597 case CSIO_HWE_HBA_RESET:
2598 if (!csio_is_hw_master(hw))
2599 break;
2600
2601
2602
2603
2604
2605 csio_err(hw, "Resetting HW and waiting 2 seconds...\n");
2606 csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
2607 mdelay(2000);
2608 break;
2609
2610
2611 default:
2612 CSIO_INC_STATS(hw, n_evt_unexp);
2613 break;
2614
2615 }
2616}
2617
2618
2619
2620
2621
2622
2623
2624static void
2625csio_hws_pcierr(struct csio_hw *hw, enum csio_hw_ev evt)
2626{
2627 hw->prev_evt = hw->cur_evt;
2628 hw->cur_evt = evt;
2629 CSIO_INC_STATS(hw, n_evt_sm[evt]);
2630
2631 switch (evt) {
2632 case CSIO_HWE_PCIERR_SLOT_RESET:
2633 csio_evtq_start(hw);
2634 csio_set_state(&hw->sm, csio_hws_configuring);
2635 csio_hw_configure(hw);
2636 break;
2637
2638 default:
2639 CSIO_INC_STATS(hw, n_evt_unexp);
2640 break;
2641 }
2642}
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661int
2662csio_handle_intr_status(struct csio_hw *hw, unsigned int reg,
2663 const struct intr_info *acts)
2664{
2665 int fatal = 0;
2666 unsigned int mask = 0;
2667 unsigned int status = csio_rd_reg32(hw, reg);
2668
2669 for ( ; acts->mask; ++acts) {
2670 if (!(status & acts->mask))
2671 continue;
2672 if (acts->fatal) {
2673 fatal++;
2674 csio_fatal(hw, "Fatal %s (0x%x)\n",
2675 acts->msg, status & acts->mask);
2676 } else if (acts->msg)
2677 csio_info(hw, "%s (0x%x)\n",
2678 acts->msg, status & acts->mask);
2679 mask |= acts->mask;
2680 }
2681 status &= mask;
2682 if (status)
2683 csio_wr_reg32(hw, status, reg);
2684 return fatal;
2685}
2686
2687
2688
2689
2690static void csio_tp_intr_handler(struct csio_hw *hw)
2691{
2692 static struct intr_info tp_intr_info[] = {
2693 { 0x3fffffff, "TP parity error", -1, 1 },
2694 { FLMTXFLSTEMPTY_F, "TP out of Tx pages", -1, 1 },
2695 { 0, NULL, 0, 0 }
2696 };
2697
2698 if (csio_handle_intr_status(hw, TP_INT_CAUSE_A, tp_intr_info))
2699 csio_hw_fatal_err(hw);
2700}
2701
2702
2703
2704
2705static void csio_sge_intr_handler(struct csio_hw *hw)
2706{
2707 uint64_t v;
2708
2709 static struct intr_info sge_intr_info[] = {
2710 { ERR_CPL_EXCEED_IQE_SIZE_F,
2711 "SGE received CPL exceeding IQE size", -1, 1 },
2712 { ERR_INVALID_CIDX_INC_F,
2713 "SGE GTS CIDX increment too large", -1, 0 },
2714 { ERR_CPL_OPCODE_0_F, "SGE received 0-length CPL", -1, 0 },
2715 { ERR_DROPPED_DB_F, "SGE doorbell dropped", -1, 0 },
2716 { ERR_DATA_CPL_ON_HIGH_QID1_F | ERR_DATA_CPL_ON_HIGH_QID0_F,
2717 "SGE IQID > 1023 received CPL for FL", -1, 0 },
2718 { ERR_BAD_DB_PIDX3_F, "SGE DBP 3 pidx increment too large", -1,
2719 0 },
2720 { ERR_BAD_DB_PIDX2_F, "SGE DBP 2 pidx increment too large", -1,
2721 0 },
2722 { ERR_BAD_DB_PIDX1_F, "SGE DBP 1 pidx increment too large", -1,
2723 0 },
2724 { ERR_BAD_DB_PIDX0_F, "SGE DBP 0 pidx increment too large", -1,
2725 0 },
2726 { ERR_ING_CTXT_PRIO_F,
2727 "SGE too many priority ingress contexts", -1, 0 },
2728 { ERR_EGR_CTXT_PRIO_F,
2729 "SGE too many priority egress contexts", -1, 0 },
2730 { INGRESS_SIZE_ERR_F, "SGE illegal ingress QID", -1, 0 },
2731 { EGRESS_SIZE_ERR_F, "SGE illegal egress QID", -1, 0 },
2732 { 0, NULL, 0, 0 }
2733 };
2734
2735 v = (uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE1_A) |
2736 ((uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE2_A) << 32);
2737 if (v) {
2738 csio_fatal(hw, "SGE parity error (%#llx)\n",
2739 (unsigned long long)v);
2740 csio_wr_reg32(hw, (uint32_t)(v & 0xFFFFFFFF),
2741 SGE_INT_CAUSE1_A);
2742 csio_wr_reg32(hw, (uint32_t)(v >> 32), SGE_INT_CAUSE2_A);
2743 }
2744
2745 v |= csio_handle_intr_status(hw, SGE_INT_CAUSE3_A, sge_intr_info);
2746
2747 if (csio_handle_intr_status(hw, SGE_INT_CAUSE3_A, sge_intr_info) ||
2748 v != 0)
2749 csio_hw_fatal_err(hw);
2750}
2751
2752#define CIM_OBQ_INTR (OBQULP0PARERR_F | OBQULP1PARERR_F | OBQULP2PARERR_F |\
2753 OBQULP3PARERR_F | OBQSGEPARERR_F | OBQNCSIPARERR_F)
2754#define CIM_IBQ_INTR (IBQTP0PARERR_F | IBQTP1PARERR_F | IBQULPPARERR_F |\
2755 IBQSGEHIPARERR_F | IBQSGELOPARERR_F | IBQNCSIPARERR_F)
2756
2757
2758
2759
2760static void csio_cim_intr_handler(struct csio_hw *hw)
2761{
2762 static struct intr_info cim_intr_info[] = {
2763 { PREFDROPINT_F, "CIM control register prefetch drop", -1, 1 },
2764 { CIM_OBQ_INTR, "CIM OBQ parity error", -1, 1 },
2765 { CIM_IBQ_INTR, "CIM IBQ parity error", -1, 1 },
2766 { MBUPPARERR_F, "CIM mailbox uP parity error", -1, 1 },
2767 { MBHOSTPARERR_F, "CIM mailbox host parity error", -1, 1 },
2768 { TIEQINPARERRINT_F, "CIM TIEQ outgoing parity error", -1, 1 },
2769 { TIEQOUTPARERRINT_F, "CIM TIEQ incoming parity error", -1, 1 },
2770 { 0, NULL, 0, 0 }
2771 };
2772 static struct intr_info cim_upintr_info[] = {
2773 { RSVDSPACEINT_F, "CIM reserved space access", -1, 1 },
2774 { ILLTRANSINT_F, "CIM illegal transaction", -1, 1 },
2775 { ILLWRINT_F, "CIM illegal write", -1, 1 },
2776 { ILLRDINT_F, "CIM illegal read", -1, 1 },
2777 { ILLRDBEINT_F, "CIM illegal read BE", -1, 1 },
2778 { ILLWRBEINT_F, "CIM illegal write BE", -1, 1 },
2779 { SGLRDBOOTINT_F, "CIM single read from boot space", -1, 1 },
2780 { SGLWRBOOTINT_F, "CIM single write to boot space", -1, 1 },
2781 { BLKWRBOOTINT_F, "CIM block write to boot space", -1, 1 },
2782 { SGLRDFLASHINT_F, "CIM single read from flash space", -1, 1 },
2783 { SGLWRFLASHINT_F, "CIM single write to flash space", -1, 1 },
2784 { BLKWRFLASHINT_F, "CIM block write to flash space", -1, 1 },
2785 { SGLRDEEPROMINT_F, "CIM single EEPROM read", -1, 1 },
2786 { SGLWREEPROMINT_F, "CIM single EEPROM write", -1, 1 },
2787 { BLKRDEEPROMINT_F, "CIM block EEPROM read", -1, 1 },
2788 { BLKWREEPROMINT_F, "CIM block EEPROM write", -1, 1 },
2789 { SGLRDCTLINT_F, "CIM single read from CTL space", -1, 1 },
2790 { SGLWRCTLINT_F, "CIM single write to CTL space", -1, 1 },
2791 { BLKRDCTLINT_F, "CIM block read from CTL space", -1, 1 },
2792 { BLKWRCTLINT_F, "CIM block write to CTL space", -1, 1 },
2793 { SGLRDPLINT_F, "CIM single read from PL space", -1, 1 },
2794 { SGLWRPLINT_F, "CIM single write to PL space", -1, 1 },
2795 { BLKRDPLINT_F, "CIM block read from PL space", -1, 1 },
2796 { BLKWRPLINT_F, "CIM block write to PL space", -1, 1 },
2797 { REQOVRLOOKUPINT_F, "CIM request FIFO overwrite", -1, 1 },
2798 { RSPOVRLOOKUPINT_F, "CIM response FIFO overwrite", -1, 1 },
2799 { TIMEOUTINT_F, "CIM PIF timeout", -1, 1 },
2800 { TIMEOUTMAINT_F, "CIM PIF MA timeout", -1, 1 },
2801 { 0, NULL, 0, 0 }
2802 };
2803
2804 int fat;
2805
2806 fat = csio_handle_intr_status(hw, CIM_HOST_INT_CAUSE_A,
2807 cim_intr_info) +
2808 csio_handle_intr_status(hw, CIM_HOST_UPACC_INT_CAUSE_A,
2809 cim_upintr_info);
2810 if (fat)
2811 csio_hw_fatal_err(hw);
2812}
2813
2814
2815
2816
2817static void csio_ulprx_intr_handler(struct csio_hw *hw)
2818{
2819 static struct intr_info ulprx_intr_info[] = {
2820 { 0x1800000, "ULPRX context error", -1, 1 },
2821 { 0x7fffff, "ULPRX parity error", -1, 1 },
2822 { 0, NULL, 0, 0 }
2823 };
2824
2825 if (csio_handle_intr_status(hw, ULP_RX_INT_CAUSE_A, ulprx_intr_info))
2826 csio_hw_fatal_err(hw);
2827}
2828
2829
2830
2831
2832static void csio_ulptx_intr_handler(struct csio_hw *hw)
2833{
2834 static struct intr_info ulptx_intr_info[] = {
2835 { PBL_BOUND_ERR_CH3_F, "ULPTX channel 3 PBL out of bounds", -1,
2836 0 },
2837 { PBL_BOUND_ERR_CH2_F, "ULPTX channel 2 PBL out of bounds", -1,
2838 0 },
2839 { PBL_BOUND_ERR_CH1_F, "ULPTX channel 1 PBL out of bounds", -1,
2840 0 },
2841 { PBL_BOUND_ERR_CH0_F, "ULPTX channel 0 PBL out of bounds", -1,
2842 0 },
2843 { 0xfffffff, "ULPTX parity error", -1, 1 },
2844 { 0, NULL, 0, 0 }
2845 };
2846
2847 if (csio_handle_intr_status(hw, ULP_TX_INT_CAUSE_A, ulptx_intr_info))
2848 csio_hw_fatal_err(hw);
2849}
2850
2851
2852
2853
2854static void csio_pmtx_intr_handler(struct csio_hw *hw)
2855{
2856 static struct intr_info pmtx_intr_info[] = {
2857 { PCMD_LEN_OVFL0_F, "PMTX channel 0 pcmd too large", -1, 1 },
2858 { PCMD_LEN_OVFL1_F, "PMTX channel 1 pcmd too large", -1, 1 },
2859 { PCMD_LEN_OVFL2_F, "PMTX channel 2 pcmd too large", -1, 1 },
2860 { ZERO_C_CMD_ERROR_F, "PMTX 0-length pcmd", -1, 1 },
2861 { 0xffffff0, "PMTX framing error", -1, 1 },
2862 { OESPI_PAR_ERROR_F, "PMTX oespi parity error", -1, 1 },
2863 { DB_OPTIONS_PAR_ERROR_F, "PMTX db_options parity error", -1,
2864 1 },
2865 { ICSPI_PAR_ERROR_F, "PMTX icspi parity error", -1, 1 },
2866 { PMTX_C_PCMD_PAR_ERROR_F, "PMTX c_pcmd parity error", -1, 1},
2867 { 0, NULL, 0, 0 }
2868 };
2869
2870 if (csio_handle_intr_status(hw, PM_TX_INT_CAUSE_A, pmtx_intr_info))
2871 csio_hw_fatal_err(hw);
2872}
2873
2874
2875
2876
2877static void csio_pmrx_intr_handler(struct csio_hw *hw)
2878{
2879 static struct intr_info pmrx_intr_info[] = {
2880 { ZERO_E_CMD_ERROR_F, "PMRX 0-length pcmd", -1, 1 },
2881 { 0x3ffff0, "PMRX framing error", -1, 1 },
2882 { OCSPI_PAR_ERROR_F, "PMRX ocspi parity error", -1, 1 },
2883 { DB_OPTIONS_PAR_ERROR_F, "PMRX db_options parity error", -1,
2884 1 },
2885 { IESPI_PAR_ERROR_F, "PMRX iespi parity error", -1, 1 },
2886 { PMRX_E_PCMD_PAR_ERROR_F, "PMRX e_pcmd parity error", -1, 1},
2887 { 0, NULL, 0, 0 }
2888 };
2889
2890 if (csio_handle_intr_status(hw, PM_RX_INT_CAUSE_A, pmrx_intr_info))
2891 csio_hw_fatal_err(hw);
2892}
2893
2894
2895
2896
2897static void csio_cplsw_intr_handler(struct csio_hw *hw)
2898{
2899 static struct intr_info cplsw_intr_info[] = {
2900 { CIM_OP_MAP_PERR_F, "CPLSW CIM op_map parity error", -1, 1 },
2901 { CIM_OVFL_ERROR_F, "CPLSW CIM overflow", -1, 1 },
2902 { TP_FRAMING_ERROR_F, "CPLSW TP framing error", -1, 1 },
2903 { SGE_FRAMING_ERROR_F, "CPLSW SGE framing error", -1, 1 },
2904 { CIM_FRAMING_ERROR_F, "CPLSW CIM framing error", -1, 1 },
2905 { ZERO_SWITCH_ERROR_F, "CPLSW no-switch error", -1, 1 },
2906 { 0, NULL, 0, 0 }
2907 };
2908
2909 if (csio_handle_intr_status(hw, CPL_INTR_CAUSE_A, cplsw_intr_info))
2910 csio_hw_fatal_err(hw);
2911}
2912
2913
2914
2915
2916static void csio_le_intr_handler(struct csio_hw *hw)
2917{
2918 static struct intr_info le_intr_info[] = {
2919 { LIPMISS_F, "LE LIP miss", -1, 0 },
2920 { LIP0_F, "LE 0 LIP error", -1, 0 },
2921 { PARITYERR_F, "LE parity error", -1, 1 },
2922 { UNKNOWNCMD_F, "LE unknown command", -1, 1 },
2923 { REQQPARERR_F, "LE request queue parity error", -1, 1 },
2924 { 0, NULL, 0, 0 }
2925 };
2926
2927 if (csio_handle_intr_status(hw, LE_DB_INT_CAUSE_A, le_intr_info))
2928 csio_hw_fatal_err(hw);
2929}
2930
2931
2932
2933
2934static void csio_mps_intr_handler(struct csio_hw *hw)
2935{
2936 static struct intr_info mps_rx_intr_info[] = {
2937 { 0xffffff, "MPS Rx parity error", -1, 1 },
2938 { 0, NULL, 0, 0 }
2939 };
2940 static struct intr_info mps_tx_intr_info[] = {
2941 { TPFIFO_V(TPFIFO_M), "MPS Tx TP FIFO parity error", -1, 1 },
2942 { NCSIFIFO_F, "MPS Tx NC-SI FIFO parity error", -1, 1 },
2943 { TXDATAFIFO_V(TXDATAFIFO_M), "MPS Tx data FIFO parity error",
2944 -1, 1 },
2945 { TXDESCFIFO_V(TXDESCFIFO_M), "MPS Tx desc FIFO parity error",
2946 -1, 1 },
2947 { BUBBLE_F, "MPS Tx underflow", -1, 1 },
2948 { SECNTERR_F, "MPS Tx SOP/EOP error", -1, 1 },
2949 { FRMERR_F, "MPS Tx framing error", -1, 1 },
2950 { 0, NULL, 0, 0 }
2951 };
2952 static struct intr_info mps_trc_intr_info[] = {
2953 { FILTMEM_V(FILTMEM_M), "MPS TRC filter parity error", -1, 1 },
2954 { PKTFIFO_V(PKTFIFO_M), "MPS TRC packet FIFO parity error",
2955 -1, 1 },
2956 { MISCPERR_F, "MPS TRC misc parity error", -1, 1 },
2957 { 0, NULL, 0, 0 }
2958 };
2959 static struct intr_info mps_stat_sram_intr_info[] = {
2960 { 0x1fffff, "MPS statistics SRAM parity error", -1, 1 },
2961 { 0, NULL, 0, 0 }
2962 };
2963 static struct intr_info mps_stat_tx_intr_info[] = {
2964 { 0xfffff, "MPS statistics Tx FIFO parity error", -1, 1 },
2965 { 0, NULL, 0, 0 }
2966 };
2967 static struct intr_info mps_stat_rx_intr_info[] = {
2968 { 0xffffff, "MPS statistics Rx FIFO parity error", -1, 1 },
2969 { 0, NULL, 0, 0 }
2970 };
2971 static struct intr_info mps_cls_intr_info[] = {
2972 { MATCHSRAM_F, "MPS match SRAM parity error", -1, 1 },
2973 { MATCHTCAM_F, "MPS match TCAM parity error", -1, 1 },
2974 { HASHSRAM_F, "MPS hash SRAM parity error", -1, 1 },
2975 { 0, NULL, 0, 0 }
2976 };
2977
2978 int fat;
2979
2980 fat = csio_handle_intr_status(hw, MPS_RX_PERR_INT_CAUSE_A,
2981 mps_rx_intr_info) +
2982 csio_handle_intr_status(hw, MPS_TX_INT_CAUSE_A,
2983 mps_tx_intr_info) +
2984 csio_handle_intr_status(hw, MPS_TRC_INT_CAUSE_A,
2985 mps_trc_intr_info) +
2986 csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_SRAM_A,
2987 mps_stat_sram_intr_info) +
2988 csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_TX_FIFO_A,
2989 mps_stat_tx_intr_info) +
2990 csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_RX_FIFO_A,
2991 mps_stat_rx_intr_info) +
2992 csio_handle_intr_status(hw, MPS_CLS_INT_CAUSE_A,
2993 mps_cls_intr_info);
2994
2995 csio_wr_reg32(hw, 0, MPS_INT_CAUSE_A);
2996 csio_rd_reg32(hw, MPS_INT_CAUSE_A);
2997 if (fat)
2998 csio_hw_fatal_err(hw);
2999}
3000
3001#define MEM_INT_MASK (PERR_INT_CAUSE_F | ECC_CE_INT_CAUSE_F | \
3002 ECC_UE_INT_CAUSE_F)
3003
3004
3005
3006
3007static void csio_mem_intr_handler(struct csio_hw *hw, int idx)
3008{
3009 static const char name[3][5] = { "EDC0", "EDC1", "MC" };
3010
3011 unsigned int addr, cnt_addr, v;
3012
3013 if (idx <= MEM_EDC1) {
3014 addr = EDC_REG(EDC_INT_CAUSE_A, idx);
3015 cnt_addr = EDC_REG(EDC_ECC_STATUS_A, idx);
3016 } else {
3017 addr = MC_INT_CAUSE_A;
3018 cnt_addr = MC_ECC_STATUS_A;
3019 }
3020
3021 v = csio_rd_reg32(hw, addr) & MEM_INT_MASK;
3022 if (v & PERR_INT_CAUSE_F)
3023 csio_fatal(hw, "%s FIFO parity error\n", name[idx]);
3024 if (v & ECC_CE_INT_CAUSE_F) {
3025 uint32_t cnt = ECC_CECNT_G(csio_rd_reg32(hw, cnt_addr));
3026
3027 csio_wr_reg32(hw, ECC_CECNT_V(ECC_CECNT_M), cnt_addr);
3028 csio_warn(hw, "%u %s correctable ECC data error%s\n",
3029 cnt, name[idx], cnt > 1 ? "s" : "");
3030 }
3031 if (v & ECC_UE_INT_CAUSE_F)
3032 csio_fatal(hw, "%s uncorrectable ECC data error\n", name[idx]);
3033
3034 csio_wr_reg32(hw, v, addr);
3035 if (v & (PERR_INT_CAUSE_F | ECC_UE_INT_CAUSE_F))
3036 csio_hw_fatal_err(hw);
3037}
3038
3039
3040
3041
3042static void csio_ma_intr_handler(struct csio_hw *hw)
3043{
3044 uint32_t v, status = csio_rd_reg32(hw, MA_INT_CAUSE_A);
3045
3046 if (status & MEM_PERR_INT_CAUSE_F)
3047 csio_fatal(hw, "MA parity error, parity status %#x\n",
3048 csio_rd_reg32(hw, MA_PARITY_ERROR_STATUS_A));
3049 if (status & MEM_WRAP_INT_CAUSE_F) {
3050 v = csio_rd_reg32(hw, MA_INT_WRAP_STATUS_A);
3051 csio_fatal(hw,
3052 "MA address wrap-around error by client %u to address %#x\n",
3053 MEM_WRAP_CLIENT_NUM_G(v), MEM_WRAP_ADDRESS_G(v) << 4);
3054 }
3055 csio_wr_reg32(hw, status, MA_INT_CAUSE_A);
3056 csio_hw_fatal_err(hw);
3057}
3058
3059
3060
3061
3062static void csio_smb_intr_handler(struct csio_hw *hw)
3063{
3064 static struct intr_info smb_intr_info[] = {
3065 { MSTTXFIFOPARINT_F, "SMB master Tx FIFO parity error", -1, 1 },
3066 { MSTRXFIFOPARINT_F, "SMB master Rx FIFO parity error", -1, 1 },
3067 { SLVFIFOPARINT_F, "SMB slave FIFO parity error", -1, 1 },
3068 { 0, NULL, 0, 0 }
3069 };
3070
3071 if (csio_handle_intr_status(hw, SMB_INT_CAUSE_A, smb_intr_info))
3072 csio_hw_fatal_err(hw);
3073}
3074
3075
3076
3077
3078static void csio_ncsi_intr_handler(struct csio_hw *hw)
3079{
3080 static struct intr_info ncsi_intr_info[] = {
3081 { CIM_DM_PRTY_ERR_F, "NC-SI CIM parity error", -1, 1 },
3082 { MPS_DM_PRTY_ERR_F, "NC-SI MPS parity error", -1, 1 },
3083 { TXFIFO_PRTY_ERR_F, "NC-SI Tx FIFO parity error", -1, 1 },
3084 { RXFIFO_PRTY_ERR_F, "NC-SI Rx FIFO parity error", -1, 1 },
3085 { 0, NULL, 0, 0 }
3086 };
3087
3088 if (csio_handle_intr_status(hw, NCSI_INT_CAUSE_A, ncsi_intr_info))
3089 csio_hw_fatal_err(hw);
3090}
3091
3092
3093
3094
3095static void csio_xgmac_intr_handler(struct csio_hw *hw, int port)
3096{
3097 uint32_t v = csio_rd_reg32(hw, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));
3098
3099 v &= TXFIFO_PRTY_ERR_F | RXFIFO_PRTY_ERR_F;
3100 if (!v)
3101 return;
3102
3103 if (v & TXFIFO_PRTY_ERR_F)
3104 csio_fatal(hw, "XGMAC %d Tx FIFO parity error\n", port);
3105 if (v & RXFIFO_PRTY_ERR_F)
3106 csio_fatal(hw, "XGMAC %d Rx FIFO parity error\n", port);
3107 csio_wr_reg32(hw, v, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));
3108 csio_hw_fatal_err(hw);
3109}
3110
3111
3112
3113
3114static void csio_pl_intr_handler(struct csio_hw *hw)
3115{
3116 static struct intr_info pl_intr_info[] = {
3117 { FATALPERR_F, "T4 fatal parity error", -1, 1 },
3118 { PERRVFID_F, "PL VFID_MAP parity error", -1, 1 },
3119 { 0, NULL, 0, 0 }
3120 };
3121
3122 if (csio_handle_intr_status(hw, PL_PL_INT_CAUSE_A, pl_intr_info))
3123 csio_hw_fatal_err(hw);
3124}
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134int
3135csio_hw_slow_intr_handler(struct csio_hw *hw)
3136{
3137 uint32_t cause = csio_rd_reg32(hw, PL_INT_CAUSE_A);
3138
3139 if (!(cause & CSIO_GLBL_INTR_MASK)) {
3140 CSIO_INC_STATS(hw, n_plint_unexp);
3141 return 0;
3142 }
3143
3144 csio_dbg(hw, "Slow interrupt! cause: 0x%x\n", cause);
3145
3146 CSIO_INC_STATS(hw, n_plint_cnt);
3147
3148 if (cause & CIM_F)
3149 csio_cim_intr_handler(hw);
3150
3151 if (cause & MPS_F)
3152 csio_mps_intr_handler(hw);
3153
3154 if (cause & NCSI_F)
3155 csio_ncsi_intr_handler(hw);
3156
3157 if (cause & PL_F)
3158 csio_pl_intr_handler(hw);
3159
3160 if (cause & SMB_F)
3161 csio_smb_intr_handler(hw);
3162
3163 if (cause & XGMAC0_F)
3164 csio_xgmac_intr_handler(hw, 0);
3165
3166 if (cause & XGMAC1_F)
3167 csio_xgmac_intr_handler(hw, 1);
3168
3169 if (cause & XGMAC_KR0_F)
3170 csio_xgmac_intr_handler(hw, 2);
3171
3172 if (cause & XGMAC_KR1_F)
3173 csio_xgmac_intr_handler(hw, 3);
3174
3175 if (cause & PCIE_F)
3176 hw->chip_ops->chip_pcie_intr_handler(hw);
3177
3178 if (cause & MC_F)
3179 csio_mem_intr_handler(hw, MEM_MC);
3180
3181 if (cause & EDC0_F)
3182 csio_mem_intr_handler(hw, MEM_EDC0);
3183
3184 if (cause & EDC1_F)
3185 csio_mem_intr_handler(hw, MEM_EDC1);
3186
3187 if (cause & LE_F)
3188 csio_le_intr_handler(hw);
3189
3190 if (cause & TP_F)
3191 csio_tp_intr_handler(hw);
3192
3193 if (cause & MA_F)
3194 csio_ma_intr_handler(hw);
3195
3196 if (cause & PM_TX_F)
3197 csio_pmtx_intr_handler(hw);
3198
3199 if (cause & PM_RX_F)
3200 csio_pmrx_intr_handler(hw);
3201
3202 if (cause & ULP_RX_F)
3203 csio_ulprx_intr_handler(hw);
3204
3205 if (cause & CPL_SWITCH_F)
3206 csio_cplsw_intr_handler(hw);
3207
3208 if (cause & SGE_F)
3209 csio_sge_intr_handler(hw);
3210
3211 if (cause & ULP_TX_F)
3212 csio_ulptx_intr_handler(hw);
3213
3214
3215 csio_wr_reg32(hw, cause & CSIO_GLBL_INTR_MASK, PL_INT_CAUSE_A);
3216 csio_rd_reg32(hw, PL_INT_CAUSE_A);
3217
3218 return 1;
3219}
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231static void
3232csio_mberr_worker(void *data)
3233{
3234 struct csio_hw *hw = (struct csio_hw *)data;
3235 struct csio_mbm *mbm = &hw->mbm;
3236 LIST_HEAD(cbfn_q);
3237 struct csio_mb *mbp_next;
3238 int rv;
3239
3240 del_timer_sync(&mbm->timer);
3241
3242 spin_lock_irq(&hw->lock);
3243 if (list_empty(&mbm->cbfn_q)) {
3244 spin_unlock_irq(&hw->lock);
3245 return;
3246 }
3247
3248 list_splice_tail_init(&mbm->cbfn_q, &cbfn_q);
3249 mbm->stats.n_cbfnq = 0;
3250
3251
3252 if (!list_empty(&mbm->req_q)) {
3253 mbp_next = list_first_entry(&mbm->req_q, struct csio_mb, list);
3254 list_del_init(&mbp_next->list);
3255
3256 rv = csio_mb_issue(hw, mbp_next);
3257 if (rv != 0)
3258 list_add_tail(&mbp_next->list, &mbm->req_q);
3259 else
3260 CSIO_DEC_STATS(mbm, n_activeq);
3261 }
3262 spin_unlock_irq(&hw->lock);
3263
3264
3265 csio_mb_completions(hw, &cbfn_q);
3266}
3267
3268
3269
3270
3271
3272
3273
3274static void
3275csio_hw_mb_timer(uintptr_t data)
3276{
3277 struct csio_hw *hw = (struct csio_hw *)data;
3278 struct csio_mb *mbp = NULL;
3279
3280 spin_lock_irq(&hw->lock);
3281 mbp = csio_mb_tmo_handler(hw);
3282 spin_unlock_irq(&hw->lock);
3283
3284
3285 if (mbp)
3286 mbp->mb_cbfn(hw, mbp);
3287
3288}
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299static void
3300csio_hw_mbm_cleanup(struct csio_hw *hw)
3301{
3302 LIST_HEAD(cbfn_q);
3303
3304 csio_mb_cancel_all(hw, &cbfn_q);
3305
3306 spin_unlock_irq(&hw->lock);
3307 csio_mb_completions(hw, &cbfn_q);
3308 spin_lock_irq(&hw->lock);
3309}
3310
3311
3312
3313
3314int
3315csio_enqueue_evt(struct csio_hw *hw, enum csio_evt type, void *evt_msg,
3316 uint16_t len)
3317{
3318 struct csio_evt_msg *evt_entry = NULL;
3319
3320 if (type >= CSIO_EVT_MAX)
3321 return -EINVAL;
3322
3323 if (len > CSIO_EVT_MSG_SIZE)
3324 return -EINVAL;
3325
3326 if (hw->flags & CSIO_HWF_FWEVT_STOP)
3327 return -EINVAL;
3328
3329 if (list_empty(&hw->evt_free_q)) {
3330 csio_err(hw, "Failed to alloc evt entry, msg type %d len %d\n",
3331 type, len);
3332 return -ENOMEM;
3333 }
3334
3335 evt_entry = list_first_entry(&hw->evt_free_q,
3336 struct csio_evt_msg, list);
3337 list_del_init(&evt_entry->list);
3338
3339
3340 evt_entry->type = type;
3341 memcpy((void *)evt_entry->data, evt_msg, len);
3342 list_add_tail(&evt_entry->list, &hw->evt_active_q);
3343
3344 CSIO_DEC_STATS(hw, n_evt_freeq);
3345 CSIO_INC_STATS(hw, n_evt_activeq);
3346
3347 return 0;
3348}
3349
3350static int
3351csio_enqueue_evt_lock(struct csio_hw *hw, enum csio_evt type, void *evt_msg,
3352 uint16_t len, bool msg_sg)
3353{
3354 struct csio_evt_msg *evt_entry = NULL;
3355 struct csio_fl_dma_buf *fl_sg;
3356 uint32_t off = 0;
3357 unsigned long flags;
3358 int n, ret = 0;
3359
3360 if (type >= CSIO_EVT_MAX)
3361 return -EINVAL;
3362
3363 if (len > CSIO_EVT_MSG_SIZE)
3364 return -EINVAL;
3365
3366 spin_lock_irqsave(&hw->lock, flags);
3367 if (hw->flags & CSIO_HWF_FWEVT_STOP) {
3368 ret = -EINVAL;
3369 goto out;
3370 }
3371
3372 if (list_empty(&hw->evt_free_q)) {
3373 csio_err(hw, "Failed to alloc evt entry, msg type %d len %d\n",
3374 type, len);
3375 ret = -ENOMEM;
3376 goto out;
3377 }
3378
3379 evt_entry = list_first_entry(&hw->evt_free_q,
3380 struct csio_evt_msg, list);
3381 list_del_init(&evt_entry->list);
3382
3383
3384 evt_entry->type = type;
3385
3386
3387 if (msg_sg) {
3388 fl_sg = (struct csio_fl_dma_buf *) evt_msg;
3389 for (n = 0; (n < CSIO_MAX_FLBUF_PER_IQWR && off < len); n++) {
3390 memcpy((void *)((uintptr_t)evt_entry->data + off),
3391 fl_sg->flbufs[n].vaddr,
3392 fl_sg->flbufs[n].len);
3393 off += fl_sg->flbufs[n].len;
3394 }
3395 } else
3396 memcpy((void *)evt_entry->data, evt_msg, len);
3397
3398 list_add_tail(&evt_entry->list, &hw->evt_active_q);
3399 CSIO_DEC_STATS(hw, n_evt_freeq);
3400 CSIO_INC_STATS(hw, n_evt_activeq);
3401out:
3402 spin_unlock_irqrestore(&hw->lock, flags);
3403 return ret;
3404}
3405
3406static void
3407csio_free_evt(struct csio_hw *hw, struct csio_evt_msg *evt_entry)
3408{
3409 if (evt_entry) {
3410 spin_lock_irq(&hw->lock);
3411 list_del_init(&evt_entry->list);
3412 list_add_tail(&evt_entry->list, &hw->evt_free_q);
3413 CSIO_DEC_STATS(hw, n_evt_activeq);
3414 CSIO_INC_STATS(hw, n_evt_freeq);
3415 spin_unlock_irq(&hw->lock);
3416 }
3417}
3418
3419void
3420csio_evtq_flush(struct csio_hw *hw)
3421{
3422 uint32_t count;
3423 count = 30;
3424 while (hw->flags & CSIO_HWF_FWEVT_PENDING && count--) {
3425 spin_unlock_irq(&hw->lock);
3426 msleep(2000);
3427 spin_lock_irq(&hw->lock);
3428 }
3429
3430 CSIO_DB_ASSERT(!(hw->flags & CSIO_HWF_FWEVT_PENDING));
3431}
3432
3433static void
3434csio_evtq_stop(struct csio_hw *hw)
3435{
3436 hw->flags |= CSIO_HWF_FWEVT_STOP;
3437}
3438
3439static void
3440csio_evtq_start(struct csio_hw *hw)
3441{
3442 hw->flags &= ~CSIO_HWF_FWEVT_STOP;
3443}
3444
3445static void
3446csio_evtq_cleanup(struct csio_hw *hw)
3447{
3448 struct list_head *evt_entry, *next_entry;
3449
3450
3451 if (!list_empty(&hw->evt_active_q))
3452 list_splice_tail_init(&hw->evt_active_q, &hw->evt_free_q);
3453
3454 hw->stats.n_evt_activeq = 0;
3455 hw->flags &= ~CSIO_HWF_FWEVT_PENDING;
3456
3457
3458 list_for_each_safe(evt_entry, next_entry, &hw->evt_free_q) {
3459 kfree(evt_entry);
3460 CSIO_DEC_STATS(hw, n_evt_freeq);
3461 }
3462
3463 hw->stats.n_evt_freeq = 0;
3464}
3465
3466
3467static void
3468csio_process_fwevtq_entry(struct csio_hw *hw, void *wr, uint32_t len,
3469 struct csio_fl_dma_buf *flb, void *priv)
3470{
3471 __u8 op;
3472 void *msg = NULL;
3473 uint32_t msg_len = 0;
3474 bool msg_sg = 0;
3475
3476 op = ((struct rss_header *) wr)->opcode;
3477 if (op == CPL_FW6_PLD) {
3478 CSIO_INC_STATS(hw, n_cpl_fw6_pld);
3479 if (!flb || !flb->totlen) {
3480 CSIO_INC_STATS(hw, n_cpl_unexp);
3481 return;
3482 }
3483
3484 msg = (void *) flb;
3485 msg_len = flb->totlen;
3486 msg_sg = 1;
3487 } else if (op == CPL_FW6_MSG || op == CPL_FW4_MSG) {
3488
3489 CSIO_INC_STATS(hw, n_cpl_fw6_msg);
3490
3491 msg = (void *)((uintptr_t)wr + sizeof(__be64));
3492 msg_len = (op == CPL_FW6_MSG) ? sizeof(struct cpl_fw6_msg) :
3493 sizeof(struct cpl_fw4_msg);
3494 } else {
3495 csio_warn(hw, "unexpected CPL %#x on FW event queue\n", op);
3496 CSIO_INC_STATS(hw, n_cpl_unexp);
3497 return;
3498 }
3499
3500
3501
3502
3503
3504 if (csio_enqueue_evt_lock(hw, CSIO_EVT_FW, msg,
3505 (uint16_t)msg_len, msg_sg))
3506 CSIO_INC_STATS(hw, n_evt_drop);
3507}
3508
3509void
3510csio_evtq_worker(struct work_struct *work)
3511{
3512 struct csio_hw *hw = container_of(work, struct csio_hw, evtq_work);
3513 struct list_head *evt_entry, *next_entry;
3514 LIST_HEAD(evt_q);
3515 struct csio_evt_msg *evt_msg;
3516 struct cpl_fw6_msg *msg;
3517 struct csio_rnode *rn;
3518 int rv = 0;
3519 uint8_t evtq_stop = 0;
3520
3521 csio_dbg(hw, "event worker thread active evts#%d\n",
3522 hw->stats.n_evt_activeq);
3523
3524 spin_lock_irq(&hw->lock);
3525 while (!list_empty(&hw->evt_active_q)) {
3526 list_splice_tail_init(&hw->evt_active_q, &evt_q);
3527 spin_unlock_irq(&hw->lock);
3528
3529 list_for_each_safe(evt_entry, next_entry, &evt_q) {
3530 evt_msg = (struct csio_evt_msg *) evt_entry;
3531
3532
3533 spin_lock_irq(&hw->lock);
3534 if (hw->flags & CSIO_HWF_FWEVT_STOP)
3535 evtq_stop = 1;
3536 spin_unlock_irq(&hw->lock);
3537 if (evtq_stop) {
3538 CSIO_INC_STATS(hw, n_evt_drop);
3539 goto free_evt;
3540 }
3541
3542 switch (evt_msg->type) {
3543 case CSIO_EVT_FW:
3544 msg = (struct cpl_fw6_msg *)(evt_msg->data);
3545
3546 if ((msg->opcode == CPL_FW6_MSG ||
3547 msg->opcode == CPL_FW4_MSG) &&
3548 !msg->type) {
3549 rv = csio_mb_fwevt_handler(hw,
3550 msg->data);
3551 if (!rv)
3552 break;
3553
3554 csio_fcoe_fwevt_handler(hw,
3555 msg->opcode, msg->data);
3556 } else if (msg->opcode == CPL_FW6_PLD) {
3557
3558 csio_fcoe_fwevt_handler(hw,
3559 msg->opcode, msg->data);
3560 } else {
3561 csio_warn(hw,
3562 "Unhandled FW msg op %x type %x\n",
3563 msg->opcode, msg->type);
3564 CSIO_INC_STATS(hw, n_evt_drop);
3565 }
3566 break;
3567
3568 case CSIO_EVT_MBX:
3569 csio_mberr_worker(hw);
3570 break;
3571
3572 case CSIO_EVT_DEV_LOSS:
3573 memcpy(&rn, evt_msg->data, sizeof(rn));
3574 csio_rnode_devloss_handler(rn);
3575 break;
3576
3577 default:
3578 csio_warn(hw, "Unhandled event %x on evtq\n",
3579 evt_msg->type);
3580 CSIO_INC_STATS(hw, n_evt_unexp);
3581 break;
3582 }
3583free_evt:
3584 csio_free_evt(hw, evt_msg);
3585 }
3586
3587 spin_lock_irq(&hw->lock);
3588 }
3589 hw->flags &= ~CSIO_HWF_FWEVT_PENDING;
3590 spin_unlock_irq(&hw->lock);
3591}
3592
3593int
3594csio_fwevtq_handler(struct csio_hw *hw)
3595{
3596 int rv;
3597
3598 if (csio_q_iqid(hw, hw->fwevt_iq_idx) == CSIO_MAX_QID) {
3599 CSIO_INC_STATS(hw, n_int_stray);
3600 return -EINVAL;
3601 }
3602
3603 rv = csio_wr_process_iq_idx(hw, hw->fwevt_iq_idx,
3604 csio_process_fwevtq_entry, NULL);
3605 return rv;
3606}
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621int
3622csio_mgmt_req_lookup(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req)
3623{
3624 struct list_head *tmp;
3625
3626
3627 list_for_each(tmp, &mgmtm->active_q) {
3628 if (io_req == (struct csio_ioreq *)tmp)
3629 return 0;
3630 }
3631 return -EINVAL;
3632}
3633
3634#define ECM_MIN_TMO 1000
3635
3636
3637
3638
3639
3640
3641
3642static void
3643csio_mgmt_tmo_handler(uintptr_t data)
3644{
3645 struct csio_mgmtm *mgmtm = (struct csio_mgmtm *) data;
3646 struct list_head *tmp;
3647 struct csio_ioreq *io_req;
3648
3649 csio_dbg(mgmtm->hw, "Mgmt timer invoked!\n");
3650
3651 spin_lock_irq(&mgmtm->hw->lock);
3652
3653 list_for_each(tmp, &mgmtm->active_q) {
3654 io_req = (struct csio_ioreq *) tmp;
3655 io_req->tmo -= min_t(uint32_t, io_req->tmo, ECM_MIN_TMO);
3656
3657 if (!io_req->tmo) {
3658
3659 tmp = csio_list_prev(tmp);
3660 list_del_init(&io_req->sm.sm_list);
3661 if (io_req->io_cbfn) {
3662
3663 io_req->wr_status = -ETIMEDOUT;
3664 io_req->io_cbfn(mgmtm->hw, io_req);
3665 } else {
3666 CSIO_DB_ASSERT(0);
3667 }
3668 }
3669 }
3670
3671
3672 if (!list_empty(&mgmtm->active_q))
3673 mod_timer(&mgmtm->mgmt_timer,
3674 jiffies + msecs_to_jiffies(ECM_MIN_TMO));
3675 spin_unlock_irq(&mgmtm->hw->lock);
3676}
3677
3678static void
3679csio_mgmtm_cleanup(struct csio_mgmtm *mgmtm)
3680{
3681 struct csio_hw *hw = mgmtm->hw;
3682 struct csio_ioreq *io_req;
3683 struct list_head *tmp;
3684 uint32_t count;
3685
3686 count = 30;
3687
3688 while ((!list_empty(&mgmtm->active_q)) && count--) {
3689 spin_unlock_irq(&hw->lock);
3690 msleep(2000);
3691 spin_lock_irq(&hw->lock);
3692 }
3693
3694
3695 list_for_each(tmp, &mgmtm->active_q) {
3696 io_req = (struct csio_ioreq *) tmp;
3697 tmp = csio_list_prev(tmp);
3698 list_del_init(&io_req->sm.sm_list);
3699 mgmtm->stats.n_active--;
3700 if (io_req->io_cbfn) {
3701
3702 io_req->wr_status = -ETIMEDOUT;
3703 io_req->io_cbfn(mgmtm->hw, io_req);
3704 }
3705 }
3706}
3707
3708
3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722static int
3723csio_mgmtm_init(struct csio_mgmtm *mgmtm, struct csio_hw *hw)
3724{
3725 struct timer_list *timer = &mgmtm->mgmt_timer;
3726
3727 init_timer(timer);
3728 timer->function = csio_mgmt_tmo_handler;
3729 timer->data = (unsigned long)mgmtm;
3730
3731 INIT_LIST_HEAD(&mgmtm->active_q);
3732 INIT_LIST_HEAD(&mgmtm->cbfn_q);
3733
3734 mgmtm->hw = hw;
3735
3736
3737 return 0;
3738}
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
3749static void
3750csio_mgmtm_exit(struct csio_mgmtm *mgmtm)
3751{
3752 del_timer_sync(&mgmtm->mgmt_timer);
3753}
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764int
3765csio_hw_start(struct csio_hw *hw)
3766{
3767 spin_lock_irq(&hw->lock);
3768 csio_post_event(&hw->sm, CSIO_HWE_CFG);
3769 spin_unlock_irq(&hw->lock);
3770
3771 if (csio_is_hw_ready(hw))
3772 return 0;
3773 else
3774 return -EINVAL;
3775}
3776
3777int
3778csio_hw_stop(struct csio_hw *hw)
3779{
3780 csio_post_event(&hw->sm, CSIO_HWE_PCI_REMOVE);
3781
3782 if (csio_is_hw_removing(hw))
3783 return 0;
3784 else
3785 return -EINVAL;
3786}
3787
3788
3789#define CSIO_MAX_RESET_RETRIES 3
3790
3791
3792
3793
3794
3795
3796
3797int
3798csio_hw_reset(struct csio_hw *hw)
3799{
3800 if (!csio_is_hw_master(hw))
3801 return -EPERM;
3802
3803 if (hw->rst_retries >= CSIO_MAX_RESET_RETRIES) {
3804 csio_dbg(hw, "Max hw reset attempts reached..");
3805 return -EINVAL;
3806 }
3807
3808 hw->rst_retries++;
3809 csio_post_event(&hw->sm, CSIO_HWE_HBA_RESET);
3810
3811 if (csio_is_hw_ready(hw)) {
3812 hw->rst_retries = 0;
3813 hw->stats.n_reset_start = jiffies_to_msecs(jiffies);
3814 return 0;
3815 } else
3816 return -EINVAL;
3817}
3818
3819
3820
3821
3822
3823static void
3824csio_hw_get_device_id(struct csio_hw *hw)
3825{
3826
3827 if (csio_is_dev_id_cached(hw))
3828 return;
3829
3830
3831 pci_read_config_word(hw->pdev, PCI_VENDOR_ID,
3832 &hw->params.pci.vendor_id);
3833 pci_read_config_word(hw->pdev, PCI_DEVICE_ID,
3834 &hw->params.pci.device_id);
3835
3836 csio_dev_id_cached(hw);
3837 hw->chip_id = (hw->params.pci.device_id & CSIO_HW_CHIP_MASK);
3838
3839}
3840
3841
3842
3843
3844
3845
3846
3847static void
3848csio_hw_set_description(struct csio_hw *hw, uint16_t ven_id, uint16_t dev_id)
3849{
3850 uint32_t adap_type, prot_type;
3851
3852 if (ven_id == CSIO_VENDOR_ID) {
3853 prot_type = (dev_id & CSIO_ASIC_DEVID_PROTO_MASK);
3854 adap_type = (dev_id & CSIO_ASIC_DEVID_TYPE_MASK);
3855
3856 if (prot_type == CSIO_T5_FCOE_ASIC) {
3857 memcpy(hw->hw_ver,
3858 csio_t5_fcoe_adapters[adap_type].model_no, 16);
3859 memcpy(hw->model_desc,
3860 csio_t5_fcoe_adapters[adap_type].description,
3861 32);
3862 } else {
3863 char tempName[32] = "Chelsio FCoE Controller";
3864 memcpy(hw->model_desc, tempName, 32);
3865 }
3866 }
3867}
3868
3869
3870
3871
3872
3873
3874
3875int
3876csio_hw_init(struct csio_hw *hw)
3877{
3878 int rv = -EINVAL;
3879 uint32_t i;
3880 uint16_t ven_id, dev_id;
3881 struct csio_evt_msg *evt_entry;
3882
3883 INIT_LIST_HEAD(&hw->sm.sm_list);
3884 csio_init_state(&hw->sm, csio_hws_uninit);
3885 spin_lock_init(&hw->lock);
3886 INIT_LIST_HEAD(&hw->sln_head);
3887
3888
3889 csio_hw_get_device_id(hw);
3890
3891 strcpy(hw->name, CSIO_HW_NAME);
3892
3893
3894 hw->chip_ops = &t5_ops;
3895
3896
3897
3898 ven_id = hw->params.pci.vendor_id;
3899 dev_id = hw->params.pci.device_id;
3900
3901 csio_hw_set_description(hw, ven_id, dev_id);
3902
3903
3904 hw->params.log_level = (uint32_t) csio_dbg_level;
3905
3906 csio_set_fwevt_intr_idx(hw, -1);
3907 csio_set_nondata_intr_idx(hw, -1);
3908
3909
3910 if (csio_mbm_init(csio_hw_to_mbm(hw), hw, csio_hw_mb_timer))
3911 goto err;
3912
3913 rv = csio_wrm_init(csio_hw_to_wrm(hw), hw);
3914 if (rv)
3915 goto err_mbm_exit;
3916
3917 rv = csio_scsim_init(csio_hw_to_scsim(hw), hw);
3918 if (rv)
3919 goto err_wrm_exit;
3920
3921 rv = csio_mgmtm_init(csio_hw_to_mgmtm(hw), hw);
3922 if (rv)
3923 goto err_scsim_exit;
3924
3925 INIT_LIST_HEAD(&hw->evt_active_q);
3926 INIT_LIST_HEAD(&hw->evt_free_q);
3927 for (i = 0; i < csio_evtq_sz; i++) {
3928
3929 evt_entry = kzalloc(sizeof(struct csio_evt_msg), GFP_KERNEL);
3930 if (!evt_entry) {
3931 rv = -ENOMEM;
3932 csio_err(hw, "Failed to initialize eventq");
3933 goto err_evtq_cleanup;
3934 }
3935
3936 list_add_tail(&evt_entry->list, &hw->evt_free_q);
3937 CSIO_INC_STATS(hw, n_evt_freeq);
3938 }
3939
3940 hw->dev_num = dev_num;
3941 dev_num++;
3942
3943 return 0;
3944
3945err_evtq_cleanup:
3946 csio_evtq_cleanup(hw);
3947 csio_mgmtm_exit(csio_hw_to_mgmtm(hw));
3948err_scsim_exit:
3949 csio_scsim_exit(csio_hw_to_scsim(hw));
3950err_wrm_exit:
3951 csio_wrm_exit(csio_hw_to_wrm(hw), hw);
3952err_mbm_exit:
3953 csio_mbm_exit(csio_hw_to_mbm(hw));
3954err:
3955 return rv;
3956}
3957
3958
3959
3960
3961
3962
3963void
3964csio_hw_exit(struct csio_hw *hw)
3965{
3966 csio_evtq_cleanup(hw);
3967 csio_mgmtm_exit(csio_hw_to_mgmtm(hw));
3968 csio_scsim_exit(csio_hw_to_scsim(hw));
3969 csio_wrm_exit(csio_hw_to_wrm(hw), hw);
3970 csio_mbm_exit(csio_hw_to_mbm(hw));
3971}
3972