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> 39688ea5feSHariprasad Shenai #include <linux/ctype.h> 40fd88b31aSHariprasad Shenai 41fd88b31aSHariprasad Shenai #include "cxgb4.h" 42fd88b31aSHariprasad Shenai #include "t4_regs.h" 43bf7c781dSHariprasad Shenai #include "t4_values.h" 44fd88b31aSHariprasad Shenai #include "t4fw_api.h" 45fd88b31aSHariprasad Shenai #include "cxgb4_debugfs.h" 46b5a02f50SAnish Bhatt #include "clip_tbl.h" 47fd88b31aSHariprasad Shenai #include "l2t.h" 48123e25c4SRahul Lakkireddy #include "cudbg_if.h" 49123e25c4SRahul Lakkireddy #include "cudbg_lib_common.h" 50123e25c4SRahul Lakkireddy #include "cudbg_entity.h" 51123e25c4SRahul Lakkireddy #include "cudbg_lib.h" 525148e595SRahul Lakkireddy #include "cxgb4_tc_mqprio.h" 53fd88b31aSHariprasad Shenai 54f1ff24aaSHariprasad Shenai /* generic seq_file support for showing a table of size rows x width. */ 55f1ff24aaSHariprasad Shenai static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos) 56f1ff24aaSHariprasad Shenai { 57f1ff24aaSHariprasad Shenai pos -= tb->skip_first; 58f1ff24aaSHariprasad Shenai return pos >= tb->rows ? NULL : &tb->data[pos * tb->width]; 59f1ff24aaSHariprasad Shenai } 60f1ff24aaSHariprasad Shenai 61f1ff24aaSHariprasad Shenai static void *seq_tab_start(struct seq_file *seq, loff_t *pos) 62f1ff24aaSHariprasad Shenai { 63f1ff24aaSHariprasad Shenai struct seq_tab *tb = seq->private; 64f1ff24aaSHariprasad Shenai 65f1ff24aaSHariprasad Shenai if (tb->skip_first && *pos == 0) 66f1ff24aaSHariprasad Shenai return SEQ_START_TOKEN; 67f1ff24aaSHariprasad Shenai 68f1ff24aaSHariprasad Shenai return seq_tab_get_idx(tb, *pos); 69f1ff24aaSHariprasad Shenai } 70f1ff24aaSHariprasad Shenai 71f1ff24aaSHariprasad Shenai static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos) 72f1ff24aaSHariprasad Shenai { 73f1ff24aaSHariprasad Shenai v = seq_tab_get_idx(seq->private, *pos + 1); 7470a87287SVasily Averin ++(*pos); 75f1ff24aaSHariprasad Shenai return v; 76f1ff24aaSHariprasad Shenai } 77f1ff24aaSHariprasad Shenai 78f1ff24aaSHariprasad Shenai static void seq_tab_stop(struct seq_file *seq, void *v) 79f1ff24aaSHariprasad Shenai { 80f1ff24aaSHariprasad Shenai } 81f1ff24aaSHariprasad Shenai 82f1ff24aaSHariprasad Shenai static int seq_tab_show(struct seq_file *seq, void *v) 83f1ff24aaSHariprasad Shenai { 84f1ff24aaSHariprasad Shenai const struct seq_tab *tb = seq->private; 85f1ff24aaSHariprasad Shenai 86f1ff24aaSHariprasad Shenai return tb->show(seq, v, ((char *)v - tb->data) / tb->width); 87f1ff24aaSHariprasad Shenai } 88f1ff24aaSHariprasad Shenai 89f1ff24aaSHariprasad Shenai static const struct seq_operations seq_tab_ops = { 90f1ff24aaSHariprasad Shenai .start = seq_tab_start, 91f1ff24aaSHariprasad Shenai .next = seq_tab_next, 92f1ff24aaSHariprasad Shenai .stop = seq_tab_stop, 93f1ff24aaSHariprasad Shenai .show = seq_tab_show 94f1ff24aaSHariprasad Shenai }; 95f1ff24aaSHariprasad Shenai 96f1ff24aaSHariprasad Shenai struct seq_tab *seq_open_tab(struct file *f, unsigned int rows, 97f1ff24aaSHariprasad Shenai unsigned int width, unsigned int have_header, 98f1ff24aaSHariprasad Shenai int (*show)(struct seq_file *seq, void *v, int i)) 99f1ff24aaSHariprasad Shenai { 100f1ff24aaSHariprasad Shenai struct seq_tab *p; 101f1ff24aaSHariprasad Shenai 102f1ff24aaSHariprasad Shenai p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width); 103f1ff24aaSHariprasad Shenai if (p) { 104f1ff24aaSHariprasad Shenai p->show = show; 105f1ff24aaSHariprasad Shenai p->rows = rows; 106f1ff24aaSHariprasad Shenai p->width = width; 107f1ff24aaSHariprasad Shenai p->skip_first = have_header != 0; 108f1ff24aaSHariprasad Shenai } 109f1ff24aaSHariprasad Shenai return p; 110f1ff24aaSHariprasad Shenai } 111f1ff24aaSHariprasad Shenai 112c778af7dSHariprasad Shenai /* Trim the size of a seq_tab to the supplied number of rows. The operation is 113c778af7dSHariprasad Shenai * irreversible. 114c778af7dSHariprasad Shenai */ 115c778af7dSHariprasad Shenai static int seq_tab_trim(struct seq_tab *p, unsigned int new_rows) 116c778af7dSHariprasad Shenai { 117c778af7dSHariprasad Shenai if (new_rows > p->rows) 118c778af7dSHariprasad Shenai return -EINVAL; 119c778af7dSHariprasad Shenai p->rows = new_rows; 120c778af7dSHariprasad Shenai return 0; 121c778af7dSHariprasad Shenai } 122c778af7dSHariprasad Shenai 123f1ff24aaSHariprasad Shenai static int cim_la_show(struct seq_file *seq, void *v, int idx) 124f1ff24aaSHariprasad Shenai { 125f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) 126f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC LS0Stat LS0Addr " 127f1ff24aaSHariprasad Shenai " LS0Data\n"); 128f1ff24aaSHariprasad Shenai else { 129f1ff24aaSHariprasad Shenai const u32 *p = v; 130f1ff24aaSHariprasad Shenai 131f1ff24aaSHariprasad Shenai seq_printf(seq, 132f1ff24aaSHariprasad Shenai " %02x %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n", 133f1ff24aaSHariprasad Shenai (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4, 134f1ff24aaSHariprasad Shenai p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5], 135f1ff24aaSHariprasad Shenai p[6], p[7]); 136f1ff24aaSHariprasad Shenai } 137f1ff24aaSHariprasad Shenai return 0; 138f1ff24aaSHariprasad Shenai } 139f1ff24aaSHariprasad Shenai 140f1ff24aaSHariprasad Shenai static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx) 141f1ff24aaSHariprasad Shenai { 142f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) { 143f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC\n"); 144f1ff24aaSHariprasad Shenai } else { 145f1ff24aaSHariprasad Shenai const u32 *p = v; 146f1ff24aaSHariprasad Shenai 147f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %08x %08x\n", p[5] & 0xff, p[6], 148f1ff24aaSHariprasad Shenai p[7]); 149f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x\n", 150f1ff24aaSHariprasad Shenai (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8, 151f1ff24aaSHariprasad Shenai p[4] & 0xff, p[5] >> 8); 152f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %x%07x %x%07x\n", (p[0] >> 4) & 0xff, 153f1ff24aaSHariprasad Shenai p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4); 154f1ff24aaSHariprasad Shenai } 155f1ff24aaSHariprasad Shenai return 0; 156f1ff24aaSHariprasad Shenai } 157f1ff24aaSHariprasad Shenai 158b7660642SHariprasad Shenai static int cim_la_show_t6(struct seq_file *seq, void *v, int idx) 159b7660642SHariprasad Shenai { 160b7660642SHariprasad Shenai if (v == SEQ_START_TOKEN) { 161b7660642SHariprasad Shenai seq_puts(seq, "Status Inst Data PC LS0Stat " 162b7660642SHariprasad Shenai "LS0Addr LS0Data LS1Stat LS1Addr LS1Data\n"); 163b7660642SHariprasad Shenai } else { 164b7660642SHariprasad Shenai const u32 *p = v; 165b7660642SHariprasad Shenai 166b7660642SHariprasad Shenai seq_printf(seq, " %02x %04x%04x %04x%04x %04x%04x %08x %08x %08x %08x %08x %08x\n", 167b7660642SHariprasad Shenai (p[9] >> 16) & 0xff, /* Status */ 168b7660642SHariprasad Shenai p[9] & 0xffff, p[8] >> 16, /* Inst */ 169b7660642SHariprasad Shenai p[8] & 0xffff, p[7] >> 16, /* Data */ 170b7660642SHariprasad Shenai p[7] & 0xffff, p[6] >> 16, /* PC */ 171b7660642SHariprasad Shenai p[2], p[1], p[0], /* LS0 Stat, Addr and Data */ 172b7660642SHariprasad Shenai p[5], p[4], p[3]); /* LS1 Stat, Addr and Data */ 173b7660642SHariprasad Shenai } 174b7660642SHariprasad Shenai return 0; 175b7660642SHariprasad Shenai } 176b7660642SHariprasad Shenai 177b7660642SHariprasad Shenai static int cim_la_show_pc_t6(struct seq_file *seq, void *v, int idx) 178b7660642SHariprasad Shenai { 179b7660642SHariprasad Shenai if (v == SEQ_START_TOKEN) { 180b7660642SHariprasad Shenai seq_puts(seq, "Status Inst Data PC\n"); 181b7660642SHariprasad Shenai } else { 182b7660642SHariprasad Shenai const u32 *p = v; 183b7660642SHariprasad Shenai 184b7660642SHariprasad Shenai seq_printf(seq, " %02x %08x %08x %08x\n", 185b7660642SHariprasad Shenai p[3] & 0xff, p[2], p[1], p[0]); 186b7660642SHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x %02x%06x\n", 187b7660642SHariprasad Shenai (p[6] >> 8) & 0xff, p[6] & 0xff, p[5] >> 8, 188b7660642SHariprasad Shenai p[5] & 0xff, p[4] >> 8, p[4] & 0xff, p[3] >> 8); 189b7660642SHariprasad Shenai seq_printf(seq, " %02x %04x%04x %04x%04x %04x%04x\n", 190b7660642SHariprasad Shenai (p[9] >> 16) & 0xff, p[9] & 0xffff, p[8] >> 16, 191b7660642SHariprasad Shenai p[8] & 0xffff, p[7] >> 16, p[7] & 0xffff, 192b7660642SHariprasad Shenai p[6] >> 16); 193b7660642SHariprasad Shenai } 194b7660642SHariprasad Shenai return 0; 195b7660642SHariprasad Shenai } 196b7660642SHariprasad Shenai 197f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 198f1ff24aaSHariprasad Shenai { 199f1ff24aaSHariprasad Shenai int ret; 200f1ff24aaSHariprasad Shenai unsigned int cfg; 201f1ff24aaSHariprasad Shenai struct seq_tab *p; 202f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 203f1ff24aaSHariprasad Shenai 204f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 205f1ff24aaSHariprasad Shenai if (ret) 206f1ff24aaSHariprasad Shenai return ret; 207f1ff24aaSHariprasad Shenai 208b7660642SHariprasad Shenai if (is_t6(adap->params.chip)) { 209b7660642SHariprasad Shenai /* +1 to account for integer division of CIMLA_SIZE/10 */ 210b7660642SHariprasad Shenai p = seq_open_tab(file, (adap->params.cim_la_size / 10) + 1, 211b7660642SHariprasad Shenai 10 * sizeof(u32), 1, 212f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 213b7660642SHariprasad Shenai cim_la_show_pc_t6 : cim_la_show_t6); 214b7660642SHariprasad Shenai } else { 215b7660642SHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 216b7660642SHariprasad Shenai 8 * sizeof(u32), 1, 217b7660642SHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? cim_la_show_3in1 : 218b7660642SHariprasad Shenai cim_la_show); 219b7660642SHariprasad Shenai } 220f1ff24aaSHariprasad Shenai if (!p) 221f1ff24aaSHariprasad Shenai return -ENOMEM; 222f1ff24aaSHariprasad Shenai 223f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 224f1ff24aaSHariprasad Shenai if (ret) 225f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 226f1ff24aaSHariprasad Shenai return ret; 227f1ff24aaSHariprasad Shenai } 228f1ff24aaSHariprasad Shenai 229f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 230f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 231f1ff24aaSHariprasad Shenai .open = cim_la_open, 232f1ff24aaSHariprasad Shenai .read = seq_read, 233f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 234f1ff24aaSHariprasad Shenai .release = seq_release_private 235f1ff24aaSHariprasad Shenai }; 236f1ff24aaSHariprasad Shenai 23719689609SHariprasad Shenai static int cim_pif_la_show(struct seq_file *seq, void *v, int idx) 23819689609SHariprasad Shenai { 23919689609SHariprasad Shenai const u32 *p = v; 24019689609SHariprasad Shenai 24119689609SHariprasad Shenai if (v == SEQ_START_TOKEN) { 24219689609SHariprasad Shenai seq_puts(seq, "Cntl ID DataBE Addr Data\n"); 24319689609SHariprasad Shenai } else if (idx < CIM_PIFLA_SIZE) { 24419689609SHariprasad Shenai seq_printf(seq, " %02x %02x %04x %08x %08x%08x%08x%08x\n", 24519689609SHariprasad Shenai (p[5] >> 22) & 0xff, (p[5] >> 16) & 0x3f, 24619689609SHariprasad Shenai p[5] & 0xffff, p[4], p[3], p[2], p[1], p[0]); 24719689609SHariprasad Shenai } else { 24819689609SHariprasad Shenai if (idx == CIM_PIFLA_SIZE) 24919689609SHariprasad Shenai seq_puts(seq, "\nCntl ID Data\n"); 25019689609SHariprasad Shenai seq_printf(seq, " %02x %02x %08x%08x%08x%08x\n", 25119689609SHariprasad Shenai (p[4] >> 6) & 0xff, p[4] & 0x3f, 25219689609SHariprasad Shenai p[3], p[2], p[1], p[0]); 25319689609SHariprasad Shenai } 25419689609SHariprasad Shenai return 0; 25519689609SHariprasad Shenai } 25619689609SHariprasad Shenai 25719689609SHariprasad Shenai static int cim_pif_la_open(struct inode *inode, struct file *file) 25819689609SHariprasad Shenai { 25919689609SHariprasad Shenai struct seq_tab *p; 26019689609SHariprasad Shenai struct adapter *adap = inode->i_private; 26119689609SHariprasad Shenai 26219689609SHariprasad Shenai p = seq_open_tab(file, 2 * CIM_PIFLA_SIZE, 6 * sizeof(u32), 1, 26319689609SHariprasad Shenai cim_pif_la_show); 26419689609SHariprasad Shenai if (!p) 26519689609SHariprasad Shenai return -ENOMEM; 26619689609SHariprasad Shenai 26719689609SHariprasad Shenai t4_cim_read_pif_la(adap, (u32 *)p->data, 26819689609SHariprasad Shenai (u32 *)p->data + 6 * CIM_PIFLA_SIZE, NULL, NULL); 26919689609SHariprasad Shenai return 0; 27019689609SHariprasad Shenai } 27119689609SHariprasad Shenai 27219689609SHariprasad Shenai static const struct file_operations cim_pif_la_fops = { 27319689609SHariprasad Shenai .owner = THIS_MODULE, 27419689609SHariprasad Shenai .open = cim_pif_la_open, 27519689609SHariprasad Shenai .read = seq_read, 27619689609SHariprasad Shenai .llseek = seq_lseek, 27719689609SHariprasad Shenai .release = seq_release_private 27819689609SHariprasad Shenai }; 27919689609SHariprasad Shenai 28026fae93fSHariprasad Shenai static int cim_ma_la_show(struct seq_file *seq, void *v, int idx) 28126fae93fSHariprasad Shenai { 28226fae93fSHariprasad Shenai const u32 *p = v; 28326fae93fSHariprasad Shenai 28426fae93fSHariprasad Shenai if (v == SEQ_START_TOKEN) { 28526fae93fSHariprasad Shenai seq_puts(seq, "\n"); 28626fae93fSHariprasad Shenai } else if (idx < CIM_MALA_SIZE) { 28726fae93fSHariprasad Shenai seq_printf(seq, "%02x%08x%08x%08x%08x\n", 28826fae93fSHariprasad Shenai p[4], p[3], p[2], p[1], p[0]); 28926fae93fSHariprasad Shenai } else { 29026fae93fSHariprasad Shenai if (idx == CIM_MALA_SIZE) 29126fae93fSHariprasad Shenai seq_puts(seq, 29226fae93fSHariprasad Shenai "\nCnt ID Tag UE Data RDY VLD\n"); 29326fae93fSHariprasad Shenai seq_printf(seq, "%3u %2u %x %u %08x%08x %u %u\n", 29426fae93fSHariprasad Shenai (p[2] >> 10) & 0xff, (p[2] >> 7) & 7, 29526fae93fSHariprasad Shenai (p[2] >> 3) & 0xf, (p[2] >> 2) & 1, 29626fae93fSHariprasad Shenai (p[1] >> 2) | ((p[2] & 3) << 30), 29726fae93fSHariprasad Shenai (p[0] >> 2) | ((p[1] & 3) << 30), (p[0] >> 1) & 1, 29826fae93fSHariprasad Shenai p[0] & 1); 29926fae93fSHariprasad Shenai } 30026fae93fSHariprasad Shenai return 0; 30126fae93fSHariprasad Shenai } 30226fae93fSHariprasad Shenai 30326fae93fSHariprasad Shenai static int cim_ma_la_open(struct inode *inode, struct file *file) 30426fae93fSHariprasad Shenai { 30526fae93fSHariprasad Shenai struct seq_tab *p; 30626fae93fSHariprasad Shenai struct adapter *adap = inode->i_private; 30726fae93fSHariprasad Shenai 30826fae93fSHariprasad Shenai p = seq_open_tab(file, 2 * CIM_MALA_SIZE, 5 * sizeof(u32), 1, 30926fae93fSHariprasad Shenai cim_ma_la_show); 31026fae93fSHariprasad Shenai if (!p) 31126fae93fSHariprasad Shenai return -ENOMEM; 31226fae93fSHariprasad Shenai 31326fae93fSHariprasad Shenai t4_cim_read_ma_la(adap, (u32 *)p->data, 31426fae93fSHariprasad Shenai (u32 *)p->data + 5 * CIM_MALA_SIZE); 31526fae93fSHariprasad Shenai return 0; 31626fae93fSHariprasad Shenai } 31726fae93fSHariprasad Shenai 31826fae93fSHariprasad Shenai static const struct file_operations cim_ma_la_fops = { 31926fae93fSHariprasad Shenai .owner = THIS_MODULE, 32026fae93fSHariprasad Shenai .open = cim_ma_la_open, 32126fae93fSHariprasad Shenai .read = seq_read, 32226fae93fSHariprasad Shenai .llseek = seq_lseek, 32326fae93fSHariprasad Shenai .release = seq_release_private 32426fae93fSHariprasad Shenai }; 32526fae93fSHariprasad Shenai 32674b3092cSHariprasad Shenai static int cim_qcfg_show(struct seq_file *seq, void *v) 32774b3092cSHariprasad Shenai { 32874b3092cSHariprasad Shenai static const char * const qname[] = { 32974b3092cSHariprasad Shenai "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI", 33074b3092cSHariprasad Shenai "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI", 33174b3092cSHariprasad Shenai "SGE0-RX", "SGE1-RX" 33274b3092cSHariprasad Shenai }; 33374b3092cSHariprasad Shenai 33474b3092cSHariprasad Shenai int i; 33574b3092cSHariprasad Shenai struct adapter *adap = seq->private; 33674b3092cSHariprasad Shenai u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 33774b3092cSHariprasad Shenai u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 33874b3092cSHariprasad Shenai u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))]; 33974b3092cSHariprasad Shenai u16 thres[CIM_NUM_IBQ]; 34074b3092cSHariprasad Shenai u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr; 34174b3092cSHariprasad Shenai u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5]; 34274b3092cSHariprasad Shenai u32 *p = stat; 34374b3092cSHariprasad Shenai int cim_num_obq = is_t4(adap->params.chip) ? 34474b3092cSHariprasad Shenai CIM_NUM_OBQ : CIM_NUM_OBQ_T5; 34574b3092cSHariprasad Shenai 34674b3092cSHariprasad Shenai i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A : 34774b3092cSHariprasad Shenai UP_IBQ_0_SHADOW_RDADDR_A, 34874b3092cSHariprasad Shenai ARRAY_SIZE(stat), stat); 34974b3092cSHariprasad Shenai if (!i) { 35074b3092cSHariprasad Shenai if (is_t4(adap->params.chip)) { 35174b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A, 35274b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t4), obq_wr_t4); 35374b3092cSHariprasad Shenai wr = obq_wr_t4; 35474b3092cSHariprasad Shenai } else { 35574b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A, 35674b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t5), obq_wr_t5); 35774b3092cSHariprasad Shenai wr = obq_wr_t5; 35874b3092cSHariprasad Shenai } 35974b3092cSHariprasad Shenai } 36074b3092cSHariprasad Shenai if (i) 36174b3092cSHariprasad Shenai return i; 36274b3092cSHariprasad Shenai 36374b3092cSHariprasad Shenai t4_read_cimq_cfg(adap, base, size, thres); 36474b3092cSHariprasad Shenai 36574b3092cSHariprasad Shenai seq_printf(seq, 36674b3092cSHariprasad Shenai " Queue Base Size Thres RdPtr WrPtr SOP EOP Avail\n"); 36774b3092cSHariprasad Shenai for (i = 0; i < CIM_NUM_IBQ; i++, p += 4) 36874b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %5u %6x %4x %4u %4u %5u\n", 36974b3092cSHariprasad Shenai qname[i], base[i], size[i], thres[i], 37074b3092cSHariprasad Shenai IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]), 37174b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 37274b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 37374b3092cSHariprasad Shenai for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2) 37474b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %12x %4x %4u %4u %5u\n", 37574b3092cSHariprasad Shenai qname[i], base[i], size[i], 37674b3092cSHariprasad Shenai QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i], 37774b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 37874b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 37974b3092cSHariprasad Shenai return 0; 38074b3092cSHariprasad Shenai } 381b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(cim_qcfg); 38274b3092cSHariprasad Shenai 383e5f0e43bSHariprasad Shenai static int cimq_show(struct seq_file *seq, void *v, int idx) 384e5f0e43bSHariprasad Shenai { 385e5f0e43bSHariprasad Shenai const u32 *p = v; 386e5f0e43bSHariprasad Shenai 387e5f0e43bSHariprasad Shenai seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1], 388e5f0e43bSHariprasad Shenai p[2], p[3]); 389e5f0e43bSHariprasad Shenai return 0; 390e5f0e43bSHariprasad Shenai } 391e5f0e43bSHariprasad Shenai 392e5f0e43bSHariprasad Shenai static int cim_ibq_open(struct inode *inode, struct file *file) 393e5f0e43bSHariprasad Shenai { 394e5f0e43bSHariprasad Shenai int ret; 395e5f0e43bSHariprasad Shenai struct seq_tab *p; 396e5f0e43bSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 397e5f0e43bSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 398e5f0e43bSHariprasad Shenai 399e5f0e43bSHariprasad Shenai p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 400e5f0e43bSHariprasad Shenai if (!p) 401e5f0e43bSHariprasad Shenai return -ENOMEM; 402e5f0e43bSHariprasad Shenai 403e5f0e43bSHariprasad Shenai ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4); 404e5f0e43bSHariprasad Shenai if (ret < 0) 405e5f0e43bSHariprasad Shenai seq_release_private(inode, file); 406e5f0e43bSHariprasad Shenai else 407e5f0e43bSHariprasad Shenai ret = 0; 408e5f0e43bSHariprasad Shenai return ret; 409e5f0e43bSHariprasad Shenai } 410e5f0e43bSHariprasad Shenai 411e5f0e43bSHariprasad Shenai static const struct file_operations cim_ibq_fops = { 412e5f0e43bSHariprasad Shenai .owner = THIS_MODULE, 413e5f0e43bSHariprasad Shenai .open = cim_ibq_open, 414e5f0e43bSHariprasad Shenai .read = seq_read, 415e5f0e43bSHariprasad Shenai .llseek = seq_lseek, 416e5f0e43bSHariprasad Shenai .release = seq_release_private 417e5f0e43bSHariprasad Shenai }; 418e5f0e43bSHariprasad Shenai 419c778af7dSHariprasad Shenai static int cim_obq_open(struct inode *inode, struct file *file) 420c778af7dSHariprasad Shenai { 421c778af7dSHariprasad Shenai int ret; 422c778af7dSHariprasad Shenai struct seq_tab *p; 423c778af7dSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 424c778af7dSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 425c778af7dSHariprasad Shenai 426c778af7dSHariprasad Shenai p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 427c778af7dSHariprasad Shenai if (!p) 428c778af7dSHariprasad Shenai return -ENOMEM; 429c778af7dSHariprasad Shenai 430c778af7dSHariprasad Shenai ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4); 431c778af7dSHariprasad Shenai if (ret < 0) { 432c778af7dSHariprasad Shenai seq_release_private(inode, file); 433c778af7dSHariprasad Shenai } else { 434c778af7dSHariprasad Shenai seq_tab_trim(p, ret / 4); 435c778af7dSHariprasad Shenai ret = 0; 436c778af7dSHariprasad Shenai } 437c778af7dSHariprasad Shenai return ret; 438c778af7dSHariprasad Shenai } 439c778af7dSHariprasad Shenai 440c778af7dSHariprasad Shenai static const struct file_operations cim_obq_fops = { 441c778af7dSHariprasad Shenai .owner = THIS_MODULE, 442c778af7dSHariprasad Shenai .open = cim_obq_open, 443c778af7dSHariprasad Shenai .read = seq_read, 444c778af7dSHariprasad Shenai .llseek = seq_lseek, 445c778af7dSHariprasad Shenai .release = seq_release_private 446c778af7dSHariprasad Shenai }; 447c778af7dSHariprasad Shenai 4482d277b3bSHariprasad Shenai struct field_desc { 4492d277b3bSHariprasad Shenai const char *name; 4502d277b3bSHariprasad Shenai unsigned int start; 4512d277b3bSHariprasad Shenai unsigned int width; 4522d277b3bSHariprasad Shenai }; 4532d277b3bSHariprasad Shenai 4542d277b3bSHariprasad Shenai static void field_desc_show(struct seq_file *seq, u64 v, 4552d277b3bSHariprasad Shenai const struct field_desc *p) 4562d277b3bSHariprasad Shenai { 4572d277b3bSHariprasad Shenai char buf[32]; 4582d277b3bSHariprasad Shenai int line_size = 0; 4592d277b3bSHariprasad Shenai 4602d277b3bSHariprasad Shenai while (p->name) { 4612d277b3bSHariprasad Shenai u64 mask = (1ULL << p->width) - 1; 4622d277b3bSHariprasad Shenai int len = scnprintf(buf, sizeof(buf), "%s: %llu", p->name, 4632d277b3bSHariprasad Shenai ((unsigned long long)v >> p->start) & mask); 4642d277b3bSHariprasad Shenai 4652d277b3bSHariprasad Shenai if (line_size + len >= 79) { 4662d277b3bSHariprasad Shenai line_size = 8; 4672d277b3bSHariprasad Shenai seq_puts(seq, "\n "); 4682d277b3bSHariprasad Shenai } 4692d277b3bSHariprasad Shenai seq_printf(seq, "%s ", buf); 4702d277b3bSHariprasad Shenai line_size += len + 1; 4712d277b3bSHariprasad Shenai p++; 4722d277b3bSHariprasad Shenai } 4732d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 4742d277b3bSHariprasad Shenai } 4752d277b3bSHariprasad Shenai 4762d277b3bSHariprasad Shenai static struct field_desc tp_la0[] = { 4772d277b3bSHariprasad Shenai { "RcfOpCodeOut", 60, 4 }, 4782d277b3bSHariprasad Shenai { "State", 56, 4 }, 4792d277b3bSHariprasad Shenai { "WcfState", 52, 4 }, 4802d277b3bSHariprasad Shenai { "RcfOpcSrcOut", 50, 2 }, 4812d277b3bSHariprasad Shenai { "CRxError", 49, 1 }, 4822d277b3bSHariprasad Shenai { "ERxError", 48, 1 }, 4832d277b3bSHariprasad Shenai { "SanityFailed", 47, 1 }, 4842d277b3bSHariprasad Shenai { "SpuriousMsg", 46, 1 }, 4852d277b3bSHariprasad Shenai { "FlushInputMsg", 45, 1 }, 4862d277b3bSHariprasad Shenai { "FlushInputCpl", 44, 1 }, 4872d277b3bSHariprasad Shenai { "RssUpBit", 43, 1 }, 4882d277b3bSHariprasad Shenai { "RssFilterHit", 42, 1 }, 4892d277b3bSHariprasad Shenai { "Tid", 32, 10 }, 4902d277b3bSHariprasad Shenai { "InitTcb", 31, 1 }, 4912d277b3bSHariprasad Shenai { "LineNumber", 24, 7 }, 4922d277b3bSHariprasad Shenai { "Emsg", 23, 1 }, 4932d277b3bSHariprasad Shenai { "EdataOut", 22, 1 }, 4942d277b3bSHariprasad Shenai { "Cmsg", 21, 1 }, 4952d277b3bSHariprasad Shenai { "CdataOut", 20, 1 }, 4962d277b3bSHariprasad Shenai { "EreadPdu", 19, 1 }, 4972d277b3bSHariprasad Shenai { "CreadPdu", 18, 1 }, 4982d277b3bSHariprasad Shenai { "TunnelPkt", 17, 1 }, 4992d277b3bSHariprasad Shenai { "RcfPeerFin", 16, 1 }, 5002d277b3bSHariprasad Shenai { "RcfReasonOut", 12, 4 }, 5012d277b3bSHariprasad Shenai { "TxCchannel", 10, 2 }, 5022d277b3bSHariprasad Shenai { "RcfTxChannel", 8, 2 }, 5032d277b3bSHariprasad Shenai { "RxEchannel", 6, 2 }, 5042d277b3bSHariprasad Shenai { "RcfRxChannel", 5, 1 }, 5052d277b3bSHariprasad Shenai { "RcfDataOutSrdy", 4, 1 }, 5062d277b3bSHariprasad Shenai { "RxDvld", 3, 1 }, 5072d277b3bSHariprasad Shenai { "RxOoDvld", 2, 1 }, 5082d277b3bSHariprasad Shenai { "RxCongestion", 1, 1 }, 5092d277b3bSHariprasad Shenai { "TxCongestion", 0, 1 }, 5102d277b3bSHariprasad Shenai { NULL } 5112d277b3bSHariprasad Shenai }; 5122d277b3bSHariprasad Shenai 5132d277b3bSHariprasad Shenai static int tp_la_show(struct seq_file *seq, void *v, int idx) 5142d277b3bSHariprasad Shenai { 5152d277b3bSHariprasad Shenai const u64 *p = v; 5162d277b3bSHariprasad Shenai 5172d277b3bSHariprasad Shenai field_desc_show(seq, *p, tp_la0); 5182d277b3bSHariprasad Shenai return 0; 5192d277b3bSHariprasad Shenai } 5202d277b3bSHariprasad Shenai 5212d277b3bSHariprasad Shenai static int tp_la_show2(struct seq_file *seq, void *v, int idx) 5222d277b3bSHariprasad Shenai { 5232d277b3bSHariprasad Shenai const u64 *p = v; 5242d277b3bSHariprasad Shenai 5252d277b3bSHariprasad Shenai if (idx) 5262d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 5272d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 5282d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 5292d277b3bSHariprasad Shenai field_desc_show(seq, p[1], tp_la0); 5302d277b3bSHariprasad Shenai return 0; 5312d277b3bSHariprasad Shenai } 5322d277b3bSHariprasad Shenai 5332d277b3bSHariprasad Shenai static int tp_la_show3(struct seq_file *seq, void *v, int idx) 5342d277b3bSHariprasad Shenai { 5352d277b3bSHariprasad Shenai static struct field_desc tp_la1[] = { 5362d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 5372d277b3bSHariprasad Shenai { "CplCmdOut", 48, 8 }, 5382d277b3bSHariprasad Shenai { "ESynOut", 47, 1 }, 5392d277b3bSHariprasad Shenai { "EAckOut", 46, 1 }, 5402d277b3bSHariprasad Shenai { "EFinOut", 45, 1 }, 5412d277b3bSHariprasad Shenai { "ERstOut", 44, 1 }, 5422d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 5432d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 5442d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 5452d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 5462d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 5472d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 5482d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 5492d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 5502d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 5512d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 5522d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 5532d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 5542d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 5552d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 5562d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 5572d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 5582d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 5592d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 5602d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 5612d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 5622d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 5632d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 5642d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 5652d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 5662d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 5672d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 5682d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 5692d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 5702d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 5712d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 5722d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 5732d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 5742d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 5752d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 5762d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 5772d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 5782d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 5792d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 5802d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 5812d277b3bSHariprasad Shenai { NULL } 5822d277b3bSHariprasad Shenai }; 5832d277b3bSHariprasad Shenai static struct field_desc tp_la2[] = { 5842d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 5852d277b3bSHariprasad Shenai { "MpsVfVld", 55, 1 }, 5862d277b3bSHariprasad Shenai { "MpsPf", 52, 3 }, 5872d277b3bSHariprasad Shenai { "MpsVf", 44, 8 }, 5882d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 5892d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 5902d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 5912d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 5922d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 5932d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 5942d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 5952d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 5962d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 5972d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 5982d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 5992d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 6002d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 6012d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 6022d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 6032d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 6042d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 6052d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 6062d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 6072d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 6082d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 6092d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 6102d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 6112d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 6122d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 6132d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 6142d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 6152d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 6162d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 6172d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 6182d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 6192d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 6202d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 6212d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 6222d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 6232d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 6242d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 6252d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 6262d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 6272d277b3bSHariprasad Shenai { NULL } 6282d277b3bSHariprasad Shenai }; 6292d277b3bSHariprasad Shenai const u64 *p = v; 6302d277b3bSHariprasad Shenai 6312d277b3bSHariprasad Shenai if (idx) 6322d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 6332d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 6342d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 6352d277b3bSHariprasad Shenai field_desc_show(seq, p[1], (p[0] & BIT(17)) ? tp_la2 : tp_la1); 6362d277b3bSHariprasad Shenai return 0; 6372d277b3bSHariprasad Shenai } 6382d277b3bSHariprasad Shenai 6392d277b3bSHariprasad Shenai static int tp_la_open(struct inode *inode, struct file *file) 6402d277b3bSHariprasad Shenai { 6412d277b3bSHariprasad Shenai struct seq_tab *p; 6422d277b3bSHariprasad Shenai struct adapter *adap = inode->i_private; 6432d277b3bSHariprasad Shenai 6442d277b3bSHariprasad Shenai switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) { 6452d277b3bSHariprasad Shenai case 2: 6462d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 6472d277b3bSHariprasad Shenai tp_la_show2); 6482d277b3bSHariprasad Shenai break; 6492d277b3bSHariprasad Shenai case 3: 6502d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 6512d277b3bSHariprasad Shenai tp_la_show3); 6522d277b3bSHariprasad Shenai break; 6532d277b3bSHariprasad Shenai default: 6542d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE, sizeof(u64), 0, tp_la_show); 6552d277b3bSHariprasad Shenai } 6562d277b3bSHariprasad Shenai if (!p) 6572d277b3bSHariprasad Shenai return -ENOMEM; 6582d277b3bSHariprasad Shenai 6592d277b3bSHariprasad Shenai t4_tp_read_la(adap, (u64 *)p->data, NULL); 6602d277b3bSHariprasad Shenai return 0; 6612d277b3bSHariprasad Shenai } 6622d277b3bSHariprasad Shenai 6632d277b3bSHariprasad Shenai static ssize_t tp_la_write(struct file *file, const char __user *buf, 6642d277b3bSHariprasad Shenai size_t count, loff_t *pos) 6652d277b3bSHariprasad Shenai { 6662d277b3bSHariprasad Shenai int err; 6672d277b3bSHariprasad Shenai char s[32]; 6682d277b3bSHariprasad Shenai unsigned long val; 6692d277b3bSHariprasad Shenai size_t size = min(sizeof(s) - 1, count); 670c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 6712d277b3bSHariprasad Shenai 6722d277b3bSHariprasad Shenai if (copy_from_user(s, buf, size)) 6732d277b3bSHariprasad Shenai return -EFAULT; 6742d277b3bSHariprasad Shenai s[size] = '\0'; 6752d277b3bSHariprasad Shenai err = kstrtoul(s, 0, &val); 6762d277b3bSHariprasad Shenai if (err) 6772d277b3bSHariprasad Shenai return err; 6782d277b3bSHariprasad Shenai if (val > 0xffff) 6792d277b3bSHariprasad Shenai return -EINVAL; 6802d277b3bSHariprasad Shenai adap->params.tp.la_mask = val << 16; 6812d277b3bSHariprasad Shenai t4_set_reg_field(adap, TP_DBG_LA_CONFIG_A, 0xffff0000U, 6822d277b3bSHariprasad Shenai adap->params.tp.la_mask); 6832d277b3bSHariprasad Shenai return count; 6842d277b3bSHariprasad Shenai } 6852d277b3bSHariprasad Shenai 6862d277b3bSHariprasad Shenai static const struct file_operations tp_la_fops = { 6872d277b3bSHariprasad Shenai .owner = THIS_MODULE, 6882d277b3bSHariprasad Shenai .open = tp_la_open, 6892d277b3bSHariprasad Shenai .read = seq_read, 6902d277b3bSHariprasad Shenai .llseek = seq_lseek, 6912d277b3bSHariprasad Shenai .release = seq_release_private, 6922d277b3bSHariprasad Shenai .write = tp_la_write 6932d277b3bSHariprasad Shenai }; 6942d277b3bSHariprasad Shenai 695797ff0f5SHariprasad Shenai static int ulprx_la_show(struct seq_file *seq, void *v, int idx) 696797ff0f5SHariprasad Shenai { 697797ff0f5SHariprasad Shenai const u32 *p = v; 698797ff0f5SHariprasad Shenai 699797ff0f5SHariprasad Shenai if (v == SEQ_START_TOKEN) 700797ff0f5SHariprasad Shenai seq_puts(seq, " Pcmd Type Message" 701797ff0f5SHariprasad Shenai " Data\n"); 702797ff0f5SHariprasad Shenai else 703797ff0f5SHariprasad Shenai seq_printf(seq, "%08x%08x %4x %08x %08x%08x%08x%08x\n", 704797ff0f5SHariprasad Shenai p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]); 705797ff0f5SHariprasad Shenai return 0; 706797ff0f5SHariprasad Shenai } 707797ff0f5SHariprasad Shenai 708797ff0f5SHariprasad Shenai static int ulprx_la_open(struct inode *inode, struct file *file) 709797ff0f5SHariprasad Shenai { 710797ff0f5SHariprasad Shenai struct seq_tab *p; 711797ff0f5SHariprasad Shenai struct adapter *adap = inode->i_private; 712797ff0f5SHariprasad Shenai 713797ff0f5SHariprasad Shenai p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1, 714797ff0f5SHariprasad Shenai ulprx_la_show); 715797ff0f5SHariprasad Shenai if (!p) 716797ff0f5SHariprasad Shenai return -ENOMEM; 717797ff0f5SHariprasad Shenai 718797ff0f5SHariprasad Shenai t4_ulprx_read_la(adap, (u32 *)p->data); 719797ff0f5SHariprasad Shenai return 0; 720797ff0f5SHariprasad Shenai } 721797ff0f5SHariprasad Shenai 722797ff0f5SHariprasad Shenai static const struct file_operations ulprx_la_fops = { 723797ff0f5SHariprasad Shenai .owner = THIS_MODULE, 724797ff0f5SHariprasad Shenai .open = ulprx_la_open, 725797ff0f5SHariprasad Shenai .read = seq_read, 726797ff0f5SHariprasad Shenai .llseek = seq_lseek, 727797ff0f5SHariprasad Shenai .release = seq_release_private 728797ff0f5SHariprasad Shenai }; 729797ff0f5SHariprasad Shenai 730b3bbe36aSHariprasad Shenai /* Show the PM memory stats. These stats include: 731b3bbe36aSHariprasad Shenai * 732b3bbe36aSHariprasad Shenai * TX: 733b3bbe36aSHariprasad Shenai * Read: memory read operation 734b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 735b3bbe36aSHariprasad Shenai * Bypass + mem: cut-through and save copy 736b3bbe36aSHariprasad Shenai * 737b3bbe36aSHariprasad Shenai * RX: 738b3bbe36aSHariprasad Shenai * Read: memory read 739b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 740b3bbe36aSHariprasad Shenai * Flush: payload trim or drop 741b3bbe36aSHariprasad Shenai */ 742b3bbe36aSHariprasad Shenai static int pm_stats_show(struct seq_file *seq, void *v) 743b3bbe36aSHariprasad Shenai { 744b3bbe36aSHariprasad Shenai static const char * const tx_pm_stats[] = { 745b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Bypass + mem:" 746b3bbe36aSHariprasad Shenai }; 747b3bbe36aSHariprasad Shenai static const char * const rx_pm_stats[] = { 748b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Flush:" 749b3bbe36aSHariprasad Shenai }; 750b3bbe36aSHariprasad Shenai 751b3bbe36aSHariprasad Shenai int i; 75244588560SHariprasad Shenai u32 tx_cnt[T6_PM_NSTATS], rx_cnt[T6_PM_NSTATS]; 75344588560SHariprasad Shenai u64 tx_cyc[T6_PM_NSTATS], rx_cyc[T6_PM_NSTATS]; 754b3bbe36aSHariprasad Shenai struct adapter *adap = seq->private; 755b3bbe36aSHariprasad Shenai 756b3bbe36aSHariprasad Shenai t4_pmtx_get_stats(adap, tx_cnt, tx_cyc); 757b3bbe36aSHariprasad Shenai t4_pmrx_get_stats(adap, rx_cnt, rx_cyc); 758b3bbe36aSHariprasad Shenai 759b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Tx pcmds", "Tx bytes"); 760b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 761b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 762b3bbe36aSHariprasad Shenai tx_pm_stats[i], tx_cnt[i], tx_cyc[i]); 763b3bbe36aSHariprasad Shenai 764b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Rx pcmds", "Rx bytes"); 765b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 766b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 767b3bbe36aSHariprasad Shenai rx_pm_stats[i], rx_cnt[i], rx_cyc[i]); 76844588560SHariprasad Shenai 76944588560SHariprasad Shenai if (CHELSIO_CHIP_VERSION(adap->params.chip) > CHELSIO_T5) { 77044588560SHariprasad Shenai /* In T5 the granularity of the total wait is too fine. 77144588560SHariprasad Shenai * It is not useful as it reaches the max value too fast. 77244588560SHariprasad Shenai * Hence display this Input FIFO wait for T6 onwards. 77344588560SHariprasad Shenai */ 77444588560SHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", 77544588560SHariprasad Shenai " ", "Total wait", "Total Occupancy"); 77644588560SHariprasad Shenai seq_printf(seq, "Tx FIFO wait %10u %20llu\n", 77744588560SHariprasad Shenai tx_cnt[i], tx_cyc[i]); 77844588560SHariprasad Shenai seq_printf(seq, "Rx FIFO wait %10u %20llu\n", 77944588560SHariprasad Shenai rx_cnt[i], rx_cyc[i]); 78044588560SHariprasad Shenai 78144588560SHariprasad Shenai /* Skip index 6 as there is nothing useful ihere */ 78244588560SHariprasad Shenai i += 2; 78344588560SHariprasad Shenai 78444588560SHariprasad Shenai /* At index 7, a new stat for read latency (count, total wait) 78544588560SHariprasad Shenai * is added. 78644588560SHariprasad Shenai */ 78744588560SHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", 78844588560SHariprasad Shenai " ", "Reads", "Total wait"); 78944588560SHariprasad Shenai seq_printf(seq, "Tx latency %10u %20llu\n", 79044588560SHariprasad Shenai tx_cnt[i], tx_cyc[i]); 79144588560SHariprasad Shenai seq_printf(seq, "Rx latency %10u %20llu\n", 79244588560SHariprasad Shenai rx_cnt[i], rx_cyc[i]); 79344588560SHariprasad Shenai } 794b3bbe36aSHariprasad Shenai return 0; 795b3bbe36aSHariprasad Shenai } 796b3bbe36aSHariprasad Shenai 797b3bbe36aSHariprasad Shenai static int pm_stats_open(struct inode *inode, struct file *file) 798b3bbe36aSHariprasad Shenai { 799b3bbe36aSHariprasad Shenai return single_open(file, pm_stats_show, inode->i_private); 800b3bbe36aSHariprasad Shenai } 801b3bbe36aSHariprasad Shenai 802b3bbe36aSHariprasad Shenai static ssize_t pm_stats_clear(struct file *file, const char __user *buf, 803b3bbe36aSHariprasad Shenai size_t count, loff_t *pos) 804b3bbe36aSHariprasad Shenai { 805c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 806b3bbe36aSHariprasad Shenai 807b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0); 808b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0); 809b3bbe36aSHariprasad Shenai return count; 810b3bbe36aSHariprasad Shenai } 811b3bbe36aSHariprasad Shenai 812b3bbe36aSHariprasad Shenai static const struct file_operations pm_stats_debugfs_fops = { 813b3bbe36aSHariprasad Shenai .owner = THIS_MODULE, 814b3bbe36aSHariprasad Shenai .open = pm_stats_open, 815b3bbe36aSHariprasad Shenai .read = seq_read, 816b3bbe36aSHariprasad Shenai .llseek = seq_lseek, 817b3bbe36aSHariprasad Shenai .release = single_release, 818b3bbe36aSHariprasad Shenai .write = pm_stats_clear 819b3bbe36aSHariprasad Shenai }; 820b3bbe36aSHariprasad Shenai 8217864026bSHariprasad Shenai static int tx_rate_show(struct seq_file *seq, void *v) 8227864026bSHariprasad Shenai { 8237864026bSHariprasad Shenai u64 nrate[NCHAN], orate[NCHAN]; 8247864026bSHariprasad Shenai struct adapter *adap = seq->private; 8257864026bSHariprasad Shenai 8267864026bSHariprasad Shenai t4_get_chan_txrate(adap, nrate, orate); 8277864026bSHariprasad Shenai if (adap->params.arch.nchan == NCHAN) { 8287864026bSHariprasad Shenai seq_puts(seq, " channel 0 channel 1 " 8297864026bSHariprasad Shenai "channel 2 channel 3\n"); 8307864026bSHariprasad Shenai seq_printf(seq, "NIC B/s: %10llu %10llu %10llu %10llu\n", 8317864026bSHariprasad Shenai (unsigned long long)nrate[0], 8327864026bSHariprasad Shenai (unsigned long long)nrate[1], 8337864026bSHariprasad Shenai (unsigned long long)nrate[2], 8347864026bSHariprasad Shenai (unsigned long long)nrate[3]); 8357864026bSHariprasad Shenai seq_printf(seq, "Offload B/s: %10llu %10llu %10llu %10llu\n", 8367864026bSHariprasad Shenai (unsigned long long)orate[0], 8377864026bSHariprasad Shenai (unsigned long long)orate[1], 8387864026bSHariprasad Shenai (unsigned long long)orate[2], 8397864026bSHariprasad Shenai (unsigned long long)orate[3]); 8407864026bSHariprasad Shenai } else { 8417864026bSHariprasad Shenai seq_puts(seq, " channel 0 channel 1\n"); 8427864026bSHariprasad Shenai seq_printf(seq, "NIC B/s: %10llu %10llu\n", 8437864026bSHariprasad Shenai (unsigned long long)nrate[0], 8447864026bSHariprasad Shenai (unsigned long long)nrate[1]); 8457864026bSHariprasad Shenai seq_printf(seq, "Offload B/s: %10llu %10llu\n", 8467864026bSHariprasad Shenai (unsigned long long)orate[0], 8477864026bSHariprasad Shenai (unsigned long long)orate[1]); 8487864026bSHariprasad Shenai } 8497864026bSHariprasad Shenai return 0; 8507864026bSHariprasad Shenai } 851b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(tx_rate); 8527864026bSHariprasad Shenai 853bad43792SHariprasad Shenai static int cctrl_tbl_show(struct seq_file *seq, void *v) 854bad43792SHariprasad Shenai { 855bad43792SHariprasad Shenai static const char * const dec_fac[] = { 856bad43792SHariprasad Shenai "0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875", 857bad43792SHariprasad Shenai "0.9375" }; 858bad43792SHariprasad Shenai 859bad43792SHariprasad Shenai int i; 860dde93dfeSHariprasad Shenai u16 (*incr)[NCCTRL_WIN]; 861bad43792SHariprasad Shenai struct adapter *adap = seq->private; 862bad43792SHariprasad Shenai 8636da2ec56SKees Cook incr = kmalloc_array(NMTUS, sizeof(*incr), GFP_KERNEL); 864dde93dfeSHariprasad Shenai if (!incr) 865dde93dfeSHariprasad Shenai return -ENOMEM; 866dde93dfeSHariprasad Shenai 867bad43792SHariprasad Shenai t4_read_cong_tbl(adap, incr); 868bad43792SHariprasad Shenai 869bad43792SHariprasad Shenai for (i = 0; i < NCCTRL_WIN; ++i) { 870bad43792SHariprasad Shenai seq_printf(seq, "%2d: %4u %4u %4u %4u %4u %4u %4u %4u\n", i, 871bad43792SHariprasad Shenai incr[0][i], incr[1][i], incr[2][i], incr[3][i], 872bad43792SHariprasad Shenai incr[4][i], incr[5][i], incr[6][i], incr[7][i]); 873bad43792SHariprasad Shenai seq_printf(seq, "%8u %4u %4u %4u %4u %4u %4u %4u %5u %s\n", 874bad43792SHariprasad Shenai incr[8][i], incr[9][i], incr[10][i], incr[11][i], 875bad43792SHariprasad Shenai incr[12][i], incr[13][i], incr[14][i], incr[15][i], 876bad43792SHariprasad Shenai adap->params.a_wnd[i], 877bad43792SHariprasad Shenai dec_fac[adap->params.b_wnd[i]]); 878bad43792SHariprasad Shenai } 879dde93dfeSHariprasad Shenai 880dde93dfeSHariprasad Shenai kfree(incr); 881bad43792SHariprasad Shenai return 0; 882bad43792SHariprasad Shenai } 883b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(cctrl_tbl); 884bad43792SHariprasad Shenai 885b58b6676SHariprasad Shenai /* Format a value in a unit that differs from the value's native unit by the 886b58b6676SHariprasad Shenai * given factor. 887b58b6676SHariprasad Shenai */ 888b58b6676SHariprasad Shenai static char *unit_conv(char *buf, size_t len, unsigned int val, 889b58b6676SHariprasad Shenai unsigned int factor) 890b58b6676SHariprasad Shenai { 891b58b6676SHariprasad Shenai unsigned int rem = val % factor; 892b58b6676SHariprasad Shenai 893b58b6676SHariprasad Shenai if (rem == 0) { 894b58b6676SHariprasad Shenai snprintf(buf, len, "%u", val / factor); 895b58b6676SHariprasad Shenai } else { 896b58b6676SHariprasad Shenai while (rem % 10 == 0) 897b58b6676SHariprasad Shenai rem /= 10; 898b58b6676SHariprasad Shenai snprintf(buf, len, "%u.%u", val / factor, rem); 899b58b6676SHariprasad Shenai } 900b58b6676SHariprasad Shenai return buf; 901b58b6676SHariprasad Shenai } 902b58b6676SHariprasad Shenai 903b58b6676SHariprasad Shenai static int clk_show(struct seq_file *seq, void *v) 904b58b6676SHariprasad Shenai { 905b58b6676SHariprasad Shenai char buf[32]; 906b58b6676SHariprasad Shenai struct adapter *adap = seq->private; 907b58b6676SHariprasad Shenai unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk; /* in ps */ 908b58b6676SHariprasad Shenai u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A); 909b58b6676SHariprasad Shenai unsigned int tre = TIMERRESOLUTION_G(res); 910b58b6676SHariprasad Shenai unsigned int dack_re = DELAYEDACKRESOLUTION_G(res); 911b58b6676SHariprasad Shenai unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */ 912b58b6676SHariprasad Shenai 913b58b6676SHariprasad Shenai seq_printf(seq, "Core clock period: %s ns\n", 914b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), cclk_ps, 1000)); 915b58b6676SHariprasad Shenai seq_printf(seq, "TP timer tick: %s us\n", 916b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000)); 917b58b6676SHariprasad Shenai seq_printf(seq, "TCP timestamp tick: %s us\n", 918b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), 919b58b6676SHariprasad Shenai (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000)); 920b58b6676SHariprasad Shenai seq_printf(seq, "DACK tick: %s us\n", 921b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000)); 922b58b6676SHariprasad Shenai seq_printf(seq, "DACK timer: %u us\n", 923b58b6676SHariprasad Shenai ((cclk_ps << dack_re) / 1000000) * 924b58b6676SHariprasad Shenai t4_read_reg(adap, TP_DACK_TIMER_A)); 925b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit min: %llu us\n", 926b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A)); 927b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit max: %llu us\n", 928b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A)); 929b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer min: %llu us\n", 930b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A)); 931b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer max: %llu us\n", 932b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A)); 933b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive idle timer: %llu us\n", 934b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A)); 935b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive interval: %llu us\n", 936b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A)); 937b58b6676SHariprasad Shenai seq_printf(seq, "Initial SRTT: %llu us\n", 938b58b6676SHariprasad Shenai tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A))); 939b58b6676SHariprasad Shenai seq_printf(seq, "FINWAIT2 timer: %llu us\n", 940b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A)); 941b58b6676SHariprasad Shenai 942b58b6676SHariprasad Shenai return 0; 943b58b6676SHariprasad Shenai } 944b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(clk); 945b58b6676SHariprasad Shenai 946f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 94749aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 94849aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 94949aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 95049aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 95149aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 95249aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 95349aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 95449aa284fSHariprasad Shenai }; 95549aa284fSHariprasad Shenai 95649aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 95749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 958da4976e1SHariprasad Shenai [FW_DEVLOG_FACILITY_CF] = "CF", 95949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 96049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 96149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 96249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 96349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 96449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 96549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 96649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 96749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 96849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 96949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 97049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 97149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 97249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 97349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 97449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 97549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 97649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 97749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 97849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 97949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 98049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 98149aa284fSHariprasad Shenai }; 98249aa284fSHariprasad Shenai 98349aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 98449aa284fSHariprasad Shenai */ 98549aa284fSHariprasad Shenai struct devlog_info { 98649aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 98749aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 98865dc2f1aSGustavo A. R. Silva struct fw_devlog_e log[]; /* Firmware Device Log */ 98949aa284fSHariprasad Shenai }; 99049aa284fSHariprasad Shenai 99149aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 99249aa284fSHariprasad Shenai */ 99349aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 99449aa284fSHariprasad Shenai { 99549aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 99649aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 99749aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 99849aa284fSHariprasad Shenai else { 99949aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 100049aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 100149aa284fSHariprasad Shenai unsigned long index; 100249aa284fSHariprasad Shenai struct fw_devlog_e *e; 100349aa284fSHariprasad Shenai 100449aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 100549aa284fSHariprasad Shenai * entries. 100649aa284fSHariprasad Shenai */ 100749aa284fSHariprasad Shenai index = dinfo->first + fidx; 100849aa284fSHariprasad Shenai if (index >= dinfo->nentries) 100949aa284fSHariprasad Shenai index -= dinfo->nentries; 101049aa284fSHariprasad Shenai e = &dinfo->log[index]; 101149aa284fSHariprasad Shenai if (e->timestamp == 0) 101249aa284fSHariprasad Shenai return 0; 101349aa284fSHariprasad Shenai 101449aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 101549aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 101649aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 101749aa284fSHariprasad Shenai */ 101849aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 1019fda8b18cSHariprasad Shenai be32_to_cpu(e->seqno), 1020fda8b18cSHariprasad Shenai be64_to_cpu(e->timestamp), 102149aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 102249aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 102349aa284fSHariprasad Shenai : "UNKNOWN"), 102449aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 102549aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 102649aa284fSHariprasad Shenai : "UNKNOWN")); 1027fda8b18cSHariprasad Shenai seq_printf(seq, e->fmt, 1028fda8b18cSHariprasad Shenai be32_to_cpu(e->params[0]), 1029fda8b18cSHariprasad Shenai be32_to_cpu(e->params[1]), 1030fda8b18cSHariprasad Shenai be32_to_cpu(e->params[2]), 1031fda8b18cSHariprasad Shenai be32_to_cpu(e->params[3]), 1032fda8b18cSHariprasad Shenai be32_to_cpu(e->params[4]), 1033fda8b18cSHariprasad Shenai be32_to_cpu(e->params[5]), 1034fda8b18cSHariprasad Shenai be32_to_cpu(e->params[6]), 1035fda8b18cSHariprasad Shenai be32_to_cpu(e->params[7])); 103649aa284fSHariprasad Shenai } 103749aa284fSHariprasad Shenai return 0; 103849aa284fSHariprasad Shenai } 103949aa284fSHariprasad Shenai 104049aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 104149aa284fSHariprasad Shenai */ 104249aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 104349aa284fSHariprasad Shenai { 104449aa284fSHariprasad Shenai if (pos > dinfo->nentries) 104549aa284fSHariprasad Shenai return NULL; 104649aa284fSHariprasad Shenai 104749aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 104849aa284fSHariprasad Shenai } 104949aa284fSHariprasad Shenai 105049aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 105149aa284fSHariprasad Shenai { 105249aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 105349aa284fSHariprasad Shenai 105449aa284fSHariprasad Shenai return (*pos 105549aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 105649aa284fSHariprasad Shenai : SEQ_START_TOKEN); 105749aa284fSHariprasad Shenai } 105849aa284fSHariprasad Shenai 105949aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 106049aa284fSHariprasad Shenai { 106149aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 106249aa284fSHariprasad Shenai 106349aa284fSHariprasad Shenai (*pos)++; 106449aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 106549aa284fSHariprasad Shenai } 106649aa284fSHariprasad Shenai 106749aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 106849aa284fSHariprasad Shenai { 106949aa284fSHariprasad Shenai } 107049aa284fSHariprasad Shenai 107149aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 107249aa284fSHariprasad Shenai .start = devlog_start, 107349aa284fSHariprasad Shenai .next = devlog_next, 107449aa284fSHariprasad Shenai .stop = devlog_stop, 107549aa284fSHariprasad Shenai .show = devlog_show 107649aa284fSHariprasad Shenai }; 107749aa284fSHariprasad Shenai 107849aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 107949aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 108049aa284fSHariprasad Shenai */ 108149aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 108249aa284fSHariprasad Shenai { 108349aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 108449aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 108549aa284fSHariprasad Shenai struct devlog_info *dinfo; 108649aa284fSHariprasad Shenai unsigned int index; 108749aa284fSHariprasad Shenai u32 fseqno; 108849aa284fSHariprasad Shenai int ret; 108949aa284fSHariprasad Shenai 109049aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 109149aa284fSHariprasad Shenai */ 109249aa284fSHariprasad Shenai if (dparams->start == 0) 109349aa284fSHariprasad Shenai return -ENXIO; 109449aa284fSHariprasad Shenai 109549aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 109649aa284fSHariprasad Shenai * for the iterated call to our display function. 109749aa284fSHariprasad Shenai */ 109849aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 109949aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 110049aa284fSHariprasad Shenai if (!dinfo) 110149aa284fSHariprasad Shenai return -ENOMEM; 110249aa284fSHariprasad Shenai 110349aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 110449aa284fSHariprasad Shenai */ 110549aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 110649aa284fSHariprasad Shenai dinfo->first = 0; 110749aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 110849aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 110949aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 111049aa284fSHariprasad Shenai T4_MEMORY_READ); 111149aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 111249aa284fSHariprasad Shenai if (ret) { 111349aa284fSHariprasad Shenai seq_release_private(inode, file); 111449aa284fSHariprasad Shenai return ret; 111549aa284fSHariprasad Shenai } 111649aa284fSHariprasad Shenai 1117fda8b18cSHariprasad Shenai /* Find the earliest (lowest Sequence Number) log entry in the 1118fda8b18cSHariprasad Shenai * circular Device Log. 111949aa284fSHariprasad Shenai */ 112049aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 112149aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 112249aa284fSHariprasad Shenai __u32 seqno; 112349aa284fSHariprasad Shenai 112449aa284fSHariprasad Shenai if (e->timestamp == 0) 112549aa284fSHariprasad Shenai continue; 112649aa284fSHariprasad Shenai 112749aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 112849aa284fSHariprasad Shenai if (seqno < fseqno) { 112949aa284fSHariprasad Shenai fseqno = seqno; 113049aa284fSHariprasad Shenai dinfo->first = index; 113149aa284fSHariprasad Shenai } 113249aa284fSHariprasad Shenai } 113349aa284fSHariprasad Shenai return 0; 113449aa284fSHariprasad Shenai } 113549aa284fSHariprasad Shenai 113649aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 113749aa284fSHariprasad Shenai .owner = THIS_MODULE, 113849aa284fSHariprasad Shenai .open = devlog_open, 113949aa284fSHariprasad Shenai .read = seq_read, 114049aa284fSHariprasad Shenai .llseek = seq_lseek, 114149aa284fSHariprasad Shenai .release = seq_release_private 114249aa284fSHariprasad Shenai }; 114349aa284fSHariprasad Shenai 11447f080c3fSHariprasad Shenai /* Show Firmware Mailbox Command/Reply Log 11457f080c3fSHariprasad Shenai * 11467f080c3fSHariprasad Shenai * Note that we don't do any locking when dumping the Firmware Mailbox Log so 11477f080c3fSHariprasad Shenai * it's possible that we can catch things during a log update and therefore 11487f080c3fSHariprasad Shenai * see partially corrupted log entries. But it's probably Good Enough(tm). 11497f080c3fSHariprasad Shenai * If we ever decide that we want to make sure that we're dumping a coherent 11507f080c3fSHariprasad Shenai * log, we'd need to perform locking in the mailbox logging and in 11517f080c3fSHariprasad Shenai * mboxlog_open() where we'd need to grab the entire mailbox log in one go 11527f080c3fSHariprasad Shenai * like we do for the Firmware Device Log. 11537f080c3fSHariprasad Shenai */ 11547f080c3fSHariprasad Shenai static int mboxlog_show(struct seq_file *seq, void *v) 11557f080c3fSHariprasad Shenai { 11567f080c3fSHariprasad Shenai struct adapter *adapter = seq->private; 11577f080c3fSHariprasad Shenai struct mbox_cmd_log *log = adapter->mbox_log; 11587f080c3fSHariprasad Shenai struct mbox_cmd *entry; 11597f080c3fSHariprasad Shenai int entry_idx, i; 11607f080c3fSHariprasad Shenai 11617f080c3fSHariprasad Shenai if (v == SEQ_START_TOKEN) { 11627f080c3fSHariprasad Shenai seq_printf(seq, 11637f080c3fSHariprasad Shenai "%10s %15s %5s %5s %s\n", 11647f080c3fSHariprasad Shenai "Seq#", "Tstamp", "Atime", "Etime", 11657f080c3fSHariprasad Shenai "Command/Reply"); 11667f080c3fSHariprasad Shenai return 0; 11677f080c3fSHariprasad Shenai } 11687f080c3fSHariprasad Shenai 11697f080c3fSHariprasad Shenai entry_idx = log->cursor + ((uintptr_t)v - 2); 11707f080c3fSHariprasad Shenai if (entry_idx >= log->size) 11717f080c3fSHariprasad Shenai entry_idx -= log->size; 11727f080c3fSHariprasad Shenai entry = mbox_cmd_log_entry(log, entry_idx); 11737f080c3fSHariprasad Shenai 11747f080c3fSHariprasad Shenai /* skip over unused entries */ 11757f080c3fSHariprasad Shenai if (entry->timestamp == 0) 11767f080c3fSHariprasad Shenai return 0; 11777f080c3fSHariprasad Shenai 11787f080c3fSHariprasad Shenai seq_printf(seq, "%10u %15llu %5d %5d", 11797f080c3fSHariprasad Shenai entry->seqno, entry->timestamp, 11807f080c3fSHariprasad Shenai entry->access, entry->execute); 11817f080c3fSHariprasad Shenai for (i = 0; i < MBOX_LEN / 8; i++) { 11827f080c3fSHariprasad Shenai u64 flit = entry->cmd[i]; 11837f080c3fSHariprasad Shenai u32 hi = (u32)(flit >> 32); 11847f080c3fSHariprasad Shenai u32 lo = (u32)flit; 11857f080c3fSHariprasad Shenai 11867f080c3fSHariprasad Shenai seq_printf(seq, " %08x %08x", hi, lo); 11877f080c3fSHariprasad Shenai } 11887f080c3fSHariprasad Shenai seq_puts(seq, "\n"); 11897f080c3fSHariprasad Shenai return 0; 11907f080c3fSHariprasad Shenai } 11917f080c3fSHariprasad Shenai 11927f080c3fSHariprasad Shenai static inline void *mboxlog_get_idx(struct seq_file *seq, loff_t pos) 11937f080c3fSHariprasad Shenai { 11947f080c3fSHariprasad Shenai struct adapter *adapter = seq->private; 11957f080c3fSHariprasad Shenai struct mbox_cmd_log *log = adapter->mbox_log; 11967f080c3fSHariprasad Shenai 11977f080c3fSHariprasad Shenai return ((pos <= log->size) ? (void *)(uintptr_t)(pos + 1) : NULL); 11987f080c3fSHariprasad Shenai } 11997f080c3fSHariprasad Shenai 12007f080c3fSHariprasad Shenai static void *mboxlog_start(struct seq_file *seq, loff_t *pos) 12017f080c3fSHariprasad Shenai { 12027f080c3fSHariprasad Shenai return *pos ? mboxlog_get_idx(seq, *pos) : SEQ_START_TOKEN; 12037f080c3fSHariprasad Shenai } 12047f080c3fSHariprasad Shenai 12057f080c3fSHariprasad Shenai static void *mboxlog_next(struct seq_file *seq, void *v, loff_t *pos) 12067f080c3fSHariprasad Shenai { 12077f080c3fSHariprasad Shenai ++*pos; 12087f080c3fSHariprasad Shenai return mboxlog_get_idx(seq, *pos); 12097f080c3fSHariprasad Shenai } 12107f080c3fSHariprasad Shenai 12117f080c3fSHariprasad Shenai static void mboxlog_stop(struct seq_file *seq, void *v) 12127f080c3fSHariprasad Shenai { 12137f080c3fSHariprasad Shenai } 12147f080c3fSHariprasad Shenai 12157f080c3fSHariprasad Shenai static const struct seq_operations mboxlog_seq_ops = { 12167f080c3fSHariprasad Shenai .start = mboxlog_start, 12177f080c3fSHariprasad Shenai .next = mboxlog_next, 12187f080c3fSHariprasad Shenai .stop = mboxlog_stop, 12197f080c3fSHariprasad Shenai .show = mboxlog_show 12207f080c3fSHariprasad Shenai }; 12217f080c3fSHariprasad Shenai 12227f080c3fSHariprasad Shenai static int mboxlog_open(struct inode *inode, struct file *file) 12237f080c3fSHariprasad Shenai { 12247f080c3fSHariprasad Shenai int res = seq_open(file, &mboxlog_seq_ops); 12257f080c3fSHariprasad Shenai 12267f080c3fSHariprasad Shenai if (!res) { 12277f080c3fSHariprasad Shenai struct seq_file *seq = file->private_data; 12287f080c3fSHariprasad Shenai 12297f080c3fSHariprasad Shenai seq->private = inode->i_private; 12307f080c3fSHariprasad Shenai } 12317f080c3fSHariprasad Shenai return res; 12327f080c3fSHariprasad Shenai } 12337f080c3fSHariprasad Shenai 12347f080c3fSHariprasad Shenai static const struct file_operations mboxlog_fops = { 12357f080c3fSHariprasad Shenai .owner = THIS_MODULE, 12367f080c3fSHariprasad Shenai .open = mboxlog_open, 12377f080c3fSHariprasad Shenai .read = seq_read, 12387f080c3fSHariprasad Shenai .llseek = seq_lseek, 12397f080c3fSHariprasad Shenai .release = seq_release, 12407f080c3fSHariprasad Shenai }; 12417f080c3fSHariprasad Shenai 1242bf7c781dSHariprasad Shenai static int mbox_show(struct seq_file *seq, void *v) 1243bf7c781dSHariprasad Shenai { 1244bf7c781dSHariprasad Shenai static const char * const owner[] = { "none", "FW", "driver", 1245b3695540SHariprasad Shenai "unknown", "<unread>" }; 1246bf7c781dSHariprasad Shenai 1247bf7c781dSHariprasad Shenai int i; 1248bf7c781dSHariprasad Shenai unsigned int mbox = (uintptr_t)seq->private & 7; 1249bf7c781dSHariprasad Shenai struct adapter *adap = seq->private - mbox; 1250bf7c781dSHariprasad Shenai void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 1251b3695540SHariprasad Shenai 1252b3695540SHariprasad Shenai /* For T4 we don't have a shadow copy of the Mailbox Control register. 1253b3695540SHariprasad Shenai * And since reading that real register causes a side effect of 1254b3695540SHariprasad Shenai * granting ownership, we're best of simply not reading it at all. 1255b3695540SHariprasad Shenai */ 1256b3695540SHariprasad Shenai if (is_t4(adap->params.chip)) { 1257b3695540SHariprasad Shenai i = 4; /* index of "<unread>" */ 1258b3695540SHariprasad Shenai } else { 1259b3695540SHariprasad Shenai unsigned int ctrl_reg = CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A; 1260bf7c781dSHariprasad Shenai void __iomem *ctrl = adap->regs + PF_REG(mbox, ctrl_reg); 1261bf7c781dSHariprasad Shenai 1262bf7c781dSHariprasad Shenai i = MBOWNER_G(readl(ctrl)); 1263b3695540SHariprasad Shenai } 1264b3695540SHariprasad Shenai 1265bf7c781dSHariprasad Shenai seq_printf(seq, "mailbox owned by %s\n\n", owner[i]); 1266bf7c781dSHariprasad Shenai 1267bf7c781dSHariprasad Shenai for (i = 0; i < MBOX_LEN; i += 8) 1268bf7c781dSHariprasad Shenai seq_printf(seq, "%016llx\n", 1269bf7c781dSHariprasad Shenai (unsigned long long)readq(addr + i)); 1270bf7c781dSHariprasad Shenai return 0; 1271bf7c781dSHariprasad Shenai } 1272bf7c781dSHariprasad Shenai 1273bf7c781dSHariprasad Shenai static int mbox_open(struct inode *inode, struct file *file) 1274bf7c781dSHariprasad Shenai { 1275bf7c781dSHariprasad Shenai return single_open(file, mbox_show, inode->i_private); 1276bf7c781dSHariprasad Shenai } 1277bf7c781dSHariprasad Shenai 1278bf7c781dSHariprasad Shenai static ssize_t mbox_write(struct file *file, const char __user *buf, 1279bf7c781dSHariprasad Shenai size_t count, loff_t *pos) 1280bf7c781dSHariprasad Shenai { 1281bf7c781dSHariprasad Shenai int i; 1282bf7c781dSHariprasad Shenai char c = '\n', s[256]; 1283bf7c781dSHariprasad Shenai unsigned long long data[8]; 1284bf7c781dSHariprasad Shenai const struct inode *ino; 1285bf7c781dSHariprasad Shenai unsigned int mbox; 1286bf7c781dSHariprasad Shenai struct adapter *adap; 1287bf7c781dSHariprasad Shenai void __iomem *addr; 1288bf7c781dSHariprasad Shenai void __iomem *ctrl; 1289bf7c781dSHariprasad Shenai 1290bf7c781dSHariprasad Shenai if (count > sizeof(s) - 1 || !count) 1291bf7c781dSHariprasad Shenai return -EINVAL; 1292bf7c781dSHariprasad Shenai if (copy_from_user(s, buf, count)) 1293bf7c781dSHariprasad Shenai return -EFAULT; 1294bf7c781dSHariprasad Shenai s[count] = '\0'; 1295bf7c781dSHariprasad Shenai 1296bf7c781dSHariprasad Shenai if (sscanf(s, "%llx %llx %llx %llx %llx %llx %llx %llx%c", &data[0], 1297bf7c781dSHariprasad Shenai &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], 1298bf7c781dSHariprasad Shenai &data[7], &c) < 8 || c != '\n') 1299bf7c781dSHariprasad Shenai return -EINVAL; 1300bf7c781dSHariprasad Shenai 1301c1d81b1cSDavid Howells ino = file_inode(file); 1302bf7c781dSHariprasad Shenai mbox = (uintptr_t)ino->i_private & 7; 1303bf7c781dSHariprasad Shenai adap = ino->i_private - mbox; 1304bf7c781dSHariprasad Shenai addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 1305bf7c781dSHariprasad Shenai ctrl = addr + MBOX_LEN; 1306bf7c781dSHariprasad Shenai 1307bf7c781dSHariprasad Shenai if (MBOWNER_G(readl(ctrl)) != X_MBOWNER_PL) 1308bf7c781dSHariprasad Shenai return -EBUSY; 1309bf7c781dSHariprasad Shenai 1310bf7c781dSHariprasad Shenai for (i = 0; i < 8; i++) 1311bf7c781dSHariprasad Shenai writeq(data[i], addr + 8 * i); 1312bf7c781dSHariprasad Shenai 1313bf7c781dSHariprasad Shenai writel(MBMSGVALID_F | MBOWNER_V(X_MBOWNER_FW), ctrl); 1314bf7c781dSHariprasad Shenai return count; 1315bf7c781dSHariprasad Shenai } 1316bf7c781dSHariprasad Shenai 1317bf7c781dSHariprasad Shenai static const struct file_operations mbox_debugfs_fops = { 1318bf7c781dSHariprasad Shenai .owner = THIS_MODULE, 1319bf7c781dSHariprasad Shenai .open = mbox_open, 1320bf7c781dSHariprasad Shenai .read = seq_read, 1321bf7c781dSHariprasad Shenai .llseek = seq_lseek, 1322bf7c781dSHariprasad Shenai .release = single_release, 1323bf7c781dSHariprasad Shenai .write = mbox_write 1324bf7c781dSHariprasad Shenai }; 1325bf7c781dSHariprasad Shenai 13268e3d04fdSHariprasad Shenai static int mps_trc_show(struct seq_file *seq, void *v) 13278e3d04fdSHariprasad Shenai { 13288e3d04fdSHariprasad Shenai int enabled, i; 13298e3d04fdSHariprasad Shenai struct trace_params tp; 13308e3d04fdSHariprasad Shenai unsigned int trcidx = (uintptr_t)seq->private & 3; 13318e3d04fdSHariprasad Shenai struct adapter *adap = seq->private - trcidx; 13328e3d04fdSHariprasad Shenai 13338e3d04fdSHariprasad Shenai t4_get_trace_filter(adap, &tp, trcidx, &enabled); 13348e3d04fdSHariprasad Shenai if (!enabled) { 13358e3d04fdSHariprasad Shenai seq_puts(seq, "tracer is disabled\n"); 13368e3d04fdSHariprasad Shenai return 0; 13378e3d04fdSHariprasad Shenai } 13388e3d04fdSHariprasad Shenai 13398e3d04fdSHariprasad Shenai if (tp.skip_ofst * 8 >= TRACE_LEN) { 13408e3d04fdSHariprasad Shenai dev_err(adap->pdev_dev, "illegal trace pattern skip offset\n"); 13418e3d04fdSHariprasad Shenai return -EINVAL; 13428e3d04fdSHariprasad Shenai } 13438e3d04fdSHariprasad Shenai if (tp.port < 8) { 13448e3d04fdSHariprasad Shenai i = adap->chan_map[tp.port & 3]; 13458e3d04fdSHariprasad Shenai if (i >= MAX_NPORTS) { 13468e3d04fdSHariprasad Shenai dev_err(adap->pdev_dev, "tracer %u is assigned " 13478e3d04fdSHariprasad Shenai "to non-existing port\n", trcidx); 13488e3d04fdSHariprasad Shenai return -EINVAL; 13498e3d04fdSHariprasad Shenai } 13508e3d04fdSHariprasad Shenai seq_printf(seq, "tracer is capturing %s %s, ", 13518e3d04fdSHariprasad Shenai adap->port[i]->name, tp.port < 4 ? "Rx" : "Tx"); 13528e3d04fdSHariprasad Shenai } else 13538e3d04fdSHariprasad Shenai seq_printf(seq, "tracer is capturing loopback %d, ", 13548e3d04fdSHariprasad Shenai tp.port - 8); 13558e3d04fdSHariprasad Shenai seq_printf(seq, "snap length: %u, min length: %u\n", tp.snap_len, 13568e3d04fdSHariprasad Shenai tp.min_len); 13578e3d04fdSHariprasad Shenai seq_printf(seq, "packets captured %smatch filter\n", 13588e3d04fdSHariprasad Shenai tp.invert ? "do not " : ""); 13598e3d04fdSHariprasad Shenai 13608e3d04fdSHariprasad Shenai if (tp.skip_ofst) { 13618e3d04fdSHariprasad Shenai seq_puts(seq, "filter pattern: "); 13628e3d04fdSHariprasad Shenai for (i = 0; i < tp.skip_ofst * 2; i += 2) 13638e3d04fdSHariprasad Shenai seq_printf(seq, "%08x%08x", tp.data[i], tp.data[i + 1]); 13648e3d04fdSHariprasad Shenai seq_putc(seq, '/'); 13658e3d04fdSHariprasad Shenai for (i = 0; i < tp.skip_ofst * 2; i += 2) 13668e3d04fdSHariprasad Shenai seq_printf(seq, "%08x%08x", tp.mask[i], tp.mask[i + 1]); 13678e3d04fdSHariprasad Shenai seq_puts(seq, "@0\n"); 13688e3d04fdSHariprasad Shenai } 13698e3d04fdSHariprasad Shenai 13708e3d04fdSHariprasad Shenai seq_puts(seq, "filter pattern: "); 13718e3d04fdSHariprasad Shenai for (i = tp.skip_ofst * 2; i < TRACE_LEN / 4; i += 2) 13728e3d04fdSHariprasad Shenai seq_printf(seq, "%08x%08x", tp.data[i], tp.data[i + 1]); 13738e3d04fdSHariprasad Shenai seq_putc(seq, '/'); 13748e3d04fdSHariprasad Shenai for (i = tp.skip_ofst * 2; i < TRACE_LEN / 4; i += 2) 13758e3d04fdSHariprasad Shenai seq_printf(seq, "%08x%08x", tp.mask[i], tp.mask[i + 1]); 13768e3d04fdSHariprasad Shenai seq_printf(seq, "@%u\n", (tp.skip_ofst + tp.skip_len) * 8); 13778e3d04fdSHariprasad Shenai return 0; 13788e3d04fdSHariprasad Shenai } 13798e3d04fdSHariprasad Shenai 13808e3d04fdSHariprasad Shenai static int mps_trc_open(struct inode *inode, struct file *file) 13818e3d04fdSHariprasad Shenai { 13828e3d04fdSHariprasad Shenai return single_open(file, mps_trc_show, inode->i_private); 13838e3d04fdSHariprasad Shenai } 13848e3d04fdSHariprasad Shenai 13858e3d04fdSHariprasad Shenai static unsigned int xdigit2int(unsigned char c) 13868e3d04fdSHariprasad Shenai { 13878e3d04fdSHariprasad Shenai return isdigit(c) ? c - '0' : tolower(c) - 'a' + 10; 13888e3d04fdSHariprasad Shenai } 13898e3d04fdSHariprasad Shenai 13908e3d04fdSHariprasad Shenai #define TRC_PORT_NONE 0xff 13918e3d04fdSHariprasad Shenai #define TRC_RSS_ENABLE 0x33 13928e3d04fdSHariprasad Shenai #define TRC_RSS_DISABLE 0x13 13938e3d04fdSHariprasad Shenai 13948e3d04fdSHariprasad Shenai /* Set an MPS trace filter. Syntax is: 13958e3d04fdSHariprasad Shenai * 13968e3d04fdSHariprasad Shenai * disable 13978e3d04fdSHariprasad Shenai * 13988e3d04fdSHariprasad Shenai * to disable tracing, or 13998e3d04fdSHariprasad Shenai * 14008e3d04fdSHariprasad Shenai * interface qid=<qid no> [snaplen=<val>] [minlen=<val>] [not] [<pattern>]... 14018e3d04fdSHariprasad Shenai * 14028e3d04fdSHariprasad Shenai * where interface is one of rxN, txN, or loopbackN, N = 0..3, qid can be one 14038e3d04fdSHariprasad Shenai * of the NIC's response qid obtained from sge_qinfo and pattern has the form 14048e3d04fdSHariprasad Shenai * 14058e3d04fdSHariprasad Shenai * <pattern data>[/<pattern mask>][@<anchor>] 14068e3d04fdSHariprasad Shenai * 14078e3d04fdSHariprasad Shenai * Up to 2 filter patterns can be specified. If 2 are supplied the first one 14080cf2a848SMasahiro Yamada * must be anchored at 0. An omitted mask is taken as a mask of 1s, an omitted 14098e3d04fdSHariprasad Shenai * anchor is taken as 0. 14108e3d04fdSHariprasad Shenai */ 14118e3d04fdSHariprasad Shenai static ssize_t mps_trc_write(struct file *file, const char __user *buf, 14128e3d04fdSHariprasad Shenai size_t count, loff_t *pos) 14138e3d04fdSHariprasad Shenai { 1414c938a003SDan Carpenter int i, enable, ret; 14158e3d04fdSHariprasad Shenai u32 *data, *mask; 14168e3d04fdSHariprasad Shenai struct trace_params tp; 14178e3d04fdSHariprasad Shenai const struct inode *ino; 14188e3d04fdSHariprasad Shenai unsigned int trcidx; 14198e3d04fdSHariprasad Shenai char *s, *p, *word, *end; 14208e3d04fdSHariprasad Shenai struct adapter *adap; 1421c938a003SDan Carpenter u32 j; 14228e3d04fdSHariprasad Shenai 14238e3d04fdSHariprasad Shenai ino = file_inode(file); 14248e3d04fdSHariprasad Shenai trcidx = (uintptr_t)ino->i_private & 3; 14258e3d04fdSHariprasad Shenai adap = ino->i_private - trcidx; 14268e3d04fdSHariprasad Shenai 14278e3d04fdSHariprasad Shenai /* Don't accept input more than 1K, can't be anything valid except lots 14288e3d04fdSHariprasad Shenai * of whitespace. Well, use less. 14298e3d04fdSHariprasad Shenai */ 14308e3d04fdSHariprasad Shenai if (count > 1024) 14318e3d04fdSHariprasad Shenai return -EFBIG; 14328e3d04fdSHariprasad Shenai p = s = kzalloc(count + 1, GFP_USER); 14338e3d04fdSHariprasad Shenai if (!s) 14348e3d04fdSHariprasad Shenai return -ENOMEM; 14358e3d04fdSHariprasad Shenai if (copy_from_user(s, buf, count)) { 14368e3d04fdSHariprasad Shenai count = -EFAULT; 14378e3d04fdSHariprasad Shenai goto out; 14388e3d04fdSHariprasad Shenai } 14398e3d04fdSHariprasad Shenai 14408e3d04fdSHariprasad Shenai if (s[count - 1] == '\n') 14418e3d04fdSHariprasad Shenai s[count - 1] = '\0'; 14428e3d04fdSHariprasad Shenai 14438e3d04fdSHariprasad Shenai enable = strcmp("disable", s) != 0; 14448e3d04fdSHariprasad Shenai if (!enable) 14458e3d04fdSHariprasad Shenai goto apply; 14468e3d04fdSHariprasad Shenai 14478e3d04fdSHariprasad Shenai /* enable or disable trace multi rss filter */ 14488e3d04fdSHariprasad Shenai if (adap->trace_rss) 14498e3d04fdSHariprasad Shenai t4_write_reg(adap, MPS_TRC_CFG_A, TRC_RSS_ENABLE); 14508e3d04fdSHariprasad Shenai else 14518e3d04fdSHariprasad Shenai t4_write_reg(adap, MPS_TRC_CFG_A, TRC_RSS_DISABLE); 14528e3d04fdSHariprasad Shenai 14538e3d04fdSHariprasad Shenai memset(&tp, 0, sizeof(tp)); 14548e3d04fdSHariprasad Shenai tp.port = TRC_PORT_NONE; 14558e3d04fdSHariprasad Shenai i = 0; /* counts pattern nibbles */ 14568e3d04fdSHariprasad Shenai 14578e3d04fdSHariprasad Shenai while (p) { 14588e3d04fdSHariprasad Shenai while (isspace(*p)) 14598e3d04fdSHariprasad Shenai p++; 14608e3d04fdSHariprasad Shenai word = strsep(&p, " "); 14618e3d04fdSHariprasad Shenai if (!*word) 14628e3d04fdSHariprasad Shenai break; 14638e3d04fdSHariprasad Shenai 14648e3d04fdSHariprasad Shenai if (!strncmp(word, "qid=", 4)) { 14658e3d04fdSHariprasad Shenai end = (char *)word + 4; 1466c938a003SDan Carpenter ret = kstrtouint(end, 10, &j); 14678e3d04fdSHariprasad Shenai if (ret) 14688e3d04fdSHariprasad Shenai goto out; 14698e3d04fdSHariprasad Shenai if (!adap->trace_rss) { 14708e3d04fdSHariprasad Shenai t4_write_reg(adap, MPS_T5_TRC_RSS_CONTROL_A, j); 14718e3d04fdSHariprasad Shenai continue; 14728e3d04fdSHariprasad Shenai } 14738e3d04fdSHariprasad Shenai 14748e3d04fdSHariprasad Shenai switch (trcidx) { 14758e3d04fdSHariprasad Shenai case 0: 14768e3d04fdSHariprasad Shenai t4_write_reg(adap, MPS_TRC_RSS_CONTROL_A, j); 14778e3d04fdSHariprasad Shenai break; 14788e3d04fdSHariprasad Shenai case 1: 14798e3d04fdSHariprasad Shenai t4_write_reg(adap, 14808e3d04fdSHariprasad Shenai MPS_TRC_FILTER1_RSS_CONTROL_A, j); 14818e3d04fdSHariprasad Shenai break; 14828e3d04fdSHariprasad Shenai case 2: 14838e3d04fdSHariprasad Shenai t4_write_reg(adap, 14848e3d04fdSHariprasad Shenai MPS_TRC_FILTER2_RSS_CONTROL_A, j); 14858e3d04fdSHariprasad Shenai break; 14868e3d04fdSHariprasad Shenai case 3: 14878e3d04fdSHariprasad Shenai t4_write_reg(adap, 14888e3d04fdSHariprasad Shenai MPS_TRC_FILTER3_RSS_CONTROL_A, j); 14898e3d04fdSHariprasad Shenai break; 14908e3d04fdSHariprasad Shenai } 14918e3d04fdSHariprasad Shenai continue; 14928e3d04fdSHariprasad Shenai } 14938e3d04fdSHariprasad Shenai if (!strncmp(word, "snaplen=", 8)) { 14948e3d04fdSHariprasad Shenai end = (char *)word + 8; 1495c938a003SDan Carpenter ret = kstrtouint(end, 10, &j); 14968e3d04fdSHariprasad Shenai if (ret || j > 9600) { 14978e3d04fdSHariprasad Shenai inval: count = -EINVAL; 14988e3d04fdSHariprasad Shenai goto out; 14998e3d04fdSHariprasad Shenai } 15008e3d04fdSHariprasad Shenai tp.snap_len = j; 15018e3d04fdSHariprasad Shenai continue; 15028e3d04fdSHariprasad Shenai } 15038e3d04fdSHariprasad Shenai if (!strncmp(word, "minlen=", 7)) { 15048e3d04fdSHariprasad Shenai end = (char *)word + 7; 1505c938a003SDan Carpenter ret = kstrtouint(end, 10, &j); 15068e3d04fdSHariprasad Shenai if (ret || j > TFMINPKTSIZE_M) 15078e3d04fdSHariprasad Shenai goto inval; 15088e3d04fdSHariprasad Shenai tp.min_len = j; 15098e3d04fdSHariprasad Shenai continue; 15108e3d04fdSHariprasad Shenai } 15118e3d04fdSHariprasad Shenai if (!strcmp(word, "not")) { 15128e3d04fdSHariprasad Shenai tp.invert = !tp.invert; 15138e3d04fdSHariprasad Shenai continue; 15148e3d04fdSHariprasad Shenai } 15158e3d04fdSHariprasad Shenai if (!strncmp(word, "loopback", 8) && tp.port == TRC_PORT_NONE) { 15168e3d04fdSHariprasad Shenai if (word[8] < '0' || word[8] > '3' || word[9]) 15178e3d04fdSHariprasad Shenai goto inval; 15188e3d04fdSHariprasad Shenai tp.port = word[8] - '0' + 8; 15198e3d04fdSHariprasad Shenai continue; 15208e3d04fdSHariprasad Shenai } 15218e3d04fdSHariprasad Shenai if (!strncmp(word, "tx", 2) && tp.port == TRC_PORT_NONE) { 15228e3d04fdSHariprasad Shenai if (word[2] < '0' || word[2] > '3' || word[3]) 15238e3d04fdSHariprasad Shenai goto inval; 15248e3d04fdSHariprasad Shenai tp.port = word[2] - '0' + 4; 15258e3d04fdSHariprasad Shenai if (adap->chan_map[tp.port & 3] >= MAX_NPORTS) 15268e3d04fdSHariprasad Shenai goto inval; 15278e3d04fdSHariprasad Shenai continue; 15288e3d04fdSHariprasad Shenai } 15298e3d04fdSHariprasad Shenai if (!strncmp(word, "rx", 2) && tp.port == TRC_PORT_NONE) { 15308e3d04fdSHariprasad Shenai if (word[2] < '0' || word[2] > '3' || word[3]) 15318e3d04fdSHariprasad Shenai goto inval; 15328e3d04fdSHariprasad Shenai tp.port = word[2] - '0'; 15338e3d04fdSHariprasad Shenai if (adap->chan_map[tp.port] >= MAX_NPORTS) 15348e3d04fdSHariprasad Shenai goto inval; 15358e3d04fdSHariprasad Shenai continue; 15368e3d04fdSHariprasad Shenai } 15378e3d04fdSHariprasad Shenai if (!isxdigit(*word)) 15388e3d04fdSHariprasad Shenai goto inval; 15398e3d04fdSHariprasad Shenai 15408e3d04fdSHariprasad Shenai /* we have found a trace pattern */ 15418e3d04fdSHariprasad Shenai if (i) { /* split pattern */ 15428e3d04fdSHariprasad Shenai if (tp.skip_len) /* too many splits */ 15438e3d04fdSHariprasad Shenai goto inval; 15448e3d04fdSHariprasad Shenai tp.skip_ofst = i / 16; 15458e3d04fdSHariprasad Shenai } 15468e3d04fdSHariprasad Shenai 15478e3d04fdSHariprasad Shenai data = &tp.data[i / 8]; 15488e3d04fdSHariprasad Shenai mask = &tp.mask[i / 8]; 15498e3d04fdSHariprasad Shenai j = i; 15508e3d04fdSHariprasad Shenai 15518e3d04fdSHariprasad Shenai while (isxdigit(*word)) { 15528e3d04fdSHariprasad Shenai if (i >= TRACE_LEN * 2) { 15538e3d04fdSHariprasad Shenai count = -EFBIG; 15548e3d04fdSHariprasad Shenai goto out; 15558e3d04fdSHariprasad Shenai } 15568e3d04fdSHariprasad Shenai *data = (*data << 4) + xdigit2int(*word++); 15578e3d04fdSHariprasad Shenai if (++i % 8 == 0) 15588e3d04fdSHariprasad Shenai data++; 15598e3d04fdSHariprasad Shenai } 15608e3d04fdSHariprasad Shenai if (*word == '/') { 15618e3d04fdSHariprasad Shenai word++; 15628e3d04fdSHariprasad Shenai while (isxdigit(*word)) { 15638e3d04fdSHariprasad Shenai if (j >= i) /* mask longer than data */ 15648e3d04fdSHariprasad Shenai goto inval; 15658e3d04fdSHariprasad Shenai *mask = (*mask << 4) + xdigit2int(*word++); 15668e3d04fdSHariprasad Shenai if (++j % 8 == 0) 15678e3d04fdSHariprasad Shenai mask++; 15688e3d04fdSHariprasad Shenai } 15698e3d04fdSHariprasad Shenai if (i != j) /* mask shorter than data */ 15708e3d04fdSHariprasad Shenai goto inval; 15718e3d04fdSHariprasad Shenai } else { /* no mask, use all 1s */ 15728e3d04fdSHariprasad Shenai for ( ; i - j >= 8; j += 8) 15738e3d04fdSHariprasad Shenai *mask++ = 0xffffffff; 15748e3d04fdSHariprasad Shenai if (i % 8) 15758e3d04fdSHariprasad Shenai *mask = (1 << (i % 8) * 4) - 1; 15768e3d04fdSHariprasad Shenai } 15778e3d04fdSHariprasad Shenai if (*word == '@') { 15788e3d04fdSHariprasad Shenai end = (char *)word + 1; 1579c938a003SDan Carpenter ret = kstrtouint(end, 10, &j); 15808e3d04fdSHariprasad Shenai if (*end && *end != '\n') 15818e3d04fdSHariprasad Shenai goto inval; 15828e3d04fdSHariprasad Shenai if (j & 7) /* doesn't start at multiple of 8 */ 15838e3d04fdSHariprasad Shenai goto inval; 15848e3d04fdSHariprasad Shenai j /= 8; 15858e3d04fdSHariprasad Shenai if (j < tp.skip_ofst) /* overlaps earlier pattern */ 15868e3d04fdSHariprasad Shenai goto inval; 15878e3d04fdSHariprasad Shenai if (j - tp.skip_ofst > 31) /* skip too big */ 15888e3d04fdSHariprasad Shenai goto inval; 15898e3d04fdSHariprasad Shenai tp.skip_len = j - tp.skip_ofst; 15908e3d04fdSHariprasad Shenai } 15918e3d04fdSHariprasad Shenai if (i % 8) { 15928e3d04fdSHariprasad Shenai *data <<= (8 - i % 8) * 4; 15938e3d04fdSHariprasad Shenai *mask <<= (8 - i % 8) * 4; 15948e3d04fdSHariprasad Shenai i = (i + 15) & ~15; /* 8-byte align */ 15958e3d04fdSHariprasad Shenai } 15968e3d04fdSHariprasad Shenai } 15978e3d04fdSHariprasad Shenai 15988e3d04fdSHariprasad Shenai if (tp.port == TRC_PORT_NONE) 15998e3d04fdSHariprasad Shenai goto inval; 16008e3d04fdSHariprasad Shenai 16018e3d04fdSHariprasad Shenai apply: 16028e3d04fdSHariprasad Shenai i = t4_set_trace_filter(adap, &tp, trcidx, enable); 16038e3d04fdSHariprasad Shenai if (i) 16048e3d04fdSHariprasad Shenai count = i; 16058e3d04fdSHariprasad Shenai out: 16068e3d04fdSHariprasad Shenai kfree(s); 16078e3d04fdSHariprasad Shenai return count; 16088e3d04fdSHariprasad Shenai } 16098e3d04fdSHariprasad Shenai 16108e3d04fdSHariprasad Shenai static const struct file_operations mps_trc_debugfs_fops = { 16118e3d04fdSHariprasad Shenai .owner = THIS_MODULE, 16128e3d04fdSHariprasad Shenai .open = mps_trc_open, 16138e3d04fdSHariprasad Shenai .read = seq_read, 16148e3d04fdSHariprasad Shenai .llseek = seq_lseek, 16158e3d04fdSHariprasad Shenai .release = single_release, 16168e3d04fdSHariprasad Shenai .write = mps_trc_write 16178e3d04fdSHariprasad Shenai }; 16188e3d04fdSHariprasad Shenai 161949216c1cSHariprasad Shenai static ssize_t flash_read(struct file *file, char __user *buf, size_t count, 162049216c1cSHariprasad Shenai loff_t *ppos) 162149216c1cSHariprasad Shenai { 162249216c1cSHariprasad Shenai loff_t pos = *ppos; 1623c1d81b1cSDavid Howells loff_t avail = file_inode(file)->i_size; 162449216c1cSHariprasad Shenai struct adapter *adap = file->private_data; 162549216c1cSHariprasad Shenai 162649216c1cSHariprasad Shenai if (pos < 0) 162749216c1cSHariprasad Shenai return -EINVAL; 162849216c1cSHariprasad Shenai if (pos >= avail) 162949216c1cSHariprasad Shenai return 0; 163049216c1cSHariprasad Shenai if (count > avail - pos) 163149216c1cSHariprasad Shenai count = avail - pos; 163249216c1cSHariprasad Shenai 163349216c1cSHariprasad Shenai while (count) { 163449216c1cSHariprasad Shenai size_t len; 163549216c1cSHariprasad Shenai int ret, ofst; 163649216c1cSHariprasad Shenai u8 data[256]; 163749216c1cSHariprasad Shenai 163849216c1cSHariprasad Shenai ofst = pos & 3; 163949216c1cSHariprasad Shenai len = min(count + ofst, sizeof(data)); 164049216c1cSHariprasad Shenai ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4, 164149216c1cSHariprasad Shenai (u32 *)data, 1); 164249216c1cSHariprasad Shenai if (ret) 164349216c1cSHariprasad Shenai return ret; 164449216c1cSHariprasad Shenai 164549216c1cSHariprasad Shenai len -= ofst; 164649216c1cSHariprasad Shenai if (copy_to_user(buf, data + ofst, len)) 164749216c1cSHariprasad Shenai return -EFAULT; 164849216c1cSHariprasad Shenai 164949216c1cSHariprasad Shenai buf += len; 165049216c1cSHariprasad Shenai pos += len; 165149216c1cSHariprasad Shenai count -= len; 165249216c1cSHariprasad Shenai } 165349216c1cSHariprasad Shenai count = pos - *ppos; 165449216c1cSHariprasad Shenai *ppos = pos; 165549216c1cSHariprasad Shenai return count; 165649216c1cSHariprasad Shenai } 165749216c1cSHariprasad Shenai 165849216c1cSHariprasad Shenai static const struct file_operations flash_debugfs_fops = { 165949216c1cSHariprasad Shenai .owner = THIS_MODULE, 166049216c1cSHariprasad Shenai .open = mem_open, 166149216c1cSHariprasad Shenai .read = flash_read, 1662ed98c85eSHariprasad Shenai .llseek = default_llseek, 166349216c1cSHariprasad Shenai }; 166449216c1cSHariprasad Shenai 1665ef82f662SHariprasad Shenai static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask) 1666ef82f662SHariprasad Shenai { 1667ef82f662SHariprasad Shenai *mask = x | y; 1668ef82f662SHariprasad Shenai y = (__force u64)cpu_to_be64(y); 1669ef82f662SHariprasad Shenai memcpy(addr, (char *)&y + 2, ETH_ALEN); 1670ef82f662SHariprasad Shenai } 1671ef82f662SHariprasad Shenai 1672ef82f662SHariprasad Shenai static int mps_tcam_show(struct seq_file *seq, void *v) 1673ef82f662SHariprasad Shenai { 16743ccc6cf7SHariprasad Shenai struct adapter *adap = seq->private; 16753ccc6cf7SHariprasad Shenai unsigned int chip_ver = CHELSIO_CHIP_VERSION(adap->params.chip); 16763ccc6cf7SHariprasad Shenai if (v == SEQ_START_TOKEN) { 1677115b56afSHariprasad Shenai if (chip_ver > CHELSIO_T5) { 1678115b56afSHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask " 1679115b56afSHariprasad Shenai " VNI Mask IVLAN Vld " 1680115b56afSHariprasad Shenai "DIP_Hit Lookup Port " 1681115b56afSHariprasad Shenai "Vld Ports PF VF " 1682115b56afSHariprasad Shenai "Replication " 1683115b56afSHariprasad Shenai " P0 P1 P2 P3 ML\n"); 1684115b56afSHariprasad Shenai } else { 16853ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 16863ccc6cf7SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask " 16873ccc6cf7SHariprasad Shenai "Vld Ports PF VF " 16883ccc6cf7SHariprasad Shenai "Replication " 1689ef82f662SHariprasad Shenai " P0 P1 P2 P3 ML\n"); 16903ccc6cf7SHariprasad Shenai else 16913ccc6cf7SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask " 16923ccc6cf7SHariprasad Shenai "Vld Ports PF VF Replication" 16933ccc6cf7SHariprasad Shenai " P0 P1 P2 P3 ML\n"); 1694115b56afSHariprasad Shenai } 16953ccc6cf7SHariprasad Shenai } else { 1696ef82f662SHariprasad Shenai u64 mask; 1697ef82f662SHariprasad Shenai u8 addr[ETH_ALEN]; 1698115b56afSHariprasad Shenai bool replicate, dip_hit = false, vlan_vld = false; 1699ef82f662SHariprasad Shenai unsigned int idx = (uintptr_t)v - 2; 17003ccc6cf7SHariprasad Shenai u64 tcamy, tcamx, val; 1701115b56afSHariprasad Shenai u32 cls_lo, cls_hi, ctl, data2, vnix = 0, vniy = 0; 17023ccc6cf7SHariprasad Shenai u32 rplc[8] = {0}; 1703115b56afSHariprasad Shenai u8 lookup_type = 0, port_num = 0; 1704115b56afSHariprasad Shenai u16 ivlan = 0; 17053ccc6cf7SHariprasad Shenai 17063ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) { 17073ccc6cf7SHariprasad Shenai /* CtlCmdType - 0: Read, 1: Write 17083ccc6cf7SHariprasad Shenai * CtlTcamSel - 0: TCAM0, 1: TCAM1 17093ccc6cf7SHariprasad Shenai * CtlXYBitSel- 0: Y bit, 1: X bit 17103ccc6cf7SHariprasad Shenai */ 17113ccc6cf7SHariprasad Shenai 17123ccc6cf7SHariprasad Shenai /* Read tcamy */ 17133ccc6cf7SHariprasad Shenai ctl = CTLCMDTYPE_V(0) | CTLXYBITSEL_V(0); 17143ccc6cf7SHariprasad Shenai if (idx < 256) 17153ccc6cf7SHariprasad Shenai ctl |= CTLTCAMINDEX_V(idx) | CTLTCAMSEL_V(0); 17163ccc6cf7SHariprasad Shenai else 17173ccc6cf7SHariprasad Shenai ctl |= CTLTCAMINDEX_V(idx - 256) | 17183ccc6cf7SHariprasad Shenai CTLTCAMSEL_V(1); 17193ccc6cf7SHariprasad Shenai t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl); 17203ccc6cf7SHariprasad Shenai val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A); 17213ccc6cf7SHariprasad Shenai tcamy = DMACH_G(val) << 32; 17223ccc6cf7SHariprasad Shenai tcamy |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A); 1723115b56afSHariprasad Shenai data2 = t4_read_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A); 1724115b56afSHariprasad Shenai lookup_type = DATALKPTYPE_G(data2); 1725115b56afSHariprasad Shenai /* 0 - Outer header, 1 - Inner header 1726115b56afSHariprasad Shenai * [71:48] bit locations are overloaded for 1727115b56afSHariprasad Shenai * outer vs. inner lookup types. 1728115b56afSHariprasad Shenai */ 1729115b56afSHariprasad Shenai if (lookup_type && (lookup_type != DATALKPTYPE_M)) { 1730115b56afSHariprasad Shenai /* Inner header VNI */ 1731b9525301SGanesh Goudar vniy = (data2 & DATAVIDH2_F) | 1732115b56afSHariprasad Shenai (DATAVIDH1_G(data2) << 16) | VIDL_G(val); 1733115b56afSHariprasad Shenai dip_hit = data2 & DATADIPHIT_F; 1734115b56afSHariprasad Shenai } else { 1735115b56afSHariprasad Shenai vlan_vld = data2 & DATAVIDH2_F; 1736115b56afSHariprasad Shenai ivlan = VIDL_G(val); 1737115b56afSHariprasad Shenai } 1738115b56afSHariprasad Shenai port_num = DATAPORTNUM_G(data2); 17393ccc6cf7SHariprasad Shenai 17403ccc6cf7SHariprasad Shenai /* Read tcamx. Change the control param */ 1741b9525301SGanesh Goudar vnix = 0; 17423ccc6cf7SHariprasad Shenai ctl |= CTLXYBITSEL_V(1); 17433ccc6cf7SHariprasad Shenai t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl); 17443ccc6cf7SHariprasad Shenai val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A); 17453ccc6cf7SHariprasad Shenai tcamx = DMACH_G(val) << 32; 17463ccc6cf7SHariprasad Shenai tcamx |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A); 1747115b56afSHariprasad Shenai data2 = t4_read_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A); 1748115b56afSHariprasad Shenai if (lookup_type && (lookup_type != DATALKPTYPE_M)) { 1749115b56afSHariprasad Shenai /* Inner header VNI mask */ 1750b9525301SGanesh Goudar vnix = (data2 & DATAVIDH2_F) | 1751115b56afSHariprasad Shenai (DATAVIDH1_G(data2) << 16) | VIDL_G(val); 1752115b56afSHariprasad Shenai } 17533ccc6cf7SHariprasad Shenai } else { 17543ccc6cf7SHariprasad Shenai tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx)); 17553ccc6cf7SHariprasad Shenai tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx)); 17563ccc6cf7SHariprasad Shenai } 17573ccc6cf7SHariprasad Shenai 17583ccc6cf7SHariprasad Shenai cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx)); 17593ccc6cf7SHariprasad Shenai cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx)); 1760ef82f662SHariprasad Shenai 1761ef82f662SHariprasad Shenai if (tcamx & tcamy) { 1762ef82f662SHariprasad Shenai seq_printf(seq, "%3u -\n", idx); 1763ef82f662SHariprasad Shenai goto out; 1764ef82f662SHariprasad Shenai } 1765ef82f662SHariprasad Shenai 17663ccc6cf7SHariprasad Shenai rplc[0] = rplc[1] = rplc[2] = rplc[3] = 0; 17673ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) 17683ccc6cf7SHariprasad Shenai replicate = (cls_lo & T6_REPLICATE_F); 17693ccc6cf7SHariprasad Shenai else 17703ccc6cf7SHariprasad Shenai replicate = (cls_lo & REPLICATE_F); 17713ccc6cf7SHariprasad Shenai 17723ccc6cf7SHariprasad Shenai if (replicate) { 1773ef82f662SHariprasad Shenai struct fw_ldst_cmd ldst_cmd; 1774ef82f662SHariprasad Shenai int ret; 17753ccc6cf7SHariprasad Shenai struct fw_ldst_mps_rplc mps_rplc; 17763ccc6cf7SHariprasad Shenai u32 ldst_addrspc; 1777ef82f662SHariprasad Shenai 1778ef82f662SHariprasad Shenai memset(&ldst_cmd, 0, sizeof(ldst_cmd)); 17793ccc6cf7SHariprasad Shenai ldst_addrspc = 17803ccc6cf7SHariprasad Shenai FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MPS); 1781ef82f662SHariprasad Shenai ldst_cmd.op_to_addrspace = 1782ef82f662SHariprasad Shenai htonl(FW_CMD_OP_V(FW_LDST_CMD) | 1783ef82f662SHariprasad Shenai FW_CMD_REQUEST_F | 1784ef82f662SHariprasad Shenai FW_CMD_READ_F | 17853ccc6cf7SHariprasad Shenai ldst_addrspc); 1786ef82f662SHariprasad Shenai ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd)); 17873ccc6cf7SHariprasad Shenai ldst_cmd.u.mps.rplc.fid_idx = 1788ef82f662SHariprasad Shenai htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) | 17893ccc6cf7SHariprasad Shenai FW_LDST_CMD_IDX_V(idx)); 1790ef82f662SHariprasad Shenai ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, 1791ef82f662SHariprasad Shenai sizeof(ldst_cmd), &ldst_cmd); 1792ef82f662SHariprasad Shenai if (ret) 1793ef82f662SHariprasad Shenai dev_warn(adap->pdev_dev, "Can't read MPS " 1794ef82f662SHariprasad Shenai "replication map for idx %d: %d\n", 1795ef82f662SHariprasad Shenai idx, -ret); 1796ef82f662SHariprasad Shenai else { 17973ccc6cf7SHariprasad Shenai mps_rplc = ldst_cmd.u.mps.rplc; 17983ccc6cf7SHariprasad Shenai rplc[0] = ntohl(mps_rplc.rplc31_0); 17993ccc6cf7SHariprasad Shenai rplc[1] = ntohl(mps_rplc.rplc63_32); 18003ccc6cf7SHariprasad Shenai rplc[2] = ntohl(mps_rplc.rplc95_64); 18013ccc6cf7SHariprasad Shenai rplc[3] = ntohl(mps_rplc.rplc127_96); 18023ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) { 18033ccc6cf7SHariprasad Shenai rplc[4] = ntohl(mps_rplc.rplc159_128); 18043ccc6cf7SHariprasad Shenai rplc[5] = ntohl(mps_rplc.rplc191_160); 18053ccc6cf7SHariprasad Shenai rplc[6] = ntohl(mps_rplc.rplc223_192); 18063ccc6cf7SHariprasad Shenai rplc[7] = ntohl(mps_rplc.rplc255_224); 18073ccc6cf7SHariprasad Shenai } 1808ef82f662SHariprasad Shenai } 1809ef82f662SHariprasad Shenai } 1810ef82f662SHariprasad Shenai 1811ef82f662SHariprasad Shenai tcamxy2valmask(tcamx, tcamy, addr, &mask); 1812115b56afSHariprasad Shenai if (chip_ver > CHELSIO_T5) { 1813115b56afSHariprasad Shenai /* Inner header lookup */ 1814115b56afSHariprasad Shenai if (lookup_type && (lookup_type != DATALKPTYPE_M)) { 1815115b56afSHariprasad Shenai seq_printf(seq, 18160992b490SAndy Shevchenko "%3u %pM %012llx %06x %06x - - %3c 'I' %4x %3c %#x%4u%4d", 18170992b490SAndy Shevchenko idx, addr, 1818115b56afSHariprasad Shenai (unsigned long long)mask, 1819b9525301SGanesh Goudar vniy, (vnix | vniy), 1820b9525301SGanesh Goudar dip_hit ? 'Y' : 'N', 182189e7a154SHariprasad Shenai port_num, 18223ccc6cf7SHariprasad Shenai (cls_lo & T6_SRAM_VLD_F) ? 'Y' : 'N', 18233ccc6cf7SHariprasad Shenai PORTMAP_G(cls_hi), 18243ccc6cf7SHariprasad Shenai T6_PF_G(cls_lo), 18253ccc6cf7SHariprasad Shenai (cls_lo & T6_VF_VALID_F) ? 18263ccc6cf7SHariprasad Shenai T6_VF_G(cls_lo) : -1); 1827115b56afSHariprasad Shenai } else { 1828115b56afSHariprasad Shenai seq_printf(seq, 18290992b490SAndy Shevchenko "%3u %pM %012llx - - ", 18300992b490SAndy Shevchenko idx, addr, 1831115b56afSHariprasad Shenai (unsigned long long)mask); 1832115b56afSHariprasad Shenai 1833115b56afSHariprasad Shenai if (vlan_vld) 1834115b56afSHariprasad Shenai seq_printf(seq, "%4u Y ", ivlan); 18353ccc6cf7SHariprasad Shenai else 1836115b56afSHariprasad Shenai seq_puts(seq, " - N "); 1837115b56afSHariprasad Shenai 1838115b56afSHariprasad Shenai seq_printf(seq, 1839115b56afSHariprasad Shenai "- %3c %4x %3c %#x%4u%4d", 1840115b56afSHariprasad Shenai lookup_type ? 'I' : 'O', port_num, 1841115b56afSHariprasad Shenai (cls_lo & T6_SRAM_VLD_F) ? 'Y' : 'N', 1842115b56afSHariprasad Shenai PORTMAP_G(cls_hi), 1843115b56afSHariprasad Shenai T6_PF_G(cls_lo), 1844115b56afSHariprasad Shenai (cls_lo & T6_VF_VALID_F) ? 1845115b56afSHariprasad Shenai T6_VF_G(cls_lo) : -1); 1846115b56afSHariprasad Shenai } 1847115b56afSHariprasad Shenai } else 18480992b490SAndy Shevchenko seq_printf(seq, "%3u %pM %012llx%3c %#x%4u%4d", 18490992b490SAndy Shevchenko idx, addr, (unsigned long long)mask, 18503ccc6cf7SHariprasad Shenai (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', 18513ccc6cf7SHariprasad Shenai PORTMAP_G(cls_hi), 1852ef82f662SHariprasad Shenai PF_G(cls_lo), 1853ef82f662SHariprasad Shenai (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1); 18543ccc6cf7SHariprasad Shenai 18553ccc6cf7SHariprasad Shenai if (replicate) { 18563ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 18573ccc6cf7SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x " 18583ccc6cf7SHariprasad Shenai "%08x %08x %08x %08x", 18593ccc6cf7SHariprasad Shenai rplc[7], rplc[6], rplc[5], rplc[4], 1860ef82f662SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 1861ef82f662SHariprasad Shenai else 18623ccc6cf7SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x", 18633ccc6cf7SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 18643ccc6cf7SHariprasad Shenai } else { 18653ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 18663ccc6cf7SHariprasad Shenai seq_printf(seq, "%72c", ' '); 18673ccc6cf7SHariprasad Shenai else 1868ef82f662SHariprasad Shenai seq_printf(seq, "%36c", ' '); 18693ccc6cf7SHariprasad Shenai } 18703ccc6cf7SHariprasad Shenai 18713ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) 18723ccc6cf7SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 18733ccc6cf7SHariprasad Shenai T6_SRAM_PRIO0_G(cls_lo), 18743ccc6cf7SHariprasad Shenai T6_SRAM_PRIO1_G(cls_lo), 18753ccc6cf7SHariprasad Shenai T6_SRAM_PRIO2_G(cls_lo), 18763ccc6cf7SHariprasad Shenai T6_SRAM_PRIO3_G(cls_lo), 18773ccc6cf7SHariprasad Shenai (cls_lo >> T6_MULTILISTEN0_S) & 0xf); 18783ccc6cf7SHariprasad Shenai else 1879ef82f662SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 1880ef82f662SHariprasad Shenai SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo), 1881ef82f662SHariprasad Shenai SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo), 1882ef82f662SHariprasad Shenai (cls_lo >> MULTILISTEN0_S) & 0xf); 1883ef82f662SHariprasad Shenai } 1884ef82f662SHariprasad Shenai out: return 0; 1885ef82f662SHariprasad Shenai } 1886ef82f662SHariprasad Shenai 1887ef82f662SHariprasad Shenai static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos) 1888ef82f662SHariprasad Shenai { 1889ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 1890ef82f662SHariprasad Shenai int max_mac_addr = is_t4(adap->params.chip) ? 1891ef82f662SHariprasad Shenai NUM_MPS_CLS_SRAM_L_INSTANCES : 1892ef82f662SHariprasad Shenai NUM_MPS_T5_CLS_SRAM_L_INSTANCES; 1893ef82f662SHariprasad Shenai return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL); 1894ef82f662SHariprasad Shenai } 1895ef82f662SHariprasad Shenai 1896ef82f662SHariprasad Shenai static void *mps_tcam_start(struct seq_file *seq, loff_t *pos) 1897ef82f662SHariprasad Shenai { 1898ef82f662SHariprasad Shenai return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN; 1899ef82f662SHariprasad Shenai } 1900ef82f662SHariprasad Shenai 1901ef82f662SHariprasad Shenai static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos) 1902ef82f662SHariprasad Shenai { 1903ef82f662SHariprasad Shenai ++*pos; 1904ef82f662SHariprasad Shenai return mps_tcam_get_idx(seq, *pos); 1905ef82f662SHariprasad Shenai } 1906ef82f662SHariprasad Shenai 1907ef82f662SHariprasad Shenai static void mps_tcam_stop(struct seq_file *seq, void *v) 1908ef82f662SHariprasad Shenai { 1909ef82f662SHariprasad Shenai } 1910ef82f662SHariprasad Shenai 1911ef82f662SHariprasad Shenai static const struct seq_operations mps_tcam_seq_ops = { 1912ef82f662SHariprasad Shenai .start = mps_tcam_start, 1913ef82f662SHariprasad Shenai .next = mps_tcam_next, 1914ef82f662SHariprasad Shenai .stop = mps_tcam_stop, 1915ef82f662SHariprasad Shenai .show = mps_tcam_show 1916ef82f662SHariprasad Shenai }; 1917ef82f662SHariprasad Shenai 1918ef82f662SHariprasad Shenai static int mps_tcam_open(struct inode *inode, struct file *file) 1919ef82f662SHariprasad Shenai { 1920ef82f662SHariprasad Shenai int res = seq_open(file, &mps_tcam_seq_ops); 1921ef82f662SHariprasad Shenai 1922ef82f662SHariprasad Shenai if (!res) { 1923ef82f662SHariprasad Shenai struct seq_file *seq = file->private_data; 1924ef82f662SHariprasad Shenai 1925ef82f662SHariprasad Shenai seq->private = inode->i_private; 1926ef82f662SHariprasad Shenai } 1927ef82f662SHariprasad Shenai return res; 1928ef82f662SHariprasad Shenai } 1929ef82f662SHariprasad Shenai 1930ef82f662SHariprasad Shenai static const struct file_operations mps_tcam_debugfs_fops = { 1931ef82f662SHariprasad Shenai .owner = THIS_MODULE, 1932ef82f662SHariprasad Shenai .open = mps_tcam_open, 1933ef82f662SHariprasad Shenai .read = seq_read, 1934ef82f662SHariprasad Shenai .llseek = seq_lseek, 1935ef82f662SHariprasad Shenai .release = seq_release, 1936ef82f662SHariprasad Shenai }; 1937ef82f662SHariprasad Shenai 193870a5f3bbSHariprasad Shenai /* Display various sensor information. 193970a5f3bbSHariprasad Shenai */ 194070a5f3bbSHariprasad Shenai static int sensors_show(struct seq_file *seq, void *v) 194170a5f3bbSHariprasad Shenai { 194270a5f3bbSHariprasad Shenai struct adapter *adap = seq->private; 194370a5f3bbSHariprasad Shenai u32 param[7], val[7]; 194470a5f3bbSHariprasad Shenai int ret; 194570a5f3bbSHariprasad Shenai 194670a5f3bbSHariprasad Shenai /* Note that if the sensors haven't been initialized and turned on 194770a5f3bbSHariprasad Shenai * we'll get values of 0, so treat those as "<unknown>" ... 194870a5f3bbSHariprasad Shenai */ 194970a5f3bbSHariprasad Shenai param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 195070a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 195170a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP)); 195270a5f3bbSHariprasad Shenai param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 195370a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 195470a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD)); 1955b2612722SHariprasad Shenai ret = t4_query_params(adap, adap->mbox, adap->pf, 0, 2, 195670a5f3bbSHariprasad Shenai param, val); 195770a5f3bbSHariprasad Shenai 195870a5f3bbSHariprasad Shenai if (ret < 0 || val[0] == 0) 195970a5f3bbSHariprasad Shenai seq_puts(seq, "Temperature: <unknown>\n"); 196070a5f3bbSHariprasad Shenai else 196170a5f3bbSHariprasad Shenai seq_printf(seq, "Temperature: %dC\n", val[0]); 196270a5f3bbSHariprasad Shenai 196370a5f3bbSHariprasad Shenai if (ret < 0 || val[1] == 0) 196470a5f3bbSHariprasad Shenai seq_puts(seq, "Core VDD: <unknown>\n"); 196570a5f3bbSHariprasad Shenai else 196670a5f3bbSHariprasad Shenai seq_printf(seq, "Core VDD: %dmV\n", val[1]); 196770a5f3bbSHariprasad Shenai 196870a5f3bbSHariprasad Shenai return 0; 196970a5f3bbSHariprasad Shenai } 1970b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(sensors); 197170a5f3bbSHariprasad Shenai 1972b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 1973b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(clip_tbl); 1974b5a02f50SAnish Bhatt #endif 1975b5a02f50SAnish Bhatt 1976688ea5feSHariprasad Shenai /*RSS Table. 1977688ea5feSHariprasad Shenai */ 1978688ea5feSHariprasad Shenai 1979688ea5feSHariprasad Shenai static int rss_show(struct seq_file *seq, void *v, int idx) 1980688ea5feSHariprasad Shenai { 1981688ea5feSHariprasad Shenai u16 *entry = v; 1982688ea5feSHariprasad Shenai 1983688ea5feSHariprasad Shenai seq_printf(seq, "%4d: %4u %4u %4u %4u %4u %4u %4u %4u\n", 1984688ea5feSHariprasad Shenai idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4], 1985688ea5feSHariprasad Shenai entry[5], entry[6], entry[7]); 1986688ea5feSHariprasad Shenai return 0; 1987688ea5feSHariprasad Shenai } 1988688ea5feSHariprasad Shenai 1989688ea5feSHariprasad Shenai static int rss_open(struct inode *inode, struct file *file) 1990688ea5feSHariprasad Shenai { 1991688ea5feSHariprasad Shenai struct adapter *adap = inode->i_private; 1992f988008aSGanesh Goudar int ret, nentries; 1993f988008aSGanesh Goudar struct seq_tab *p; 1994688ea5feSHariprasad Shenai 1995f988008aSGanesh Goudar nentries = t4_chip_rss_size(adap); 1996f988008aSGanesh Goudar p = seq_open_tab(file, nentries / 8, 8 * sizeof(u16), 0, rss_show); 1997688ea5feSHariprasad Shenai if (!p) 1998688ea5feSHariprasad Shenai return -ENOMEM; 1999688ea5feSHariprasad Shenai 2000688ea5feSHariprasad Shenai ret = t4_read_rss(adap, (u16 *)p->data); 2001688ea5feSHariprasad Shenai if (ret) 2002688ea5feSHariprasad Shenai seq_release_private(inode, file); 2003688ea5feSHariprasad Shenai 2004688ea5feSHariprasad Shenai return ret; 2005688ea5feSHariprasad Shenai } 2006688ea5feSHariprasad Shenai 2007688ea5feSHariprasad Shenai static const struct file_operations rss_debugfs_fops = { 2008688ea5feSHariprasad Shenai .owner = THIS_MODULE, 2009688ea5feSHariprasad Shenai .open = rss_open, 2010688ea5feSHariprasad Shenai .read = seq_read, 2011688ea5feSHariprasad Shenai .llseek = seq_lseek, 2012688ea5feSHariprasad Shenai .release = seq_release_private 2013688ea5feSHariprasad Shenai }; 2014688ea5feSHariprasad Shenai 2015688ea5feSHariprasad Shenai /* RSS Configuration. 2016688ea5feSHariprasad Shenai */ 2017688ea5feSHariprasad Shenai 2018688ea5feSHariprasad Shenai /* Small utility function to return the strings "yes" or "no" if the supplied 2019688ea5feSHariprasad Shenai * argument is non-zero. 2020688ea5feSHariprasad Shenai */ 2021688ea5feSHariprasad Shenai static const char *yesno(int x) 2022688ea5feSHariprasad Shenai { 2023688ea5feSHariprasad Shenai static const char *yes = "yes"; 2024688ea5feSHariprasad Shenai static const char *no = "no"; 2025688ea5feSHariprasad Shenai 2026688ea5feSHariprasad Shenai return x ? yes : no; 2027688ea5feSHariprasad Shenai } 2028688ea5feSHariprasad Shenai 2029688ea5feSHariprasad Shenai static int rss_config_show(struct seq_file *seq, void *v) 2030688ea5feSHariprasad Shenai { 2031688ea5feSHariprasad Shenai struct adapter *adapter = seq->private; 2032688ea5feSHariprasad Shenai static const char * const keymode[] = { 2033688ea5feSHariprasad Shenai "global", 2034688ea5feSHariprasad Shenai "global and per-VF scramble", 2035688ea5feSHariprasad Shenai "per-PF and per-VF scramble", 2036688ea5feSHariprasad Shenai "per-VF and per-VF scramble", 2037688ea5feSHariprasad Shenai }; 2038688ea5feSHariprasad Shenai u32 rssconf; 2039688ea5feSHariprasad Shenai 2040688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A); 2041688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf); 2042688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv6: %3s\n", yesno(rssconf & 2043688ea5feSHariprasad Shenai TNL4TUPENIPV6_F)); 2044688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv6: %3s\n", yesno(rssconf & 2045688ea5feSHariprasad Shenai TNL2TUPENIPV6_F)); 2046688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv4: %3s\n", yesno(rssconf & 2047688ea5feSHariprasad Shenai TNL4TUPENIPV4_F)); 2048688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv4: %3s\n", yesno(rssconf & 2049688ea5feSHariprasad Shenai TNL2TUPENIPV4_F)); 2050688ea5feSHariprasad Shenai seq_printf(seq, " TnlTcpSel: %3s\n", yesno(rssconf & TNLTCPSEL_F)); 2051688ea5feSHariprasad Shenai seq_printf(seq, " TnlIp6Sel: %3s\n", yesno(rssconf & TNLIP6SEL_F)); 2052688ea5feSHariprasad Shenai seq_printf(seq, " TnlVrtSel: %3s\n", yesno(rssconf & TNLVRTSEL_F)); 2053688ea5feSHariprasad Shenai seq_printf(seq, " TnlMapEn: %3s\n", yesno(rssconf & TNLMAPEN_F)); 2054688ea5feSHariprasad Shenai seq_printf(seq, " OfdHashSave: %3s\n", yesno(rssconf & 2055688ea5feSHariprasad Shenai OFDHASHSAVE_F)); 2056688ea5feSHariprasad Shenai seq_printf(seq, " OfdVrtSel: %3s\n", yesno(rssconf & OFDVRTSEL_F)); 2057688ea5feSHariprasad Shenai seq_printf(seq, " OfdMapEn: %3s\n", yesno(rssconf & OFDMAPEN_F)); 2058688ea5feSHariprasad Shenai seq_printf(seq, " OfdLkpEn: %3s\n", yesno(rssconf & OFDLKPEN_F)); 2059688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 2060688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 2061688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv6: %3s\n", yesno(rssconf & 2062688ea5feSHariprasad Shenai SYN2TUPENIPV6_F)); 2063688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv4: %3s\n", yesno(rssconf & 2064688ea5feSHariprasad Shenai SYN4TUPENIPV4_F)); 2065688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv4: %3s\n", yesno(rssconf & 2066688ea5feSHariprasad Shenai SYN2TUPENIPV4_F)); 2067688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 2068688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 2069688ea5feSHariprasad Shenai seq_printf(seq, " SynIp6Sel: %3s\n", yesno(rssconf & SYNIP6SEL_F)); 2070688ea5feSHariprasad Shenai seq_printf(seq, " SynVrt6Sel: %3s\n", yesno(rssconf & SYNVRTSEL_F)); 2071688ea5feSHariprasad Shenai seq_printf(seq, " SynMapEn: %3s\n", yesno(rssconf & SYNMAPEN_F)); 2072688ea5feSHariprasad Shenai seq_printf(seq, " SynLkpEn: %3s\n", yesno(rssconf & SYNLKPEN_F)); 2073688ea5feSHariprasad Shenai seq_printf(seq, " ChnEn: %3s\n", yesno(rssconf & 2074688ea5feSHariprasad Shenai CHANNELENABLE_F)); 2075688ea5feSHariprasad Shenai seq_printf(seq, " PrtEn: %3s\n", yesno(rssconf & 2076688ea5feSHariprasad Shenai PORTENABLE_F)); 2077688ea5feSHariprasad Shenai seq_printf(seq, " TnlAllLkp: %3s\n", yesno(rssconf & 2078688ea5feSHariprasad Shenai TNLALLLOOKUP_F)); 2079688ea5feSHariprasad Shenai seq_printf(seq, " VrtEn: %3s\n", yesno(rssconf & 2080688ea5feSHariprasad Shenai VIRTENABLE_F)); 2081688ea5feSHariprasad Shenai seq_printf(seq, " CngEn: %3s\n", yesno(rssconf & 2082688ea5feSHariprasad Shenai CONGESTIONENABLE_F)); 2083688ea5feSHariprasad Shenai seq_printf(seq, " HashToeplitz: %3s\n", yesno(rssconf & 2084688ea5feSHariprasad Shenai HASHTOEPLITZ_F)); 2085688ea5feSHariprasad Shenai seq_printf(seq, " Udp4En: %3s\n", yesno(rssconf & UDPENABLE_F)); 2086688ea5feSHariprasad Shenai seq_printf(seq, " Disable: %3s\n", yesno(rssconf & DISABLE_F)); 2087688ea5feSHariprasad Shenai 2088688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 2089688ea5feSHariprasad Shenai 2090688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A); 2091688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf); 2092688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 2093688ea5feSHariprasad Shenai seq_printf(seq, " MaskFilter: %3d\n", MASKFILTER_G(rssconf)); 2094688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 2095688ea5feSHariprasad Shenai seq_printf(seq, " HashAll: %3s\n", 2096688ea5feSHariprasad Shenai yesno(rssconf & HASHALL_F)); 2097688ea5feSHariprasad Shenai seq_printf(seq, " HashEth: %3s\n", 2098688ea5feSHariprasad Shenai yesno(rssconf & HASHETH_F)); 2099688ea5feSHariprasad Shenai } 2100688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 2101688ea5feSHariprasad Shenai 2102688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 2103688ea5feSHariprasad Shenai 2104688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A); 2105688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf); 2106688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 2107688ea5feSHariprasad Shenai seq_printf(seq, " RRCplMapEn: %3s\n", yesno(rssconf & 2108688ea5feSHariprasad Shenai RRCPLMAPEN_F)); 2109688ea5feSHariprasad Shenai seq_printf(seq, " RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf)); 2110688ea5feSHariprasad Shenai 2111688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 2112688ea5feSHariprasad Shenai 2113688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A); 2114688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf); 2115688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 2116688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 2117688ea5feSHariprasad Shenai 2118688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 2119688ea5feSHariprasad Shenai 2120688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A); 2121688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf); 2122688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 2123688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddrX: %3d\n", 2124688ea5feSHariprasad Shenai KEYWRADDRX_G(rssconf)); 2125688ea5feSHariprasad Shenai seq_printf(seq, " KeyExtend: %3s\n", 2126688ea5feSHariprasad Shenai yesno(rssconf & KEYEXTEND_F)); 2127688ea5feSHariprasad Shenai } 2128688ea5feSHariprasad Shenai seq_printf(seq, " VfRdRg: %3s\n", yesno(rssconf & VFRDRG_F)); 2129688ea5feSHariprasad Shenai seq_printf(seq, " VfRdEn: %3s\n", yesno(rssconf & VFRDEN_F)); 2130688ea5feSHariprasad Shenai seq_printf(seq, " VfPerrEn: %3s\n", yesno(rssconf & VFPERREN_F)); 2131688ea5feSHariprasad Shenai seq_printf(seq, " KeyPerrEn: %3s\n", yesno(rssconf & KEYPERREN_F)); 2132688ea5feSHariprasad Shenai seq_printf(seq, " DisVfVlan: %3s\n", yesno(rssconf & 2133688ea5feSHariprasad Shenai DISABLEVLAN_F)); 2134688ea5feSHariprasad Shenai seq_printf(seq, " EnUpSwt: %3s\n", yesno(rssconf & ENABLEUP0_F)); 2135688ea5feSHariprasad Shenai seq_printf(seq, " HashDelay: %3d\n", HASHDELAY_G(rssconf)); 2136688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5) 2137688ea5feSHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", VFWRADDR_G(rssconf)); 21383ccc6cf7SHariprasad Shenai else 21393ccc6cf7SHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", 21403ccc6cf7SHariprasad Shenai T6_VFWRADDR_G(rssconf)); 2141688ea5feSHariprasad Shenai seq_printf(seq, " KeyMode: %s\n", keymode[KEYMODE_G(rssconf)]); 2142688ea5feSHariprasad Shenai seq_printf(seq, " VfWrEn: %3s\n", yesno(rssconf & VFWREN_F)); 2143688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrEn: %3s\n", yesno(rssconf & KEYWREN_F)); 2144688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddr: %3d\n", KEYWRADDR_G(rssconf)); 2145688ea5feSHariprasad Shenai 2146688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 2147688ea5feSHariprasad Shenai 2148688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A); 2149688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf); 2150688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount3: %3s\n", yesno(rssconf & CHNCOUNT3_F)); 2151688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount2: %3s\n", yesno(rssconf & CHNCOUNT2_F)); 2152688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount1: %3s\n", yesno(rssconf & CHNCOUNT1_F)); 2153688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount0: %3s\n", yesno(rssconf & CHNCOUNT0_F)); 2154688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow3: %3s\n", yesno(rssconf & 2155688ea5feSHariprasad Shenai CHNUNDFLOW3_F)); 2156688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow2: %3s\n", yesno(rssconf & 2157688ea5feSHariprasad Shenai CHNUNDFLOW2_F)); 2158688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow1: %3s\n", yesno(rssconf & 2159688ea5feSHariprasad Shenai CHNUNDFLOW1_F)); 2160688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow0: %3s\n", yesno(rssconf & 2161688ea5feSHariprasad Shenai CHNUNDFLOW0_F)); 2162688ea5feSHariprasad Shenai seq_printf(seq, " RstChn3: %3s\n", yesno(rssconf & RSTCHN3_F)); 2163688ea5feSHariprasad Shenai seq_printf(seq, " RstChn2: %3s\n", yesno(rssconf & RSTCHN2_F)); 2164688ea5feSHariprasad Shenai seq_printf(seq, " RstChn1: %3s\n", yesno(rssconf & RSTCHN1_F)); 2165688ea5feSHariprasad Shenai seq_printf(seq, " RstChn0: %3s\n", yesno(rssconf & RSTCHN0_F)); 2166688ea5feSHariprasad Shenai seq_printf(seq, " UpdVld: %3s\n", yesno(rssconf & UPDVLD_F)); 2167688ea5feSHariprasad Shenai seq_printf(seq, " Xoff: %3s\n", yesno(rssconf & XOFF_F)); 2168688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn3: %3s\n", yesno(rssconf & UPDCHN3_F)); 2169688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn2: %3s\n", yesno(rssconf & UPDCHN2_F)); 2170688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn1: %3s\n", yesno(rssconf & UPDCHN1_F)); 2171688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn0: %3s\n", yesno(rssconf & UPDCHN0_F)); 2172688ea5feSHariprasad Shenai seq_printf(seq, " Queue: %3d\n", QUEUE_G(rssconf)); 2173688ea5feSHariprasad Shenai 2174688ea5feSHariprasad Shenai return 0; 2175688ea5feSHariprasad Shenai } 2176b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(rss_config); 2177688ea5feSHariprasad Shenai 2178688ea5feSHariprasad Shenai /* RSS Secret Key. 2179688ea5feSHariprasad Shenai */ 2180688ea5feSHariprasad Shenai 2181688ea5feSHariprasad Shenai static int rss_key_show(struct seq_file *seq, void *v) 2182688ea5feSHariprasad Shenai { 2183688ea5feSHariprasad Shenai u32 key[10]; 2184688ea5feSHariprasad Shenai 21855ccf9d04SRahul Lakkireddy t4_read_rss_key(seq->private, key, true); 2186688ea5feSHariprasad Shenai seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", 2187688ea5feSHariprasad Shenai key[9], key[8], key[7], key[6], key[5], key[4], key[3], 2188688ea5feSHariprasad Shenai key[2], key[1], key[0]); 2189688ea5feSHariprasad Shenai return 0; 2190688ea5feSHariprasad Shenai } 2191688ea5feSHariprasad Shenai 2192688ea5feSHariprasad Shenai static int rss_key_open(struct inode *inode, struct file *file) 2193688ea5feSHariprasad Shenai { 2194688ea5feSHariprasad Shenai return single_open(file, rss_key_show, inode->i_private); 2195688ea5feSHariprasad Shenai } 2196688ea5feSHariprasad Shenai 2197688ea5feSHariprasad Shenai static ssize_t rss_key_write(struct file *file, const char __user *buf, 2198688ea5feSHariprasad Shenai size_t count, loff_t *pos) 2199688ea5feSHariprasad Shenai { 2200688ea5feSHariprasad Shenai int i, j; 2201688ea5feSHariprasad Shenai u32 key[10]; 2202688ea5feSHariprasad Shenai char s[100], *p; 2203c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 2204688ea5feSHariprasad Shenai 2205688ea5feSHariprasad Shenai if (count > sizeof(s) - 1) 2206688ea5feSHariprasad Shenai return -EINVAL; 2207688ea5feSHariprasad Shenai if (copy_from_user(s, buf, count)) 2208688ea5feSHariprasad Shenai return -EFAULT; 2209688ea5feSHariprasad Shenai for (i = count; i > 0 && isspace(s[i - 1]); i--) 2210688ea5feSHariprasad Shenai ; 2211688ea5feSHariprasad Shenai s[i] = '\0'; 2212688ea5feSHariprasad Shenai 2213688ea5feSHariprasad Shenai for (p = s, i = 9; i >= 0; i--) { 2214688ea5feSHariprasad Shenai key[i] = 0; 2215688ea5feSHariprasad Shenai for (j = 0; j < 8; j++, p++) { 2216688ea5feSHariprasad Shenai if (!isxdigit(*p)) 2217688ea5feSHariprasad Shenai return -EINVAL; 2218688ea5feSHariprasad Shenai key[i] = (key[i] << 4) | hex2val(*p); 2219688ea5feSHariprasad Shenai } 2220688ea5feSHariprasad Shenai } 2221688ea5feSHariprasad Shenai 22225ccf9d04SRahul Lakkireddy t4_write_rss_key(adap, key, -1, true); 2223688ea5feSHariprasad Shenai return count; 2224688ea5feSHariprasad Shenai } 2225688ea5feSHariprasad Shenai 2226688ea5feSHariprasad Shenai static const struct file_operations rss_key_debugfs_fops = { 2227688ea5feSHariprasad Shenai .owner = THIS_MODULE, 2228688ea5feSHariprasad Shenai .open = rss_key_open, 2229688ea5feSHariprasad Shenai .read = seq_read, 2230688ea5feSHariprasad Shenai .llseek = seq_lseek, 2231688ea5feSHariprasad Shenai .release = single_release, 2232688ea5feSHariprasad Shenai .write = rss_key_write 2233688ea5feSHariprasad Shenai }; 2234688ea5feSHariprasad Shenai 2235688ea5feSHariprasad Shenai /* PF RSS Configuration. 2236688ea5feSHariprasad Shenai */ 2237688ea5feSHariprasad Shenai 2238688ea5feSHariprasad Shenai struct rss_pf_conf { 2239688ea5feSHariprasad Shenai u32 rss_pf_map; 2240688ea5feSHariprasad Shenai u32 rss_pf_mask; 2241688ea5feSHariprasad Shenai u32 rss_pf_config; 2242688ea5feSHariprasad Shenai }; 2243688ea5feSHariprasad Shenai 2244688ea5feSHariprasad Shenai static int rss_pf_config_show(struct seq_file *seq, void *v, int idx) 2245688ea5feSHariprasad Shenai { 2246688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 2247688ea5feSHariprasad Shenai 2248688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 2249688ea5feSHariprasad Shenai /* use the 0th entry to dump the PF Map Index Size */ 2250688ea5feSHariprasad Shenai pfconf = seq->private + offsetof(struct seq_tab, data); 2251688ea5feSHariprasad Shenai seq_printf(seq, "PF Map Index Size = %d\n\n", 2252688ea5feSHariprasad Shenai LKPIDXSIZE_G(pfconf->rss_pf_map)); 2253688ea5feSHariprasad Shenai 2254688ea5feSHariprasad Shenai seq_puts(seq, " RSS PF VF Hash Tuple Enable Default\n"); 2255688ea5feSHariprasad Shenai seq_puts(seq, " Enable IPF Mask Mask IPv6 IPv4 UDP Queue\n"); 2256688ea5feSHariprasad Shenai seq_puts(seq, " PF Map Chn Prt Map Size Size Four Two Four Two Four Ch1 Ch0\n"); 2257688ea5feSHariprasad Shenai } else { 2258688ea5feSHariprasad Shenai #define G_PFnLKPIDX(map, n) \ 2259688ea5feSHariprasad Shenai (((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M) 2260688ea5feSHariprasad Shenai #define G_PFnMSKSIZE(mask, n) \ 2261688ea5feSHariprasad Shenai (((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M) 2262688ea5feSHariprasad Shenai 2263688ea5feSHariprasad Shenai pfconf = v; 2264688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3s %3d %3d %3d %3s %3s %3s %3s %3s %3d %3d\n", 2265688ea5feSHariprasad Shenai idx, 2266688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & MAPENABLE_F), 2267688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & CHNENABLE_F), 2268688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & PRTENABLE_F), 2269688ea5feSHariprasad Shenai G_PFnLKPIDX(pfconf->rss_pf_map, idx), 2270688ea5feSHariprasad Shenai G_PFnMSKSIZE(pfconf->rss_pf_mask, idx), 2271688ea5feSHariprasad Shenai IVFWIDTH_G(pfconf->rss_pf_config), 2272688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F), 2273688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F), 2274688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F), 2275688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F), 2276688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F), 2277688ea5feSHariprasad Shenai CH1DEFAULTQUEUE_G(pfconf->rss_pf_config), 2278688ea5feSHariprasad Shenai CH0DEFAULTQUEUE_G(pfconf->rss_pf_config)); 2279688ea5feSHariprasad Shenai 2280688ea5feSHariprasad Shenai #undef G_PFnLKPIDX 2281688ea5feSHariprasad Shenai #undef G_PFnMSKSIZE 2282688ea5feSHariprasad Shenai } 2283688ea5feSHariprasad Shenai return 0; 2284688ea5feSHariprasad Shenai } 2285688ea5feSHariprasad Shenai 2286688ea5feSHariprasad Shenai static int rss_pf_config_open(struct inode *inode, struct file *file) 2287688ea5feSHariprasad Shenai { 2288688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 2289688ea5feSHariprasad Shenai struct seq_tab *p; 2290688ea5feSHariprasad Shenai u32 rss_pf_map, rss_pf_mask; 2291688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 2292688ea5feSHariprasad Shenai int pf; 2293688ea5feSHariprasad Shenai 2294688ea5feSHariprasad Shenai p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show); 2295688ea5feSHariprasad Shenai if (!p) 2296688ea5feSHariprasad Shenai return -ENOMEM; 2297688ea5feSHariprasad Shenai 2298688ea5feSHariprasad Shenai pfconf = (struct rss_pf_conf *)p->data; 22995ccf9d04SRahul Lakkireddy rss_pf_map = t4_read_rss_pf_map(adapter, true); 23005ccf9d04SRahul Lakkireddy rss_pf_mask = t4_read_rss_pf_mask(adapter, true); 2301688ea5feSHariprasad Shenai for (pf = 0; pf < 8; pf++) { 2302688ea5feSHariprasad Shenai pfconf[pf].rss_pf_map = rss_pf_map; 2303688ea5feSHariprasad Shenai pfconf[pf].rss_pf_mask = rss_pf_mask; 23045ccf9d04SRahul Lakkireddy t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config, 23055ccf9d04SRahul Lakkireddy true); 2306688ea5feSHariprasad Shenai } 2307688ea5feSHariprasad Shenai return 0; 2308688ea5feSHariprasad Shenai } 2309688ea5feSHariprasad Shenai 2310688ea5feSHariprasad Shenai static const struct file_operations rss_pf_config_debugfs_fops = { 2311688ea5feSHariprasad Shenai .owner = THIS_MODULE, 2312688ea5feSHariprasad Shenai .open = rss_pf_config_open, 2313688ea5feSHariprasad Shenai .read = seq_read, 2314688ea5feSHariprasad Shenai .llseek = seq_lseek, 2315688ea5feSHariprasad Shenai .release = seq_release_private 2316688ea5feSHariprasad Shenai }; 2317688ea5feSHariprasad Shenai 2318688ea5feSHariprasad Shenai /* VF RSS Configuration. 2319688ea5feSHariprasad Shenai */ 2320688ea5feSHariprasad Shenai 2321688ea5feSHariprasad Shenai struct rss_vf_conf { 2322688ea5feSHariprasad Shenai u32 rss_vf_vfl; 2323688ea5feSHariprasad Shenai u32 rss_vf_vfh; 2324688ea5feSHariprasad Shenai }; 2325688ea5feSHariprasad Shenai 2326688ea5feSHariprasad Shenai static int rss_vf_config_show(struct seq_file *seq, void *v, int idx) 2327688ea5feSHariprasad Shenai { 2328688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 2329688ea5feSHariprasad Shenai seq_puts(seq, " RSS Hash Tuple Enable\n"); 2330688ea5feSHariprasad Shenai seq_puts(seq, " Enable IVF Dis Enb IPv6 IPv4 UDP Def Secret Key\n"); 2331688ea5feSHariprasad Shenai seq_puts(seq, " VF Chn Prt Map VLAN uP Four Two Four Two Four Que Idx Hash\n"); 2332688ea5feSHariprasad Shenai } else { 2333688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf = v; 2334688ea5feSHariprasad Shenai 2335688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3d %3s %3s %3s %3s %3s %3s %3s %4d %3d %#10x\n", 2336688ea5feSHariprasad Shenai idx, 2337688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFCHNEN_F), 2338688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFPRTEN_F), 2339688ea5feSHariprasad Shenai VFLKPIDX_G(vfconf->rss_vf_vfh), 2340688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFVLNEX_F), 2341688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFUPEN_F), 2342688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 2343688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F), 2344688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 2345688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F), 2346688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F), 2347688ea5feSHariprasad Shenai DEFAULTQUEUE_G(vfconf->rss_vf_vfh), 2348688ea5feSHariprasad Shenai KEYINDEX_G(vfconf->rss_vf_vfh), 2349688ea5feSHariprasad Shenai vfconf->rss_vf_vfl); 2350688ea5feSHariprasad Shenai } 2351688ea5feSHariprasad Shenai return 0; 2352688ea5feSHariprasad Shenai } 2353688ea5feSHariprasad Shenai 2354688ea5feSHariprasad Shenai static int rss_vf_config_open(struct inode *inode, struct file *file) 2355688ea5feSHariprasad Shenai { 2356688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 2357688ea5feSHariprasad Shenai struct seq_tab *p; 2358688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf; 23593ccc6cf7SHariprasad Shenai int vf, vfcount = adapter->params.arch.vfcount; 2360688ea5feSHariprasad Shenai 23613ccc6cf7SHariprasad Shenai p = seq_open_tab(file, vfcount, sizeof(*vfconf), 1, rss_vf_config_show); 2362688ea5feSHariprasad Shenai if (!p) 2363688ea5feSHariprasad Shenai return -ENOMEM; 2364688ea5feSHariprasad Shenai 2365688ea5feSHariprasad Shenai vfconf = (struct rss_vf_conf *)p->data; 23663ccc6cf7SHariprasad Shenai for (vf = 0; vf < vfcount; vf++) { 2367688ea5feSHariprasad Shenai t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl, 23685ccf9d04SRahul Lakkireddy &vfconf[vf].rss_vf_vfh, true); 2369688ea5feSHariprasad Shenai } 2370688ea5feSHariprasad Shenai return 0; 2371688ea5feSHariprasad Shenai } 2372688ea5feSHariprasad Shenai 2373688ea5feSHariprasad Shenai static const struct file_operations rss_vf_config_debugfs_fops = { 2374688ea5feSHariprasad Shenai .owner = THIS_MODULE, 2375688ea5feSHariprasad Shenai .open = rss_vf_config_open, 2376688ea5feSHariprasad Shenai .read = seq_read, 2377688ea5feSHariprasad Shenai .llseek = seq_lseek, 2378688ea5feSHariprasad Shenai .release = seq_release_private 2379688ea5feSHariprasad Shenai }; 2380688ea5feSHariprasad Shenai 2381ebddd97aSGanesh Goudar #ifdef CONFIG_CHELSIO_T4_DCB 2382ebddd97aSGanesh Goudar extern char *dcb_ver_array[]; 2383ebddd97aSGanesh Goudar 2384ebddd97aSGanesh Goudar /* Data Center Briging information for each port. 2385ebddd97aSGanesh Goudar */ 2386ebddd97aSGanesh Goudar static int dcb_info_show(struct seq_file *seq, void *v) 2387ebddd97aSGanesh Goudar { 2388ebddd97aSGanesh Goudar struct adapter *adap = seq->private; 2389ebddd97aSGanesh Goudar 2390ebddd97aSGanesh Goudar if (v == SEQ_START_TOKEN) { 2391ebddd97aSGanesh Goudar seq_puts(seq, "Data Center Bridging Information\n"); 2392ebddd97aSGanesh Goudar } else { 2393ebddd97aSGanesh Goudar int port = (uintptr_t)v - 2; 2394ebddd97aSGanesh Goudar struct net_device *dev = adap->port[port]; 2395ebddd97aSGanesh Goudar struct port_info *pi = netdev2pinfo(dev); 2396ebddd97aSGanesh Goudar struct port_dcb_info *dcb = &pi->dcb; 2397ebddd97aSGanesh Goudar 2398ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2399ebddd97aSGanesh Goudar seq_printf(seq, "Port: %d (DCB negotiated: %s)\n", 2400ebddd97aSGanesh Goudar port, 2401ebddd97aSGanesh Goudar cxgb4_dcb_enabled(dev) ? "yes" : "no"); 2402ebddd97aSGanesh Goudar 2403ebddd97aSGanesh Goudar if (cxgb4_dcb_enabled(dev)) 2404ebddd97aSGanesh Goudar seq_printf(seq, "[ DCBx Version %s ]\n", 2405ebddd97aSGanesh Goudar dcb_ver_array[dcb->dcb_version]); 2406ebddd97aSGanesh Goudar 2407ebddd97aSGanesh Goudar if (dcb->msgs) { 2408ebddd97aSGanesh Goudar int i; 2409ebddd97aSGanesh Goudar 2410ebddd97aSGanesh Goudar seq_puts(seq, "\n Index\t\t\t :\t"); 2411ebddd97aSGanesh Goudar for (i = 0; i < 8; i++) 2412ebddd97aSGanesh Goudar seq_printf(seq, " %3d", i); 2413ebddd97aSGanesh Goudar seq_puts(seq, "\n\n"); 2414ebddd97aSGanesh Goudar } 2415ebddd97aSGanesh Goudar 2416ebddd97aSGanesh Goudar if (dcb->msgs & CXGB4_DCB_FW_PGID) { 2417ebddd97aSGanesh Goudar int prio, pgid; 2418ebddd97aSGanesh Goudar 2419ebddd97aSGanesh Goudar seq_puts(seq, " Priority Group IDs\t :\t"); 2420ebddd97aSGanesh Goudar for (prio = 0; prio < 8; prio++) { 2421ebddd97aSGanesh Goudar pgid = (dcb->pgid >> 4 * (7 - prio)) & 0xf; 2422ebddd97aSGanesh Goudar seq_printf(seq, " %3d", pgid); 2423ebddd97aSGanesh Goudar } 2424ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2425ebddd97aSGanesh Goudar } 2426ebddd97aSGanesh Goudar 2427ebddd97aSGanesh Goudar if (dcb->msgs & CXGB4_DCB_FW_PGRATE) { 2428ebddd97aSGanesh Goudar int pg; 2429ebddd97aSGanesh Goudar 2430ebddd97aSGanesh Goudar seq_puts(seq, " Priority Group BW(%)\t :\t"); 2431ebddd97aSGanesh Goudar for (pg = 0; pg < 8; pg++) 2432ebddd97aSGanesh Goudar seq_printf(seq, " %3d", dcb->pgrate[pg]); 2433ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2434ebddd97aSGanesh Goudar 2435ebddd97aSGanesh Goudar if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) { 2436ebddd97aSGanesh Goudar seq_puts(seq, " TSA Algorithm\t\t :\t"); 2437ebddd97aSGanesh Goudar for (pg = 0; pg < 8; pg++) 2438ebddd97aSGanesh Goudar seq_printf(seq, " %3d", dcb->tsa[pg]); 2439ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2440ebddd97aSGanesh Goudar } 2441ebddd97aSGanesh Goudar 2442ebddd97aSGanesh Goudar seq_printf(seq, " Max PG Traffic Classes [%3d ]\n", 2443ebddd97aSGanesh Goudar dcb->pg_num_tcs_supported); 2444ebddd97aSGanesh Goudar 2445ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2446ebddd97aSGanesh Goudar } 2447ebddd97aSGanesh Goudar 2448ebddd97aSGanesh Goudar if (dcb->msgs & CXGB4_DCB_FW_PRIORATE) { 2449ebddd97aSGanesh Goudar int prio; 2450ebddd97aSGanesh Goudar 2451ebddd97aSGanesh Goudar seq_puts(seq, " Priority Rate\t:\t"); 2452ebddd97aSGanesh Goudar for (prio = 0; prio < 8; prio++) 2453ebddd97aSGanesh Goudar seq_printf(seq, " %3d", dcb->priorate[prio]); 2454ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2455ebddd97aSGanesh Goudar } 2456ebddd97aSGanesh Goudar 2457ebddd97aSGanesh Goudar if (dcb->msgs & CXGB4_DCB_FW_PFC) { 2458ebddd97aSGanesh Goudar int prio; 2459ebddd97aSGanesh Goudar 2460ebddd97aSGanesh Goudar seq_puts(seq, " Priority Flow Control :\t"); 2461ebddd97aSGanesh Goudar for (prio = 0; prio < 8; prio++) { 2462ebddd97aSGanesh Goudar int pfcen = (dcb->pfcen >> 1 * (7 - prio)) 2463ebddd97aSGanesh Goudar & 0x1; 2464ebddd97aSGanesh Goudar seq_printf(seq, " %3d", pfcen); 2465ebddd97aSGanesh Goudar } 2466ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2467ebddd97aSGanesh Goudar 2468ebddd97aSGanesh Goudar seq_printf(seq, " Max PFC Traffic Classes [%3d ]\n", 2469ebddd97aSGanesh Goudar dcb->pfc_num_tcs_supported); 2470ebddd97aSGanesh Goudar 2471ebddd97aSGanesh Goudar seq_puts(seq, "\n"); 2472ebddd97aSGanesh Goudar } 2473ebddd97aSGanesh Goudar 2474ebddd97aSGanesh Goudar if (dcb->msgs & CXGB4_DCB_FW_APP_ID) { 2475ebddd97aSGanesh Goudar int app, napps; 2476ebddd97aSGanesh Goudar 2477ebddd97aSGanesh Goudar seq_puts(seq, " Application Information:\n"); 2478ebddd97aSGanesh Goudar seq_puts(seq, " App Priority Selection Protocol\n"); 2479ebddd97aSGanesh Goudar seq_puts(seq, " Index Map Field ID\n"); 2480ebddd97aSGanesh Goudar for (app = 0, napps = 0; 2481ebddd97aSGanesh Goudar app < CXGB4_MAX_DCBX_APP_SUPPORTED; app++) { 2482ebddd97aSGanesh Goudar struct app_priority *ap; 2483ebddd97aSGanesh Goudar static const char * const sel_names[] = { 2484ebddd97aSGanesh Goudar "Ethertype", 2485ebddd97aSGanesh Goudar "Socket TCP", 2486ebddd97aSGanesh Goudar "Socket UDP", 2487ebddd97aSGanesh Goudar "Socket All", 2488ebddd97aSGanesh Goudar }; 2489ebddd97aSGanesh Goudar const char *sel_name; 2490ebddd97aSGanesh Goudar 2491ebddd97aSGanesh Goudar ap = &dcb->app_priority[app]; 2492ebddd97aSGanesh Goudar /* skip empty slots */ 2493ebddd97aSGanesh Goudar if (ap->protocolid == 0) 2494ebddd97aSGanesh Goudar continue; 2495ebddd97aSGanesh Goudar napps++; 2496ebddd97aSGanesh Goudar 2497ebddd97aSGanesh Goudar if (ap->sel_field < ARRAY_SIZE(sel_names)) 2498ebddd97aSGanesh Goudar sel_name = sel_names[ap->sel_field]; 2499ebddd97aSGanesh Goudar else 2500ebddd97aSGanesh Goudar sel_name = "UNKNOWN"; 2501ebddd97aSGanesh Goudar 2502ebddd97aSGanesh Goudar seq_printf(seq, " %3d %#04x %-10s (%d) %#06x (%d)\n", 2503ebddd97aSGanesh Goudar app, 2504ebddd97aSGanesh Goudar ap->user_prio_map, 2505ebddd97aSGanesh Goudar sel_name, ap->sel_field, 2506ebddd97aSGanesh Goudar ap->protocolid, ap->protocolid); 2507ebddd97aSGanesh Goudar } 2508ebddd97aSGanesh Goudar if (napps == 0) 2509ebddd97aSGanesh Goudar seq_puts(seq, " --- None ---\n"); 2510ebddd97aSGanesh Goudar } 2511ebddd97aSGanesh Goudar } 2512ebddd97aSGanesh Goudar return 0; 2513ebddd97aSGanesh Goudar } 2514ebddd97aSGanesh Goudar 2515ebddd97aSGanesh Goudar static inline void *dcb_info_get_idx(struct adapter *adap, loff_t pos) 2516ebddd97aSGanesh Goudar { 2517ebddd97aSGanesh Goudar return (pos <= adap->params.nports 2518ebddd97aSGanesh Goudar ? (void *)((uintptr_t)pos + 1) 2519ebddd97aSGanesh Goudar : NULL); 2520ebddd97aSGanesh Goudar } 2521ebddd97aSGanesh Goudar 2522ebddd97aSGanesh Goudar static void *dcb_info_start(struct seq_file *seq, loff_t *pos) 2523ebddd97aSGanesh Goudar { 2524ebddd97aSGanesh Goudar struct adapter *adap = seq->private; 2525ebddd97aSGanesh Goudar 2526ebddd97aSGanesh Goudar return (*pos 2527ebddd97aSGanesh Goudar ? dcb_info_get_idx(adap, *pos) 2528ebddd97aSGanesh Goudar : SEQ_START_TOKEN); 2529ebddd97aSGanesh Goudar } 2530ebddd97aSGanesh Goudar 2531ebddd97aSGanesh Goudar static void dcb_info_stop(struct seq_file *seq, void *v) 2532ebddd97aSGanesh Goudar { 2533ebddd97aSGanesh Goudar } 2534ebddd97aSGanesh Goudar 2535ebddd97aSGanesh Goudar static void *dcb_info_next(struct seq_file *seq, void *v, loff_t *pos) 2536ebddd97aSGanesh Goudar { 2537ebddd97aSGanesh Goudar struct adapter *adap = seq->private; 2538ebddd97aSGanesh Goudar 2539ebddd97aSGanesh Goudar (*pos)++; 2540ebddd97aSGanesh Goudar return dcb_info_get_idx(adap, *pos); 2541ebddd97aSGanesh Goudar } 2542ebddd97aSGanesh Goudar 2543ebddd97aSGanesh Goudar static const struct seq_operations dcb_info_seq_ops = { 2544ebddd97aSGanesh Goudar .start = dcb_info_start, 2545ebddd97aSGanesh Goudar .next = dcb_info_next, 2546ebddd97aSGanesh Goudar .stop = dcb_info_stop, 2547ebddd97aSGanesh Goudar .show = dcb_info_show 2548ebddd97aSGanesh Goudar }; 2549ebddd97aSGanesh Goudar 2550ebddd97aSGanesh Goudar static int dcb_info_open(struct inode *inode, struct file *file) 2551ebddd97aSGanesh Goudar { 2552ebddd97aSGanesh Goudar int res = seq_open(file, &dcb_info_seq_ops); 2553ebddd97aSGanesh Goudar 2554ebddd97aSGanesh Goudar if (!res) { 2555ebddd97aSGanesh Goudar struct seq_file *seq = file->private_data; 2556ebddd97aSGanesh Goudar 2557ebddd97aSGanesh Goudar seq->private = inode->i_private; 2558ebddd97aSGanesh Goudar } 2559ebddd97aSGanesh Goudar return res; 2560ebddd97aSGanesh Goudar } 2561ebddd97aSGanesh Goudar 2562ebddd97aSGanesh Goudar static const struct file_operations dcb_info_debugfs_fops = { 2563ebddd97aSGanesh Goudar .owner = THIS_MODULE, 2564ebddd97aSGanesh Goudar .open = dcb_info_open, 2565ebddd97aSGanesh Goudar .read = seq_read, 2566ebddd97aSGanesh Goudar .llseek = seq_lseek, 2567ebddd97aSGanesh Goudar .release = seq_release, 2568ebddd97aSGanesh Goudar }; 2569ebddd97aSGanesh Goudar #endif /* CONFIG_CHELSIO_T4_DCB */ 2570ebddd97aSGanesh Goudar 25710eaec62aSCasey Leedom static int resources_show(struct seq_file *seq, void *v) 25720eaec62aSCasey Leedom { 25730eaec62aSCasey Leedom struct adapter *adapter = seq->private; 25740eaec62aSCasey Leedom struct pf_resources *pfres = &adapter->params.pfres; 25750eaec62aSCasey Leedom 25760eaec62aSCasey Leedom #define S(desc, fmt, var) \ 25770eaec62aSCasey Leedom seq_printf(seq, "%-60s " fmt "\n", \ 25780eaec62aSCasey Leedom desc " (" #var "):", pfres->var) 25790eaec62aSCasey Leedom 25800eaec62aSCasey Leedom S("Virtual Interfaces", "%d", nvi); 25810eaec62aSCasey Leedom S("Egress Queues", "%d", neq); 25820eaec62aSCasey Leedom S("Ethernet Control", "%d", nethctrl); 25830eaec62aSCasey Leedom S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint); 25840eaec62aSCasey Leedom S("Ingress Queues", "%d", niq); 25850eaec62aSCasey Leedom S("Traffic Class", "%d", tc); 25860eaec62aSCasey Leedom S("Port Access Rights Mask", "%#x", pmask); 25870eaec62aSCasey Leedom S("MAC Address Filters", "%d", nexactf); 25880eaec62aSCasey Leedom S("Firmware Command Read Capabilities", "%#x", r_caps); 25890eaec62aSCasey Leedom S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps); 25900eaec62aSCasey Leedom 25910eaec62aSCasey Leedom #undef S 25920eaec62aSCasey Leedom 25930eaec62aSCasey Leedom return 0; 25940eaec62aSCasey Leedom } 2595b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(resources); 25960eaec62aSCasey Leedom 25973051fa61SHariprasad Shenai /** 25983051fa61SHariprasad Shenai * ethqset2pinfo - return port_info of an Ethernet Queue Set 25993051fa61SHariprasad Shenai * @adap: the adapter 26003051fa61SHariprasad Shenai * @qset: Ethernet Queue Set 26013051fa61SHariprasad Shenai */ 26023051fa61SHariprasad Shenai static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset) 26033051fa61SHariprasad Shenai { 26043051fa61SHariprasad Shenai int pidx; 26053051fa61SHariprasad Shenai 26063051fa61SHariprasad Shenai for_each_port(adap, pidx) { 26073051fa61SHariprasad Shenai struct port_info *pi = adap2pinfo(adap, pidx); 26083051fa61SHariprasad Shenai 26093051fa61SHariprasad Shenai if (qset >= pi->first_qset && 26103051fa61SHariprasad Shenai qset < pi->first_qset + pi->nqsets) 26113051fa61SHariprasad Shenai return pi; 26123051fa61SHariprasad Shenai } 26133051fa61SHariprasad Shenai 26143051fa61SHariprasad Shenai /* should never happen! */ 2615047a013fSArnd Bergmann BUG(); 26163051fa61SHariprasad Shenai return NULL; 26173051fa61SHariprasad Shenai } 26183051fa61SHariprasad Shenai 261927defe9dSRahul Lakkireddy static int sge_qinfo_uld_txq_entries(const struct adapter *adap, int uld) 262027defe9dSRahul Lakkireddy { 262127defe9dSRahul Lakkireddy const struct sge_uld_txq_info *utxq_info = adap->sge.uld_txq_info[uld]; 262227defe9dSRahul Lakkireddy 262327defe9dSRahul Lakkireddy if (!utxq_info) 262427defe9dSRahul Lakkireddy return 0; 262527defe9dSRahul Lakkireddy 262627defe9dSRahul Lakkireddy return DIV_ROUND_UP(utxq_info->ntxq, 4); 262727defe9dSRahul Lakkireddy } 262827defe9dSRahul Lakkireddy 262927defe9dSRahul Lakkireddy static int sge_qinfo_uld_rspq_entries(const struct adapter *adap, int uld, 263027defe9dSRahul Lakkireddy bool ciq) 263127defe9dSRahul Lakkireddy { 263227defe9dSRahul Lakkireddy const struct sge_uld_rxq_info *urxq_info = adap->sge.uld_rxq_info[uld]; 263327defe9dSRahul Lakkireddy 263427defe9dSRahul Lakkireddy if (!urxq_info) 263527defe9dSRahul Lakkireddy return 0; 263627defe9dSRahul Lakkireddy 263727defe9dSRahul Lakkireddy return ciq ? DIV_ROUND_UP(urxq_info->nciq, 4) : 263827defe9dSRahul Lakkireddy DIV_ROUND_UP(urxq_info->nrxq, 4); 263927defe9dSRahul Lakkireddy } 264027defe9dSRahul Lakkireddy 264127defe9dSRahul Lakkireddy static int sge_qinfo_uld_rxq_entries(const struct adapter *adap, int uld) 264227defe9dSRahul Lakkireddy { 264327defe9dSRahul Lakkireddy return sge_qinfo_uld_rspq_entries(adap, uld, false); 264427defe9dSRahul Lakkireddy } 264527defe9dSRahul Lakkireddy 264627defe9dSRahul Lakkireddy static int sge_qinfo_uld_ciq_entries(const struct adapter *adap, int uld) 264727defe9dSRahul Lakkireddy { 264827defe9dSRahul Lakkireddy return sge_qinfo_uld_rspq_entries(adap, uld, true); 264927defe9dSRahul Lakkireddy } 265027defe9dSRahul Lakkireddy 2651dc9daab2SHariprasad Shenai static int sge_qinfo_show(struct seq_file *seq, void *v) 2652dc9daab2SHariprasad Shenai { 26535148e595SRahul Lakkireddy int eth_entries, ctrl_entries, eohw_entries = 0, eosw_entries = 0; 265427defe9dSRahul Lakkireddy int uld_rxq_entries[CXGB4_ULD_MAX] = { 0 }; 265527defe9dSRahul Lakkireddy int uld_ciq_entries[CXGB4_ULD_MAX] = { 0 }; 265627defe9dSRahul Lakkireddy int uld_txq_entries[CXGB4_TX_MAX] = { 0 }; 265727defe9dSRahul Lakkireddy const struct sge_uld_txq_info *utxq_info; 265827defe9dSRahul Lakkireddy const struct sge_uld_rxq_info *urxq_info; 26595148e595SRahul Lakkireddy struct cxgb4_tc_port_mqprio *port_mqprio; 2660dc9daab2SHariprasad Shenai struct adapter *adap = seq->private; 26615148e595SRahul Lakkireddy int i, j, n, r = (uintptr_t)v - 1; 266227defe9dSRahul Lakkireddy struct sge *s = &adap->sge; 266327defe9dSRahul Lakkireddy 266427defe9dSRahul Lakkireddy eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4); 266527defe9dSRahul Lakkireddy ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4); 2666dc9daab2SHariprasad Shenai 2667dc9daab2SHariprasad Shenai if (r) 2668dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); 2669dc9daab2SHariprasad Shenai 2670dc9daab2SHariprasad Shenai #define S3(fmt_spec, s, v) \ 2671dc9daab2SHariprasad Shenai do { \ 2672dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s", s); \ 2673dc9daab2SHariprasad Shenai for (i = 0; i < n; ++i) \ 2674dc9daab2SHariprasad Shenai seq_printf(seq, " %16" fmt_spec, v); \ 2675dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); \ 2676dc9daab2SHariprasad Shenai } while (0) 2677dc9daab2SHariprasad Shenai #define S(s, v) S3("s", s, v) 2678e106a4d9SHariprasad Shenai #define T3(fmt_spec, s, v) S3(fmt_spec, s, tx[i].v) 2679dc9daab2SHariprasad Shenai #define T(s, v) S3("u", s, tx[i].v) 2680e106a4d9SHariprasad Shenai #define TL(s, v) T3("lu", s, v) 2681e106a4d9SHariprasad Shenai #define R3(fmt_spec, s, v) S3(fmt_spec, s, rx[i].v) 2682dc9daab2SHariprasad Shenai #define R(s, v) S3("u", s, rx[i].v) 2683e106a4d9SHariprasad Shenai #define RL(s, v) R3("lu", s, v) 2684dc9daab2SHariprasad Shenai 2685dc9daab2SHariprasad Shenai if (r < eth_entries) { 2686dc9daab2SHariprasad Shenai int base_qset = r * 4; 268727defe9dSRahul Lakkireddy const struct sge_eth_rxq *rx = &s->ethrxq[base_qset]; 268827defe9dSRahul Lakkireddy const struct sge_eth_txq *tx = &s->ethtxq[base_qset]; 268927defe9dSRahul Lakkireddy 269027defe9dSRahul Lakkireddy n = min(4, s->ethqsets - 4 * r); 2691dc9daab2SHariprasad Shenai 2692dc9daab2SHariprasad Shenai S("QType:", "Ethernet"); 2693dc9daab2SHariprasad Shenai S("Interface:", 2694dc9daab2SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 2695dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 2696dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 2697dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 2698dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 2699dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 27003051fa61SHariprasad Shenai #ifdef CONFIG_CHELSIO_T4_DCB 2701dc9daab2SHariprasad Shenai T("DCB Prio:", dcb_prio); 2702dc9daab2SHariprasad Shenai S3("u", "DCB PGID:", 2703dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >> 2704dc9daab2SHariprasad Shenai 4*(7-tx[i].dcb_prio)) & 0xf); 2705dc9daab2SHariprasad Shenai S3("u", "DCB PFC:", 2706dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >> 2707dc9daab2SHariprasad Shenai 1*(7-tx[i].dcb_prio)) & 0x1); 2708dc9daab2SHariprasad Shenai #endif 2709dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 2710dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 2711dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 2712dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 2713dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 2714dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 271527defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 2716dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 2717dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 2718dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 2719dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 2720dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 2721dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 2722e106a4d9SHariprasad Shenai RL("RxPackets:", stats.pkts); 2723e106a4d9SHariprasad Shenai RL("RxCSO:", stats.rx_cso); 2724e106a4d9SHariprasad Shenai RL("VLANxtract:", stats.vlan_ex); 2725e106a4d9SHariprasad Shenai RL("LROmerged:", stats.lro_merged); 2726e106a4d9SHariprasad Shenai RL("LROpackets:", stats.lro_pkts); 2727e106a4d9SHariprasad Shenai RL("RxDrops:", stats.rx_drops); 2728992bea8eSGanesh Goudar RL("RxBadPkts:", stats.bad_rx_pkts); 2729e106a4d9SHariprasad Shenai TL("TSO:", tso); 27301a2a14fbSRahul Lakkireddy TL("USO:", uso); 2731e106a4d9SHariprasad Shenai TL("TxCSO:", tx_cso); 2732e106a4d9SHariprasad Shenai TL("VLANins:", vlan_ins); 2733e106a4d9SHariprasad Shenai TL("TxQFull:", q.stops); 2734e106a4d9SHariprasad Shenai TL("TxQRestarts:", q.restarts); 2735e106a4d9SHariprasad Shenai TL("TxMapErr:", mapping_err); 2736e106a4d9SHariprasad Shenai RL("FLAllocErr:", fl.alloc_failed); 2737e106a4d9SHariprasad Shenai RL("FLLrgAlcErr:", fl.large_alloc_failed); 273870055dd0SHariprasad Shenai RL("FLMapErr:", fl.mapping_err); 273970055dd0SHariprasad Shenai RL("FLLow:", fl.low); 2740e106a4d9SHariprasad Shenai RL("FLStarving:", fl.starving); 2741dc9daab2SHariprasad Shenai 27425148e595SRahul Lakkireddy goto out; 274327defe9dSRahul Lakkireddy } 274427defe9dSRahul Lakkireddy 274527defe9dSRahul Lakkireddy r -= eth_entries; 27465148e595SRahul Lakkireddy if (!adap->tc_mqprio) 27475148e595SRahul Lakkireddy goto skip_mqprio; 27485148e595SRahul Lakkireddy 27495148e595SRahul Lakkireddy mutex_lock(&adap->tc_mqprio->mqprio_mutex); 27505148e595SRahul Lakkireddy if (!refcount_read(&adap->tc_mqprio->refcnt)) { 27515148e595SRahul Lakkireddy mutex_unlock(&adap->tc_mqprio->mqprio_mutex); 27525148e595SRahul Lakkireddy goto skip_mqprio; 27535148e595SRahul Lakkireddy } 27545148e595SRahul Lakkireddy 27555148e595SRahul Lakkireddy eohw_entries = DIV_ROUND_UP(adap->sge.eoqsets, 4); 27565148e595SRahul Lakkireddy if (r < eohw_entries) { 27572d0cb84dSRahul Lakkireddy int base_qset = r * 4; 27582d0cb84dSRahul Lakkireddy const struct sge_ofld_rxq *rx = &s->eohw_rxq[base_qset]; 27592d0cb84dSRahul Lakkireddy const struct sge_eohw_txq *tx = &s->eohw_txq[base_qset]; 27602d0cb84dSRahul Lakkireddy 27612d0cb84dSRahul Lakkireddy n = min(4, s->eoqsets - 4 * r); 27622d0cb84dSRahul Lakkireddy 27632d0cb84dSRahul Lakkireddy S("QType:", "ETHOFLD"); 27642d0cb84dSRahul Lakkireddy S("Interface:", 27652d0cb84dSRahul Lakkireddy rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 27662d0cb84dSRahul Lakkireddy T("TxQ ID:", q.cntxt_id); 27672d0cb84dSRahul Lakkireddy T("TxQ size:", q.size); 27682d0cb84dSRahul Lakkireddy T("TxQ inuse:", q.in_use); 27692d0cb84dSRahul Lakkireddy T("TxQ CIDX:", q.cidx); 27702d0cb84dSRahul Lakkireddy T("TxQ PIDX:", q.pidx); 27712d0cb84dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 27722d0cb84dSRahul Lakkireddy R("RspQ size:", rspq.size); 27732d0cb84dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 27742d0cb84dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 27752d0cb84dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 27762d0cb84dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 27772d0cb84dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 27782d0cb84dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 27792d0cb84dSRahul Lakkireddy S3("u", "FL size:", rx->fl.size ? rx->fl.size - 8 : 0); 27802d0cb84dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 27812d0cb84dSRahul Lakkireddy R("FL avail:", fl.avail); 27822d0cb84dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 27832d0cb84dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 27842d0cb84dSRahul Lakkireddy RL("RxPackets:", stats.pkts); 27852d0cb84dSRahul Lakkireddy RL("RxImm:", stats.imm); 27862d0cb84dSRahul Lakkireddy RL("RxAN", stats.an); 27872d0cb84dSRahul Lakkireddy RL("RxNoMem", stats.nomem); 27882d0cb84dSRahul Lakkireddy TL("TSO:", tso); 27898311f0beSRahul Lakkireddy TL("USO:", uso); 27902d0cb84dSRahul Lakkireddy TL("TxCSO:", tx_cso); 27912d0cb84dSRahul Lakkireddy TL("VLANins:", vlan_ins); 27922d0cb84dSRahul Lakkireddy TL("TxQFull:", q.stops); 27932d0cb84dSRahul Lakkireddy TL("TxQRestarts:", q.restarts); 27942d0cb84dSRahul Lakkireddy TL("TxMapErr:", mapping_err); 27952d0cb84dSRahul Lakkireddy RL("FLAllocErr:", fl.alloc_failed); 27962d0cb84dSRahul Lakkireddy RL("FLLrgAlcErr:", fl.large_alloc_failed); 27972d0cb84dSRahul Lakkireddy RL("FLMapErr:", fl.mapping_err); 27982d0cb84dSRahul Lakkireddy RL("FLLow:", fl.low); 27992d0cb84dSRahul Lakkireddy RL("FLStarving:", fl.starving); 28002d0cb84dSRahul Lakkireddy 28015148e595SRahul Lakkireddy mutex_unlock(&adap->tc_mqprio->mqprio_mutex); 28025148e595SRahul Lakkireddy goto out; 28032d0cb84dSRahul Lakkireddy } 28042d0cb84dSRahul Lakkireddy 28055148e595SRahul Lakkireddy r -= eohw_entries; 28065148e595SRahul Lakkireddy for (j = 0; j < adap->params.nports; j++) { 28075148e595SRahul Lakkireddy int entries; 28085148e595SRahul Lakkireddy u8 tc; 28095148e595SRahul Lakkireddy 28105148e595SRahul Lakkireddy port_mqprio = &adap->tc_mqprio->port_mqprio[j]; 28115148e595SRahul Lakkireddy entries = 0; 28125148e595SRahul Lakkireddy for (tc = 0; tc < port_mqprio->mqprio.qopt.num_tc; tc++) 28135148e595SRahul Lakkireddy entries += port_mqprio->mqprio.qopt.count[tc]; 28145148e595SRahul Lakkireddy 28155148e595SRahul Lakkireddy if (!entries) 28165148e595SRahul Lakkireddy continue; 28175148e595SRahul Lakkireddy 28185148e595SRahul Lakkireddy eosw_entries = DIV_ROUND_UP(entries, 4); 28195148e595SRahul Lakkireddy if (r < eosw_entries) { 28205148e595SRahul Lakkireddy const struct sge_eosw_txq *tx; 28215148e595SRahul Lakkireddy 28225148e595SRahul Lakkireddy n = min(4, entries - 4 * r); 28235148e595SRahul Lakkireddy tx = &port_mqprio->eosw_txq[4 * r]; 28245148e595SRahul Lakkireddy 28255148e595SRahul Lakkireddy S("QType:", "EOSW-TXQ"); 28265148e595SRahul Lakkireddy S("Interface:", 28275148e595SRahul Lakkireddy adap->port[j] ? adap->port[j]->name : "N/A"); 28285148e595SRahul Lakkireddy T("EOTID:", hwtid); 28295148e595SRahul Lakkireddy T("HWQID:", hwqid); 28305148e595SRahul Lakkireddy T("State:", state); 28315148e595SRahul Lakkireddy T("Size:", ndesc); 28325148e595SRahul Lakkireddy T("In-Use:", inuse); 28335148e595SRahul Lakkireddy T("Credits:", cred); 28345148e595SRahul Lakkireddy T("Compl:", ncompl); 28355148e595SRahul Lakkireddy T("Last-Compl:", last_compl); 28365148e595SRahul Lakkireddy T("PIDX:", pidx); 28375148e595SRahul Lakkireddy T("Last-PIDX:", last_pidx); 28385148e595SRahul Lakkireddy T("CIDX:", cidx); 28395148e595SRahul Lakkireddy T("Last-CIDX:", last_cidx); 28405148e595SRahul Lakkireddy T("FLOWC-IDX:", flowc_idx); 28415148e595SRahul Lakkireddy 28425148e595SRahul Lakkireddy mutex_unlock(&adap->tc_mqprio->mqprio_mutex); 28435148e595SRahul Lakkireddy goto out; 28445148e595SRahul Lakkireddy } 28455148e595SRahul Lakkireddy 28465148e595SRahul Lakkireddy r -= eosw_entries; 28475148e595SRahul Lakkireddy } 28485148e595SRahul Lakkireddy mutex_unlock(&adap->tc_mqprio->mqprio_mutex); 28495148e595SRahul Lakkireddy 28505148e595SRahul Lakkireddy skip_mqprio: 28515148e595SRahul Lakkireddy if (!is_uld(adap)) 28525148e595SRahul Lakkireddy goto skip_uld; 28535148e595SRahul Lakkireddy 28545148e595SRahul Lakkireddy mutex_lock(&uld_mutex); 28555148e595SRahul Lakkireddy if (s->uld_txq_info) 28565148e595SRahul Lakkireddy for (i = 0; i < ARRAY_SIZE(uld_txq_entries); i++) 28575148e595SRahul Lakkireddy uld_txq_entries[i] = sge_qinfo_uld_txq_entries(adap, i); 28585148e595SRahul Lakkireddy 28595148e595SRahul Lakkireddy if (s->uld_rxq_info) { 28605148e595SRahul Lakkireddy for (i = 0; i < ARRAY_SIZE(uld_rxq_entries); i++) { 28615148e595SRahul Lakkireddy uld_rxq_entries[i] = sge_qinfo_uld_rxq_entries(adap, i); 28625148e595SRahul Lakkireddy uld_ciq_entries[i] = sge_qinfo_uld_ciq_entries(adap, i); 28635148e595SRahul Lakkireddy } 28645148e595SRahul Lakkireddy } 28655148e595SRahul Lakkireddy 286627defe9dSRahul Lakkireddy if (r < uld_txq_entries[CXGB4_TX_OFLD]) { 286727defe9dSRahul Lakkireddy const struct sge_uld_txq *tx; 286827defe9dSRahul Lakkireddy 286927defe9dSRahul Lakkireddy utxq_info = s->uld_txq_info[CXGB4_TX_OFLD]; 287027defe9dSRahul Lakkireddy tx = &utxq_info->uldtxq[r * 4]; 287127defe9dSRahul Lakkireddy n = min(4, utxq_info->ntxq - 4 * r); 287227defe9dSRahul Lakkireddy 287327defe9dSRahul Lakkireddy S("QType:", "OFLD-TXQ"); 287427defe9dSRahul Lakkireddy T("TxQ ID:", q.cntxt_id); 287527defe9dSRahul Lakkireddy T("TxQ size:", q.size); 287627defe9dSRahul Lakkireddy T("TxQ inuse:", q.in_use); 287727defe9dSRahul Lakkireddy T("TxQ CIDX:", q.cidx); 287827defe9dSRahul Lakkireddy T("TxQ PIDX:", q.pidx); 287927defe9dSRahul Lakkireddy 288027defe9dSRahul Lakkireddy goto unlock; 288127defe9dSRahul Lakkireddy } 288227defe9dSRahul Lakkireddy 288327defe9dSRahul Lakkireddy r -= uld_txq_entries[CXGB4_TX_OFLD]; 288427defe9dSRahul Lakkireddy if (r < uld_rxq_entries[CXGB4_ULD_RDMA]) { 288527defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 288627defe9dSRahul Lakkireddy 288727defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_RDMA]; 288827defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[r * 4]; 288927defe9dSRahul Lakkireddy n = min(4, urxq_info->nrxq - 4 * r); 289027defe9dSRahul Lakkireddy 289127defe9dSRahul Lakkireddy S("QType:", "RDMA-CPL"); 289227defe9dSRahul Lakkireddy S("Interface:", 289327defe9dSRahul Lakkireddy rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 289427defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 289527defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 289627defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 289727defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 289827defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 289927defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 290027defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 290127defe9dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 290227defe9dSRahul Lakkireddy R("FL size:", fl.size - 8); 290327defe9dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 290427defe9dSRahul Lakkireddy R("FL avail:", fl.avail); 290527defe9dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 290627defe9dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 290727defe9dSRahul Lakkireddy 290827defe9dSRahul Lakkireddy goto unlock; 290927defe9dSRahul Lakkireddy } 291027defe9dSRahul Lakkireddy 291127defe9dSRahul Lakkireddy r -= uld_rxq_entries[CXGB4_ULD_RDMA]; 291227defe9dSRahul Lakkireddy if (r < uld_ciq_entries[CXGB4_ULD_RDMA]) { 291327defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 291427defe9dSRahul Lakkireddy int ciq_idx = 0; 291527defe9dSRahul Lakkireddy 291627defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_RDMA]; 291727defe9dSRahul Lakkireddy ciq_idx = urxq_info->nrxq + (r * 4); 291827defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[ciq_idx]; 291927defe9dSRahul Lakkireddy n = min(4, urxq_info->nciq - 4 * r); 292027defe9dSRahul Lakkireddy 292127defe9dSRahul Lakkireddy S("QType:", "RDMA-CIQ"); 292227defe9dSRahul Lakkireddy S("Interface:", 292327defe9dSRahul Lakkireddy rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 292427defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 292527defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 292627defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 292727defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 292827defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 292927defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 293027defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 293127defe9dSRahul Lakkireddy 293227defe9dSRahul Lakkireddy goto unlock; 293327defe9dSRahul Lakkireddy } 293427defe9dSRahul Lakkireddy 293527defe9dSRahul Lakkireddy r -= uld_ciq_entries[CXGB4_ULD_RDMA]; 293627defe9dSRahul Lakkireddy if (r < uld_rxq_entries[CXGB4_ULD_ISCSI]) { 293727defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 293827defe9dSRahul Lakkireddy 293927defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_ISCSI]; 294027defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[r * 4]; 294127defe9dSRahul Lakkireddy n = min(4, urxq_info->nrxq - 4 * r); 294227defe9dSRahul Lakkireddy 294327defe9dSRahul Lakkireddy S("QType:", "iSCSI"); 294427defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 294527defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 294627defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 294727defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 294827defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 294927defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 295027defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 295127defe9dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 295227defe9dSRahul Lakkireddy R("FL size:", fl.size - 8); 295327defe9dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 295427defe9dSRahul Lakkireddy R("FL avail:", fl.avail); 295527defe9dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 295627defe9dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 295727defe9dSRahul Lakkireddy 295827defe9dSRahul Lakkireddy goto unlock; 295927defe9dSRahul Lakkireddy } 296027defe9dSRahul Lakkireddy 296127defe9dSRahul Lakkireddy r -= uld_rxq_entries[CXGB4_ULD_ISCSI]; 296227defe9dSRahul Lakkireddy if (r < uld_rxq_entries[CXGB4_ULD_ISCSIT]) { 296327defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 296427defe9dSRahul Lakkireddy 296527defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_ISCSIT]; 296627defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[r * 4]; 296727defe9dSRahul Lakkireddy n = min(4, urxq_info->nrxq - 4 * r); 296827defe9dSRahul Lakkireddy 296927defe9dSRahul Lakkireddy S("QType:", "iSCSIT"); 297027defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 297127defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 297227defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 297327defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 297427defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 297527defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 297627defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 297727defe9dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 297827defe9dSRahul Lakkireddy R("FL size:", fl.size - 8); 297927defe9dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 298027defe9dSRahul Lakkireddy R("FL avail:", fl.avail); 298127defe9dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 298227defe9dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 298327defe9dSRahul Lakkireddy 298427defe9dSRahul Lakkireddy goto unlock; 298527defe9dSRahul Lakkireddy } 298627defe9dSRahul Lakkireddy 298727defe9dSRahul Lakkireddy r -= uld_rxq_entries[CXGB4_ULD_ISCSIT]; 298827defe9dSRahul Lakkireddy if (r < uld_rxq_entries[CXGB4_ULD_TLS]) { 298927defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 299027defe9dSRahul Lakkireddy 299127defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_TLS]; 299227defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[r * 4]; 299327defe9dSRahul Lakkireddy n = min(4, urxq_info->nrxq - 4 * r); 299427defe9dSRahul Lakkireddy 299527defe9dSRahul Lakkireddy S("QType:", "TLS"); 299627defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 299727defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 299827defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 299927defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 300027defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 300127defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 300227defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 300327defe9dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 300427defe9dSRahul Lakkireddy R("FL size:", fl.size - 8); 300527defe9dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 300627defe9dSRahul Lakkireddy R("FL avail:", fl.avail); 300727defe9dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 300827defe9dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 300927defe9dSRahul Lakkireddy 301027defe9dSRahul Lakkireddy goto unlock; 301127defe9dSRahul Lakkireddy } 301227defe9dSRahul Lakkireddy 301327defe9dSRahul Lakkireddy r -= uld_rxq_entries[CXGB4_ULD_TLS]; 301427defe9dSRahul Lakkireddy if (r < uld_txq_entries[CXGB4_TX_CRYPTO]) { 301527defe9dSRahul Lakkireddy const struct sge_ofld_rxq *rx; 301627defe9dSRahul Lakkireddy const struct sge_uld_txq *tx; 301727defe9dSRahul Lakkireddy 301827defe9dSRahul Lakkireddy utxq_info = s->uld_txq_info[CXGB4_TX_CRYPTO]; 301927defe9dSRahul Lakkireddy urxq_info = s->uld_rxq_info[CXGB4_ULD_CRYPTO]; 302027defe9dSRahul Lakkireddy tx = &utxq_info->uldtxq[r * 4]; 302127defe9dSRahul Lakkireddy rx = &urxq_info->uldrxq[r * 4]; 302227defe9dSRahul Lakkireddy n = min(4, utxq_info->ntxq - 4 * r); 302327defe9dSRahul Lakkireddy 302427defe9dSRahul Lakkireddy S("QType:", "Crypto"); 302527defe9dSRahul Lakkireddy T("TxQ ID:", q.cntxt_id); 302627defe9dSRahul Lakkireddy T("TxQ size:", q.size); 302727defe9dSRahul Lakkireddy T("TxQ inuse:", q.in_use); 302827defe9dSRahul Lakkireddy T("TxQ CIDX:", q.cidx); 302927defe9dSRahul Lakkireddy T("TxQ PIDX:", q.pidx); 303027defe9dSRahul Lakkireddy R("RspQ ID:", rspq.abs_id); 303127defe9dSRahul Lakkireddy R("RspQ size:", rspq.size); 303227defe9dSRahul Lakkireddy R("RspQE size:", rspq.iqe_len); 303327defe9dSRahul Lakkireddy R("RspQ CIDX:", rspq.cidx); 303427defe9dSRahul Lakkireddy R("RspQ Gen:", rspq.gen); 303527defe9dSRahul Lakkireddy S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 303627defe9dSRahul Lakkireddy S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]); 303727defe9dSRahul Lakkireddy R("FL ID:", fl.cntxt_id); 303827defe9dSRahul Lakkireddy R("FL size:", fl.size - 8); 303927defe9dSRahul Lakkireddy R("FL pend:", fl.pend_cred); 304027defe9dSRahul Lakkireddy R("FL avail:", fl.avail); 304127defe9dSRahul Lakkireddy R("FL PIDX:", fl.pidx); 304227defe9dSRahul Lakkireddy R("FL CIDX:", fl.cidx); 304327defe9dSRahul Lakkireddy 304427defe9dSRahul Lakkireddy goto unlock; 304527defe9dSRahul Lakkireddy } 304627defe9dSRahul Lakkireddy 304727defe9dSRahul Lakkireddy r -= uld_txq_entries[CXGB4_TX_CRYPTO]; 30485148e595SRahul Lakkireddy mutex_unlock(&uld_mutex); 30495148e595SRahul Lakkireddy 30505148e595SRahul Lakkireddy skip_uld: 305127defe9dSRahul Lakkireddy if (r < ctrl_entries) { 305227defe9dSRahul Lakkireddy const struct sge_ctrl_txq *tx = &s->ctrlq[r * 4]; 305327defe9dSRahul Lakkireddy 305427defe9dSRahul Lakkireddy n = min(4, adap->params.nports - 4 * r); 3055dc9daab2SHariprasad Shenai 3056dc9daab2SHariprasad Shenai S("QType:", "Control"); 3057dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 3058dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 3059dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 3060dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 3061dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 3062e106a4d9SHariprasad Shenai TL("TxQFull:", q.stops); 3063e106a4d9SHariprasad Shenai TL("TxQRestarts:", q.restarts); 306427defe9dSRahul Lakkireddy 30655148e595SRahul Lakkireddy goto out; 306627defe9dSRahul Lakkireddy } 306727defe9dSRahul Lakkireddy 306827defe9dSRahul Lakkireddy r -= ctrl_entries; 306927defe9dSRahul Lakkireddy if (r < 1) { 307027defe9dSRahul Lakkireddy const struct sge_rspq *evtq = &s->fw_evtq; 3071dc9daab2SHariprasad Shenai 3072dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); 3073dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); 3074dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size); 3075dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len); 3076dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx); 3077dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); 3078dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr delay:", 3079dc9daab2SHariprasad Shenai qtimer_val(adap, evtq)); 3080dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 308127defe9dSRahul Lakkireddy s->counter_val[evtq->pktcnt_idx]); 308227defe9dSRahul Lakkireddy 30835148e595SRahul Lakkireddy goto out; 3084dc9daab2SHariprasad Shenai } 308527defe9dSRahul Lakkireddy 3086dc9daab2SHariprasad Shenai #undef R 3087e106a4d9SHariprasad Shenai #undef RL 3088dc9daab2SHariprasad Shenai #undef T 3089e106a4d9SHariprasad Shenai #undef TL 3090dc9daab2SHariprasad Shenai #undef S 3091e106a4d9SHariprasad Shenai #undef R3 3092e106a4d9SHariprasad Shenai #undef T3 3093dc9daab2SHariprasad Shenai #undef S3 30945148e595SRahul Lakkireddy out: 30955148e595SRahul Lakkireddy return 0; 30965148e595SRahul Lakkireddy 30975148e595SRahul Lakkireddy unlock: 30985148e595SRahul Lakkireddy mutex_unlock(&uld_mutex); 3099dc9daab2SHariprasad Shenai return 0; 3100dc9daab2SHariprasad Shenai } 3101dc9daab2SHariprasad Shenai 3102dc9daab2SHariprasad Shenai static int sge_queue_entries(const struct adapter *adap) 3103dc9daab2SHariprasad Shenai { 31045148e595SRahul Lakkireddy int i, tot_uld_entries = 0, eohw_entries = 0, eosw_entries = 0; 31055148e595SRahul Lakkireddy 31065148e595SRahul Lakkireddy if (adap->tc_mqprio) { 31075148e595SRahul Lakkireddy struct cxgb4_tc_port_mqprio *port_mqprio; 31085148e595SRahul Lakkireddy u8 tc; 31095148e595SRahul Lakkireddy 31105148e595SRahul Lakkireddy mutex_lock(&adap->tc_mqprio->mqprio_mutex); 31115148e595SRahul Lakkireddy if (adap->sge.eohw_txq) 31125148e595SRahul Lakkireddy eohw_entries = DIV_ROUND_UP(adap->sge.eoqsets, 4); 31135148e595SRahul Lakkireddy 31145148e595SRahul Lakkireddy for (i = 0; i < adap->params.nports; i++) { 31155148e595SRahul Lakkireddy u32 entries = 0; 31165148e595SRahul Lakkireddy 31175148e595SRahul Lakkireddy port_mqprio = &adap->tc_mqprio->port_mqprio[i]; 31185148e595SRahul Lakkireddy for (tc = 0; tc < port_mqprio->mqprio.qopt.num_tc; tc++) 31195148e595SRahul Lakkireddy entries += port_mqprio->mqprio.qopt.count[tc]; 31205148e595SRahul Lakkireddy 31215148e595SRahul Lakkireddy if (entries) 31225148e595SRahul Lakkireddy eosw_entries += DIV_ROUND_UP(entries, 4); 31235148e595SRahul Lakkireddy } 31245148e595SRahul Lakkireddy mutex_unlock(&adap->tc_mqprio->mqprio_mutex); 31255148e595SRahul Lakkireddy } 312627defe9dSRahul Lakkireddy 3127479a0d13SVishal Kulkarni if (!is_uld(adap)) 3128479a0d13SVishal Kulkarni goto lld_only; 3129479a0d13SVishal Kulkarni 313027defe9dSRahul Lakkireddy mutex_lock(&uld_mutex); 313127defe9dSRahul Lakkireddy for (i = 0; i < CXGB4_TX_MAX; i++) 313227defe9dSRahul Lakkireddy tot_uld_entries += sge_qinfo_uld_txq_entries(adap, i); 313327defe9dSRahul Lakkireddy 313427defe9dSRahul Lakkireddy for (i = 0; i < CXGB4_ULD_MAX; i++) { 313527defe9dSRahul Lakkireddy tot_uld_entries += sge_qinfo_uld_rxq_entries(adap, i); 313627defe9dSRahul Lakkireddy tot_uld_entries += sge_qinfo_uld_ciq_entries(adap, i); 313727defe9dSRahul Lakkireddy } 313827defe9dSRahul Lakkireddy mutex_unlock(&uld_mutex); 313927defe9dSRahul Lakkireddy 3140479a0d13SVishal Kulkarni lld_only: 3141dc9daab2SHariprasad Shenai return DIV_ROUND_UP(adap->sge.ethqsets, 4) + 31425148e595SRahul Lakkireddy eohw_entries + eosw_entries + tot_uld_entries + 3143dc9daab2SHariprasad Shenai DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1; 3144dc9daab2SHariprasad Shenai } 3145dc9daab2SHariprasad Shenai 3146dc9daab2SHariprasad Shenai static void *sge_queue_start(struct seq_file *seq, loff_t *pos) 3147dc9daab2SHariprasad Shenai { 3148dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 3149dc9daab2SHariprasad Shenai 3150dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 3151dc9daab2SHariprasad Shenai } 3152dc9daab2SHariprasad Shenai 3153dc9daab2SHariprasad Shenai static void sge_queue_stop(struct seq_file *seq, void *v) 3154dc9daab2SHariprasad Shenai { 3155dc9daab2SHariprasad Shenai } 3156dc9daab2SHariprasad Shenai 3157dc9daab2SHariprasad Shenai static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) 3158dc9daab2SHariprasad Shenai { 3159dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 3160dc9daab2SHariprasad Shenai 3161dc9daab2SHariprasad Shenai ++*pos; 3162dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 3163dc9daab2SHariprasad Shenai } 3164dc9daab2SHariprasad Shenai 3165dc9daab2SHariprasad Shenai static const struct seq_operations sge_qinfo_seq_ops = { 3166dc9daab2SHariprasad Shenai .start = sge_queue_start, 3167dc9daab2SHariprasad Shenai .next = sge_queue_next, 3168dc9daab2SHariprasad Shenai .stop = sge_queue_stop, 3169dc9daab2SHariprasad Shenai .show = sge_qinfo_show 3170dc9daab2SHariprasad Shenai }; 3171dc9daab2SHariprasad Shenai 3172dc9daab2SHariprasad Shenai static int sge_qinfo_open(struct inode *inode, struct file *file) 3173dc9daab2SHariprasad Shenai { 3174dc9daab2SHariprasad Shenai int res = seq_open(file, &sge_qinfo_seq_ops); 3175dc9daab2SHariprasad Shenai 3176dc9daab2SHariprasad Shenai if (!res) { 3177dc9daab2SHariprasad Shenai struct seq_file *seq = file->private_data; 3178dc9daab2SHariprasad Shenai 3179dc9daab2SHariprasad Shenai seq->private = inode->i_private; 3180dc9daab2SHariprasad Shenai } 3181dc9daab2SHariprasad Shenai return res; 3182dc9daab2SHariprasad Shenai } 3183dc9daab2SHariprasad Shenai 3184dc9daab2SHariprasad Shenai static const struct file_operations sge_qinfo_debugfs_fops = { 3185dc9daab2SHariprasad Shenai .owner = THIS_MODULE, 3186dc9daab2SHariprasad Shenai .open = sge_qinfo_open, 3187dc9daab2SHariprasad Shenai .read = seq_read, 3188dc9daab2SHariprasad Shenai .llseek = seq_lseek, 3189dc9daab2SHariprasad Shenai .release = seq_release, 3190dc9daab2SHariprasad Shenai }; 3191dc9daab2SHariprasad Shenai 319249216c1cSHariprasad Shenai int mem_open(struct inode *inode, struct file *file) 319349216c1cSHariprasad Shenai { 319449216c1cSHariprasad Shenai unsigned int mem; 319549216c1cSHariprasad Shenai struct adapter *adap; 319649216c1cSHariprasad Shenai 319749216c1cSHariprasad Shenai file->private_data = inode->i_private; 319849216c1cSHariprasad Shenai 31998b4e6b3cSArjun Vynipadath mem = (uintptr_t)file->private_data & 0x7; 320049216c1cSHariprasad Shenai adap = file->private_data - mem; 320149216c1cSHariprasad Shenai 320249216c1cSHariprasad Shenai (void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH); 320349216c1cSHariprasad Shenai 320449216c1cSHariprasad Shenai return 0; 320549216c1cSHariprasad Shenai } 320649216c1cSHariprasad Shenai 3207fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 3208fd88b31aSHariprasad Shenai loff_t *ppos) 3209fd88b31aSHariprasad Shenai { 3210fd88b31aSHariprasad Shenai loff_t pos = *ppos; 3211fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 32128b4e6b3cSArjun Vynipadath unsigned int mem = (uintptr_t)file->private_data & 0x7; 3213fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 3214fd88b31aSHariprasad Shenai __be32 *data; 3215fd88b31aSHariprasad Shenai int ret; 3216fd88b31aSHariprasad Shenai 3217fd88b31aSHariprasad Shenai if (pos < 0) 3218fd88b31aSHariprasad Shenai return -EINVAL; 3219fd88b31aSHariprasad Shenai if (pos >= avail) 3220fd88b31aSHariprasad Shenai return 0; 3221fd88b31aSHariprasad Shenai if (count > avail - pos) 3222fd88b31aSHariprasad Shenai count = avail - pos; 3223fd88b31aSHariprasad Shenai 3224752ade68SMichal Hocko data = kvzalloc(count, GFP_KERNEL); 3225fd88b31aSHariprasad Shenai if (!data) 3226fd88b31aSHariprasad Shenai return -ENOMEM; 3227fd88b31aSHariprasad Shenai 3228fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 3229fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 3230fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 3231fd88b31aSHariprasad Shenai if (ret) { 3232752ade68SMichal Hocko kvfree(data); 3233fd88b31aSHariprasad Shenai return ret; 3234fd88b31aSHariprasad Shenai } 3235fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 3236fd88b31aSHariprasad Shenai 3237752ade68SMichal Hocko kvfree(data); 3238fd88b31aSHariprasad Shenai if (ret) 3239fd88b31aSHariprasad Shenai return -EFAULT; 3240fd88b31aSHariprasad Shenai 3241fd88b31aSHariprasad Shenai *ppos = pos + count; 3242fd88b31aSHariprasad Shenai return count; 3243fd88b31aSHariprasad Shenai } 3244fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 3245fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 3246fd88b31aSHariprasad Shenai .open = simple_open, 3247fd88b31aSHariprasad Shenai .read = mem_read, 3248fd88b31aSHariprasad Shenai .llseek = default_llseek, 3249fd88b31aSHariprasad Shenai }; 3250fd88b31aSHariprasad Shenai 3251a4011fd4SHariprasad Shenai static int tid_info_show(struct seq_file *seq, void *v) 3252a4011fd4SHariprasad Shenai { 3253a4011fd4SHariprasad Shenai struct adapter *adap = seq->private; 325459437d78SShahjada Abul Husain const struct tid_info *t; 325559437d78SShahjada Abul Husain enum chip_type chip; 3256a4011fd4SHariprasad Shenai 325759437d78SShahjada Abul Husain t = &adap->tids; 325859437d78SShahjada Abul Husain chip = CHELSIO_CHIP_VERSION(adap->params.chip); 3259a4011fd4SHariprasad Shenai if (t4_read_reg(adap, LE_DB_CONFIG_A) & HASHEN_F) { 3260a4011fd4SHariprasad Shenai unsigned int sb; 32611dec4cecSGanesh Goudar seq_printf(seq, "Connections in use: %u\n", 32621dec4cecSGanesh Goudar atomic_read(&t->conns_in_use)); 3263a4011fd4SHariprasad Shenai 3264a4011fd4SHariprasad Shenai if (chip <= CHELSIO_T5) 3265a4011fd4SHariprasad Shenai sb = t4_read_reg(adap, LE_DB_SERVER_INDEX_A) / 4; 3266a4011fd4SHariprasad Shenai else 3267a4011fd4SHariprasad Shenai sb = t4_read_reg(adap, LE_DB_SRVR_START_INDEX_A); 3268a4011fd4SHariprasad Shenai 3269a4011fd4SHariprasad Shenai if (sb) { 327059437d78SShahjada Abul Husain seq_printf(seq, "TID range: %u..%u/%u..%u", t->tid_base, 3271918341e0SGanesh Goudar sb - 1, adap->tids.hash_base, 327259437d78SShahjada Abul Husain t->tid_base + t->ntids - 1); 3273a4011fd4SHariprasad Shenai seq_printf(seq, ", in use: %u/%u\n", 3274a4011fd4SHariprasad Shenai atomic_read(&t->tids_in_use), 3275a4011fd4SHariprasad Shenai atomic_read(&t->hash_tids_in_use)); 327680f61f19SArjun Vynipadath } else if (adap->flags & CXGB4_FW_OFLD_CONN) { 3277a4011fd4SHariprasad Shenai seq_printf(seq, "TID range: %u..%u/%u..%u", 3278a4011fd4SHariprasad Shenai t->aftid_base, 3279a4011fd4SHariprasad Shenai t->aftid_end, 3280a4011fd4SHariprasad Shenai adap->tids.hash_base, 328159437d78SShahjada Abul Husain t->tid_base + t->ntids - 1); 3282a4011fd4SHariprasad Shenai seq_printf(seq, ", in use: %u/%u\n", 3283a4011fd4SHariprasad Shenai atomic_read(&t->tids_in_use), 3284a4011fd4SHariprasad Shenai atomic_read(&t->hash_tids_in_use)); 3285a4011fd4SHariprasad Shenai } else { 3286a4011fd4SHariprasad Shenai seq_printf(seq, "TID range: %u..%u", 3287a4011fd4SHariprasad Shenai adap->tids.hash_base, 328859437d78SShahjada Abul Husain t->tid_base + t->ntids - 1); 3289a4011fd4SHariprasad Shenai seq_printf(seq, ", in use: %u\n", 3290a4011fd4SHariprasad Shenai atomic_read(&t->hash_tids_in_use)); 3291a4011fd4SHariprasad Shenai } 3292a4011fd4SHariprasad Shenai } else if (t->ntids) { 32931dec4cecSGanesh Goudar seq_printf(seq, "Connections in use: %u\n", 32941dec4cecSGanesh Goudar atomic_read(&t->conns_in_use)); 32951dec4cecSGanesh Goudar 329659437d78SShahjada Abul Husain seq_printf(seq, "TID range: %u..%u", t->tid_base, 329759437d78SShahjada Abul Husain t->tid_base + t->ntids - 1); 3298a4011fd4SHariprasad Shenai seq_printf(seq, ", in use: %u\n", 3299a4011fd4SHariprasad Shenai atomic_read(&t->tids_in_use)); 3300a4011fd4SHariprasad Shenai } 3301a4011fd4SHariprasad Shenai 3302a4011fd4SHariprasad Shenai if (t->nstids) 33031dec4cecSGanesh Goudar seq_printf(seq, "STID range: %u..%u, in use-IPv4/IPv6: %u/%u\n", 3304a4011fd4SHariprasad Shenai (!t->stid_base && 3305a4011fd4SHariprasad Shenai (chip <= CHELSIO_T5)) ? 3306a4011fd4SHariprasad Shenai t->stid_base + 1 : t->stid_base, 33071dec4cecSGanesh Goudar t->stid_base + t->nstids - 1, 33081dec4cecSGanesh Goudar t->stids_in_use - t->v6_stids_in_use, 33091dec4cecSGanesh Goudar t->v6_stids_in_use); 33101dec4cecSGanesh Goudar 3311a4011fd4SHariprasad Shenai if (t->natids) 3312a4011fd4SHariprasad Shenai seq_printf(seq, "ATID range: 0..%u, in use: %u\n", 3313a4011fd4SHariprasad Shenai t->natids - 1, t->atids_in_use); 3314a4011fd4SHariprasad Shenai seq_printf(seq, "FTID range: %u..%u\n", t->ftid_base, 3315a4011fd4SHariprasad Shenai t->ftid_base + t->nftids - 1); 3316a4011fd4SHariprasad Shenai if (t->nsftids) 3317a4011fd4SHariprasad Shenai seq_printf(seq, "SFTID range: %u..%u in use: %u\n", 3318a4011fd4SHariprasad Shenai t->sftid_base, t->sftid_base + t->nsftids - 2, 3319a4011fd4SHariprasad Shenai t->sftids_in_use); 3320c2193999SShahjada Abul Husain if (t->nhpftids) 3321c2193999SShahjada Abul Husain seq_printf(seq, "HPFTID range: %u..%u\n", t->hpftid_base, 3322c2193999SShahjada Abul Husain t->hpftid_base + t->nhpftids - 1); 33235148e595SRahul Lakkireddy if (t->neotids) 33245148e595SRahul Lakkireddy seq_printf(seq, "EOTID range: %u..%u, in use: %u\n", 33255148e595SRahul Lakkireddy t->eotid_base, t->eotid_base + t->neotids - 1, 33265148e595SRahul Lakkireddy atomic_read(&t->eotids_in_use)); 3327a4011fd4SHariprasad Shenai if (t->ntids) 3328a4011fd4SHariprasad Shenai seq_printf(seq, "HW TID usage: %u IP users, %u IPv6 users\n", 3329a4011fd4SHariprasad Shenai t4_read_reg(adap, LE_DB_ACT_CNT_IPV4_A), 3330a4011fd4SHariprasad Shenai t4_read_reg(adap, LE_DB_ACT_CNT_IPV6_A)); 3331a4011fd4SHariprasad Shenai return 0; 3332a4011fd4SHariprasad Shenai } 3333b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(tid_info); 3334a4011fd4SHariprasad Shenai 3335fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 3336fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 3337fd88b31aSHariprasad Shenai { 3338d3757ba4SJoe Perches debugfs_create_file_size(name, 0400, adap->debugfs_root, 3339e59b4e91SDavid Howells (void *)adap + idx, &mem_debugfs_fops, 3340e59b4e91SDavid Howells size_mb << 20); 3341fd88b31aSHariprasad Shenai } 3342fd88b31aSHariprasad Shenai 33435b377d11SHariprasad Shenai static ssize_t blocked_fl_read(struct file *filp, char __user *ubuf, 33445b377d11SHariprasad Shenai size_t count, loff_t *ppos) 33455b377d11SHariprasad Shenai { 33465b377d11SHariprasad Shenai int len; 33475b377d11SHariprasad Shenai const struct adapter *adap = filp->private_data; 33485b377d11SHariprasad Shenai char *buf; 33495b377d11SHariprasad Shenai ssize_t size = (adap->sge.egr_sz + 3) / 4 + 33505b377d11SHariprasad Shenai adap->sge.egr_sz / 32 + 2; /* includes ,/\n/\0 */ 33515b377d11SHariprasad Shenai 33525b377d11SHariprasad Shenai buf = kzalloc(size, GFP_KERNEL); 33535b377d11SHariprasad Shenai if (!buf) 33545b377d11SHariprasad Shenai return -ENOMEM; 33555b377d11SHariprasad Shenai 33565b377d11SHariprasad Shenai len = snprintf(buf, size - 1, "%*pb\n", 33575b377d11SHariprasad Shenai adap->sge.egr_sz, adap->sge.blocked_fl); 33585b377d11SHariprasad Shenai len += sprintf(buf + len, "\n"); 33595b377d11SHariprasad Shenai size = simple_read_from_buffer(ubuf, count, ppos, buf, len); 3360752ade68SMichal Hocko kvfree(buf); 33615b377d11SHariprasad Shenai return size; 33625b377d11SHariprasad Shenai } 33635b377d11SHariprasad Shenai 33645b377d11SHariprasad Shenai static ssize_t blocked_fl_write(struct file *filp, const char __user *ubuf, 33655b377d11SHariprasad Shenai size_t count, loff_t *ppos) 33665b377d11SHariprasad Shenai { 33675b377d11SHariprasad Shenai int err; 33685b377d11SHariprasad Shenai unsigned long *t; 33695b377d11SHariprasad Shenai struct adapter *adap = filp->private_data; 33705b377d11SHariprasad Shenai 33715b377d11SHariprasad Shenai t = kcalloc(BITS_TO_LONGS(adap->sge.egr_sz), sizeof(long), GFP_KERNEL); 33725b377d11SHariprasad Shenai if (!t) 33735b377d11SHariprasad Shenai return -ENOMEM; 33745b377d11SHariprasad Shenai 33755b377d11SHariprasad Shenai err = bitmap_parse_user(ubuf, count, t, adap->sge.egr_sz); 3376c554336eSWenwen Wang if (err) { 3377c554336eSWenwen Wang kvfree(t); 33785b377d11SHariprasad Shenai return err; 3379c554336eSWenwen Wang } 33805b377d11SHariprasad Shenai 33815b377d11SHariprasad Shenai bitmap_copy(adap->sge.blocked_fl, t, adap->sge.egr_sz); 3382752ade68SMichal Hocko kvfree(t); 33835b377d11SHariprasad Shenai return count; 33845b377d11SHariprasad Shenai } 33855b377d11SHariprasad Shenai 33865b377d11SHariprasad Shenai static const struct file_operations blocked_fl_fops = { 33875b377d11SHariprasad Shenai .owner = THIS_MODULE, 3388524605e5SWei Yongjun .open = simple_open, 33895b377d11SHariprasad Shenai .read = blocked_fl_read, 33905b377d11SHariprasad Shenai .write = blocked_fl_write, 33915b377d11SHariprasad Shenai .llseek = generic_file_llseek, 33925b377d11SHariprasad Shenai }; 33935b377d11SHariprasad Shenai 33945888111cSHariprasad Shenai static void mem_region_show(struct seq_file *seq, const char *name, 33955888111cSHariprasad Shenai unsigned int from, unsigned int to) 33965888111cSHariprasad Shenai { 33975888111cSHariprasad Shenai char buf[40]; 33985888111cSHariprasad Shenai 33995888111cSHariprasad Shenai string_get_size((u64)to - from + 1, 1, STRING_UNITS_2, buf, 34005888111cSHariprasad Shenai sizeof(buf)); 34015888111cSHariprasad Shenai seq_printf(seq, "%-15s %#x-%#x [%s]\n", name, from, to, buf); 34025888111cSHariprasad Shenai } 34035888111cSHariprasad Shenai 34045888111cSHariprasad Shenai static int meminfo_show(struct seq_file *seq, void *v) 34055888111cSHariprasad Shenai { 34065888111cSHariprasad Shenai static const char * const memory[] = { "EDC0:", "EDC1:", "MC:", 34074db0401fSRahul Lakkireddy "MC0:", "MC1:", "HMA:"}; 34085888111cSHariprasad Shenai struct adapter *adap = seq->private; 3409123e25c4SRahul Lakkireddy struct cudbg_meminfo meminfo; 3410123e25c4SRahul Lakkireddy int i, rc; 34115888111cSHariprasad Shenai 3412123e25c4SRahul Lakkireddy memset(&meminfo, 0, sizeof(struct cudbg_meminfo)); 3413123e25c4SRahul Lakkireddy rc = cudbg_fill_meminfo(adap, &meminfo); 3414123e25c4SRahul Lakkireddy if (rc) 3415123e25c4SRahul Lakkireddy return -ENXIO; 34165888111cSHariprasad Shenai 3417123e25c4SRahul Lakkireddy for (i = 0; i < meminfo.avail_c; i++) 3418123e25c4SRahul Lakkireddy mem_region_show(seq, memory[meminfo.avail[i].idx], 3419123e25c4SRahul Lakkireddy meminfo.avail[i].base, 3420123e25c4SRahul Lakkireddy meminfo.avail[i].limit - 1); 34215888111cSHariprasad Shenai 34225888111cSHariprasad Shenai seq_putc(seq, '\n'); 3423123e25c4SRahul Lakkireddy for (i = 0; i < meminfo.mem_c; i++) { 3424123e25c4SRahul Lakkireddy if (meminfo.mem[i].idx >= ARRAY_SIZE(cudbg_region)) 34255888111cSHariprasad Shenai continue; /* skip holes */ 3426123e25c4SRahul Lakkireddy if (!meminfo.mem[i].limit) 3427123e25c4SRahul Lakkireddy meminfo.mem[i].limit = 3428123e25c4SRahul Lakkireddy i < meminfo.mem_c - 1 ? 3429123e25c4SRahul Lakkireddy meminfo.mem[i + 1].base - 1 : ~0; 3430123e25c4SRahul Lakkireddy mem_region_show(seq, cudbg_region[meminfo.mem[i].idx], 3431123e25c4SRahul Lakkireddy meminfo.mem[i].base, meminfo.mem[i].limit); 34325888111cSHariprasad Shenai } 34335888111cSHariprasad Shenai 34345888111cSHariprasad Shenai seq_putc(seq, '\n'); 3435123e25c4SRahul Lakkireddy mem_region_show(seq, "uP RAM:", meminfo.up_ram_lo, meminfo.up_ram_hi); 3436123e25c4SRahul Lakkireddy mem_region_show(seq, "uP Extmem2:", meminfo.up_extmem2_lo, 3437123e25c4SRahul Lakkireddy meminfo.up_extmem2_hi); 34385888111cSHariprasad Shenai 3439fa145d5dSGanesh Goudar seq_printf(seq, "\n%u Rx pages (%u free) of size %uKiB for %u channels\n", 3440ae2a922fSRahul Lakkireddy meminfo.rx_pages_data[0], meminfo.free_rx_cnt, 3441fa145d5dSGanesh Goudar meminfo.rx_pages_data[1], meminfo.rx_pages_data[2]); 34425888111cSHariprasad Shenai 3443fa145d5dSGanesh Goudar seq_printf(seq, "%u Tx pages (%u free) of size %u%ciB for %u channels\n", 3444ae2a922fSRahul Lakkireddy meminfo.tx_pages_data[0], meminfo.free_tx_cnt, 3445fa145d5dSGanesh Goudar meminfo.tx_pages_data[1], meminfo.tx_pages_data[2], 3446fa145d5dSGanesh Goudar meminfo.tx_pages_data[3]); 34475888111cSHariprasad Shenai 34489d0f180cSRahul Lakkireddy seq_printf(seq, "%u p-structs (%u free)\n\n", 34499d0f180cSRahul Lakkireddy meminfo.p_structs, meminfo.p_structs_free_cnt); 3450123e25c4SRahul Lakkireddy 3451123e25c4SRahul Lakkireddy for (i = 0; i < 4; i++) 34525888111cSHariprasad Shenai /* For T6 these are MAC buffer groups */ 34535888111cSHariprasad Shenai seq_printf(seq, "Port %d using %u pages out of %u allocated\n", 3454123e25c4SRahul Lakkireddy i, meminfo.port_used[i], meminfo.port_alloc[i]); 3455123e25c4SRahul Lakkireddy 3456123e25c4SRahul Lakkireddy for (i = 0; i < adap->params.arch.nchan; i++) 34575888111cSHariprasad Shenai /* For T6 these are MAC buffer groups */ 34585888111cSHariprasad Shenai seq_printf(seq, 34595888111cSHariprasad Shenai "Loopback %d using %u pages out of %u allocated\n", 3460123e25c4SRahul Lakkireddy i, meminfo.loopback_used[i], 3461123e25c4SRahul Lakkireddy meminfo.loopback_alloc[i]); 3462123e25c4SRahul Lakkireddy 34635888111cSHariprasad Shenai return 0; 34645888111cSHariprasad Shenai } 3465b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(meminfo); 34665888111cSHariprasad Shenai 3467b09026c6SYangtao Li static int chcr_stats_show(struct seq_file *seq, void *v) 3468ee0863baSHarsh Jain { 3469ee0863baSHarsh Jain struct adapter *adap = seq->private; 3470ee0863baSHarsh Jain 3471ee0863baSHarsh Jain seq_puts(seq, "Chelsio Crypto Accelerator Stats \n"); 3472ee0863baSHarsh Jain seq_printf(seq, "Cipher Ops: %10u \n", 3473ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.cipher_rqst)); 3474ee0863baSHarsh Jain seq_printf(seq, "Digest Ops: %10u \n", 3475ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.digest_rqst)); 3476ee0863baSHarsh Jain seq_printf(seq, "Aead Ops: %10u \n", 3477ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.aead_rqst)); 3478ee0863baSHarsh Jain seq_printf(seq, "Completion: %10u \n", 3479ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.complete)); 3480ee0863baSHarsh Jain seq_printf(seq, "Error: %10u \n", 3481ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.error)); 3482ee0863baSHarsh Jain seq_printf(seq, "Fallback: %10u \n", 3483ee0863baSHarsh Jain atomic_read(&adap->chcr_stats.fallback)); 3484a6ec572bSAtul Gupta seq_printf(seq, "IPSec PDU: %10u\n", 3485a6ec572bSAtul Gupta atomic_read(&adap->chcr_stats.ipsec_cnt)); 348645a8317eSDevulapally Shiva Krishna seq_printf(seq, "TLS PDU Tx: %10u\n", 348745a8317eSDevulapally Shiva Krishna atomic_read(&adap->chcr_stats.tls_pdu_tx)); 348845a8317eSDevulapally Shiva Krishna seq_printf(seq, "TLS PDU Rx: %10u\n", 348945a8317eSDevulapally Shiva Krishna atomic_read(&adap->chcr_stats.tls_pdu_rx)); 349045a8317eSDevulapally Shiva Krishna seq_printf(seq, "TLS Keys (DDR) Count: %10u\n", 349145a8317eSDevulapally Shiva Krishna atomic_read(&adap->chcr_stats.tls_key)); 349262370a4fSRohit Maheshwari #ifdef CONFIG_CHELSIO_TLS_DEVICE 349362370a4fSRohit Maheshwari seq_puts(seq, "\nChelsio KTLS Crypto Accelerator Stats\n"); 3494a3ac249aSRohit Maheshwari seq_printf(seq, "Tx TLS offload refcount: %20u\n", 3495a3ac249aSRohit Maheshwari refcount_read(&adap->chcr_ktls.ktls_refcount)); 349662370a4fSRohit Maheshwari seq_printf(seq, "Tx HW offload contexts added: %20llu\n", 349762370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_ctx)); 349862370a4fSRohit Maheshwari seq_printf(seq, "Tx connection created: %20llu\n", 349962370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_connection_open)); 350062370a4fSRohit Maheshwari seq_printf(seq, "Tx connection failed: %20llu\n", 350162370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_connection_fail)); 350262370a4fSRohit Maheshwari seq_printf(seq, "Tx connection closed: %20llu\n", 350362370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_connection_close)); 350462370a4fSRohit Maheshwari seq_printf(seq, "Packets passed for encryption : %20llu\n", 350562370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_encrypted_packets)); 350662370a4fSRohit Maheshwari seq_printf(seq, "Bytes passed for encryption : %20llu\n", 350762370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_encrypted_bytes)); 350862370a4fSRohit Maheshwari seq_printf(seq, "Tx records send: %20llu\n", 350962370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_send_records)); 351062370a4fSRohit Maheshwari seq_printf(seq, "Tx partial start of records: %20llu\n", 351162370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_start_pkts)); 351262370a4fSRohit Maheshwari seq_printf(seq, "Tx partial middle of records: %20llu\n", 351362370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_middle_pkts)); 351462370a4fSRohit Maheshwari seq_printf(seq, "Tx partial end of record: %20llu\n", 351562370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_end_pkts)); 351662370a4fSRohit Maheshwari seq_printf(seq, "Tx complete records: %20llu\n", 351762370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_complete_pkts)); 351862370a4fSRohit Maheshwari seq_printf(seq, "TX trim pkts : %20llu\n", 351962370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_trimmed_pkts)); 352062370a4fSRohit Maheshwari seq_printf(seq, "Tx out of order packets: %20llu\n", 352162370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_ooo)); 352262370a4fSRohit Maheshwari seq_printf(seq, "Tx drop pkts before HW offload: %20llu\n", 352362370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_skip_no_sync_data)); 352462370a4fSRohit Maheshwari seq_printf(seq, "Tx drop not synced packets: %20llu\n", 352562370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_drop_no_sync_data)); 352662370a4fSRohit Maheshwari seq_printf(seq, "Tx drop bypass req: %20llu\n", 352762370a4fSRohit Maheshwari atomic64_read(&adap->chcr_stats.ktls_tx_drop_bypass_req)); 352862370a4fSRohit Maheshwari #endif 352945a8317eSDevulapally Shiva Krishna 3530ee0863baSHarsh Jain return 0; 3531ee0863baSHarsh Jain } 3532b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(chcr_stats); 353331e5f5c3SRahul Lakkireddy 353431e5f5c3SRahul Lakkireddy #define PRINT_ADAP_STATS(string, value) \ 353531e5f5c3SRahul Lakkireddy seq_printf(seq, "%-25s %-20llu\n", (string), \ 353631e5f5c3SRahul Lakkireddy (unsigned long long)(value)) 353731e5f5c3SRahul Lakkireddy 353831e5f5c3SRahul Lakkireddy #define PRINT_CH_STATS(string, value) \ 353931e5f5c3SRahul Lakkireddy do { \ 354031e5f5c3SRahul Lakkireddy seq_printf(seq, "%-25s ", (string)); \ 354131e5f5c3SRahul Lakkireddy for (i = 0; i < adap->params.arch.nchan; i++) \ 354231e5f5c3SRahul Lakkireddy seq_printf(seq, "%-20llu ", \ 354331e5f5c3SRahul Lakkireddy (unsigned long long)stats.value[i]); \ 354431e5f5c3SRahul Lakkireddy seq_printf(seq, "\n"); \ 354531e5f5c3SRahul Lakkireddy } while (0) 354631e5f5c3SRahul Lakkireddy 354731e5f5c3SRahul Lakkireddy #define PRINT_CH_STATS2(string, value) \ 354831e5f5c3SRahul Lakkireddy do { \ 354931e5f5c3SRahul Lakkireddy seq_printf(seq, "%-25s ", (string)); \ 355031e5f5c3SRahul Lakkireddy for (i = 0; i < adap->params.arch.nchan; i++) \ 355131e5f5c3SRahul Lakkireddy seq_printf(seq, "%-20llu ", \ 355231e5f5c3SRahul Lakkireddy (unsigned long long)stats[i].value); \ 355331e5f5c3SRahul Lakkireddy seq_printf(seq, "\n"); \ 355431e5f5c3SRahul Lakkireddy } while (0) 355531e5f5c3SRahul Lakkireddy 355631e5f5c3SRahul Lakkireddy static void show_tcp_stats(struct seq_file *seq) 355731e5f5c3SRahul Lakkireddy { 355831e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 355931e5f5c3SRahul Lakkireddy struct tp_tcp_stats v4, v6; 356031e5f5c3SRahul Lakkireddy 356131e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 356231e5f5c3SRahul Lakkireddy t4_tp_get_tcp_stats(adap, &v4, &v6, false); 356331e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 356431e5f5c3SRahul Lakkireddy 356531e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv4_out_rsts:", v4.tcp_out_rsts); 356631e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv4_in_segs:", v4.tcp_in_segs); 356731e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv4_out_segs:", v4.tcp_out_segs); 356831e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv4_retrans_segs:", v4.tcp_retrans_segs); 356931e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv6_out_rsts:", v6.tcp_out_rsts); 357031e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv6_in_segs:", v6.tcp_in_segs); 357131e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv6_out_segs:", v6.tcp_out_segs); 357231e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tcp_ipv6_retrans_segs:", v6.tcp_retrans_segs); 357331e5f5c3SRahul Lakkireddy } 357431e5f5c3SRahul Lakkireddy 357531e5f5c3SRahul Lakkireddy static void show_ddp_stats(struct seq_file *seq) 357631e5f5c3SRahul Lakkireddy { 357731e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 357831e5f5c3SRahul Lakkireddy struct tp_usm_stats stats; 357931e5f5c3SRahul Lakkireddy 358031e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 358131e5f5c3SRahul Lakkireddy t4_get_usm_stats(adap, &stats, false); 358231e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 358331e5f5c3SRahul Lakkireddy 358431e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("usm_ddp_frames:", stats.frames); 358531e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("usm_ddp_octets:", stats.octets); 358631e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("usm_ddp_drops:", stats.drops); 358731e5f5c3SRahul Lakkireddy } 358831e5f5c3SRahul Lakkireddy 358931e5f5c3SRahul Lakkireddy static void show_rdma_stats(struct seq_file *seq) 359031e5f5c3SRahul Lakkireddy { 359131e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 359231e5f5c3SRahul Lakkireddy struct tp_rdma_stats stats; 359331e5f5c3SRahul Lakkireddy 359431e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 359531e5f5c3SRahul Lakkireddy t4_tp_get_rdma_stats(adap, &stats, false); 359631e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 359731e5f5c3SRahul Lakkireddy 359831e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("rdma_no_rqe_mod_defer:", stats.rqe_dfr_mod); 359931e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("rdma_no_rqe_pkt_defer:", stats.rqe_dfr_pkt); 360031e5f5c3SRahul Lakkireddy } 360131e5f5c3SRahul Lakkireddy 360231e5f5c3SRahul Lakkireddy static void show_tp_err_adapter_stats(struct seq_file *seq) 360331e5f5c3SRahul Lakkireddy { 360431e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 360531e5f5c3SRahul Lakkireddy struct tp_err_stats stats; 360631e5f5c3SRahul Lakkireddy 360731e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 360831e5f5c3SRahul Lakkireddy t4_tp_get_err_stats(adap, &stats, false); 360931e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 361031e5f5c3SRahul Lakkireddy 361131e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tp_err_ofld_no_neigh:", stats.ofld_no_neigh); 361231e5f5c3SRahul Lakkireddy PRINT_ADAP_STATS("tp_err_ofld_cong_defer:", stats.ofld_cong_defer); 361331e5f5c3SRahul Lakkireddy } 361431e5f5c3SRahul Lakkireddy 361531e5f5c3SRahul Lakkireddy static void show_cpl_stats(struct seq_file *seq) 361631e5f5c3SRahul Lakkireddy { 361731e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 361831e5f5c3SRahul Lakkireddy struct tp_cpl_stats stats; 361931e5f5c3SRahul Lakkireddy u8 i; 362031e5f5c3SRahul Lakkireddy 362131e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 362231e5f5c3SRahul Lakkireddy t4_tp_get_cpl_stats(adap, &stats, false); 362331e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 362431e5f5c3SRahul Lakkireddy 362531e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_cpl_requests:", req); 362631e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_cpl_responses:", rsp); 362731e5f5c3SRahul Lakkireddy } 362831e5f5c3SRahul Lakkireddy 362931e5f5c3SRahul Lakkireddy static void show_tp_err_channel_stats(struct seq_file *seq) 363031e5f5c3SRahul Lakkireddy { 363131e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 363231e5f5c3SRahul Lakkireddy struct tp_err_stats stats; 363331e5f5c3SRahul Lakkireddy u8 i; 363431e5f5c3SRahul Lakkireddy 363531e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 363631e5f5c3SRahul Lakkireddy t4_tp_get_err_stats(adap, &stats, false); 363731e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 363831e5f5c3SRahul Lakkireddy 363931e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_mac_in_errs:", mac_in_errs); 364031e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_hdr_in_errs:", hdr_in_errs); 364131e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_tcp_in_errs:", tcp_in_errs); 364231e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_tcp6_in_errs:", tcp6_in_errs); 364331e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_tnl_cong_drops:", tnl_cong_drops); 364431e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_tnl_tx_drops:", tnl_tx_drops); 364531e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_ofld_vlan_drops:", ofld_vlan_drops); 364631e5f5c3SRahul Lakkireddy PRINT_CH_STATS("tp_ofld_chan_drops:", ofld_chan_drops); 364731e5f5c3SRahul Lakkireddy } 364831e5f5c3SRahul Lakkireddy 364931e5f5c3SRahul Lakkireddy static void show_fcoe_stats(struct seq_file *seq) 365031e5f5c3SRahul Lakkireddy { 365131e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 365231e5f5c3SRahul Lakkireddy struct tp_fcoe_stats stats[NCHAN]; 365331e5f5c3SRahul Lakkireddy u8 i; 365431e5f5c3SRahul Lakkireddy 365531e5f5c3SRahul Lakkireddy spin_lock(&adap->stats_lock); 365631e5f5c3SRahul Lakkireddy for (i = 0; i < adap->params.arch.nchan; i++) 365731e5f5c3SRahul Lakkireddy t4_get_fcoe_stats(adap, i, &stats[i], false); 365831e5f5c3SRahul Lakkireddy spin_unlock(&adap->stats_lock); 365931e5f5c3SRahul Lakkireddy 366031e5f5c3SRahul Lakkireddy PRINT_CH_STATS2("fcoe_octets_ddp", octets_ddp); 366131e5f5c3SRahul Lakkireddy PRINT_CH_STATS2("fcoe_frames_ddp", frames_ddp); 366231e5f5c3SRahul Lakkireddy PRINT_CH_STATS2("fcoe_frames_drop", frames_drop); 366331e5f5c3SRahul Lakkireddy } 366431e5f5c3SRahul Lakkireddy 366531e5f5c3SRahul Lakkireddy #undef PRINT_CH_STATS2 366631e5f5c3SRahul Lakkireddy #undef PRINT_CH_STATS 366731e5f5c3SRahul Lakkireddy #undef PRINT_ADAP_STATS 366831e5f5c3SRahul Lakkireddy 366931e5f5c3SRahul Lakkireddy static int tp_stats_show(struct seq_file *seq, void *v) 367031e5f5c3SRahul Lakkireddy { 367131e5f5c3SRahul Lakkireddy struct adapter *adap = seq->private; 367231e5f5c3SRahul Lakkireddy 367331e5f5c3SRahul Lakkireddy seq_puts(seq, "\n--------Adapter Stats--------\n"); 367431e5f5c3SRahul Lakkireddy show_tcp_stats(seq); 367531e5f5c3SRahul Lakkireddy show_ddp_stats(seq); 367631e5f5c3SRahul Lakkireddy show_rdma_stats(seq); 367731e5f5c3SRahul Lakkireddy show_tp_err_adapter_stats(seq); 367831e5f5c3SRahul Lakkireddy 367931e5f5c3SRahul Lakkireddy seq_puts(seq, "\n-------- Channel Stats --------\n"); 368031e5f5c3SRahul Lakkireddy if (adap->params.arch.nchan == NCHAN) 368131e5f5c3SRahul Lakkireddy seq_printf(seq, "%-25s %-20s %-20s %-20s %-20s\n", 368231e5f5c3SRahul Lakkireddy " ", "channel 0", "channel 1", 368331e5f5c3SRahul Lakkireddy "channel 2", "channel 3"); 368431e5f5c3SRahul Lakkireddy else 368531e5f5c3SRahul Lakkireddy seq_printf(seq, "%-25s %-20s %-20s\n", 368631e5f5c3SRahul Lakkireddy " ", "channel 0", "channel 1"); 368731e5f5c3SRahul Lakkireddy show_cpl_stats(seq); 368831e5f5c3SRahul Lakkireddy show_tp_err_channel_stats(seq); 368931e5f5c3SRahul Lakkireddy show_fcoe_stats(seq); 369031e5f5c3SRahul Lakkireddy 369131e5f5c3SRahul Lakkireddy return 0; 369231e5f5c3SRahul Lakkireddy } 3693b09026c6SYangtao Li DEFINE_SHOW_ATTRIBUTE(tp_stats); 369431e5f5c3SRahul Lakkireddy 3695fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 3696fd88b31aSHariprasad Shenai */ 3697fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 3698fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 3699fd88b31aSHariprasad Shenai unsigned int nfiles) 3700fd88b31aSHariprasad Shenai { 3701fd88b31aSHariprasad Shenai int i; 3702fd88b31aSHariprasad Shenai 3703fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 3704fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 3705fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 3706fd88b31aSHariprasad Shenai adap->debugfs_root, 3707fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 3708fd88b31aSHariprasad Shenai files[i].ops); 3709fd88b31aSHariprasad Shenai } 3710fd88b31aSHariprasad Shenai 3711fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 3712fd88b31aSHariprasad Shenai { 3713fd88b31aSHariprasad Shenai int i; 37143ccc6cf7SHariprasad Shenai u32 size = 0; 3715fd88b31aSHariprasad Shenai 3716fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 3717d3757ba4SJoe Perches { "cim_la", &cim_la_fops, 0400, 0 }, 3718d3757ba4SJoe Perches { "cim_pif_la", &cim_pif_la_fops, 0400, 0 }, 3719d3757ba4SJoe Perches { "cim_ma_la", &cim_ma_la_fops, 0400, 0 }, 3720d3757ba4SJoe Perches { "cim_qcfg", &cim_qcfg_fops, 0400, 0 }, 3721b09026c6SYangtao Li { "clk", &clk_fops, 0400, 0 }, 3722d3757ba4SJoe Perches { "devlog", &devlog_fops, 0400, 0 }, 3723d3757ba4SJoe Perches { "mboxlog", &mboxlog_fops, 0400, 0 }, 3724d3757ba4SJoe Perches { "mbox0", &mbox_debugfs_fops, 0600, 0 }, 3725d3757ba4SJoe Perches { "mbox1", &mbox_debugfs_fops, 0600, 1 }, 3726d3757ba4SJoe Perches { "mbox2", &mbox_debugfs_fops, 0600, 2 }, 3727d3757ba4SJoe Perches { "mbox3", &mbox_debugfs_fops, 0600, 3 }, 3728d3757ba4SJoe Perches { "mbox4", &mbox_debugfs_fops, 0600, 4 }, 3729d3757ba4SJoe Perches { "mbox5", &mbox_debugfs_fops, 0600, 5 }, 3730d3757ba4SJoe Perches { "mbox6", &mbox_debugfs_fops, 0600, 6 }, 3731d3757ba4SJoe Perches { "mbox7", &mbox_debugfs_fops, 0600, 7 }, 3732d3757ba4SJoe Perches { "trace0", &mps_trc_debugfs_fops, 0600, 0 }, 3733d3757ba4SJoe Perches { "trace1", &mps_trc_debugfs_fops, 0600, 1 }, 3734d3757ba4SJoe Perches { "trace2", &mps_trc_debugfs_fops, 0600, 2 }, 3735d3757ba4SJoe Perches { "trace3", &mps_trc_debugfs_fops, 0600, 3 }, 3736d3757ba4SJoe Perches { "l2t", &t4_l2t_fops, 0400, 0}, 3737d3757ba4SJoe Perches { "mps_tcam", &mps_tcam_debugfs_fops, 0400, 0 }, 3738d3757ba4SJoe Perches { "rss", &rss_debugfs_fops, 0400, 0 }, 3739b09026c6SYangtao Li { "rss_config", &rss_config_fops, 0400, 0 }, 3740d3757ba4SJoe Perches { "rss_key", &rss_key_debugfs_fops, 0400, 0 }, 3741d3757ba4SJoe Perches { "rss_pf_config", &rss_pf_config_debugfs_fops, 0400, 0 }, 3742d3757ba4SJoe Perches { "rss_vf_config", &rss_vf_config_debugfs_fops, 0400, 0 }, 3743b09026c6SYangtao Li { "resources", &resources_fops, 0400, 0 }, 3744ebddd97aSGanesh Goudar #ifdef CONFIG_CHELSIO_T4_DCB 3745ebddd97aSGanesh Goudar { "dcb_info", &dcb_info_debugfs_fops, 0400, 0 }, 3746ebddd97aSGanesh Goudar #endif 3747d3757ba4SJoe Perches { "sge_qinfo", &sge_qinfo_debugfs_fops, 0400, 0 }, 3748d3757ba4SJoe Perches { "ibq_tp0", &cim_ibq_fops, 0400, 0 }, 3749d3757ba4SJoe Perches { "ibq_tp1", &cim_ibq_fops, 0400, 1 }, 3750d3757ba4SJoe Perches { "ibq_ulp", &cim_ibq_fops, 0400, 2 }, 3751d3757ba4SJoe Perches { "ibq_sge0", &cim_ibq_fops, 0400, 3 }, 3752d3757ba4SJoe Perches { "ibq_sge1", &cim_ibq_fops, 0400, 4 }, 3753d3757ba4SJoe Perches { "ibq_ncsi", &cim_ibq_fops, 0400, 5 }, 3754d3757ba4SJoe Perches { "obq_ulp0", &cim_obq_fops, 0400, 0 }, 3755d3757ba4SJoe Perches { "obq_ulp1", &cim_obq_fops, 0400, 1 }, 3756d3757ba4SJoe Perches { "obq_ulp2", &cim_obq_fops, 0400, 2 }, 3757d3757ba4SJoe Perches { "obq_ulp3", &cim_obq_fops, 0400, 3 }, 3758d3757ba4SJoe Perches { "obq_sge", &cim_obq_fops, 0400, 4 }, 3759d3757ba4SJoe Perches { "obq_ncsi", &cim_obq_fops, 0400, 5 }, 3760d3757ba4SJoe Perches { "tp_la", &tp_la_fops, 0400, 0 }, 3761d3757ba4SJoe Perches { "ulprx_la", &ulprx_la_fops, 0400, 0 }, 3762b09026c6SYangtao Li { "sensors", &sensors_fops, 0400, 0 }, 3763d3757ba4SJoe Perches { "pm_stats", &pm_stats_debugfs_fops, 0400, 0 }, 3764b09026c6SYangtao Li { "tx_rate", &tx_rate_fops, 0400, 0 }, 3765b09026c6SYangtao Li { "cctrl", &cctrl_tbl_fops, 0400, 0 }, 3766b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 3767b09026c6SYangtao Li { "clip_tbl", &clip_tbl_fops, 0400, 0 }, 3768b5a02f50SAnish Bhatt #endif 3769b09026c6SYangtao Li { "tids", &tid_info_fops, 0400, 0}, 3770d3757ba4SJoe Perches { "blocked_fl", &blocked_fl_fops, 0600, 0 }, 3771d3757ba4SJoe Perches { "meminfo", &meminfo_fops, 0400, 0 }, 3772b09026c6SYangtao Li { "crypto", &chcr_stats_fops, 0400, 0 }, 3773b09026c6SYangtao Li { "tp_stats", &tp_stats_fops, 0400, 0 }, 3774fd88b31aSHariprasad Shenai }; 3775fd88b31aSHariprasad Shenai 3776c778af7dSHariprasad Shenai /* Debug FS nodes common to all T5 and later adapters. 3777c778af7dSHariprasad Shenai */ 3778c778af7dSHariprasad Shenai static struct t4_debugfs_entry t5_debugfs_files[] = { 3779d3757ba4SJoe Perches { "obq_sge_rx_q0", &cim_obq_fops, 0400, 6 }, 3780d3757ba4SJoe Perches { "obq_sge_rx_q1", &cim_obq_fops, 0400, 7 }, 3781c778af7dSHariprasad Shenai }; 3782c778af7dSHariprasad Shenai 3783fd88b31aSHariprasad Shenai add_debugfs_files(adap, 3784fd88b31aSHariprasad Shenai t4_debugfs_files, 3785fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 3786c778af7dSHariprasad Shenai if (!is_t4(adap->params.chip)) 3787c778af7dSHariprasad Shenai add_debugfs_files(adap, 3788c778af7dSHariprasad Shenai t5_debugfs_files, 3789c778af7dSHariprasad Shenai ARRAY_SIZE(t5_debugfs_files)); 3790fd88b31aSHariprasad Shenai 37916559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 37926559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 37936559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 37946559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 3795fd88b31aSHariprasad Shenai } 37966559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 37976559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 37986559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 3799fd88b31aSHariprasad Shenai } 38003ccc6cf7SHariprasad Shenai if (is_t5(adap->params.chip)) { 38016559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 38026559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 3803fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 38046559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 3805fd88b31aSHariprasad Shenai } 38066559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 38076559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 3808fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 38096559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 3810fd88b31aSHariprasad Shenai } 38113ccc6cf7SHariprasad Shenai } else { 381221a44763SDan Carpenter if (i & EXT_MEM_ENABLE_F) { 38133ccc6cf7SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 38143ccc6cf7SHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 38153ccc6cf7SHariprasad Shenai EXT_MEM_SIZE_G(size)); 3816fd88b31aSHariprasad Shenai } 38178b4e6b3cSArjun Vynipadath 38188b4e6b3cSArjun Vynipadath if (i & HMA_MUX_F) { 38198b4e6b3cSArjun Vynipadath size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 38208b4e6b3cSArjun Vynipadath add_debugfs_mem(adap, "hma", MEM_HMA, 38218b4e6b3cSArjun Vynipadath EXT_MEM1_SIZE_G(size)); 38228b4e6b3cSArjun Vynipadath } 382321a44763SDan Carpenter } 382449216c1cSHariprasad Shenai 38259dac1e8eSGreg Kroah-Hartman debugfs_create_file_size("flash", 0400, adap->debugfs_root, adap, 3826c1d81b1cSDavid Howells &flash_debugfs_fops, adap->params.sf_size); 3827d3757ba4SJoe Perches debugfs_create_bool("use_backdoor", 0600, 38280b2c2a93SHariprasad Shenai adap->debugfs_root, &adap->use_bd); 3829d3757ba4SJoe Perches debugfs_create_bool("trace_rss", 0600, 38308e3d04fdSHariprasad Shenai adap->debugfs_root, &adap->trace_rss); 383149216c1cSHariprasad Shenai 3832fd88b31aSHariprasad Shenai return 0; 3833fd88b31aSHariprasad Shenai } 3834