1 // SPDX-License-Identifier: GPL-2.0
2 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
4 #include <linux/slab.h>
8 /* Read a NIC register from the alternate function. */
9 static u32 qlge_read_other_func_reg(struct qlge_adapter *qdev,
14 unsigned int status = 0;
16 register_to_read = MPI_NIC_REG_BLOCK
18 | (qdev->alt_func << MPI_NIC_FUNCTION_SHIFT)
20 status = qlge_read_mpi_reg(qdev, register_to_read, ®_val);
27 /* Write a NIC register from the alternate function. */
28 static int qlge_write_other_func_reg(struct qlge_adapter *qdev,
33 register_to_read = MPI_NIC_REG_BLOCK
35 | (qdev->alt_func << MPI_NIC_FUNCTION_SHIFT)
38 return qlge_write_mpi_reg(qdev, register_to_read, reg_val);
41 static int qlge_wait_other_func_reg_rdy(struct qlge_adapter *qdev, u32 reg,
47 for (count = 10; count; count--) {
48 temp = qlge_read_other_func_reg(qdev, reg);
50 /* check for errors */
60 static int qlge_read_other_func_serdes_reg(struct qlge_adapter *qdev, u32 reg,
65 /* wait for reg to come ready */
66 status = qlge_wait_other_func_reg_rdy(qdev, XG_SERDES_ADDR / 4,
67 XG_SERDES_ADDR_RDY, 0);
71 /* set up for reg read */
72 qlge_write_other_func_reg(qdev, XG_SERDES_ADDR / 4, reg | PROC_ADDR_R);
74 /* wait for reg to come ready */
75 status = qlge_wait_other_func_reg_rdy(qdev, XG_SERDES_ADDR / 4,
76 XG_SERDES_ADDR_RDY, 0);
81 *data = qlge_read_other_func_reg(qdev, (XG_SERDES_DATA / 4));
86 /* Read out the SERDES registers */
87 static int qlge_read_serdes_reg(struct qlge_adapter *qdev, u32 reg, u32 *data)
91 /* wait for reg to come ready */
92 status = qlge_wait_reg_rdy(qdev, XG_SERDES_ADDR, XG_SERDES_ADDR_RDY, 0);
96 /* set up for reg read */
97 qlge_write32(qdev, XG_SERDES_ADDR, reg | PROC_ADDR_R);
99 /* wait for reg to come ready */
100 status = qlge_wait_reg_rdy(qdev, XG_SERDES_ADDR, XG_SERDES_ADDR_RDY, 0);
105 *data = qlge_read32(qdev, XG_SERDES_DATA);
110 static void qlge_get_both_serdes(struct qlge_adapter *qdev, u32 addr,
111 u32 *direct_ptr, u32 *indirect_ptr,
112 bool direct_valid, bool indirect_valid)
118 status = qlge_read_serdes_reg(qdev, addr, direct_ptr);
119 /* Dead fill any failures or invalids. */
121 *direct_ptr = 0xDEADBEEF;
125 status = qlge_read_other_func_serdes_reg(qdev, addr,
127 /* Dead fill any failures or invalids. */
129 *indirect_ptr = 0xDEADBEEF;
132 static int qlge_get_serdes_regs(struct qlge_adapter *qdev,
133 struct qlge_mpi_coredump *mpi_coredump)
136 bool xfi_direct_valid = false, xfi_indirect_valid = false;
137 bool xaui_direct_valid = true, xaui_indirect_valid = true;
139 u32 *direct_ptr, temp;
142 /* The XAUI needs to be read out per port */
143 status = qlge_read_other_func_serdes_reg(qdev,
144 XG_SERDES_XAUI_HSS_PCS_START,
147 temp = XG_SERDES_ADDR_XAUI_PWR_DOWN;
149 if ((temp & XG_SERDES_ADDR_XAUI_PWR_DOWN) ==
150 XG_SERDES_ADDR_XAUI_PWR_DOWN)
151 xaui_indirect_valid = false;
153 status = qlge_read_serdes_reg(qdev, XG_SERDES_XAUI_HSS_PCS_START, &temp);
156 temp = XG_SERDES_ADDR_XAUI_PWR_DOWN;
158 if ((temp & XG_SERDES_ADDR_XAUI_PWR_DOWN) ==
159 XG_SERDES_ADDR_XAUI_PWR_DOWN)
160 xaui_direct_valid = false;
163 * XFI register is shared so only need to read one
164 * functions and then check the bits.
166 status = qlge_read_serdes_reg(qdev, XG_SERDES_ADDR_STS, &temp);
170 if ((temp & XG_SERDES_ADDR_XFI1_PWR_UP) ==
171 XG_SERDES_ADDR_XFI1_PWR_UP) {
172 /* now see if i'm NIC 1 or NIC 2 */
174 /* I'm NIC 2, so the indirect (NIC1) xfi is up. */
175 xfi_indirect_valid = true;
177 xfi_direct_valid = true;
179 if ((temp & XG_SERDES_ADDR_XFI2_PWR_UP) ==
180 XG_SERDES_ADDR_XFI2_PWR_UP) {
181 /* now see if i'm NIC 1 or NIC 2 */
183 /* I'm NIC 2, so the indirect (NIC1) xfi is up. */
184 xfi_direct_valid = true;
186 xfi_indirect_valid = true;
189 /* Get XAUI_AN register block. */
190 if (qdev->func & 1) {
191 /* Function 2 is direct */
192 direct_ptr = mpi_coredump->serdes2_xaui_an;
193 indirect_ptr = mpi_coredump->serdes_xaui_an;
195 /* Function 1 is direct */
196 direct_ptr = mpi_coredump->serdes_xaui_an;
197 indirect_ptr = mpi_coredump->serdes2_xaui_an;
200 for (i = 0; i <= 0x000000034; i += 4, direct_ptr++, indirect_ptr++)
201 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
202 xaui_direct_valid, xaui_indirect_valid);
204 /* Get XAUI_HSS_PCS register block. */
205 if (qdev->func & 1) {
207 mpi_coredump->serdes2_xaui_hss_pcs;
209 mpi_coredump->serdes_xaui_hss_pcs;
212 mpi_coredump->serdes_xaui_hss_pcs;
214 mpi_coredump->serdes2_xaui_hss_pcs;
217 for (i = 0x800; i <= 0x880; i += 4, direct_ptr++, indirect_ptr++)
218 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
219 xaui_direct_valid, xaui_indirect_valid);
221 /* Get XAUI_XFI_AN register block. */
222 if (qdev->func & 1) {
223 direct_ptr = mpi_coredump->serdes2_xfi_an;
224 indirect_ptr = mpi_coredump->serdes_xfi_an;
226 direct_ptr = mpi_coredump->serdes_xfi_an;
227 indirect_ptr = mpi_coredump->serdes2_xfi_an;
230 for (i = 0x1000; i <= 0x1034; i += 4, direct_ptr++, indirect_ptr++)
231 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
232 xfi_direct_valid, xfi_indirect_valid);
234 /* Get XAUI_XFI_TRAIN register block. */
235 if (qdev->func & 1) {
236 direct_ptr = mpi_coredump->serdes2_xfi_train;
238 mpi_coredump->serdes_xfi_train;
240 direct_ptr = mpi_coredump->serdes_xfi_train;
242 mpi_coredump->serdes2_xfi_train;
245 for (i = 0x1050; i <= 0x107c; i += 4, direct_ptr++, indirect_ptr++)
246 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
247 xfi_direct_valid, xfi_indirect_valid);
249 /* Get XAUI_XFI_HSS_PCS register block. */
250 if (qdev->func & 1) {
252 mpi_coredump->serdes2_xfi_hss_pcs;
254 mpi_coredump->serdes_xfi_hss_pcs;
257 mpi_coredump->serdes_xfi_hss_pcs;
259 mpi_coredump->serdes2_xfi_hss_pcs;
262 for (i = 0x1800; i <= 0x1838; i += 4, direct_ptr++, indirect_ptr++)
263 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
264 xfi_direct_valid, xfi_indirect_valid);
266 /* Get XAUI_XFI_HSS_TX register block. */
267 if (qdev->func & 1) {
269 mpi_coredump->serdes2_xfi_hss_tx;
271 mpi_coredump->serdes_xfi_hss_tx;
273 direct_ptr = mpi_coredump->serdes_xfi_hss_tx;
275 mpi_coredump->serdes2_xfi_hss_tx;
277 for (i = 0x1c00; i <= 0x1c1f; i++, direct_ptr++, indirect_ptr++)
278 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
279 xfi_direct_valid, xfi_indirect_valid);
281 /* Get XAUI_XFI_HSS_RX register block. */
282 if (qdev->func & 1) {
284 mpi_coredump->serdes2_xfi_hss_rx;
286 mpi_coredump->serdes_xfi_hss_rx;
288 direct_ptr = mpi_coredump->serdes_xfi_hss_rx;
290 mpi_coredump->serdes2_xfi_hss_rx;
293 for (i = 0x1c40; i <= 0x1c5f; i++, direct_ptr++, indirect_ptr++)
294 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
295 xfi_direct_valid, xfi_indirect_valid);
297 /* Get XAUI_XFI_HSS_PLL register block. */
298 if (qdev->func & 1) {
300 mpi_coredump->serdes2_xfi_hss_pll;
302 mpi_coredump->serdes_xfi_hss_pll;
305 mpi_coredump->serdes_xfi_hss_pll;
307 mpi_coredump->serdes2_xfi_hss_pll;
309 for (i = 0x1e00; i <= 0x1e1f; i++, direct_ptr++, indirect_ptr++)
310 qlge_get_both_serdes(qdev, i, direct_ptr, indirect_ptr,
311 xfi_direct_valid, xfi_indirect_valid);
315 static int qlge_read_other_func_xgmac_reg(struct qlge_adapter *qdev, u32 reg,
320 /* wait for reg to come ready */
321 status = qlge_wait_other_func_reg_rdy(qdev, XGMAC_ADDR / 4,
322 XGMAC_ADDR_RDY, XGMAC_ADDR_XME);
326 /* set up for reg read */
327 qlge_write_other_func_reg(qdev, XGMAC_ADDR / 4, reg | XGMAC_ADDR_R);
329 /* wait for reg to come ready */
330 status = qlge_wait_other_func_reg_rdy(qdev, XGMAC_ADDR / 4,
331 XGMAC_ADDR_RDY, XGMAC_ADDR_XME);
336 *data = qlge_read_other_func_reg(qdev, XGMAC_DATA / 4);
341 /* Read the 400 xgmac control/statistics registers
342 * skipping unused locations.
344 static int qlge_get_xgmac_regs(struct qlge_adapter *qdev, u32 *buf,
345 unsigned int other_function)
350 for (i = PAUSE_SRC_LO; i < XGMAC_REGISTER_END; i += 4, buf++) {
351 /* We're reading 400 xgmac registers, but we filter out
352 * several locations that are non-responsive to reads.
354 if ((i == 0x00000114) ||
358 (i > 0x00000150 && i < 0x000001fc) ||
359 (i > 0x00000278 && i < 0x000002a0) ||
360 (i > 0x000002c0 && i < 0x000002cf) ||
361 (i > 0x000002dc && i < 0x000002f0) ||
362 (i > 0x000003c8 && i < 0x00000400) ||
363 (i > 0x00000400 && i < 0x00000410) ||
364 (i > 0x00000410 && i < 0x00000420) ||
365 (i > 0x00000420 && i < 0x00000430) ||
366 (i > 0x00000430 && i < 0x00000440) ||
367 (i > 0x00000440 && i < 0x00000450) ||
368 (i > 0x00000450 && i < 0x00000500) ||
369 (i > 0x0000054c && i < 0x00000568) ||
370 (i > 0x000005c8 && i < 0x00000600)) {
373 qlge_read_other_func_xgmac_reg(qdev, i, buf);
375 status = qlge_read_xgmac_reg(qdev, i, buf);
385 static int qlge_get_ets_regs(struct qlge_adapter *qdev, u32 *buf)
389 for (i = 0; i < 8; i++, buf++) {
390 qlge_write32(qdev, NIC_ETS, i << 29 | 0x08000000);
391 *buf = qlge_read32(qdev, NIC_ETS);
394 for (i = 0; i < 2; i++, buf++) {
395 qlge_write32(qdev, CNA_ETS, i << 29 | 0x08000000);
396 *buf = qlge_read32(qdev, CNA_ETS);
402 static void qlge_get_intr_states(struct qlge_adapter *qdev, u32 *buf)
406 for (i = 0; i < qdev->rx_ring_count; i++, buf++) {
407 qlge_write32(qdev, INTR_EN,
408 qdev->intr_context[i].intr_read_mask);
409 *buf = qlge_read32(qdev, INTR_EN);
413 static int qlge_get_cam_entries(struct qlge_adapter *qdev, u32 *buf)
418 status = qlge_sem_spinlock(qdev, SEM_MAC_ADDR_MASK);
422 for (i = 0; i < 16; i++) {
423 status = qlge_get_mac_addr_reg(qdev,
424 MAC_ADDR_TYPE_CAM_MAC, i, value);
426 netif_err(qdev, drv, qdev->ndev,
427 "Failed read of mac index register\n");
430 *buf++ = value[0]; /* lower MAC address */
431 *buf++ = value[1]; /* upper MAC address */
432 *buf++ = value[2]; /* output */
434 for (i = 0; i < 32; i++) {
435 status = qlge_get_mac_addr_reg(qdev, MAC_ADDR_TYPE_MULTI_MAC,
438 netif_err(qdev, drv, qdev->ndev,
439 "Failed read of mac index register\n");
442 *buf++ = value[0]; /* lower Mcast address */
443 *buf++ = value[1]; /* upper Mcast address */
446 qlge_sem_unlock(qdev, SEM_MAC_ADDR_MASK);
450 static int qlge_get_routing_entries(struct qlge_adapter *qdev, u32 *buf)
455 status = qlge_sem_spinlock(qdev, SEM_RT_IDX_MASK);
459 for (i = 0; i < 16; i++) {
460 status = qlge_get_routing_reg(qdev, i, &value);
462 netif_err(qdev, drv, qdev->ndev,
463 "Failed read of routing index register\n");
470 qlge_sem_unlock(qdev, SEM_RT_IDX_MASK);
474 /* Read the MPI Processor shadow registers */
475 static int qlge_get_mpi_shadow_regs(struct qlge_adapter *qdev, u32 *buf)
480 for (i = 0; i < MPI_CORE_SH_REGS_CNT; i++, buf++) {
481 status = qlge_write_mpi_reg(qdev,
483 (SHADOW_OFFSET | i << SHADOW_REG_SHIFT));
486 status = qlge_read_mpi_reg(qdev, RISC_127, buf);
494 /* Read the MPI Processor core registers */
495 static int qlge_get_mpi_regs(struct qlge_adapter *qdev, u32 *buf,
496 u32 offset, u32 count)
500 for (i = 0; i < count; i++, buf++) {
501 status = qlge_read_mpi_reg(qdev, offset + i, buf);
508 /* Read the ASIC probe dump */
509 static unsigned int *qlge_get_probe(struct qlge_adapter *qdev, u32 clock,
512 u32 module, mux_sel, probe, lo_val, hi_val;
514 for (module = 0; module < PRB_MX_ADDR_MAX_MODS; module++) {
515 if (!((valid >> module) & 1))
517 for (mux_sel = 0; mux_sel < PRB_MX_ADDR_MAX_MUX; mux_sel++) {
521 | (module << PRB_MX_ADDR_MOD_SEL_SHIFT);
522 qlge_write32(qdev, PRB_MX_ADDR, probe);
523 lo_val = qlge_read32(qdev, PRB_MX_DATA);
528 probe |= PRB_MX_ADDR_UP;
529 qlge_write32(qdev, PRB_MX_ADDR, probe);
530 hi_val = qlge_read32(qdev, PRB_MX_DATA);
540 static int qlge_get_probe_dump(struct qlge_adapter *qdev, unsigned int *buf)
542 /* First we have to enable the probe mux */
543 qlge_write_mpi_reg(qdev, MPI_TEST_FUNC_PRB_CTL, MPI_TEST_FUNC_PRB_EN);
544 buf = qlge_get_probe(qdev, PRB_MX_ADDR_SYS_CLOCK,
545 PRB_MX_ADDR_VALID_SYS_MOD, buf);
546 buf = qlge_get_probe(qdev, PRB_MX_ADDR_PCI_CLOCK,
547 PRB_MX_ADDR_VALID_PCI_MOD, buf);
548 buf = qlge_get_probe(qdev, PRB_MX_ADDR_XGM_CLOCK,
549 PRB_MX_ADDR_VALID_XGM_MOD, buf);
550 buf = qlge_get_probe(qdev, PRB_MX_ADDR_FC_CLOCK,
551 PRB_MX_ADDR_VALID_FC_MOD, buf);
555 /* Read out the routing index registers */
556 static int qlge_get_routing_index_registers(struct qlge_adapter *qdev, u32 *buf)
559 u32 type, index, index_max;
564 status = qlge_sem_spinlock(qdev, SEM_RT_IDX_MASK);
568 for (type = 0; type < 4; type++) {
573 for (index = 0; index < index_max; index++) {
575 | (type << RT_IDX_TYPE_SHIFT)
576 | (index << RT_IDX_IDX_SHIFT);
577 qlge_write32(qdev, RT_IDX, val);
579 while ((result_index & RT_IDX_MR) == 0)
580 result_index = qlge_read32(qdev, RT_IDX);
581 result_data = qlge_read32(qdev, RT_DATA);
592 qlge_sem_unlock(qdev, SEM_RT_IDX_MASK);
596 /* Read out the MAC protocol registers */
597 static void qlge_get_mac_protocol_registers(struct qlge_adapter *qdev, u32 *buf)
599 u32 result_index, result_data;
604 u32 initial_val = MAC_ADDR_RS;
608 for (type = 0; type < MAC_ADDR_TYPE_COUNT; type++) {
611 initial_val |= MAC_ADDR_ADR;
612 max_index = MAC_ADDR_MAX_CAM_ENTRIES;
613 max_offset = MAC_ADDR_MAX_CAM_WCOUNT;
615 case 1: /* Multicast MAC Address */
616 max_index = MAC_ADDR_MAX_CAM_WCOUNT;
617 max_offset = MAC_ADDR_MAX_CAM_WCOUNT;
619 case 2: /* VLAN filter mask */
620 case 3: /* MC filter mask */
621 max_index = MAC_ADDR_MAX_CAM_WCOUNT;
622 max_offset = MAC_ADDR_MAX_CAM_WCOUNT;
624 case 4: /* FC MAC addresses */
625 max_index = MAC_ADDR_MAX_FC_MAC_ENTRIES;
626 max_offset = MAC_ADDR_MAX_FC_MAC_WCOUNT;
628 case 5: /* Mgmt MAC addresses */
629 max_index = MAC_ADDR_MAX_MGMT_MAC_ENTRIES;
630 max_offset = MAC_ADDR_MAX_MGMT_MAC_WCOUNT;
632 case 6: /* Mgmt VLAN addresses */
633 max_index = MAC_ADDR_MAX_MGMT_VLAN_ENTRIES;
634 max_offset = MAC_ADDR_MAX_MGMT_VLAN_WCOUNT;
636 case 7: /* Mgmt IPv4 address */
637 max_index = MAC_ADDR_MAX_MGMT_V4_ENTRIES;
638 max_offset = MAC_ADDR_MAX_MGMT_V4_WCOUNT;
640 case 8: /* Mgmt IPv6 address */
641 max_index = MAC_ADDR_MAX_MGMT_V6_ENTRIES;
642 max_offset = MAC_ADDR_MAX_MGMT_V6_WCOUNT;
644 case 9: /* Mgmt TCP/UDP Dest port */
645 max_index = MAC_ADDR_MAX_MGMT_TU_DP_ENTRIES;
646 max_offset = MAC_ADDR_MAX_MGMT_TU_DP_WCOUNT;
649 netdev_err(qdev->ndev, "Bad type!!! 0x%08x\n", type);
654 for (index = 0; index < max_index; index++) {
655 for (offset = 0; offset < max_offset; offset++) {
657 | (type << MAC_ADDR_TYPE_SHIFT)
658 | (index << MAC_ADDR_IDX_SHIFT)
660 qlge_write32(qdev, MAC_ADDR_IDX, val);
662 while ((result_index & MAC_ADDR_MR) == 0) {
663 result_index = qlge_read32(qdev,
666 result_data = qlge_read32(qdev, MAC_ADDR_DATA);
676 static void qlge_get_sem_registers(struct qlge_adapter *qdev, u32 *buf)
678 u32 func_num, reg, reg_val;
681 for (func_num = 0; func_num < MAX_SEMAPHORE_FUNCTIONS ; func_num++) {
682 reg = MPI_NIC_REG_BLOCK
683 | (func_num << MPI_NIC_FUNCTION_SHIFT)
685 status = qlge_read_mpi_reg(qdev, reg, ®_val);
687 /* if the read failed then dead fill the element. */
694 /* Create a coredump segment header */
695 static void qlge_build_coredump_seg_header(struct mpi_coredump_segment_header *seg_hdr,
696 u32 seg_number, u32 seg_size, u8 *desc)
698 memset(seg_hdr, 0, sizeof(struct mpi_coredump_segment_header));
699 seg_hdr->cookie = MPI_COREDUMP_COOKIE;
700 seg_hdr->seg_num = seg_number;
701 seg_hdr->seg_size = seg_size;
702 strncpy(seg_hdr->description, desc, (sizeof(seg_hdr->description)) - 1);
706 * This function should be called when a coredump / probedump
707 * is to be extracted from the HBA. It is assumed there is a
708 * qdev structure that contains the base address of the register
709 * space for this function as well as a coredump structure that
710 * will contain the dump.
712 int qlge_core_dump(struct qlge_adapter *qdev, struct qlge_mpi_coredump *mpi_coredump)
718 netif_err(qdev, drv, qdev->ndev, "No memory allocated\n");
722 /* Try to get the spinlock, but dont worry if
723 * it isn't available. If the firmware died it
724 * might be holding the sem.
726 qlge_sem_spinlock(qdev, SEM_PROC_REG_MASK);
728 status = qlge_pause_mpi_risc(qdev);
730 netif_err(qdev, drv, qdev->ndev,
731 "Failed RISC pause. Status = 0x%.08x\n", status);
735 /* Insert the global header */
736 memset(&(mpi_coredump->mpi_global_header), 0,
737 sizeof(struct mpi_coredump_global_header));
738 mpi_coredump->mpi_global_header.cookie = MPI_COREDUMP_COOKIE;
739 mpi_coredump->mpi_global_header.header_size =
740 sizeof(struct mpi_coredump_global_header);
741 mpi_coredump->mpi_global_header.image_size =
742 sizeof(struct qlge_mpi_coredump);
743 strncpy(mpi_coredump->mpi_global_header.id_string, "MPI Coredump",
744 sizeof(mpi_coredump->mpi_global_header.id_string));
746 /* Get generic NIC reg dump */
747 qlge_build_coredump_seg_header(&mpi_coredump->nic_regs_seg_hdr,
748 NIC1_CONTROL_SEG_NUM,
749 sizeof(struct mpi_coredump_segment_header) +
750 sizeof(mpi_coredump->nic_regs), "NIC1 Registers");
752 qlge_build_coredump_seg_header(&mpi_coredump->nic2_regs_seg_hdr,
753 NIC2_CONTROL_SEG_NUM,
754 sizeof(struct mpi_coredump_segment_header) +
755 sizeof(mpi_coredump->nic2_regs), "NIC2 Registers");
757 /* Get XGMac registers. (Segment 18, Rev C. step 21) */
758 qlge_build_coredump_seg_header(&mpi_coredump->xgmac1_seg_hdr,
760 sizeof(struct mpi_coredump_segment_header) +
761 sizeof(mpi_coredump->xgmac1), "NIC1 XGMac Registers");
763 qlge_build_coredump_seg_header(&mpi_coredump->xgmac2_seg_hdr,
765 sizeof(struct mpi_coredump_segment_header) +
766 sizeof(mpi_coredump->xgmac2), "NIC2 XGMac Registers");
768 if (qdev->func & 1) {
769 /* Odd means our function is NIC 2 */
770 for (i = 0; i < NIC_REGS_DUMP_WORD_COUNT; i++)
771 mpi_coredump->nic2_regs[i] =
772 qlge_read32(qdev, i * sizeof(u32));
774 for (i = 0; i < NIC_REGS_DUMP_WORD_COUNT; i++)
775 mpi_coredump->nic_regs[i] =
776 qlge_read_other_func_reg(qdev, (i * sizeof(u32)) / 4);
778 qlge_get_xgmac_regs(qdev, &mpi_coredump->xgmac2[0], 0);
779 qlge_get_xgmac_regs(qdev, &mpi_coredump->xgmac1[0], 1);
781 /* Even means our function is NIC 1 */
782 for (i = 0; i < NIC_REGS_DUMP_WORD_COUNT; i++)
783 mpi_coredump->nic_regs[i] =
784 qlge_read32(qdev, i * sizeof(u32));
785 for (i = 0; i < NIC_REGS_DUMP_WORD_COUNT; i++)
786 mpi_coredump->nic2_regs[i] =
787 qlge_read_other_func_reg(qdev, (i * sizeof(u32)) / 4);
789 qlge_get_xgmac_regs(qdev, &mpi_coredump->xgmac1[0], 0);
790 qlge_get_xgmac_regs(qdev, &mpi_coredump->xgmac2[0], 1);
793 /* Rev C. Step 20a */
794 qlge_build_coredump_seg_header(&mpi_coredump->xaui_an_hdr,
796 sizeof(struct mpi_coredump_segment_header) +
797 sizeof(mpi_coredump->serdes_xaui_an),
798 "XAUI AN Registers");
800 /* Rev C. Step 20b */
801 qlge_build_coredump_seg_header(&mpi_coredump->xaui_hss_pcs_hdr,
802 XAUI_HSS_PCS_SEG_NUM,
803 sizeof(struct mpi_coredump_segment_header) +
804 sizeof(mpi_coredump->serdes_xaui_hss_pcs),
805 "XAUI HSS PCS Registers");
807 qlge_build_coredump_seg_header(&mpi_coredump->xfi_an_hdr, XFI_AN_SEG_NUM,
808 sizeof(struct mpi_coredump_segment_header) +
809 sizeof(mpi_coredump->serdes_xfi_an),
812 qlge_build_coredump_seg_header(&mpi_coredump->xfi_train_hdr,
814 sizeof(struct mpi_coredump_segment_header) +
815 sizeof(mpi_coredump->serdes_xfi_train),
816 "XFI TRAIN Registers");
818 qlge_build_coredump_seg_header(&mpi_coredump->xfi_hss_pcs_hdr,
820 sizeof(struct mpi_coredump_segment_header) +
821 sizeof(mpi_coredump->serdes_xfi_hss_pcs),
822 "XFI HSS PCS Registers");
824 qlge_build_coredump_seg_header(&mpi_coredump->xfi_hss_tx_hdr,
826 sizeof(struct mpi_coredump_segment_header) +
827 sizeof(mpi_coredump->serdes_xfi_hss_tx),
828 "XFI HSS TX Registers");
830 qlge_build_coredump_seg_header(&mpi_coredump->xfi_hss_rx_hdr,
832 sizeof(struct mpi_coredump_segment_header) +
833 sizeof(mpi_coredump->serdes_xfi_hss_rx),
834 "XFI HSS RX Registers");
836 qlge_build_coredump_seg_header(&mpi_coredump->xfi_hss_pll_hdr,
838 sizeof(struct mpi_coredump_segment_header) +
839 sizeof(mpi_coredump->serdes_xfi_hss_pll),
840 "XFI HSS PLL Registers");
842 qlge_build_coredump_seg_header(&mpi_coredump->xaui2_an_hdr,
844 sizeof(struct mpi_coredump_segment_header) +
845 sizeof(mpi_coredump->serdes2_xaui_an),
846 "XAUI2 AN Registers");
848 qlge_build_coredump_seg_header(&mpi_coredump->xaui2_hss_pcs_hdr,
849 XAUI2_HSS_PCS_SEG_NUM,
850 sizeof(struct mpi_coredump_segment_header) +
851 sizeof(mpi_coredump->serdes2_xaui_hss_pcs),
852 "XAUI2 HSS PCS Registers");
854 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_an_hdr,
856 sizeof(struct mpi_coredump_segment_header) +
857 sizeof(mpi_coredump->serdes2_xfi_an),
858 "XFI2 AN Registers");
860 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_train_hdr,
862 sizeof(struct mpi_coredump_segment_header) +
863 sizeof(mpi_coredump->serdes2_xfi_train),
864 "XFI2 TRAIN Registers");
866 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_hss_pcs_hdr,
867 XFI2_HSS_PCS_SEG_NUM,
868 sizeof(struct mpi_coredump_segment_header) +
869 sizeof(mpi_coredump->serdes2_xfi_hss_pcs),
870 "XFI2 HSS PCS Registers");
872 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_hss_tx_hdr,
874 sizeof(struct mpi_coredump_segment_header) +
875 sizeof(mpi_coredump->serdes2_xfi_hss_tx),
876 "XFI2 HSS TX Registers");
878 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_hss_rx_hdr,
880 sizeof(struct mpi_coredump_segment_header) +
881 sizeof(mpi_coredump->serdes2_xfi_hss_rx),
882 "XFI2 HSS RX Registers");
884 qlge_build_coredump_seg_header(&mpi_coredump->xfi2_hss_pll_hdr,
885 XFI2_HSS_PLL_SEG_NUM,
886 sizeof(struct mpi_coredump_segment_header) +
887 sizeof(mpi_coredump->serdes2_xfi_hss_pll),
888 "XFI2 HSS PLL Registers");
890 status = qlge_get_serdes_regs(qdev, mpi_coredump);
892 netif_err(qdev, drv, qdev->ndev,
893 "Failed Dump of Serdes Registers. Status = 0x%.08x\n",
898 qlge_build_coredump_seg_header(&mpi_coredump->core_regs_seg_hdr,
900 sizeof(mpi_coredump->core_regs_seg_hdr) +
901 sizeof(mpi_coredump->mpi_core_regs) +
902 sizeof(mpi_coredump->mpi_core_sh_regs),
905 /* Get the MPI Core Registers */
906 status = qlge_get_mpi_regs(qdev, &mpi_coredump->mpi_core_regs[0],
907 MPI_CORE_REGS_ADDR, MPI_CORE_REGS_CNT);
910 /* Get the 16 MPI shadow registers */
911 status = qlge_get_mpi_shadow_regs(qdev,
912 &mpi_coredump->mpi_core_sh_regs[0]);
916 /* Get the Test Logic Registers */
917 qlge_build_coredump_seg_header(&mpi_coredump->test_logic_regs_seg_hdr,
919 sizeof(struct mpi_coredump_segment_header)
920 + sizeof(mpi_coredump->test_logic_regs),
922 status = qlge_get_mpi_regs(qdev, &mpi_coredump->test_logic_regs[0],
923 TEST_REGS_ADDR, TEST_REGS_CNT);
927 /* Get the RMII Registers */
928 qlge_build_coredump_seg_header(&mpi_coredump->rmii_regs_seg_hdr,
930 sizeof(struct mpi_coredump_segment_header)
931 + sizeof(mpi_coredump->rmii_regs),
933 status = qlge_get_mpi_regs(qdev, &mpi_coredump->rmii_regs[0],
934 RMII_REGS_ADDR, RMII_REGS_CNT);
938 /* Get the FCMAC1 Registers */
939 qlge_build_coredump_seg_header(&mpi_coredump->fcmac1_regs_seg_hdr,
941 sizeof(struct mpi_coredump_segment_header)
942 + sizeof(mpi_coredump->fcmac1_regs),
944 status = qlge_get_mpi_regs(qdev, &mpi_coredump->fcmac1_regs[0],
945 FCMAC1_REGS_ADDR, FCMAC_REGS_CNT);
949 /* Get the FCMAC2 Registers */
951 qlge_build_coredump_seg_header(&mpi_coredump->fcmac2_regs_seg_hdr,
953 sizeof(struct mpi_coredump_segment_header)
954 + sizeof(mpi_coredump->fcmac2_regs),
957 status = qlge_get_mpi_regs(qdev, &mpi_coredump->fcmac2_regs[0],
958 FCMAC2_REGS_ADDR, FCMAC_REGS_CNT);
962 /* Get the FC1 MBX Registers */
963 qlge_build_coredump_seg_header(&mpi_coredump->fc1_mbx_regs_seg_hdr,
965 sizeof(struct mpi_coredump_segment_header)
966 + sizeof(mpi_coredump->fc1_mbx_regs),
968 status = qlge_get_mpi_regs(qdev, &mpi_coredump->fc1_mbx_regs[0],
969 FC1_MBX_REGS_ADDR, FC_MBX_REGS_CNT);
973 /* Get the IDE Registers */
974 qlge_build_coredump_seg_header(&mpi_coredump->ide_regs_seg_hdr,
976 sizeof(struct mpi_coredump_segment_header)
977 + sizeof(mpi_coredump->ide_regs),
979 status = qlge_get_mpi_regs(qdev, &mpi_coredump->ide_regs[0],
980 IDE_REGS_ADDR, IDE_REGS_CNT);
984 /* Get the NIC1 MBX Registers */
985 qlge_build_coredump_seg_header(&mpi_coredump->nic1_mbx_regs_seg_hdr,
987 sizeof(struct mpi_coredump_segment_header)
988 + sizeof(mpi_coredump->nic1_mbx_regs),
990 status = qlge_get_mpi_regs(qdev, &mpi_coredump->nic1_mbx_regs[0],
991 NIC1_MBX_REGS_ADDR, NIC_MBX_REGS_CNT);
995 /* Get the SMBus Registers */
996 qlge_build_coredump_seg_header(&mpi_coredump->smbus_regs_seg_hdr,
998 sizeof(struct mpi_coredump_segment_header)
999 + sizeof(mpi_coredump->smbus_regs),
1001 status = qlge_get_mpi_regs(qdev, &mpi_coredump->smbus_regs[0],
1002 SMBUS_REGS_ADDR, SMBUS_REGS_CNT);
1006 /* Get the FC2 MBX Registers */
1007 qlge_build_coredump_seg_header(&mpi_coredump->fc2_mbx_regs_seg_hdr,
1009 sizeof(struct mpi_coredump_segment_header)
1010 + sizeof(mpi_coredump->fc2_mbx_regs),
1012 status = qlge_get_mpi_regs(qdev, &mpi_coredump->fc2_mbx_regs[0],
1013 FC2_MBX_REGS_ADDR, FC_MBX_REGS_CNT);
1017 /* Get the NIC2 MBX Registers */
1018 qlge_build_coredump_seg_header(&mpi_coredump->nic2_mbx_regs_seg_hdr,
1020 sizeof(struct mpi_coredump_segment_header)
1021 + sizeof(mpi_coredump->nic2_mbx_regs),
1023 status = qlge_get_mpi_regs(qdev, &mpi_coredump->nic2_mbx_regs[0],
1024 NIC2_MBX_REGS_ADDR, NIC_MBX_REGS_CNT);
1028 /* Get the I2C Registers */
1029 qlge_build_coredump_seg_header(&mpi_coredump->i2c_regs_seg_hdr,
1031 sizeof(struct mpi_coredump_segment_header)
1032 + sizeof(mpi_coredump->i2c_regs),
1034 status = qlge_get_mpi_regs(qdev, &mpi_coredump->i2c_regs[0],
1035 I2C_REGS_ADDR, I2C_REGS_CNT);
1039 /* Get the MEMC Registers */
1040 qlge_build_coredump_seg_header(&mpi_coredump->memc_regs_seg_hdr,
1042 sizeof(struct mpi_coredump_segment_header)
1043 + sizeof(mpi_coredump->memc_regs),
1045 status = qlge_get_mpi_regs(qdev, &mpi_coredump->memc_regs[0],
1046 MEMC_REGS_ADDR, MEMC_REGS_CNT);
1050 /* Get the PBus Registers */
1051 qlge_build_coredump_seg_header(&mpi_coredump->pbus_regs_seg_hdr,
1053 sizeof(struct mpi_coredump_segment_header)
1054 + sizeof(mpi_coredump->pbus_regs),
1056 status = qlge_get_mpi_regs(qdev, &mpi_coredump->pbus_regs[0],
1057 PBUS_REGS_ADDR, PBUS_REGS_CNT);
1061 /* Get the MDE Registers */
1062 qlge_build_coredump_seg_header(&mpi_coredump->mde_regs_seg_hdr,
1064 sizeof(struct mpi_coredump_segment_header)
1065 + sizeof(mpi_coredump->mde_regs),
1067 status = qlge_get_mpi_regs(qdev, &mpi_coredump->mde_regs[0],
1068 MDE_REGS_ADDR, MDE_REGS_CNT);
1072 qlge_build_coredump_seg_header(&mpi_coredump->misc_nic_seg_hdr,
1073 MISC_NIC_INFO_SEG_NUM,
1074 sizeof(struct mpi_coredump_segment_header)
1075 + sizeof(mpi_coredump->misc_nic_info),
1077 mpi_coredump->misc_nic_info.rx_ring_count = qdev->rx_ring_count;
1078 mpi_coredump->misc_nic_info.tx_ring_count = qdev->tx_ring_count;
1079 mpi_coredump->misc_nic_info.intr_count = qdev->intr_count;
1080 mpi_coredump->misc_nic_info.function = qdev->func;
1083 /* Get indexed register values. */
1084 qlge_build_coredump_seg_header(&mpi_coredump->intr_states_seg_hdr,
1085 INTR_STATES_SEG_NUM,
1086 sizeof(struct mpi_coredump_segment_header)
1087 + sizeof(mpi_coredump->intr_states),
1089 qlge_get_intr_states(qdev, &mpi_coredump->intr_states[0]);
1091 qlge_build_coredump_seg_header(&mpi_coredump->cam_entries_seg_hdr,
1092 CAM_ENTRIES_SEG_NUM,
1093 sizeof(struct mpi_coredump_segment_header)
1094 + sizeof(mpi_coredump->cam_entries),
1096 status = qlge_get_cam_entries(qdev, &mpi_coredump->cam_entries[0]);
1100 qlge_build_coredump_seg_header(&mpi_coredump->nic_routing_words_seg_hdr,
1101 ROUTING_WORDS_SEG_NUM,
1102 sizeof(struct mpi_coredump_segment_header)
1103 + sizeof(mpi_coredump->nic_routing_words),
1105 status = qlge_get_routing_entries(qdev,
1106 &mpi_coredump->nic_routing_words[0]);
1110 /* Segment 34 (Rev C. step 23) */
1111 qlge_build_coredump_seg_header(&mpi_coredump->ets_seg_hdr,
1113 sizeof(struct mpi_coredump_segment_header)
1114 + sizeof(mpi_coredump->ets),
1116 status = qlge_get_ets_regs(qdev, &mpi_coredump->ets[0]);
1120 qlge_build_coredump_seg_header(&mpi_coredump->probe_dump_seg_hdr,
1122 sizeof(struct mpi_coredump_segment_header)
1123 + sizeof(mpi_coredump->probe_dump),
1125 qlge_get_probe_dump(qdev, &mpi_coredump->probe_dump[0]);
1127 qlge_build_coredump_seg_header(&mpi_coredump->routing_reg_seg_hdr,
1128 ROUTING_INDEX_SEG_NUM,
1129 sizeof(struct mpi_coredump_segment_header)
1130 + sizeof(mpi_coredump->routing_regs),
1132 status = qlge_get_routing_index_registers(qdev,
1133 &mpi_coredump->routing_regs[0]);
1137 qlge_build_coredump_seg_header(&mpi_coredump->mac_prot_reg_seg_hdr,
1138 MAC_PROTOCOL_SEG_NUM,
1139 sizeof(struct mpi_coredump_segment_header)
1140 + sizeof(mpi_coredump->mac_prot_regs),
1142 qlge_get_mac_protocol_registers(qdev, &mpi_coredump->mac_prot_regs[0]);
1144 /* Get the semaphore registers for all 5 functions */
1145 qlge_build_coredump_seg_header(&mpi_coredump->sem_regs_seg_hdr,
1147 sizeof(struct mpi_coredump_segment_header) +
1148 sizeof(mpi_coredump->sem_regs), "Sem Registers");
1150 qlge_get_sem_registers(qdev, &mpi_coredump->sem_regs[0]);
1152 /* Prevent the mpi restarting while we dump the memory.*/
1153 qlge_write_mpi_reg(qdev, MPI_TEST_FUNC_RST_STS, MPI_TEST_FUNC_RST_FRC);
1155 /* clear the pause */
1156 status = qlge_unpause_mpi_risc(qdev);
1158 netif_err(qdev, drv, qdev->ndev,
1159 "Failed RISC unpause. Status = 0x%.08x\n", status);
1163 /* Reset the RISC so we can dump RAM */
1164 status = qlge_hard_reset_mpi_risc(qdev);
1166 netif_err(qdev, drv, qdev->ndev,
1167 "Failed RISC reset. Status = 0x%.08x\n", status);
1171 qlge_build_coredump_seg_header(&mpi_coredump->code_ram_seg_hdr,
1173 sizeof(struct mpi_coredump_segment_header)
1174 + sizeof(mpi_coredump->code_ram),
1176 status = qlge_dump_risc_ram_area(qdev, &mpi_coredump->code_ram[0],
1177 CODE_RAM_ADDR, CODE_RAM_CNT);
1179 netif_err(qdev, drv, qdev->ndev,
1180 "Failed Dump of CODE RAM. Status = 0x%.08x\n",
1185 /* Insert the segment header */
1186 qlge_build_coredump_seg_header(&mpi_coredump->memc_ram_seg_hdr,
1188 sizeof(struct mpi_coredump_segment_header)
1189 + sizeof(mpi_coredump->memc_ram),
1191 status = qlge_dump_risc_ram_area(qdev, &mpi_coredump->memc_ram[0],
1192 MEMC_RAM_ADDR, MEMC_RAM_CNT);
1194 netif_err(qdev, drv, qdev->ndev,
1195 "Failed Dump of MEMC RAM. Status = 0x%.08x\n",
1200 qlge_sem_unlock(qdev, SEM_PROC_REG_MASK); /* does flush too */
1204 static void qlge_get_core_dump(struct qlge_adapter *qdev)
1206 if (!qlge_own_firmware(qdev)) {
1207 netif_err(qdev, drv, qdev->ndev, "Don't own firmware!\n");
1211 if (!netif_running(qdev->ndev)) {
1212 netif_err(qdev, ifup, qdev->ndev,
1213 "Force Coredump can only be done from interface that is up\n");
1216 qlge_queue_fw_error(qdev);
1219 static void qlge_gen_reg_dump(struct qlge_adapter *qdev,
1220 struct qlge_reg_dump *mpi_coredump)
1224 memset(&(mpi_coredump->mpi_global_header), 0,
1225 sizeof(struct mpi_coredump_global_header));
1226 mpi_coredump->mpi_global_header.cookie = MPI_COREDUMP_COOKIE;
1227 mpi_coredump->mpi_global_header.header_size =
1228 sizeof(struct mpi_coredump_global_header);
1229 mpi_coredump->mpi_global_header.image_size =
1230 sizeof(struct qlge_reg_dump);
1231 strncpy(mpi_coredump->mpi_global_header.id_string, "MPI Coredump",
1232 sizeof(mpi_coredump->mpi_global_header.id_string));
1235 qlge_build_coredump_seg_header(&mpi_coredump->misc_nic_seg_hdr,
1236 MISC_NIC_INFO_SEG_NUM,
1237 sizeof(struct mpi_coredump_segment_header)
1238 + sizeof(mpi_coredump->misc_nic_info),
1240 mpi_coredump->misc_nic_info.rx_ring_count = qdev->rx_ring_count;
1241 mpi_coredump->misc_nic_info.tx_ring_count = qdev->tx_ring_count;
1242 mpi_coredump->misc_nic_info.intr_count = qdev->intr_count;
1243 mpi_coredump->misc_nic_info.function = qdev->func;
1245 /* Segment 16, Rev C. Step 18 */
1246 qlge_build_coredump_seg_header(&mpi_coredump->nic_regs_seg_hdr,
1247 NIC1_CONTROL_SEG_NUM,
1248 sizeof(struct mpi_coredump_segment_header)
1249 + sizeof(mpi_coredump->nic_regs),
1251 /* Get generic reg dump */
1252 for (i = 0; i < 64; i++)
1253 mpi_coredump->nic_regs[i] = qlge_read32(qdev, i * sizeof(u32));
1256 /* Get indexed register values. */
1257 qlge_build_coredump_seg_header(&mpi_coredump->intr_states_seg_hdr,
1258 INTR_STATES_SEG_NUM,
1259 sizeof(struct mpi_coredump_segment_header)
1260 + sizeof(mpi_coredump->intr_states),
1262 qlge_get_intr_states(qdev, &mpi_coredump->intr_states[0]);
1264 qlge_build_coredump_seg_header(&mpi_coredump->cam_entries_seg_hdr,
1265 CAM_ENTRIES_SEG_NUM,
1266 sizeof(struct mpi_coredump_segment_header)
1267 + sizeof(mpi_coredump->cam_entries),
1269 status = qlge_get_cam_entries(qdev, &mpi_coredump->cam_entries[0]);
1273 qlge_build_coredump_seg_header(&mpi_coredump->nic_routing_words_seg_hdr,
1274 ROUTING_WORDS_SEG_NUM,
1275 sizeof(struct mpi_coredump_segment_header)
1276 + sizeof(mpi_coredump->nic_routing_words),
1278 status = qlge_get_routing_entries(qdev,
1279 &mpi_coredump->nic_routing_words[0]);
1283 /* Segment 34 (Rev C. step 23) */
1284 qlge_build_coredump_seg_header(&mpi_coredump->ets_seg_hdr,
1286 sizeof(struct mpi_coredump_segment_header)
1287 + sizeof(mpi_coredump->ets),
1289 status = qlge_get_ets_regs(qdev, &mpi_coredump->ets[0]);
1294 void qlge_get_dump(struct qlge_adapter *qdev, void *buff)
1297 * If the dump has already been taken and is stored
1298 * in our internal buffer and if force dump is set then
1299 * just start the spool to dump it to the log file
1300 * and also, take a snapshot of the general regs
1301 * to the user's buffer or else take complete dump
1302 * to the user's buffer if force is not set.
1305 if (!test_bit(QL_FRC_COREDUMP, &qdev->flags)) {
1306 if (!qlge_core_dump(qdev, buff))
1307 qlge_soft_reset_mpi_risc(qdev);
1309 netif_err(qdev, drv, qdev->ndev, "coredump failed!\n");
1311 qlge_gen_reg_dump(qdev, buff);
1312 qlge_get_core_dump(qdev);