1fd88b31aSHariprasad Shenai /* 2fd88b31aSHariprasad Shenai * This file is part of the Chelsio T4 Ethernet driver for Linux. 3fd88b31aSHariprasad Shenai * 4fd88b31aSHariprasad Shenai * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved. 5fd88b31aSHariprasad Shenai * 6fd88b31aSHariprasad Shenai * This software is available to you under a choice of one of two 7fd88b31aSHariprasad Shenai * licenses. You may choose to be licensed under the terms of the GNU 8fd88b31aSHariprasad Shenai * General Public License (GPL) Version 2, available from the file 9fd88b31aSHariprasad Shenai * COPYING in the main directory of this source tree, or the 10fd88b31aSHariprasad Shenai * OpenIB.org BSD license below: 11fd88b31aSHariprasad Shenai * 12fd88b31aSHariprasad Shenai * Redistribution and use in source and binary forms, with or 13fd88b31aSHariprasad Shenai * without modification, are permitted provided that the following 14fd88b31aSHariprasad Shenai * conditions are met: 15fd88b31aSHariprasad Shenai * 16fd88b31aSHariprasad Shenai * - Redistributions of source code must retain the above 17fd88b31aSHariprasad Shenai * copyright notice, this list of conditions and the following 18fd88b31aSHariprasad Shenai * disclaimer. 19fd88b31aSHariprasad Shenai * 20fd88b31aSHariprasad Shenai * - Redistributions in binary form must reproduce the above 21fd88b31aSHariprasad Shenai * copyright notice, this list of conditions and the following 22fd88b31aSHariprasad Shenai * disclaimer in the documentation and/or other materials 23fd88b31aSHariprasad Shenai * provided with the distribution. 24fd88b31aSHariprasad Shenai * 25fd88b31aSHariprasad Shenai * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26fd88b31aSHariprasad Shenai * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27fd88b31aSHariprasad Shenai * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28fd88b31aSHariprasad Shenai * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29fd88b31aSHariprasad Shenai * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30fd88b31aSHariprasad Shenai * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31fd88b31aSHariprasad Shenai * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32fd88b31aSHariprasad Shenai * SOFTWARE. 33fd88b31aSHariprasad Shenai */ 34fd88b31aSHariprasad Shenai 35fd88b31aSHariprasad Shenai #include <linux/seq_file.h> 36fd88b31aSHariprasad Shenai #include <linux/debugfs.h> 37fd88b31aSHariprasad Shenai #include <linux/string_helpers.h> 38fd88b31aSHariprasad Shenai #include <linux/sort.h> 39fd88b31aSHariprasad Shenai 40fd88b31aSHariprasad Shenai #include "cxgb4.h" 41fd88b31aSHariprasad Shenai #include "t4_regs.h" 42fd88b31aSHariprasad Shenai #include "t4fw_api.h" 43fd88b31aSHariprasad Shenai #include "cxgb4_debugfs.h" 44fd88b31aSHariprasad Shenai #include "l2t.h" 45fd88b31aSHariprasad Shenai 46f1ff24aaSHariprasad Shenai /* generic seq_file support for showing a table of size rows x width. */ 47f1ff24aaSHariprasad Shenai static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos) 48f1ff24aaSHariprasad Shenai { 49f1ff24aaSHariprasad Shenai pos -= tb->skip_first; 50f1ff24aaSHariprasad Shenai return pos >= tb->rows ? NULL : &tb->data[pos * tb->width]; 51f1ff24aaSHariprasad Shenai } 52f1ff24aaSHariprasad Shenai 53f1ff24aaSHariprasad Shenai static void *seq_tab_start(struct seq_file *seq, loff_t *pos) 54f1ff24aaSHariprasad Shenai { 55f1ff24aaSHariprasad Shenai struct seq_tab *tb = seq->private; 56f1ff24aaSHariprasad Shenai 57f1ff24aaSHariprasad Shenai if (tb->skip_first && *pos == 0) 58f1ff24aaSHariprasad Shenai return SEQ_START_TOKEN; 59f1ff24aaSHariprasad Shenai 60f1ff24aaSHariprasad Shenai return seq_tab_get_idx(tb, *pos); 61f1ff24aaSHariprasad Shenai } 62f1ff24aaSHariprasad Shenai 63f1ff24aaSHariprasad Shenai static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos) 64f1ff24aaSHariprasad Shenai { 65f1ff24aaSHariprasad Shenai v = seq_tab_get_idx(seq->private, *pos + 1); 66f1ff24aaSHariprasad Shenai if (v) 67f1ff24aaSHariprasad Shenai ++*pos; 68f1ff24aaSHariprasad Shenai return v; 69f1ff24aaSHariprasad Shenai } 70f1ff24aaSHariprasad Shenai 71f1ff24aaSHariprasad Shenai static void seq_tab_stop(struct seq_file *seq, void *v) 72f1ff24aaSHariprasad Shenai { 73f1ff24aaSHariprasad Shenai } 74f1ff24aaSHariprasad Shenai 75f1ff24aaSHariprasad Shenai static int seq_tab_show(struct seq_file *seq, void *v) 76f1ff24aaSHariprasad Shenai { 77f1ff24aaSHariprasad Shenai const struct seq_tab *tb = seq->private; 78f1ff24aaSHariprasad Shenai 79f1ff24aaSHariprasad Shenai return tb->show(seq, v, ((char *)v - tb->data) / tb->width); 80f1ff24aaSHariprasad Shenai } 81f1ff24aaSHariprasad Shenai 82f1ff24aaSHariprasad Shenai static const struct seq_operations seq_tab_ops = { 83f1ff24aaSHariprasad Shenai .start = seq_tab_start, 84f1ff24aaSHariprasad Shenai .next = seq_tab_next, 85f1ff24aaSHariprasad Shenai .stop = seq_tab_stop, 86f1ff24aaSHariprasad Shenai .show = seq_tab_show 87f1ff24aaSHariprasad Shenai }; 88f1ff24aaSHariprasad Shenai 89f1ff24aaSHariprasad Shenai struct seq_tab *seq_open_tab(struct file *f, unsigned int rows, 90f1ff24aaSHariprasad Shenai unsigned int width, unsigned int have_header, 91f1ff24aaSHariprasad Shenai int (*show)(struct seq_file *seq, void *v, int i)) 92f1ff24aaSHariprasad Shenai { 93f1ff24aaSHariprasad Shenai struct seq_tab *p; 94f1ff24aaSHariprasad Shenai 95f1ff24aaSHariprasad Shenai p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width); 96f1ff24aaSHariprasad Shenai if (p) { 97f1ff24aaSHariprasad Shenai p->show = show; 98f1ff24aaSHariprasad Shenai p->rows = rows; 99f1ff24aaSHariprasad Shenai p->width = width; 100f1ff24aaSHariprasad Shenai p->skip_first = have_header != 0; 101f1ff24aaSHariprasad Shenai } 102f1ff24aaSHariprasad Shenai return p; 103f1ff24aaSHariprasad Shenai } 104f1ff24aaSHariprasad Shenai 105f1ff24aaSHariprasad Shenai static int cim_la_show(struct seq_file *seq, void *v, int idx) 106f1ff24aaSHariprasad Shenai { 107f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) 108f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC LS0Stat LS0Addr " 109f1ff24aaSHariprasad Shenai " LS0Data\n"); 110f1ff24aaSHariprasad Shenai else { 111f1ff24aaSHariprasad Shenai const u32 *p = v; 112f1ff24aaSHariprasad Shenai 113f1ff24aaSHariprasad Shenai seq_printf(seq, 114f1ff24aaSHariprasad Shenai " %02x %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n", 115f1ff24aaSHariprasad Shenai (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4, 116f1ff24aaSHariprasad Shenai p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5], 117f1ff24aaSHariprasad Shenai p[6], p[7]); 118f1ff24aaSHariprasad Shenai } 119f1ff24aaSHariprasad Shenai return 0; 120f1ff24aaSHariprasad Shenai } 121f1ff24aaSHariprasad Shenai 122f1ff24aaSHariprasad Shenai static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx) 123f1ff24aaSHariprasad Shenai { 124f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) { 125f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC\n"); 126f1ff24aaSHariprasad Shenai } else { 127f1ff24aaSHariprasad Shenai const u32 *p = v; 128f1ff24aaSHariprasad Shenai 129f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %08x %08x\n", p[5] & 0xff, p[6], 130f1ff24aaSHariprasad Shenai p[7]); 131f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x\n", 132f1ff24aaSHariprasad Shenai (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8, 133f1ff24aaSHariprasad Shenai p[4] & 0xff, p[5] >> 8); 134f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %x%07x %x%07x\n", (p[0] >> 4) & 0xff, 135f1ff24aaSHariprasad Shenai p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4); 136f1ff24aaSHariprasad Shenai } 137f1ff24aaSHariprasad Shenai return 0; 138f1ff24aaSHariprasad Shenai } 139f1ff24aaSHariprasad Shenai 140f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 141f1ff24aaSHariprasad Shenai { 142f1ff24aaSHariprasad Shenai int ret; 143f1ff24aaSHariprasad Shenai unsigned int cfg; 144f1ff24aaSHariprasad Shenai struct seq_tab *p; 145f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 146f1ff24aaSHariprasad Shenai 147f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 148f1ff24aaSHariprasad Shenai if (ret) 149f1ff24aaSHariprasad Shenai return ret; 150f1ff24aaSHariprasad Shenai 151f1ff24aaSHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 8 * sizeof(u32), 1, 152f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 153f1ff24aaSHariprasad Shenai cim_la_show_3in1 : cim_la_show); 154f1ff24aaSHariprasad Shenai if (!p) 155f1ff24aaSHariprasad Shenai return -ENOMEM; 156f1ff24aaSHariprasad Shenai 157f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 158f1ff24aaSHariprasad Shenai if (ret) 159f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 160f1ff24aaSHariprasad Shenai return ret; 161f1ff24aaSHariprasad Shenai } 162f1ff24aaSHariprasad Shenai 163f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 164f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 165f1ff24aaSHariprasad Shenai .open = cim_la_open, 166f1ff24aaSHariprasad Shenai .read = seq_read, 167f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 168f1ff24aaSHariprasad Shenai .release = seq_release_private 169f1ff24aaSHariprasad Shenai }; 170f1ff24aaSHariprasad Shenai 17174b3092cSHariprasad Shenai static int cim_qcfg_show(struct seq_file *seq, void *v) 17274b3092cSHariprasad Shenai { 17374b3092cSHariprasad Shenai static const char * const qname[] = { 17474b3092cSHariprasad Shenai "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI", 17574b3092cSHariprasad Shenai "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI", 17674b3092cSHariprasad Shenai "SGE0-RX", "SGE1-RX" 17774b3092cSHariprasad Shenai }; 17874b3092cSHariprasad Shenai 17974b3092cSHariprasad Shenai int i; 18074b3092cSHariprasad Shenai struct adapter *adap = seq->private; 18174b3092cSHariprasad Shenai u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 18274b3092cSHariprasad Shenai u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 18374b3092cSHariprasad Shenai u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))]; 18474b3092cSHariprasad Shenai u16 thres[CIM_NUM_IBQ]; 18574b3092cSHariprasad Shenai u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr; 18674b3092cSHariprasad Shenai u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5]; 18774b3092cSHariprasad Shenai u32 *p = stat; 18874b3092cSHariprasad Shenai int cim_num_obq = is_t4(adap->params.chip) ? 18974b3092cSHariprasad Shenai CIM_NUM_OBQ : CIM_NUM_OBQ_T5; 19074b3092cSHariprasad Shenai 19174b3092cSHariprasad Shenai i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A : 19274b3092cSHariprasad Shenai UP_IBQ_0_SHADOW_RDADDR_A, 19374b3092cSHariprasad Shenai ARRAY_SIZE(stat), stat); 19474b3092cSHariprasad Shenai if (!i) { 19574b3092cSHariprasad Shenai if (is_t4(adap->params.chip)) { 19674b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A, 19774b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t4), obq_wr_t4); 19874b3092cSHariprasad Shenai wr = obq_wr_t4; 19974b3092cSHariprasad Shenai } else { 20074b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A, 20174b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t5), obq_wr_t5); 20274b3092cSHariprasad Shenai wr = obq_wr_t5; 20374b3092cSHariprasad Shenai } 20474b3092cSHariprasad Shenai } 20574b3092cSHariprasad Shenai if (i) 20674b3092cSHariprasad Shenai return i; 20774b3092cSHariprasad Shenai 20874b3092cSHariprasad Shenai t4_read_cimq_cfg(adap, base, size, thres); 20974b3092cSHariprasad Shenai 21074b3092cSHariprasad Shenai seq_printf(seq, 21174b3092cSHariprasad Shenai " Queue Base Size Thres RdPtr WrPtr SOP EOP Avail\n"); 21274b3092cSHariprasad Shenai for (i = 0; i < CIM_NUM_IBQ; i++, p += 4) 21374b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %5u %6x %4x %4u %4u %5u\n", 21474b3092cSHariprasad Shenai qname[i], base[i], size[i], thres[i], 21574b3092cSHariprasad Shenai IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]), 21674b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 21774b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 21874b3092cSHariprasad Shenai for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2) 21974b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %12x %4x %4u %4u %5u\n", 22074b3092cSHariprasad Shenai qname[i], base[i], size[i], 22174b3092cSHariprasad Shenai QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i], 22274b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 22374b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 22474b3092cSHariprasad Shenai return 0; 22574b3092cSHariprasad Shenai } 22674b3092cSHariprasad Shenai 22774b3092cSHariprasad Shenai static int cim_qcfg_open(struct inode *inode, struct file *file) 22874b3092cSHariprasad Shenai { 22974b3092cSHariprasad Shenai return single_open(file, cim_qcfg_show, inode->i_private); 23074b3092cSHariprasad Shenai } 23174b3092cSHariprasad Shenai 23274b3092cSHariprasad Shenai static const struct file_operations cim_qcfg_fops = { 23374b3092cSHariprasad Shenai .owner = THIS_MODULE, 23474b3092cSHariprasad Shenai .open = cim_qcfg_open, 23574b3092cSHariprasad Shenai .read = seq_read, 23674b3092cSHariprasad Shenai .llseek = seq_lseek, 23774b3092cSHariprasad Shenai .release = single_release, 23874b3092cSHariprasad Shenai }; 23974b3092cSHariprasad Shenai 240f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 24149aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 24249aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 24349aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 24449aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 24549aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 24649aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 24749aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 24849aa284fSHariprasad Shenai }; 24949aa284fSHariprasad Shenai 25049aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 25149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 25249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 25349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 25449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 25549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 25649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 25749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 25849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 25949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 26049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 26149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 26249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 26349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 26449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 26549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 26649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 26749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 26849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 26949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 27049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 27149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 27249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 27349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 27449aa284fSHariprasad Shenai }; 27549aa284fSHariprasad Shenai 27649aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 27749aa284fSHariprasad Shenai */ 27849aa284fSHariprasad Shenai struct devlog_info { 27949aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 28049aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 28149aa284fSHariprasad Shenai struct fw_devlog_e log[0]; /* Firmware Device Log */ 28249aa284fSHariprasad Shenai }; 28349aa284fSHariprasad Shenai 28449aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 28549aa284fSHariprasad Shenai */ 28649aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 28749aa284fSHariprasad Shenai { 28849aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 28949aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 29049aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 29149aa284fSHariprasad Shenai else { 29249aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 29349aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 29449aa284fSHariprasad Shenai unsigned long index; 29549aa284fSHariprasad Shenai struct fw_devlog_e *e; 29649aa284fSHariprasad Shenai 29749aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 29849aa284fSHariprasad Shenai * entries. 29949aa284fSHariprasad Shenai */ 30049aa284fSHariprasad Shenai index = dinfo->first + fidx; 30149aa284fSHariprasad Shenai if (index >= dinfo->nentries) 30249aa284fSHariprasad Shenai index -= dinfo->nentries; 30349aa284fSHariprasad Shenai e = &dinfo->log[index]; 30449aa284fSHariprasad Shenai if (e->timestamp == 0) 30549aa284fSHariprasad Shenai return 0; 30649aa284fSHariprasad Shenai 30749aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 30849aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 30949aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 31049aa284fSHariprasad Shenai */ 31149aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 31249aa284fSHariprasad Shenai e->seqno, e->timestamp, 31349aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 31449aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 31549aa284fSHariprasad Shenai : "UNKNOWN"), 31649aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 31749aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 31849aa284fSHariprasad Shenai : "UNKNOWN")); 31949aa284fSHariprasad Shenai seq_printf(seq, e->fmt, e->params[0], e->params[1], 32049aa284fSHariprasad Shenai e->params[2], e->params[3], e->params[4], 32149aa284fSHariprasad Shenai e->params[5], e->params[6], e->params[7]); 32249aa284fSHariprasad Shenai } 32349aa284fSHariprasad Shenai return 0; 32449aa284fSHariprasad Shenai } 32549aa284fSHariprasad Shenai 32649aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 32749aa284fSHariprasad Shenai */ 32849aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 32949aa284fSHariprasad Shenai { 33049aa284fSHariprasad Shenai if (pos > dinfo->nentries) 33149aa284fSHariprasad Shenai return NULL; 33249aa284fSHariprasad Shenai 33349aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 33449aa284fSHariprasad Shenai } 33549aa284fSHariprasad Shenai 33649aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 33749aa284fSHariprasad Shenai { 33849aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 33949aa284fSHariprasad Shenai 34049aa284fSHariprasad Shenai return (*pos 34149aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 34249aa284fSHariprasad Shenai : SEQ_START_TOKEN); 34349aa284fSHariprasad Shenai } 34449aa284fSHariprasad Shenai 34549aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 34649aa284fSHariprasad Shenai { 34749aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 34849aa284fSHariprasad Shenai 34949aa284fSHariprasad Shenai (*pos)++; 35049aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 35149aa284fSHariprasad Shenai } 35249aa284fSHariprasad Shenai 35349aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 35449aa284fSHariprasad Shenai { 35549aa284fSHariprasad Shenai } 35649aa284fSHariprasad Shenai 35749aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 35849aa284fSHariprasad Shenai .start = devlog_start, 35949aa284fSHariprasad Shenai .next = devlog_next, 36049aa284fSHariprasad Shenai .stop = devlog_stop, 36149aa284fSHariprasad Shenai .show = devlog_show 36249aa284fSHariprasad Shenai }; 36349aa284fSHariprasad Shenai 36449aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 36549aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 36649aa284fSHariprasad Shenai */ 36749aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 36849aa284fSHariprasad Shenai { 36949aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 37049aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 37149aa284fSHariprasad Shenai struct devlog_info *dinfo; 37249aa284fSHariprasad Shenai unsigned int index; 37349aa284fSHariprasad Shenai u32 fseqno; 37449aa284fSHariprasad Shenai int ret; 37549aa284fSHariprasad Shenai 37649aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 37749aa284fSHariprasad Shenai */ 37849aa284fSHariprasad Shenai if (dparams->start == 0) 37949aa284fSHariprasad Shenai return -ENXIO; 38049aa284fSHariprasad Shenai 38149aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 38249aa284fSHariprasad Shenai * for the iterated call to our display function. 38349aa284fSHariprasad Shenai */ 38449aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 38549aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 38649aa284fSHariprasad Shenai if (!dinfo) 38749aa284fSHariprasad Shenai return -ENOMEM; 38849aa284fSHariprasad Shenai 38949aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 39049aa284fSHariprasad Shenai */ 39149aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 39249aa284fSHariprasad Shenai dinfo->first = 0; 39349aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 39449aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 39549aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 39649aa284fSHariprasad Shenai T4_MEMORY_READ); 39749aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 39849aa284fSHariprasad Shenai if (ret) { 39949aa284fSHariprasad Shenai seq_release_private(inode, file); 40049aa284fSHariprasad Shenai return ret; 40149aa284fSHariprasad Shenai } 40249aa284fSHariprasad Shenai 40349aa284fSHariprasad Shenai /* Translate log multi-byte integral elements into host native format 40449aa284fSHariprasad Shenai * and determine where the first entry in the log is. 40549aa284fSHariprasad Shenai */ 40649aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 40749aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 40849aa284fSHariprasad Shenai int i; 40949aa284fSHariprasad Shenai __u32 seqno; 41049aa284fSHariprasad Shenai 41149aa284fSHariprasad Shenai if (e->timestamp == 0) 41249aa284fSHariprasad Shenai continue; 41349aa284fSHariprasad Shenai 41449aa284fSHariprasad Shenai e->timestamp = (__force __be64)be64_to_cpu(e->timestamp); 41549aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 41649aa284fSHariprasad Shenai for (i = 0; i < 8; i++) 41749aa284fSHariprasad Shenai e->params[i] = 41849aa284fSHariprasad Shenai (__force __be32)be32_to_cpu(e->params[i]); 41949aa284fSHariprasad Shenai 42049aa284fSHariprasad Shenai if (seqno < fseqno) { 42149aa284fSHariprasad Shenai fseqno = seqno; 42249aa284fSHariprasad Shenai dinfo->first = index; 42349aa284fSHariprasad Shenai } 42449aa284fSHariprasad Shenai } 42549aa284fSHariprasad Shenai return 0; 42649aa284fSHariprasad Shenai } 42749aa284fSHariprasad Shenai 42849aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 42949aa284fSHariprasad Shenai .owner = THIS_MODULE, 43049aa284fSHariprasad Shenai .open = devlog_open, 43149aa284fSHariprasad Shenai .read = seq_read, 43249aa284fSHariprasad Shenai .llseek = seq_lseek, 43349aa284fSHariprasad Shenai .release = seq_release_private 43449aa284fSHariprasad Shenai }; 43549aa284fSHariprasad Shenai 436ef82f662SHariprasad Shenai static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask) 437ef82f662SHariprasad Shenai { 438ef82f662SHariprasad Shenai *mask = x | y; 439ef82f662SHariprasad Shenai y = (__force u64)cpu_to_be64(y); 440ef82f662SHariprasad Shenai memcpy(addr, (char *)&y + 2, ETH_ALEN); 441ef82f662SHariprasad Shenai } 442ef82f662SHariprasad Shenai 443ef82f662SHariprasad Shenai static int mps_tcam_show(struct seq_file *seq, void *v) 444ef82f662SHariprasad Shenai { 445ef82f662SHariprasad Shenai if (v == SEQ_START_TOKEN) 446ef82f662SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask Vld Ports PF" 447ef82f662SHariprasad Shenai " VF Replication " 448ef82f662SHariprasad Shenai "P0 P1 P2 P3 ML\n"); 449ef82f662SHariprasad Shenai else { 450ef82f662SHariprasad Shenai u64 mask; 451ef82f662SHariprasad Shenai u8 addr[ETH_ALEN]; 452ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 453ef82f662SHariprasad Shenai unsigned int idx = (uintptr_t)v - 2; 454ef82f662SHariprasad Shenai u64 tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx)); 455ef82f662SHariprasad Shenai u64 tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx)); 456ef82f662SHariprasad Shenai u32 cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx)); 457ef82f662SHariprasad Shenai u32 cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx)); 458ef82f662SHariprasad Shenai u32 rplc[4] = {0, 0, 0, 0}; 459ef82f662SHariprasad Shenai 460ef82f662SHariprasad Shenai if (tcamx & tcamy) { 461ef82f662SHariprasad Shenai seq_printf(seq, "%3u -\n", idx); 462ef82f662SHariprasad Shenai goto out; 463ef82f662SHariprasad Shenai } 464ef82f662SHariprasad Shenai 465ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) { 466ef82f662SHariprasad Shenai struct fw_ldst_cmd ldst_cmd; 467ef82f662SHariprasad Shenai int ret; 468ef82f662SHariprasad Shenai 469ef82f662SHariprasad Shenai memset(&ldst_cmd, 0, sizeof(ldst_cmd)); 470ef82f662SHariprasad Shenai ldst_cmd.op_to_addrspace = 471ef82f662SHariprasad Shenai htonl(FW_CMD_OP_V(FW_LDST_CMD) | 472ef82f662SHariprasad Shenai FW_CMD_REQUEST_F | 473ef82f662SHariprasad Shenai FW_CMD_READ_F | 474ef82f662SHariprasad Shenai FW_LDST_CMD_ADDRSPACE_V( 475ef82f662SHariprasad Shenai FW_LDST_ADDRSPC_MPS)); 476ef82f662SHariprasad Shenai ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd)); 477ef82f662SHariprasad Shenai ldst_cmd.u.mps.fid_ctl = 478ef82f662SHariprasad Shenai htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) | 479ef82f662SHariprasad Shenai FW_LDST_CMD_CTL_V(idx)); 480ef82f662SHariprasad Shenai ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, 481ef82f662SHariprasad Shenai sizeof(ldst_cmd), &ldst_cmd); 482ef82f662SHariprasad Shenai if (ret) 483ef82f662SHariprasad Shenai dev_warn(adap->pdev_dev, "Can't read MPS " 484ef82f662SHariprasad Shenai "replication map for idx %d: %d\n", 485ef82f662SHariprasad Shenai idx, -ret); 486ef82f662SHariprasad Shenai else { 487ef82f662SHariprasad Shenai rplc[0] = ntohl(ldst_cmd.u.mps.rplc31_0); 488ef82f662SHariprasad Shenai rplc[1] = ntohl(ldst_cmd.u.mps.rplc63_32); 489ef82f662SHariprasad Shenai rplc[2] = ntohl(ldst_cmd.u.mps.rplc95_64); 490ef82f662SHariprasad Shenai rplc[3] = ntohl(ldst_cmd.u.mps.rplc127_96); 491ef82f662SHariprasad Shenai } 492ef82f662SHariprasad Shenai } 493ef82f662SHariprasad Shenai 494ef82f662SHariprasad Shenai tcamxy2valmask(tcamx, tcamy, addr, &mask); 495ef82f662SHariprasad Shenai seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x %012llx" 496ef82f662SHariprasad Shenai "%3c %#x%4u%4d", 497ef82f662SHariprasad Shenai idx, addr[0], addr[1], addr[2], addr[3], addr[4], 498ef82f662SHariprasad Shenai addr[5], (unsigned long long)mask, 499ef82f662SHariprasad Shenai (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', PORTMAP_G(cls_hi), 500ef82f662SHariprasad Shenai PF_G(cls_lo), 501ef82f662SHariprasad Shenai (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1); 502ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) 503ef82f662SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x", 504ef82f662SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 505ef82f662SHariprasad Shenai else 506ef82f662SHariprasad Shenai seq_printf(seq, "%36c", ' '); 507ef82f662SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 508ef82f662SHariprasad Shenai SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo), 509ef82f662SHariprasad Shenai SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo), 510ef82f662SHariprasad Shenai (cls_lo >> MULTILISTEN0_S) & 0xf); 511ef82f662SHariprasad Shenai } 512ef82f662SHariprasad Shenai out: return 0; 513ef82f662SHariprasad Shenai } 514ef82f662SHariprasad Shenai 515ef82f662SHariprasad Shenai static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos) 516ef82f662SHariprasad Shenai { 517ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 518ef82f662SHariprasad Shenai int max_mac_addr = is_t4(adap->params.chip) ? 519ef82f662SHariprasad Shenai NUM_MPS_CLS_SRAM_L_INSTANCES : 520ef82f662SHariprasad Shenai NUM_MPS_T5_CLS_SRAM_L_INSTANCES; 521ef82f662SHariprasad Shenai return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL); 522ef82f662SHariprasad Shenai } 523ef82f662SHariprasad Shenai 524ef82f662SHariprasad Shenai static void *mps_tcam_start(struct seq_file *seq, loff_t *pos) 525ef82f662SHariprasad Shenai { 526ef82f662SHariprasad Shenai return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN; 527ef82f662SHariprasad Shenai } 528ef82f662SHariprasad Shenai 529ef82f662SHariprasad Shenai static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos) 530ef82f662SHariprasad Shenai { 531ef82f662SHariprasad Shenai ++*pos; 532ef82f662SHariprasad Shenai return mps_tcam_get_idx(seq, *pos); 533ef82f662SHariprasad Shenai } 534ef82f662SHariprasad Shenai 535ef82f662SHariprasad Shenai static void mps_tcam_stop(struct seq_file *seq, void *v) 536ef82f662SHariprasad Shenai { 537ef82f662SHariprasad Shenai } 538ef82f662SHariprasad Shenai 539ef82f662SHariprasad Shenai static const struct seq_operations mps_tcam_seq_ops = { 540ef82f662SHariprasad Shenai .start = mps_tcam_start, 541ef82f662SHariprasad Shenai .next = mps_tcam_next, 542ef82f662SHariprasad Shenai .stop = mps_tcam_stop, 543ef82f662SHariprasad Shenai .show = mps_tcam_show 544ef82f662SHariprasad Shenai }; 545ef82f662SHariprasad Shenai 546ef82f662SHariprasad Shenai static int mps_tcam_open(struct inode *inode, struct file *file) 547ef82f662SHariprasad Shenai { 548ef82f662SHariprasad Shenai int res = seq_open(file, &mps_tcam_seq_ops); 549ef82f662SHariprasad Shenai 550ef82f662SHariprasad Shenai if (!res) { 551ef82f662SHariprasad Shenai struct seq_file *seq = file->private_data; 552ef82f662SHariprasad Shenai 553ef82f662SHariprasad Shenai seq->private = inode->i_private; 554ef82f662SHariprasad Shenai } 555ef82f662SHariprasad Shenai return res; 556ef82f662SHariprasad Shenai } 557ef82f662SHariprasad Shenai 558ef82f662SHariprasad Shenai static const struct file_operations mps_tcam_debugfs_fops = { 559ef82f662SHariprasad Shenai .owner = THIS_MODULE, 560ef82f662SHariprasad Shenai .open = mps_tcam_open, 561ef82f662SHariprasad Shenai .read = seq_read, 562ef82f662SHariprasad Shenai .llseek = seq_lseek, 563ef82f662SHariprasad Shenai .release = seq_release, 564ef82f662SHariprasad Shenai }; 565ef82f662SHariprasad Shenai 566fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 567fd88b31aSHariprasad Shenai loff_t *ppos) 568fd88b31aSHariprasad Shenai { 569fd88b31aSHariprasad Shenai loff_t pos = *ppos; 570fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 571fd88b31aSHariprasad Shenai unsigned int mem = (uintptr_t)file->private_data & 3; 572fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 573fd88b31aSHariprasad Shenai __be32 *data; 574fd88b31aSHariprasad Shenai int ret; 575fd88b31aSHariprasad Shenai 576fd88b31aSHariprasad Shenai if (pos < 0) 577fd88b31aSHariprasad Shenai return -EINVAL; 578fd88b31aSHariprasad Shenai if (pos >= avail) 579fd88b31aSHariprasad Shenai return 0; 580fd88b31aSHariprasad Shenai if (count > avail - pos) 581fd88b31aSHariprasad Shenai count = avail - pos; 582fd88b31aSHariprasad Shenai 583fd88b31aSHariprasad Shenai data = t4_alloc_mem(count); 584fd88b31aSHariprasad Shenai if (!data) 585fd88b31aSHariprasad Shenai return -ENOMEM; 586fd88b31aSHariprasad Shenai 587fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 588fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 589fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 590fd88b31aSHariprasad Shenai if (ret) { 591fd88b31aSHariprasad Shenai t4_free_mem(data); 592fd88b31aSHariprasad Shenai return ret; 593fd88b31aSHariprasad Shenai } 594fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 595fd88b31aSHariprasad Shenai 596fd88b31aSHariprasad Shenai t4_free_mem(data); 597fd88b31aSHariprasad Shenai if (ret) 598fd88b31aSHariprasad Shenai return -EFAULT; 599fd88b31aSHariprasad Shenai 600fd88b31aSHariprasad Shenai *ppos = pos + count; 601fd88b31aSHariprasad Shenai return count; 602fd88b31aSHariprasad Shenai } 603fd88b31aSHariprasad Shenai 604fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 605fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 606fd88b31aSHariprasad Shenai .open = simple_open, 607fd88b31aSHariprasad Shenai .read = mem_read, 608fd88b31aSHariprasad Shenai .llseek = default_llseek, 609fd88b31aSHariprasad Shenai }; 610fd88b31aSHariprasad Shenai 611fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 612fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 613fd88b31aSHariprasad Shenai { 614fd88b31aSHariprasad Shenai struct dentry *de; 615fd88b31aSHariprasad Shenai 616fd88b31aSHariprasad Shenai de = debugfs_create_file(name, S_IRUSR, adap->debugfs_root, 617fd88b31aSHariprasad Shenai (void *)adap + idx, &mem_debugfs_fops); 618fd88b31aSHariprasad Shenai if (de && de->d_inode) 619fd88b31aSHariprasad Shenai de->d_inode->i_size = size_mb << 20; 620fd88b31aSHariprasad Shenai } 621fd88b31aSHariprasad Shenai 622fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 623fd88b31aSHariprasad Shenai */ 624fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 625fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 626fd88b31aSHariprasad Shenai unsigned int nfiles) 627fd88b31aSHariprasad Shenai { 628fd88b31aSHariprasad Shenai int i; 629fd88b31aSHariprasad Shenai 630fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 631fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 632fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 633fd88b31aSHariprasad Shenai adap->debugfs_root, 634fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 635fd88b31aSHariprasad Shenai files[i].ops); 636fd88b31aSHariprasad Shenai } 637fd88b31aSHariprasad Shenai 638fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 639fd88b31aSHariprasad Shenai { 640fd88b31aSHariprasad Shenai int i; 641fd88b31aSHariprasad Shenai u32 size; 642fd88b31aSHariprasad Shenai 643fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 644f1ff24aaSHariprasad Shenai { "cim_la", &cim_la_fops, S_IRUSR, 0 }, 64574b3092cSHariprasad Shenai { "cim_qcfg", &cim_qcfg_fops, S_IRUSR, 0 }, 64649aa284fSHariprasad Shenai { "devlog", &devlog_fops, S_IRUSR, 0 }, 647fd88b31aSHariprasad Shenai { "l2t", &t4_l2t_fops, S_IRUSR, 0}, 648ef82f662SHariprasad Shenai { "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 }, 649fd88b31aSHariprasad Shenai }; 650fd88b31aSHariprasad Shenai 651fd88b31aSHariprasad Shenai add_debugfs_files(adap, 652fd88b31aSHariprasad Shenai t4_debugfs_files, 653fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 654fd88b31aSHariprasad Shenai 6556559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 6566559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 6576559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 6586559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 659fd88b31aSHariprasad Shenai } 6606559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 6616559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 6626559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 663fd88b31aSHariprasad Shenai } 664fd88b31aSHariprasad Shenai if (is_t4(adap->params.chip)) { 6656559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 6666559a7e8SHariprasad Shenai if (i & EXT_MEM_ENABLE_F) 667fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 6686559a7e8SHariprasad Shenai EXT_MEM_SIZE_G(size)); 669fd88b31aSHariprasad Shenai } else { 6706559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 6716559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 672fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 6736559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 674fd88b31aSHariprasad Shenai } 6756559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 6766559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 677fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 6786559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 679fd88b31aSHariprasad Shenai } 680fd88b31aSHariprasad Shenai } 681fd88b31aSHariprasad Shenai return 0; 682fd88b31aSHariprasad Shenai } 683