17e6ad469SVishal Kulkarni /*
27e6ad469SVishal Kulkarni * This file and its contents are supplied under the terms of the
37e6ad469SVishal Kulkarni * Common Development and Distribution License ("CDDL"), version 1.0.
47e6ad469SVishal Kulkarni * You may only use this file in accordance with the terms of version
57e6ad469SVishal Kulkarni * 1.0 of the CDDL.
67e6ad469SVishal Kulkarni *
77e6ad469SVishal Kulkarni * A full copy of the text of the CDDL should have accompanied this
87e6ad469SVishal Kulkarni * source. A copy of the CDDL is also available via the Internet at
97e6ad469SVishal Kulkarni * http://www.illumos.org/license/CDDL.
107e6ad469SVishal Kulkarni */
117e6ad469SVishal Kulkarni
127e6ad469SVishal Kulkarni /*-
137e6ad469SVishal Kulkarni * Copyright (c) 2019 Chelsio Communications, Inc.
147e6ad469SVishal Kulkarni * All rights reserved.
157e6ad469SVishal Kulkarni *
167e6ad469SVishal Kulkarni * Redistribution and use in source and binary forms, with or without
177e6ad469SVishal Kulkarni * modification, are permitted provided that the following conditions
187e6ad469SVishal Kulkarni * are met:
197e6ad469SVishal Kulkarni * 1. Redistributions of source code must retain the above copyright
207e6ad469SVishal Kulkarni * notice, this list of conditions and the following disclaimer.
217e6ad469SVishal Kulkarni * 2. Redistributions in binary form must reproduce the above copyright
227e6ad469SVishal Kulkarni * notice, this list of conditions and the following disclaimer in the
237e6ad469SVishal Kulkarni * documentation and/or other materials provided with the distribution.
247e6ad469SVishal Kulkarni *
257e6ad469SVishal Kulkarni * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
267e6ad469SVishal Kulkarni * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
277e6ad469SVishal Kulkarni * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
287e6ad469SVishal Kulkarni * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
297e6ad469SVishal Kulkarni * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
307e6ad469SVishal Kulkarni * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
317e6ad469SVishal Kulkarni * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
327e6ad469SVishal Kulkarni * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
337e6ad469SVishal Kulkarni * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
347e6ad469SVishal Kulkarni * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
357e6ad469SVishal Kulkarni * SUCH DAMAGE.
367e6ad469SVishal Kulkarni */
377e6ad469SVishal Kulkarni
387e6ad469SVishal Kulkarni #include <sys/types.h>
397e6ad469SVishal Kulkarni #include <sys/param.h>
407e6ad469SVishal Kulkarni
417e6ad469SVishal Kulkarni #include "common/common.h"
427e6ad469SVishal Kulkarni #include "common/t4_regs.h"
437e6ad469SVishal Kulkarni #include "common/t4_chip_type.h"
447e6ad469SVishal Kulkarni #include "cudbg.h"
457e6ad469SVishal Kulkarni #include "cudbg_lib_common.h"
467e6ad469SVishal Kulkarni #include "cudbg_lib.h"
477e6ad469SVishal Kulkarni #include "cudbg_entity.h"
487e6ad469SVishal Kulkarni
497e6ad469SVishal Kulkarni #define BUFFER_WARN_LIMIT 10000000
507e6ad469SVishal Kulkarni
517e6ad469SVishal Kulkarni struct large_entity large_entity_list[] = {
527e6ad469SVishal Kulkarni {CUDBG_EDC0, 0, 0},
537e6ad469SVishal Kulkarni {CUDBG_EDC1, 0 , 0},
547e6ad469SVishal Kulkarni {CUDBG_MC0, 0, 0},
557e6ad469SVishal Kulkarni {CUDBG_MC1, 0, 0}
567e6ad469SVishal Kulkarni };
577e6ad469SVishal Kulkarni
587e6ad469SVishal Kulkarni static int
is_fw_attached(struct cudbg_init * pdbg_init)597e6ad469SVishal Kulkarni is_fw_attached(struct cudbg_init *pdbg_init)
607e6ad469SVishal Kulkarni {
617e6ad469SVishal Kulkarni
627e6ad469SVishal Kulkarni return (pdbg_init->adap->flags & FW_OK);
637e6ad469SVishal Kulkarni }
647e6ad469SVishal Kulkarni
657e6ad469SVishal Kulkarni /* This function will add additional padding bytes into debug_buffer to make it
667e6ad469SVishal Kulkarni * 4 byte aligned.*/
677e6ad469SVishal Kulkarni static void
align_debug_buffer(struct cudbg_buffer * dbg_buff,struct cudbg_entity_hdr * entity_hdr)687e6ad469SVishal Kulkarni align_debug_buffer(struct cudbg_buffer *dbg_buff,
697e6ad469SVishal Kulkarni struct cudbg_entity_hdr *entity_hdr)
707e6ad469SVishal Kulkarni {
717e6ad469SVishal Kulkarni u8 zero_buf[4] = {0};
727e6ad469SVishal Kulkarni u8 padding, remain;
737e6ad469SVishal Kulkarni
747e6ad469SVishal Kulkarni remain = (dbg_buff->offset - entity_hdr->start_offset) % 4;
757e6ad469SVishal Kulkarni padding = 4 - remain;
767e6ad469SVishal Kulkarni if (remain) {
777e6ad469SVishal Kulkarni memcpy(((u8 *) dbg_buff->data) + dbg_buff->offset, &zero_buf,
787e6ad469SVishal Kulkarni padding);
797e6ad469SVishal Kulkarni dbg_buff->offset += padding;
807e6ad469SVishal Kulkarni entity_hdr->num_pad = padding;
817e6ad469SVishal Kulkarni }
827e6ad469SVishal Kulkarni
837e6ad469SVishal Kulkarni entity_hdr->size = dbg_buff->offset - entity_hdr->start_offset;
847e6ad469SVishal Kulkarni }
857e6ad469SVishal Kulkarni
867e6ad469SVishal Kulkarni static void
u32_swap(void * a,void * b,int size)877e6ad469SVishal Kulkarni u32_swap(void *a, void *b, int size)
887e6ad469SVishal Kulkarni {
897e6ad469SVishal Kulkarni u32 t = *(u32 *)a;
907e6ad469SVishal Kulkarni
917e6ad469SVishal Kulkarni *(u32 *)a = *(u32 *)b;
927e6ad469SVishal Kulkarni *(u32 *)b = t;
937e6ad469SVishal Kulkarni }
947e6ad469SVishal Kulkarni
957e6ad469SVishal Kulkarni static void
generic_swap(void * a1,void * b1,int size)967e6ad469SVishal Kulkarni generic_swap(void *a1, void *b1, int size)
977e6ad469SVishal Kulkarni {
987e6ad469SVishal Kulkarni u8 t;
997e6ad469SVishal Kulkarni u8 *a = (u8 *)a1;
1007e6ad469SVishal Kulkarni u8 *b = (u8 *)b1;
1017e6ad469SVishal Kulkarni
1027e6ad469SVishal Kulkarni do {
1037e6ad469SVishal Kulkarni t = *a;
1047e6ad469SVishal Kulkarni *(a++) = *b;
1057e6ad469SVishal Kulkarni *(b++) = t;
1067e6ad469SVishal Kulkarni } while (--size > 0);
1077e6ad469SVishal Kulkarni }
1087e6ad469SVishal Kulkarni
1097e6ad469SVishal Kulkarni static void
qsort(void * base_val,int num,int size,int (* cmp_func)(const void *,const void *),void (* swap_func)(void *,void *,int size))1107e6ad469SVishal Kulkarni qsort(void *base_val, int num, int size,
1117e6ad469SVishal Kulkarni int (*cmp_func)(const void *, const void *),
1127e6ad469SVishal Kulkarni void (*swap_func)(void *, void *, int size))
1137e6ad469SVishal Kulkarni {
1147e6ad469SVishal Kulkarni /* pre-scale counters for performance */
1157e6ad469SVishal Kulkarni int i = (num / 2 - 1) * size;
1167e6ad469SVishal Kulkarni int n = num * size;
1177e6ad469SVishal Kulkarni int c, r;
1187e6ad469SVishal Kulkarni u8 *base = (u8 *)base_val;
1197e6ad469SVishal Kulkarni
1207e6ad469SVishal Kulkarni if (!swap_func)
1217e6ad469SVishal Kulkarni swap_func = (size == 4 ? u32_swap : generic_swap);
1227e6ad469SVishal Kulkarni
1237e6ad469SVishal Kulkarni /* heapify */
1247e6ad469SVishal Kulkarni for (; i >= 0; i -= size) {
1257e6ad469SVishal Kulkarni for (r = i; r * 2 + size < n; r = c) {
1267e6ad469SVishal Kulkarni c = r * 2 + size;
1277e6ad469SVishal Kulkarni if (c < n - size &&
1287e6ad469SVishal Kulkarni cmp_func(base + c, base + c + size) < 0)
1297e6ad469SVishal Kulkarni c += size;
1307e6ad469SVishal Kulkarni if (cmp_func(base + r, base + c) >= 0)
1317e6ad469SVishal Kulkarni break;
1327e6ad469SVishal Kulkarni swap_func(base + r, base + c, size);
1337e6ad469SVishal Kulkarni }
1347e6ad469SVishal Kulkarni }
1357e6ad469SVishal Kulkarni
1367e6ad469SVishal Kulkarni /* sort */
1377e6ad469SVishal Kulkarni for (i = n - size; i > 0; i -= size) {
1387e6ad469SVishal Kulkarni swap_func(base, base + i, size);
1397e6ad469SVishal Kulkarni for (r = 0; r * 2 + size < i; r = c) {
1407e6ad469SVishal Kulkarni c = r * 2 + size;
1417e6ad469SVishal Kulkarni if (c < i - size &&
1427e6ad469SVishal Kulkarni cmp_func(base + c, base + c + size) < 0)
1437e6ad469SVishal Kulkarni c += size;
1447e6ad469SVishal Kulkarni if (cmp_func(base + r, base + c) >= 0)
1457e6ad469SVishal Kulkarni break;
1467e6ad469SVishal Kulkarni swap_func(base + r, base + c, size);
1477e6ad469SVishal Kulkarni }
1487e6ad469SVishal Kulkarni }
1497e6ad469SVishal Kulkarni }
1507e6ad469SVishal Kulkarni
1517e6ad469SVishal Kulkarni static void
read_sge_ctxt(struct cudbg_init * pdbg_init,u32 cid,enum ctxt_type ctype,u32 * data)1527e6ad469SVishal Kulkarni read_sge_ctxt(struct cudbg_init *pdbg_init, u32 cid,
1537e6ad469SVishal Kulkarni enum ctxt_type ctype, u32 *data)
1547e6ad469SVishal Kulkarni {
1557e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
1567e6ad469SVishal Kulkarni int rc = -1;
1577e6ad469SVishal Kulkarni
1587e6ad469SVishal Kulkarni if (is_fw_attached(pdbg_init)) {
1597e6ad469SVishal Kulkarni rc =begin_synchronized_op(padap->port[0], 1, 1);
1607e6ad469SVishal Kulkarni if (rc != 0)
1617e6ad469SVishal Kulkarni goto out;
1627e6ad469SVishal Kulkarni rc = t4_sge_ctxt_rd(padap, padap->mbox, cid, ctype,
1637e6ad469SVishal Kulkarni data);
1647e6ad469SVishal Kulkarni end_synchronized_op(padap->port[0], 1);
1657e6ad469SVishal Kulkarni }
1667e6ad469SVishal Kulkarni
1677e6ad469SVishal Kulkarni out:
1687e6ad469SVishal Kulkarni if (rc)
1697e6ad469SVishal Kulkarni t4_sge_ctxt_rd_bd(padap, cid, ctype, data);
1707e6ad469SVishal Kulkarni }
1717e6ad469SVishal Kulkarni
1727e6ad469SVishal Kulkarni static int
get_next_ext_entity_hdr(void * outbuf,u32 * ext_size,struct cudbg_buffer * dbg_buff,struct cudbg_entity_hdr ** entity_hdr)1737e6ad469SVishal Kulkarni get_next_ext_entity_hdr(void *outbuf, u32 *ext_size,
1747e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
1757e6ad469SVishal Kulkarni struct cudbg_entity_hdr **entity_hdr)
1767e6ad469SVishal Kulkarni {
1777e6ad469SVishal Kulkarni struct cudbg_hdr *cudbg_hdr = (struct cudbg_hdr *)outbuf;
1787e6ad469SVishal Kulkarni int rc = 0;
1797e6ad469SVishal Kulkarni u32 ext_offset = cudbg_hdr->data_len;
1807e6ad469SVishal Kulkarni *ext_size = 0;
1817e6ad469SVishal Kulkarni
1827e6ad469SVishal Kulkarni if (dbg_buff->size - dbg_buff->offset <=
1837e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr)) {
1847e6ad469SVishal Kulkarni rc = CUDBG_STATUS_BUFFER_SHORT;
1857e6ad469SVishal Kulkarni goto err;
1867e6ad469SVishal Kulkarni }
1877e6ad469SVishal Kulkarni
1887e6ad469SVishal Kulkarni *entity_hdr = (struct cudbg_entity_hdr *)
1897e6ad469SVishal Kulkarni ((char *)outbuf + cudbg_hdr->data_len);
1907e6ad469SVishal Kulkarni
1917e6ad469SVishal Kulkarni /* Find the last extended entity header */
1927e6ad469SVishal Kulkarni while ((*entity_hdr)->size) {
1937e6ad469SVishal Kulkarni
1947e6ad469SVishal Kulkarni ext_offset += sizeof(struct cudbg_entity_hdr) +
1957e6ad469SVishal Kulkarni (*entity_hdr)->size;
1967e6ad469SVishal Kulkarni
1977e6ad469SVishal Kulkarni *ext_size += (*entity_hdr)->size +
1987e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr);
1997e6ad469SVishal Kulkarni
2007e6ad469SVishal Kulkarni if (dbg_buff->size - dbg_buff->offset + *ext_size <=
2017e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr)) {
2027e6ad469SVishal Kulkarni rc = CUDBG_STATUS_BUFFER_SHORT;
2037e6ad469SVishal Kulkarni goto err;
2047e6ad469SVishal Kulkarni }
2057e6ad469SVishal Kulkarni
2067e6ad469SVishal Kulkarni if (ext_offset != (*entity_hdr)->next_ext_offset) {
2077e6ad469SVishal Kulkarni ext_offset -= sizeof(struct cudbg_entity_hdr) +
2087e6ad469SVishal Kulkarni (*entity_hdr)->size;
2097e6ad469SVishal Kulkarni break;
2107e6ad469SVishal Kulkarni }
2117e6ad469SVishal Kulkarni
2127e6ad469SVishal Kulkarni (*entity_hdr)->next_ext_offset = *ext_size;
2137e6ad469SVishal Kulkarni
2147e6ad469SVishal Kulkarni *entity_hdr = (struct cudbg_entity_hdr *)
2157e6ad469SVishal Kulkarni ((char *)outbuf +
2167e6ad469SVishal Kulkarni ext_offset);
2177e6ad469SVishal Kulkarni }
2187e6ad469SVishal Kulkarni
2197e6ad469SVishal Kulkarni /* update the data offset */
2207e6ad469SVishal Kulkarni dbg_buff->offset = ext_offset;
2217e6ad469SVishal Kulkarni err:
2227e6ad469SVishal Kulkarni return rc;
2237e6ad469SVishal Kulkarni }
2247e6ad469SVishal Kulkarni
2257e6ad469SVishal Kulkarni static int
wr_entity_to_flash(void * handle,struct cudbg_buffer * dbg_buff,u32 cur_entity_data_offset,u32 cur_entity_size,int entity_nu,u32 ext_size)2267e6ad469SVishal Kulkarni wr_entity_to_flash(void *handle, struct cudbg_buffer *dbg_buff,
2277e6ad469SVishal Kulkarni u32 cur_entity_data_offset,
2287e6ad469SVishal Kulkarni u32 cur_entity_size,
2297e6ad469SVishal Kulkarni int entity_nu, u32 ext_size)
2307e6ad469SVishal Kulkarni {
2317e6ad469SVishal Kulkarni struct cudbg_private *priv = handle;
2327e6ad469SVishal Kulkarni struct cudbg_init *cudbg_init = &priv->dbg_init;
2337e6ad469SVishal Kulkarni struct cudbg_flash_sec_info *sec_info = &priv->sec_info;
2347e6ad469SVishal Kulkarni struct adapter *adap = cudbg_init->adap;
2357e6ad469SVishal Kulkarni u64 timestamp;
2367e6ad469SVishal Kulkarni u32 cur_entity_hdr_offset = sizeof(struct cudbg_hdr);
2377e6ad469SVishal Kulkarni u32 remain_flash_size;
2387e6ad469SVishal Kulkarni u32 flash_data_offset;
2397e6ad469SVishal Kulkarni u32 data_hdr_size;
2407e6ad469SVishal Kulkarni int rc = -1;
2417e6ad469SVishal Kulkarni
2427e6ad469SVishal Kulkarni data_hdr_size = CUDBG_MAX_ENTITY * sizeof(struct cudbg_entity_hdr) +
2437e6ad469SVishal Kulkarni sizeof(struct cudbg_hdr);
2447e6ad469SVishal Kulkarni
2457e6ad469SVishal Kulkarni flash_data_offset = (FLASH_CUDBG_NSECS *
2467e6ad469SVishal Kulkarni (sizeof(struct cudbg_flash_hdr) +
2477e6ad469SVishal Kulkarni data_hdr_size)) +
2487e6ad469SVishal Kulkarni (cur_entity_data_offset - data_hdr_size);
2497e6ad469SVishal Kulkarni
2507e6ad469SVishal Kulkarni if (flash_data_offset > CUDBG_FLASH_SIZE) {
2517e6ad469SVishal Kulkarni update_skip_size(sec_info, cur_entity_size);
2527e6ad469SVishal Kulkarni if (cudbg_init->verbose)
2537e6ad469SVishal Kulkarni cudbg_init->print(adap->dip, CE_NOTE,
2547e6ad469SVishal Kulkarni "Large entity skipping...\n");
2557e6ad469SVishal Kulkarni return rc;
2567e6ad469SVishal Kulkarni }
2577e6ad469SVishal Kulkarni
2587e6ad469SVishal Kulkarni remain_flash_size = CUDBG_FLASH_SIZE - flash_data_offset;
2597e6ad469SVishal Kulkarni
2607e6ad469SVishal Kulkarni if (cur_entity_size > remain_flash_size) {
2617e6ad469SVishal Kulkarni update_skip_size(sec_info, cur_entity_size);
2627e6ad469SVishal Kulkarni if (cudbg_init->verbose)
2637e6ad469SVishal Kulkarni cudbg_init->print(adap->dip, CE_NOTE,
2647e6ad469SVishal Kulkarni "Large entity skipping...\n");
2657e6ad469SVishal Kulkarni } else {
2667e6ad469SVishal Kulkarni timestamp = 0;
2677e6ad469SVishal Kulkarni
2687e6ad469SVishal Kulkarni cur_entity_hdr_offset +=
2697e6ad469SVishal Kulkarni (sizeof(struct cudbg_entity_hdr) *
2707e6ad469SVishal Kulkarni (entity_nu - 1));
2717e6ad469SVishal Kulkarni
2727e6ad469SVishal Kulkarni rc = cudbg_write_flash(handle, timestamp, dbg_buff,
2737e6ad469SVishal Kulkarni cur_entity_data_offset,
2747e6ad469SVishal Kulkarni cur_entity_hdr_offset,
2757e6ad469SVishal Kulkarni cur_entity_size,
2767e6ad469SVishal Kulkarni ext_size);
2777e6ad469SVishal Kulkarni if (rc == CUDBG_STATUS_FLASH_FULL && cudbg_init->verbose)
2787e6ad469SVishal Kulkarni cudbg_init->print(adap->dip, CE_NOTE,
2797e6ad469SVishal Kulkarni "\n\tFLASH is full... "
2807e6ad469SVishal Kulkarni "can not write in flash more\n\n");
2817e6ad469SVishal Kulkarni }
2827e6ad469SVishal Kulkarni
2837e6ad469SVishal Kulkarni return rc;
2847e6ad469SVishal Kulkarni }
2857e6ad469SVishal Kulkarni
2867e6ad469SVishal Kulkarni int
cudbg_collect(void * handle,void * outbuf,u32 * outbuf_size)2877e6ad469SVishal Kulkarni cudbg_collect(void *handle, void *outbuf, u32 *outbuf_size)
2887e6ad469SVishal Kulkarni {
2897e6ad469SVishal Kulkarni struct cudbg_entity_hdr *entity_hdr = NULL;
2907e6ad469SVishal Kulkarni struct cudbg_entity_hdr *ext_entity_hdr = NULL;
2917e6ad469SVishal Kulkarni struct cudbg_hdr *cudbg_hdr;
2927e6ad469SVishal Kulkarni struct cudbg_buffer dbg_buff;
2937e6ad469SVishal Kulkarni struct cudbg_error cudbg_err = {0};
2947e6ad469SVishal Kulkarni int large_entity_code;
2957e6ad469SVishal Kulkarni
2967e6ad469SVishal Kulkarni u8 *dbg_bitmap = ((struct cudbg_private *)handle)->dbg_init.dbg_bitmap;
2977e6ad469SVishal Kulkarni struct cudbg_init *cudbg_init =
2987e6ad469SVishal Kulkarni &(((struct cudbg_private *)handle)->dbg_init);
2997e6ad469SVishal Kulkarni struct adapter *padap = cudbg_init->adap;
3007e6ad469SVishal Kulkarni u32 total_size, remaining_buf_size;
3017e6ad469SVishal Kulkarni u32 ext_size = 0;
3027e6ad469SVishal Kulkarni int index, bit, i, rc = -1;
3037e6ad469SVishal Kulkarni int all;
3047e6ad469SVishal Kulkarni bool flag_ext = 0;
3057e6ad469SVishal Kulkarni
3067e6ad469SVishal Kulkarni reset_skip_entity();
3077e6ad469SVishal Kulkarni
3087e6ad469SVishal Kulkarni dbg_buff.data = outbuf;
3097e6ad469SVishal Kulkarni dbg_buff.size = *outbuf_size;
3107e6ad469SVishal Kulkarni dbg_buff.offset = 0;
3117e6ad469SVishal Kulkarni
3127e6ad469SVishal Kulkarni cudbg_hdr = (struct cudbg_hdr *)dbg_buff.data;
3137e6ad469SVishal Kulkarni cudbg_hdr->signature = CUDBG_SIGNATURE;
3147e6ad469SVishal Kulkarni cudbg_hdr->hdr_len = sizeof(struct cudbg_hdr);
3157e6ad469SVishal Kulkarni cudbg_hdr->major_ver = CUDBG_MAJOR_VERSION;
3167e6ad469SVishal Kulkarni cudbg_hdr->minor_ver = CUDBG_MINOR_VERSION;
3177e6ad469SVishal Kulkarni cudbg_hdr->max_entities = CUDBG_MAX_ENTITY;
3187e6ad469SVishal Kulkarni cudbg_hdr->chip_ver = padap->params.chip;
3197e6ad469SVishal Kulkarni
3207e6ad469SVishal Kulkarni if (cudbg_hdr->data_len)
3217e6ad469SVishal Kulkarni flag_ext = 1;
3227e6ad469SVishal Kulkarni
3237e6ad469SVishal Kulkarni if (sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY >
3247e6ad469SVishal Kulkarni dbg_buff.size) {
3257e6ad469SVishal Kulkarni rc = CUDBG_STATUS_SMALL_BUFF;
3267e6ad469SVishal Kulkarni total_size = cudbg_hdr->hdr_len;
3277e6ad469SVishal Kulkarni goto err;
3287e6ad469SVishal Kulkarni }
3297e6ad469SVishal Kulkarni
3307e6ad469SVishal Kulkarni /* If ext flag is set then move the offset to the end of the buf
3317e6ad469SVishal Kulkarni * so that we can add ext entities
3327e6ad469SVishal Kulkarni */
3337e6ad469SVishal Kulkarni if (flag_ext) {
3347e6ad469SVishal Kulkarni ext_entity_hdr = (struct cudbg_entity_hdr *)
3357e6ad469SVishal Kulkarni ((char *)outbuf + cudbg_hdr->hdr_len +
3367e6ad469SVishal Kulkarni (sizeof(struct cudbg_entity_hdr) *
3377e6ad469SVishal Kulkarni (CUDBG_EXT_ENTITY - 1)));
3387e6ad469SVishal Kulkarni ext_entity_hdr->start_offset = cudbg_hdr->data_len;
3397e6ad469SVishal Kulkarni ext_entity_hdr->entity_type = CUDBG_EXT_ENTITY;
3407e6ad469SVishal Kulkarni ext_entity_hdr->size = 0;
3417e6ad469SVishal Kulkarni dbg_buff.offset = cudbg_hdr->data_len;
3427e6ad469SVishal Kulkarni } else {
3437e6ad469SVishal Kulkarni dbg_buff.offset += cudbg_hdr->hdr_len; /* move 24 bytes*/
3447e6ad469SVishal Kulkarni dbg_buff.offset += CUDBG_MAX_ENTITY *
3457e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr);
3467e6ad469SVishal Kulkarni }
3477e6ad469SVishal Kulkarni
3487e6ad469SVishal Kulkarni total_size = dbg_buff.offset;
3497e6ad469SVishal Kulkarni all = dbg_bitmap[0] & (1 << CUDBG_ALL);
3507e6ad469SVishal Kulkarni
3517e6ad469SVishal Kulkarni for (i = 1; i < CUDBG_MAX_ENTITY; i++) {
3527e6ad469SVishal Kulkarni index = i / 8;
3537e6ad469SVishal Kulkarni bit = i % 8;
3547e6ad469SVishal Kulkarni
3557e6ad469SVishal Kulkarni if (entity_list[i].bit == CUDBG_EXT_ENTITY)
3567e6ad469SVishal Kulkarni continue;
3577e6ad469SVishal Kulkarni
3587e6ad469SVishal Kulkarni if (all || (dbg_bitmap[index] & (1 << bit))) {
3597e6ad469SVishal Kulkarni
3607e6ad469SVishal Kulkarni if (!flag_ext) {
3617e6ad469SVishal Kulkarni rc = get_entity_hdr(outbuf, i, dbg_buff.size,
3627e6ad469SVishal Kulkarni &entity_hdr);
3637e6ad469SVishal Kulkarni if (rc)
3647e6ad469SVishal Kulkarni cudbg_hdr->hdr_flags = rc;
3657e6ad469SVishal Kulkarni } else {
3667e6ad469SVishal Kulkarni rc = get_next_ext_entity_hdr(outbuf, &ext_size,
3677e6ad469SVishal Kulkarni &dbg_buff,
3687e6ad469SVishal Kulkarni &entity_hdr);
3697e6ad469SVishal Kulkarni if (rc)
3707e6ad469SVishal Kulkarni goto err;
3717e6ad469SVishal Kulkarni
3727e6ad469SVishal Kulkarni /* move the offset after the ext header */
3737e6ad469SVishal Kulkarni dbg_buff.offset +=
3747e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr);
3757e6ad469SVishal Kulkarni }
3767e6ad469SVishal Kulkarni
3777e6ad469SVishal Kulkarni entity_hdr->entity_type = i;
3787e6ad469SVishal Kulkarni entity_hdr->start_offset = dbg_buff.offset;
3797e6ad469SVishal Kulkarni /* process each entity by calling process_entity fp */
3807e6ad469SVishal Kulkarni remaining_buf_size = dbg_buff.size - dbg_buff.offset;
3817e6ad469SVishal Kulkarni
3827e6ad469SVishal Kulkarni if ((remaining_buf_size <= BUFFER_WARN_LIMIT) &&
3837e6ad469SVishal Kulkarni is_large_entity(i)) {
3847e6ad469SVishal Kulkarni if (cudbg_init->verbose)
3857e6ad469SVishal Kulkarni cudbg_init->print(padap->dip, CE_NOTE,
3867e6ad469SVishal Kulkarni "Skipping %s\n",
3877e6ad469SVishal Kulkarni entity_list[i].name);
3887e6ad469SVishal Kulkarni skip_entity(i);
3897e6ad469SVishal Kulkarni continue;
3907e6ad469SVishal Kulkarni } else {
3917e6ad469SVishal Kulkarni
3927e6ad469SVishal Kulkarni /* If fw_attach is 0, then skip entities which
3937e6ad469SVishal Kulkarni * communicates with firmware
3947e6ad469SVishal Kulkarni */
3957e6ad469SVishal Kulkarni
3967e6ad469SVishal Kulkarni if (!is_fw_attached(cudbg_init) &&
3977e6ad469SVishal Kulkarni (entity_list[i].flag &
3987e6ad469SVishal Kulkarni (1 << ENTITY_FLAG_FW_NO_ATTACH))) {
3997e6ad469SVishal Kulkarni if (cudbg_init->verbose)
4007e6ad469SVishal Kulkarni cudbg_init->print(padap->dip, CE_NOTE,
4017e6ad469SVishal Kulkarni "Skipping %s entity,"\
4027e6ad469SVishal Kulkarni "because fw_attach "\
4037e6ad469SVishal Kulkarni "is 0\n",
4047e6ad469SVishal Kulkarni entity_list[i].name);
4057e6ad469SVishal Kulkarni continue;
4067e6ad469SVishal Kulkarni }
4077e6ad469SVishal Kulkarni
4087e6ad469SVishal Kulkarni if (cudbg_init->verbose)
4097e6ad469SVishal Kulkarni cudbg_init->print(padap->dip, CE_NOTE,
4107e6ad469SVishal Kulkarni "collecting debug entity: "\
4117e6ad469SVishal Kulkarni "%s\n", entity_list[i].name);
4127e6ad469SVishal Kulkarni memset(&cudbg_err, 0,
4137e6ad469SVishal Kulkarni sizeof(struct cudbg_error));
4147e6ad469SVishal Kulkarni rc = process_entity[i-1](cudbg_init, &dbg_buff,
4157e6ad469SVishal Kulkarni &cudbg_err);
4167e6ad469SVishal Kulkarni }
4177e6ad469SVishal Kulkarni
4187e6ad469SVishal Kulkarni if (rc) {
4197e6ad469SVishal Kulkarni entity_hdr->size = 0;
4207e6ad469SVishal Kulkarni dbg_buff.offset = entity_hdr->start_offset;
4217e6ad469SVishal Kulkarni } else
4227e6ad469SVishal Kulkarni align_debug_buffer(&dbg_buff, entity_hdr);
4237e6ad469SVishal Kulkarni
4247e6ad469SVishal Kulkarni if (cudbg_err.sys_err)
4257e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
4267e6ad469SVishal Kulkarni
4277e6ad469SVishal Kulkarni entity_hdr->hdr_flags = rc;
4287e6ad469SVishal Kulkarni entity_hdr->sys_err = cudbg_err.sys_err;
4297e6ad469SVishal Kulkarni entity_hdr->sys_warn = cudbg_err.sys_warn;
4307e6ad469SVishal Kulkarni
4317e6ad469SVishal Kulkarni /* We don't want to include ext entity size in global
4327e6ad469SVishal Kulkarni * header
4337e6ad469SVishal Kulkarni */
4347e6ad469SVishal Kulkarni if (!flag_ext)
4357e6ad469SVishal Kulkarni total_size += entity_hdr->size;
4367e6ad469SVishal Kulkarni
4377e6ad469SVishal Kulkarni cudbg_hdr->data_len = total_size;
4387e6ad469SVishal Kulkarni *outbuf_size = total_size;
4397e6ad469SVishal Kulkarni
4407e6ad469SVishal Kulkarni /* consider the size of the ext entity header and data
4417e6ad469SVishal Kulkarni * also
4427e6ad469SVishal Kulkarni */
4437e6ad469SVishal Kulkarni if (flag_ext) {
4447e6ad469SVishal Kulkarni ext_size += (sizeof(struct cudbg_entity_hdr) +
4457e6ad469SVishal Kulkarni entity_hdr->size);
4467e6ad469SVishal Kulkarni entity_hdr->start_offset -= cudbg_hdr->data_len;
4477e6ad469SVishal Kulkarni ext_entity_hdr->size = ext_size;
4487e6ad469SVishal Kulkarni entity_hdr->next_ext_offset = ext_size;
4497e6ad469SVishal Kulkarni entity_hdr->flag |= CUDBG_EXT_DATA_VALID;
4507e6ad469SVishal Kulkarni }
4517e6ad469SVishal Kulkarni
4527e6ad469SVishal Kulkarni if (cudbg_init->use_flash) {
4537e6ad469SVishal Kulkarni if (flag_ext) {
4547e6ad469SVishal Kulkarni wr_entity_to_flash(handle,
4557e6ad469SVishal Kulkarni &dbg_buff,
4567e6ad469SVishal Kulkarni ext_entity_hdr->
4577e6ad469SVishal Kulkarni start_offset,
4587e6ad469SVishal Kulkarni entity_hdr->
4597e6ad469SVishal Kulkarni size,
4607e6ad469SVishal Kulkarni CUDBG_EXT_ENTITY,
4617e6ad469SVishal Kulkarni ext_size);
4627e6ad469SVishal Kulkarni }
4637e6ad469SVishal Kulkarni else
4647e6ad469SVishal Kulkarni wr_entity_to_flash(handle,
4657e6ad469SVishal Kulkarni &dbg_buff,
4667e6ad469SVishal Kulkarni entity_hdr->\
4677e6ad469SVishal Kulkarni start_offset,
4687e6ad469SVishal Kulkarni entity_hdr->size,
4697e6ad469SVishal Kulkarni i, ext_size);
4707e6ad469SVishal Kulkarni }
4717e6ad469SVishal Kulkarni }
4727e6ad469SVishal Kulkarni }
4737e6ad469SVishal Kulkarni
4747e6ad469SVishal Kulkarni for (i = 0; i < sizeof(large_entity_list) / sizeof(struct large_entity);
4757e6ad469SVishal Kulkarni i++) {
4767e6ad469SVishal Kulkarni large_entity_code = large_entity_list[i].entity_code;
4777e6ad469SVishal Kulkarni if (large_entity_list[i].skip_flag) {
4787e6ad469SVishal Kulkarni if (!flag_ext) {
4797e6ad469SVishal Kulkarni rc = get_entity_hdr(outbuf, large_entity_code,
4807e6ad469SVishal Kulkarni dbg_buff.size, &entity_hdr);
4817e6ad469SVishal Kulkarni if (rc)
4827e6ad469SVishal Kulkarni cudbg_hdr->hdr_flags = rc;
4837e6ad469SVishal Kulkarni } else {
4847e6ad469SVishal Kulkarni rc = get_next_ext_entity_hdr(outbuf, &ext_size,
4857e6ad469SVishal Kulkarni &dbg_buff,
4867e6ad469SVishal Kulkarni &entity_hdr);
4877e6ad469SVishal Kulkarni if (rc)
4887e6ad469SVishal Kulkarni goto err;
4897e6ad469SVishal Kulkarni
4907e6ad469SVishal Kulkarni dbg_buff.offset +=
4917e6ad469SVishal Kulkarni sizeof(struct cudbg_entity_hdr);
4927e6ad469SVishal Kulkarni }
4937e6ad469SVishal Kulkarni
4947e6ad469SVishal Kulkarni /* If fw_attach is 0, then skip entities which
4957e6ad469SVishal Kulkarni * communicates with firmware
4967e6ad469SVishal Kulkarni */
4977e6ad469SVishal Kulkarni if (!is_fw_attached(cudbg_init) &&
4987e6ad469SVishal Kulkarni (entity_list[large_entity_code].flag &
4997e6ad469SVishal Kulkarni (1 << ENTITY_FLAG_FW_NO_ATTACH))) {
5007e6ad469SVishal Kulkarni if (cudbg_init->verbose)
5017e6ad469SVishal Kulkarni cudbg_init->print(padap->dip, CE_NOTE,
5027e6ad469SVishal Kulkarni "Skipping %s entity,"\
5037e6ad469SVishal Kulkarni "because fw_attach "\
5047e6ad469SVishal Kulkarni "is 0\n",
5057e6ad469SVishal Kulkarni entity_list[large_entity_code]
5067e6ad469SVishal Kulkarni .name);
5077e6ad469SVishal Kulkarni continue;
5087e6ad469SVishal Kulkarni }
5097e6ad469SVishal Kulkarni
5107e6ad469SVishal Kulkarni entity_hdr->entity_type = large_entity_code;
5117e6ad469SVishal Kulkarni entity_hdr->start_offset = dbg_buff.offset;
5127e6ad469SVishal Kulkarni if (cudbg_init->verbose)
5137e6ad469SVishal Kulkarni cudbg_init->print(padap->dip, CE_NOTE,
5147e6ad469SVishal Kulkarni "Re-trying debug entity: %s\n",
5157e6ad469SVishal Kulkarni entity_list[large_entity_code].name);
5167e6ad469SVishal Kulkarni
5177e6ad469SVishal Kulkarni memset(&cudbg_err, 0, sizeof(struct cudbg_error));
5187e6ad469SVishal Kulkarni rc = process_entity[large_entity_code - 1](cudbg_init,
5197e6ad469SVishal Kulkarni &dbg_buff,
5207e6ad469SVishal Kulkarni &cudbg_err);
5217e6ad469SVishal Kulkarni if (rc) {
5227e6ad469SVishal Kulkarni entity_hdr->size = 0;
5237e6ad469SVishal Kulkarni dbg_buff.offset = entity_hdr->start_offset;
5247e6ad469SVishal Kulkarni } else
5257e6ad469SVishal Kulkarni align_debug_buffer(&dbg_buff, entity_hdr);
5267e6ad469SVishal Kulkarni
5277e6ad469SVishal Kulkarni if (cudbg_err.sys_err)
5287e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
5297e6ad469SVishal Kulkarni
5307e6ad469SVishal Kulkarni entity_hdr->hdr_flags = rc;
5317e6ad469SVishal Kulkarni entity_hdr->sys_err = cudbg_err.sys_err;
5327e6ad469SVishal Kulkarni entity_hdr->sys_warn = cudbg_err.sys_warn;
5337e6ad469SVishal Kulkarni
5347e6ad469SVishal Kulkarni /* We don't want to include ext entity size in global
5357e6ad469SVishal Kulkarni * header
5367e6ad469SVishal Kulkarni */
5377e6ad469SVishal Kulkarni if (!flag_ext)
5387e6ad469SVishal Kulkarni total_size += entity_hdr->size;
5397e6ad469SVishal Kulkarni
5407e6ad469SVishal Kulkarni cudbg_hdr->data_len = total_size;
5417e6ad469SVishal Kulkarni *outbuf_size = total_size;
5427e6ad469SVishal Kulkarni
5437e6ad469SVishal Kulkarni /* consider the size of the ext entity header and
5447e6ad469SVishal Kulkarni * data also
5457e6ad469SVishal Kulkarni */
5467e6ad469SVishal Kulkarni if (flag_ext) {
5477e6ad469SVishal Kulkarni ext_size += (sizeof(struct cudbg_entity_hdr) +
5487e6ad469SVishal Kulkarni entity_hdr->size);
5497e6ad469SVishal Kulkarni entity_hdr->start_offset -=
5507e6ad469SVishal Kulkarni cudbg_hdr->data_len;
5517e6ad469SVishal Kulkarni ext_entity_hdr->size = ext_size;
5527e6ad469SVishal Kulkarni entity_hdr->flag |= CUDBG_EXT_DATA_VALID;
5537e6ad469SVishal Kulkarni }
5547e6ad469SVishal Kulkarni
5557e6ad469SVishal Kulkarni if (cudbg_init->use_flash) {
5567e6ad469SVishal Kulkarni if (flag_ext)
5577e6ad469SVishal Kulkarni wr_entity_to_flash(handle,
5587e6ad469SVishal Kulkarni &dbg_buff,
5597e6ad469SVishal Kulkarni ext_entity_hdr->
5607e6ad469SVishal Kulkarni start_offset,
5617e6ad469SVishal Kulkarni entity_hdr->size,
5627e6ad469SVishal Kulkarni CUDBG_EXT_ENTITY,
5637e6ad469SVishal Kulkarni ext_size);
5647e6ad469SVishal Kulkarni else
5657e6ad469SVishal Kulkarni wr_entity_to_flash(handle,
5667e6ad469SVishal Kulkarni &dbg_buff,
5677e6ad469SVishal Kulkarni entity_hdr->
5687e6ad469SVishal Kulkarni start_offset,
5697e6ad469SVishal Kulkarni entity_hdr->
5707e6ad469SVishal Kulkarni size,
5717e6ad469SVishal Kulkarni large_entity_list[i].
5727e6ad469SVishal Kulkarni entity_code,
5737e6ad469SVishal Kulkarni ext_size);
5747e6ad469SVishal Kulkarni }
5757e6ad469SVishal Kulkarni }
5767e6ad469SVishal Kulkarni }
5777e6ad469SVishal Kulkarni
5787e6ad469SVishal Kulkarni cudbg_hdr->data_len = total_size;
5797e6ad469SVishal Kulkarni *outbuf_size = total_size;
5807e6ad469SVishal Kulkarni
5817e6ad469SVishal Kulkarni if (flag_ext)
5827e6ad469SVishal Kulkarni *outbuf_size += ext_size;
5837e6ad469SVishal Kulkarni
5847e6ad469SVishal Kulkarni return 0;
5857e6ad469SVishal Kulkarni err:
5867e6ad469SVishal Kulkarni return rc;
5877e6ad469SVishal Kulkarni }
5887e6ad469SVishal Kulkarni
5897e6ad469SVishal Kulkarni void
reset_skip_entity(void)5907e6ad469SVishal Kulkarni reset_skip_entity(void)
5917e6ad469SVishal Kulkarni {
5927e6ad469SVishal Kulkarni int i;
5937e6ad469SVishal Kulkarni
5947e6ad469SVishal Kulkarni for (i = 0; i < ARRAY_SIZE(large_entity_list); i++)
5957e6ad469SVishal Kulkarni large_entity_list[i].skip_flag = 0;
5967e6ad469SVishal Kulkarni }
5977e6ad469SVishal Kulkarni
5987e6ad469SVishal Kulkarni void
skip_entity(int entity_code)5997e6ad469SVishal Kulkarni skip_entity(int entity_code)
6007e6ad469SVishal Kulkarni {
6017e6ad469SVishal Kulkarni int i;
6027e6ad469SVishal Kulkarni for (i = 0; i < sizeof(large_entity_list) / sizeof(struct large_entity);
6037e6ad469SVishal Kulkarni i++) {
6047e6ad469SVishal Kulkarni if (large_entity_list[i].entity_code == entity_code)
6057e6ad469SVishal Kulkarni large_entity_list[i].skip_flag = 1;
6067e6ad469SVishal Kulkarni }
6077e6ad469SVishal Kulkarni }
6087e6ad469SVishal Kulkarni
6097e6ad469SVishal Kulkarni int
is_large_entity(int entity_code)6107e6ad469SVishal Kulkarni is_large_entity(int entity_code)
6117e6ad469SVishal Kulkarni {
6127e6ad469SVishal Kulkarni int i;
6137e6ad469SVishal Kulkarni
6147e6ad469SVishal Kulkarni for (i = 0; i < sizeof(large_entity_list) / sizeof(struct large_entity);
6157e6ad469SVishal Kulkarni i++) {
6167e6ad469SVishal Kulkarni if (large_entity_list[i].entity_code == entity_code)
6177e6ad469SVishal Kulkarni return 1;
6187e6ad469SVishal Kulkarni }
6197e6ad469SVishal Kulkarni return 0;
6207e6ad469SVishal Kulkarni }
6217e6ad469SVishal Kulkarni
6227e6ad469SVishal Kulkarni int
get_entity_hdr(void * outbuf,int i,u32 size,struct cudbg_entity_hdr ** entity_hdr)6237e6ad469SVishal Kulkarni get_entity_hdr(void *outbuf, int i, u32 size,
6247e6ad469SVishal Kulkarni struct cudbg_entity_hdr **entity_hdr)
6257e6ad469SVishal Kulkarni {
6267e6ad469SVishal Kulkarni int rc = 0;
6277e6ad469SVishal Kulkarni struct cudbg_hdr *cudbg_hdr = (struct cudbg_hdr *)outbuf;
6287e6ad469SVishal Kulkarni
6297e6ad469SVishal Kulkarni if (cudbg_hdr->hdr_len + (sizeof(struct cudbg_entity_hdr)*i) > size)
6307e6ad469SVishal Kulkarni return CUDBG_STATUS_SMALL_BUFF;
6317e6ad469SVishal Kulkarni
6327e6ad469SVishal Kulkarni *entity_hdr = (struct cudbg_entity_hdr *)
6337e6ad469SVishal Kulkarni ((char *)outbuf+cudbg_hdr->hdr_len +
6347e6ad469SVishal Kulkarni (sizeof(struct cudbg_entity_hdr)*(i-1)));
6357e6ad469SVishal Kulkarni return rc;
6367e6ad469SVishal Kulkarni }
6377e6ad469SVishal Kulkarni
6387e6ad469SVishal Kulkarni static int
collect_rss(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)6397e6ad469SVishal Kulkarni collect_rss(struct cudbg_init *pdbg_init,
6407e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
6417e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
6427e6ad469SVishal Kulkarni {
6437e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
6447e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
6457e6ad469SVishal Kulkarni u32 size;
6467e6ad469SVishal Kulkarni int rc = 0;
6477e6ad469SVishal Kulkarni
6487e6ad469SVishal Kulkarni size = RSS_NENTRIES * sizeof(u16);
6497e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
6507e6ad469SVishal Kulkarni if (rc)
6517e6ad469SVishal Kulkarni goto err;
6527e6ad469SVishal Kulkarni
6537e6ad469SVishal Kulkarni rc = t4_read_rss(padap, (u16 *)scratch_buff.data);
6547e6ad469SVishal Kulkarni if (rc) {
6557e6ad469SVishal Kulkarni if (pdbg_init->verbose)
6567e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
6577e6ad469SVishal Kulkarni "%s(), t4_read_rss failed!, rc: %d\n",
6587e6ad469SVishal Kulkarni __func__, rc);
6597e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
6607e6ad469SVishal Kulkarni goto err1;
6617e6ad469SVishal Kulkarni }
6627e6ad469SVishal Kulkarni
6637e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
6647e6ad469SVishal Kulkarni if (rc)
6657e6ad469SVishal Kulkarni goto err1;
6667e6ad469SVishal Kulkarni
6677e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
6687e6ad469SVishal Kulkarni
6697e6ad469SVishal Kulkarni err1:
6707e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
6717e6ad469SVishal Kulkarni err:
6727e6ad469SVishal Kulkarni return rc;
6737e6ad469SVishal Kulkarni }
6747e6ad469SVishal Kulkarni
6757e6ad469SVishal Kulkarni static int
collect_sw_state(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)6767e6ad469SVishal Kulkarni collect_sw_state(struct cudbg_init *pdbg_init,
6777e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
6787e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
6797e6ad469SVishal Kulkarni {
6807e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
6817e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
6827e6ad469SVishal Kulkarni struct sw_state *swstate;
6837e6ad469SVishal Kulkarni u32 size;
6847e6ad469SVishal Kulkarni int rc = 0;
6857e6ad469SVishal Kulkarni
6867e6ad469SVishal Kulkarni size = sizeof(struct sw_state);
6877e6ad469SVishal Kulkarni
6887e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
6897e6ad469SVishal Kulkarni if (rc)
6907e6ad469SVishal Kulkarni goto err;
6917e6ad469SVishal Kulkarni
6927e6ad469SVishal Kulkarni swstate = (struct sw_state *) scratch_buff.data;
6937e6ad469SVishal Kulkarni
6947e6ad469SVishal Kulkarni swstate->fw_state = t4_read_reg(padap, A_PCIE_FW);
6957e6ad469SVishal Kulkarni snprintf((char *)swstate->caller_string, sizeof(swstate->caller_string), "%s",
6967e6ad469SVishal Kulkarni "Illumos");
6977e6ad469SVishal Kulkarni swstate->os_type = 0;
6987e6ad469SVishal Kulkarni
6997e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
7007e6ad469SVishal Kulkarni if (rc)
7017e6ad469SVishal Kulkarni goto err1;
7027e6ad469SVishal Kulkarni
7037e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
7047e6ad469SVishal Kulkarni
7057e6ad469SVishal Kulkarni err1:
7067e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
7077e6ad469SVishal Kulkarni err:
7087e6ad469SVishal Kulkarni return rc;
7097e6ad469SVishal Kulkarni }
7107e6ad469SVishal Kulkarni
7117e6ad469SVishal Kulkarni static int
collect_ddp_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)7127e6ad469SVishal Kulkarni collect_ddp_stats(struct cudbg_init *pdbg_init,
7137e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
7147e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
7157e6ad469SVishal Kulkarni {
7167e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
7177e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
7187e6ad469SVishal Kulkarni struct tp_usm_stats *tp_usm_stats_buff;
7197e6ad469SVishal Kulkarni u32 size;
7207e6ad469SVishal Kulkarni int rc = 0;
7217e6ad469SVishal Kulkarni
7227e6ad469SVishal Kulkarni size = sizeof(struct tp_usm_stats);
7237e6ad469SVishal Kulkarni
7247e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
7257e6ad469SVishal Kulkarni if (rc)
7267e6ad469SVishal Kulkarni goto err;
7277e6ad469SVishal Kulkarni
7287e6ad469SVishal Kulkarni tp_usm_stats_buff = (struct tp_usm_stats *) scratch_buff.data;
7297e6ad469SVishal Kulkarni
7307e6ad469SVishal Kulkarni /* spin_lock(&padap->stats_lock); TODO*/
7317e6ad469SVishal Kulkarni t4_get_usm_stats(padap, tp_usm_stats_buff, 1);
7327e6ad469SVishal Kulkarni /* spin_unlock(&padap->stats_lock); TODO*/
7337e6ad469SVishal Kulkarni
7347e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
7357e6ad469SVishal Kulkarni if (rc)
7367e6ad469SVishal Kulkarni goto err1;
7377e6ad469SVishal Kulkarni
7387e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
7397e6ad469SVishal Kulkarni
7407e6ad469SVishal Kulkarni err1:
7417e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
7427e6ad469SVishal Kulkarni err:
7437e6ad469SVishal Kulkarni return rc;
7447e6ad469SVishal Kulkarni }
7457e6ad469SVishal Kulkarni
7467e6ad469SVishal Kulkarni static int
collect_ulptx_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)7477e6ad469SVishal Kulkarni collect_ulptx_la(struct cudbg_init *pdbg_init,
7487e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
7497e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
7507e6ad469SVishal Kulkarni {
7517e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
7527e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
7537e6ad469SVishal Kulkarni struct struct_ulptx_la *ulptx_la_buff;
7547e6ad469SVishal Kulkarni u32 size, i, j;
7557e6ad469SVishal Kulkarni int rc = 0;
7567e6ad469SVishal Kulkarni
7577e6ad469SVishal Kulkarni size = sizeof(struct struct_ulptx_la);
7587e6ad469SVishal Kulkarni
7597e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
7607e6ad469SVishal Kulkarni if (rc)
7617e6ad469SVishal Kulkarni goto err;
7627e6ad469SVishal Kulkarni
7637e6ad469SVishal Kulkarni ulptx_la_buff = (struct struct_ulptx_la *) scratch_buff.data;
7647e6ad469SVishal Kulkarni
7657e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_NUM_ULPTX; i++) {
7667e6ad469SVishal Kulkarni ulptx_la_buff->rdptr[i] = t4_read_reg(padap,
7677e6ad469SVishal Kulkarni A_ULP_TX_LA_RDPTR_0 +
7687e6ad469SVishal Kulkarni 0x10 * i);
7697e6ad469SVishal Kulkarni ulptx_la_buff->wrptr[i] = t4_read_reg(padap,
7707e6ad469SVishal Kulkarni A_ULP_TX_LA_WRPTR_0 +
7717e6ad469SVishal Kulkarni 0x10 * i);
7727e6ad469SVishal Kulkarni ulptx_la_buff->rddata[i] = t4_read_reg(padap,
7737e6ad469SVishal Kulkarni A_ULP_TX_LA_RDDATA_0 +
7747e6ad469SVishal Kulkarni 0x10 * i);
7757e6ad469SVishal Kulkarni for (j = 0; j < CUDBG_NUM_ULPTX_READ; j++) {
7767e6ad469SVishal Kulkarni ulptx_la_buff->rd_data[i][j] =
7777e6ad469SVishal Kulkarni t4_read_reg(padap,
7787e6ad469SVishal Kulkarni A_ULP_TX_LA_RDDATA_0 + 0x10 * i);
7797e6ad469SVishal Kulkarni }
7807e6ad469SVishal Kulkarni }
7817e6ad469SVishal Kulkarni
7827e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
7837e6ad469SVishal Kulkarni if (rc)
7847e6ad469SVishal Kulkarni goto err1;
7857e6ad469SVishal Kulkarni
7867e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
7877e6ad469SVishal Kulkarni
7887e6ad469SVishal Kulkarni err1:
7897e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
7907e6ad469SVishal Kulkarni err:
7917e6ad469SVishal Kulkarni return rc;
7927e6ad469SVishal Kulkarni
7937e6ad469SVishal Kulkarni }
7947e6ad469SVishal Kulkarni
7957e6ad469SVishal Kulkarni static int
collect_ulprx_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)7967e6ad469SVishal Kulkarni collect_ulprx_la(struct cudbg_init *pdbg_init,
7977e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
7987e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
7997e6ad469SVishal Kulkarni {
8007e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
8017e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
8027e6ad469SVishal Kulkarni struct struct_ulprx_la *ulprx_la_buff;
8037e6ad469SVishal Kulkarni u32 size;
8047e6ad469SVishal Kulkarni int rc = 0;
8057e6ad469SVishal Kulkarni
8067e6ad469SVishal Kulkarni size = sizeof(struct struct_ulprx_la);
8077e6ad469SVishal Kulkarni
8087e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
8097e6ad469SVishal Kulkarni if (rc)
8107e6ad469SVishal Kulkarni goto err;
8117e6ad469SVishal Kulkarni
8127e6ad469SVishal Kulkarni ulprx_la_buff = (struct struct_ulprx_la *) scratch_buff.data;
8137e6ad469SVishal Kulkarni t4_ulprx_read_la(padap, (u32 *)ulprx_la_buff->data);
8147e6ad469SVishal Kulkarni ulprx_la_buff->size = ULPRX_LA_SIZE;
8157e6ad469SVishal Kulkarni
8167e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
8177e6ad469SVishal Kulkarni if (rc)
8187e6ad469SVishal Kulkarni goto err1;
8197e6ad469SVishal Kulkarni
8207e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
8217e6ad469SVishal Kulkarni
8227e6ad469SVishal Kulkarni err1:
8237e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
8247e6ad469SVishal Kulkarni err:
8257e6ad469SVishal Kulkarni return rc;
8267e6ad469SVishal Kulkarni }
8277e6ad469SVishal Kulkarni
8287e6ad469SVishal Kulkarni static int
collect_cpl_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)8297e6ad469SVishal Kulkarni collect_cpl_stats(struct cudbg_init *pdbg_init,
8307e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
8317e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
8327e6ad469SVishal Kulkarni {
8337e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
8347e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
8357e6ad469SVishal Kulkarni struct struct_tp_cpl_stats *tp_cpl_stats_buff;
8367e6ad469SVishal Kulkarni u32 size;
8377e6ad469SVishal Kulkarni int rc = 0;
8387e6ad469SVishal Kulkarni
8397e6ad469SVishal Kulkarni size = sizeof(struct struct_tp_cpl_stats);
8407e6ad469SVishal Kulkarni
8417e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
8427e6ad469SVishal Kulkarni if (rc)
8437e6ad469SVishal Kulkarni goto err;
8447e6ad469SVishal Kulkarni
8457e6ad469SVishal Kulkarni tp_cpl_stats_buff = (struct struct_tp_cpl_stats *) scratch_buff.data;
8467e6ad469SVishal Kulkarni tp_cpl_stats_buff->nchan = padap->params.arch.nchan;
8477e6ad469SVishal Kulkarni
8487e6ad469SVishal Kulkarni t4_tp_get_cpl_stats(padap, &tp_cpl_stats_buff->stats, 1);
8497e6ad469SVishal Kulkarni
8507e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
8517e6ad469SVishal Kulkarni if (rc)
8527e6ad469SVishal Kulkarni goto err1;
8537e6ad469SVishal Kulkarni
8547e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
8557e6ad469SVishal Kulkarni
8567e6ad469SVishal Kulkarni err1:
8577e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
8587e6ad469SVishal Kulkarni err:
8597e6ad469SVishal Kulkarni return rc;
8607e6ad469SVishal Kulkarni }
8617e6ad469SVishal Kulkarni
8627e6ad469SVishal Kulkarni static int
collect_wc_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)8637e6ad469SVishal Kulkarni collect_wc_stats(struct cudbg_init *pdbg_init,
8647e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
8657e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
8667e6ad469SVishal Kulkarni {
8677e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
8687e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
8697e6ad469SVishal Kulkarni struct struct_wc_stats *wc_stats_buff;
8707e6ad469SVishal Kulkarni u32 val1;
8717e6ad469SVishal Kulkarni u32 val2;
8727e6ad469SVishal Kulkarni u32 size;
8737e6ad469SVishal Kulkarni
8747e6ad469SVishal Kulkarni int rc = 0;
8757e6ad469SVishal Kulkarni
8767e6ad469SVishal Kulkarni size = sizeof(struct struct_wc_stats);
8777e6ad469SVishal Kulkarni
8787e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
8797e6ad469SVishal Kulkarni if (rc)
8807e6ad469SVishal Kulkarni goto err;
8817e6ad469SVishal Kulkarni
8827e6ad469SVishal Kulkarni wc_stats_buff = (struct struct_wc_stats *) scratch_buff.data;
8837e6ad469SVishal Kulkarni
8847e6ad469SVishal Kulkarni if (!is_t4(padap->params.chip)) {
8857e6ad469SVishal Kulkarni val1 = t4_read_reg(padap, A_SGE_STAT_TOTAL);
8867e6ad469SVishal Kulkarni val2 = t4_read_reg(padap, A_SGE_STAT_MATCH);
8877e6ad469SVishal Kulkarni wc_stats_buff->wr_cl_success = val1 - val2;
8887e6ad469SVishal Kulkarni wc_stats_buff->wr_cl_fail = val2;
8897e6ad469SVishal Kulkarni } else {
8907e6ad469SVishal Kulkarni wc_stats_buff->wr_cl_success = 0;
8917e6ad469SVishal Kulkarni wc_stats_buff->wr_cl_fail = 0;
8927e6ad469SVishal Kulkarni }
8937e6ad469SVishal Kulkarni
8947e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
8957e6ad469SVishal Kulkarni if (rc)
8967e6ad469SVishal Kulkarni goto err1;
8977e6ad469SVishal Kulkarni
8987e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
8997e6ad469SVishal Kulkarni err1:
9007e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
9017e6ad469SVishal Kulkarni err:
9027e6ad469SVishal Kulkarni return rc;
9037e6ad469SVishal Kulkarni }
9047e6ad469SVishal Kulkarni
9057e6ad469SVishal Kulkarni static int
mem_desc_cmp(const void * a,const void * b)9067e6ad469SVishal Kulkarni mem_desc_cmp(const void *a, const void *b)
9077e6ad469SVishal Kulkarni {
9087e6ad469SVishal Kulkarni return ((const struct struct_mem_desc *)a)->base -
9097e6ad469SVishal Kulkarni ((const struct struct_mem_desc *)b)->base;
9107e6ad469SVishal Kulkarni }
9117e6ad469SVishal Kulkarni
9127e6ad469SVishal Kulkarni static int
fill_meminfo(struct adapter * padap,struct struct_meminfo * meminfo_buff)9137e6ad469SVishal Kulkarni fill_meminfo(struct adapter *padap,
9147e6ad469SVishal Kulkarni struct struct_meminfo *meminfo_buff)
9157e6ad469SVishal Kulkarni {
9167e6ad469SVishal Kulkarni struct struct_mem_desc *md;
9177e6ad469SVishal Kulkarni u32 size, lo, hi;
9187e6ad469SVishal Kulkarni u32 used, alloc;
9197e6ad469SVishal Kulkarni int n, i, rc = 0;
9207e6ad469SVishal Kulkarni
9217e6ad469SVishal Kulkarni size = sizeof(struct struct_meminfo);
9227e6ad469SVishal Kulkarni
9237e6ad469SVishal Kulkarni memset(meminfo_buff->avail, 0,
9247e6ad469SVishal Kulkarni ARRAY_SIZE(meminfo_buff->avail) *
9257e6ad469SVishal Kulkarni sizeof(struct struct_mem_desc));
9267e6ad469SVishal Kulkarni memset(meminfo_buff->mem, 0,
9277e6ad469SVishal Kulkarni (ARRAY_SIZE(region) + 3) * sizeof(struct struct_mem_desc));
9287e6ad469SVishal Kulkarni md = meminfo_buff->mem;
9297e6ad469SVishal Kulkarni
9307e6ad469SVishal Kulkarni for (i = 0; i < ARRAY_SIZE(meminfo_buff->mem); i++) {
9317e6ad469SVishal Kulkarni meminfo_buff->mem[i].limit = 0;
9327e6ad469SVishal Kulkarni meminfo_buff->mem[i].idx = i;
9337e6ad469SVishal Kulkarni }
9347e6ad469SVishal Kulkarni
9357e6ad469SVishal Kulkarni i = 0;
9367e6ad469SVishal Kulkarni
9377e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_MA_TARGET_MEM_ENABLE);
9387e6ad469SVishal Kulkarni
9397e6ad469SVishal Kulkarni if (lo & F_EDRAM0_ENABLE) {
9407e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_MA_EDRAM0_BAR);
9417e6ad469SVishal Kulkarni meminfo_buff->avail[i].base = G_EDRAM0_BASE(hi) << 20;
9427e6ad469SVishal Kulkarni meminfo_buff->avail[i].limit = meminfo_buff->avail[i].base +
9437e6ad469SVishal Kulkarni (G_EDRAM0_SIZE(hi) << 20);
9447e6ad469SVishal Kulkarni meminfo_buff->avail[i].idx = 0;
9457e6ad469SVishal Kulkarni i++;
9467e6ad469SVishal Kulkarni }
9477e6ad469SVishal Kulkarni
9487e6ad469SVishal Kulkarni if (lo & F_EDRAM1_ENABLE) {
9497e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_MA_EDRAM1_BAR);
9507e6ad469SVishal Kulkarni meminfo_buff->avail[i].base = G_EDRAM1_BASE(hi) << 20;
9517e6ad469SVishal Kulkarni meminfo_buff->avail[i].limit = meminfo_buff->avail[i].base +
9527e6ad469SVishal Kulkarni (G_EDRAM1_SIZE(hi) << 20);
9537e6ad469SVishal Kulkarni meminfo_buff->avail[i].idx = 1;
9547e6ad469SVishal Kulkarni i++;
9557e6ad469SVishal Kulkarni }
9567e6ad469SVishal Kulkarni
9577e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
9587e6ad469SVishal Kulkarni if (lo & F_EXT_MEM0_ENABLE) {
9597e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_MA_EXT_MEMORY0_BAR);
9607e6ad469SVishal Kulkarni meminfo_buff->avail[i].base = G_EXT_MEM_BASE(hi) << 20;
9617e6ad469SVishal Kulkarni meminfo_buff->avail[i].limit =
9627e6ad469SVishal Kulkarni meminfo_buff->avail[i].base +
9637e6ad469SVishal Kulkarni (G_EXT_MEM_SIZE(hi) << 20);
9647e6ad469SVishal Kulkarni meminfo_buff->avail[i].idx = 3;
9657e6ad469SVishal Kulkarni i++;
9667e6ad469SVishal Kulkarni }
9677e6ad469SVishal Kulkarni
9687e6ad469SVishal Kulkarni if (lo & F_EXT_MEM1_ENABLE) {
9697e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_MA_EXT_MEMORY1_BAR);
9707e6ad469SVishal Kulkarni meminfo_buff->avail[i].base = G_EXT_MEM1_BASE(hi) << 20;
9717e6ad469SVishal Kulkarni meminfo_buff->avail[i].limit =
9727e6ad469SVishal Kulkarni meminfo_buff->avail[i].base +
9737e6ad469SVishal Kulkarni (G_EXT_MEM1_SIZE(hi) << 20);
9747e6ad469SVishal Kulkarni meminfo_buff->avail[i].idx = 4;
9757e6ad469SVishal Kulkarni i++;
9767e6ad469SVishal Kulkarni }
9777e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
9787e6ad469SVishal Kulkarni if (lo & F_EXT_MEM_ENABLE) {
9797e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_MA_EXT_MEMORY_BAR);
9807e6ad469SVishal Kulkarni meminfo_buff->avail[i].base = G_EXT_MEM_BASE(hi) << 20;
9817e6ad469SVishal Kulkarni meminfo_buff->avail[i].limit =
9827e6ad469SVishal Kulkarni meminfo_buff->avail[i].base +
9837e6ad469SVishal Kulkarni (G_EXT_MEM_SIZE(hi) << 20);
9847e6ad469SVishal Kulkarni meminfo_buff->avail[i].idx = 2;
9857e6ad469SVishal Kulkarni i++;
9867e6ad469SVishal Kulkarni }
9877e6ad469SVishal Kulkarni }
9887e6ad469SVishal Kulkarni
9897e6ad469SVishal Kulkarni if (!i) { /* no memory available */
9907e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
9917e6ad469SVishal Kulkarni goto err;
9927e6ad469SVishal Kulkarni }
9937e6ad469SVishal Kulkarni
9947e6ad469SVishal Kulkarni meminfo_buff->avail_c = i;
9957e6ad469SVishal Kulkarni qsort(meminfo_buff->avail, i, sizeof(struct struct_mem_desc),
9967e6ad469SVishal Kulkarni mem_desc_cmp, NULL);
9977e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_SGE_DBQ_CTXT_BADDR);
9987e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_SGE_IMSG_CTXT_BADDR);
9997e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_SGE_FLM_CACHE_BADDR);
10007e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_TCB_BASE);
10017e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_MM_BASE);
10027e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_TIMER_BASE);
10037e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_MM_RX_FLST_BASE);
10047e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_MM_TX_FLST_BASE);
10057e6ad469SVishal Kulkarni (md++)->base = t4_read_reg(padap, A_TP_CMM_MM_PS_FLST_BASE);
10067e6ad469SVishal Kulkarni
10077e6ad469SVishal Kulkarni /* the next few have explicit upper bounds */
10087e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_TP_PMM_TX_BASE);
10097e6ad469SVishal Kulkarni md->limit = md->base - 1 +
10107e6ad469SVishal Kulkarni t4_read_reg(padap,
10117e6ad469SVishal Kulkarni A_TP_PMM_TX_PAGE_SIZE) *
10127e6ad469SVishal Kulkarni G_PMTXMAXPAGE(t4_read_reg(padap,
10137e6ad469SVishal Kulkarni A_TP_PMM_TX_MAX_PAGE)
10147e6ad469SVishal Kulkarni );
10157e6ad469SVishal Kulkarni md++;
10167e6ad469SVishal Kulkarni
10177e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_TP_PMM_RX_BASE);
10187e6ad469SVishal Kulkarni md->limit = md->base - 1 +
10197e6ad469SVishal Kulkarni t4_read_reg(padap,
10207e6ad469SVishal Kulkarni A_TP_PMM_RX_PAGE_SIZE) *
10217e6ad469SVishal Kulkarni G_PMRXMAXPAGE(t4_read_reg(padap,
10227e6ad469SVishal Kulkarni A_TP_PMM_RX_MAX_PAGE)
10237e6ad469SVishal Kulkarni );
10247e6ad469SVishal Kulkarni md++;
10257e6ad469SVishal Kulkarni if (t4_read_reg(padap, A_LE_DB_CONFIG) & F_HASHEN) {
10267e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) <= CHELSIO_T5) {
10277e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_LE_DB_TID_HASHBASE) / 4;
10287e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_LE_DB_HASH_TID_BASE);
10297e6ad469SVishal Kulkarni } else {
10307e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_LE_DB_HASH_TID_BASE);
10317e6ad469SVishal Kulkarni md->base = t4_read_reg(padap,
10327e6ad469SVishal Kulkarni A_LE_DB_HASH_TBL_BASE_ADDR);
10337e6ad469SVishal Kulkarni }
10347e6ad469SVishal Kulkarni md->limit = 0;
10357e6ad469SVishal Kulkarni } else {
10367e6ad469SVishal Kulkarni md->base = 0;
10377e6ad469SVishal Kulkarni md->idx = ARRAY_SIZE(region); /* hide it */
10387e6ad469SVishal Kulkarni }
10397e6ad469SVishal Kulkarni md++;
10407e6ad469SVishal Kulkarni #define ulp_region(reg) \
10417e6ad469SVishal Kulkarni {\
10427e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_ULP_ ## reg ## _LLIMIT);\
10437e6ad469SVishal Kulkarni (md++)->limit = t4_read_reg(padap, A_ULP_ ## reg ## _ULIMIT);\
10447e6ad469SVishal Kulkarni }
10457e6ad469SVishal Kulkarni
10467e6ad469SVishal Kulkarni ulp_region(RX_ISCSI);
10477e6ad469SVishal Kulkarni ulp_region(RX_TDDP);
10487e6ad469SVishal Kulkarni ulp_region(TX_TPT);
10497e6ad469SVishal Kulkarni ulp_region(RX_STAG);
10507e6ad469SVishal Kulkarni ulp_region(RX_RQ);
10517e6ad469SVishal Kulkarni ulp_region(RX_RQUDP);
10527e6ad469SVishal Kulkarni ulp_region(RX_PBL);
10537e6ad469SVishal Kulkarni ulp_region(TX_PBL);
10547e6ad469SVishal Kulkarni #undef ulp_region
10557e6ad469SVishal Kulkarni md->base = 0;
10567e6ad469SVishal Kulkarni md->idx = ARRAY_SIZE(region);
10577e6ad469SVishal Kulkarni if (!is_t4(padap->params.chip)) {
10587e6ad469SVishal Kulkarni u32 sge_ctrl = t4_read_reg(padap, A_SGE_CONTROL2);
10597e6ad469SVishal Kulkarni u32 fifo_size = t4_read_reg(padap, A_SGE_DBVFIFO_SIZE);
10607e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
10617e6ad469SVishal Kulkarni if (sge_ctrl & F_VFIFO_ENABLE)
10627e6ad469SVishal Kulkarni size = G_DBVFIFO_SIZE(fifo_size);
10637e6ad469SVishal Kulkarni } else
10647e6ad469SVishal Kulkarni size = G_T6_DBVFIFO_SIZE(fifo_size);
10657e6ad469SVishal Kulkarni
10667e6ad469SVishal Kulkarni if (size) {
10677e6ad469SVishal Kulkarni md->base = G_BASEADDR(t4_read_reg(padap,
10687e6ad469SVishal Kulkarni A_SGE_DBVFIFO_BADDR));
10697e6ad469SVishal Kulkarni md->limit = md->base + (size << 2) - 1;
10707e6ad469SVishal Kulkarni }
10717e6ad469SVishal Kulkarni }
10727e6ad469SVishal Kulkarni
10737e6ad469SVishal Kulkarni md++;
10747e6ad469SVishal Kulkarni
10757e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_ULP_RX_CTX_BASE);
10767e6ad469SVishal Kulkarni md->limit = 0;
10777e6ad469SVishal Kulkarni md++;
10787e6ad469SVishal Kulkarni md->base = t4_read_reg(padap, A_ULP_TX_ERR_TABLE_BASE);
10797e6ad469SVishal Kulkarni md->limit = 0;
10807e6ad469SVishal Kulkarni md++;
10817e6ad469SVishal Kulkarni #ifndef __NO_DRIVER_OCQ_SUPPORT__
10827e6ad469SVishal Kulkarni /*md->base = padap->vres.ocq.start;*/
10837e6ad469SVishal Kulkarni /*if (adap->vres.ocq.size)*/
10847e6ad469SVishal Kulkarni /* md->limit = md->base + adap->vres.ocq.size - 1;*/
10857e6ad469SVishal Kulkarni /*else*/
10867e6ad469SVishal Kulkarni md->idx = ARRAY_SIZE(region); /* hide it */
10877e6ad469SVishal Kulkarni md++;
10887e6ad469SVishal Kulkarni #endif
10897e6ad469SVishal Kulkarni
10907e6ad469SVishal Kulkarni /* add any address-space holes, there can be up to 3 */
10917e6ad469SVishal Kulkarni for (n = 0; n < i - 1; n++)
10927e6ad469SVishal Kulkarni if (meminfo_buff->avail[n].limit <
10937e6ad469SVishal Kulkarni meminfo_buff->avail[n + 1].base)
10947e6ad469SVishal Kulkarni (md++)->base = meminfo_buff->avail[n].limit;
10957e6ad469SVishal Kulkarni
10967e6ad469SVishal Kulkarni if (meminfo_buff->avail[n].limit)
10977e6ad469SVishal Kulkarni (md++)->base = meminfo_buff->avail[n].limit;
10987e6ad469SVishal Kulkarni
10997e6ad469SVishal Kulkarni n = (int) (md - meminfo_buff->mem);
11007e6ad469SVishal Kulkarni meminfo_buff->mem_c = n;
11017e6ad469SVishal Kulkarni
11027e6ad469SVishal Kulkarni qsort(meminfo_buff->mem, n, sizeof(struct struct_mem_desc),
11037e6ad469SVishal Kulkarni mem_desc_cmp, NULL);
11047e6ad469SVishal Kulkarni
11057e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_CIM_SDRAM_BASE_ADDR);
11067e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_CIM_SDRAM_ADDR_SIZE) + lo - 1;
11077e6ad469SVishal Kulkarni meminfo_buff->up_ram_lo = lo;
11087e6ad469SVishal Kulkarni meminfo_buff->up_ram_hi = hi;
11097e6ad469SVishal Kulkarni
11107e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_CIM_EXTMEM2_BASE_ADDR);
11117e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_CIM_EXTMEM2_ADDR_SIZE) + lo - 1;
11127e6ad469SVishal Kulkarni meminfo_buff->up_extmem2_lo = lo;
11137e6ad469SVishal Kulkarni meminfo_buff->up_extmem2_hi = hi;
11147e6ad469SVishal Kulkarni
11157e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_TP_PMM_RX_MAX_PAGE);
11167e6ad469SVishal Kulkarni meminfo_buff->rx_pages_data[0] = G_PMRXMAXPAGE(lo);
11177e6ad469SVishal Kulkarni meminfo_buff->rx_pages_data[1] =
11187e6ad469SVishal Kulkarni t4_read_reg(padap, A_TP_PMM_RX_PAGE_SIZE) >> 10;
11197e6ad469SVishal Kulkarni meminfo_buff->rx_pages_data[2] = (lo & F_PMRXNUMCHN) ? 2 : 1 ;
11207e6ad469SVishal Kulkarni
11217e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_TP_PMM_TX_MAX_PAGE);
11227e6ad469SVishal Kulkarni hi = t4_read_reg(padap, A_TP_PMM_TX_PAGE_SIZE);
11237e6ad469SVishal Kulkarni meminfo_buff->tx_pages_data[0] = G_PMTXMAXPAGE(lo);
11247e6ad469SVishal Kulkarni meminfo_buff->tx_pages_data[1] =
11257e6ad469SVishal Kulkarni hi >= (1 << 20) ? (hi >> 20) : (hi >> 10);
11267e6ad469SVishal Kulkarni meminfo_buff->tx_pages_data[2] =
11277e6ad469SVishal Kulkarni hi >= (1 << 20) ? 'M' : 'K';
11287e6ad469SVishal Kulkarni meminfo_buff->tx_pages_data[3] = 1 << G_PMTXNUMCHN(lo);
11297e6ad469SVishal Kulkarni
11307e6ad469SVishal Kulkarni for (i = 0; i < 4; i++) {
11317e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) > CHELSIO_T5)
11327e6ad469SVishal Kulkarni lo = t4_read_reg(padap,
11337e6ad469SVishal Kulkarni A_MPS_RX_MAC_BG_PG_CNT0 + i * 4);
11347e6ad469SVishal Kulkarni else
11357e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_MPS_RX_PG_RSV0 + i * 4);
11367e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
11377e6ad469SVishal Kulkarni used = G_T5_USED(lo);
11387e6ad469SVishal Kulkarni alloc = G_T5_ALLOC(lo);
11397e6ad469SVishal Kulkarni } else {
11407e6ad469SVishal Kulkarni used = G_USED(lo);
11417e6ad469SVishal Kulkarni alloc = G_ALLOC(lo);
11427e6ad469SVishal Kulkarni }
11437e6ad469SVishal Kulkarni meminfo_buff->port_used[i] = used;
11447e6ad469SVishal Kulkarni meminfo_buff->port_alloc[i] = alloc;
11457e6ad469SVishal Kulkarni }
11467e6ad469SVishal Kulkarni
11477e6ad469SVishal Kulkarni for (i = 0; i < padap->params.arch.nchan; i++) {
11487e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) > CHELSIO_T5)
11497e6ad469SVishal Kulkarni lo = t4_read_reg(padap,
11507e6ad469SVishal Kulkarni A_MPS_RX_LPBK_BG_PG_CNT0 + i * 4);
11517e6ad469SVishal Kulkarni else
11527e6ad469SVishal Kulkarni lo = t4_read_reg(padap, A_MPS_RX_PG_RSV4 + i * 4);
11537e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
11547e6ad469SVishal Kulkarni used = G_T5_USED(lo);
11557e6ad469SVishal Kulkarni alloc = G_T5_ALLOC(lo);
11567e6ad469SVishal Kulkarni } else {
11577e6ad469SVishal Kulkarni used = G_USED(lo);
11587e6ad469SVishal Kulkarni alloc = G_ALLOC(lo);
11597e6ad469SVishal Kulkarni }
11607e6ad469SVishal Kulkarni meminfo_buff->loopback_used[i] = used;
11617e6ad469SVishal Kulkarni meminfo_buff->loopback_alloc[i] = alloc;
11627e6ad469SVishal Kulkarni }
11637e6ad469SVishal Kulkarni err:
11647e6ad469SVishal Kulkarni return rc;
11657e6ad469SVishal Kulkarni }
11667e6ad469SVishal Kulkarni
11677e6ad469SVishal Kulkarni static int
collect_meminfo(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)11687e6ad469SVishal Kulkarni collect_meminfo(struct cudbg_init *pdbg_init,
11697e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
11707e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
11717e6ad469SVishal Kulkarni {
11727e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
11737e6ad469SVishal Kulkarni struct struct_meminfo *meminfo_buff;
11747e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
11757e6ad469SVishal Kulkarni int rc = 0;
11767e6ad469SVishal Kulkarni u32 size;
11777e6ad469SVishal Kulkarni
11787e6ad469SVishal Kulkarni size = sizeof(struct struct_meminfo);
11797e6ad469SVishal Kulkarni
11807e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
11817e6ad469SVishal Kulkarni if (rc)
11827e6ad469SVishal Kulkarni goto err;
11837e6ad469SVishal Kulkarni
11847e6ad469SVishal Kulkarni meminfo_buff = (struct struct_meminfo *)scratch_buff.data;
11857e6ad469SVishal Kulkarni
11867e6ad469SVishal Kulkarni rc = fill_meminfo(padap, meminfo_buff);
11877e6ad469SVishal Kulkarni if (rc)
11887e6ad469SVishal Kulkarni goto err;
11897e6ad469SVishal Kulkarni
11907e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
11917e6ad469SVishal Kulkarni if (rc)
11927e6ad469SVishal Kulkarni goto err1;
11937e6ad469SVishal Kulkarni
11947e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
11957e6ad469SVishal Kulkarni err1:
11967e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
11977e6ad469SVishal Kulkarni err:
11987e6ad469SVishal Kulkarni return rc;
11997e6ad469SVishal Kulkarni }
12007e6ad469SVishal Kulkarni
12017e6ad469SVishal Kulkarni static int
collect_lb_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)12027e6ad469SVishal Kulkarni collect_lb_stats(struct cudbg_init *pdbg_init,
12037e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
12047e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
12057e6ad469SVishal Kulkarni {
12067e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
12077e6ad469SVishal Kulkarni struct struct_lb_stats *lb_stats_buff;
12087e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
12097e6ad469SVishal Kulkarni struct lb_port_stats *tmp_stats;
12107e6ad469SVishal Kulkarni u32 i, n, size;
12117e6ad469SVishal Kulkarni int rc = 0;
12127e6ad469SVishal Kulkarni
12137e6ad469SVishal Kulkarni rc = padap->params.nports;
12147e6ad469SVishal Kulkarni if (rc < 0)
12157e6ad469SVishal Kulkarni goto err;
12167e6ad469SVishal Kulkarni
12177e6ad469SVishal Kulkarni n = rc;
12187e6ad469SVishal Kulkarni size = sizeof(struct struct_lb_stats) +
12197e6ad469SVishal Kulkarni n * sizeof(struct lb_port_stats);
12207e6ad469SVishal Kulkarni
12217e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
12227e6ad469SVishal Kulkarni if (rc)
12237e6ad469SVishal Kulkarni goto err;
12247e6ad469SVishal Kulkarni
12257e6ad469SVishal Kulkarni lb_stats_buff = (struct struct_lb_stats *) scratch_buff.data;
12267e6ad469SVishal Kulkarni
12277e6ad469SVishal Kulkarni lb_stats_buff->nchan = n;
12287e6ad469SVishal Kulkarni tmp_stats = lb_stats_buff->s;
12297e6ad469SVishal Kulkarni
12307e6ad469SVishal Kulkarni for (i = 0; i < n; i += 2, tmp_stats += 2) {
12317e6ad469SVishal Kulkarni t4_get_lb_stats(padap, i, tmp_stats);
12327e6ad469SVishal Kulkarni t4_get_lb_stats(padap, i + 1, tmp_stats+1);
12337e6ad469SVishal Kulkarni }
12347e6ad469SVishal Kulkarni
12357e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
12367e6ad469SVishal Kulkarni if (rc)
12377e6ad469SVishal Kulkarni goto err1;
12387e6ad469SVishal Kulkarni
12397e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
12407e6ad469SVishal Kulkarni err1:
12417e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
12427e6ad469SVishal Kulkarni err:
12437e6ad469SVishal Kulkarni return rc;
12447e6ad469SVishal Kulkarni }
12457e6ad469SVishal Kulkarni
12467e6ad469SVishal Kulkarni static int
collect_rdma_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_er)12477e6ad469SVishal Kulkarni collect_rdma_stats(struct cudbg_init *pdbg_init,
12487e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
12497e6ad469SVishal Kulkarni struct cudbg_error *cudbg_er)
12507e6ad469SVishal Kulkarni {
12517e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
12527e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
12537e6ad469SVishal Kulkarni struct tp_rdma_stats *rdma_stats_buff;
12547e6ad469SVishal Kulkarni u32 size;
12557e6ad469SVishal Kulkarni int rc = 0;
12567e6ad469SVishal Kulkarni
12577e6ad469SVishal Kulkarni size = sizeof(struct tp_rdma_stats);
12587e6ad469SVishal Kulkarni
12597e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
12607e6ad469SVishal Kulkarni if (rc)
12617e6ad469SVishal Kulkarni goto err;
12627e6ad469SVishal Kulkarni
12637e6ad469SVishal Kulkarni rdma_stats_buff = (struct tp_rdma_stats *) scratch_buff.data;
12647e6ad469SVishal Kulkarni
12657e6ad469SVishal Kulkarni /* spin_lock(&padap->stats_lock); TODO*/
12667e6ad469SVishal Kulkarni t4_tp_get_rdma_stats(padap, rdma_stats_buff, 1);
12677e6ad469SVishal Kulkarni /* spin_unlock(&padap->stats_lock); TODO*/
12687e6ad469SVishal Kulkarni
12697e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
12707e6ad469SVishal Kulkarni if (rc)
12717e6ad469SVishal Kulkarni goto err1;
12727e6ad469SVishal Kulkarni
12737e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
12747e6ad469SVishal Kulkarni err1:
12757e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
12767e6ad469SVishal Kulkarni err:
12777e6ad469SVishal Kulkarni return rc;
12787e6ad469SVishal Kulkarni }
12797e6ad469SVishal Kulkarni
12807e6ad469SVishal Kulkarni static int
collect_clk_info(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)12817e6ad469SVishal Kulkarni collect_clk_info(struct cudbg_init *pdbg_init,
12827e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
12837e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
12847e6ad469SVishal Kulkarni {
12857e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
12867e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
12877e6ad469SVishal Kulkarni struct struct_clk_info *clk_info_buff;
12887e6ad469SVishal Kulkarni u64 tp_tick_us;
12897e6ad469SVishal Kulkarni int size;
12907e6ad469SVishal Kulkarni int rc = 0;
12917e6ad469SVishal Kulkarni
12927e6ad469SVishal Kulkarni if (!padap->params.vpd.cclk) {
12937e6ad469SVishal Kulkarni rc = CUDBG_STATUS_CCLK_NOT_DEFINED;
12947e6ad469SVishal Kulkarni goto err;
12957e6ad469SVishal Kulkarni }
12967e6ad469SVishal Kulkarni
12977e6ad469SVishal Kulkarni size = sizeof(struct struct_clk_info);
12987e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
12997e6ad469SVishal Kulkarni if (rc)
13007e6ad469SVishal Kulkarni goto err;
13017e6ad469SVishal Kulkarni
13027e6ad469SVishal Kulkarni clk_info_buff = (struct struct_clk_info *) scratch_buff.data;
13037e6ad469SVishal Kulkarni
13047e6ad469SVishal Kulkarni clk_info_buff->cclk_ps = 1000000000 / padap->params.vpd.cclk; /* in ps
13057e6ad469SVishal Kulkarni */
13067e6ad469SVishal Kulkarni clk_info_buff->res = t4_read_reg(padap, A_TP_TIMER_RESOLUTION);
13077e6ad469SVishal Kulkarni clk_info_buff->tre = G_TIMERRESOLUTION(clk_info_buff->res);
13087e6ad469SVishal Kulkarni clk_info_buff->dack_re = G_DELAYEDACKRESOLUTION(clk_info_buff->res);
13097e6ad469SVishal Kulkarni tp_tick_us = (clk_info_buff->cclk_ps << clk_info_buff->tre) / 1000000;
13107e6ad469SVishal Kulkarni /* in us */
13117e6ad469SVishal Kulkarni clk_info_buff->dack_timer = ((clk_info_buff->cclk_ps <<
13127e6ad469SVishal Kulkarni clk_info_buff->dack_re) / 1000000) *
13137e6ad469SVishal Kulkarni t4_read_reg(padap, A_TP_DACK_TIMER);
13147e6ad469SVishal Kulkarni
13157e6ad469SVishal Kulkarni clk_info_buff->retransmit_min =
13167e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_RXT_MIN);
13177e6ad469SVishal Kulkarni clk_info_buff->retransmit_max =
13187e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_RXT_MAX);
13197e6ad469SVishal Kulkarni
13207e6ad469SVishal Kulkarni clk_info_buff->persist_timer_min =
13217e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_PERS_MIN);
13227e6ad469SVishal Kulkarni clk_info_buff->persist_timer_max =
13237e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_PERS_MAX);
13247e6ad469SVishal Kulkarni
13257e6ad469SVishal Kulkarni clk_info_buff->keepalive_idle_timer =
13267e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_KEEP_IDLE);
13277e6ad469SVishal Kulkarni clk_info_buff->keepalive_interval =
13287e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_KEEP_INTVL);
13297e6ad469SVishal Kulkarni
13307e6ad469SVishal Kulkarni clk_info_buff->initial_srtt =
13317e6ad469SVishal Kulkarni tp_tick_us * G_INITSRTT(t4_read_reg(padap, A_TP_INIT_SRTT));
13327e6ad469SVishal Kulkarni clk_info_buff->finwait2_timer =
13337e6ad469SVishal Kulkarni tp_tick_us * t4_read_reg(padap, A_TP_FINWAIT2_TIMER);
13347e6ad469SVishal Kulkarni
13357e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
13367e6ad469SVishal Kulkarni
13377e6ad469SVishal Kulkarni if (rc)
13387e6ad469SVishal Kulkarni goto err1;
13397e6ad469SVishal Kulkarni
13407e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
13417e6ad469SVishal Kulkarni err1:
13427e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
13437e6ad469SVishal Kulkarni err:
13447e6ad469SVishal Kulkarni return rc;
13457e6ad469SVishal Kulkarni
13467e6ad469SVishal Kulkarni }
13477e6ad469SVishal Kulkarni
13487e6ad469SVishal Kulkarni static int
collect_macstats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)13497e6ad469SVishal Kulkarni collect_macstats(struct cudbg_init *pdbg_init,
13507e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
13517e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
13527e6ad469SVishal Kulkarni {
13537e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
13547e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
13557e6ad469SVishal Kulkarni struct struct_mac_stats_rev1 *mac_stats_buff;
13567e6ad469SVishal Kulkarni u32 i, n, size;
13577e6ad469SVishal Kulkarni int rc = 0;
13587e6ad469SVishal Kulkarni
13597e6ad469SVishal Kulkarni rc = padap->params.nports;
13607e6ad469SVishal Kulkarni if (rc < 0)
13617e6ad469SVishal Kulkarni goto err;
13627e6ad469SVishal Kulkarni
13637e6ad469SVishal Kulkarni n = rc;
13647e6ad469SVishal Kulkarni size = sizeof(struct struct_mac_stats_rev1);
13657e6ad469SVishal Kulkarni
13667e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
13677e6ad469SVishal Kulkarni if (rc)
13687e6ad469SVishal Kulkarni goto err;
13697e6ad469SVishal Kulkarni
13707e6ad469SVishal Kulkarni mac_stats_buff = (struct struct_mac_stats_rev1 *) scratch_buff.data;
13717e6ad469SVishal Kulkarni
13727e6ad469SVishal Kulkarni mac_stats_buff->ver_hdr.signature = CUDBG_ENTITY_SIGNATURE;
13737e6ad469SVishal Kulkarni mac_stats_buff->ver_hdr.revision = CUDBG_MAC_STATS_REV;
13747e6ad469SVishal Kulkarni mac_stats_buff->ver_hdr.size = sizeof(struct struct_mac_stats_rev1) -
13757e6ad469SVishal Kulkarni sizeof(struct cudbg_ver_hdr);
13767e6ad469SVishal Kulkarni
13777e6ad469SVishal Kulkarni mac_stats_buff->port_count = n;
13787e6ad469SVishal Kulkarni for (i = 0; i < mac_stats_buff->port_count; i++)
13797e6ad469SVishal Kulkarni t4_get_port_stats(padap, i, &mac_stats_buff->stats[i]);
13807e6ad469SVishal Kulkarni
13817e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
13827e6ad469SVishal Kulkarni if (rc)
13837e6ad469SVishal Kulkarni goto err1;
13847e6ad469SVishal Kulkarni
13857e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
13867e6ad469SVishal Kulkarni err1:
13877e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
13887e6ad469SVishal Kulkarni err:
13897e6ad469SVishal Kulkarni return rc;
13907e6ad469SVishal Kulkarni }
13917e6ad469SVishal Kulkarni
13927e6ad469SVishal Kulkarni static int
collect_cim_pif_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)13937e6ad469SVishal Kulkarni collect_cim_pif_la(struct cudbg_init *pdbg_init,
13947e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
13957e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
13967e6ad469SVishal Kulkarni {
13977e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
13987e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
13997e6ad469SVishal Kulkarni struct cim_pif_la *cim_pif_la_buff;
14007e6ad469SVishal Kulkarni u32 size;
14017e6ad469SVishal Kulkarni int rc = 0;
14027e6ad469SVishal Kulkarni
14037e6ad469SVishal Kulkarni size = sizeof(struct cim_pif_la) +
14047e6ad469SVishal Kulkarni 2 * CIM_PIFLA_SIZE * 6 * sizeof(u32);
14057e6ad469SVishal Kulkarni
14067e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
14077e6ad469SVishal Kulkarni if (rc)
14087e6ad469SVishal Kulkarni goto err;
14097e6ad469SVishal Kulkarni
14107e6ad469SVishal Kulkarni cim_pif_la_buff = (struct cim_pif_la *) scratch_buff.data;
14117e6ad469SVishal Kulkarni cim_pif_la_buff->size = CIM_PIFLA_SIZE;
14127e6ad469SVishal Kulkarni
14137e6ad469SVishal Kulkarni t4_cim_read_pif_la(padap, (u32 *)cim_pif_la_buff->data,
14147e6ad469SVishal Kulkarni (u32 *)cim_pif_la_buff->data + 6 * CIM_PIFLA_SIZE,
14157e6ad469SVishal Kulkarni NULL, NULL);
14167e6ad469SVishal Kulkarni
14177e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
14187e6ad469SVishal Kulkarni if (rc)
14197e6ad469SVishal Kulkarni goto err1;
14207e6ad469SVishal Kulkarni
14217e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
14227e6ad469SVishal Kulkarni err1:
14237e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
14247e6ad469SVishal Kulkarni err:
14257e6ad469SVishal Kulkarni return rc;
14267e6ad469SVishal Kulkarni }
14277e6ad469SVishal Kulkarni
14287e6ad469SVishal Kulkarni static int
collect_tp_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)14297e6ad469SVishal Kulkarni collect_tp_la(struct cudbg_init *pdbg_init,
14307e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
14317e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
14327e6ad469SVishal Kulkarni {
14337e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
14347e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
14357e6ad469SVishal Kulkarni struct struct_tp_la *tp_la_buff;
14367e6ad469SVishal Kulkarni u32 size;
14377e6ad469SVishal Kulkarni int rc = 0;
14387e6ad469SVishal Kulkarni
14397e6ad469SVishal Kulkarni size = sizeof(struct struct_tp_la) + TPLA_SIZE * sizeof(u64);
14407e6ad469SVishal Kulkarni
14417e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
14427e6ad469SVishal Kulkarni if (rc)
14437e6ad469SVishal Kulkarni goto err;
14447e6ad469SVishal Kulkarni
14457e6ad469SVishal Kulkarni tp_la_buff = (struct struct_tp_la *) scratch_buff.data;
14467e6ad469SVishal Kulkarni
14477e6ad469SVishal Kulkarni tp_la_buff->mode = G_DBGLAMODE(t4_read_reg(padap, A_TP_DBG_LA_CONFIG));
14487e6ad469SVishal Kulkarni t4_tp_read_la(padap, (u64 *)tp_la_buff->data, NULL);
14497e6ad469SVishal Kulkarni
14507e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
14517e6ad469SVishal Kulkarni if (rc)
14527e6ad469SVishal Kulkarni goto err1;
14537e6ad469SVishal Kulkarni
14547e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
14557e6ad469SVishal Kulkarni err1:
14567e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
14577e6ad469SVishal Kulkarni err:
14587e6ad469SVishal Kulkarni return rc;
14597e6ad469SVishal Kulkarni }
14607e6ad469SVishal Kulkarni
14617e6ad469SVishal Kulkarni static int
collect_fcoe_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)14627e6ad469SVishal Kulkarni collect_fcoe_stats(struct cudbg_init *pdbg_init,
14637e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
14647e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
14657e6ad469SVishal Kulkarni {
14667e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
14677e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
14687e6ad469SVishal Kulkarni struct struct_tp_fcoe_stats *tp_fcoe_stats_buff;
14697e6ad469SVishal Kulkarni u32 size;
14707e6ad469SVishal Kulkarni int rc = 0;
14717e6ad469SVishal Kulkarni
14727e6ad469SVishal Kulkarni size = sizeof(struct struct_tp_fcoe_stats);
14737e6ad469SVishal Kulkarni
14747e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
14757e6ad469SVishal Kulkarni if (rc)
14767e6ad469SVishal Kulkarni goto err;
14777e6ad469SVishal Kulkarni
14787e6ad469SVishal Kulkarni tp_fcoe_stats_buff = (struct struct_tp_fcoe_stats *) scratch_buff.data;
14797e6ad469SVishal Kulkarni
14807e6ad469SVishal Kulkarni t4_get_fcoe_stats(padap, 0, &tp_fcoe_stats_buff->stats[0], 1);
14817e6ad469SVishal Kulkarni t4_get_fcoe_stats(padap, 1, &tp_fcoe_stats_buff->stats[1], 1);
14827e6ad469SVishal Kulkarni
14837e6ad469SVishal Kulkarni if (padap->params.arch.nchan == NCHAN) {
14847e6ad469SVishal Kulkarni t4_get_fcoe_stats(padap, 2, &tp_fcoe_stats_buff->stats[2], 1);
14857e6ad469SVishal Kulkarni t4_get_fcoe_stats(padap, 3, &tp_fcoe_stats_buff->stats[3], 1);
14867e6ad469SVishal Kulkarni }
14877e6ad469SVishal Kulkarni
14887e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
14897e6ad469SVishal Kulkarni if (rc)
14907e6ad469SVishal Kulkarni goto err1;
14917e6ad469SVishal Kulkarni
14927e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
14937e6ad469SVishal Kulkarni err1:
14947e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
14957e6ad469SVishal Kulkarni err:
14967e6ad469SVishal Kulkarni return rc;
14977e6ad469SVishal Kulkarni }
14987e6ad469SVishal Kulkarni
14997e6ad469SVishal Kulkarni static int
collect_tp_err_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)15007e6ad469SVishal Kulkarni collect_tp_err_stats(struct cudbg_init *pdbg_init,
15017e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
15027e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
15037e6ad469SVishal Kulkarni {
15047e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
15057e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
15067e6ad469SVishal Kulkarni struct struct_tp_err_stats *tp_err_stats_buff;
15077e6ad469SVishal Kulkarni u32 size;
15087e6ad469SVishal Kulkarni int rc = 0;
15097e6ad469SVishal Kulkarni
15107e6ad469SVishal Kulkarni size = sizeof(struct struct_tp_err_stats);
15117e6ad469SVishal Kulkarni
15127e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
15137e6ad469SVishal Kulkarni if (rc)
15147e6ad469SVishal Kulkarni goto err;
15157e6ad469SVishal Kulkarni
15167e6ad469SVishal Kulkarni tp_err_stats_buff = (struct struct_tp_err_stats *) scratch_buff.data;
15177e6ad469SVishal Kulkarni
15187e6ad469SVishal Kulkarni t4_tp_get_err_stats(padap, &tp_err_stats_buff->stats, 1);
15197e6ad469SVishal Kulkarni tp_err_stats_buff->nchan = padap->params.arch.nchan;
15207e6ad469SVishal Kulkarni
15217e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
15227e6ad469SVishal Kulkarni if (rc)
15237e6ad469SVishal Kulkarni goto err1;
15247e6ad469SVishal Kulkarni
15257e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
15267e6ad469SVishal Kulkarni err1:
15277e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
15287e6ad469SVishal Kulkarni err:
15297e6ad469SVishal Kulkarni return rc;
15307e6ad469SVishal Kulkarni }
15317e6ad469SVishal Kulkarni
15327e6ad469SVishal Kulkarni static int
collect_tcp_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)15337e6ad469SVishal Kulkarni collect_tcp_stats(struct cudbg_init *pdbg_init,
15347e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
15357e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
15367e6ad469SVishal Kulkarni {
15377e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
15387e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
15397e6ad469SVishal Kulkarni struct struct_tcp_stats *tcp_stats_buff;
15407e6ad469SVishal Kulkarni u32 size;
15417e6ad469SVishal Kulkarni int rc = 0;
15427e6ad469SVishal Kulkarni
15437e6ad469SVishal Kulkarni size = sizeof(struct struct_tcp_stats);
15447e6ad469SVishal Kulkarni
15457e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
15467e6ad469SVishal Kulkarni if (rc)
15477e6ad469SVishal Kulkarni goto err;
15487e6ad469SVishal Kulkarni
15497e6ad469SVishal Kulkarni tcp_stats_buff = (struct struct_tcp_stats *) scratch_buff.data;
15507e6ad469SVishal Kulkarni
15517e6ad469SVishal Kulkarni /* spin_lock(&padap->stats_lock); TODO*/
15527e6ad469SVishal Kulkarni t4_tp_get_tcp_stats(padap, &tcp_stats_buff->v4, &tcp_stats_buff->v6, 1);
15537e6ad469SVishal Kulkarni /* spin_unlock(&padap->stats_lock); TODO*/
15547e6ad469SVishal Kulkarni
15557e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
15567e6ad469SVishal Kulkarni if (rc)
15577e6ad469SVishal Kulkarni goto err1;
15587e6ad469SVishal Kulkarni
15597e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
15607e6ad469SVishal Kulkarni err1:
15617e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
15627e6ad469SVishal Kulkarni err:
15637e6ad469SVishal Kulkarni return rc;
15647e6ad469SVishal Kulkarni }
15657e6ad469SVishal Kulkarni
15667e6ad469SVishal Kulkarni static int
collect_hw_sched(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)15677e6ad469SVishal Kulkarni collect_hw_sched(struct cudbg_init *pdbg_init,
15687e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
15697e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
15707e6ad469SVishal Kulkarni {
15717e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
15727e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
15737e6ad469SVishal Kulkarni struct struct_hw_sched *hw_sched_buff;
15747e6ad469SVishal Kulkarni u32 size;
15757e6ad469SVishal Kulkarni int i, rc = 0;
15767e6ad469SVishal Kulkarni
15777e6ad469SVishal Kulkarni if (!padap->params.vpd.cclk) {
15787e6ad469SVishal Kulkarni rc = CUDBG_STATUS_CCLK_NOT_DEFINED;
15797e6ad469SVishal Kulkarni goto err;
15807e6ad469SVishal Kulkarni }
15817e6ad469SVishal Kulkarni
15827e6ad469SVishal Kulkarni size = sizeof(struct struct_hw_sched);
15837e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
15847e6ad469SVishal Kulkarni if (rc)
15857e6ad469SVishal Kulkarni goto err;
15867e6ad469SVishal Kulkarni
15877e6ad469SVishal Kulkarni hw_sched_buff = (struct struct_hw_sched *) scratch_buff.data;
15887e6ad469SVishal Kulkarni
15897e6ad469SVishal Kulkarni hw_sched_buff->map = t4_read_reg(padap, A_TP_TX_MOD_QUEUE_REQ_MAP);
15907e6ad469SVishal Kulkarni hw_sched_buff->mode = G_TIMERMODE(t4_read_reg(padap, A_TP_MOD_CONFIG));
15917e6ad469SVishal Kulkarni t4_read_pace_tbl(padap, hw_sched_buff->pace_tab);
15927e6ad469SVishal Kulkarni
15937e6ad469SVishal Kulkarni for (i = 0; i < NTX_SCHED; ++i) {
15947e6ad469SVishal Kulkarni t4_get_tx_sched(padap, i, &hw_sched_buff->kbps[i],
15957e6ad469SVishal Kulkarni &hw_sched_buff->ipg[i], 1);
15967e6ad469SVishal Kulkarni }
15977e6ad469SVishal Kulkarni
15987e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
15997e6ad469SVishal Kulkarni if (rc)
16007e6ad469SVishal Kulkarni goto err1;
16017e6ad469SVishal Kulkarni
16027e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
16037e6ad469SVishal Kulkarni err1:
16047e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
16057e6ad469SVishal Kulkarni err:
16067e6ad469SVishal Kulkarni return rc;
16077e6ad469SVishal Kulkarni }
16087e6ad469SVishal Kulkarni
16097e6ad469SVishal Kulkarni static int
collect_pm_stats(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)16107e6ad469SVishal Kulkarni collect_pm_stats(struct cudbg_init *pdbg_init,
16117e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
16127e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
16137e6ad469SVishal Kulkarni {
16147e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
16157e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
16167e6ad469SVishal Kulkarni struct struct_pm_stats *pm_stats_buff;
16177e6ad469SVishal Kulkarni u32 size;
16187e6ad469SVishal Kulkarni int rc = 0;
16197e6ad469SVishal Kulkarni
16207e6ad469SVishal Kulkarni size = sizeof(struct struct_pm_stats);
16217e6ad469SVishal Kulkarni
16227e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
16237e6ad469SVishal Kulkarni if (rc)
16247e6ad469SVishal Kulkarni goto err;
16257e6ad469SVishal Kulkarni
16267e6ad469SVishal Kulkarni pm_stats_buff = (struct struct_pm_stats *) scratch_buff.data;
16277e6ad469SVishal Kulkarni
16287e6ad469SVishal Kulkarni t4_pmtx_get_stats(padap, pm_stats_buff->tx_cnt, pm_stats_buff->tx_cyc);
16297e6ad469SVishal Kulkarni t4_pmrx_get_stats(padap, pm_stats_buff->rx_cnt, pm_stats_buff->rx_cyc);
16307e6ad469SVishal Kulkarni
16317e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
16327e6ad469SVishal Kulkarni if (rc)
16337e6ad469SVishal Kulkarni goto err1;
16347e6ad469SVishal Kulkarni
16357e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
16367e6ad469SVishal Kulkarni err1:
16377e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
16387e6ad469SVishal Kulkarni err:
16397e6ad469SVishal Kulkarni return rc;
16407e6ad469SVishal Kulkarni }
16417e6ad469SVishal Kulkarni
16427e6ad469SVishal Kulkarni static int
collect_path_mtu(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)16437e6ad469SVishal Kulkarni collect_path_mtu(struct cudbg_init *pdbg_init,
16447e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
16457e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
16467e6ad469SVishal Kulkarni {
16477e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
16487e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
16497e6ad469SVishal Kulkarni u32 size;
16507e6ad469SVishal Kulkarni int rc = 0;
16517e6ad469SVishal Kulkarni
16527e6ad469SVishal Kulkarni size = NMTUS * sizeof(u16);
16537e6ad469SVishal Kulkarni
16547e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
16557e6ad469SVishal Kulkarni if (rc)
16567e6ad469SVishal Kulkarni goto err;
16577e6ad469SVishal Kulkarni
16587e6ad469SVishal Kulkarni t4_read_mtu_tbl(padap, (u16 *)scratch_buff.data, NULL);
16597e6ad469SVishal Kulkarni
16607e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
16617e6ad469SVishal Kulkarni if (rc)
16627e6ad469SVishal Kulkarni goto err1;
16637e6ad469SVishal Kulkarni
16647e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
16657e6ad469SVishal Kulkarni err1:
16667e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
16677e6ad469SVishal Kulkarni err:
16687e6ad469SVishal Kulkarni return rc;
16697e6ad469SVishal Kulkarni }
16707e6ad469SVishal Kulkarni
16717e6ad469SVishal Kulkarni static int
collect_rss_key(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)16727e6ad469SVishal Kulkarni collect_rss_key(struct cudbg_init *pdbg_init,
16737e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
16747e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
16757e6ad469SVishal Kulkarni {
16767e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
16777e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
16787e6ad469SVishal Kulkarni u32 size;
16797e6ad469SVishal Kulkarni
16807e6ad469SVishal Kulkarni int rc = 0;
16817e6ad469SVishal Kulkarni
16827e6ad469SVishal Kulkarni size = 10 * sizeof(u32);
16837e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
16847e6ad469SVishal Kulkarni if (rc)
16857e6ad469SVishal Kulkarni goto err;
16867e6ad469SVishal Kulkarni
16877e6ad469SVishal Kulkarni t4_read_rss_key(padap, (u32 *)scratch_buff.data, 1);
16887e6ad469SVishal Kulkarni
16897e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
16907e6ad469SVishal Kulkarni if (rc)
16917e6ad469SVishal Kulkarni goto err1;
16927e6ad469SVishal Kulkarni
16937e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
16947e6ad469SVishal Kulkarni err1:
16957e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
16967e6ad469SVishal Kulkarni err:
16977e6ad469SVishal Kulkarni return rc;
16987e6ad469SVishal Kulkarni }
16997e6ad469SVishal Kulkarni
17007e6ad469SVishal Kulkarni static int
collect_rss_config(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)17017e6ad469SVishal Kulkarni collect_rss_config(struct cudbg_init *pdbg_init,
17027e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
17037e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
17047e6ad469SVishal Kulkarni {
17057e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
17067e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
17077e6ad469SVishal Kulkarni struct rss_config *rss_conf;
17087e6ad469SVishal Kulkarni int rc;
17097e6ad469SVishal Kulkarni u32 size;
17107e6ad469SVishal Kulkarni
17117e6ad469SVishal Kulkarni size = sizeof(struct rss_config);
17127e6ad469SVishal Kulkarni
17137e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
17147e6ad469SVishal Kulkarni if (rc)
17157e6ad469SVishal Kulkarni goto err;
17167e6ad469SVishal Kulkarni
17177e6ad469SVishal Kulkarni rss_conf = (struct rss_config *)scratch_buff.data;
17187e6ad469SVishal Kulkarni
17197e6ad469SVishal Kulkarni rss_conf->tp_rssconf = t4_read_reg(padap, A_TP_RSS_CONFIG);
17207e6ad469SVishal Kulkarni rss_conf->tp_rssconf_tnl = t4_read_reg(padap, A_TP_RSS_CONFIG_TNL);
17217e6ad469SVishal Kulkarni rss_conf->tp_rssconf_ofd = t4_read_reg(padap, A_TP_RSS_CONFIG_OFD);
17227e6ad469SVishal Kulkarni rss_conf->tp_rssconf_syn = t4_read_reg(padap, A_TP_RSS_CONFIG_SYN);
17237e6ad469SVishal Kulkarni rss_conf->tp_rssconf_vrt = t4_read_reg(padap, A_TP_RSS_CONFIG_VRT);
17247e6ad469SVishal Kulkarni rss_conf->tp_rssconf_cng = t4_read_reg(padap, A_TP_RSS_CONFIG_CNG);
17257e6ad469SVishal Kulkarni rss_conf->chip = padap->params.chip;
17267e6ad469SVishal Kulkarni
17277e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
17287e6ad469SVishal Kulkarni if (rc)
17297e6ad469SVishal Kulkarni goto err1;
17307e6ad469SVishal Kulkarni
17317e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
17327e6ad469SVishal Kulkarni
17337e6ad469SVishal Kulkarni err1:
17347e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
17357e6ad469SVishal Kulkarni err:
17367e6ad469SVishal Kulkarni return rc;
17377e6ad469SVishal Kulkarni }
17387e6ad469SVishal Kulkarni
17397e6ad469SVishal Kulkarni static int
collect_rss_vf_config(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)17407e6ad469SVishal Kulkarni collect_rss_vf_config(struct cudbg_init *pdbg_init,
17417e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
17427e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
17437e6ad469SVishal Kulkarni {
17447e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
17457e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
17467e6ad469SVishal Kulkarni struct rss_vf_conf *vfconf;
17477e6ad469SVishal Kulkarni int vf, rc, vf_count = 0;
17487e6ad469SVishal Kulkarni u32 size;
17497e6ad469SVishal Kulkarni
17507e6ad469SVishal Kulkarni vf_count = padap->params.arch.vfcount;
17517e6ad469SVishal Kulkarni size = vf_count * sizeof(*vfconf);
17527e6ad469SVishal Kulkarni
17537e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
17547e6ad469SVishal Kulkarni if (rc)
17557e6ad469SVishal Kulkarni goto err;
17567e6ad469SVishal Kulkarni
17577e6ad469SVishal Kulkarni vfconf = (struct rss_vf_conf *)scratch_buff.data;
17587e6ad469SVishal Kulkarni
17597e6ad469SVishal Kulkarni for (vf = 0; vf < vf_count; vf++) {
17607e6ad469SVishal Kulkarni t4_read_rss_vf_config(padap, vf, &vfconf[vf].rss_vf_vfl,
17617e6ad469SVishal Kulkarni &vfconf[vf].rss_vf_vfh, 1);
17627e6ad469SVishal Kulkarni }
17637e6ad469SVishal Kulkarni
17647e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
17657e6ad469SVishal Kulkarni if (rc)
17667e6ad469SVishal Kulkarni goto err1;
17677e6ad469SVishal Kulkarni
17687e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
17697e6ad469SVishal Kulkarni
17707e6ad469SVishal Kulkarni err1:
17717e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
17727e6ad469SVishal Kulkarni err:
17737e6ad469SVishal Kulkarni return rc;
17747e6ad469SVishal Kulkarni }
17757e6ad469SVishal Kulkarni
17767e6ad469SVishal Kulkarni static int
collect_rss_pf_config(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)17777e6ad469SVishal Kulkarni collect_rss_pf_config(struct cudbg_init *pdbg_init,
17787e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
17797e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
17807e6ad469SVishal Kulkarni {
17817e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
17827e6ad469SVishal Kulkarni struct rss_pf_conf *pfconf;
17837e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
17847e6ad469SVishal Kulkarni u32 rss_pf_map, rss_pf_mask, size;
17857e6ad469SVishal Kulkarni int pf, rc;
17867e6ad469SVishal Kulkarni
17877e6ad469SVishal Kulkarni size = 8 * sizeof(*pfconf);
17887e6ad469SVishal Kulkarni
17897e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
17907e6ad469SVishal Kulkarni if (rc)
17917e6ad469SVishal Kulkarni goto err;
17927e6ad469SVishal Kulkarni
17937e6ad469SVishal Kulkarni pfconf = (struct rss_pf_conf *)scratch_buff.data;
17947e6ad469SVishal Kulkarni
17957e6ad469SVishal Kulkarni rss_pf_map = t4_read_rss_pf_map(padap, 1);
17967e6ad469SVishal Kulkarni rss_pf_mask = t4_read_rss_pf_mask(padap, 1);
17977e6ad469SVishal Kulkarni
17987e6ad469SVishal Kulkarni for (pf = 0; pf < 8; pf++) {
17997e6ad469SVishal Kulkarni pfconf[pf].rss_pf_map = rss_pf_map;
18007e6ad469SVishal Kulkarni pfconf[pf].rss_pf_mask = rss_pf_mask;
18017e6ad469SVishal Kulkarni /* no return val */
18027e6ad469SVishal Kulkarni t4_read_rss_pf_config(padap, pf, &pfconf[pf].rss_pf_config, 1);
18037e6ad469SVishal Kulkarni }
18047e6ad469SVishal Kulkarni
18057e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
18067e6ad469SVishal Kulkarni if (rc)
18077e6ad469SVishal Kulkarni goto err1;
18087e6ad469SVishal Kulkarni
18097e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
18107e6ad469SVishal Kulkarni err1:
18117e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
18127e6ad469SVishal Kulkarni err:
18137e6ad469SVishal Kulkarni return rc;
18147e6ad469SVishal Kulkarni }
18157e6ad469SVishal Kulkarni
18167e6ad469SVishal Kulkarni static int
check_valid(u32 * buf,int type)18177e6ad469SVishal Kulkarni check_valid(u32 *buf, int type)
18187e6ad469SVishal Kulkarni {
18197e6ad469SVishal Kulkarni int index;
18207e6ad469SVishal Kulkarni int bit;
18217e6ad469SVishal Kulkarni int bit_pos = 0;
18227e6ad469SVishal Kulkarni
18237e6ad469SVishal Kulkarni switch (type) {
18247e6ad469SVishal Kulkarni case CTXT_EGRESS:
18257e6ad469SVishal Kulkarni bit_pos = 176;
18267e6ad469SVishal Kulkarni break;
18277e6ad469SVishal Kulkarni case CTXT_INGRESS:
18287e6ad469SVishal Kulkarni bit_pos = 141;
18297e6ad469SVishal Kulkarni break;
18307e6ad469SVishal Kulkarni case CTXT_FLM:
18317e6ad469SVishal Kulkarni bit_pos = 89;
18327e6ad469SVishal Kulkarni break;
18337e6ad469SVishal Kulkarni }
18347e6ad469SVishal Kulkarni index = bit_pos / 32;
18357e6ad469SVishal Kulkarni bit = bit_pos % 32;
18367e6ad469SVishal Kulkarni
18377e6ad469SVishal Kulkarni return buf[index] & (1U << bit);
18387e6ad469SVishal Kulkarni }
18397e6ad469SVishal Kulkarni
18407e6ad469SVishal Kulkarni /**
18417e6ad469SVishal Kulkarni * Get EGRESS, INGRESS, FLM, and CNM max qid.
18427e6ad469SVishal Kulkarni *
18437e6ad469SVishal Kulkarni * For EGRESS and INGRESS, do the following calculation.
18447e6ad469SVishal Kulkarni * max_qid = (DBQ/IMSG context region size in bytes) /
18457e6ad469SVishal Kulkarni * (size of context in bytes).
18467e6ad469SVishal Kulkarni *
18477e6ad469SVishal Kulkarni * For FLM, do the following calculation.
18487e6ad469SVishal Kulkarni * max_qid = (FLM cache region size in bytes) /
18497e6ad469SVishal Kulkarni * ((number of pointers cached in EDRAM) * 8 (bytes per pointer)).
18507e6ad469SVishal Kulkarni *
18517e6ad469SVishal Kulkarni * There's a 1-to-1 mapping between FLM and CNM if there's no header splitting
18527e6ad469SVishal Kulkarni * enabled; i.e., max CNM qid is equal to max FLM qid. However, if header
18537e6ad469SVishal Kulkarni * splitting is enabled, then max CNM qid is half of max FLM qid.
18547e6ad469SVishal Kulkarni */
18557e6ad469SVishal Kulkarni static int
get_max_ctxt_qid(struct adapter * padap,struct struct_meminfo * meminfo,u32 * max_ctx_qid,u8 nelem)18567e6ad469SVishal Kulkarni get_max_ctxt_qid(struct adapter *padap,
18577e6ad469SVishal Kulkarni struct struct_meminfo *meminfo,
18587e6ad469SVishal Kulkarni u32 *max_ctx_qid, u8 nelem)
18597e6ad469SVishal Kulkarni {
18607e6ad469SVishal Kulkarni u32 i, idx, found = 0;
18617e6ad469SVishal Kulkarni
18627e6ad469SVishal Kulkarni if (nelem != (CTXT_CNM + 1))
18637e6ad469SVishal Kulkarni return -EINVAL;
18647e6ad469SVishal Kulkarni
18657e6ad469SVishal Kulkarni for (i = 0; i < meminfo->mem_c; i++) {
18667e6ad469SVishal Kulkarni if (meminfo->mem[i].idx >= ARRAY_SIZE(region))
18677e6ad469SVishal Kulkarni continue; /* skip holes */
18687e6ad469SVishal Kulkarni
18697e6ad469SVishal Kulkarni idx = meminfo->mem[i].idx;
18707e6ad469SVishal Kulkarni /* Get DBQ, IMSG, and FLM context region size */
18717e6ad469SVishal Kulkarni if (idx <= CTXT_FLM) {
18727e6ad469SVishal Kulkarni if (!(meminfo->mem[i].limit))
18737e6ad469SVishal Kulkarni meminfo->mem[i].limit =
18747e6ad469SVishal Kulkarni i < meminfo->mem_c - 1 ?
18757e6ad469SVishal Kulkarni meminfo->mem[i + 1].base - 1 : ~0;
18767e6ad469SVishal Kulkarni
18777e6ad469SVishal Kulkarni if (idx < CTXT_FLM) {
18787e6ad469SVishal Kulkarni /* Get EGRESS and INGRESS max qid. */
18797e6ad469SVishal Kulkarni max_ctx_qid[idx] = (meminfo->mem[i].limit -
18807e6ad469SVishal Kulkarni meminfo->mem[i].base + 1) /
18817e6ad469SVishal Kulkarni CUDBG_CTXT_SIZE_BYTES;
18827e6ad469SVishal Kulkarni found++;
18837e6ad469SVishal Kulkarni } else {
18847e6ad469SVishal Kulkarni /* Get FLM and CNM max qid. */
18857e6ad469SVishal Kulkarni u32 value, edram_ptr_count;
18867e6ad469SVishal Kulkarni u8 bytes_per_ptr = 8;
18877e6ad469SVishal Kulkarni u8 nohdr;
18887e6ad469SVishal Kulkarni
18897e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_SGE_FLM_CFG);
18907e6ad469SVishal Kulkarni
18917e6ad469SVishal Kulkarni /* Check if header splitting is enabled. */
18927e6ad469SVishal Kulkarni nohdr = (value >> S_NOHDR) & 1U;
18937e6ad469SVishal Kulkarni
18947e6ad469SVishal Kulkarni /* Get the number of pointers in EDRAM per
18957e6ad469SVishal Kulkarni * qid in units of 32.
18967e6ad469SVishal Kulkarni */
18977e6ad469SVishal Kulkarni edram_ptr_count = 32 *
18987e6ad469SVishal Kulkarni (1U << G_EDRAMPTRCNT(value));
18997e6ad469SVishal Kulkarni
19007e6ad469SVishal Kulkarni /* EDRAMPTRCNT value of 3 is reserved.
19017e6ad469SVishal Kulkarni * So don't exceed 128.
19027e6ad469SVishal Kulkarni */
19037e6ad469SVishal Kulkarni if (edram_ptr_count > 128)
19047e6ad469SVishal Kulkarni edram_ptr_count = 128;
19057e6ad469SVishal Kulkarni
19067e6ad469SVishal Kulkarni max_ctx_qid[idx] = (meminfo->mem[i].limit -
19077e6ad469SVishal Kulkarni meminfo->mem[i].base + 1) /
19087e6ad469SVishal Kulkarni (edram_ptr_count *
19097e6ad469SVishal Kulkarni bytes_per_ptr);
19107e6ad469SVishal Kulkarni found++;
19117e6ad469SVishal Kulkarni
19127e6ad469SVishal Kulkarni /* CNM has 1-to-1 mapping with FLM.
19137e6ad469SVishal Kulkarni * However, if header splitting is enabled,
19147e6ad469SVishal Kulkarni * then max CNM qid is half of max FLM qid.
19157e6ad469SVishal Kulkarni */
19167e6ad469SVishal Kulkarni max_ctx_qid[CTXT_CNM] = nohdr ?
19177e6ad469SVishal Kulkarni max_ctx_qid[idx] :
19187e6ad469SVishal Kulkarni max_ctx_qid[idx] >> 1;
19197e6ad469SVishal Kulkarni
19207e6ad469SVishal Kulkarni /* One more increment for CNM */
19217e6ad469SVishal Kulkarni found++;
19227e6ad469SVishal Kulkarni }
19237e6ad469SVishal Kulkarni }
19247e6ad469SVishal Kulkarni if (found == nelem)
19257e6ad469SVishal Kulkarni break;
19267e6ad469SVishal Kulkarni }
19277e6ad469SVishal Kulkarni
19287e6ad469SVishal Kulkarni /* Sanity check. Ensure the values are within known max. */
19297e6ad469SVishal Kulkarni max_ctx_qid[CTXT_EGRESS] = min_t(u32, max_ctx_qid[CTXT_EGRESS],
19307e6ad469SVishal Kulkarni M_CTXTQID);
19317e6ad469SVishal Kulkarni max_ctx_qid[CTXT_INGRESS] = min_t(u32, max_ctx_qid[CTXT_INGRESS],
19327e6ad469SVishal Kulkarni CUDBG_MAX_INGRESS_QIDS);
19337e6ad469SVishal Kulkarni max_ctx_qid[CTXT_FLM] = min_t(u32, max_ctx_qid[CTXT_FLM],
19347e6ad469SVishal Kulkarni CUDBG_MAX_FL_QIDS);
19357e6ad469SVishal Kulkarni max_ctx_qid[CTXT_CNM] = min_t(u32, max_ctx_qid[CTXT_CNM],
19367e6ad469SVishal Kulkarni CUDBG_MAX_CNM_QIDS);
19377e6ad469SVishal Kulkarni return 0;
19387e6ad469SVishal Kulkarni }
19397e6ad469SVishal Kulkarni
19407e6ad469SVishal Kulkarni static int
collect_dump_context(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)19417e6ad469SVishal Kulkarni collect_dump_context(struct cudbg_init *pdbg_init,
19427e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
19437e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
19447e6ad469SVishal Kulkarni {
19457e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
19467e6ad469SVishal Kulkarni struct cudbg_buffer temp_buff;
19477e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
19487e6ad469SVishal Kulkarni u32 size = 0, next_offset = 0, total_size = 0;
19497e6ad469SVishal Kulkarni struct cudbg_ch_cntxt *buff = NULL;
19507e6ad469SVishal Kulkarni struct struct_meminfo meminfo;
19517e6ad469SVishal Kulkarni int bytes = 0;
19527e6ad469SVishal Kulkarni int rc = 0;
19537e6ad469SVishal Kulkarni u32 i, j;
19547e6ad469SVishal Kulkarni u32 max_ctx_qid[CTXT_CNM + 1];
19557e6ad469SVishal Kulkarni bool limit_qid = false;
19567e6ad469SVishal Kulkarni u32 qid_count = 0;
19577e6ad469SVishal Kulkarni
19587e6ad469SVishal Kulkarni rc = fill_meminfo(padap, &meminfo);
19597e6ad469SVishal Kulkarni if (rc)
19607e6ad469SVishal Kulkarni goto err;
19617e6ad469SVishal Kulkarni
19627e6ad469SVishal Kulkarni /* Get max valid qid for each type of queue */
19637e6ad469SVishal Kulkarni rc = get_max_ctxt_qid(padap, &meminfo, max_ctx_qid, CTXT_CNM + 1);
19647e6ad469SVishal Kulkarni if (rc)
19657e6ad469SVishal Kulkarni goto err;
19667e6ad469SVishal Kulkarni
19677e6ad469SVishal Kulkarni /* There are four types of queues. Collect context upto max
19687e6ad469SVishal Kulkarni * qid of each type of queue.
19697e6ad469SVishal Kulkarni */
19707e6ad469SVishal Kulkarni for (i = CTXT_EGRESS; i <= CTXT_CNM; i++)
19717e6ad469SVishal Kulkarni size += sizeof(struct cudbg_ch_cntxt) * max_ctx_qid[i];
19727e6ad469SVishal Kulkarni
19737e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
19747e6ad469SVishal Kulkarni if (rc == CUDBG_STATUS_NO_SCRATCH_MEM) {
19757e6ad469SVishal Kulkarni /* Not enough scratch Memory available.
19767e6ad469SVishal Kulkarni * Collect context of at least CUDBG_LOWMEM_MAX_CTXT_QIDS
19777e6ad469SVishal Kulkarni * for each queue type.
19787e6ad469SVishal Kulkarni */
19797e6ad469SVishal Kulkarni size = 0;
19807e6ad469SVishal Kulkarni for (i = CTXT_EGRESS; i <= CTXT_CNM; i++)
19817e6ad469SVishal Kulkarni size += sizeof(struct cudbg_ch_cntxt) *
19827e6ad469SVishal Kulkarni CUDBG_LOWMEM_MAX_CTXT_QIDS;
19837e6ad469SVishal Kulkarni
19847e6ad469SVishal Kulkarni limit_qid = true;
19857e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
19867e6ad469SVishal Kulkarni if (rc)
19877e6ad469SVishal Kulkarni goto err;
19887e6ad469SVishal Kulkarni }
19897e6ad469SVishal Kulkarni
19907e6ad469SVishal Kulkarni buff = (struct cudbg_ch_cntxt *)scratch_buff.data;
19917e6ad469SVishal Kulkarni
19927e6ad469SVishal Kulkarni /* Collect context data */
19937e6ad469SVishal Kulkarni for (i = CTXT_EGRESS; i <= CTXT_FLM; i++) {
19947e6ad469SVishal Kulkarni qid_count = 0;
19957e6ad469SVishal Kulkarni for (j = 0; j < max_ctx_qid[i]; j++) {
19967e6ad469SVishal Kulkarni read_sge_ctxt(pdbg_init, j, i, buff->data);
19977e6ad469SVishal Kulkarni
19987e6ad469SVishal Kulkarni rc = check_valid(buff->data, i);
19997e6ad469SVishal Kulkarni if (rc) {
20007e6ad469SVishal Kulkarni buff->cntxt_type = i;
20017e6ad469SVishal Kulkarni buff->cntxt_id = j;
20027e6ad469SVishal Kulkarni buff++;
20037e6ad469SVishal Kulkarni total_size += sizeof(struct cudbg_ch_cntxt);
20047e6ad469SVishal Kulkarni
20057e6ad469SVishal Kulkarni if (i == CTXT_FLM) {
20067e6ad469SVishal Kulkarni read_sge_ctxt(pdbg_init, j, CTXT_CNM,
20077e6ad469SVishal Kulkarni buff->data);
20087e6ad469SVishal Kulkarni buff->cntxt_type = CTXT_CNM;
20097e6ad469SVishal Kulkarni buff->cntxt_id = j;
20107e6ad469SVishal Kulkarni buff++;
20117e6ad469SVishal Kulkarni total_size +=
20127e6ad469SVishal Kulkarni sizeof(struct cudbg_ch_cntxt);
20137e6ad469SVishal Kulkarni }
20147e6ad469SVishal Kulkarni qid_count++;
20157e6ad469SVishal Kulkarni }
20167e6ad469SVishal Kulkarni
20177e6ad469SVishal Kulkarni /* If there's not enough space to collect more qids,
20187e6ad469SVishal Kulkarni * then bail and move on to next queue type.
20197e6ad469SVishal Kulkarni */
20207e6ad469SVishal Kulkarni if (limit_qid &&
20217e6ad469SVishal Kulkarni qid_count >= CUDBG_LOWMEM_MAX_CTXT_QIDS)
20227e6ad469SVishal Kulkarni break;
20237e6ad469SVishal Kulkarni }
20247e6ad469SVishal Kulkarni }
20257e6ad469SVishal Kulkarni
20267e6ad469SVishal Kulkarni scratch_buff.size = total_size;
20277e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
20287e6ad469SVishal Kulkarni if (rc)
20297e6ad469SVishal Kulkarni goto err1;
20307e6ad469SVishal Kulkarni
20317e6ad469SVishal Kulkarni /* Splitting buffer and writing in terms of CUDBG_CHUNK_SIZE */
20327e6ad469SVishal Kulkarni while (total_size > 0) {
20337e6ad469SVishal Kulkarni bytes = min_t(unsigned long, (unsigned long)total_size,
20347e6ad469SVishal Kulkarni (unsigned long)CUDBG_CHUNK_SIZE);
20357e6ad469SVishal Kulkarni temp_buff.size = bytes;
20367e6ad469SVishal Kulkarni temp_buff.data = (void *)((char *)scratch_buff.data +
20377e6ad469SVishal Kulkarni next_offset);
20387e6ad469SVishal Kulkarni
20397e6ad469SVishal Kulkarni rc = compress_buff(&temp_buff, dbg_buff);
20407e6ad469SVishal Kulkarni if (rc)
20417e6ad469SVishal Kulkarni goto err1;
20427e6ad469SVishal Kulkarni
20437e6ad469SVishal Kulkarni total_size -= bytes;
20447e6ad469SVishal Kulkarni next_offset += bytes;
20457e6ad469SVishal Kulkarni }
20467e6ad469SVishal Kulkarni
20477e6ad469SVishal Kulkarni err1:
20487e6ad469SVishal Kulkarni scratch_buff.size = size;
20497e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
20507e6ad469SVishal Kulkarni err:
20517e6ad469SVishal Kulkarni return rc;
20527e6ad469SVishal Kulkarni }
20537e6ad469SVishal Kulkarni
20547e6ad469SVishal Kulkarni static int
collect_fw_devlog(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)20557e6ad469SVishal Kulkarni collect_fw_devlog(struct cudbg_init *pdbg_init,
20567e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
20577e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
20587e6ad469SVishal Kulkarni {
20597e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
20607e6ad469SVishal Kulkarni struct devlog_params *dparams = &padap->params.devlog;
20617e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
20627e6ad469SVishal Kulkarni u32 offset;
20637e6ad469SVishal Kulkarni int rc = 0;
20647e6ad469SVishal Kulkarni
20657e6ad469SVishal Kulkarni rc = t4_init_devlog_params(padap, 1);
20667e6ad469SVishal Kulkarni
20677e6ad469SVishal Kulkarni if (rc < 0) {
20687e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
20697e6ad469SVishal Kulkarni "%s(), t4_init_devlog_params failed!, rc: "\
20707e6ad469SVishal Kulkarni "%d\n", __func__, rc);
20717e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
20727e6ad469SVishal Kulkarni goto err;
20737e6ad469SVishal Kulkarni }
20747e6ad469SVishal Kulkarni
20757e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, dparams->size, &scratch_buff);
20767e6ad469SVishal Kulkarni
20777e6ad469SVishal Kulkarni if (rc)
20787e6ad469SVishal Kulkarni goto err;
20797e6ad469SVishal Kulkarni
20807e6ad469SVishal Kulkarni /* Collect FW devlog */
20817e6ad469SVishal Kulkarni if (dparams->start != 0) {
20827e6ad469SVishal Kulkarni offset = scratch_buff.offset;
20837e6ad469SVishal Kulkarni rc = t4_memory_rw(padap, padap->params.drv_memwin,
20847e6ad469SVishal Kulkarni dparams->memtype, dparams->start,
20857e6ad469SVishal Kulkarni dparams->size,
20867e6ad469SVishal Kulkarni (__be32 *)((char *)scratch_buff.data +
20877e6ad469SVishal Kulkarni offset), 1);
20887e6ad469SVishal Kulkarni
20897e6ad469SVishal Kulkarni if (rc) {
20907e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
20917e6ad469SVishal Kulkarni "%s(), t4_memory_rw failed!, rc: "\
20927e6ad469SVishal Kulkarni "%d\n", __func__, rc);
20937e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
20947e6ad469SVishal Kulkarni goto err1;
20957e6ad469SVishal Kulkarni }
20967e6ad469SVishal Kulkarni }
20977e6ad469SVishal Kulkarni
20987e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
20997e6ad469SVishal Kulkarni
21007e6ad469SVishal Kulkarni if (rc)
21017e6ad469SVishal Kulkarni goto err1;
21027e6ad469SVishal Kulkarni
21037e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
21047e6ad469SVishal Kulkarni
21057e6ad469SVishal Kulkarni err1:
21067e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
21077e6ad469SVishal Kulkarni err:
21087e6ad469SVishal Kulkarni return rc;
21097e6ad469SVishal Kulkarni }
21107e6ad469SVishal Kulkarni /* CIM OBQ */
21117e6ad469SVishal Kulkarni
21127e6ad469SVishal Kulkarni static int
collect_cim_obq_ulp0(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21137e6ad469SVishal Kulkarni collect_cim_obq_ulp0(struct cudbg_init *pdbg_init,
21147e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21157e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21167e6ad469SVishal Kulkarni {
21177e6ad469SVishal Kulkarni int rc = 0, qid = 0;
21187e6ad469SVishal Kulkarni
21197e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21207e6ad469SVishal Kulkarni
21217e6ad469SVishal Kulkarni return rc;
21227e6ad469SVishal Kulkarni }
21237e6ad469SVishal Kulkarni
21247e6ad469SVishal Kulkarni static int
collect_cim_obq_ulp1(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21257e6ad469SVishal Kulkarni collect_cim_obq_ulp1(struct cudbg_init *pdbg_init,
21267e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21277e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21287e6ad469SVishal Kulkarni {
21297e6ad469SVishal Kulkarni int rc = 0, qid = 1;
21307e6ad469SVishal Kulkarni
21317e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21327e6ad469SVishal Kulkarni
21337e6ad469SVishal Kulkarni return rc;
21347e6ad469SVishal Kulkarni }
21357e6ad469SVishal Kulkarni
21367e6ad469SVishal Kulkarni static int
collect_cim_obq_ulp2(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21377e6ad469SVishal Kulkarni collect_cim_obq_ulp2(struct cudbg_init *pdbg_init,
21387e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21397e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21407e6ad469SVishal Kulkarni {
21417e6ad469SVishal Kulkarni int rc = 0, qid = 2;
21427e6ad469SVishal Kulkarni
21437e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21447e6ad469SVishal Kulkarni
21457e6ad469SVishal Kulkarni return rc;
21467e6ad469SVishal Kulkarni }
21477e6ad469SVishal Kulkarni
21487e6ad469SVishal Kulkarni static int
collect_cim_obq_ulp3(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21497e6ad469SVishal Kulkarni collect_cim_obq_ulp3(struct cudbg_init *pdbg_init,
21507e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21517e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21527e6ad469SVishal Kulkarni {
21537e6ad469SVishal Kulkarni int rc = 0, qid = 3;
21547e6ad469SVishal Kulkarni
21557e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21567e6ad469SVishal Kulkarni
21577e6ad469SVishal Kulkarni return rc;
21587e6ad469SVishal Kulkarni }
21597e6ad469SVishal Kulkarni
21607e6ad469SVishal Kulkarni static int
collect_cim_obq_sge(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21617e6ad469SVishal Kulkarni collect_cim_obq_sge(struct cudbg_init *pdbg_init,
21627e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21637e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21647e6ad469SVishal Kulkarni {
21657e6ad469SVishal Kulkarni int rc = 0, qid = 4;
21667e6ad469SVishal Kulkarni
21677e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21687e6ad469SVishal Kulkarni
21697e6ad469SVishal Kulkarni return rc;
21707e6ad469SVishal Kulkarni }
21717e6ad469SVishal Kulkarni
21727e6ad469SVishal Kulkarni static int
collect_cim_obq_ncsi(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21737e6ad469SVishal Kulkarni collect_cim_obq_ncsi(struct cudbg_init *pdbg_init,
21747e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21757e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21767e6ad469SVishal Kulkarni {
21777e6ad469SVishal Kulkarni int rc = 0, qid = 5;
21787e6ad469SVishal Kulkarni
21797e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21807e6ad469SVishal Kulkarni
21817e6ad469SVishal Kulkarni return rc;
21827e6ad469SVishal Kulkarni }
21837e6ad469SVishal Kulkarni
21847e6ad469SVishal Kulkarni static int
collect_obq_sge_rx_q0(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21857e6ad469SVishal Kulkarni collect_obq_sge_rx_q0(struct cudbg_init *pdbg_init,
21867e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21877e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
21887e6ad469SVishal Kulkarni {
21897e6ad469SVishal Kulkarni int rc = 0, qid = 6;
21907e6ad469SVishal Kulkarni
21917e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
21927e6ad469SVishal Kulkarni
21937e6ad469SVishal Kulkarni return rc;
21947e6ad469SVishal Kulkarni }
21957e6ad469SVishal Kulkarni
21967e6ad469SVishal Kulkarni static int
collect_obq_sge_rx_q1(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)21977e6ad469SVishal Kulkarni collect_obq_sge_rx_q1(struct cudbg_init *pdbg_init,
21987e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
21997e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
22007e6ad469SVishal Kulkarni {
22017e6ad469SVishal Kulkarni int rc = 0, qid = 7;
22027e6ad469SVishal Kulkarni
22037e6ad469SVishal Kulkarni rc = read_cim_obq(pdbg_init, dbg_buff, cudbg_err, qid);
22047e6ad469SVishal Kulkarni
22057e6ad469SVishal Kulkarni return rc;
22067e6ad469SVishal Kulkarni }
22077e6ad469SVishal Kulkarni
22087e6ad469SVishal Kulkarni static int
read_cim_obq(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err,int qid)22097e6ad469SVishal Kulkarni read_cim_obq(struct cudbg_init *pdbg_init,
22107e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
22117e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err, int qid)
22127e6ad469SVishal Kulkarni {
22137e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
22147e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
22157e6ad469SVishal Kulkarni u32 qsize;
22167e6ad469SVishal Kulkarni int rc;
22177e6ad469SVishal Kulkarni int no_of_read_words;
22187e6ad469SVishal Kulkarni
22197e6ad469SVishal Kulkarni /* collect CIM OBQ */
22207e6ad469SVishal Kulkarni qsize = 6 * CIM_OBQ_SIZE * 4 * sizeof(u32);
22217e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, qsize, &scratch_buff);
22227e6ad469SVishal Kulkarni if (rc)
22237e6ad469SVishal Kulkarni goto err;
22247e6ad469SVishal Kulkarni
22257e6ad469SVishal Kulkarni /* t4_read_cim_obq will return no. of read words or error */
22267e6ad469SVishal Kulkarni no_of_read_words = t4_read_cim_obq(padap, qid,
22277e6ad469SVishal Kulkarni (u32 *)((u32 *)scratch_buff.data +
22287e6ad469SVishal Kulkarni scratch_buff.offset), qsize);
22297e6ad469SVishal Kulkarni
22307e6ad469SVishal Kulkarni /* no_of_read_words is less than or equal to 0 means error */
22317e6ad469SVishal Kulkarni if (no_of_read_words <= 0) {
22327e6ad469SVishal Kulkarni if (no_of_read_words == 0)
22337e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
22347e6ad469SVishal Kulkarni else
22357e6ad469SVishal Kulkarni rc = no_of_read_words;
22367e6ad469SVishal Kulkarni if (pdbg_init->verbose)
22377e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
22387e6ad469SVishal Kulkarni "%s: t4_read_cim_obq failed (%d)\n",
22397e6ad469SVishal Kulkarni __func__, rc);
22407e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
22417e6ad469SVishal Kulkarni goto err1;
22427e6ad469SVishal Kulkarni }
22437e6ad469SVishal Kulkarni
22447e6ad469SVishal Kulkarni scratch_buff.size = no_of_read_words * 4;
22457e6ad469SVishal Kulkarni
22467e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
22477e6ad469SVishal Kulkarni
22487e6ad469SVishal Kulkarni if (rc)
22497e6ad469SVishal Kulkarni goto err1;
22507e6ad469SVishal Kulkarni
22517e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
22527e6ad469SVishal Kulkarni
22537e6ad469SVishal Kulkarni if (rc)
22547e6ad469SVishal Kulkarni goto err1;
22557e6ad469SVishal Kulkarni
22567e6ad469SVishal Kulkarni err1:
22577e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
22587e6ad469SVishal Kulkarni err:
22597e6ad469SVishal Kulkarni return rc;
22607e6ad469SVishal Kulkarni }
22617e6ad469SVishal Kulkarni
22627e6ad469SVishal Kulkarni /* CIM IBQ */
22637e6ad469SVishal Kulkarni
22647e6ad469SVishal Kulkarni static int
collect_cim_ibq_tp0(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)22657e6ad469SVishal Kulkarni collect_cim_ibq_tp0(struct cudbg_init *pdbg_init,
22667e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
22677e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
22687e6ad469SVishal Kulkarni {
22697e6ad469SVishal Kulkarni int rc = 0, qid = 0;
22707e6ad469SVishal Kulkarni
22717e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
22727e6ad469SVishal Kulkarni return rc;
22737e6ad469SVishal Kulkarni }
22747e6ad469SVishal Kulkarni
22757e6ad469SVishal Kulkarni static int
collect_cim_ibq_tp1(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)22767e6ad469SVishal Kulkarni collect_cim_ibq_tp1(struct cudbg_init *pdbg_init,
22777e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
22787e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
22797e6ad469SVishal Kulkarni {
22807e6ad469SVishal Kulkarni int rc = 0, qid = 1;
22817e6ad469SVishal Kulkarni
22827e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
22837e6ad469SVishal Kulkarni return rc;
22847e6ad469SVishal Kulkarni }
22857e6ad469SVishal Kulkarni
22867e6ad469SVishal Kulkarni static int
collect_cim_ibq_ulp(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)22877e6ad469SVishal Kulkarni collect_cim_ibq_ulp(struct cudbg_init *pdbg_init,
22887e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
22897e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
22907e6ad469SVishal Kulkarni {
22917e6ad469SVishal Kulkarni int rc = 0, qid = 2;
22927e6ad469SVishal Kulkarni
22937e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
22947e6ad469SVishal Kulkarni return rc;
22957e6ad469SVishal Kulkarni }
22967e6ad469SVishal Kulkarni
22977e6ad469SVishal Kulkarni static int
collect_cim_ibq_sge0(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)22987e6ad469SVishal Kulkarni collect_cim_ibq_sge0(struct cudbg_init *pdbg_init,
22997e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
23007e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
23017e6ad469SVishal Kulkarni {
23027e6ad469SVishal Kulkarni int rc = 0, qid = 3;
23037e6ad469SVishal Kulkarni
23047e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
23057e6ad469SVishal Kulkarni return rc;
23067e6ad469SVishal Kulkarni }
23077e6ad469SVishal Kulkarni
23087e6ad469SVishal Kulkarni static int
collect_cim_ibq_sge1(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)23097e6ad469SVishal Kulkarni collect_cim_ibq_sge1(struct cudbg_init *pdbg_init,
23107e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
23117e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
23127e6ad469SVishal Kulkarni {
23137e6ad469SVishal Kulkarni int rc = 0, qid = 4;
23147e6ad469SVishal Kulkarni
23157e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
23167e6ad469SVishal Kulkarni return rc;
23177e6ad469SVishal Kulkarni }
23187e6ad469SVishal Kulkarni
23197e6ad469SVishal Kulkarni static int
collect_cim_ibq_ncsi(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)23207e6ad469SVishal Kulkarni collect_cim_ibq_ncsi(struct cudbg_init *pdbg_init,
23217e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
23227e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
23237e6ad469SVishal Kulkarni {
23247e6ad469SVishal Kulkarni int rc, qid = 5;
23257e6ad469SVishal Kulkarni
23267e6ad469SVishal Kulkarni rc = read_cim_ibq(pdbg_init, dbg_buff, cudbg_err, qid);
23277e6ad469SVishal Kulkarni return rc;
23287e6ad469SVishal Kulkarni }
23297e6ad469SVishal Kulkarni
23307e6ad469SVishal Kulkarni static int
read_cim_ibq(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err,int qid)23317e6ad469SVishal Kulkarni read_cim_ibq(struct cudbg_init *pdbg_init,
23327e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
23337e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err, int qid)
23347e6ad469SVishal Kulkarni {
23357e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
23367e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
23377e6ad469SVishal Kulkarni u32 qsize;
23387e6ad469SVishal Kulkarni int rc;
23397e6ad469SVishal Kulkarni int no_of_read_words;
23407e6ad469SVishal Kulkarni
23417e6ad469SVishal Kulkarni /* collect CIM IBQ */
23427e6ad469SVishal Kulkarni qsize = CIM_IBQ_SIZE * 4 * sizeof(u32);
23437e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, qsize, &scratch_buff);
23447e6ad469SVishal Kulkarni
23457e6ad469SVishal Kulkarni if (rc)
23467e6ad469SVishal Kulkarni goto err;
23477e6ad469SVishal Kulkarni
23487e6ad469SVishal Kulkarni /* t4_read_cim_ibq will return no. of read words or error */
23497e6ad469SVishal Kulkarni no_of_read_words = t4_read_cim_ibq(padap, qid,
23507e6ad469SVishal Kulkarni (u32 *)((u32 *)scratch_buff.data +
23517e6ad469SVishal Kulkarni scratch_buff.offset), qsize);
23527e6ad469SVishal Kulkarni /* no_of_read_words is less than or equal to 0 means error */
23537e6ad469SVishal Kulkarni if (no_of_read_words <= 0) {
23547e6ad469SVishal Kulkarni if (no_of_read_words == 0)
23557e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
23567e6ad469SVishal Kulkarni else
23577e6ad469SVishal Kulkarni rc = no_of_read_words;
23587e6ad469SVishal Kulkarni if (pdbg_init->verbose)
23597e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
23607e6ad469SVishal Kulkarni "%s: t4_read_cim_ibq failed (%d)\n",
23617e6ad469SVishal Kulkarni __func__, rc);
23627e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
23637e6ad469SVishal Kulkarni goto err1;
23647e6ad469SVishal Kulkarni }
23657e6ad469SVishal Kulkarni
23667e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
23677e6ad469SVishal Kulkarni if (rc)
23687e6ad469SVishal Kulkarni goto err1;
23697e6ad469SVishal Kulkarni
23707e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
23717e6ad469SVishal Kulkarni if (rc)
23727e6ad469SVishal Kulkarni goto err1;
23737e6ad469SVishal Kulkarni
23747e6ad469SVishal Kulkarni err1:
23757e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
23767e6ad469SVishal Kulkarni
23777e6ad469SVishal Kulkarni err:
23787e6ad469SVishal Kulkarni return rc;
23797e6ad469SVishal Kulkarni }
23807e6ad469SVishal Kulkarni
23817e6ad469SVishal Kulkarni static int
collect_cim_ma_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)23827e6ad469SVishal Kulkarni collect_cim_ma_la(struct cudbg_init *pdbg_init,
23837e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
23847e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
23857e6ad469SVishal Kulkarni {
23867e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
23877e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
23887e6ad469SVishal Kulkarni u32 rc = 0;
23897e6ad469SVishal Kulkarni
23907e6ad469SVishal Kulkarni /* collect CIM MA LA */
23917e6ad469SVishal Kulkarni scratch_buff.size = 2 * CIM_MALA_SIZE * 5 * sizeof(u32);
23927e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
23937e6ad469SVishal Kulkarni if (rc)
23947e6ad469SVishal Kulkarni goto err;
23957e6ad469SVishal Kulkarni
23967e6ad469SVishal Kulkarni /* no return */
23977e6ad469SVishal Kulkarni t4_cim_read_ma_la(padap,
23987e6ad469SVishal Kulkarni (u32 *) ((char *)scratch_buff.data +
23997e6ad469SVishal Kulkarni scratch_buff.offset),
24007e6ad469SVishal Kulkarni (u32 *) ((char *)scratch_buff.data +
24017e6ad469SVishal Kulkarni scratch_buff.offset + 5 * CIM_MALA_SIZE));
24027e6ad469SVishal Kulkarni
24037e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
24047e6ad469SVishal Kulkarni if (rc)
24057e6ad469SVishal Kulkarni goto err1;
24067e6ad469SVishal Kulkarni
24077e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
24087e6ad469SVishal Kulkarni
24097e6ad469SVishal Kulkarni err1:
24107e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
24117e6ad469SVishal Kulkarni err:
24127e6ad469SVishal Kulkarni return rc;
24137e6ad469SVishal Kulkarni }
24147e6ad469SVishal Kulkarni
24157e6ad469SVishal Kulkarni static int
collect_cim_la(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)24167e6ad469SVishal Kulkarni collect_cim_la(struct cudbg_init *pdbg_init,
24177e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
24187e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
24197e6ad469SVishal Kulkarni {
24207e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
24217e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
24227e6ad469SVishal Kulkarni
24237e6ad469SVishal Kulkarni int rc;
24247e6ad469SVishal Kulkarni u32 cfg = 0;
24257e6ad469SVishal Kulkarni int size;
24267e6ad469SVishal Kulkarni
24277e6ad469SVishal Kulkarni /* collect CIM LA */
24287e6ad469SVishal Kulkarni if (is_t6(padap->params.chip)) {
24297e6ad469SVishal Kulkarni size = padap->params.cim_la_size / 10 + 1;
24307e6ad469SVishal Kulkarni size *= 11 * sizeof(u32);
24317e6ad469SVishal Kulkarni } else {
24327e6ad469SVishal Kulkarni size = padap->params.cim_la_size / 8;
24337e6ad469SVishal Kulkarni size *= 8 * sizeof(u32);
24347e6ad469SVishal Kulkarni }
24357e6ad469SVishal Kulkarni
24367e6ad469SVishal Kulkarni size += sizeof(cfg);
24377e6ad469SVishal Kulkarni
24387e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, size, &scratch_buff);
24397e6ad469SVishal Kulkarni if (rc)
24407e6ad469SVishal Kulkarni goto err;
24417e6ad469SVishal Kulkarni
24427e6ad469SVishal Kulkarni rc = t4_cim_read(padap, A_UP_UP_DBG_LA_CFG, 1, &cfg);
24437e6ad469SVishal Kulkarni
24447e6ad469SVishal Kulkarni if (rc) {
24457e6ad469SVishal Kulkarni if (pdbg_init->verbose)
24467e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
24477e6ad469SVishal Kulkarni "%s: t4_cim_read failed (%d)\n",
24487e6ad469SVishal Kulkarni __func__, rc);
24497e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
24507e6ad469SVishal Kulkarni goto err1;
24517e6ad469SVishal Kulkarni }
24527e6ad469SVishal Kulkarni
24537e6ad469SVishal Kulkarni memcpy((char *)scratch_buff.data + scratch_buff.offset, &cfg,
24547e6ad469SVishal Kulkarni sizeof(cfg));
24557e6ad469SVishal Kulkarni
24567e6ad469SVishal Kulkarni rc = t4_cim_read_la(padap,
24577e6ad469SVishal Kulkarni (u32 *) ((char *)scratch_buff.data +
24587e6ad469SVishal Kulkarni scratch_buff.offset + sizeof(cfg)), NULL);
24597e6ad469SVishal Kulkarni if (rc < 0) {
24607e6ad469SVishal Kulkarni if (pdbg_init->verbose)
24617e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
24627e6ad469SVishal Kulkarni "%s: t4_cim_read_la failed (%d)\n",
24637e6ad469SVishal Kulkarni __func__, rc);
24647e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
24657e6ad469SVishal Kulkarni goto err1;
24667e6ad469SVishal Kulkarni }
24677e6ad469SVishal Kulkarni
24687e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
24697e6ad469SVishal Kulkarni if (rc)
24707e6ad469SVishal Kulkarni goto err1;
24717e6ad469SVishal Kulkarni
24727e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
24737e6ad469SVishal Kulkarni if (rc)
24747e6ad469SVishal Kulkarni goto err1;
24757e6ad469SVishal Kulkarni
24767e6ad469SVishal Kulkarni err1:
24777e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
24787e6ad469SVishal Kulkarni err:
24797e6ad469SVishal Kulkarni return rc;
24807e6ad469SVishal Kulkarni }
24817e6ad469SVishal Kulkarni
24827e6ad469SVishal Kulkarni static int
collect_cim_qcfg(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)24837e6ad469SVishal Kulkarni collect_cim_qcfg(struct cudbg_init *pdbg_init,
24847e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
24857e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
24867e6ad469SVishal Kulkarni {
24877e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
24887e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
24897e6ad469SVishal Kulkarni u32 offset;
24907e6ad469SVishal Kulkarni int rc = 0;
24917e6ad469SVishal Kulkarni
24927e6ad469SVishal Kulkarni struct struct_cim_qcfg *cim_qcfg_data = NULL;
24937e6ad469SVishal Kulkarni
24947e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, sizeof(struct struct_cim_qcfg),
24957e6ad469SVishal Kulkarni &scratch_buff);
24967e6ad469SVishal Kulkarni
24977e6ad469SVishal Kulkarni if (rc)
24987e6ad469SVishal Kulkarni goto err;
24997e6ad469SVishal Kulkarni
25007e6ad469SVishal Kulkarni offset = scratch_buff.offset;
25017e6ad469SVishal Kulkarni
25027e6ad469SVishal Kulkarni cim_qcfg_data =
25037e6ad469SVishal Kulkarni (struct struct_cim_qcfg *)((u8 *)((char *)scratch_buff.data +
25047e6ad469SVishal Kulkarni offset));
25057e6ad469SVishal Kulkarni
25067e6ad469SVishal Kulkarni rc = t4_cim_read(padap, A_UP_IBQ_0_RDADDR,
25077e6ad469SVishal Kulkarni ARRAY_SIZE(cim_qcfg_data->stat), cim_qcfg_data->stat);
25087e6ad469SVishal Kulkarni
25097e6ad469SVishal Kulkarni if (rc) {
25107e6ad469SVishal Kulkarni if (pdbg_init->verbose)
25117e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
25127e6ad469SVishal Kulkarni "%s: t4_cim_read IBQ_0_RDADDR failed (%d)\n",
25137e6ad469SVishal Kulkarni __func__, rc);
25147e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
25157e6ad469SVishal Kulkarni goto err1;
25167e6ad469SVishal Kulkarni }
25177e6ad469SVishal Kulkarni
25187e6ad469SVishal Kulkarni rc = t4_cim_read(padap, A_UP_OBQ_0_REALADDR,
25197e6ad469SVishal Kulkarni ARRAY_SIZE(cim_qcfg_data->obq_wr),
25207e6ad469SVishal Kulkarni cim_qcfg_data->obq_wr);
25217e6ad469SVishal Kulkarni
25227e6ad469SVishal Kulkarni if (rc) {
25237e6ad469SVishal Kulkarni if (pdbg_init->verbose)
25247e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
25257e6ad469SVishal Kulkarni "%s: t4_cim_read OBQ_0_REALADDR failed (%d)\n",
25267e6ad469SVishal Kulkarni __func__, rc);
25277e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
25287e6ad469SVishal Kulkarni goto err1;
25297e6ad469SVishal Kulkarni }
25307e6ad469SVishal Kulkarni
25317e6ad469SVishal Kulkarni /* no return val */
25327e6ad469SVishal Kulkarni t4_read_cimq_cfg(padap,
25337e6ad469SVishal Kulkarni cim_qcfg_data->base,
25347e6ad469SVishal Kulkarni cim_qcfg_data->size,
25357e6ad469SVishal Kulkarni cim_qcfg_data->thres);
25367e6ad469SVishal Kulkarni
25377e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
25387e6ad469SVishal Kulkarni if (rc)
25397e6ad469SVishal Kulkarni goto err1;
25407e6ad469SVishal Kulkarni
25417e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
25427e6ad469SVishal Kulkarni if (rc)
25437e6ad469SVishal Kulkarni goto err1;
25447e6ad469SVishal Kulkarni
25457e6ad469SVishal Kulkarni err1:
25467e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
25477e6ad469SVishal Kulkarni err:
25487e6ad469SVishal Kulkarni return rc;
25497e6ad469SVishal Kulkarni }
25507e6ad469SVishal Kulkarni
25517e6ad469SVishal Kulkarni static int
read_fw_mem(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,u8 mem_type,unsigned long tot_len,struct cudbg_error * cudbg_err)25527e6ad469SVishal Kulkarni read_fw_mem(struct cudbg_init *pdbg_init,
25537e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff, u8 mem_type,
25547e6ad469SVishal Kulkarni unsigned long tot_len, struct cudbg_error *cudbg_err)
25557e6ad469SVishal Kulkarni {
25567e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
25577e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
25587e6ad469SVishal Kulkarni unsigned long bytes_read = 0;
25597e6ad469SVishal Kulkarni unsigned long bytes_left;
25607e6ad469SVishal Kulkarni unsigned long bytes;
25617e6ad469SVishal Kulkarni int rc;
25627e6ad469SVishal Kulkarni
25637e6ad469SVishal Kulkarni bytes_left = tot_len;
25647e6ad469SVishal Kulkarni scratch_buff.size = tot_len;
25657e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
25667e6ad469SVishal Kulkarni if (rc)
25677e6ad469SVishal Kulkarni goto err;
25687e6ad469SVishal Kulkarni
25697e6ad469SVishal Kulkarni while (bytes_left > 0) {
25707e6ad469SVishal Kulkarni bytes = min_t(unsigned long, bytes_left, (unsigned long)CUDBG_CHUNK_SIZE);
25717e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, bytes, &scratch_buff);
25727e6ad469SVishal Kulkarni
25737e6ad469SVishal Kulkarni if (rc) {
25747e6ad469SVishal Kulkarni rc = CUDBG_STATUS_NO_SCRATCH_MEM;
25757e6ad469SVishal Kulkarni goto err;
25767e6ad469SVishal Kulkarni }
25777e6ad469SVishal Kulkarni
25787e6ad469SVishal Kulkarni /* Read from file */
25797e6ad469SVishal Kulkarni /*fread(scratch_buff.data, 1, Bytes, in);*/
25807e6ad469SVishal Kulkarni rc = t4_memory_rw(padap, MEMWIN_NIC, mem_type, bytes_read,
25817e6ad469SVishal Kulkarni bytes, (__be32 *)(scratch_buff.data), 1);
25827e6ad469SVishal Kulkarni
25837e6ad469SVishal Kulkarni if (rc) {
25847e6ad469SVishal Kulkarni if (pdbg_init->verbose)
25857e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
25867e6ad469SVishal Kulkarni "%s: t4_memory_rw failed (%d)",
25877e6ad469SVishal Kulkarni __func__, rc);
25887e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
25897e6ad469SVishal Kulkarni goto err1;
25907e6ad469SVishal Kulkarni }
25917e6ad469SVishal Kulkarni
25927e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
25937e6ad469SVishal Kulkarni if (rc)
25947e6ad469SVishal Kulkarni goto err1;
25957e6ad469SVishal Kulkarni
25967e6ad469SVishal Kulkarni bytes_left -= bytes;
25977e6ad469SVishal Kulkarni bytes_read += bytes;
25987e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
25997e6ad469SVishal Kulkarni }
26007e6ad469SVishal Kulkarni
26017e6ad469SVishal Kulkarni err1:
26027e6ad469SVishal Kulkarni if (rc)
26037e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
26047e6ad469SVishal Kulkarni
26057e6ad469SVishal Kulkarni err:
26067e6ad469SVishal Kulkarni return rc;
26077e6ad469SVishal Kulkarni }
26087e6ad469SVishal Kulkarni
26097e6ad469SVishal Kulkarni static void
collect_mem_info(struct cudbg_init * pdbg_init,struct card_mem * mem_info)26107e6ad469SVishal Kulkarni collect_mem_info(struct cudbg_init *pdbg_init,
26117e6ad469SVishal Kulkarni struct card_mem *mem_info)
26127e6ad469SVishal Kulkarni {
26137e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
26147e6ad469SVishal Kulkarni u32 value;
26157e6ad469SVishal Kulkarni int t4 = 0;
26167e6ad469SVishal Kulkarni
26177e6ad469SVishal Kulkarni if (is_t4(padap->params.chip))
26187e6ad469SVishal Kulkarni t4 = 1;
26197e6ad469SVishal Kulkarni
26207e6ad469SVishal Kulkarni if (t4) {
26217e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_EXT_MEMORY_BAR);
26227e6ad469SVishal Kulkarni value = G_EXT_MEM_SIZE(value);
26237e6ad469SVishal Kulkarni mem_info->size_mc0 = (u16)value; /* size in MB */
26247e6ad469SVishal Kulkarni
26257e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_TARGET_MEM_ENABLE);
26267e6ad469SVishal Kulkarni if (value & F_EXT_MEM_ENABLE)
26277e6ad469SVishal Kulkarni mem_info->mem_flag |= (1 << MC0_FLAG); /* set mc0 flag
26287e6ad469SVishal Kulkarni bit */
26297e6ad469SVishal Kulkarni } else {
26307e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_EXT_MEMORY0_BAR);
26317e6ad469SVishal Kulkarni value = G_EXT_MEM0_SIZE(value);
26327e6ad469SVishal Kulkarni mem_info->size_mc0 = (u16)value;
26337e6ad469SVishal Kulkarni
26347e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_EXT_MEMORY1_BAR);
26357e6ad469SVishal Kulkarni value = G_EXT_MEM1_SIZE(value);
26367e6ad469SVishal Kulkarni mem_info->size_mc1 = (u16)value;
26377e6ad469SVishal Kulkarni
26387e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_TARGET_MEM_ENABLE);
26397e6ad469SVishal Kulkarni if (value & F_EXT_MEM0_ENABLE)
26407e6ad469SVishal Kulkarni mem_info->mem_flag |= (1 << MC0_FLAG);
26417e6ad469SVishal Kulkarni if (value & F_EXT_MEM1_ENABLE)
26427e6ad469SVishal Kulkarni mem_info->mem_flag |= (1 << MC1_FLAG);
26437e6ad469SVishal Kulkarni }
26447e6ad469SVishal Kulkarni
26457e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_EDRAM0_BAR);
26467e6ad469SVishal Kulkarni value = G_EDRAM0_SIZE(value);
26477e6ad469SVishal Kulkarni mem_info->size_edc0 = (u16)value;
26487e6ad469SVishal Kulkarni
26497e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_EDRAM1_BAR);
26507e6ad469SVishal Kulkarni value = G_EDRAM1_SIZE(value);
26517e6ad469SVishal Kulkarni mem_info->size_edc1 = (u16)value;
26527e6ad469SVishal Kulkarni
26537e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_MA_TARGET_MEM_ENABLE);
26547e6ad469SVishal Kulkarni if (value & F_EDRAM0_ENABLE)
26557e6ad469SVishal Kulkarni mem_info->mem_flag |= (1 << EDC0_FLAG);
26567e6ad469SVishal Kulkarni if (value & F_EDRAM1_ENABLE)
26577e6ad469SVishal Kulkarni mem_info->mem_flag |= (1 << EDC1_FLAG);
26587e6ad469SVishal Kulkarni
26597e6ad469SVishal Kulkarni }
26607e6ad469SVishal Kulkarni
26617e6ad469SVishal Kulkarni static void
cudbg_t4_fwcache(struct cudbg_init * pdbg_init,struct cudbg_error * cudbg_err)26627e6ad469SVishal Kulkarni cudbg_t4_fwcache(struct cudbg_init *pdbg_init,
26637e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
26647e6ad469SVishal Kulkarni {
26657e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
26667e6ad469SVishal Kulkarni int rc;
26677e6ad469SVishal Kulkarni
26687e6ad469SVishal Kulkarni if (is_fw_attached(pdbg_init)) {
26697e6ad469SVishal Kulkarni
26707e6ad469SVishal Kulkarni /* Flush uP dcache before reading edcX/mcX */
26717e6ad469SVishal Kulkarni rc = begin_synchronized_op(padap->port[0], 1, 1);
26727e6ad469SVishal Kulkarni if (rc == 0) {
26737e6ad469SVishal Kulkarni rc = t4_fwcache(padap, FW_PARAM_DEV_FWCACHE_FLUSH);
26747e6ad469SVishal Kulkarni end_synchronized_op(padap->port[0], 1);
26757e6ad469SVishal Kulkarni }
26767e6ad469SVishal Kulkarni
26777e6ad469SVishal Kulkarni if (rc) {
26787e6ad469SVishal Kulkarni if (pdbg_init->verbose)
26797e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
26807e6ad469SVishal Kulkarni "%s: t4_fwcache failed (%d)\n",
26817e6ad469SVishal Kulkarni __func__, rc);
26827e6ad469SVishal Kulkarni cudbg_err->sys_warn = rc;
26837e6ad469SVishal Kulkarni }
26847e6ad469SVishal Kulkarni }
26857e6ad469SVishal Kulkarni }
26867e6ad469SVishal Kulkarni
26877e6ad469SVishal Kulkarni static int
collect_edc0_meminfo(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)26887e6ad469SVishal Kulkarni collect_edc0_meminfo(struct cudbg_init *pdbg_init,
26897e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
26907e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
26917e6ad469SVishal Kulkarni {
26927e6ad469SVishal Kulkarni struct card_mem mem_info = {0};
26937e6ad469SVishal Kulkarni unsigned long edc0_size;
26947e6ad469SVishal Kulkarni int rc;
26957e6ad469SVishal Kulkarni
26967e6ad469SVishal Kulkarni cudbg_t4_fwcache(pdbg_init, cudbg_err);
26977e6ad469SVishal Kulkarni
26987e6ad469SVishal Kulkarni collect_mem_info(pdbg_init, &mem_info);
26997e6ad469SVishal Kulkarni
27007e6ad469SVishal Kulkarni if (mem_info.mem_flag & (1 << EDC0_FLAG)) {
27017e6ad469SVishal Kulkarni edc0_size = (((unsigned long)mem_info.size_edc0) * 1024 * 1024);
27027e6ad469SVishal Kulkarni rc = read_fw_mem(pdbg_init, dbg_buff, MEM_EDC0,
27037e6ad469SVishal Kulkarni edc0_size, cudbg_err);
27047e6ad469SVishal Kulkarni if (rc)
27057e6ad469SVishal Kulkarni goto err;
27067e6ad469SVishal Kulkarni
27077e6ad469SVishal Kulkarni } else {
27087e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
27097e6ad469SVishal Kulkarni if (pdbg_init->verbose)
27107e6ad469SVishal Kulkarni pdbg_init->print(pdbg_init->adap->dip, CE_NOTE,
27117e6ad469SVishal Kulkarni "%s(), collect_mem_info failed!, %s\n",
27127e6ad469SVishal Kulkarni __func__, err_msg[-rc]);
27137e6ad469SVishal Kulkarni goto err;
27147e6ad469SVishal Kulkarni
27157e6ad469SVishal Kulkarni }
27167e6ad469SVishal Kulkarni err:
27177e6ad469SVishal Kulkarni return rc;
27187e6ad469SVishal Kulkarni }
27197e6ad469SVishal Kulkarni
27207e6ad469SVishal Kulkarni static int
collect_edc1_meminfo(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)27217e6ad469SVishal Kulkarni collect_edc1_meminfo(struct cudbg_init *pdbg_init,
27227e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
27237e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
27247e6ad469SVishal Kulkarni {
27257e6ad469SVishal Kulkarni struct card_mem mem_info = {0};
27267e6ad469SVishal Kulkarni unsigned long edc1_size;
27277e6ad469SVishal Kulkarni int rc;
27287e6ad469SVishal Kulkarni
27297e6ad469SVishal Kulkarni cudbg_t4_fwcache(pdbg_init, cudbg_err);
27307e6ad469SVishal Kulkarni
27317e6ad469SVishal Kulkarni collect_mem_info(pdbg_init, &mem_info);
27327e6ad469SVishal Kulkarni
27337e6ad469SVishal Kulkarni if (mem_info.mem_flag & (1 << EDC1_FLAG)) {
27347e6ad469SVishal Kulkarni edc1_size = (((unsigned long)mem_info.size_edc1) * 1024 * 1024);
27357e6ad469SVishal Kulkarni rc = read_fw_mem(pdbg_init, dbg_buff, MEM_EDC1,
27367e6ad469SVishal Kulkarni edc1_size, cudbg_err);
27377e6ad469SVishal Kulkarni if (rc)
27387e6ad469SVishal Kulkarni goto err;
27397e6ad469SVishal Kulkarni } else {
27407e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
27417e6ad469SVishal Kulkarni if (pdbg_init->verbose)
27427e6ad469SVishal Kulkarni pdbg_init->print(pdbg_init->adap->dip, CE_NOTE,
27437e6ad469SVishal Kulkarni "%s(), collect_mem_info failed!, %s\n",
27447e6ad469SVishal Kulkarni __func__, err_msg[-rc]);
27457e6ad469SVishal Kulkarni goto err;
27467e6ad469SVishal Kulkarni }
27477e6ad469SVishal Kulkarni
27487e6ad469SVishal Kulkarni err:
27497e6ad469SVishal Kulkarni
27507e6ad469SVishal Kulkarni return rc;
27517e6ad469SVishal Kulkarni }
27527e6ad469SVishal Kulkarni
27537e6ad469SVishal Kulkarni static int
collect_mc0_meminfo(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)27547e6ad469SVishal Kulkarni collect_mc0_meminfo(struct cudbg_init *pdbg_init,
27557e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
27567e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
27577e6ad469SVishal Kulkarni {
27587e6ad469SVishal Kulkarni struct card_mem mem_info = {0};
27597e6ad469SVishal Kulkarni unsigned long mc0_size;
27607e6ad469SVishal Kulkarni int rc;
27617e6ad469SVishal Kulkarni
27627e6ad469SVishal Kulkarni cudbg_t4_fwcache(pdbg_init, cudbg_err);
27637e6ad469SVishal Kulkarni
27647e6ad469SVishal Kulkarni collect_mem_info(pdbg_init, &mem_info);
27657e6ad469SVishal Kulkarni
27667e6ad469SVishal Kulkarni if (mem_info.mem_flag & (1 << MC0_FLAG)) {
27677e6ad469SVishal Kulkarni mc0_size = (((unsigned long)mem_info.size_mc0) * 1024 * 1024);
27687e6ad469SVishal Kulkarni rc = read_fw_mem(pdbg_init, dbg_buff, MEM_MC0,
27697e6ad469SVishal Kulkarni mc0_size, cudbg_err);
27707e6ad469SVishal Kulkarni if (rc)
27717e6ad469SVishal Kulkarni goto err;
27727e6ad469SVishal Kulkarni } else {
27737e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
27747e6ad469SVishal Kulkarni if (pdbg_init->verbose)
27757e6ad469SVishal Kulkarni pdbg_init->print(pdbg_init->adap->dip, CE_NOTE,
27767e6ad469SVishal Kulkarni "%s(), collect_mem_info failed!, %s\n",
27777e6ad469SVishal Kulkarni __func__, err_msg[-rc]);
27787e6ad469SVishal Kulkarni goto err;
27797e6ad469SVishal Kulkarni }
27807e6ad469SVishal Kulkarni
27817e6ad469SVishal Kulkarni err:
27827e6ad469SVishal Kulkarni return rc;
27837e6ad469SVishal Kulkarni }
27847e6ad469SVishal Kulkarni
27857e6ad469SVishal Kulkarni static int
collect_mc1_meminfo(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)27867e6ad469SVishal Kulkarni collect_mc1_meminfo(struct cudbg_init *pdbg_init,
27877e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
27887e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
27897e6ad469SVishal Kulkarni {
27907e6ad469SVishal Kulkarni struct card_mem mem_info = {0};
27917e6ad469SVishal Kulkarni unsigned long mc1_size;
27927e6ad469SVishal Kulkarni int rc;
27937e6ad469SVishal Kulkarni
27947e6ad469SVishal Kulkarni cudbg_t4_fwcache(pdbg_init, cudbg_err);
27957e6ad469SVishal Kulkarni
27967e6ad469SVishal Kulkarni collect_mem_info(pdbg_init, &mem_info);
27977e6ad469SVishal Kulkarni
27987e6ad469SVishal Kulkarni if (mem_info.mem_flag & (1 << MC1_FLAG)) {
27997e6ad469SVishal Kulkarni mc1_size = (((unsigned long)mem_info.size_mc1) * 1024 * 1024);
28007e6ad469SVishal Kulkarni rc = read_fw_mem(pdbg_init, dbg_buff, MEM_MC1,
28017e6ad469SVishal Kulkarni mc1_size, cudbg_err);
28027e6ad469SVishal Kulkarni if (rc)
28037e6ad469SVishal Kulkarni goto err;
28047e6ad469SVishal Kulkarni } else {
28057e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
28067e6ad469SVishal Kulkarni
28077e6ad469SVishal Kulkarni if (pdbg_init->verbose)
28087e6ad469SVishal Kulkarni pdbg_init->print(pdbg_init->adap->dip, CE_NOTE,
28097e6ad469SVishal Kulkarni "%s(), collect_mem_info failed!, %s\n",
28107e6ad469SVishal Kulkarni __func__, err_msg[-rc]);
28117e6ad469SVishal Kulkarni goto err;
28127e6ad469SVishal Kulkarni }
28137e6ad469SVishal Kulkarni err:
28147e6ad469SVishal Kulkarni return rc;
28157e6ad469SVishal Kulkarni }
28167e6ad469SVishal Kulkarni
28177e6ad469SVishal Kulkarni static int
collect_reg_dump(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)28187e6ad469SVishal Kulkarni collect_reg_dump(struct cudbg_init *pdbg_init,
28197e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
28207e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
28217e6ad469SVishal Kulkarni {
28227e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
28237e6ad469SVishal Kulkarni struct cudbg_buffer tmp_scratch_buff;
28247e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
28257e6ad469SVishal Kulkarni unsigned long bytes_read = 0;
28267e6ad469SVishal Kulkarni unsigned long bytes_left;
28277e6ad469SVishal Kulkarni u32 buf_size = 0, bytes = 0;
28287e6ad469SVishal Kulkarni int rc = 0;
28297e6ad469SVishal Kulkarni
28307e6ad469SVishal Kulkarni if (is_t4(padap->params.chip))
28317e6ad469SVishal Kulkarni buf_size = T4_REGMAP_SIZE ;/*+ sizeof(unsigned int);*/
28327e6ad469SVishal Kulkarni else if (is_t5(padap->params.chip) || is_t6(padap->params.chip))
28337e6ad469SVishal Kulkarni buf_size = T5_REGMAP_SIZE;
28347e6ad469SVishal Kulkarni
28357e6ad469SVishal Kulkarni scratch_buff.size = buf_size;
28367e6ad469SVishal Kulkarni
28377e6ad469SVishal Kulkarni tmp_scratch_buff = scratch_buff;
28387e6ad469SVishal Kulkarni
28397e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
28407e6ad469SVishal Kulkarni if (rc)
28417e6ad469SVishal Kulkarni goto err;
28427e6ad469SVishal Kulkarni
28437e6ad469SVishal Kulkarni /* no return */
28447e6ad469SVishal Kulkarni t4_get_regs(padap, (void *)scratch_buff.data, scratch_buff.size);
28457e6ad469SVishal Kulkarni bytes_left = scratch_buff.size;
28467e6ad469SVishal Kulkarni
28477e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
28487e6ad469SVishal Kulkarni if (rc)
28497e6ad469SVishal Kulkarni goto err1;
28507e6ad469SVishal Kulkarni
28517e6ad469SVishal Kulkarni while (bytes_left > 0) {
28527e6ad469SVishal Kulkarni tmp_scratch_buff.data =
28537e6ad469SVishal Kulkarni ((char *)scratch_buff.data) + bytes_read;
28547e6ad469SVishal Kulkarni bytes = min_t(unsigned long, bytes_left, (unsigned long)CUDBG_CHUNK_SIZE);
28557e6ad469SVishal Kulkarni tmp_scratch_buff.size = bytes;
28567e6ad469SVishal Kulkarni compress_buff(&tmp_scratch_buff, dbg_buff);
28577e6ad469SVishal Kulkarni bytes_left -= bytes;
28587e6ad469SVishal Kulkarni bytes_read += bytes;
28597e6ad469SVishal Kulkarni }
28607e6ad469SVishal Kulkarni
28617e6ad469SVishal Kulkarni err1:
28627e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
28637e6ad469SVishal Kulkarni err:
28647e6ad469SVishal Kulkarni return rc;
28657e6ad469SVishal Kulkarni }
28667e6ad469SVishal Kulkarni
28677e6ad469SVishal Kulkarni static int
collect_cctrl(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)28687e6ad469SVishal Kulkarni collect_cctrl(struct cudbg_init *pdbg_init,
28697e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
28707e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
28717e6ad469SVishal Kulkarni {
28727e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
28737e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
28747e6ad469SVishal Kulkarni u32 size;
28757e6ad469SVishal Kulkarni int rc;
28767e6ad469SVishal Kulkarni
28777e6ad469SVishal Kulkarni size = sizeof(u16) * NMTUS * NCCTRL_WIN;
28787e6ad469SVishal Kulkarni scratch_buff.size = size;
28797e6ad469SVishal Kulkarni
28807e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
28817e6ad469SVishal Kulkarni if (rc)
28827e6ad469SVishal Kulkarni goto err;
28837e6ad469SVishal Kulkarni
28847e6ad469SVishal Kulkarni t4_read_cong_tbl(padap, (void *)scratch_buff.data);
28857e6ad469SVishal Kulkarni
28867e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
28877e6ad469SVishal Kulkarni if (rc)
28887e6ad469SVishal Kulkarni goto err1;
28897e6ad469SVishal Kulkarni
28907e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
28917e6ad469SVishal Kulkarni
28927e6ad469SVishal Kulkarni err1:
28937e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
28947e6ad469SVishal Kulkarni err:
28957e6ad469SVishal Kulkarni return rc;
28967e6ad469SVishal Kulkarni }
28977e6ad469SVishal Kulkarni
28987e6ad469SVishal Kulkarni static int
check_busy_bit(struct adapter * padap)28997e6ad469SVishal Kulkarni check_busy_bit(struct adapter *padap)
29007e6ad469SVishal Kulkarni {
29017e6ad469SVishal Kulkarni u32 val;
29027e6ad469SVishal Kulkarni u32 busy = 1;
29037e6ad469SVishal Kulkarni int i = 0;
29047e6ad469SVishal Kulkarni int retry = 10;
29057e6ad469SVishal Kulkarni int status = 0;
29067e6ad469SVishal Kulkarni
2907*89f249c9SRobert Mustacchi while (busy && (i < retry)) {
29087e6ad469SVishal Kulkarni val = t4_read_reg(padap, A_CIM_HOST_ACC_CTRL);
29097e6ad469SVishal Kulkarni busy = (0 != (val & CUDBG_CIM_BUSY_BIT));
29107e6ad469SVishal Kulkarni i++;
29117e6ad469SVishal Kulkarni }
29127e6ad469SVishal Kulkarni
29137e6ad469SVishal Kulkarni if (busy)
29147e6ad469SVishal Kulkarni status = -1;
29157e6ad469SVishal Kulkarni
29167e6ad469SVishal Kulkarni return status;
29177e6ad469SVishal Kulkarni }
29187e6ad469SVishal Kulkarni
29197e6ad469SVishal Kulkarni static int
cim_ha_rreg(struct adapter * padap,u32 addr,u32 * val)29207e6ad469SVishal Kulkarni cim_ha_rreg(struct adapter *padap, u32 addr, u32 *val)
29217e6ad469SVishal Kulkarni {
29227e6ad469SVishal Kulkarni int rc = 0;
29237e6ad469SVishal Kulkarni
29247e6ad469SVishal Kulkarni /* write register address into the A_CIM_HOST_ACC_CTRL */
29257e6ad469SVishal Kulkarni t4_write_reg(padap, A_CIM_HOST_ACC_CTRL, addr);
29267e6ad469SVishal Kulkarni
29277e6ad469SVishal Kulkarni /* Poll HOSTBUSY */
29287e6ad469SVishal Kulkarni rc = check_busy_bit(padap);
29297e6ad469SVishal Kulkarni if (rc)
29307e6ad469SVishal Kulkarni goto err;
29317e6ad469SVishal Kulkarni
29327e6ad469SVishal Kulkarni /* Read value from A_CIM_HOST_ACC_DATA */
29337e6ad469SVishal Kulkarni *val = t4_read_reg(padap, A_CIM_HOST_ACC_DATA);
29347e6ad469SVishal Kulkarni
29357e6ad469SVishal Kulkarni err:
29367e6ad469SVishal Kulkarni return rc;
29377e6ad469SVishal Kulkarni }
29387e6ad469SVishal Kulkarni
29397e6ad469SVishal Kulkarni static int
dump_up_cim(struct adapter * padap,struct cudbg_init * pdbg_init,struct ireg_field * up_cim_reg,u32 * buff)29407e6ad469SVishal Kulkarni dump_up_cim(struct adapter *padap, struct cudbg_init *pdbg_init,
29417e6ad469SVishal Kulkarni struct ireg_field *up_cim_reg, u32 *buff)
29427e6ad469SVishal Kulkarni {
29437e6ad469SVishal Kulkarni u32 i;
29447e6ad469SVishal Kulkarni int rc = 0;
29457e6ad469SVishal Kulkarni
29467e6ad469SVishal Kulkarni for (i = 0; i < up_cim_reg->ireg_offset_range; i++) {
29477e6ad469SVishal Kulkarni rc = cim_ha_rreg(padap,
29487e6ad469SVishal Kulkarni up_cim_reg->ireg_local_offset + (i * 4),
29497e6ad469SVishal Kulkarni buff);
29507e6ad469SVishal Kulkarni if (rc) {
29517e6ad469SVishal Kulkarni if (pdbg_init->verbose)
29527e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
29537e6ad469SVishal Kulkarni "BUSY timeout reading"
29547e6ad469SVishal Kulkarni "CIM_HOST_ACC_CTRL\n");
29557e6ad469SVishal Kulkarni goto err;
29567e6ad469SVishal Kulkarni }
29577e6ad469SVishal Kulkarni
29587e6ad469SVishal Kulkarni buff++;
29597e6ad469SVishal Kulkarni }
29607e6ad469SVishal Kulkarni
29617e6ad469SVishal Kulkarni err:
29627e6ad469SVishal Kulkarni return rc;
29637e6ad469SVishal Kulkarni }
29647e6ad469SVishal Kulkarni
29657e6ad469SVishal Kulkarni static int
collect_up_cim_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)29667e6ad469SVishal Kulkarni collect_up_cim_indirect(struct cudbg_init *pdbg_init,
29677e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
29687e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
29697e6ad469SVishal Kulkarni {
29707e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
29717e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
29727e6ad469SVishal Kulkarni struct ireg_buf *up_cim;
29737e6ad469SVishal Kulkarni u32 size;
29747e6ad469SVishal Kulkarni int i, rc, n;
29757e6ad469SVishal Kulkarni
29767e6ad469SVishal Kulkarni n = sizeof(t5_up_cim_reg_array) / (4 * sizeof(u32));
29777e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n;
29787e6ad469SVishal Kulkarni scratch_buff.size = size;
29797e6ad469SVishal Kulkarni
29807e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
29817e6ad469SVishal Kulkarni if (rc)
29827e6ad469SVishal Kulkarni goto err;
29837e6ad469SVishal Kulkarni
29847e6ad469SVishal Kulkarni up_cim = (struct ireg_buf *)scratch_buff.data;
29857e6ad469SVishal Kulkarni
29867e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
29877e6ad469SVishal Kulkarni struct ireg_field *up_cim_reg = &up_cim->tp_pio;
29887e6ad469SVishal Kulkarni u32 *buff = up_cim->outbuf;
29897e6ad469SVishal Kulkarni
29907e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
29917e6ad469SVishal Kulkarni up_cim_reg->ireg_addr = t5_up_cim_reg_array[i][0];
29927e6ad469SVishal Kulkarni up_cim_reg->ireg_data = t5_up_cim_reg_array[i][1];
29937e6ad469SVishal Kulkarni up_cim_reg->ireg_local_offset =
29947e6ad469SVishal Kulkarni t5_up_cim_reg_array[i][2];
29957e6ad469SVishal Kulkarni up_cim_reg->ireg_offset_range =
29967e6ad469SVishal Kulkarni t5_up_cim_reg_array[i][3];
29977e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
29987e6ad469SVishal Kulkarni up_cim_reg->ireg_addr = t6_up_cim_reg_array[i][0];
29997e6ad469SVishal Kulkarni up_cim_reg->ireg_data = t6_up_cim_reg_array[i][1];
30007e6ad469SVishal Kulkarni up_cim_reg->ireg_local_offset =
30017e6ad469SVishal Kulkarni t6_up_cim_reg_array[i][2];
30027e6ad469SVishal Kulkarni up_cim_reg->ireg_offset_range =
30037e6ad469SVishal Kulkarni t6_up_cim_reg_array[i][3];
30047e6ad469SVishal Kulkarni }
30057e6ad469SVishal Kulkarni
30067e6ad469SVishal Kulkarni rc = dump_up_cim(padap, pdbg_init, up_cim_reg, buff);
30077e6ad469SVishal Kulkarni
30087e6ad469SVishal Kulkarni up_cim++;
30097e6ad469SVishal Kulkarni }
30107e6ad469SVishal Kulkarni
30117e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
30127e6ad469SVishal Kulkarni if (rc)
30137e6ad469SVishal Kulkarni goto err1;
30147e6ad469SVishal Kulkarni
30157e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
30167e6ad469SVishal Kulkarni
30177e6ad469SVishal Kulkarni err1:
30187e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
30197e6ad469SVishal Kulkarni err:
30207e6ad469SVishal Kulkarni return rc;
30217e6ad469SVishal Kulkarni }
30227e6ad469SVishal Kulkarni
30237e6ad469SVishal Kulkarni static int
collect_mbox_log(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)30247e6ad469SVishal Kulkarni collect_mbox_log(struct cudbg_init *pdbg_init,
30257e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
30267e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
30277e6ad469SVishal Kulkarni {
30287e6ad469SVishal Kulkarni #ifdef notyet
30297e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
30307e6ad469SVishal Kulkarni struct cudbg_mbox_log *mboxlog = NULL;
30317e6ad469SVishal Kulkarni struct mbox_cmd_log *log = NULL;
30327e6ad469SVishal Kulkarni struct mbox_cmd *entry;
30337e6ad469SVishal Kulkarni u64 flit;
30347e6ad469SVishal Kulkarni u32 size;
30357e6ad469SVishal Kulkarni unsigned int entry_idx;
30367e6ad469SVishal Kulkarni int i, k, rc;
30377e6ad469SVishal Kulkarni u16 mbox_cmds;
30387e6ad469SVishal Kulkarni
30397e6ad469SVishal Kulkarni if (pdbg_init->dbg_params[CUDBG_MBOX_LOG_PARAM].u.mboxlog_param.log) {
30407e6ad469SVishal Kulkarni log = pdbg_init->dbg_params[CUDBG_MBOX_LOG_PARAM].u.
30417e6ad469SVishal Kulkarni mboxlog_param.log;
30427e6ad469SVishal Kulkarni mbox_cmds = pdbg_init->dbg_params[CUDBG_MBOX_LOG_PARAM].u.
30437e6ad469SVishal Kulkarni mboxlog_param.mbox_cmds;
30447e6ad469SVishal Kulkarni } else {
30457e6ad469SVishal Kulkarni if (pdbg_init->verbose)
30467e6ad469SVishal Kulkarni pdbg_init->print(adap->dip, CE_NOTE,
30477e6ad469SVishal Kulkarni "Mbox log is not requested\n");
30487e6ad469SVishal Kulkarni return CUDBG_STATUS_ENTITY_NOT_REQUESTED;
30497e6ad469SVishal Kulkarni }
30507e6ad469SVishal Kulkarni
30517e6ad469SVishal Kulkarni size = sizeof(struct cudbg_mbox_log) * mbox_cmds;
30527e6ad469SVishal Kulkarni scratch_buff.size = size;
30537e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
30547e6ad469SVishal Kulkarni if (rc)
30557e6ad469SVishal Kulkarni goto err;
30567e6ad469SVishal Kulkarni
30577e6ad469SVishal Kulkarni mboxlog = (struct cudbg_mbox_log *)scratch_buff.data;
30587e6ad469SVishal Kulkarni
30597e6ad469SVishal Kulkarni for (k = 0; k < mbox_cmds; k++) {
30607e6ad469SVishal Kulkarni entry_idx = log->cursor + k;
30617e6ad469SVishal Kulkarni if (entry_idx >= log->size)
30627e6ad469SVishal Kulkarni entry_idx -= log->size;
30637e6ad469SVishal Kulkarni entry = mbox_cmd_log_entry(log, entry_idx);
30647e6ad469SVishal Kulkarni
30657e6ad469SVishal Kulkarni /* skip over unused entries */
30667e6ad469SVishal Kulkarni if (entry->timestamp == 0)
30677e6ad469SVishal Kulkarni continue;
30687e6ad469SVishal Kulkarni
30697e6ad469SVishal Kulkarni memcpy(&mboxlog->entry, entry, sizeof(struct mbox_cmd));
30707e6ad469SVishal Kulkarni
30717e6ad469SVishal Kulkarni for (i = 0; i < MBOX_LEN / 8; i++) {
30727e6ad469SVishal Kulkarni flit = entry->cmd[i];
30737e6ad469SVishal Kulkarni mboxlog->hi[i] = (u32)(flit >> 32);
30747e6ad469SVishal Kulkarni mboxlog->lo[i] = (u32)flit;
30757e6ad469SVishal Kulkarni }
30767e6ad469SVishal Kulkarni
30777e6ad469SVishal Kulkarni mboxlog++;
30787e6ad469SVishal Kulkarni }
30797e6ad469SVishal Kulkarni
30807e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
30817e6ad469SVishal Kulkarni if (rc)
30827e6ad469SVishal Kulkarni goto err1;
30837e6ad469SVishal Kulkarni
30847e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
30857e6ad469SVishal Kulkarni
30867e6ad469SVishal Kulkarni err1:
30877e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
30887e6ad469SVishal Kulkarni err:
30897e6ad469SVishal Kulkarni return rc;
30907e6ad469SVishal Kulkarni #endif
30917e6ad469SVishal Kulkarni return (-1);
30927e6ad469SVishal Kulkarni }
30937e6ad469SVishal Kulkarni
30947e6ad469SVishal Kulkarni static int
collect_pbt_tables(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)30957e6ad469SVishal Kulkarni collect_pbt_tables(struct cudbg_init *pdbg_init,
30967e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
30977e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
30987e6ad469SVishal Kulkarni {
30997e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
31007e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
31017e6ad469SVishal Kulkarni struct cudbg_pbt_tables *pbt = NULL;
31027e6ad469SVishal Kulkarni u32 size;
31037e6ad469SVishal Kulkarni u32 addr;
31047e6ad469SVishal Kulkarni int i, rc;
31057e6ad469SVishal Kulkarni
31067e6ad469SVishal Kulkarni size = sizeof(struct cudbg_pbt_tables);
31077e6ad469SVishal Kulkarni scratch_buff.size = size;
31087e6ad469SVishal Kulkarni
31097e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
31107e6ad469SVishal Kulkarni if (rc)
31117e6ad469SVishal Kulkarni goto err;
31127e6ad469SVishal Kulkarni
31137e6ad469SVishal Kulkarni pbt = (struct cudbg_pbt_tables *)scratch_buff.data;
31147e6ad469SVishal Kulkarni
31157e6ad469SVishal Kulkarni /* PBT dynamic entries */
31167e6ad469SVishal Kulkarni addr = CUDBG_CHAC_PBT_ADDR;
31177e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_PBT_DYNAMIC_ENTRIES; i++) {
31187e6ad469SVishal Kulkarni rc = cim_ha_rreg(padap, addr + (i * 4), &pbt->pbt_dynamic[i]);
31197e6ad469SVishal Kulkarni if (rc) {
31207e6ad469SVishal Kulkarni if (pdbg_init->verbose)
31217e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
31227e6ad469SVishal Kulkarni "BUSY timeout reading"
31237e6ad469SVishal Kulkarni "CIM_HOST_ACC_CTRL\n");
31247e6ad469SVishal Kulkarni goto err1;
31257e6ad469SVishal Kulkarni }
31267e6ad469SVishal Kulkarni }
31277e6ad469SVishal Kulkarni
31287e6ad469SVishal Kulkarni /* PBT static entries */
31297e6ad469SVishal Kulkarni
31307e6ad469SVishal Kulkarni /* static entries start when bit 6 is set */
31317e6ad469SVishal Kulkarni addr = CUDBG_CHAC_PBT_ADDR + (1 << 6);
31327e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_PBT_STATIC_ENTRIES; i++) {
31337e6ad469SVishal Kulkarni rc = cim_ha_rreg(padap, addr + (i * 4), &pbt->pbt_static[i]);
31347e6ad469SVishal Kulkarni if (rc) {
31357e6ad469SVishal Kulkarni if (pdbg_init->verbose)
31367e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
31377e6ad469SVishal Kulkarni "BUSY timeout reading"
31387e6ad469SVishal Kulkarni "CIM_HOST_ACC_CTRL\n");
31397e6ad469SVishal Kulkarni goto err1;
31407e6ad469SVishal Kulkarni }
31417e6ad469SVishal Kulkarni }
31427e6ad469SVishal Kulkarni
31437e6ad469SVishal Kulkarni /* LRF entries */
31447e6ad469SVishal Kulkarni addr = CUDBG_CHAC_PBT_LRF;
31457e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_LRF_ENTRIES; i++) {
31467e6ad469SVishal Kulkarni rc = cim_ha_rreg(padap, addr + (i * 4), &pbt->lrf_table[i]);
31477e6ad469SVishal Kulkarni if (rc) {
31487e6ad469SVishal Kulkarni if (pdbg_init->verbose)
31497e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
31507e6ad469SVishal Kulkarni "BUSY timeout reading"
31517e6ad469SVishal Kulkarni "CIM_HOST_ACC_CTRL\n");
31527e6ad469SVishal Kulkarni goto err1;
31537e6ad469SVishal Kulkarni }
31547e6ad469SVishal Kulkarni }
31557e6ad469SVishal Kulkarni
31567e6ad469SVishal Kulkarni /* PBT data entries */
31577e6ad469SVishal Kulkarni addr = CUDBG_CHAC_PBT_DATA;
31587e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_PBT_DATA_ENTRIES; i++) {
31597e6ad469SVishal Kulkarni rc = cim_ha_rreg(padap, addr + (i * 4), &pbt->pbt_data[i]);
31607e6ad469SVishal Kulkarni if (rc) {
31617e6ad469SVishal Kulkarni if (pdbg_init->verbose)
31627e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
31637e6ad469SVishal Kulkarni "BUSY timeout reading"
31647e6ad469SVishal Kulkarni "CIM_HOST_ACC_CTRL\n");
31657e6ad469SVishal Kulkarni goto err1;
31667e6ad469SVishal Kulkarni }
31677e6ad469SVishal Kulkarni }
31687e6ad469SVishal Kulkarni
31697e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
31707e6ad469SVishal Kulkarni if (rc)
31717e6ad469SVishal Kulkarni goto err1;
31727e6ad469SVishal Kulkarni
31737e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
31747e6ad469SVishal Kulkarni
31757e6ad469SVishal Kulkarni err1:
31767e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
31777e6ad469SVishal Kulkarni err:
31787e6ad469SVishal Kulkarni return rc;
31797e6ad469SVishal Kulkarni }
31807e6ad469SVishal Kulkarni
31817e6ad469SVishal Kulkarni static int
collect_pm_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)31827e6ad469SVishal Kulkarni collect_pm_indirect(struct cudbg_init *pdbg_init,
31837e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
31847e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
31857e6ad469SVishal Kulkarni {
31867e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
31877e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
31887e6ad469SVishal Kulkarni struct ireg_buf *ch_pm;
31897e6ad469SVishal Kulkarni u32 size;
31907e6ad469SVishal Kulkarni int i, rc, n;
31917e6ad469SVishal Kulkarni
31927e6ad469SVishal Kulkarni n = sizeof(t5_pm_rx_array) / (4 * sizeof(u32));
31937e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n * 2;
31947e6ad469SVishal Kulkarni scratch_buff.size = size;
31957e6ad469SVishal Kulkarni
31967e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
31977e6ad469SVishal Kulkarni if (rc)
31987e6ad469SVishal Kulkarni goto err;
31997e6ad469SVishal Kulkarni
32007e6ad469SVishal Kulkarni ch_pm = (struct ireg_buf *)scratch_buff.data;
32017e6ad469SVishal Kulkarni
32027e6ad469SVishal Kulkarni /*PM_RX*/
32037e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
32047e6ad469SVishal Kulkarni struct ireg_field *pm_pio = &ch_pm->tp_pio;
32057e6ad469SVishal Kulkarni u32 *buff = ch_pm->outbuf;
32067e6ad469SVishal Kulkarni
32077e6ad469SVishal Kulkarni pm_pio->ireg_addr = t5_pm_rx_array[i][0];
32087e6ad469SVishal Kulkarni pm_pio->ireg_data = t5_pm_rx_array[i][1];
32097e6ad469SVishal Kulkarni pm_pio->ireg_local_offset = t5_pm_rx_array[i][2];
32107e6ad469SVishal Kulkarni pm_pio->ireg_offset_range = t5_pm_rx_array[i][3];
32117e6ad469SVishal Kulkarni
32127e6ad469SVishal Kulkarni t4_read_indirect(padap,
32137e6ad469SVishal Kulkarni pm_pio->ireg_addr,
32147e6ad469SVishal Kulkarni pm_pio->ireg_data,
32157e6ad469SVishal Kulkarni buff,
32167e6ad469SVishal Kulkarni pm_pio->ireg_offset_range,
32177e6ad469SVishal Kulkarni pm_pio->ireg_local_offset);
32187e6ad469SVishal Kulkarni
32197e6ad469SVishal Kulkarni ch_pm++;
32207e6ad469SVishal Kulkarni }
32217e6ad469SVishal Kulkarni
32227e6ad469SVishal Kulkarni /*PM_Tx*/
32237e6ad469SVishal Kulkarni n = sizeof(t5_pm_tx_array) / (4 * sizeof(u32));
32247e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
32257e6ad469SVishal Kulkarni struct ireg_field *pm_pio = &ch_pm->tp_pio;
32267e6ad469SVishal Kulkarni u32 *buff = ch_pm->outbuf;
32277e6ad469SVishal Kulkarni
32287e6ad469SVishal Kulkarni pm_pio->ireg_addr = t5_pm_tx_array[i][0];
32297e6ad469SVishal Kulkarni pm_pio->ireg_data = t5_pm_tx_array[i][1];
32307e6ad469SVishal Kulkarni pm_pio->ireg_local_offset = t5_pm_tx_array[i][2];
32317e6ad469SVishal Kulkarni pm_pio->ireg_offset_range = t5_pm_tx_array[i][3];
32327e6ad469SVishal Kulkarni
32337e6ad469SVishal Kulkarni t4_read_indirect(padap,
32347e6ad469SVishal Kulkarni pm_pio->ireg_addr,
32357e6ad469SVishal Kulkarni pm_pio->ireg_data,
32367e6ad469SVishal Kulkarni buff,
32377e6ad469SVishal Kulkarni pm_pio->ireg_offset_range,
32387e6ad469SVishal Kulkarni pm_pio->ireg_local_offset);
32397e6ad469SVishal Kulkarni
32407e6ad469SVishal Kulkarni ch_pm++;
32417e6ad469SVishal Kulkarni }
32427e6ad469SVishal Kulkarni
32437e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
32447e6ad469SVishal Kulkarni if (rc)
32457e6ad469SVishal Kulkarni goto err1;
32467e6ad469SVishal Kulkarni
32477e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
32487e6ad469SVishal Kulkarni
32497e6ad469SVishal Kulkarni err1:
32507e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
32517e6ad469SVishal Kulkarni err:
32527e6ad469SVishal Kulkarni return rc;
32537e6ad469SVishal Kulkarni
32547e6ad469SVishal Kulkarni }
32557e6ad469SVishal Kulkarni
32567e6ad469SVishal Kulkarni static int
collect_tid(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)32577e6ad469SVishal Kulkarni collect_tid(struct cudbg_init *pdbg_init,
32587e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
32597e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
32607e6ad469SVishal Kulkarni {
32617e6ad469SVishal Kulkarni
32627e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
32637e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
32647e6ad469SVishal Kulkarni struct tid_info_region *tid;
32657e6ad469SVishal Kulkarni struct tid_info_region_rev1 *tid1;
32667e6ad469SVishal Kulkarni u32 para[7], val[7];
32677e6ad469SVishal Kulkarni u32 mbox, pf;
32687e6ad469SVishal Kulkarni int rc;
32697e6ad469SVishal Kulkarni
32707e6ad469SVishal Kulkarni scratch_buff.size = sizeof(struct tid_info_region_rev1);
32717e6ad469SVishal Kulkarni
32727e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
32737e6ad469SVishal Kulkarni if (rc)
32747e6ad469SVishal Kulkarni goto err;
32757e6ad469SVishal Kulkarni
32767e6ad469SVishal Kulkarni #define FW_PARAM_DEV_A(param) \
32777e6ad469SVishal Kulkarni (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) | \
32787e6ad469SVishal Kulkarni V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_##param))
32797e6ad469SVishal Kulkarni #define FW_PARAM_PFVF_A(param) \
32807e6ad469SVishal Kulkarni (V_FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | \
32817e6ad469SVishal Kulkarni V_FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_##param)| \
32827e6ad469SVishal Kulkarni V_FW_PARAMS_PARAM_Y(0) | \
32837e6ad469SVishal Kulkarni V_FW_PARAMS_PARAM_Z(0))
32847e6ad469SVishal Kulkarni #define MAX_ATIDS_A 8192U
32857e6ad469SVishal Kulkarni
32867e6ad469SVishal Kulkarni tid1 = (struct tid_info_region_rev1 *)scratch_buff.data;
32877e6ad469SVishal Kulkarni tid = &(tid1->tid);
32887e6ad469SVishal Kulkarni tid1->ver_hdr.signature = CUDBG_ENTITY_SIGNATURE;
32897e6ad469SVishal Kulkarni tid1->ver_hdr.revision = CUDBG_TID_INFO_REV;
32907e6ad469SVishal Kulkarni tid1->ver_hdr.size = sizeof(struct tid_info_region_rev1) -
32917e6ad469SVishal Kulkarni sizeof(struct cudbg_ver_hdr);
32927e6ad469SVishal Kulkarni
32937e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
32947e6ad469SVishal Kulkarni tid->hash_base = t4_read_reg(padap, A_LE_DB_TID_HASHBASE);
32957e6ad469SVishal Kulkarni tid1->tid_start = 0;
32967e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
32977e6ad469SVishal Kulkarni tid->hash_base = t4_read_reg(padap, A_T6_LE_DB_HASH_TID_BASE);
32987e6ad469SVishal Kulkarni tid1->tid_start = t4_read_reg(padap, A_LE_DB_ACTIVE_TABLE_START_INDEX);
32997e6ad469SVishal Kulkarni }
33007e6ad469SVishal Kulkarni
33017e6ad469SVishal Kulkarni tid->le_db_conf = t4_read_reg(padap, A_LE_DB_CONFIG);
33027e6ad469SVishal Kulkarni
33037e6ad469SVishal Kulkarni para[0] = FW_PARAM_PFVF_A(FILTER_START);
33047e6ad469SVishal Kulkarni para[1] = FW_PARAM_PFVF_A(FILTER_END);
33057e6ad469SVishal Kulkarni para[2] = FW_PARAM_PFVF_A(ACTIVE_FILTER_START);
33067e6ad469SVishal Kulkarni para[3] = FW_PARAM_PFVF_A(ACTIVE_FILTER_END);
33077e6ad469SVishal Kulkarni para[4] = FW_PARAM_DEV_A(NTID);
33087e6ad469SVishal Kulkarni para[5] = FW_PARAM_PFVF_A(SERVER_START);
33097e6ad469SVishal Kulkarni para[6] = FW_PARAM_PFVF_A(SERVER_END);
33107e6ad469SVishal Kulkarni
33117e6ad469SVishal Kulkarni rc = begin_synchronized_op(padap->port[0], 1, 1);
33127e6ad469SVishal Kulkarni if (rc)
33137e6ad469SVishal Kulkarni goto err;
33147e6ad469SVishal Kulkarni mbox = padap->mbox;
33157e6ad469SVishal Kulkarni pf = padap->pf;
33167e6ad469SVishal Kulkarni rc = t4_query_params(padap, mbox, pf, 0, 7, para, val);
33177e6ad469SVishal Kulkarni if (rc < 0) {
33187e6ad469SVishal Kulkarni if (rc == -FW_EPERM) {
33197e6ad469SVishal Kulkarni /* It looks like we don't have permission to use
33207e6ad469SVishal Kulkarni * padap->mbox.
33217e6ad469SVishal Kulkarni *
33227e6ad469SVishal Kulkarni * Try mbox 4. If it works, we'll continue to
33237e6ad469SVishal Kulkarni * collect the rest of tid info from mbox 4.
33247e6ad469SVishal Kulkarni * Else, quit trying to collect tid info.
33257e6ad469SVishal Kulkarni */
33267e6ad469SVishal Kulkarni mbox = 4;
33277e6ad469SVishal Kulkarni pf = 4;
33287e6ad469SVishal Kulkarni rc = t4_query_params(padap, mbox, pf, 0, 7, para, val);
33297e6ad469SVishal Kulkarni if (rc < 0) {
33307e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
33317e6ad469SVishal Kulkarni goto err1;
33327e6ad469SVishal Kulkarni }
33337e6ad469SVishal Kulkarni } else {
33347e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
33357e6ad469SVishal Kulkarni goto err1;
33367e6ad469SVishal Kulkarni }
33377e6ad469SVishal Kulkarni }
33387e6ad469SVishal Kulkarni
33397e6ad469SVishal Kulkarni tid->ftid_base = val[0];
33407e6ad469SVishal Kulkarni tid->nftids = val[1] - val[0] + 1;
33417e6ad469SVishal Kulkarni /*active filter region*/
33427e6ad469SVishal Kulkarni if (val[2] != val[3]) {
33437e6ad469SVishal Kulkarni #ifdef notyet
33447e6ad469SVishal Kulkarni tid->flags |= FW_OFLD_CONN;
33457e6ad469SVishal Kulkarni #endif
33467e6ad469SVishal Kulkarni tid->aftid_base = val[2];
33477e6ad469SVishal Kulkarni tid->aftid_end = val[3];
33487e6ad469SVishal Kulkarni }
33497e6ad469SVishal Kulkarni tid->ntids = val[4];
33507e6ad469SVishal Kulkarni tid->natids = min_t(u32, tid->ntids / 2, MAX_ATIDS_A);
33517e6ad469SVishal Kulkarni tid->stid_base = val[5];
33527e6ad469SVishal Kulkarni tid->nstids = val[6] - val[5] + 1;
33537e6ad469SVishal Kulkarni
33547e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) >= CHELSIO_T6) {
33557e6ad469SVishal Kulkarni para[0] = FW_PARAM_PFVF_A(HPFILTER_START);
33567e6ad469SVishal Kulkarni para[1] = FW_PARAM_PFVF_A(HPFILTER_END);
33577e6ad469SVishal Kulkarni rc = t4_query_params(padap, mbox, pf, 0, 2, para, val);
33587e6ad469SVishal Kulkarni if (rc < 0) {
33597e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
33607e6ad469SVishal Kulkarni goto err1;
33617e6ad469SVishal Kulkarni }
33627e6ad469SVishal Kulkarni
33637e6ad469SVishal Kulkarni tid->hpftid_base = val[0];
33647e6ad469SVishal Kulkarni tid->nhpftids = val[1] - val[0] + 1;
33657e6ad469SVishal Kulkarni }
33667e6ad469SVishal Kulkarni
33677e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) <= CHELSIO_T5) {
33687e6ad469SVishal Kulkarni tid->sb = t4_read_reg(padap, A_LE_DB_SERVER_INDEX) / 4;
33697e6ad469SVishal Kulkarni tid->hash_base /= 4;
33707e6ad469SVishal Kulkarni } else
33717e6ad469SVishal Kulkarni tid->sb = t4_read_reg(padap, A_LE_DB_SRVR_START_INDEX);
33727e6ad469SVishal Kulkarni
33737e6ad469SVishal Kulkarni /*UO context range*/
33747e6ad469SVishal Kulkarni para[0] = FW_PARAM_PFVF_A(ETHOFLD_START);
33757e6ad469SVishal Kulkarni para[1] = FW_PARAM_PFVF_A(ETHOFLD_END);
33767e6ad469SVishal Kulkarni
33777e6ad469SVishal Kulkarni rc = t4_query_params(padap, mbox, pf, 0, 2, para, val);
33787e6ad469SVishal Kulkarni if (rc < 0) {
33797e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
33807e6ad469SVishal Kulkarni goto err1;
33817e6ad469SVishal Kulkarni }
33827e6ad469SVishal Kulkarni
33837e6ad469SVishal Kulkarni if (val[0] != val[1]) {
33847e6ad469SVishal Kulkarni tid->uotid_base = val[0];
33857e6ad469SVishal Kulkarni tid->nuotids = val[1] - val[0] + 1;
33867e6ad469SVishal Kulkarni }
33877e6ad469SVishal Kulkarni tid->IP_users = t4_read_reg(padap, A_LE_DB_ACT_CNT_IPV4);
33887e6ad469SVishal Kulkarni tid->IPv6_users = t4_read_reg(padap, A_LE_DB_ACT_CNT_IPV6);
33897e6ad469SVishal Kulkarni
33907e6ad469SVishal Kulkarni #undef FW_PARAM_PFVF_A
33917e6ad469SVishal Kulkarni #undef FW_PARAM_DEV_A
33927e6ad469SVishal Kulkarni #undef MAX_ATIDS_A
33937e6ad469SVishal Kulkarni
33947e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
33957e6ad469SVishal Kulkarni if (rc)
33967e6ad469SVishal Kulkarni goto err1;
33977e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
33987e6ad469SVishal Kulkarni
33997e6ad469SVishal Kulkarni err1:
34007e6ad469SVishal Kulkarni end_synchronized_op(padap->port[0], 1);
34017e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
34027e6ad469SVishal Kulkarni err:
34037e6ad469SVishal Kulkarni return rc;
34047e6ad469SVishal Kulkarni }
34057e6ad469SVishal Kulkarni
34067e6ad469SVishal Kulkarni static int
collect_tx_rate(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)34077e6ad469SVishal Kulkarni collect_tx_rate(struct cudbg_init *pdbg_init,
34087e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
34097e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
34107e6ad469SVishal Kulkarni {
34117e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
34127e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
34137e6ad469SVishal Kulkarni struct tx_rate *tx_rate;
34147e6ad469SVishal Kulkarni u32 size;
34157e6ad469SVishal Kulkarni int rc;
34167e6ad469SVishal Kulkarni
34177e6ad469SVishal Kulkarni size = sizeof(struct tx_rate);
34187e6ad469SVishal Kulkarni scratch_buff.size = size;
34197e6ad469SVishal Kulkarni
34207e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
34217e6ad469SVishal Kulkarni if (rc)
34227e6ad469SVishal Kulkarni goto err;
34237e6ad469SVishal Kulkarni
34247e6ad469SVishal Kulkarni tx_rate = (struct tx_rate *)scratch_buff.data;
34257e6ad469SVishal Kulkarni t4_get_chan_txrate(padap, tx_rate->nrate, tx_rate->orate);
34267e6ad469SVishal Kulkarni tx_rate->nchan = padap->params.arch.nchan;
34277e6ad469SVishal Kulkarni
34287e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
34297e6ad469SVishal Kulkarni if (rc)
34307e6ad469SVishal Kulkarni goto err1;
34317e6ad469SVishal Kulkarni
34327e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
34337e6ad469SVishal Kulkarni
34347e6ad469SVishal Kulkarni err1:
34357e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
34367e6ad469SVishal Kulkarni err:
34377e6ad469SVishal Kulkarni return rc;
34387e6ad469SVishal Kulkarni }
34397e6ad469SVishal Kulkarni
34407e6ad469SVishal Kulkarni static inline void
cudbg_tcamxy2valmask(u64 x,u64 y,u8 * addr,u64 * mask)34417e6ad469SVishal Kulkarni cudbg_tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask)
34427e6ad469SVishal Kulkarni {
34437e6ad469SVishal Kulkarni *mask = x | y;
34447e6ad469SVishal Kulkarni y = (__force u64)cpu_to_be64(y);
34457e6ad469SVishal Kulkarni memcpy(addr, (char *)&y + 2, ETH_ALEN);
34467e6ad469SVishal Kulkarni }
34477e6ad469SVishal Kulkarni
34487e6ad469SVishal Kulkarni static void
mps_rpl_backdoor(struct adapter * padap,struct fw_ldst_mps_rplc * mps_rplc)34497e6ad469SVishal Kulkarni mps_rpl_backdoor(struct adapter *padap, struct fw_ldst_mps_rplc *mps_rplc)
34507e6ad469SVishal Kulkarni {
34517e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
34527e6ad469SVishal Kulkarni mps_rplc->rplc255_224 = htonl(t4_read_reg(padap,
34537e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP3));
34547e6ad469SVishal Kulkarni mps_rplc->rplc223_192 = htonl(t4_read_reg(padap,
34557e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP2));
34567e6ad469SVishal Kulkarni mps_rplc->rplc191_160 = htonl(t4_read_reg(padap,
34577e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP1));
34587e6ad469SVishal Kulkarni mps_rplc->rplc159_128 = htonl(t4_read_reg(padap,
34597e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP0));
34607e6ad469SVishal Kulkarni } else {
34617e6ad469SVishal Kulkarni mps_rplc->rplc255_224 = htonl(t4_read_reg(padap,
34627e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP7));
34637e6ad469SVishal Kulkarni mps_rplc->rplc223_192 = htonl(t4_read_reg(padap,
34647e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP6));
34657e6ad469SVishal Kulkarni mps_rplc->rplc191_160 = htonl(t4_read_reg(padap,
34667e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP5));
34677e6ad469SVishal Kulkarni mps_rplc->rplc159_128 = htonl(t4_read_reg(padap,
34687e6ad469SVishal Kulkarni A_MPS_VF_RPLCT_MAP4));
34697e6ad469SVishal Kulkarni }
34707e6ad469SVishal Kulkarni mps_rplc->rplc127_96 = htonl(t4_read_reg(padap, A_MPS_VF_RPLCT_MAP3));
34717e6ad469SVishal Kulkarni mps_rplc->rplc95_64 = htonl(t4_read_reg(padap, A_MPS_VF_RPLCT_MAP2));
34727e6ad469SVishal Kulkarni mps_rplc->rplc63_32 = htonl(t4_read_reg(padap, A_MPS_VF_RPLCT_MAP1));
34737e6ad469SVishal Kulkarni mps_rplc->rplc31_0 = htonl(t4_read_reg(padap, A_MPS_VF_RPLCT_MAP0));
34747e6ad469SVishal Kulkarni }
34757e6ad469SVishal Kulkarni
34767e6ad469SVishal Kulkarni static int
collect_mps_tcam(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)34777e6ad469SVishal Kulkarni collect_mps_tcam(struct cudbg_init *pdbg_init,
34787e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
34797e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
34807e6ad469SVishal Kulkarni {
34817e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
34827e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
34837e6ad469SVishal Kulkarni struct cudbg_mps_tcam *tcam = NULL;
34847e6ad469SVishal Kulkarni u32 size = 0, i, n, total_size = 0;
34857e6ad469SVishal Kulkarni u32 ctl, data2;
34867e6ad469SVishal Kulkarni u64 tcamy, tcamx, val;
34877e6ad469SVishal Kulkarni int rc;
34887e6ad469SVishal Kulkarni
34897e6ad469SVishal Kulkarni
34907e6ad469SVishal Kulkarni n = padap->params.arch.mps_tcam_size;
34917e6ad469SVishal Kulkarni size = sizeof(struct cudbg_mps_tcam) * n;
34927e6ad469SVishal Kulkarni scratch_buff.size = size;
34937e6ad469SVishal Kulkarni
34947e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
34957e6ad469SVishal Kulkarni if (rc)
34967e6ad469SVishal Kulkarni goto err;
34977e6ad469SVishal Kulkarni memset(scratch_buff.data, 0, size);
34987e6ad469SVishal Kulkarni
34997e6ad469SVishal Kulkarni tcam = (struct cudbg_mps_tcam *)scratch_buff.data;
35007e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
35017e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) >= CHELSIO_T6) {
35027e6ad469SVishal Kulkarni /* CtlReqID - 1: use Host Driver Requester ID
35037e6ad469SVishal Kulkarni * CtlCmdType - 0: Read, 1: Write
35047e6ad469SVishal Kulkarni * CtlTcamSel - 0: TCAM0, 1: TCAM1
35057e6ad469SVishal Kulkarni * CtlXYBitSel- 0: Y bit, 1: X bit
35067e6ad469SVishal Kulkarni */
35077e6ad469SVishal Kulkarni
35087e6ad469SVishal Kulkarni /* Read tcamy */
35097e6ad469SVishal Kulkarni ctl = (V_CTLREQID(1) |
35107e6ad469SVishal Kulkarni V_CTLCMDTYPE(0) | V_CTLXYBITSEL(0));
35117e6ad469SVishal Kulkarni if (i < 256)
35127e6ad469SVishal Kulkarni ctl |= V_CTLTCAMINDEX(i) | V_CTLTCAMSEL(0);
35137e6ad469SVishal Kulkarni else
35147e6ad469SVishal Kulkarni ctl |= V_CTLTCAMINDEX(i - 256) |
35157e6ad469SVishal Kulkarni V_CTLTCAMSEL(1);
35167e6ad469SVishal Kulkarni
35177e6ad469SVishal Kulkarni t4_write_reg(padap, A_MPS_CLS_TCAM_DATA2_CTL, ctl);
35187e6ad469SVishal Kulkarni val = t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA1_REQ_ID1);
35197e6ad469SVishal Kulkarni tcamy = G_DMACH(val) << 32;
35207e6ad469SVishal Kulkarni tcamy |= t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA0_REQ_ID1);
35217e6ad469SVishal Kulkarni data2 = t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA2_REQ_ID1);
35227e6ad469SVishal Kulkarni tcam->lookup_type = G_DATALKPTYPE(data2);
35237e6ad469SVishal Kulkarni
35247e6ad469SVishal Kulkarni /* 0 - Outer header, 1 - Inner header
35257e6ad469SVishal Kulkarni * [71:48] bit locations are overloaded for
35267e6ad469SVishal Kulkarni * outer vs. inner lookup types.
35277e6ad469SVishal Kulkarni */
35287e6ad469SVishal Kulkarni
35297e6ad469SVishal Kulkarni if (tcam->lookup_type &&
35307e6ad469SVishal Kulkarni (tcam->lookup_type != M_DATALKPTYPE)) {
35317e6ad469SVishal Kulkarni /* Inner header VNI */
35327e6ad469SVishal Kulkarni tcam->vniy = ((data2 & F_DATAVIDH2) << 23) |
35337e6ad469SVishal Kulkarni (G_DATAVIDH1(data2) << 16) |
35347e6ad469SVishal Kulkarni G_VIDL(val);
35357e6ad469SVishal Kulkarni tcam->dip_hit = data2 & F_DATADIPHIT;
35367e6ad469SVishal Kulkarni } else {
35377e6ad469SVishal Kulkarni tcam->vlan_vld = data2 & F_DATAVIDH2;
35387e6ad469SVishal Kulkarni tcam->ivlan = G_VIDL(val);
35397e6ad469SVishal Kulkarni }
35407e6ad469SVishal Kulkarni
35417e6ad469SVishal Kulkarni tcam->port_num = G_DATAPORTNUM(data2);
35427e6ad469SVishal Kulkarni
35437e6ad469SVishal Kulkarni /* Read tcamx. Change the control param */
35447e6ad469SVishal Kulkarni ctl |= V_CTLXYBITSEL(1);
35457e6ad469SVishal Kulkarni t4_write_reg(padap, A_MPS_CLS_TCAM_DATA2_CTL, ctl);
35467e6ad469SVishal Kulkarni val = t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA1_REQ_ID1);
35477e6ad469SVishal Kulkarni tcamx = G_DMACH(val) << 32;
35487e6ad469SVishal Kulkarni tcamx |= t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA0_REQ_ID1);
35497e6ad469SVishal Kulkarni data2 = t4_read_reg(padap, A_MPS_CLS_TCAM_RDATA2_REQ_ID1);
35507e6ad469SVishal Kulkarni if (tcam->lookup_type &&
35517e6ad469SVishal Kulkarni (tcam->lookup_type != M_DATALKPTYPE)) {
35527e6ad469SVishal Kulkarni /* Inner header VNI mask */
35537e6ad469SVishal Kulkarni tcam->vnix = ((data2 & F_DATAVIDH2) << 23) |
35547e6ad469SVishal Kulkarni (G_DATAVIDH1(data2) << 16) |
35557e6ad469SVishal Kulkarni G_VIDL(val);
35567e6ad469SVishal Kulkarni }
35577e6ad469SVishal Kulkarni } else {
35587e6ad469SVishal Kulkarni tcamy = t4_read_reg64(padap, MPS_CLS_TCAM_Y_L(i));
35597e6ad469SVishal Kulkarni tcamx = t4_read_reg64(padap, MPS_CLS_TCAM_X_L(i));
35607e6ad469SVishal Kulkarni }
35617e6ad469SVishal Kulkarni
35627e6ad469SVishal Kulkarni if (tcamx & tcamy)
35637e6ad469SVishal Kulkarni continue;
35647e6ad469SVishal Kulkarni
35657e6ad469SVishal Kulkarni tcam->cls_lo = t4_read_reg(padap, MPS_CLS_SRAM_L(i));
35667e6ad469SVishal Kulkarni tcam->cls_hi = t4_read_reg(padap, MPS_CLS_SRAM_H(i));
35677e6ad469SVishal Kulkarni
35687e6ad469SVishal Kulkarni if (is_t5(padap->params.chip))
35697e6ad469SVishal Kulkarni tcam->repli = (tcam->cls_lo & F_REPLICATE);
35707e6ad469SVishal Kulkarni else if (is_t6(padap->params.chip))
35717e6ad469SVishal Kulkarni tcam->repli = (tcam->cls_lo & F_T6_REPLICATE);
35727e6ad469SVishal Kulkarni
35737e6ad469SVishal Kulkarni if (tcam->repli) {
35747e6ad469SVishal Kulkarni struct fw_ldst_cmd ldst_cmd;
35757e6ad469SVishal Kulkarni struct fw_ldst_mps_rplc mps_rplc;
35767e6ad469SVishal Kulkarni
35777e6ad469SVishal Kulkarni memset(&ldst_cmd, 0, sizeof(ldst_cmd));
35787e6ad469SVishal Kulkarni ldst_cmd.op_to_addrspace =
35797e6ad469SVishal Kulkarni htonl(V_FW_CMD_OP(FW_LDST_CMD) |
35807e6ad469SVishal Kulkarni F_FW_CMD_REQUEST |
35817e6ad469SVishal Kulkarni F_FW_CMD_READ |
35827e6ad469SVishal Kulkarni V_FW_LDST_CMD_ADDRSPACE(
35837e6ad469SVishal Kulkarni FW_LDST_ADDRSPC_MPS));
35847e6ad469SVishal Kulkarni
35857e6ad469SVishal Kulkarni ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd));
35867e6ad469SVishal Kulkarni
35877e6ad469SVishal Kulkarni ldst_cmd.u.mps.rplc.fid_idx =
35887e6ad469SVishal Kulkarni htons(V_FW_LDST_CMD_FID(FW_LDST_MPS_RPLC) |
35897e6ad469SVishal Kulkarni V_FW_LDST_CMD_IDX(i));
35907e6ad469SVishal Kulkarni
35917e6ad469SVishal Kulkarni rc = begin_synchronized_op(padap->port[0], 1, 1);
35927e6ad469SVishal Kulkarni if (rc == 0) {
35937e6ad469SVishal Kulkarni rc = t4_wr_mbox(padap, padap->mbox, &ldst_cmd,
35947e6ad469SVishal Kulkarni sizeof(ldst_cmd), &ldst_cmd);
35957e6ad469SVishal Kulkarni end_synchronized_op(padap->port[0], 1);
35967e6ad469SVishal Kulkarni }
35977e6ad469SVishal Kulkarni
35987e6ad469SVishal Kulkarni if (rc)
35997e6ad469SVishal Kulkarni mps_rpl_backdoor(padap, &mps_rplc);
36007e6ad469SVishal Kulkarni else
36017e6ad469SVishal Kulkarni mps_rplc = ldst_cmd.u.mps.rplc;
36027e6ad469SVishal Kulkarni
36037e6ad469SVishal Kulkarni tcam->rplc[0] = ntohl(mps_rplc.rplc31_0);
36047e6ad469SVishal Kulkarni tcam->rplc[1] = ntohl(mps_rplc.rplc63_32);
36057e6ad469SVishal Kulkarni tcam->rplc[2] = ntohl(mps_rplc.rplc95_64);
36067e6ad469SVishal Kulkarni tcam->rplc[3] = ntohl(mps_rplc.rplc127_96);
36077e6ad469SVishal Kulkarni if (padap->params.arch.mps_rplc_size >
36087e6ad469SVishal Kulkarni CUDBG_MAX_RPLC_SIZE) {
36097e6ad469SVishal Kulkarni tcam->rplc[4] = ntohl(mps_rplc.rplc159_128);
36107e6ad469SVishal Kulkarni tcam->rplc[5] = ntohl(mps_rplc.rplc191_160);
36117e6ad469SVishal Kulkarni tcam->rplc[6] = ntohl(mps_rplc.rplc223_192);
36127e6ad469SVishal Kulkarni tcam->rplc[7] = ntohl(mps_rplc.rplc255_224);
36137e6ad469SVishal Kulkarni }
36147e6ad469SVishal Kulkarni }
36157e6ad469SVishal Kulkarni cudbg_tcamxy2valmask(tcamx, tcamy, tcam->addr, &tcam->mask);
36167e6ad469SVishal Kulkarni
36177e6ad469SVishal Kulkarni tcam->idx = i;
36187e6ad469SVishal Kulkarni tcam->rplc_size = padap->params.arch.mps_rplc_size;
36197e6ad469SVishal Kulkarni
36207e6ad469SVishal Kulkarni total_size += sizeof(struct cudbg_mps_tcam);
36217e6ad469SVishal Kulkarni
36227e6ad469SVishal Kulkarni tcam++;
36237e6ad469SVishal Kulkarni }
36247e6ad469SVishal Kulkarni
36257e6ad469SVishal Kulkarni if (total_size == 0) {
36267e6ad469SVishal Kulkarni rc = CUDBG_SYSTEM_ERROR;
36277e6ad469SVishal Kulkarni goto err1;
36287e6ad469SVishal Kulkarni }
36297e6ad469SVishal Kulkarni
36307e6ad469SVishal Kulkarni scratch_buff.size = total_size;
36317e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
36327e6ad469SVishal Kulkarni if (rc)
36337e6ad469SVishal Kulkarni goto err1;
36347e6ad469SVishal Kulkarni
36357e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
36367e6ad469SVishal Kulkarni
36377e6ad469SVishal Kulkarni err1:
36387e6ad469SVishal Kulkarni scratch_buff.size = size;
36397e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
36407e6ad469SVishal Kulkarni err:
36417e6ad469SVishal Kulkarni return rc;
36427e6ad469SVishal Kulkarni }
36437e6ad469SVishal Kulkarni
36447e6ad469SVishal Kulkarni static int
collect_pcie_config(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)36457e6ad469SVishal Kulkarni collect_pcie_config(struct cudbg_init *pdbg_init,
36467e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
36477e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
36487e6ad469SVishal Kulkarni {
36497e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
36507e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
36517e6ad469SVishal Kulkarni u32 size, *value, j;
36527e6ad469SVishal Kulkarni int i, rc, n;
36537e6ad469SVishal Kulkarni
36547e6ad469SVishal Kulkarni size = sizeof(u32) * NUM_PCIE_CONFIG_REGS;
36557e6ad469SVishal Kulkarni n = sizeof(t5_pcie_config_array) / (2 * sizeof(u32));
36567e6ad469SVishal Kulkarni scratch_buff.size = size;
36577e6ad469SVishal Kulkarni
36587e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
36597e6ad469SVishal Kulkarni if (rc)
36607e6ad469SVishal Kulkarni goto err;
36617e6ad469SVishal Kulkarni
36627e6ad469SVishal Kulkarni value = (u32 *)scratch_buff.data;
36637e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
36647e6ad469SVishal Kulkarni for (j = t5_pcie_config_array[i][0];
36657e6ad469SVishal Kulkarni j <= t5_pcie_config_array[i][1]; j += 4) {
36667e6ad469SVishal Kulkarni t4_hw_pci_read_cfg4(padap, j, value++);
36677e6ad469SVishal Kulkarni }
36687e6ad469SVishal Kulkarni }
36697e6ad469SVishal Kulkarni
36707e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
36717e6ad469SVishal Kulkarni if (rc)
36727e6ad469SVishal Kulkarni goto err1;
36737e6ad469SVishal Kulkarni
36747e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
36757e6ad469SVishal Kulkarni
36767e6ad469SVishal Kulkarni err1:
36777e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
36787e6ad469SVishal Kulkarni err:
36797e6ad469SVishal Kulkarni return rc;
36807e6ad469SVishal Kulkarni }
36817e6ad469SVishal Kulkarni
36827e6ad469SVishal Kulkarni static int
cudbg_read_tid(struct cudbg_init * pdbg_init,u32 tid,struct cudbg_tid_data * tid_data)36837e6ad469SVishal Kulkarni cudbg_read_tid(struct cudbg_init *pdbg_init, u32 tid,
36847e6ad469SVishal Kulkarni struct cudbg_tid_data *tid_data)
36857e6ad469SVishal Kulkarni {
36867e6ad469SVishal Kulkarni int i, cmd_retry = 8;
36877e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
36887e6ad469SVishal Kulkarni u32 val;
36897e6ad469SVishal Kulkarni
36907e6ad469SVishal Kulkarni /* Fill REQ_DATA regs with 0's */
36917e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_NUM_REQ_REGS; i++)
36927e6ad469SVishal Kulkarni t4_write_reg(padap, A_LE_DB_DBGI_REQ_DATA + (i << 2), 0);
36937e6ad469SVishal Kulkarni
36947e6ad469SVishal Kulkarni /* Write DBIG command */
36957e6ad469SVishal Kulkarni val = (0x4 << S_DBGICMD) | tid;
36967e6ad469SVishal Kulkarni t4_write_reg(padap, A_LE_DB_DBGI_REQ_TCAM_CMD, val);
36977e6ad469SVishal Kulkarni tid_data->dbig_cmd = val;
36987e6ad469SVishal Kulkarni
36997e6ad469SVishal Kulkarni val = 0;
37007e6ad469SVishal Kulkarni val |= 1 << S_DBGICMDSTRT;
37017e6ad469SVishal Kulkarni val |= 1; /* LE mode */
37027e6ad469SVishal Kulkarni t4_write_reg(padap, A_LE_DB_DBGI_CONFIG, val);
37037e6ad469SVishal Kulkarni tid_data->dbig_conf = val;
37047e6ad469SVishal Kulkarni
37057e6ad469SVishal Kulkarni /* Poll the DBGICMDBUSY bit */
37067e6ad469SVishal Kulkarni val = 1;
37077e6ad469SVishal Kulkarni while (val) {
37087e6ad469SVishal Kulkarni val = t4_read_reg(padap, A_LE_DB_DBGI_CONFIG);
37097e6ad469SVishal Kulkarni val = (val >> S_DBGICMDBUSY) & 1;
37107e6ad469SVishal Kulkarni cmd_retry--;
37117e6ad469SVishal Kulkarni if (!cmd_retry) {
37127e6ad469SVishal Kulkarni if (pdbg_init->verbose)
37137e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
37147e6ad469SVishal Kulkarni "%s(): Timeout waiting for non-busy\n",
37157e6ad469SVishal Kulkarni __func__);
37167e6ad469SVishal Kulkarni return CUDBG_SYSTEM_ERROR;
37177e6ad469SVishal Kulkarni }
37187e6ad469SVishal Kulkarni }
37197e6ad469SVishal Kulkarni
37207e6ad469SVishal Kulkarni /* Check RESP status */
37217e6ad469SVishal Kulkarni val = 0;
37227e6ad469SVishal Kulkarni val = t4_read_reg(padap, A_LE_DB_DBGI_RSP_STATUS);
37237e6ad469SVishal Kulkarni tid_data->dbig_rsp_stat = val;
37247e6ad469SVishal Kulkarni if (!(val & 1)) {
37257e6ad469SVishal Kulkarni if (pdbg_init->verbose)
37267e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
37277e6ad469SVishal Kulkarni "%s(): DBGI command failed\n", __func__);
37287e6ad469SVishal Kulkarni return CUDBG_SYSTEM_ERROR;
37297e6ad469SVishal Kulkarni }
37307e6ad469SVishal Kulkarni
37317e6ad469SVishal Kulkarni /* Read RESP data */
37327e6ad469SVishal Kulkarni for (i = 0; i < CUDBG_NUM_REQ_REGS; i++)
37337e6ad469SVishal Kulkarni tid_data->data[i] = t4_read_reg(padap,
37347e6ad469SVishal Kulkarni A_LE_DB_DBGI_RSP_DATA +
37357e6ad469SVishal Kulkarni (i << 2));
37367e6ad469SVishal Kulkarni
37377e6ad469SVishal Kulkarni tid_data->tid = tid;
37387e6ad469SVishal Kulkarni
37397e6ad469SVishal Kulkarni return 0;
37407e6ad469SVishal Kulkarni }
37417e6ad469SVishal Kulkarni
37427e6ad469SVishal Kulkarni static int
collect_le_tcam(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)37437e6ad469SVishal Kulkarni collect_le_tcam(struct cudbg_init *pdbg_init,
37447e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
37457e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
37467e6ad469SVishal Kulkarni {
37477e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
37487e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
37497e6ad469SVishal Kulkarni struct cudbg_tcam tcam_region = {0};
37507e6ad469SVishal Kulkarni struct cudbg_tid_data *tid_data = NULL;
37517e6ad469SVishal Kulkarni u32 value, bytes = 0, bytes_left = 0;
37527e6ad469SVishal Kulkarni u32 i;
37537e6ad469SVishal Kulkarni int rc, size;
37547e6ad469SVishal Kulkarni
37557e6ad469SVishal Kulkarni /* Get the LE regions */
37567e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_TID_HASHBASE); /* Get hash base
37577e6ad469SVishal Kulkarni index */
37587e6ad469SVishal Kulkarni tcam_region.tid_hash_base = value;
37597e6ad469SVishal Kulkarni
37607e6ad469SVishal Kulkarni /* Get routing table index */
37617e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_ROUTING_TABLE_INDEX);
37627e6ad469SVishal Kulkarni tcam_region.routing_start = value;
37637e6ad469SVishal Kulkarni
37647e6ad469SVishal Kulkarni /*Get clip table index */
37657e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_CLIP_TABLE_INDEX);
37667e6ad469SVishal Kulkarni tcam_region.clip_start = value;
37677e6ad469SVishal Kulkarni
37687e6ad469SVishal Kulkarni /* Get filter table index */
37697e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_FILTER_TABLE_INDEX);
37707e6ad469SVishal Kulkarni tcam_region.filter_start = value;
37717e6ad469SVishal Kulkarni
37727e6ad469SVishal Kulkarni /* Get server table index */
37737e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_SERVER_INDEX);
37747e6ad469SVishal Kulkarni tcam_region.server_start = value;
37757e6ad469SVishal Kulkarni
37767e6ad469SVishal Kulkarni /* Check whether hash is enabled and calculate the max tids */
37777e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_CONFIG);
37787e6ad469SVishal Kulkarni if ((value >> S_HASHEN) & 1) {
37797e6ad469SVishal Kulkarni value = t4_read_reg(padap, A_LE_DB_HASH_CONFIG);
37807e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) > CHELSIO_T5)
37817e6ad469SVishal Kulkarni tcam_region.max_tid = (value & 0xFFFFF) +
37827e6ad469SVishal Kulkarni tcam_region.tid_hash_base;
37837e6ad469SVishal Kulkarni else { /* for T5 */
37847e6ad469SVishal Kulkarni value = G_HASHTIDSIZE(value);
37857e6ad469SVishal Kulkarni value = 1 << value;
37867e6ad469SVishal Kulkarni tcam_region.max_tid = value +
37877e6ad469SVishal Kulkarni tcam_region.tid_hash_base;
37887e6ad469SVishal Kulkarni }
37897e6ad469SVishal Kulkarni } else /* hash not enabled */
37907e6ad469SVishal Kulkarni tcam_region.max_tid = CUDBG_MAX_TCAM_TID;
37917e6ad469SVishal Kulkarni
37927e6ad469SVishal Kulkarni size = sizeof(struct cudbg_tid_data) * tcam_region.max_tid;
37937e6ad469SVishal Kulkarni size += sizeof(struct cudbg_tcam);
37947e6ad469SVishal Kulkarni scratch_buff.size = size;
37957e6ad469SVishal Kulkarni
37967e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
37977e6ad469SVishal Kulkarni if (rc)
37987e6ad469SVishal Kulkarni goto err;
37997e6ad469SVishal Kulkarni
38007e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, CUDBG_CHUNK_SIZE, &scratch_buff);
38017e6ad469SVishal Kulkarni if (rc)
38027e6ad469SVishal Kulkarni goto err;
38037e6ad469SVishal Kulkarni
38047e6ad469SVishal Kulkarni memcpy(scratch_buff.data, &tcam_region, sizeof(struct cudbg_tcam));
38057e6ad469SVishal Kulkarni
38067e6ad469SVishal Kulkarni tid_data = (struct cudbg_tid_data *)(((struct cudbg_tcam *)
38077e6ad469SVishal Kulkarni scratch_buff.data) + 1);
38087e6ad469SVishal Kulkarni bytes_left = CUDBG_CHUNK_SIZE - sizeof(struct cudbg_tcam);
38097e6ad469SVishal Kulkarni bytes = sizeof(struct cudbg_tcam);
38107e6ad469SVishal Kulkarni
38117e6ad469SVishal Kulkarni /* read all tid */
38127e6ad469SVishal Kulkarni for (i = 0; i < tcam_region.max_tid; i++) {
38137e6ad469SVishal Kulkarni if (bytes_left < sizeof(struct cudbg_tid_data)) {
38147e6ad469SVishal Kulkarni scratch_buff.size = bytes;
38157e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
38167e6ad469SVishal Kulkarni if (rc)
38177e6ad469SVishal Kulkarni goto err1;
38187e6ad469SVishal Kulkarni scratch_buff.size = CUDBG_CHUNK_SIZE;
38197e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
38207e6ad469SVishal Kulkarni
38217e6ad469SVishal Kulkarni /* new alloc */
38227e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, CUDBG_CHUNK_SIZE,
38237e6ad469SVishal Kulkarni &scratch_buff);
38247e6ad469SVishal Kulkarni if (rc)
38257e6ad469SVishal Kulkarni goto err;
38267e6ad469SVishal Kulkarni
38277e6ad469SVishal Kulkarni tid_data = (struct cudbg_tid_data *)(scratch_buff.data);
38287e6ad469SVishal Kulkarni bytes_left = CUDBG_CHUNK_SIZE;
38297e6ad469SVishal Kulkarni bytes = 0;
38307e6ad469SVishal Kulkarni }
38317e6ad469SVishal Kulkarni
38327e6ad469SVishal Kulkarni rc = cudbg_read_tid(pdbg_init, i, tid_data);
38337e6ad469SVishal Kulkarni
38347e6ad469SVishal Kulkarni if (rc) {
38357e6ad469SVishal Kulkarni cudbg_err->sys_err = rc;
38367e6ad469SVishal Kulkarni goto err1;
38377e6ad469SVishal Kulkarni }
38387e6ad469SVishal Kulkarni
38397e6ad469SVishal Kulkarni tid_data++;
38407e6ad469SVishal Kulkarni bytes_left -= sizeof(struct cudbg_tid_data);
38417e6ad469SVishal Kulkarni bytes += sizeof(struct cudbg_tid_data);
38427e6ad469SVishal Kulkarni }
38437e6ad469SVishal Kulkarni
38447e6ad469SVishal Kulkarni if (bytes) {
38457e6ad469SVishal Kulkarni scratch_buff.size = bytes;
38467e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
38477e6ad469SVishal Kulkarni }
38487e6ad469SVishal Kulkarni
38497e6ad469SVishal Kulkarni err1:
38507e6ad469SVishal Kulkarni scratch_buff.size = CUDBG_CHUNK_SIZE;
38517e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
38527e6ad469SVishal Kulkarni err:
38537e6ad469SVishal Kulkarni return rc;
38547e6ad469SVishal Kulkarni }
38557e6ad469SVishal Kulkarni
38567e6ad469SVishal Kulkarni static int
collect_ma_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)38577e6ad469SVishal Kulkarni collect_ma_indirect(struct cudbg_init *pdbg_init,
38587e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
38597e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
38607e6ad469SVishal Kulkarni {
38617e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
38627e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
38637e6ad469SVishal Kulkarni struct ireg_buf *ma_indr = NULL;
38647e6ad469SVishal Kulkarni u32 size, j;
38657e6ad469SVishal Kulkarni int i, rc, n;
38667e6ad469SVishal Kulkarni
38677e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) < CHELSIO_T6) {
38687e6ad469SVishal Kulkarni if (pdbg_init->verbose)
38697e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
38707e6ad469SVishal Kulkarni "MA indirect available only in T6\n");
38717e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
38727e6ad469SVishal Kulkarni goto err;
38737e6ad469SVishal Kulkarni }
38747e6ad469SVishal Kulkarni
38757e6ad469SVishal Kulkarni n = sizeof(t6_ma_ireg_array) / (4 * sizeof(u32));
38767e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n * 2;
38777e6ad469SVishal Kulkarni scratch_buff.size = size;
38787e6ad469SVishal Kulkarni
38797e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
38807e6ad469SVishal Kulkarni if (rc)
38817e6ad469SVishal Kulkarni goto err;
38827e6ad469SVishal Kulkarni
38837e6ad469SVishal Kulkarni ma_indr = (struct ireg_buf *)scratch_buff.data;
38847e6ad469SVishal Kulkarni
38857e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
38867e6ad469SVishal Kulkarni struct ireg_field *ma_fli = &ma_indr->tp_pio;
38877e6ad469SVishal Kulkarni u32 *buff = ma_indr->outbuf;
38887e6ad469SVishal Kulkarni
38897e6ad469SVishal Kulkarni ma_fli->ireg_addr = t6_ma_ireg_array[i][0];
38907e6ad469SVishal Kulkarni ma_fli->ireg_data = t6_ma_ireg_array[i][1];
38917e6ad469SVishal Kulkarni ma_fli->ireg_local_offset = t6_ma_ireg_array[i][2];
38927e6ad469SVishal Kulkarni ma_fli->ireg_offset_range = t6_ma_ireg_array[i][3];
38937e6ad469SVishal Kulkarni
38947e6ad469SVishal Kulkarni t4_read_indirect(padap, ma_fli->ireg_addr, ma_fli->ireg_data,
38957e6ad469SVishal Kulkarni buff, ma_fli->ireg_offset_range,
38967e6ad469SVishal Kulkarni ma_fli->ireg_local_offset);
38977e6ad469SVishal Kulkarni
38987e6ad469SVishal Kulkarni ma_indr++;
38997e6ad469SVishal Kulkarni
39007e6ad469SVishal Kulkarni }
39017e6ad469SVishal Kulkarni
39027e6ad469SVishal Kulkarni n = sizeof(t6_ma_ireg_array2) / (4 * sizeof(u32));
39037e6ad469SVishal Kulkarni
39047e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
39057e6ad469SVishal Kulkarni struct ireg_field *ma_fli = &ma_indr->tp_pio;
39067e6ad469SVishal Kulkarni u32 *buff = ma_indr->outbuf;
39077e6ad469SVishal Kulkarni
39087e6ad469SVishal Kulkarni ma_fli->ireg_addr = t6_ma_ireg_array2[i][0];
39097e6ad469SVishal Kulkarni ma_fli->ireg_data = t6_ma_ireg_array2[i][1];
39107e6ad469SVishal Kulkarni ma_fli->ireg_local_offset = t6_ma_ireg_array2[i][2];
39117e6ad469SVishal Kulkarni
39127e6ad469SVishal Kulkarni for (j = 0; j < t6_ma_ireg_array2[i][3]; j++) {
39137e6ad469SVishal Kulkarni t4_read_indirect(padap, ma_fli->ireg_addr,
39147e6ad469SVishal Kulkarni ma_fli->ireg_data, buff, 1,
39157e6ad469SVishal Kulkarni ma_fli->ireg_local_offset);
39167e6ad469SVishal Kulkarni buff++;
39177e6ad469SVishal Kulkarni ma_fli->ireg_local_offset += 0x20;
39187e6ad469SVishal Kulkarni }
39197e6ad469SVishal Kulkarni ma_indr++;
39207e6ad469SVishal Kulkarni }
39217e6ad469SVishal Kulkarni
39227e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
39237e6ad469SVishal Kulkarni if (rc)
39247e6ad469SVishal Kulkarni goto err1;
39257e6ad469SVishal Kulkarni
39267e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
39277e6ad469SVishal Kulkarni
39287e6ad469SVishal Kulkarni err1:
39297e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
39307e6ad469SVishal Kulkarni err:
39317e6ad469SVishal Kulkarni return rc;
39327e6ad469SVishal Kulkarni }
39337e6ad469SVishal Kulkarni
39347e6ad469SVishal Kulkarni static int
collect_hma_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)39357e6ad469SVishal Kulkarni collect_hma_indirect(struct cudbg_init *pdbg_init,
39367e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
39377e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
39387e6ad469SVishal Kulkarni {
39397e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
39407e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
39417e6ad469SVishal Kulkarni struct ireg_buf *hma_indr = NULL;
39427e6ad469SVishal Kulkarni u32 size;
39437e6ad469SVishal Kulkarni int i, rc, n;
39447e6ad469SVishal Kulkarni
39457e6ad469SVishal Kulkarni if (CHELSIO_CHIP_VERSION(padap->params.chip) < CHELSIO_T6) {
39467e6ad469SVishal Kulkarni if (pdbg_init->verbose)
39477e6ad469SVishal Kulkarni pdbg_init->print(padap->dip, CE_NOTE,
39487e6ad469SVishal Kulkarni "HMA indirect available only in T6\n");
39497e6ad469SVishal Kulkarni rc = CUDBG_STATUS_ENTITY_NOT_FOUND;
39507e6ad469SVishal Kulkarni goto err;
39517e6ad469SVishal Kulkarni }
39527e6ad469SVishal Kulkarni
39537e6ad469SVishal Kulkarni n = sizeof(t6_hma_ireg_array) / (4 * sizeof(u32));
39547e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n;
39557e6ad469SVishal Kulkarni scratch_buff.size = size;
39567e6ad469SVishal Kulkarni
39577e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
39587e6ad469SVishal Kulkarni if (rc)
39597e6ad469SVishal Kulkarni goto err;
39607e6ad469SVishal Kulkarni
39617e6ad469SVishal Kulkarni hma_indr = (struct ireg_buf *)scratch_buff.data;
39627e6ad469SVishal Kulkarni
39637e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
39647e6ad469SVishal Kulkarni struct ireg_field *hma_fli = &hma_indr->tp_pio;
39657e6ad469SVishal Kulkarni u32 *buff = hma_indr->outbuf;
39667e6ad469SVishal Kulkarni
39677e6ad469SVishal Kulkarni hma_fli->ireg_addr = t6_hma_ireg_array[i][0];
39687e6ad469SVishal Kulkarni hma_fli->ireg_data = t6_hma_ireg_array[i][1];
39697e6ad469SVishal Kulkarni hma_fli->ireg_local_offset = t6_hma_ireg_array[i][2];
39707e6ad469SVishal Kulkarni hma_fli->ireg_offset_range = t6_hma_ireg_array[i][3];
39717e6ad469SVishal Kulkarni
39727e6ad469SVishal Kulkarni t4_read_indirect(padap, hma_fli->ireg_addr, hma_fli->ireg_data,
39737e6ad469SVishal Kulkarni buff, hma_fli->ireg_offset_range,
39747e6ad469SVishal Kulkarni hma_fli->ireg_local_offset);
39757e6ad469SVishal Kulkarni
39767e6ad469SVishal Kulkarni hma_indr++;
39777e6ad469SVishal Kulkarni
39787e6ad469SVishal Kulkarni }
39797e6ad469SVishal Kulkarni
39807e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
39817e6ad469SVishal Kulkarni if (rc)
39827e6ad469SVishal Kulkarni goto err1;
39837e6ad469SVishal Kulkarni
39847e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
39857e6ad469SVishal Kulkarni
39867e6ad469SVishal Kulkarni err1:
39877e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
39887e6ad469SVishal Kulkarni err:
39897e6ad469SVishal Kulkarni return rc;
39907e6ad469SVishal Kulkarni }
39917e6ad469SVishal Kulkarni
39927e6ad469SVishal Kulkarni static int
collect_pcie_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)39937e6ad469SVishal Kulkarni collect_pcie_indirect(struct cudbg_init *pdbg_init,
39947e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
39957e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
39967e6ad469SVishal Kulkarni {
39977e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
39987e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
39997e6ad469SVishal Kulkarni struct ireg_buf *ch_pcie;
40007e6ad469SVishal Kulkarni u32 size;
40017e6ad469SVishal Kulkarni int i, rc, n;
40027e6ad469SVishal Kulkarni
40037e6ad469SVishal Kulkarni n = sizeof(t5_pcie_pdbg_array) / (4 * sizeof(u32));
40047e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n * 2;
40057e6ad469SVishal Kulkarni scratch_buff.size = size;
40067e6ad469SVishal Kulkarni
40077e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
40087e6ad469SVishal Kulkarni if (rc)
40097e6ad469SVishal Kulkarni goto err;
40107e6ad469SVishal Kulkarni
40117e6ad469SVishal Kulkarni ch_pcie = (struct ireg_buf *)scratch_buff.data;
40127e6ad469SVishal Kulkarni
40137e6ad469SVishal Kulkarni /*PCIE_PDBG*/
40147e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
40157e6ad469SVishal Kulkarni struct ireg_field *pcie_pio = &ch_pcie->tp_pio;
40167e6ad469SVishal Kulkarni u32 *buff = ch_pcie->outbuf;
40177e6ad469SVishal Kulkarni
40187e6ad469SVishal Kulkarni pcie_pio->ireg_addr = t5_pcie_pdbg_array[i][0];
40197e6ad469SVishal Kulkarni pcie_pio->ireg_data = t5_pcie_pdbg_array[i][1];
40207e6ad469SVishal Kulkarni pcie_pio->ireg_local_offset = t5_pcie_pdbg_array[i][2];
40217e6ad469SVishal Kulkarni pcie_pio->ireg_offset_range = t5_pcie_pdbg_array[i][3];
40227e6ad469SVishal Kulkarni
40237e6ad469SVishal Kulkarni t4_read_indirect(padap,
40247e6ad469SVishal Kulkarni pcie_pio->ireg_addr,
40257e6ad469SVishal Kulkarni pcie_pio->ireg_data,
40267e6ad469SVishal Kulkarni buff,
40277e6ad469SVishal Kulkarni pcie_pio->ireg_offset_range,
40287e6ad469SVishal Kulkarni pcie_pio->ireg_local_offset);
40297e6ad469SVishal Kulkarni
40307e6ad469SVishal Kulkarni ch_pcie++;
40317e6ad469SVishal Kulkarni }
40327e6ad469SVishal Kulkarni
40337e6ad469SVishal Kulkarni /*PCIE_CDBG*/
40347e6ad469SVishal Kulkarni n = sizeof(t5_pcie_cdbg_array) / (4 * sizeof(u32));
40357e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
40367e6ad469SVishal Kulkarni struct ireg_field *pcie_pio = &ch_pcie->tp_pio;
40377e6ad469SVishal Kulkarni u32 *buff = ch_pcie->outbuf;
40387e6ad469SVishal Kulkarni
40397e6ad469SVishal Kulkarni pcie_pio->ireg_addr = t5_pcie_cdbg_array[i][0];
40407e6ad469SVishal Kulkarni pcie_pio->ireg_data = t5_pcie_cdbg_array[i][1];
40417e6ad469SVishal Kulkarni pcie_pio->ireg_local_offset = t5_pcie_cdbg_array[i][2];
40427e6ad469SVishal Kulkarni pcie_pio->ireg_offset_range = t5_pcie_cdbg_array[i][3];
40437e6ad469SVishal Kulkarni
40447e6ad469SVishal Kulkarni t4_read_indirect(padap,
40457e6ad469SVishal Kulkarni pcie_pio->ireg_addr,
40467e6ad469SVishal Kulkarni pcie_pio->ireg_data,
40477e6ad469SVishal Kulkarni buff,
40487e6ad469SVishal Kulkarni pcie_pio->ireg_offset_range,
40497e6ad469SVishal Kulkarni pcie_pio->ireg_local_offset);
40507e6ad469SVishal Kulkarni
40517e6ad469SVishal Kulkarni ch_pcie++;
40527e6ad469SVishal Kulkarni }
40537e6ad469SVishal Kulkarni
40547e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
40557e6ad469SVishal Kulkarni if (rc)
40567e6ad469SVishal Kulkarni goto err1;
40577e6ad469SVishal Kulkarni
40587e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
40597e6ad469SVishal Kulkarni
40607e6ad469SVishal Kulkarni err1:
40617e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
40627e6ad469SVishal Kulkarni err:
40637e6ad469SVishal Kulkarni return rc;
40647e6ad469SVishal Kulkarni
40657e6ad469SVishal Kulkarni }
40667e6ad469SVishal Kulkarni
40677e6ad469SVishal Kulkarni static int
collect_tp_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)40687e6ad469SVishal Kulkarni collect_tp_indirect(struct cudbg_init *pdbg_init,
40697e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
40707e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
40717e6ad469SVishal Kulkarni {
40727e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
40737e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
40747e6ad469SVishal Kulkarni struct ireg_buf *ch_tp_pio;
40757e6ad469SVishal Kulkarni u32 size;
40767e6ad469SVishal Kulkarni int i, rc, n = 0;
40777e6ad469SVishal Kulkarni
40787e6ad469SVishal Kulkarni if (is_t5(padap->params.chip))
40797e6ad469SVishal Kulkarni n = sizeof(t5_tp_pio_array) / (4 * sizeof(u32));
40807e6ad469SVishal Kulkarni else if (is_t6(padap->params.chip))
40817e6ad469SVishal Kulkarni n = sizeof(t6_tp_pio_array) / (4 * sizeof(u32));
40827e6ad469SVishal Kulkarni
40837e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * n * 3;
40847e6ad469SVishal Kulkarni scratch_buff.size = size;
40857e6ad469SVishal Kulkarni
40867e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
40877e6ad469SVishal Kulkarni if (rc)
40887e6ad469SVishal Kulkarni goto err;
40897e6ad469SVishal Kulkarni
40907e6ad469SVishal Kulkarni ch_tp_pio = (struct ireg_buf *)scratch_buff.data;
40917e6ad469SVishal Kulkarni
40927e6ad469SVishal Kulkarni /* TP_PIO*/
40937e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
40947e6ad469SVishal Kulkarni struct ireg_field *tp_pio = &ch_tp_pio->tp_pio;
40957e6ad469SVishal Kulkarni u32 *buff = ch_tp_pio->outbuf;
40967e6ad469SVishal Kulkarni
40977e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
40987e6ad469SVishal Kulkarni tp_pio->ireg_addr = t5_tp_pio_array[i][0];
40997e6ad469SVishal Kulkarni tp_pio->ireg_data = t5_tp_pio_array[i][1];
41007e6ad469SVishal Kulkarni tp_pio->ireg_local_offset = t5_tp_pio_array[i][2];
41017e6ad469SVishal Kulkarni tp_pio->ireg_offset_range = t5_tp_pio_array[i][3];
41027e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
41037e6ad469SVishal Kulkarni tp_pio->ireg_addr = t6_tp_pio_array[i][0];
41047e6ad469SVishal Kulkarni tp_pio->ireg_data = t6_tp_pio_array[i][1];
41057e6ad469SVishal Kulkarni tp_pio->ireg_local_offset = t6_tp_pio_array[i][2];
41067e6ad469SVishal Kulkarni tp_pio->ireg_offset_range = t6_tp_pio_array[i][3];
41077e6ad469SVishal Kulkarni }
41087e6ad469SVishal Kulkarni
41097e6ad469SVishal Kulkarni t4_tp_pio_read(padap, buff, tp_pio->ireg_offset_range,
41107e6ad469SVishal Kulkarni tp_pio->ireg_local_offset, true);
41117e6ad469SVishal Kulkarni
41127e6ad469SVishal Kulkarni ch_tp_pio++;
41137e6ad469SVishal Kulkarni }
41147e6ad469SVishal Kulkarni
41157e6ad469SVishal Kulkarni /* TP_TM_PIO*/
41167e6ad469SVishal Kulkarni if (is_t5(padap->params.chip))
41177e6ad469SVishal Kulkarni n = sizeof(t5_tp_tm_pio_array) / (4 * sizeof(u32));
41187e6ad469SVishal Kulkarni else if (is_t6(padap->params.chip))
41197e6ad469SVishal Kulkarni n = sizeof(t6_tp_tm_pio_array) / (4 * sizeof(u32));
41207e6ad469SVishal Kulkarni
41217e6ad469SVishal Kulkarni for (i = 0; i < n; i++) {
41227e6ad469SVishal Kulkarni struct ireg_field *tp_pio = &ch_tp_pio->tp_pio;
41237e6ad469SVishal Kulkarni u32 *buff = ch_tp_pio->outbuf;
41247e6ad469SVishal Kulkarni
41257e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
41267e6ad469SVishal Kulkarni tp_pio->ireg_addr = t5_tp_tm_pio_array[i][0];
41277e6ad469SVishal Kulkarni tp_pio->ireg_data = t5_tp_tm_pio_array[i][1];
41287e6ad469SVishal Kulkarni tp_pio->ireg_local_offset = t5_tp_tm_pio_array[i][2];
41297e6ad469SVishal Kulkarni tp_pio->ireg_offset_range = t5_tp_tm_pio_array[i][3];
41307e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
41317e6ad469SVishal Kulkarni tp_pio->ireg_addr = t6_tp_tm_pio_array[i][0];
41327e6ad469SVishal Kulkarni tp_pio->ireg_data = t6_tp_tm_pio_array[i][1];
41337e6ad469SVishal Kulkarni tp_pio->ireg_local_offset = t6_tp_tm_pio_array[i][2];
41347e6ad469SVishal Kulkarni tp_pio->ireg_offset_range = t6_tp_tm_pio_array[i][3];
41357e6ad469SVishal Kulkarni }
41367e6ad469SVishal Kulkarni
41377e6ad469SVishal Kulkarni t4_tp_tm_pio_read(padap, buff, tp_pio->ireg_offset_range,
41387e6ad469SVishal Kulkarni tp_pio->ireg_local_offset, true);
41397e6ad469SVishal Kulkarni
41407e6ad469SVishal Kulkarni ch_tp_pio++;
41417e6ad469SVishal Kulkarni }
41427e6ad469SVishal Kulkarni
41437e6ad469SVishal Kulkarni /* TP_MIB_INDEX*/
41447e6ad469SVishal Kulkarni if (is_t5(padap->params.chip))
41457e6ad469SVishal Kulkarni n = sizeof(t5_tp_mib_index_array) / (4 * sizeof(u32));
41467e6ad469SVishal Kulkarni else if (is_t6(padap->params.chip))
41477e6ad469SVishal Kulkarni n = sizeof(t6_tp_mib_index_array) / (4 * sizeof(u32));
41487e6ad469SVishal Kulkarni
41497e6ad469SVishal Kulkarni for (i = 0; i < n ; i++) {
41507e6ad469SVishal Kulkarni struct ireg_field *tp_pio = &ch_tp_pio->tp_pio;
41517e6ad469SVishal Kulkarni u32 *buff = ch_tp_pio->outbuf;
41527e6ad469SVishal Kulkarni
41537e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
41547e6ad469SVishal Kulkarni tp_pio->ireg_addr = t5_tp_mib_index_array[i][0];
41557e6ad469SVishal Kulkarni tp_pio->ireg_data = t5_tp_mib_index_array[i][1];
41567e6ad469SVishal Kulkarni tp_pio->ireg_local_offset =
41577e6ad469SVishal Kulkarni t5_tp_mib_index_array[i][2];
41587e6ad469SVishal Kulkarni tp_pio->ireg_offset_range =
41597e6ad469SVishal Kulkarni t5_tp_mib_index_array[i][3];
41607e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
41617e6ad469SVishal Kulkarni tp_pio->ireg_addr = t6_tp_mib_index_array[i][0];
41627e6ad469SVishal Kulkarni tp_pio->ireg_data = t6_tp_mib_index_array[i][1];
41637e6ad469SVishal Kulkarni tp_pio->ireg_local_offset =
41647e6ad469SVishal Kulkarni t6_tp_mib_index_array[i][2];
41657e6ad469SVishal Kulkarni tp_pio->ireg_offset_range =
41667e6ad469SVishal Kulkarni t6_tp_mib_index_array[i][3];
41677e6ad469SVishal Kulkarni }
41687e6ad469SVishal Kulkarni
41697e6ad469SVishal Kulkarni t4_tp_mib_read(padap, buff, tp_pio->ireg_offset_range,
41707e6ad469SVishal Kulkarni tp_pio->ireg_local_offset, true);
41717e6ad469SVishal Kulkarni
41727e6ad469SVishal Kulkarni ch_tp_pio++;
41737e6ad469SVishal Kulkarni }
41747e6ad469SVishal Kulkarni
41757e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
41767e6ad469SVishal Kulkarni if (rc)
41777e6ad469SVishal Kulkarni goto err1;
41787e6ad469SVishal Kulkarni
41797e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
41807e6ad469SVishal Kulkarni
41817e6ad469SVishal Kulkarni err1:
41827e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
41837e6ad469SVishal Kulkarni err:
41847e6ad469SVishal Kulkarni return rc;
41857e6ad469SVishal Kulkarni }
41867e6ad469SVishal Kulkarni
41877e6ad469SVishal Kulkarni static int
collect_sge_indirect(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)41887e6ad469SVishal Kulkarni collect_sge_indirect(struct cudbg_init *pdbg_init,
41897e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
41907e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
41917e6ad469SVishal Kulkarni {
41927e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
41937e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
41947e6ad469SVishal Kulkarni struct ireg_buf *ch_sge_dbg;
41957e6ad469SVishal Kulkarni u32 size;
41967e6ad469SVishal Kulkarni int i, rc;
41977e6ad469SVishal Kulkarni
41987e6ad469SVishal Kulkarni size = sizeof(struct ireg_buf) * 2;
41997e6ad469SVishal Kulkarni scratch_buff.size = size;
42007e6ad469SVishal Kulkarni
42017e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
42027e6ad469SVishal Kulkarni if (rc)
42037e6ad469SVishal Kulkarni goto err;
42047e6ad469SVishal Kulkarni
42057e6ad469SVishal Kulkarni ch_sge_dbg = (struct ireg_buf *)scratch_buff.data;
42067e6ad469SVishal Kulkarni
42077e6ad469SVishal Kulkarni for (i = 0; i < 2; i++) {
42087e6ad469SVishal Kulkarni struct ireg_field *sge_pio = &ch_sge_dbg->tp_pio;
42097e6ad469SVishal Kulkarni u32 *buff = ch_sge_dbg->outbuf;
42107e6ad469SVishal Kulkarni
42117e6ad469SVishal Kulkarni sge_pio->ireg_addr = t5_sge_dbg_index_array[i][0];
42127e6ad469SVishal Kulkarni sge_pio->ireg_data = t5_sge_dbg_index_array[i][1];
42137e6ad469SVishal Kulkarni sge_pio->ireg_local_offset = t5_sge_dbg_index_array[i][2];
42147e6ad469SVishal Kulkarni sge_pio->ireg_offset_range = t5_sge_dbg_index_array[i][3];
42157e6ad469SVishal Kulkarni
42167e6ad469SVishal Kulkarni t4_read_indirect(padap,
42177e6ad469SVishal Kulkarni sge_pio->ireg_addr,
42187e6ad469SVishal Kulkarni sge_pio->ireg_data,
42197e6ad469SVishal Kulkarni buff,
42207e6ad469SVishal Kulkarni sge_pio->ireg_offset_range,
42217e6ad469SVishal Kulkarni sge_pio->ireg_local_offset);
42227e6ad469SVishal Kulkarni
42237e6ad469SVishal Kulkarni ch_sge_dbg++;
42247e6ad469SVishal Kulkarni }
42257e6ad469SVishal Kulkarni
42267e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
42277e6ad469SVishal Kulkarni if (rc)
42287e6ad469SVishal Kulkarni goto err1;
42297e6ad469SVishal Kulkarni
42307e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
42317e6ad469SVishal Kulkarni
42327e6ad469SVishal Kulkarni err1:
42337e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
42347e6ad469SVishal Kulkarni err:
42357e6ad469SVishal Kulkarni return rc;
42367e6ad469SVishal Kulkarni }
42377e6ad469SVishal Kulkarni
42387e6ad469SVishal Kulkarni static int
collect_full(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)42397e6ad469SVishal Kulkarni collect_full(struct cudbg_init *pdbg_init,
42407e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
42417e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
42427e6ad469SVishal Kulkarni {
42437e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
42447e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
42457e6ad469SVishal Kulkarni u32 reg_addr, reg_data, reg_local_offset, reg_offset_range;
42467e6ad469SVishal Kulkarni u32 *sp;
42477e6ad469SVishal Kulkarni int rc;
42487e6ad469SVishal Kulkarni int nreg = 0;
42497e6ad469SVishal Kulkarni
42507e6ad469SVishal Kulkarni /* Collect Registers:
42517e6ad469SVishal Kulkarni * TP_DBG_SCHED_TX (0x7e40 + 0x6a),
42527e6ad469SVishal Kulkarni * TP_DBG_SCHED_RX (0x7e40 + 0x6b),
42537e6ad469SVishal Kulkarni * TP_DBG_CSIDE_INT (0x7e40 + 0x23f),
42547e6ad469SVishal Kulkarni * TP_DBG_ESIDE_INT (0x7e40 + 0x148),
42557e6ad469SVishal Kulkarni * PCIE_CDEBUG_INDEX[AppData0] (0x5a10 + 2),
42567e6ad469SVishal Kulkarni * PCIE_CDEBUG_INDEX[AppData1] (0x5a10 + 3) This is for T6
42577e6ad469SVishal Kulkarni * SGE_DEBUG_DATA_HIGH_INDEX_10 (0x12a8)
42587e6ad469SVishal Kulkarni **/
42597e6ad469SVishal Kulkarni
42607e6ad469SVishal Kulkarni if (is_t5(padap->params.chip))
42617e6ad469SVishal Kulkarni nreg = 6;
42627e6ad469SVishal Kulkarni else if (is_t6(padap->params.chip))
42637e6ad469SVishal Kulkarni nreg = 7;
42647e6ad469SVishal Kulkarni
42657e6ad469SVishal Kulkarni scratch_buff.size = nreg * sizeof(u32);
42667e6ad469SVishal Kulkarni
42677e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
42687e6ad469SVishal Kulkarni if (rc)
42697e6ad469SVishal Kulkarni goto err;
42707e6ad469SVishal Kulkarni
42717e6ad469SVishal Kulkarni sp = (u32 *)scratch_buff.data;
42727e6ad469SVishal Kulkarni
42737e6ad469SVishal Kulkarni /* TP_DBG_SCHED_TX */
42747e6ad469SVishal Kulkarni reg_local_offset = t5_tp_pio_array[3][2] + 0xa;
42757e6ad469SVishal Kulkarni reg_offset_range = 1;
42767e6ad469SVishal Kulkarni
42777e6ad469SVishal Kulkarni t4_tp_pio_read(padap, sp, reg_offset_range, reg_local_offset, true);
42787e6ad469SVishal Kulkarni
42797e6ad469SVishal Kulkarni sp++;
42807e6ad469SVishal Kulkarni
42817e6ad469SVishal Kulkarni /* TP_DBG_SCHED_RX */
42827e6ad469SVishal Kulkarni reg_local_offset = t5_tp_pio_array[3][2] + 0xb;
42837e6ad469SVishal Kulkarni reg_offset_range = 1;
42847e6ad469SVishal Kulkarni
42857e6ad469SVishal Kulkarni t4_tp_pio_read(padap, sp, reg_offset_range, reg_local_offset, true);
42867e6ad469SVishal Kulkarni
42877e6ad469SVishal Kulkarni sp++;
42887e6ad469SVishal Kulkarni
42897e6ad469SVishal Kulkarni /* TP_DBG_CSIDE_INT */
42907e6ad469SVishal Kulkarni reg_local_offset = t5_tp_pio_array[9][2] + 0xf;
42917e6ad469SVishal Kulkarni reg_offset_range = 1;
42927e6ad469SVishal Kulkarni
42937e6ad469SVishal Kulkarni t4_tp_pio_read(padap, sp, reg_offset_range, reg_local_offset, true);
42947e6ad469SVishal Kulkarni
42957e6ad469SVishal Kulkarni sp++;
42967e6ad469SVishal Kulkarni
42977e6ad469SVishal Kulkarni /* TP_DBG_ESIDE_INT */
42987e6ad469SVishal Kulkarni reg_local_offset = t5_tp_pio_array[8][2] + 3;
42997e6ad469SVishal Kulkarni reg_offset_range = 1;
43007e6ad469SVishal Kulkarni
43017e6ad469SVishal Kulkarni t4_tp_pio_read(padap, sp, reg_offset_range, reg_local_offset, true);
43027e6ad469SVishal Kulkarni
43037e6ad469SVishal Kulkarni sp++;
43047e6ad469SVishal Kulkarni
43057e6ad469SVishal Kulkarni /* PCIE_CDEBUG_INDEX[AppData0] */
43067e6ad469SVishal Kulkarni reg_addr = t5_pcie_cdbg_array[0][0];
43077e6ad469SVishal Kulkarni reg_data = t5_pcie_cdbg_array[0][1];
43087e6ad469SVishal Kulkarni reg_local_offset = t5_pcie_cdbg_array[0][2] + 2;
43097e6ad469SVishal Kulkarni reg_offset_range = 1;
43107e6ad469SVishal Kulkarni
43117e6ad469SVishal Kulkarni t4_read_indirect(padap, reg_addr, reg_data, sp, reg_offset_range,
43127e6ad469SVishal Kulkarni reg_local_offset);
43137e6ad469SVishal Kulkarni
43147e6ad469SVishal Kulkarni sp++;
43157e6ad469SVishal Kulkarni
43167e6ad469SVishal Kulkarni if (is_t6(padap->params.chip)) {
43177e6ad469SVishal Kulkarni /* PCIE_CDEBUG_INDEX[AppData1] */
43187e6ad469SVishal Kulkarni reg_addr = t5_pcie_cdbg_array[0][0];
43197e6ad469SVishal Kulkarni reg_data = t5_pcie_cdbg_array[0][1];
43207e6ad469SVishal Kulkarni reg_local_offset = t5_pcie_cdbg_array[0][2] + 3;
43217e6ad469SVishal Kulkarni reg_offset_range = 1;
43227e6ad469SVishal Kulkarni
43237e6ad469SVishal Kulkarni t4_read_indirect(padap, reg_addr, reg_data, sp,
43247e6ad469SVishal Kulkarni reg_offset_range, reg_local_offset);
43257e6ad469SVishal Kulkarni
43267e6ad469SVishal Kulkarni sp++;
43277e6ad469SVishal Kulkarni }
43287e6ad469SVishal Kulkarni
43297e6ad469SVishal Kulkarni /* SGE_DEBUG_DATA_HIGH_INDEX_10 */
43307e6ad469SVishal Kulkarni *sp = t4_read_reg(padap, A_SGE_DEBUG_DATA_HIGH_INDEX_10);
43317e6ad469SVishal Kulkarni
43327e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
43337e6ad469SVishal Kulkarni if (rc)
43347e6ad469SVishal Kulkarni goto err1;
43357e6ad469SVishal Kulkarni
43367e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
43377e6ad469SVishal Kulkarni
43387e6ad469SVishal Kulkarni err1:
43397e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
43407e6ad469SVishal Kulkarni err:
43417e6ad469SVishal Kulkarni return rc;
43427e6ad469SVishal Kulkarni }
43437e6ad469SVishal Kulkarni
43447e6ad469SVishal Kulkarni static int
collect_vpd_data(struct cudbg_init * pdbg_init,struct cudbg_buffer * dbg_buff,struct cudbg_error * cudbg_err)43457e6ad469SVishal Kulkarni collect_vpd_data(struct cudbg_init *pdbg_init,
43467e6ad469SVishal Kulkarni struct cudbg_buffer *dbg_buff,
43477e6ad469SVishal Kulkarni struct cudbg_error *cudbg_err)
43487e6ad469SVishal Kulkarni {
43497e6ad469SVishal Kulkarni #ifdef notyet
43507e6ad469SVishal Kulkarni struct cudbg_buffer scratch_buff;
43517e6ad469SVishal Kulkarni struct adapter *padap = pdbg_init->adap;
43527e6ad469SVishal Kulkarni struct struct_vpd_data *vpd_data;
43537e6ad469SVishal Kulkarni char vpd_ver[4];
43547e6ad469SVishal Kulkarni u32 fw_vers;
43557e6ad469SVishal Kulkarni u32 size;
43567e6ad469SVishal Kulkarni int rc;
43577e6ad469SVishal Kulkarni
43587e6ad469SVishal Kulkarni size = sizeof(struct struct_vpd_data);
43597e6ad469SVishal Kulkarni scratch_buff.size = size;
43607e6ad469SVishal Kulkarni
43617e6ad469SVishal Kulkarni rc = get_scratch_buff(dbg_buff, scratch_buff.size, &scratch_buff);
43627e6ad469SVishal Kulkarni if (rc)
43637e6ad469SVishal Kulkarni goto err;
43647e6ad469SVishal Kulkarni
43657e6ad469SVishal Kulkarni vpd_data = (struct struct_vpd_data *)scratch_buff.data;
43667e6ad469SVishal Kulkarni
43677e6ad469SVishal Kulkarni if (is_t5(padap->params.chip)) {
43687e6ad469SVishal Kulkarni read_vpd_reg(padap, SN_REG_ADDR, SN_MAX_LEN, vpd_data->sn);
43697e6ad469SVishal Kulkarni read_vpd_reg(padap, BN_REG_ADDR, BN_MAX_LEN, vpd_data->bn);
43707e6ad469SVishal Kulkarni read_vpd_reg(padap, NA_REG_ADDR, NA_MAX_LEN, vpd_data->na);
43717e6ad469SVishal Kulkarni read_vpd_reg(padap, MN_REG_ADDR, MN_MAX_LEN, vpd_data->mn);
43727e6ad469SVishal Kulkarni } else if (is_t6(padap->params.chip)) {
43737e6ad469SVishal Kulkarni read_vpd_reg(padap, SN_T6_ADDR, SN_MAX_LEN, vpd_data->sn);
43747e6ad469SVishal Kulkarni read_vpd_reg(padap, BN_T6_ADDR, BN_MAX_LEN, vpd_data->bn);
43757e6ad469SVishal Kulkarni read_vpd_reg(padap, NA_T6_ADDR, NA_MAX_LEN, vpd_data->na);
43767e6ad469SVishal Kulkarni read_vpd_reg(padap, MN_T6_ADDR, MN_MAX_LEN, vpd_data->mn);
43777e6ad469SVishal Kulkarni }
43787e6ad469SVishal Kulkarni
43797e6ad469SVishal Kulkarni if (is_fw_attached(pdbg_init)) {
43807e6ad469SVishal Kulkarni rc = t4_get_scfg_version(padap, &vpd_data->scfg_vers);
43817e6ad469SVishal Kulkarni } else {
43827e6ad469SVishal Kulkarni rc = 1;
43837e6ad469SVishal Kulkarni }
43847e6ad469SVishal Kulkarni
43857e6ad469SVishal Kulkarni if (rc) {
43867e6ad469SVishal Kulkarni /* Now trying with backdoor mechanism */
43877e6ad469SVishal Kulkarni rc = read_vpd_reg(padap, SCFG_VER_ADDR, SCFG_VER_LEN,
43887e6ad469SVishal Kulkarni (u8 *)&vpd_data->scfg_vers);
43897e6ad469SVishal Kulkarni if (rc)
43907e6ad469SVishal Kulkarni goto err1;
43917e6ad469SVishal Kulkarni }
43927e6ad469SVishal Kulkarni
43937e6ad469SVishal Kulkarni if (is_fw_attached(pdbg_init)) {
43947e6ad469SVishal Kulkarni rc = t4_get_vpd_version(padap, &vpd_data->vpd_vers);
43957e6ad469SVishal Kulkarni } else {
43967e6ad469SVishal Kulkarni rc = 1;
43977e6ad469SVishal Kulkarni }
43987e6ad469SVishal Kulkarni
43997e6ad469SVishal Kulkarni if (rc) {
44007e6ad469SVishal Kulkarni /* Now trying with backdoor mechanism */
44017e6ad469SVishal Kulkarni rc = read_vpd_reg(padap, VPD_VER_ADDR, VPD_VER_LEN,
44027e6ad469SVishal Kulkarni (u8 *)vpd_ver);
44037e6ad469SVishal Kulkarni if (rc)
44047e6ad469SVishal Kulkarni goto err1;
44057e6ad469SVishal Kulkarni /* read_vpd_reg return string of stored hex
44067e6ad469SVishal Kulkarni * converting hex string to char string
44077e6ad469SVishal Kulkarni * vpd version is 2 bytes only */
44087e6ad469SVishal Kulkarni sprintf(vpd_ver, "%c%c\n", vpd_ver[0], vpd_ver[1]);
44097e6ad469SVishal Kulkarni vpd_data->vpd_vers = simple_strtoul(vpd_ver, NULL, 16);
44107e6ad469SVishal Kulkarni }
44117e6ad469SVishal Kulkarni
44127e6ad469SVishal Kulkarni /* Get FW version if it's not already filled in */
44137e6ad469SVishal Kulkarni fw_vers = padap->params.fw_vers;
44147e6ad469SVishal Kulkarni if (!fw_vers) {
44157e6ad469SVishal Kulkarni rc = t4_get_fw_version(padap, &fw_vers);
44167e6ad469SVishal Kulkarni if (rc)
44177e6ad469SVishal Kulkarni goto err1;
44187e6ad469SVishal Kulkarni }
44197e6ad469SVishal Kulkarni
44207e6ad469SVishal Kulkarni vpd_data->fw_major = G_FW_HDR_FW_VER_MAJOR(fw_vers);
44217e6ad469SVishal Kulkarni vpd_data->fw_minor = G_FW_HDR_FW_VER_MINOR(fw_vers);
44227e6ad469SVishal Kulkarni vpd_data->fw_micro = G_FW_HDR_FW_VER_MICRO(fw_vers);
44237e6ad469SVishal Kulkarni vpd_data->fw_build = G_FW_HDR_FW_VER_BUILD(fw_vers);
44247e6ad469SVishal Kulkarni
44257e6ad469SVishal Kulkarni rc = write_compression_hdr(&scratch_buff, dbg_buff);
44267e6ad469SVishal Kulkarni if (rc)
44277e6ad469SVishal Kulkarni goto err1;
44287e6ad469SVishal Kulkarni
44297e6ad469SVishal Kulkarni rc = compress_buff(&scratch_buff, dbg_buff);
44307e6ad469SVishal Kulkarni
44317e6ad469SVishal Kulkarni err1:
44327e6ad469SVishal Kulkarni release_scratch_buff(&scratch_buff, dbg_buff);
44337e6ad469SVishal Kulkarni err:
44347e6ad469SVishal Kulkarni return rc;
44357e6ad469SVishal Kulkarni #endif
44367e6ad469SVishal Kulkarni return (-1);
44377e6ad469SVishal Kulkarni }
4438