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" 48fd88b31aSHariprasad Shenai 49f1ff24aaSHariprasad Shenai /* generic seq_file support for showing a table of size rows x width. */ 50f1ff24aaSHariprasad Shenai static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos) 51f1ff24aaSHariprasad Shenai { 52f1ff24aaSHariprasad Shenai pos -= tb->skip_first; 53f1ff24aaSHariprasad Shenai return pos >= tb->rows ? NULL : &tb->data[pos * tb->width]; 54f1ff24aaSHariprasad Shenai } 55f1ff24aaSHariprasad Shenai 56f1ff24aaSHariprasad Shenai static void *seq_tab_start(struct seq_file *seq, loff_t *pos) 57f1ff24aaSHariprasad Shenai { 58f1ff24aaSHariprasad Shenai struct seq_tab *tb = seq->private; 59f1ff24aaSHariprasad Shenai 60f1ff24aaSHariprasad Shenai if (tb->skip_first && *pos == 0) 61f1ff24aaSHariprasad Shenai return SEQ_START_TOKEN; 62f1ff24aaSHariprasad Shenai 63f1ff24aaSHariprasad Shenai return seq_tab_get_idx(tb, *pos); 64f1ff24aaSHariprasad Shenai } 65f1ff24aaSHariprasad Shenai 66f1ff24aaSHariprasad Shenai static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos) 67f1ff24aaSHariprasad Shenai { 68f1ff24aaSHariprasad Shenai v = seq_tab_get_idx(seq->private, *pos + 1); 69f1ff24aaSHariprasad Shenai if (v) 70f1ff24aaSHariprasad Shenai ++*pos; 71f1ff24aaSHariprasad Shenai return v; 72f1ff24aaSHariprasad Shenai } 73f1ff24aaSHariprasad Shenai 74f1ff24aaSHariprasad Shenai static void seq_tab_stop(struct seq_file *seq, void *v) 75f1ff24aaSHariprasad Shenai { 76f1ff24aaSHariprasad Shenai } 77f1ff24aaSHariprasad Shenai 78f1ff24aaSHariprasad Shenai static int seq_tab_show(struct seq_file *seq, void *v) 79f1ff24aaSHariprasad Shenai { 80f1ff24aaSHariprasad Shenai const struct seq_tab *tb = seq->private; 81f1ff24aaSHariprasad Shenai 82f1ff24aaSHariprasad Shenai return tb->show(seq, v, ((char *)v - tb->data) / tb->width); 83f1ff24aaSHariprasad Shenai } 84f1ff24aaSHariprasad Shenai 85f1ff24aaSHariprasad Shenai static const struct seq_operations seq_tab_ops = { 86f1ff24aaSHariprasad Shenai .start = seq_tab_start, 87f1ff24aaSHariprasad Shenai .next = seq_tab_next, 88f1ff24aaSHariprasad Shenai .stop = seq_tab_stop, 89f1ff24aaSHariprasad Shenai .show = seq_tab_show 90f1ff24aaSHariprasad Shenai }; 91f1ff24aaSHariprasad Shenai 92f1ff24aaSHariprasad Shenai struct seq_tab *seq_open_tab(struct file *f, unsigned int rows, 93f1ff24aaSHariprasad Shenai unsigned int width, unsigned int have_header, 94f1ff24aaSHariprasad Shenai int (*show)(struct seq_file *seq, void *v, int i)) 95f1ff24aaSHariprasad Shenai { 96f1ff24aaSHariprasad Shenai struct seq_tab *p; 97f1ff24aaSHariprasad Shenai 98f1ff24aaSHariprasad Shenai p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width); 99f1ff24aaSHariprasad Shenai if (p) { 100f1ff24aaSHariprasad Shenai p->show = show; 101f1ff24aaSHariprasad Shenai p->rows = rows; 102f1ff24aaSHariprasad Shenai p->width = width; 103f1ff24aaSHariprasad Shenai p->skip_first = have_header != 0; 104f1ff24aaSHariprasad Shenai } 105f1ff24aaSHariprasad Shenai return p; 106f1ff24aaSHariprasad Shenai } 107f1ff24aaSHariprasad Shenai 108c778af7dSHariprasad Shenai /* Trim the size of a seq_tab to the supplied number of rows. The operation is 109c778af7dSHariprasad Shenai * irreversible. 110c778af7dSHariprasad Shenai */ 111c778af7dSHariprasad Shenai static int seq_tab_trim(struct seq_tab *p, unsigned int new_rows) 112c778af7dSHariprasad Shenai { 113c778af7dSHariprasad Shenai if (new_rows > p->rows) 114c778af7dSHariprasad Shenai return -EINVAL; 115c778af7dSHariprasad Shenai p->rows = new_rows; 116c778af7dSHariprasad Shenai return 0; 117c778af7dSHariprasad Shenai } 118c778af7dSHariprasad Shenai 119f1ff24aaSHariprasad Shenai static int cim_la_show(struct seq_file *seq, void *v, int idx) 120f1ff24aaSHariprasad Shenai { 121f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) 122f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC LS0Stat LS0Addr " 123f1ff24aaSHariprasad Shenai " LS0Data\n"); 124f1ff24aaSHariprasad Shenai else { 125f1ff24aaSHariprasad Shenai const u32 *p = v; 126f1ff24aaSHariprasad Shenai 127f1ff24aaSHariprasad Shenai seq_printf(seq, 128f1ff24aaSHariprasad Shenai " %02x %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n", 129f1ff24aaSHariprasad Shenai (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4, 130f1ff24aaSHariprasad Shenai p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5], 131f1ff24aaSHariprasad Shenai p[6], p[7]); 132f1ff24aaSHariprasad Shenai } 133f1ff24aaSHariprasad Shenai return 0; 134f1ff24aaSHariprasad Shenai } 135f1ff24aaSHariprasad Shenai 136f1ff24aaSHariprasad Shenai static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx) 137f1ff24aaSHariprasad Shenai { 138f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) { 139f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC\n"); 140f1ff24aaSHariprasad Shenai } else { 141f1ff24aaSHariprasad Shenai const u32 *p = v; 142f1ff24aaSHariprasad Shenai 143f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %08x %08x\n", p[5] & 0xff, p[6], 144f1ff24aaSHariprasad Shenai p[7]); 145f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x\n", 146f1ff24aaSHariprasad Shenai (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8, 147f1ff24aaSHariprasad Shenai p[4] & 0xff, p[5] >> 8); 148f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %x%07x %x%07x\n", (p[0] >> 4) & 0xff, 149f1ff24aaSHariprasad Shenai p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4); 150f1ff24aaSHariprasad Shenai } 151f1ff24aaSHariprasad Shenai return 0; 152f1ff24aaSHariprasad Shenai } 153f1ff24aaSHariprasad Shenai 154b7660642SHariprasad Shenai static int cim_la_show_t6(struct seq_file *seq, void *v, int idx) 155b7660642SHariprasad Shenai { 156b7660642SHariprasad Shenai if (v == SEQ_START_TOKEN) { 157b7660642SHariprasad Shenai seq_puts(seq, "Status Inst Data PC LS0Stat " 158b7660642SHariprasad Shenai "LS0Addr LS0Data LS1Stat LS1Addr LS1Data\n"); 159b7660642SHariprasad Shenai } else { 160b7660642SHariprasad Shenai const u32 *p = v; 161b7660642SHariprasad Shenai 162b7660642SHariprasad Shenai seq_printf(seq, " %02x %04x%04x %04x%04x %04x%04x %08x %08x %08x %08x %08x %08x\n", 163b7660642SHariprasad Shenai (p[9] >> 16) & 0xff, /* Status */ 164b7660642SHariprasad Shenai p[9] & 0xffff, p[8] >> 16, /* Inst */ 165b7660642SHariprasad Shenai p[8] & 0xffff, p[7] >> 16, /* Data */ 166b7660642SHariprasad Shenai p[7] & 0xffff, p[6] >> 16, /* PC */ 167b7660642SHariprasad Shenai p[2], p[1], p[0], /* LS0 Stat, Addr and Data */ 168b7660642SHariprasad Shenai p[5], p[4], p[3]); /* LS1 Stat, Addr and Data */ 169b7660642SHariprasad Shenai } 170b7660642SHariprasad Shenai return 0; 171b7660642SHariprasad Shenai } 172b7660642SHariprasad Shenai 173b7660642SHariprasad Shenai static int cim_la_show_pc_t6(struct seq_file *seq, void *v, int idx) 174b7660642SHariprasad Shenai { 175b7660642SHariprasad Shenai if (v == SEQ_START_TOKEN) { 176b7660642SHariprasad Shenai seq_puts(seq, "Status Inst Data PC\n"); 177b7660642SHariprasad Shenai } else { 178b7660642SHariprasad Shenai const u32 *p = v; 179b7660642SHariprasad Shenai 180b7660642SHariprasad Shenai seq_printf(seq, " %02x %08x %08x %08x\n", 181b7660642SHariprasad Shenai p[3] & 0xff, p[2], p[1], p[0]); 182b7660642SHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x %02x%06x\n", 183b7660642SHariprasad Shenai (p[6] >> 8) & 0xff, p[6] & 0xff, p[5] >> 8, 184b7660642SHariprasad Shenai p[5] & 0xff, p[4] >> 8, p[4] & 0xff, p[3] >> 8); 185b7660642SHariprasad Shenai seq_printf(seq, " %02x %04x%04x %04x%04x %04x%04x\n", 186b7660642SHariprasad Shenai (p[9] >> 16) & 0xff, p[9] & 0xffff, p[8] >> 16, 187b7660642SHariprasad Shenai p[8] & 0xffff, p[7] >> 16, p[7] & 0xffff, 188b7660642SHariprasad Shenai p[6] >> 16); 189b7660642SHariprasad Shenai } 190b7660642SHariprasad Shenai return 0; 191b7660642SHariprasad Shenai } 192b7660642SHariprasad Shenai 193f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 194f1ff24aaSHariprasad Shenai { 195f1ff24aaSHariprasad Shenai int ret; 196f1ff24aaSHariprasad Shenai unsigned int cfg; 197f1ff24aaSHariprasad Shenai struct seq_tab *p; 198f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 199f1ff24aaSHariprasad Shenai 200f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 201f1ff24aaSHariprasad Shenai if (ret) 202f1ff24aaSHariprasad Shenai return ret; 203f1ff24aaSHariprasad Shenai 204b7660642SHariprasad Shenai if (is_t6(adap->params.chip)) { 205b7660642SHariprasad Shenai /* +1 to account for integer division of CIMLA_SIZE/10 */ 206b7660642SHariprasad Shenai p = seq_open_tab(file, (adap->params.cim_la_size / 10) + 1, 207b7660642SHariprasad Shenai 10 * sizeof(u32), 1, 208f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 209b7660642SHariprasad Shenai cim_la_show_pc_t6 : cim_la_show_t6); 210b7660642SHariprasad Shenai } else { 211b7660642SHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 212b7660642SHariprasad Shenai 8 * sizeof(u32), 1, 213b7660642SHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? cim_la_show_3in1 : 214b7660642SHariprasad Shenai cim_la_show); 215b7660642SHariprasad Shenai } 216f1ff24aaSHariprasad Shenai if (!p) 217f1ff24aaSHariprasad Shenai return -ENOMEM; 218f1ff24aaSHariprasad Shenai 219f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 220f1ff24aaSHariprasad Shenai if (ret) 221f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 222f1ff24aaSHariprasad Shenai return ret; 223f1ff24aaSHariprasad Shenai } 224f1ff24aaSHariprasad Shenai 225f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 226f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 227f1ff24aaSHariprasad Shenai .open = cim_la_open, 228f1ff24aaSHariprasad Shenai .read = seq_read, 229f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 230f1ff24aaSHariprasad Shenai .release = seq_release_private 231f1ff24aaSHariprasad Shenai }; 232f1ff24aaSHariprasad Shenai 23319689609SHariprasad Shenai static int cim_pif_la_show(struct seq_file *seq, void *v, int idx) 23419689609SHariprasad Shenai { 23519689609SHariprasad Shenai const u32 *p = v; 23619689609SHariprasad Shenai 23719689609SHariprasad Shenai if (v == SEQ_START_TOKEN) { 23819689609SHariprasad Shenai seq_puts(seq, "Cntl ID DataBE Addr Data\n"); 23919689609SHariprasad Shenai } else if (idx < CIM_PIFLA_SIZE) { 24019689609SHariprasad Shenai seq_printf(seq, " %02x %02x %04x %08x %08x%08x%08x%08x\n", 24119689609SHariprasad Shenai (p[5] >> 22) & 0xff, (p[5] >> 16) & 0x3f, 24219689609SHariprasad Shenai p[5] & 0xffff, p[4], p[3], p[2], p[1], p[0]); 24319689609SHariprasad Shenai } else { 24419689609SHariprasad Shenai if (idx == CIM_PIFLA_SIZE) 24519689609SHariprasad Shenai seq_puts(seq, "\nCntl ID Data\n"); 24619689609SHariprasad Shenai seq_printf(seq, " %02x %02x %08x%08x%08x%08x\n", 24719689609SHariprasad Shenai (p[4] >> 6) & 0xff, p[4] & 0x3f, 24819689609SHariprasad Shenai p[3], p[2], p[1], p[0]); 24919689609SHariprasad Shenai } 25019689609SHariprasad Shenai return 0; 25119689609SHariprasad Shenai } 25219689609SHariprasad Shenai 25319689609SHariprasad Shenai static int cim_pif_la_open(struct inode *inode, struct file *file) 25419689609SHariprasad Shenai { 25519689609SHariprasad Shenai struct seq_tab *p; 25619689609SHariprasad Shenai struct adapter *adap = inode->i_private; 25719689609SHariprasad Shenai 25819689609SHariprasad Shenai p = seq_open_tab(file, 2 * CIM_PIFLA_SIZE, 6 * sizeof(u32), 1, 25919689609SHariprasad Shenai cim_pif_la_show); 26019689609SHariprasad Shenai if (!p) 26119689609SHariprasad Shenai return -ENOMEM; 26219689609SHariprasad Shenai 26319689609SHariprasad Shenai t4_cim_read_pif_la(adap, (u32 *)p->data, 26419689609SHariprasad Shenai (u32 *)p->data + 6 * CIM_PIFLA_SIZE, NULL, NULL); 26519689609SHariprasad Shenai return 0; 26619689609SHariprasad Shenai } 26719689609SHariprasad Shenai 26819689609SHariprasad Shenai static const struct file_operations cim_pif_la_fops = { 26919689609SHariprasad Shenai .owner = THIS_MODULE, 27019689609SHariprasad Shenai .open = cim_pif_la_open, 27119689609SHariprasad Shenai .read = seq_read, 27219689609SHariprasad Shenai .llseek = seq_lseek, 27319689609SHariprasad Shenai .release = seq_release_private 27419689609SHariprasad Shenai }; 27519689609SHariprasad Shenai 27626fae93fSHariprasad Shenai static int cim_ma_la_show(struct seq_file *seq, void *v, int idx) 27726fae93fSHariprasad Shenai { 27826fae93fSHariprasad Shenai const u32 *p = v; 27926fae93fSHariprasad Shenai 28026fae93fSHariprasad Shenai if (v == SEQ_START_TOKEN) { 28126fae93fSHariprasad Shenai seq_puts(seq, "\n"); 28226fae93fSHariprasad Shenai } else if (idx < CIM_MALA_SIZE) { 28326fae93fSHariprasad Shenai seq_printf(seq, "%02x%08x%08x%08x%08x\n", 28426fae93fSHariprasad Shenai p[4], p[3], p[2], p[1], p[0]); 28526fae93fSHariprasad Shenai } else { 28626fae93fSHariprasad Shenai if (idx == CIM_MALA_SIZE) 28726fae93fSHariprasad Shenai seq_puts(seq, 28826fae93fSHariprasad Shenai "\nCnt ID Tag UE Data RDY VLD\n"); 28926fae93fSHariprasad Shenai seq_printf(seq, "%3u %2u %x %u %08x%08x %u %u\n", 29026fae93fSHariprasad Shenai (p[2] >> 10) & 0xff, (p[2] >> 7) & 7, 29126fae93fSHariprasad Shenai (p[2] >> 3) & 0xf, (p[2] >> 2) & 1, 29226fae93fSHariprasad Shenai (p[1] >> 2) | ((p[2] & 3) << 30), 29326fae93fSHariprasad Shenai (p[0] >> 2) | ((p[1] & 3) << 30), (p[0] >> 1) & 1, 29426fae93fSHariprasad Shenai p[0] & 1); 29526fae93fSHariprasad Shenai } 29626fae93fSHariprasad Shenai return 0; 29726fae93fSHariprasad Shenai } 29826fae93fSHariprasad Shenai 29926fae93fSHariprasad Shenai static int cim_ma_la_open(struct inode *inode, struct file *file) 30026fae93fSHariprasad Shenai { 30126fae93fSHariprasad Shenai struct seq_tab *p; 30226fae93fSHariprasad Shenai struct adapter *adap = inode->i_private; 30326fae93fSHariprasad Shenai 30426fae93fSHariprasad Shenai p = seq_open_tab(file, 2 * CIM_MALA_SIZE, 5 * sizeof(u32), 1, 30526fae93fSHariprasad Shenai cim_ma_la_show); 30626fae93fSHariprasad Shenai if (!p) 30726fae93fSHariprasad Shenai return -ENOMEM; 30826fae93fSHariprasad Shenai 30926fae93fSHariprasad Shenai t4_cim_read_ma_la(adap, (u32 *)p->data, 31026fae93fSHariprasad Shenai (u32 *)p->data + 5 * CIM_MALA_SIZE); 31126fae93fSHariprasad Shenai return 0; 31226fae93fSHariprasad Shenai } 31326fae93fSHariprasad Shenai 31426fae93fSHariprasad Shenai static const struct file_operations cim_ma_la_fops = { 31526fae93fSHariprasad Shenai .owner = THIS_MODULE, 31626fae93fSHariprasad Shenai .open = cim_ma_la_open, 31726fae93fSHariprasad Shenai .read = seq_read, 31826fae93fSHariprasad Shenai .llseek = seq_lseek, 31926fae93fSHariprasad Shenai .release = seq_release_private 32026fae93fSHariprasad Shenai }; 32126fae93fSHariprasad Shenai 32274b3092cSHariprasad Shenai static int cim_qcfg_show(struct seq_file *seq, void *v) 32374b3092cSHariprasad Shenai { 32474b3092cSHariprasad Shenai static const char * const qname[] = { 32574b3092cSHariprasad Shenai "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI", 32674b3092cSHariprasad Shenai "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI", 32774b3092cSHariprasad Shenai "SGE0-RX", "SGE1-RX" 32874b3092cSHariprasad Shenai }; 32974b3092cSHariprasad Shenai 33074b3092cSHariprasad Shenai int i; 33174b3092cSHariprasad Shenai struct adapter *adap = seq->private; 33274b3092cSHariprasad Shenai u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 33374b3092cSHariprasad Shenai u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 33474b3092cSHariprasad Shenai u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))]; 33574b3092cSHariprasad Shenai u16 thres[CIM_NUM_IBQ]; 33674b3092cSHariprasad Shenai u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr; 33774b3092cSHariprasad Shenai u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5]; 33874b3092cSHariprasad Shenai u32 *p = stat; 33974b3092cSHariprasad Shenai int cim_num_obq = is_t4(adap->params.chip) ? 34074b3092cSHariprasad Shenai CIM_NUM_OBQ : CIM_NUM_OBQ_T5; 34174b3092cSHariprasad Shenai 34274b3092cSHariprasad Shenai i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A : 34374b3092cSHariprasad Shenai UP_IBQ_0_SHADOW_RDADDR_A, 34474b3092cSHariprasad Shenai ARRAY_SIZE(stat), stat); 34574b3092cSHariprasad Shenai if (!i) { 34674b3092cSHariprasad Shenai if (is_t4(adap->params.chip)) { 34774b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A, 34874b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t4), obq_wr_t4); 34974b3092cSHariprasad Shenai wr = obq_wr_t4; 35074b3092cSHariprasad Shenai } else { 35174b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A, 35274b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t5), obq_wr_t5); 35374b3092cSHariprasad Shenai wr = obq_wr_t5; 35474b3092cSHariprasad Shenai } 35574b3092cSHariprasad Shenai } 35674b3092cSHariprasad Shenai if (i) 35774b3092cSHariprasad Shenai return i; 35874b3092cSHariprasad Shenai 35974b3092cSHariprasad Shenai t4_read_cimq_cfg(adap, base, size, thres); 36074b3092cSHariprasad Shenai 36174b3092cSHariprasad Shenai seq_printf(seq, 36274b3092cSHariprasad Shenai " Queue Base Size Thres RdPtr WrPtr SOP EOP Avail\n"); 36374b3092cSHariprasad Shenai for (i = 0; i < CIM_NUM_IBQ; i++, p += 4) 36474b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %5u %6x %4x %4u %4u %5u\n", 36574b3092cSHariprasad Shenai qname[i], base[i], size[i], thres[i], 36674b3092cSHariprasad Shenai IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]), 36774b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 36874b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 36974b3092cSHariprasad Shenai for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2) 37074b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %12x %4x %4u %4u %5u\n", 37174b3092cSHariprasad Shenai qname[i], base[i], size[i], 37274b3092cSHariprasad Shenai QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i], 37374b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 37474b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 37574b3092cSHariprasad Shenai return 0; 37674b3092cSHariprasad Shenai } 37774b3092cSHariprasad Shenai 37874b3092cSHariprasad Shenai static int cim_qcfg_open(struct inode *inode, struct file *file) 37974b3092cSHariprasad Shenai { 38074b3092cSHariprasad Shenai return single_open(file, cim_qcfg_show, inode->i_private); 38174b3092cSHariprasad Shenai } 38274b3092cSHariprasad Shenai 38374b3092cSHariprasad Shenai static const struct file_operations cim_qcfg_fops = { 38474b3092cSHariprasad Shenai .owner = THIS_MODULE, 38574b3092cSHariprasad Shenai .open = cim_qcfg_open, 38674b3092cSHariprasad Shenai .read = seq_read, 38774b3092cSHariprasad Shenai .llseek = seq_lseek, 38874b3092cSHariprasad Shenai .release = single_release, 38974b3092cSHariprasad Shenai }; 39074b3092cSHariprasad Shenai 391e5f0e43bSHariprasad Shenai static int cimq_show(struct seq_file *seq, void *v, int idx) 392e5f0e43bSHariprasad Shenai { 393e5f0e43bSHariprasad Shenai const u32 *p = v; 394e5f0e43bSHariprasad Shenai 395e5f0e43bSHariprasad Shenai seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1], 396e5f0e43bSHariprasad Shenai p[2], p[3]); 397e5f0e43bSHariprasad Shenai return 0; 398e5f0e43bSHariprasad Shenai } 399e5f0e43bSHariprasad Shenai 400e5f0e43bSHariprasad Shenai static int cim_ibq_open(struct inode *inode, struct file *file) 401e5f0e43bSHariprasad Shenai { 402e5f0e43bSHariprasad Shenai int ret; 403e5f0e43bSHariprasad Shenai struct seq_tab *p; 404e5f0e43bSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 405e5f0e43bSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 406e5f0e43bSHariprasad Shenai 407e5f0e43bSHariprasad Shenai p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 408e5f0e43bSHariprasad Shenai if (!p) 409e5f0e43bSHariprasad Shenai return -ENOMEM; 410e5f0e43bSHariprasad Shenai 411e5f0e43bSHariprasad Shenai ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4); 412e5f0e43bSHariprasad Shenai if (ret < 0) 413e5f0e43bSHariprasad Shenai seq_release_private(inode, file); 414e5f0e43bSHariprasad Shenai else 415e5f0e43bSHariprasad Shenai ret = 0; 416e5f0e43bSHariprasad Shenai return ret; 417e5f0e43bSHariprasad Shenai } 418e5f0e43bSHariprasad Shenai 419e5f0e43bSHariprasad Shenai static const struct file_operations cim_ibq_fops = { 420e5f0e43bSHariprasad Shenai .owner = THIS_MODULE, 421e5f0e43bSHariprasad Shenai .open = cim_ibq_open, 422e5f0e43bSHariprasad Shenai .read = seq_read, 423e5f0e43bSHariprasad Shenai .llseek = seq_lseek, 424e5f0e43bSHariprasad Shenai .release = seq_release_private 425e5f0e43bSHariprasad Shenai }; 426e5f0e43bSHariprasad Shenai 427c778af7dSHariprasad Shenai static int cim_obq_open(struct inode *inode, struct file *file) 428c778af7dSHariprasad Shenai { 429c778af7dSHariprasad Shenai int ret; 430c778af7dSHariprasad Shenai struct seq_tab *p; 431c778af7dSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 432c778af7dSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 433c778af7dSHariprasad Shenai 434c778af7dSHariprasad Shenai p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 435c778af7dSHariprasad Shenai if (!p) 436c778af7dSHariprasad Shenai return -ENOMEM; 437c778af7dSHariprasad Shenai 438c778af7dSHariprasad Shenai ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4); 439c778af7dSHariprasad Shenai if (ret < 0) { 440c778af7dSHariprasad Shenai seq_release_private(inode, file); 441c778af7dSHariprasad Shenai } else { 442c778af7dSHariprasad Shenai seq_tab_trim(p, ret / 4); 443c778af7dSHariprasad Shenai ret = 0; 444c778af7dSHariprasad Shenai } 445c778af7dSHariprasad Shenai return ret; 446c778af7dSHariprasad Shenai } 447c778af7dSHariprasad Shenai 448c778af7dSHariprasad Shenai static const struct file_operations cim_obq_fops = { 449c778af7dSHariprasad Shenai .owner = THIS_MODULE, 450c778af7dSHariprasad Shenai .open = cim_obq_open, 451c778af7dSHariprasad Shenai .read = seq_read, 452c778af7dSHariprasad Shenai .llseek = seq_lseek, 453c778af7dSHariprasad Shenai .release = seq_release_private 454c778af7dSHariprasad Shenai }; 455c778af7dSHariprasad Shenai 4562d277b3bSHariprasad Shenai struct field_desc { 4572d277b3bSHariprasad Shenai const char *name; 4582d277b3bSHariprasad Shenai unsigned int start; 4592d277b3bSHariprasad Shenai unsigned int width; 4602d277b3bSHariprasad Shenai }; 4612d277b3bSHariprasad Shenai 4622d277b3bSHariprasad Shenai static void field_desc_show(struct seq_file *seq, u64 v, 4632d277b3bSHariprasad Shenai const struct field_desc *p) 4642d277b3bSHariprasad Shenai { 4652d277b3bSHariprasad Shenai char buf[32]; 4662d277b3bSHariprasad Shenai int line_size = 0; 4672d277b3bSHariprasad Shenai 4682d277b3bSHariprasad Shenai while (p->name) { 4692d277b3bSHariprasad Shenai u64 mask = (1ULL << p->width) - 1; 4702d277b3bSHariprasad Shenai int len = scnprintf(buf, sizeof(buf), "%s: %llu", p->name, 4712d277b3bSHariprasad Shenai ((unsigned long long)v >> p->start) & mask); 4722d277b3bSHariprasad Shenai 4732d277b3bSHariprasad Shenai if (line_size + len >= 79) { 4742d277b3bSHariprasad Shenai line_size = 8; 4752d277b3bSHariprasad Shenai seq_puts(seq, "\n "); 4762d277b3bSHariprasad Shenai } 4772d277b3bSHariprasad Shenai seq_printf(seq, "%s ", buf); 4782d277b3bSHariprasad Shenai line_size += len + 1; 4792d277b3bSHariprasad Shenai p++; 4802d277b3bSHariprasad Shenai } 4812d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 4822d277b3bSHariprasad Shenai } 4832d277b3bSHariprasad Shenai 4842d277b3bSHariprasad Shenai static struct field_desc tp_la0[] = { 4852d277b3bSHariprasad Shenai { "RcfOpCodeOut", 60, 4 }, 4862d277b3bSHariprasad Shenai { "State", 56, 4 }, 4872d277b3bSHariprasad Shenai { "WcfState", 52, 4 }, 4882d277b3bSHariprasad Shenai { "RcfOpcSrcOut", 50, 2 }, 4892d277b3bSHariprasad Shenai { "CRxError", 49, 1 }, 4902d277b3bSHariprasad Shenai { "ERxError", 48, 1 }, 4912d277b3bSHariprasad Shenai { "SanityFailed", 47, 1 }, 4922d277b3bSHariprasad Shenai { "SpuriousMsg", 46, 1 }, 4932d277b3bSHariprasad Shenai { "FlushInputMsg", 45, 1 }, 4942d277b3bSHariprasad Shenai { "FlushInputCpl", 44, 1 }, 4952d277b3bSHariprasad Shenai { "RssUpBit", 43, 1 }, 4962d277b3bSHariprasad Shenai { "RssFilterHit", 42, 1 }, 4972d277b3bSHariprasad Shenai { "Tid", 32, 10 }, 4982d277b3bSHariprasad Shenai { "InitTcb", 31, 1 }, 4992d277b3bSHariprasad Shenai { "LineNumber", 24, 7 }, 5002d277b3bSHariprasad Shenai { "Emsg", 23, 1 }, 5012d277b3bSHariprasad Shenai { "EdataOut", 22, 1 }, 5022d277b3bSHariprasad Shenai { "Cmsg", 21, 1 }, 5032d277b3bSHariprasad Shenai { "CdataOut", 20, 1 }, 5042d277b3bSHariprasad Shenai { "EreadPdu", 19, 1 }, 5052d277b3bSHariprasad Shenai { "CreadPdu", 18, 1 }, 5062d277b3bSHariprasad Shenai { "TunnelPkt", 17, 1 }, 5072d277b3bSHariprasad Shenai { "RcfPeerFin", 16, 1 }, 5082d277b3bSHariprasad Shenai { "RcfReasonOut", 12, 4 }, 5092d277b3bSHariprasad Shenai { "TxCchannel", 10, 2 }, 5102d277b3bSHariprasad Shenai { "RcfTxChannel", 8, 2 }, 5112d277b3bSHariprasad Shenai { "RxEchannel", 6, 2 }, 5122d277b3bSHariprasad Shenai { "RcfRxChannel", 5, 1 }, 5132d277b3bSHariprasad Shenai { "RcfDataOutSrdy", 4, 1 }, 5142d277b3bSHariprasad Shenai { "RxDvld", 3, 1 }, 5152d277b3bSHariprasad Shenai { "RxOoDvld", 2, 1 }, 5162d277b3bSHariprasad Shenai { "RxCongestion", 1, 1 }, 5172d277b3bSHariprasad Shenai { "TxCongestion", 0, 1 }, 5182d277b3bSHariprasad Shenai { NULL } 5192d277b3bSHariprasad Shenai }; 5202d277b3bSHariprasad Shenai 5212d277b3bSHariprasad Shenai static int tp_la_show(struct seq_file *seq, void *v, int idx) 5222d277b3bSHariprasad Shenai { 5232d277b3bSHariprasad Shenai const u64 *p = v; 5242d277b3bSHariprasad Shenai 5252d277b3bSHariprasad Shenai field_desc_show(seq, *p, tp_la0); 5262d277b3bSHariprasad Shenai return 0; 5272d277b3bSHariprasad Shenai } 5282d277b3bSHariprasad Shenai 5292d277b3bSHariprasad Shenai static int tp_la_show2(struct seq_file *seq, void *v, int idx) 5302d277b3bSHariprasad Shenai { 5312d277b3bSHariprasad Shenai const u64 *p = v; 5322d277b3bSHariprasad Shenai 5332d277b3bSHariprasad Shenai if (idx) 5342d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 5352d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 5362d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 5372d277b3bSHariprasad Shenai field_desc_show(seq, p[1], tp_la0); 5382d277b3bSHariprasad Shenai return 0; 5392d277b3bSHariprasad Shenai } 5402d277b3bSHariprasad Shenai 5412d277b3bSHariprasad Shenai static int tp_la_show3(struct seq_file *seq, void *v, int idx) 5422d277b3bSHariprasad Shenai { 5432d277b3bSHariprasad Shenai static struct field_desc tp_la1[] = { 5442d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 5452d277b3bSHariprasad Shenai { "CplCmdOut", 48, 8 }, 5462d277b3bSHariprasad Shenai { "ESynOut", 47, 1 }, 5472d277b3bSHariprasad Shenai { "EAckOut", 46, 1 }, 5482d277b3bSHariprasad Shenai { "EFinOut", 45, 1 }, 5492d277b3bSHariprasad Shenai { "ERstOut", 44, 1 }, 5502d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 5512d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 5522d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 5532d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 5542d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 5552d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 5562d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 5572d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 5582d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 5592d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 5602d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 5612d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 5622d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 5632d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 5642d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 5652d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 5662d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 5672d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 5682d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 5692d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 5702d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 5712d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 5722d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 5732d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 5742d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 5752d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 5762d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 5772d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 5782d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 5792d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 5802d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 5812d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 5822d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 5832d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 5842d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 5852d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 5862d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 5872d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 5882d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 5892d277b3bSHariprasad Shenai { NULL } 5902d277b3bSHariprasad Shenai }; 5912d277b3bSHariprasad Shenai static struct field_desc tp_la2[] = { 5922d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 5932d277b3bSHariprasad Shenai { "MpsVfVld", 55, 1 }, 5942d277b3bSHariprasad Shenai { "MpsPf", 52, 3 }, 5952d277b3bSHariprasad Shenai { "MpsVf", 44, 8 }, 5962d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 5972d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 5982d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 5992d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 6002d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 6012d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 6022d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 6032d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 6042d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 6052d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 6062d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 6072d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 6082d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 6092d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 6102d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 6112d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 6122d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 6132d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 6142d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 6152d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 6162d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 6172d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 6182d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 6192d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 6202d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 6212d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 6222d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 6232d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 6242d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 6252d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 6262d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 6272d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 6282d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 6292d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 6302d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 6312d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 6322d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 6332d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 6342d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 6352d277b3bSHariprasad Shenai { NULL } 6362d277b3bSHariprasad Shenai }; 6372d277b3bSHariprasad Shenai const u64 *p = v; 6382d277b3bSHariprasad Shenai 6392d277b3bSHariprasad Shenai if (idx) 6402d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 6412d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 6422d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 6432d277b3bSHariprasad Shenai field_desc_show(seq, p[1], (p[0] & BIT(17)) ? tp_la2 : tp_la1); 6442d277b3bSHariprasad Shenai return 0; 6452d277b3bSHariprasad Shenai } 6462d277b3bSHariprasad Shenai 6472d277b3bSHariprasad Shenai static int tp_la_open(struct inode *inode, struct file *file) 6482d277b3bSHariprasad Shenai { 6492d277b3bSHariprasad Shenai struct seq_tab *p; 6502d277b3bSHariprasad Shenai struct adapter *adap = inode->i_private; 6512d277b3bSHariprasad Shenai 6522d277b3bSHariprasad Shenai switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) { 6532d277b3bSHariprasad Shenai case 2: 6542d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 6552d277b3bSHariprasad Shenai tp_la_show2); 6562d277b3bSHariprasad Shenai break; 6572d277b3bSHariprasad Shenai case 3: 6582d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 6592d277b3bSHariprasad Shenai tp_la_show3); 6602d277b3bSHariprasad Shenai break; 6612d277b3bSHariprasad Shenai default: 6622d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE, sizeof(u64), 0, tp_la_show); 6632d277b3bSHariprasad Shenai } 6642d277b3bSHariprasad Shenai if (!p) 6652d277b3bSHariprasad Shenai return -ENOMEM; 6662d277b3bSHariprasad Shenai 6672d277b3bSHariprasad Shenai t4_tp_read_la(adap, (u64 *)p->data, NULL); 6682d277b3bSHariprasad Shenai return 0; 6692d277b3bSHariprasad Shenai } 6702d277b3bSHariprasad Shenai 6712d277b3bSHariprasad Shenai static ssize_t tp_la_write(struct file *file, const char __user *buf, 6722d277b3bSHariprasad Shenai size_t count, loff_t *pos) 6732d277b3bSHariprasad Shenai { 6742d277b3bSHariprasad Shenai int err; 6752d277b3bSHariprasad Shenai char s[32]; 6762d277b3bSHariprasad Shenai unsigned long val; 6772d277b3bSHariprasad Shenai size_t size = min(sizeof(s) - 1, count); 678c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 6792d277b3bSHariprasad Shenai 6802d277b3bSHariprasad Shenai if (copy_from_user(s, buf, size)) 6812d277b3bSHariprasad Shenai return -EFAULT; 6822d277b3bSHariprasad Shenai s[size] = '\0'; 6832d277b3bSHariprasad Shenai err = kstrtoul(s, 0, &val); 6842d277b3bSHariprasad Shenai if (err) 6852d277b3bSHariprasad Shenai return err; 6862d277b3bSHariprasad Shenai if (val > 0xffff) 6872d277b3bSHariprasad Shenai return -EINVAL; 6882d277b3bSHariprasad Shenai adap->params.tp.la_mask = val << 16; 6892d277b3bSHariprasad Shenai t4_set_reg_field(adap, TP_DBG_LA_CONFIG_A, 0xffff0000U, 6902d277b3bSHariprasad Shenai adap->params.tp.la_mask); 6912d277b3bSHariprasad Shenai return count; 6922d277b3bSHariprasad Shenai } 6932d277b3bSHariprasad Shenai 6942d277b3bSHariprasad Shenai static const struct file_operations tp_la_fops = { 6952d277b3bSHariprasad Shenai .owner = THIS_MODULE, 6962d277b3bSHariprasad Shenai .open = tp_la_open, 6972d277b3bSHariprasad Shenai .read = seq_read, 6982d277b3bSHariprasad Shenai .llseek = seq_lseek, 6992d277b3bSHariprasad Shenai .release = seq_release_private, 7002d277b3bSHariprasad Shenai .write = tp_la_write 7012d277b3bSHariprasad Shenai }; 7022d277b3bSHariprasad Shenai 703797ff0f5SHariprasad Shenai static int ulprx_la_show(struct seq_file *seq, void *v, int idx) 704797ff0f5SHariprasad Shenai { 705797ff0f5SHariprasad Shenai const u32 *p = v; 706797ff0f5SHariprasad Shenai 707797ff0f5SHariprasad Shenai if (v == SEQ_START_TOKEN) 708797ff0f5SHariprasad Shenai seq_puts(seq, " Pcmd Type Message" 709797ff0f5SHariprasad Shenai " Data\n"); 710797ff0f5SHariprasad Shenai else 711797ff0f5SHariprasad Shenai seq_printf(seq, "%08x%08x %4x %08x %08x%08x%08x%08x\n", 712797ff0f5SHariprasad Shenai p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]); 713797ff0f5SHariprasad Shenai return 0; 714797ff0f5SHariprasad Shenai } 715797ff0f5SHariprasad Shenai 716797ff0f5SHariprasad Shenai static int ulprx_la_open(struct inode *inode, struct file *file) 717797ff0f5SHariprasad Shenai { 718797ff0f5SHariprasad Shenai struct seq_tab *p; 719797ff0f5SHariprasad Shenai struct adapter *adap = inode->i_private; 720797ff0f5SHariprasad Shenai 721797ff0f5SHariprasad Shenai p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1, 722797ff0f5SHariprasad Shenai ulprx_la_show); 723797ff0f5SHariprasad Shenai if (!p) 724797ff0f5SHariprasad Shenai return -ENOMEM; 725797ff0f5SHariprasad Shenai 726797ff0f5SHariprasad Shenai t4_ulprx_read_la(adap, (u32 *)p->data); 727797ff0f5SHariprasad Shenai return 0; 728797ff0f5SHariprasad Shenai } 729797ff0f5SHariprasad Shenai 730797ff0f5SHariprasad Shenai static const struct file_operations ulprx_la_fops = { 731797ff0f5SHariprasad Shenai .owner = THIS_MODULE, 732797ff0f5SHariprasad Shenai .open = ulprx_la_open, 733797ff0f5SHariprasad Shenai .read = seq_read, 734797ff0f5SHariprasad Shenai .llseek = seq_lseek, 735797ff0f5SHariprasad Shenai .release = seq_release_private 736797ff0f5SHariprasad Shenai }; 737797ff0f5SHariprasad Shenai 738b3bbe36aSHariprasad Shenai /* Show the PM memory stats. These stats include: 739b3bbe36aSHariprasad Shenai * 740b3bbe36aSHariprasad Shenai * TX: 741b3bbe36aSHariprasad Shenai * Read: memory read operation 742b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 743b3bbe36aSHariprasad Shenai * Bypass + mem: cut-through and save copy 744b3bbe36aSHariprasad Shenai * 745b3bbe36aSHariprasad Shenai * RX: 746b3bbe36aSHariprasad Shenai * Read: memory read 747b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 748b3bbe36aSHariprasad Shenai * Flush: payload trim or drop 749b3bbe36aSHariprasad Shenai */ 750b3bbe36aSHariprasad Shenai static int pm_stats_show(struct seq_file *seq, void *v) 751b3bbe36aSHariprasad Shenai { 752b3bbe36aSHariprasad Shenai static const char * const tx_pm_stats[] = { 753b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Bypass + mem:" 754b3bbe36aSHariprasad Shenai }; 755b3bbe36aSHariprasad Shenai static const char * const rx_pm_stats[] = { 756b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Flush:" 757b3bbe36aSHariprasad Shenai }; 758b3bbe36aSHariprasad Shenai 759b3bbe36aSHariprasad Shenai int i; 760b3bbe36aSHariprasad Shenai u32 tx_cnt[PM_NSTATS], rx_cnt[PM_NSTATS]; 761b3bbe36aSHariprasad Shenai u64 tx_cyc[PM_NSTATS], rx_cyc[PM_NSTATS]; 762b3bbe36aSHariprasad Shenai struct adapter *adap = seq->private; 763b3bbe36aSHariprasad Shenai 764b3bbe36aSHariprasad Shenai t4_pmtx_get_stats(adap, tx_cnt, tx_cyc); 765b3bbe36aSHariprasad Shenai t4_pmrx_get_stats(adap, rx_cnt, rx_cyc); 766b3bbe36aSHariprasad Shenai 767b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Tx pcmds", "Tx bytes"); 768b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 769b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 770b3bbe36aSHariprasad Shenai tx_pm_stats[i], tx_cnt[i], tx_cyc[i]); 771b3bbe36aSHariprasad Shenai 772b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Rx pcmds", "Rx bytes"); 773b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 774b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 775b3bbe36aSHariprasad Shenai rx_pm_stats[i], rx_cnt[i], rx_cyc[i]); 776b3bbe36aSHariprasad Shenai return 0; 777b3bbe36aSHariprasad Shenai } 778b3bbe36aSHariprasad Shenai 779b3bbe36aSHariprasad Shenai static int pm_stats_open(struct inode *inode, struct file *file) 780b3bbe36aSHariprasad Shenai { 781b3bbe36aSHariprasad Shenai return single_open(file, pm_stats_show, inode->i_private); 782b3bbe36aSHariprasad Shenai } 783b3bbe36aSHariprasad Shenai 784b3bbe36aSHariprasad Shenai static ssize_t pm_stats_clear(struct file *file, const char __user *buf, 785b3bbe36aSHariprasad Shenai size_t count, loff_t *pos) 786b3bbe36aSHariprasad Shenai { 787c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 788b3bbe36aSHariprasad Shenai 789b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0); 790b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0); 791b3bbe36aSHariprasad Shenai return count; 792b3bbe36aSHariprasad Shenai } 793b3bbe36aSHariprasad Shenai 794b3bbe36aSHariprasad Shenai static const struct file_operations pm_stats_debugfs_fops = { 795b3bbe36aSHariprasad Shenai .owner = THIS_MODULE, 796b3bbe36aSHariprasad Shenai .open = pm_stats_open, 797b3bbe36aSHariprasad Shenai .read = seq_read, 798b3bbe36aSHariprasad Shenai .llseek = seq_lseek, 799b3bbe36aSHariprasad Shenai .release = single_release, 800b3bbe36aSHariprasad Shenai .write = pm_stats_clear 801b3bbe36aSHariprasad Shenai }; 802b3bbe36aSHariprasad Shenai 8037864026bSHariprasad Shenai static int tx_rate_show(struct seq_file *seq, void *v) 8047864026bSHariprasad Shenai { 8057864026bSHariprasad Shenai u64 nrate[NCHAN], orate[NCHAN]; 8067864026bSHariprasad Shenai struct adapter *adap = seq->private; 8077864026bSHariprasad Shenai 8087864026bSHariprasad Shenai t4_get_chan_txrate(adap, nrate, orate); 8097864026bSHariprasad Shenai if (adap->params.arch.nchan == NCHAN) { 8107864026bSHariprasad Shenai seq_puts(seq, " channel 0 channel 1 " 8117864026bSHariprasad Shenai "channel 2 channel 3\n"); 8127864026bSHariprasad Shenai seq_printf(seq, "NIC B/s: %10llu %10llu %10llu %10llu\n", 8137864026bSHariprasad Shenai (unsigned long long)nrate[0], 8147864026bSHariprasad Shenai (unsigned long long)nrate[1], 8157864026bSHariprasad Shenai (unsigned long long)nrate[2], 8167864026bSHariprasad Shenai (unsigned long long)nrate[3]); 8177864026bSHariprasad Shenai seq_printf(seq, "Offload B/s: %10llu %10llu %10llu %10llu\n", 8187864026bSHariprasad Shenai (unsigned long long)orate[0], 8197864026bSHariprasad Shenai (unsigned long long)orate[1], 8207864026bSHariprasad Shenai (unsigned long long)orate[2], 8217864026bSHariprasad Shenai (unsigned long long)orate[3]); 8227864026bSHariprasad Shenai } else { 8237864026bSHariprasad Shenai seq_puts(seq, " channel 0 channel 1\n"); 8247864026bSHariprasad Shenai seq_printf(seq, "NIC B/s: %10llu %10llu\n", 8257864026bSHariprasad Shenai (unsigned long long)nrate[0], 8267864026bSHariprasad Shenai (unsigned long long)nrate[1]); 8277864026bSHariprasad Shenai seq_printf(seq, "Offload B/s: %10llu %10llu\n", 8287864026bSHariprasad Shenai (unsigned long long)orate[0], 8297864026bSHariprasad Shenai (unsigned long long)orate[1]); 8307864026bSHariprasad Shenai } 8317864026bSHariprasad Shenai return 0; 8327864026bSHariprasad Shenai } 8337864026bSHariprasad Shenai 8347864026bSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(tx_rate); 8357864026bSHariprasad Shenai 836bad43792SHariprasad Shenai static int cctrl_tbl_show(struct seq_file *seq, void *v) 837bad43792SHariprasad Shenai { 838bad43792SHariprasad Shenai static const char * const dec_fac[] = { 839bad43792SHariprasad Shenai "0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875", 840bad43792SHariprasad Shenai "0.9375" }; 841bad43792SHariprasad Shenai 842bad43792SHariprasad Shenai int i; 843dde93dfeSHariprasad Shenai u16 (*incr)[NCCTRL_WIN]; 844bad43792SHariprasad Shenai struct adapter *adap = seq->private; 845bad43792SHariprasad Shenai 846dde93dfeSHariprasad Shenai incr = kmalloc(sizeof(*incr) * NMTUS, GFP_KERNEL); 847dde93dfeSHariprasad Shenai if (!incr) 848dde93dfeSHariprasad Shenai return -ENOMEM; 849dde93dfeSHariprasad Shenai 850bad43792SHariprasad Shenai t4_read_cong_tbl(adap, incr); 851bad43792SHariprasad Shenai 852bad43792SHariprasad Shenai for (i = 0; i < NCCTRL_WIN; ++i) { 853bad43792SHariprasad Shenai seq_printf(seq, "%2d: %4u %4u %4u %4u %4u %4u %4u %4u\n", i, 854bad43792SHariprasad Shenai incr[0][i], incr[1][i], incr[2][i], incr[3][i], 855bad43792SHariprasad Shenai incr[4][i], incr[5][i], incr[6][i], incr[7][i]); 856bad43792SHariprasad Shenai seq_printf(seq, "%8u %4u %4u %4u %4u %4u %4u %4u %5u %s\n", 857bad43792SHariprasad Shenai incr[8][i], incr[9][i], incr[10][i], incr[11][i], 858bad43792SHariprasad Shenai incr[12][i], incr[13][i], incr[14][i], incr[15][i], 859bad43792SHariprasad Shenai adap->params.a_wnd[i], 860bad43792SHariprasad Shenai dec_fac[adap->params.b_wnd[i]]); 861bad43792SHariprasad Shenai } 862dde93dfeSHariprasad Shenai 863dde93dfeSHariprasad Shenai kfree(incr); 864bad43792SHariprasad Shenai return 0; 865bad43792SHariprasad Shenai } 866bad43792SHariprasad Shenai 867bad43792SHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(cctrl_tbl); 868bad43792SHariprasad Shenai 869b58b6676SHariprasad Shenai /* Format a value in a unit that differs from the value's native unit by the 870b58b6676SHariprasad Shenai * given factor. 871b58b6676SHariprasad Shenai */ 872b58b6676SHariprasad Shenai static char *unit_conv(char *buf, size_t len, unsigned int val, 873b58b6676SHariprasad Shenai unsigned int factor) 874b58b6676SHariprasad Shenai { 875b58b6676SHariprasad Shenai unsigned int rem = val % factor; 876b58b6676SHariprasad Shenai 877b58b6676SHariprasad Shenai if (rem == 0) { 878b58b6676SHariprasad Shenai snprintf(buf, len, "%u", val / factor); 879b58b6676SHariprasad Shenai } else { 880b58b6676SHariprasad Shenai while (rem % 10 == 0) 881b58b6676SHariprasad Shenai rem /= 10; 882b58b6676SHariprasad Shenai snprintf(buf, len, "%u.%u", val / factor, rem); 883b58b6676SHariprasad Shenai } 884b58b6676SHariprasad Shenai return buf; 885b58b6676SHariprasad Shenai } 886b58b6676SHariprasad Shenai 887b58b6676SHariprasad Shenai static int clk_show(struct seq_file *seq, void *v) 888b58b6676SHariprasad Shenai { 889b58b6676SHariprasad Shenai char buf[32]; 890b58b6676SHariprasad Shenai struct adapter *adap = seq->private; 891b58b6676SHariprasad Shenai unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk; /* in ps */ 892b58b6676SHariprasad Shenai u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A); 893b58b6676SHariprasad Shenai unsigned int tre = TIMERRESOLUTION_G(res); 894b58b6676SHariprasad Shenai unsigned int dack_re = DELAYEDACKRESOLUTION_G(res); 895b58b6676SHariprasad Shenai unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */ 896b58b6676SHariprasad Shenai 897b58b6676SHariprasad Shenai seq_printf(seq, "Core clock period: %s ns\n", 898b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), cclk_ps, 1000)); 899b58b6676SHariprasad Shenai seq_printf(seq, "TP timer tick: %s us\n", 900b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000)); 901b58b6676SHariprasad Shenai seq_printf(seq, "TCP timestamp tick: %s us\n", 902b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), 903b58b6676SHariprasad Shenai (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000)); 904b58b6676SHariprasad Shenai seq_printf(seq, "DACK tick: %s us\n", 905b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000)); 906b58b6676SHariprasad Shenai seq_printf(seq, "DACK timer: %u us\n", 907b58b6676SHariprasad Shenai ((cclk_ps << dack_re) / 1000000) * 908b58b6676SHariprasad Shenai t4_read_reg(adap, TP_DACK_TIMER_A)); 909b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit min: %llu us\n", 910b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A)); 911b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit max: %llu us\n", 912b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A)); 913b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer min: %llu us\n", 914b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A)); 915b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer max: %llu us\n", 916b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A)); 917b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive idle timer: %llu us\n", 918b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A)); 919b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive interval: %llu us\n", 920b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A)); 921b58b6676SHariprasad Shenai seq_printf(seq, "Initial SRTT: %llu us\n", 922b58b6676SHariprasad Shenai tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A))); 923b58b6676SHariprasad Shenai seq_printf(seq, "FINWAIT2 timer: %llu us\n", 924b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A)); 925b58b6676SHariprasad Shenai 926b58b6676SHariprasad Shenai return 0; 927b58b6676SHariprasad Shenai } 928b58b6676SHariprasad Shenai 929b58b6676SHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(clk); 930b58b6676SHariprasad Shenai 931f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 93249aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 93349aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 93449aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 93549aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 93649aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 93749aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 93849aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 93949aa284fSHariprasad Shenai }; 94049aa284fSHariprasad Shenai 94149aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 94249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 94349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 94449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 94549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 94649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 94749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 94849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 94949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 95049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 95149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 95249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 95349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 95449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 95549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 95649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 95749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 95849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 95949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 96049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 96149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 96249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 96349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 96449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 96549aa284fSHariprasad Shenai }; 96649aa284fSHariprasad Shenai 96749aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 96849aa284fSHariprasad Shenai */ 96949aa284fSHariprasad Shenai struct devlog_info { 97049aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 97149aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 97249aa284fSHariprasad Shenai struct fw_devlog_e log[0]; /* Firmware Device Log */ 97349aa284fSHariprasad Shenai }; 97449aa284fSHariprasad Shenai 97549aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 97649aa284fSHariprasad Shenai */ 97749aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 97849aa284fSHariprasad Shenai { 97949aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 98049aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 98149aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 98249aa284fSHariprasad Shenai else { 98349aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 98449aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 98549aa284fSHariprasad Shenai unsigned long index; 98649aa284fSHariprasad Shenai struct fw_devlog_e *e; 98749aa284fSHariprasad Shenai 98849aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 98949aa284fSHariprasad Shenai * entries. 99049aa284fSHariprasad Shenai */ 99149aa284fSHariprasad Shenai index = dinfo->first + fidx; 99249aa284fSHariprasad Shenai if (index >= dinfo->nentries) 99349aa284fSHariprasad Shenai index -= dinfo->nentries; 99449aa284fSHariprasad Shenai e = &dinfo->log[index]; 99549aa284fSHariprasad Shenai if (e->timestamp == 0) 99649aa284fSHariprasad Shenai return 0; 99749aa284fSHariprasad Shenai 99849aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 99949aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 100049aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 100149aa284fSHariprasad Shenai */ 100249aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 1003fda8b18cSHariprasad Shenai be32_to_cpu(e->seqno), 1004fda8b18cSHariprasad Shenai be64_to_cpu(e->timestamp), 100549aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 100649aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 100749aa284fSHariprasad Shenai : "UNKNOWN"), 100849aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 100949aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 101049aa284fSHariprasad Shenai : "UNKNOWN")); 1011fda8b18cSHariprasad Shenai seq_printf(seq, e->fmt, 1012fda8b18cSHariprasad Shenai be32_to_cpu(e->params[0]), 1013fda8b18cSHariprasad Shenai be32_to_cpu(e->params[1]), 1014fda8b18cSHariprasad Shenai be32_to_cpu(e->params[2]), 1015fda8b18cSHariprasad Shenai be32_to_cpu(e->params[3]), 1016fda8b18cSHariprasad Shenai be32_to_cpu(e->params[4]), 1017fda8b18cSHariprasad Shenai be32_to_cpu(e->params[5]), 1018fda8b18cSHariprasad Shenai be32_to_cpu(e->params[6]), 1019fda8b18cSHariprasad Shenai be32_to_cpu(e->params[7])); 102049aa284fSHariprasad Shenai } 102149aa284fSHariprasad Shenai return 0; 102249aa284fSHariprasad Shenai } 102349aa284fSHariprasad Shenai 102449aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 102549aa284fSHariprasad Shenai */ 102649aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 102749aa284fSHariprasad Shenai { 102849aa284fSHariprasad Shenai if (pos > dinfo->nentries) 102949aa284fSHariprasad Shenai return NULL; 103049aa284fSHariprasad Shenai 103149aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 103249aa284fSHariprasad Shenai } 103349aa284fSHariprasad Shenai 103449aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 103549aa284fSHariprasad Shenai { 103649aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 103749aa284fSHariprasad Shenai 103849aa284fSHariprasad Shenai return (*pos 103949aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 104049aa284fSHariprasad Shenai : SEQ_START_TOKEN); 104149aa284fSHariprasad Shenai } 104249aa284fSHariprasad Shenai 104349aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 104449aa284fSHariprasad Shenai { 104549aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 104649aa284fSHariprasad Shenai 104749aa284fSHariprasad Shenai (*pos)++; 104849aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 104949aa284fSHariprasad Shenai } 105049aa284fSHariprasad Shenai 105149aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 105249aa284fSHariprasad Shenai { 105349aa284fSHariprasad Shenai } 105449aa284fSHariprasad Shenai 105549aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 105649aa284fSHariprasad Shenai .start = devlog_start, 105749aa284fSHariprasad Shenai .next = devlog_next, 105849aa284fSHariprasad Shenai .stop = devlog_stop, 105949aa284fSHariprasad Shenai .show = devlog_show 106049aa284fSHariprasad Shenai }; 106149aa284fSHariprasad Shenai 106249aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 106349aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 106449aa284fSHariprasad Shenai */ 106549aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 106649aa284fSHariprasad Shenai { 106749aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 106849aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 106949aa284fSHariprasad Shenai struct devlog_info *dinfo; 107049aa284fSHariprasad Shenai unsigned int index; 107149aa284fSHariprasad Shenai u32 fseqno; 107249aa284fSHariprasad Shenai int ret; 107349aa284fSHariprasad Shenai 107449aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 107549aa284fSHariprasad Shenai */ 107649aa284fSHariprasad Shenai if (dparams->start == 0) 107749aa284fSHariprasad Shenai return -ENXIO; 107849aa284fSHariprasad Shenai 107949aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 108049aa284fSHariprasad Shenai * for the iterated call to our display function. 108149aa284fSHariprasad Shenai */ 108249aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 108349aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 108449aa284fSHariprasad Shenai if (!dinfo) 108549aa284fSHariprasad Shenai return -ENOMEM; 108649aa284fSHariprasad Shenai 108749aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 108849aa284fSHariprasad Shenai */ 108949aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 109049aa284fSHariprasad Shenai dinfo->first = 0; 109149aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 109249aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 109349aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 109449aa284fSHariprasad Shenai T4_MEMORY_READ); 109549aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 109649aa284fSHariprasad Shenai if (ret) { 109749aa284fSHariprasad Shenai seq_release_private(inode, file); 109849aa284fSHariprasad Shenai return ret; 109949aa284fSHariprasad Shenai } 110049aa284fSHariprasad Shenai 1101fda8b18cSHariprasad Shenai /* Find the earliest (lowest Sequence Number) log entry in the 1102fda8b18cSHariprasad Shenai * circular Device Log. 110349aa284fSHariprasad Shenai */ 110449aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 110549aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 110649aa284fSHariprasad Shenai __u32 seqno; 110749aa284fSHariprasad Shenai 110849aa284fSHariprasad Shenai if (e->timestamp == 0) 110949aa284fSHariprasad Shenai continue; 111049aa284fSHariprasad Shenai 111149aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 111249aa284fSHariprasad Shenai if (seqno < fseqno) { 111349aa284fSHariprasad Shenai fseqno = seqno; 111449aa284fSHariprasad Shenai dinfo->first = index; 111549aa284fSHariprasad Shenai } 111649aa284fSHariprasad Shenai } 111749aa284fSHariprasad Shenai return 0; 111849aa284fSHariprasad Shenai } 111949aa284fSHariprasad Shenai 112049aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 112149aa284fSHariprasad Shenai .owner = THIS_MODULE, 112249aa284fSHariprasad Shenai .open = devlog_open, 112349aa284fSHariprasad Shenai .read = seq_read, 112449aa284fSHariprasad Shenai .llseek = seq_lseek, 112549aa284fSHariprasad Shenai .release = seq_release_private 112649aa284fSHariprasad Shenai }; 112749aa284fSHariprasad Shenai 1128bf7c781dSHariprasad Shenai static int mbox_show(struct seq_file *seq, void *v) 1129bf7c781dSHariprasad Shenai { 1130bf7c781dSHariprasad Shenai static const char * const owner[] = { "none", "FW", "driver", 1131bf7c781dSHariprasad Shenai "unknown" }; 1132bf7c781dSHariprasad Shenai 1133bf7c781dSHariprasad Shenai int i; 1134bf7c781dSHariprasad Shenai unsigned int mbox = (uintptr_t)seq->private & 7; 1135bf7c781dSHariprasad Shenai struct adapter *adap = seq->private - mbox; 1136bf7c781dSHariprasad Shenai void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 1137bf7c781dSHariprasad Shenai unsigned int ctrl_reg = (is_t4(adap->params.chip) 1138bf7c781dSHariprasad Shenai ? CIM_PF_MAILBOX_CTRL_A 1139bf7c781dSHariprasad Shenai : CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A); 1140bf7c781dSHariprasad Shenai void __iomem *ctrl = adap->regs + PF_REG(mbox, ctrl_reg); 1141bf7c781dSHariprasad Shenai 1142bf7c781dSHariprasad Shenai i = MBOWNER_G(readl(ctrl)); 1143bf7c781dSHariprasad Shenai seq_printf(seq, "mailbox owned by %s\n\n", owner[i]); 1144bf7c781dSHariprasad Shenai 1145bf7c781dSHariprasad Shenai for (i = 0; i < MBOX_LEN; i += 8) 1146bf7c781dSHariprasad Shenai seq_printf(seq, "%016llx\n", 1147bf7c781dSHariprasad Shenai (unsigned long long)readq(addr + i)); 1148bf7c781dSHariprasad Shenai return 0; 1149bf7c781dSHariprasad Shenai } 1150bf7c781dSHariprasad Shenai 1151bf7c781dSHariprasad Shenai static int mbox_open(struct inode *inode, struct file *file) 1152bf7c781dSHariprasad Shenai { 1153bf7c781dSHariprasad Shenai return single_open(file, mbox_show, inode->i_private); 1154bf7c781dSHariprasad Shenai } 1155bf7c781dSHariprasad Shenai 1156bf7c781dSHariprasad Shenai static ssize_t mbox_write(struct file *file, const char __user *buf, 1157bf7c781dSHariprasad Shenai size_t count, loff_t *pos) 1158bf7c781dSHariprasad Shenai { 1159bf7c781dSHariprasad Shenai int i; 1160bf7c781dSHariprasad Shenai char c = '\n', s[256]; 1161bf7c781dSHariprasad Shenai unsigned long long data[8]; 1162bf7c781dSHariprasad Shenai const struct inode *ino; 1163bf7c781dSHariprasad Shenai unsigned int mbox; 1164bf7c781dSHariprasad Shenai struct adapter *adap; 1165bf7c781dSHariprasad Shenai void __iomem *addr; 1166bf7c781dSHariprasad Shenai void __iomem *ctrl; 1167bf7c781dSHariprasad Shenai 1168bf7c781dSHariprasad Shenai if (count > sizeof(s) - 1 || !count) 1169bf7c781dSHariprasad Shenai return -EINVAL; 1170bf7c781dSHariprasad Shenai if (copy_from_user(s, buf, count)) 1171bf7c781dSHariprasad Shenai return -EFAULT; 1172bf7c781dSHariprasad Shenai s[count] = '\0'; 1173bf7c781dSHariprasad Shenai 1174bf7c781dSHariprasad Shenai if (sscanf(s, "%llx %llx %llx %llx %llx %llx %llx %llx%c", &data[0], 1175bf7c781dSHariprasad Shenai &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], 1176bf7c781dSHariprasad Shenai &data[7], &c) < 8 || c != '\n') 1177bf7c781dSHariprasad Shenai return -EINVAL; 1178bf7c781dSHariprasad Shenai 1179c1d81b1cSDavid Howells ino = file_inode(file); 1180bf7c781dSHariprasad Shenai mbox = (uintptr_t)ino->i_private & 7; 1181bf7c781dSHariprasad Shenai adap = ino->i_private - mbox; 1182bf7c781dSHariprasad Shenai addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 1183bf7c781dSHariprasad Shenai ctrl = addr + MBOX_LEN; 1184bf7c781dSHariprasad Shenai 1185bf7c781dSHariprasad Shenai if (MBOWNER_G(readl(ctrl)) != X_MBOWNER_PL) 1186bf7c781dSHariprasad Shenai return -EBUSY; 1187bf7c781dSHariprasad Shenai 1188bf7c781dSHariprasad Shenai for (i = 0; i < 8; i++) 1189bf7c781dSHariprasad Shenai writeq(data[i], addr + 8 * i); 1190bf7c781dSHariprasad Shenai 1191bf7c781dSHariprasad Shenai writel(MBMSGVALID_F | MBOWNER_V(X_MBOWNER_FW), ctrl); 1192bf7c781dSHariprasad Shenai return count; 1193bf7c781dSHariprasad Shenai } 1194bf7c781dSHariprasad Shenai 1195bf7c781dSHariprasad Shenai static const struct file_operations mbox_debugfs_fops = { 1196bf7c781dSHariprasad Shenai .owner = THIS_MODULE, 1197bf7c781dSHariprasad Shenai .open = mbox_open, 1198bf7c781dSHariprasad Shenai .read = seq_read, 1199bf7c781dSHariprasad Shenai .llseek = seq_lseek, 1200bf7c781dSHariprasad Shenai .release = single_release, 1201bf7c781dSHariprasad Shenai .write = mbox_write 1202bf7c781dSHariprasad Shenai }; 1203bf7c781dSHariprasad Shenai 120449216c1cSHariprasad Shenai static ssize_t flash_read(struct file *file, char __user *buf, size_t count, 120549216c1cSHariprasad Shenai loff_t *ppos) 120649216c1cSHariprasad Shenai { 120749216c1cSHariprasad Shenai loff_t pos = *ppos; 1208c1d81b1cSDavid Howells loff_t avail = file_inode(file)->i_size; 120949216c1cSHariprasad Shenai struct adapter *adap = file->private_data; 121049216c1cSHariprasad Shenai 121149216c1cSHariprasad Shenai if (pos < 0) 121249216c1cSHariprasad Shenai return -EINVAL; 121349216c1cSHariprasad Shenai if (pos >= avail) 121449216c1cSHariprasad Shenai return 0; 121549216c1cSHariprasad Shenai if (count > avail - pos) 121649216c1cSHariprasad Shenai count = avail - pos; 121749216c1cSHariprasad Shenai 121849216c1cSHariprasad Shenai while (count) { 121949216c1cSHariprasad Shenai size_t len; 122049216c1cSHariprasad Shenai int ret, ofst; 122149216c1cSHariprasad Shenai u8 data[256]; 122249216c1cSHariprasad Shenai 122349216c1cSHariprasad Shenai ofst = pos & 3; 122449216c1cSHariprasad Shenai len = min(count + ofst, sizeof(data)); 122549216c1cSHariprasad Shenai ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4, 122649216c1cSHariprasad Shenai (u32 *)data, 1); 122749216c1cSHariprasad Shenai if (ret) 122849216c1cSHariprasad Shenai return ret; 122949216c1cSHariprasad Shenai 123049216c1cSHariprasad Shenai len -= ofst; 123149216c1cSHariprasad Shenai if (copy_to_user(buf, data + ofst, len)) 123249216c1cSHariprasad Shenai return -EFAULT; 123349216c1cSHariprasad Shenai 123449216c1cSHariprasad Shenai buf += len; 123549216c1cSHariprasad Shenai pos += len; 123649216c1cSHariprasad Shenai count -= len; 123749216c1cSHariprasad Shenai } 123849216c1cSHariprasad Shenai count = pos - *ppos; 123949216c1cSHariprasad Shenai *ppos = pos; 124049216c1cSHariprasad Shenai return count; 124149216c1cSHariprasad Shenai } 124249216c1cSHariprasad Shenai 124349216c1cSHariprasad Shenai static const struct file_operations flash_debugfs_fops = { 124449216c1cSHariprasad Shenai .owner = THIS_MODULE, 124549216c1cSHariprasad Shenai .open = mem_open, 124649216c1cSHariprasad Shenai .read = flash_read, 124749216c1cSHariprasad Shenai }; 124849216c1cSHariprasad Shenai 1249ef82f662SHariprasad Shenai static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask) 1250ef82f662SHariprasad Shenai { 1251ef82f662SHariprasad Shenai *mask = x | y; 1252ef82f662SHariprasad Shenai y = (__force u64)cpu_to_be64(y); 1253ef82f662SHariprasad Shenai memcpy(addr, (char *)&y + 2, ETH_ALEN); 1254ef82f662SHariprasad Shenai } 1255ef82f662SHariprasad Shenai 1256ef82f662SHariprasad Shenai static int mps_tcam_show(struct seq_file *seq, void *v) 1257ef82f662SHariprasad Shenai { 12583ccc6cf7SHariprasad Shenai struct adapter *adap = seq->private; 12593ccc6cf7SHariprasad Shenai unsigned int chip_ver = CHELSIO_CHIP_VERSION(adap->params.chip); 12603ccc6cf7SHariprasad Shenai 12613ccc6cf7SHariprasad Shenai if (v == SEQ_START_TOKEN) { 12623ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 12633ccc6cf7SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask " 12643ccc6cf7SHariprasad Shenai "Vld Ports PF VF " 12653ccc6cf7SHariprasad Shenai "Replication " 1266ef82f662SHariprasad Shenai " P0 P1 P2 P3 ML\n"); 12673ccc6cf7SHariprasad Shenai else 12683ccc6cf7SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask " 12693ccc6cf7SHariprasad Shenai "Vld Ports PF VF Replication" 12703ccc6cf7SHariprasad Shenai " P0 P1 P2 P3 ML\n"); 12713ccc6cf7SHariprasad Shenai } else { 1272ef82f662SHariprasad Shenai u64 mask; 1273ef82f662SHariprasad Shenai u8 addr[ETH_ALEN]; 12743ccc6cf7SHariprasad Shenai bool replicate; 1275ef82f662SHariprasad Shenai unsigned int idx = (uintptr_t)v - 2; 12763ccc6cf7SHariprasad Shenai u64 tcamy, tcamx, val; 12773ccc6cf7SHariprasad Shenai u32 cls_lo, cls_hi, ctl; 12783ccc6cf7SHariprasad Shenai u32 rplc[8] = {0}; 12793ccc6cf7SHariprasad Shenai 12803ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) { 12813ccc6cf7SHariprasad Shenai /* CtlCmdType - 0: Read, 1: Write 12823ccc6cf7SHariprasad Shenai * CtlTcamSel - 0: TCAM0, 1: TCAM1 12833ccc6cf7SHariprasad Shenai * CtlXYBitSel- 0: Y bit, 1: X bit 12843ccc6cf7SHariprasad Shenai */ 12853ccc6cf7SHariprasad Shenai 12863ccc6cf7SHariprasad Shenai /* Read tcamy */ 12873ccc6cf7SHariprasad Shenai ctl = CTLCMDTYPE_V(0) | CTLXYBITSEL_V(0); 12883ccc6cf7SHariprasad Shenai if (idx < 256) 12893ccc6cf7SHariprasad Shenai ctl |= CTLTCAMINDEX_V(idx) | CTLTCAMSEL_V(0); 12903ccc6cf7SHariprasad Shenai else 12913ccc6cf7SHariprasad Shenai ctl |= CTLTCAMINDEX_V(idx - 256) | 12923ccc6cf7SHariprasad Shenai CTLTCAMSEL_V(1); 12933ccc6cf7SHariprasad Shenai t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl); 12943ccc6cf7SHariprasad Shenai val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A); 12953ccc6cf7SHariprasad Shenai tcamy = DMACH_G(val) << 32; 12963ccc6cf7SHariprasad Shenai tcamy |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A); 12973ccc6cf7SHariprasad Shenai 12983ccc6cf7SHariprasad Shenai /* Read tcamx. Change the control param */ 12993ccc6cf7SHariprasad Shenai ctl |= CTLXYBITSEL_V(1); 13003ccc6cf7SHariprasad Shenai t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl); 13013ccc6cf7SHariprasad Shenai val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A); 13023ccc6cf7SHariprasad Shenai tcamx = DMACH_G(val) << 32; 13033ccc6cf7SHariprasad Shenai tcamx |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A); 13043ccc6cf7SHariprasad Shenai } else { 13053ccc6cf7SHariprasad Shenai tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx)); 13063ccc6cf7SHariprasad Shenai tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx)); 13073ccc6cf7SHariprasad Shenai } 13083ccc6cf7SHariprasad Shenai 13093ccc6cf7SHariprasad Shenai cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx)); 13103ccc6cf7SHariprasad Shenai cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx)); 1311ef82f662SHariprasad Shenai 1312ef82f662SHariprasad Shenai if (tcamx & tcamy) { 1313ef82f662SHariprasad Shenai seq_printf(seq, "%3u -\n", idx); 1314ef82f662SHariprasad Shenai goto out; 1315ef82f662SHariprasad Shenai } 1316ef82f662SHariprasad Shenai 13173ccc6cf7SHariprasad Shenai rplc[0] = rplc[1] = rplc[2] = rplc[3] = 0; 13183ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) 13193ccc6cf7SHariprasad Shenai replicate = (cls_lo & T6_REPLICATE_F); 13203ccc6cf7SHariprasad Shenai else 13213ccc6cf7SHariprasad Shenai replicate = (cls_lo & REPLICATE_F); 13223ccc6cf7SHariprasad Shenai 13233ccc6cf7SHariprasad Shenai if (replicate) { 1324ef82f662SHariprasad Shenai struct fw_ldst_cmd ldst_cmd; 1325ef82f662SHariprasad Shenai int ret; 13263ccc6cf7SHariprasad Shenai struct fw_ldst_mps_rplc mps_rplc; 13273ccc6cf7SHariprasad Shenai u32 ldst_addrspc; 1328ef82f662SHariprasad Shenai 1329ef82f662SHariprasad Shenai memset(&ldst_cmd, 0, sizeof(ldst_cmd)); 13303ccc6cf7SHariprasad Shenai ldst_addrspc = 13313ccc6cf7SHariprasad Shenai FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MPS); 1332ef82f662SHariprasad Shenai ldst_cmd.op_to_addrspace = 1333ef82f662SHariprasad Shenai htonl(FW_CMD_OP_V(FW_LDST_CMD) | 1334ef82f662SHariprasad Shenai FW_CMD_REQUEST_F | 1335ef82f662SHariprasad Shenai FW_CMD_READ_F | 13363ccc6cf7SHariprasad Shenai ldst_addrspc); 1337ef82f662SHariprasad Shenai ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd)); 13383ccc6cf7SHariprasad Shenai ldst_cmd.u.mps.rplc.fid_idx = 1339ef82f662SHariprasad Shenai htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) | 13403ccc6cf7SHariprasad Shenai FW_LDST_CMD_IDX_V(idx)); 1341ef82f662SHariprasad Shenai ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, 1342ef82f662SHariprasad Shenai sizeof(ldst_cmd), &ldst_cmd); 1343ef82f662SHariprasad Shenai if (ret) 1344ef82f662SHariprasad Shenai dev_warn(adap->pdev_dev, "Can't read MPS " 1345ef82f662SHariprasad Shenai "replication map for idx %d: %d\n", 1346ef82f662SHariprasad Shenai idx, -ret); 1347ef82f662SHariprasad Shenai else { 13483ccc6cf7SHariprasad Shenai mps_rplc = ldst_cmd.u.mps.rplc; 13493ccc6cf7SHariprasad Shenai rplc[0] = ntohl(mps_rplc.rplc31_0); 13503ccc6cf7SHariprasad Shenai rplc[1] = ntohl(mps_rplc.rplc63_32); 13513ccc6cf7SHariprasad Shenai rplc[2] = ntohl(mps_rplc.rplc95_64); 13523ccc6cf7SHariprasad Shenai rplc[3] = ntohl(mps_rplc.rplc127_96); 13533ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) { 13543ccc6cf7SHariprasad Shenai rplc[4] = ntohl(mps_rplc.rplc159_128); 13553ccc6cf7SHariprasad Shenai rplc[5] = ntohl(mps_rplc.rplc191_160); 13563ccc6cf7SHariprasad Shenai rplc[6] = ntohl(mps_rplc.rplc223_192); 13573ccc6cf7SHariprasad Shenai rplc[7] = ntohl(mps_rplc.rplc255_224); 13583ccc6cf7SHariprasad Shenai } 1359ef82f662SHariprasad Shenai } 1360ef82f662SHariprasad Shenai } 1361ef82f662SHariprasad Shenai 1362ef82f662SHariprasad Shenai tcamxy2valmask(tcamx, tcamy, addr, &mask); 13633ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) 13643ccc6cf7SHariprasad Shenai seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x " 13653ccc6cf7SHariprasad Shenai "%012llx%3c %#x%4u%4d", 13663ccc6cf7SHariprasad Shenai idx, addr[0], addr[1], addr[2], addr[3], 13673ccc6cf7SHariprasad Shenai addr[4], addr[5], (unsigned long long)mask, 13683ccc6cf7SHariprasad Shenai (cls_lo & T6_SRAM_VLD_F) ? 'Y' : 'N', 13693ccc6cf7SHariprasad Shenai PORTMAP_G(cls_hi), 13703ccc6cf7SHariprasad Shenai T6_PF_G(cls_lo), 13713ccc6cf7SHariprasad Shenai (cls_lo & T6_VF_VALID_F) ? 13723ccc6cf7SHariprasad Shenai T6_VF_G(cls_lo) : -1); 13733ccc6cf7SHariprasad Shenai else 13743ccc6cf7SHariprasad Shenai seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x " 13753ccc6cf7SHariprasad Shenai "%012llx%3c %#x%4u%4d", 13763ccc6cf7SHariprasad Shenai idx, addr[0], addr[1], addr[2], addr[3], 13773ccc6cf7SHariprasad Shenai addr[4], addr[5], (unsigned long long)mask, 13783ccc6cf7SHariprasad Shenai (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', 13793ccc6cf7SHariprasad Shenai PORTMAP_G(cls_hi), 1380ef82f662SHariprasad Shenai PF_G(cls_lo), 1381ef82f662SHariprasad Shenai (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1); 13823ccc6cf7SHariprasad Shenai 13833ccc6cf7SHariprasad Shenai if (replicate) { 13843ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 13853ccc6cf7SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x " 13863ccc6cf7SHariprasad Shenai "%08x %08x %08x %08x", 13873ccc6cf7SHariprasad Shenai rplc[7], rplc[6], rplc[5], rplc[4], 1388ef82f662SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 1389ef82f662SHariprasad Shenai else 13903ccc6cf7SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x", 13913ccc6cf7SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 13923ccc6cf7SHariprasad Shenai } else { 13933ccc6cf7SHariprasad Shenai if (adap->params.arch.mps_rplc_size > 128) 13943ccc6cf7SHariprasad Shenai seq_printf(seq, "%72c", ' '); 13953ccc6cf7SHariprasad Shenai else 1396ef82f662SHariprasad Shenai seq_printf(seq, "%36c", ' '); 13973ccc6cf7SHariprasad Shenai } 13983ccc6cf7SHariprasad Shenai 13993ccc6cf7SHariprasad Shenai if (chip_ver > CHELSIO_T5) 14003ccc6cf7SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 14013ccc6cf7SHariprasad Shenai T6_SRAM_PRIO0_G(cls_lo), 14023ccc6cf7SHariprasad Shenai T6_SRAM_PRIO1_G(cls_lo), 14033ccc6cf7SHariprasad Shenai T6_SRAM_PRIO2_G(cls_lo), 14043ccc6cf7SHariprasad Shenai T6_SRAM_PRIO3_G(cls_lo), 14053ccc6cf7SHariprasad Shenai (cls_lo >> T6_MULTILISTEN0_S) & 0xf); 14063ccc6cf7SHariprasad Shenai else 1407ef82f662SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 1408ef82f662SHariprasad Shenai SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo), 1409ef82f662SHariprasad Shenai SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo), 1410ef82f662SHariprasad Shenai (cls_lo >> MULTILISTEN0_S) & 0xf); 1411ef82f662SHariprasad Shenai } 1412ef82f662SHariprasad Shenai out: return 0; 1413ef82f662SHariprasad Shenai } 1414ef82f662SHariprasad Shenai 1415ef82f662SHariprasad Shenai static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos) 1416ef82f662SHariprasad Shenai { 1417ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 1418ef82f662SHariprasad Shenai int max_mac_addr = is_t4(adap->params.chip) ? 1419ef82f662SHariprasad Shenai NUM_MPS_CLS_SRAM_L_INSTANCES : 1420ef82f662SHariprasad Shenai NUM_MPS_T5_CLS_SRAM_L_INSTANCES; 1421ef82f662SHariprasad Shenai return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL); 1422ef82f662SHariprasad Shenai } 1423ef82f662SHariprasad Shenai 1424ef82f662SHariprasad Shenai static void *mps_tcam_start(struct seq_file *seq, loff_t *pos) 1425ef82f662SHariprasad Shenai { 1426ef82f662SHariprasad Shenai return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN; 1427ef82f662SHariprasad Shenai } 1428ef82f662SHariprasad Shenai 1429ef82f662SHariprasad Shenai static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos) 1430ef82f662SHariprasad Shenai { 1431ef82f662SHariprasad Shenai ++*pos; 1432ef82f662SHariprasad Shenai return mps_tcam_get_idx(seq, *pos); 1433ef82f662SHariprasad Shenai } 1434ef82f662SHariprasad Shenai 1435ef82f662SHariprasad Shenai static void mps_tcam_stop(struct seq_file *seq, void *v) 1436ef82f662SHariprasad Shenai { 1437ef82f662SHariprasad Shenai } 1438ef82f662SHariprasad Shenai 1439ef82f662SHariprasad Shenai static const struct seq_operations mps_tcam_seq_ops = { 1440ef82f662SHariprasad Shenai .start = mps_tcam_start, 1441ef82f662SHariprasad Shenai .next = mps_tcam_next, 1442ef82f662SHariprasad Shenai .stop = mps_tcam_stop, 1443ef82f662SHariprasad Shenai .show = mps_tcam_show 1444ef82f662SHariprasad Shenai }; 1445ef82f662SHariprasad Shenai 1446ef82f662SHariprasad Shenai static int mps_tcam_open(struct inode *inode, struct file *file) 1447ef82f662SHariprasad Shenai { 1448ef82f662SHariprasad Shenai int res = seq_open(file, &mps_tcam_seq_ops); 1449ef82f662SHariprasad Shenai 1450ef82f662SHariprasad Shenai if (!res) { 1451ef82f662SHariprasad Shenai struct seq_file *seq = file->private_data; 1452ef82f662SHariprasad Shenai 1453ef82f662SHariprasad Shenai seq->private = inode->i_private; 1454ef82f662SHariprasad Shenai } 1455ef82f662SHariprasad Shenai return res; 1456ef82f662SHariprasad Shenai } 1457ef82f662SHariprasad Shenai 1458ef82f662SHariprasad Shenai static const struct file_operations mps_tcam_debugfs_fops = { 1459ef82f662SHariprasad Shenai .owner = THIS_MODULE, 1460ef82f662SHariprasad Shenai .open = mps_tcam_open, 1461ef82f662SHariprasad Shenai .read = seq_read, 1462ef82f662SHariprasad Shenai .llseek = seq_lseek, 1463ef82f662SHariprasad Shenai .release = seq_release, 1464ef82f662SHariprasad Shenai }; 1465ef82f662SHariprasad Shenai 146670a5f3bbSHariprasad Shenai /* Display various sensor information. 146770a5f3bbSHariprasad Shenai */ 146870a5f3bbSHariprasad Shenai static int sensors_show(struct seq_file *seq, void *v) 146970a5f3bbSHariprasad Shenai { 147070a5f3bbSHariprasad Shenai struct adapter *adap = seq->private; 147170a5f3bbSHariprasad Shenai u32 param[7], val[7]; 147270a5f3bbSHariprasad Shenai int ret; 147370a5f3bbSHariprasad Shenai 147470a5f3bbSHariprasad Shenai /* Note that if the sensors haven't been initialized and turned on 147570a5f3bbSHariprasad Shenai * we'll get values of 0, so treat those as "<unknown>" ... 147670a5f3bbSHariprasad Shenai */ 147770a5f3bbSHariprasad Shenai param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 147870a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 147970a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP)); 148070a5f3bbSHariprasad Shenai param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 148170a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 148270a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD)); 1483b2612722SHariprasad Shenai ret = t4_query_params(adap, adap->mbox, adap->pf, 0, 2, 148470a5f3bbSHariprasad Shenai param, val); 148570a5f3bbSHariprasad Shenai 148670a5f3bbSHariprasad Shenai if (ret < 0 || val[0] == 0) 148770a5f3bbSHariprasad Shenai seq_puts(seq, "Temperature: <unknown>\n"); 148870a5f3bbSHariprasad Shenai else 148970a5f3bbSHariprasad Shenai seq_printf(seq, "Temperature: %dC\n", val[0]); 149070a5f3bbSHariprasad Shenai 149170a5f3bbSHariprasad Shenai if (ret < 0 || val[1] == 0) 149270a5f3bbSHariprasad Shenai seq_puts(seq, "Core VDD: <unknown>\n"); 149370a5f3bbSHariprasad Shenai else 149470a5f3bbSHariprasad Shenai seq_printf(seq, "Core VDD: %dmV\n", val[1]); 149570a5f3bbSHariprasad Shenai 149670a5f3bbSHariprasad Shenai return 0; 149770a5f3bbSHariprasad Shenai } 149870a5f3bbSHariprasad Shenai 149970a5f3bbSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(sensors); 150070a5f3bbSHariprasad Shenai 1501b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 1502b5a02f50SAnish Bhatt static int clip_tbl_open(struct inode *inode, struct file *file) 1503b5a02f50SAnish Bhatt { 1504acde2c2dSHariprasad Shenai return single_open(file, clip_tbl_show, inode->i_private); 1505b5a02f50SAnish Bhatt } 1506b5a02f50SAnish Bhatt 1507b5a02f50SAnish Bhatt static const struct file_operations clip_tbl_debugfs_fops = { 1508b5a02f50SAnish Bhatt .owner = THIS_MODULE, 1509b5a02f50SAnish Bhatt .open = clip_tbl_open, 1510b5a02f50SAnish Bhatt .read = seq_read, 1511b5a02f50SAnish Bhatt .llseek = seq_lseek, 1512b5a02f50SAnish Bhatt .release = single_release 1513b5a02f50SAnish Bhatt }; 1514b5a02f50SAnish Bhatt #endif 1515b5a02f50SAnish Bhatt 1516688ea5feSHariprasad Shenai /*RSS Table. 1517688ea5feSHariprasad Shenai */ 1518688ea5feSHariprasad Shenai 1519688ea5feSHariprasad Shenai static int rss_show(struct seq_file *seq, void *v, int idx) 1520688ea5feSHariprasad Shenai { 1521688ea5feSHariprasad Shenai u16 *entry = v; 1522688ea5feSHariprasad Shenai 1523688ea5feSHariprasad Shenai seq_printf(seq, "%4d: %4u %4u %4u %4u %4u %4u %4u %4u\n", 1524688ea5feSHariprasad Shenai idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4], 1525688ea5feSHariprasad Shenai entry[5], entry[6], entry[7]); 1526688ea5feSHariprasad Shenai return 0; 1527688ea5feSHariprasad Shenai } 1528688ea5feSHariprasad Shenai 1529688ea5feSHariprasad Shenai static int rss_open(struct inode *inode, struct file *file) 1530688ea5feSHariprasad Shenai { 1531688ea5feSHariprasad Shenai int ret; 1532688ea5feSHariprasad Shenai struct seq_tab *p; 1533688ea5feSHariprasad Shenai struct adapter *adap = inode->i_private; 1534688ea5feSHariprasad Shenai 1535688ea5feSHariprasad Shenai p = seq_open_tab(file, RSS_NENTRIES / 8, 8 * sizeof(u16), 0, rss_show); 1536688ea5feSHariprasad Shenai if (!p) 1537688ea5feSHariprasad Shenai return -ENOMEM; 1538688ea5feSHariprasad Shenai 1539688ea5feSHariprasad Shenai ret = t4_read_rss(adap, (u16 *)p->data); 1540688ea5feSHariprasad Shenai if (ret) 1541688ea5feSHariprasad Shenai seq_release_private(inode, file); 1542688ea5feSHariprasad Shenai 1543688ea5feSHariprasad Shenai return ret; 1544688ea5feSHariprasad Shenai } 1545688ea5feSHariprasad Shenai 1546688ea5feSHariprasad Shenai static const struct file_operations rss_debugfs_fops = { 1547688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1548688ea5feSHariprasad Shenai .open = rss_open, 1549688ea5feSHariprasad Shenai .read = seq_read, 1550688ea5feSHariprasad Shenai .llseek = seq_lseek, 1551688ea5feSHariprasad Shenai .release = seq_release_private 1552688ea5feSHariprasad Shenai }; 1553688ea5feSHariprasad Shenai 1554688ea5feSHariprasad Shenai /* RSS Configuration. 1555688ea5feSHariprasad Shenai */ 1556688ea5feSHariprasad Shenai 1557688ea5feSHariprasad Shenai /* Small utility function to return the strings "yes" or "no" if the supplied 1558688ea5feSHariprasad Shenai * argument is non-zero. 1559688ea5feSHariprasad Shenai */ 1560688ea5feSHariprasad Shenai static const char *yesno(int x) 1561688ea5feSHariprasad Shenai { 1562688ea5feSHariprasad Shenai static const char *yes = "yes"; 1563688ea5feSHariprasad Shenai static const char *no = "no"; 1564688ea5feSHariprasad Shenai 1565688ea5feSHariprasad Shenai return x ? yes : no; 1566688ea5feSHariprasad Shenai } 1567688ea5feSHariprasad Shenai 1568688ea5feSHariprasad Shenai static int rss_config_show(struct seq_file *seq, void *v) 1569688ea5feSHariprasad Shenai { 1570688ea5feSHariprasad Shenai struct adapter *adapter = seq->private; 1571688ea5feSHariprasad Shenai static const char * const keymode[] = { 1572688ea5feSHariprasad Shenai "global", 1573688ea5feSHariprasad Shenai "global and per-VF scramble", 1574688ea5feSHariprasad Shenai "per-PF and per-VF scramble", 1575688ea5feSHariprasad Shenai "per-VF and per-VF scramble", 1576688ea5feSHariprasad Shenai }; 1577688ea5feSHariprasad Shenai u32 rssconf; 1578688ea5feSHariprasad Shenai 1579688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A); 1580688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf); 1581688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv6: %3s\n", yesno(rssconf & 1582688ea5feSHariprasad Shenai TNL4TUPENIPV6_F)); 1583688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv6: %3s\n", yesno(rssconf & 1584688ea5feSHariprasad Shenai TNL2TUPENIPV6_F)); 1585688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv4: %3s\n", yesno(rssconf & 1586688ea5feSHariprasad Shenai TNL4TUPENIPV4_F)); 1587688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv4: %3s\n", yesno(rssconf & 1588688ea5feSHariprasad Shenai TNL2TUPENIPV4_F)); 1589688ea5feSHariprasad Shenai seq_printf(seq, " TnlTcpSel: %3s\n", yesno(rssconf & TNLTCPSEL_F)); 1590688ea5feSHariprasad Shenai seq_printf(seq, " TnlIp6Sel: %3s\n", yesno(rssconf & TNLIP6SEL_F)); 1591688ea5feSHariprasad Shenai seq_printf(seq, " TnlVrtSel: %3s\n", yesno(rssconf & TNLVRTSEL_F)); 1592688ea5feSHariprasad Shenai seq_printf(seq, " TnlMapEn: %3s\n", yesno(rssconf & TNLMAPEN_F)); 1593688ea5feSHariprasad Shenai seq_printf(seq, " OfdHashSave: %3s\n", yesno(rssconf & 1594688ea5feSHariprasad Shenai OFDHASHSAVE_F)); 1595688ea5feSHariprasad Shenai seq_printf(seq, " OfdVrtSel: %3s\n", yesno(rssconf & OFDVRTSEL_F)); 1596688ea5feSHariprasad Shenai seq_printf(seq, " OfdMapEn: %3s\n", yesno(rssconf & OFDMAPEN_F)); 1597688ea5feSHariprasad Shenai seq_printf(seq, " OfdLkpEn: %3s\n", yesno(rssconf & OFDLKPEN_F)); 1598688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 1599688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 1600688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv6: %3s\n", yesno(rssconf & 1601688ea5feSHariprasad Shenai SYN2TUPENIPV6_F)); 1602688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv4: %3s\n", yesno(rssconf & 1603688ea5feSHariprasad Shenai SYN4TUPENIPV4_F)); 1604688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv4: %3s\n", yesno(rssconf & 1605688ea5feSHariprasad Shenai SYN2TUPENIPV4_F)); 1606688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 1607688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 1608688ea5feSHariprasad Shenai seq_printf(seq, " SynIp6Sel: %3s\n", yesno(rssconf & SYNIP6SEL_F)); 1609688ea5feSHariprasad Shenai seq_printf(seq, " SynVrt6Sel: %3s\n", yesno(rssconf & SYNVRTSEL_F)); 1610688ea5feSHariprasad Shenai seq_printf(seq, " SynMapEn: %3s\n", yesno(rssconf & SYNMAPEN_F)); 1611688ea5feSHariprasad Shenai seq_printf(seq, " SynLkpEn: %3s\n", yesno(rssconf & SYNLKPEN_F)); 1612688ea5feSHariprasad Shenai seq_printf(seq, " ChnEn: %3s\n", yesno(rssconf & 1613688ea5feSHariprasad Shenai CHANNELENABLE_F)); 1614688ea5feSHariprasad Shenai seq_printf(seq, " PrtEn: %3s\n", yesno(rssconf & 1615688ea5feSHariprasad Shenai PORTENABLE_F)); 1616688ea5feSHariprasad Shenai seq_printf(seq, " TnlAllLkp: %3s\n", yesno(rssconf & 1617688ea5feSHariprasad Shenai TNLALLLOOKUP_F)); 1618688ea5feSHariprasad Shenai seq_printf(seq, " VrtEn: %3s\n", yesno(rssconf & 1619688ea5feSHariprasad Shenai VIRTENABLE_F)); 1620688ea5feSHariprasad Shenai seq_printf(seq, " CngEn: %3s\n", yesno(rssconf & 1621688ea5feSHariprasad Shenai CONGESTIONENABLE_F)); 1622688ea5feSHariprasad Shenai seq_printf(seq, " HashToeplitz: %3s\n", yesno(rssconf & 1623688ea5feSHariprasad Shenai HASHTOEPLITZ_F)); 1624688ea5feSHariprasad Shenai seq_printf(seq, " Udp4En: %3s\n", yesno(rssconf & UDPENABLE_F)); 1625688ea5feSHariprasad Shenai seq_printf(seq, " Disable: %3s\n", yesno(rssconf & DISABLE_F)); 1626688ea5feSHariprasad Shenai 1627688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1628688ea5feSHariprasad Shenai 1629688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A); 1630688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf); 1631688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1632688ea5feSHariprasad Shenai seq_printf(seq, " MaskFilter: %3d\n", MASKFILTER_G(rssconf)); 1633688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 1634688ea5feSHariprasad Shenai seq_printf(seq, " HashAll: %3s\n", 1635688ea5feSHariprasad Shenai yesno(rssconf & HASHALL_F)); 1636688ea5feSHariprasad Shenai seq_printf(seq, " HashEth: %3s\n", 1637688ea5feSHariprasad Shenai yesno(rssconf & HASHETH_F)); 1638688ea5feSHariprasad Shenai } 1639688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 1640688ea5feSHariprasad Shenai 1641688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1642688ea5feSHariprasad Shenai 1643688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A); 1644688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf); 1645688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1646688ea5feSHariprasad Shenai seq_printf(seq, " RRCplMapEn: %3s\n", yesno(rssconf & 1647688ea5feSHariprasad Shenai RRCPLMAPEN_F)); 1648688ea5feSHariprasad Shenai seq_printf(seq, " RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf)); 1649688ea5feSHariprasad Shenai 1650688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1651688ea5feSHariprasad Shenai 1652688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A); 1653688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf); 1654688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1655688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 1656688ea5feSHariprasad Shenai 1657688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1658688ea5feSHariprasad Shenai 1659688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A); 1660688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf); 1661688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 1662688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddrX: %3d\n", 1663688ea5feSHariprasad Shenai KEYWRADDRX_G(rssconf)); 1664688ea5feSHariprasad Shenai seq_printf(seq, " KeyExtend: %3s\n", 1665688ea5feSHariprasad Shenai yesno(rssconf & KEYEXTEND_F)); 1666688ea5feSHariprasad Shenai } 1667688ea5feSHariprasad Shenai seq_printf(seq, " VfRdRg: %3s\n", yesno(rssconf & VFRDRG_F)); 1668688ea5feSHariprasad Shenai seq_printf(seq, " VfRdEn: %3s\n", yesno(rssconf & VFRDEN_F)); 1669688ea5feSHariprasad Shenai seq_printf(seq, " VfPerrEn: %3s\n", yesno(rssconf & VFPERREN_F)); 1670688ea5feSHariprasad Shenai seq_printf(seq, " KeyPerrEn: %3s\n", yesno(rssconf & KEYPERREN_F)); 1671688ea5feSHariprasad Shenai seq_printf(seq, " DisVfVlan: %3s\n", yesno(rssconf & 1672688ea5feSHariprasad Shenai DISABLEVLAN_F)); 1673688ea5feSHariprasad Shenai seq_printf(seq, " EnUpSwt: %3s\n", yesno(rssconf & ENABLEUP0_F)); 1674688ea5feSHariprasad Shenai seq_printf(seq, " HashDelay: %3d\n", HASHDELAY_G(rssconf)); 1675688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5) 1676688ea5feSHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", VFWRADDR_G(rssconf)); 16773ccc6cf7SHariprasad Shenai else 16783ccc6cf7SHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", 16793ccc6cf7SHariprasad Shenai T6_VFWRADDR_G(rssconf)); 1680688ea5feSHariprasad Shenai seq_printf(seq, " KeyMode: %s\n", keymode[KEYMODE_G(rssconf)]); 1681688ea5feSHariprasad Shenai seq_printf(seq, " VfWrEn: %3s\n", yesno(rssconf & VFWREN_F)); 1682688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrEn: %3s\n", yesno(rssconf & KEYWREN_F)); 1683688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddr: %3d\n", KEYWRADDR_G(rssconf)); 1684688ea5feSHariprasad Shenai 1685688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1686688ea5feSHariprasad Shenai 1687688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A); 1688688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf); 1689688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount3: %3s\n", yesno(rssconf & CHNCOUNT3_F)); 1690688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount2: %3s\n", yesno(rssconf & CHNCOUNT2_F)); 1691688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount1: %3s\n", yesno(rssconf & CHNCOUNT1_F)); 1692688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount0: %3s\n", yesno(rssconf & CHNCOUNT0_F)); 1693688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow3: %3s\n", yesno(rssconf & 1694688ea5feSHariprasad Shenai CHNUNDFLOW3_F)); 1695688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow2: %3s\n", yesno(rssconf & 1696688ea5feSHariprasad Shenai CHNUNDFLOW2_F)); 1697688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow1: %3s\n", yesno(rssconf & 1698688ea5feSHariprasad Shenai CHNUNDFLOW1_F)); 1699688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow0: %3s\n", yesno(rssconf & 1700688ea5feSHariprasad Shenai CHNUNDFLOW0_F)); 1701688ea5feSHariprasad Shenai seq_printf(seq, " RstChn3: %3s\n", yesno(rssconf & RSTCHN3_F)); 1702688ea5feSHariprasad Shenai seq_printf(seq, " RstChn2: %3s\n", yesno(rssconf & RSTCHN2_F)); 1703688ea5feSHariprasad Shenai seq_printf(seq, " RstChn1: %3s\n", yesno(rssconf & RSTCHN1_F)); 1704688ea5feSHariprasad Shenai seq_printf(seq, " RstChn0: %3s\n", yesno(rssconf & RSTCHN0_F)); 1705688ea5feSHariprasad Shenai seq_printf(seq, " UpdVld: %3s\n", yesno(rssconf & UPDVLD_F)); 1706688ea5feSHariprasad Shenai seq_printf(seq, " Xoff: %3s\n", yesno(rssconf & XOFF_F)); 1707688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn3: %3s\n", yesno(rssconf & UPDCHN3_F)); 1708688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn2: %3s\n", yesno(rssconf & UPDCHN2_F)); 1709688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn1: %3s\n", yesno(rssconf & UPDCHN1_F)); 1710688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn0: %3s\n", yesno(rssconf & UPDCHN0_F)); 1711688ea5feSHariprasad Shenai seq_printf(seq, " Queue: %3d\n", QUEUE_G(rssconf)); 1712688ea5feSHariprasad Shenai 1713688ea5feSHariprasad Shenai return 0; 1714688ea5feSHariprasad Shenai } 1715688ea5feSHariprasad Shenai 1716688ea5feSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(rss_config); 1717688ea5feSHariprasad Shenai 1718688ea5feSHariprasad Shenai /* RSS Secret Key. 1719688ea5feSHariprasad Shenai */ 1720688ea5feSHariprasad Shenai 1721688ea5feSHariprasad Shenai static int rss_key_show(struct seq_file *seq, void *v) 1722688ea5feSHariprasad Shenai { 1723688ea5feSHariprasad Shenai u32 key[10]; 1724688ea5feSHariprasad Shenai 1725688ea5feSHariprasad Shenai t4_read_rss_key(seq->private, key); 1726688ea5feSHariprasad Shenai seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1727688ea5feSHariprasad Shenai key[9], key[8], key[7], key[6], key[5], key[4], key[3], 1728688ea5feSHariprasad Shenai key[2], key[1], key[0]); 1729688ea5feSHariprasad Shenai return 0; 1730688ea5feSHariprasad Shenai } 1731688ea5feSHariprasad Shenai 1732688ea5feSHariprasad Shenai static int rss_key_open(struct inode *inode, struct file *file) 1733688ea5feSHariprasad Shenai { 1734688ea5feSHariprasad Shenai return single_open(file, rss_key_show, inode->i_private); 1735688ea5feSHariprasad Shenai } 1736688ea5feSHariprasad Shenai 1737688ea5feSHariprasad Shenai static ssize_t rss_key_write(struct file *file, const char __user *buf, 1738688ea5feSHariprasad Shenai size_t count, loff_t *pos) 1739688ea5feSHariprasad Shenai { 1740688ea5feSHariprasad Shenai int i, j; 1741688ea5feSHariprasad Shenai u32 key[10]; 1742688ea5feSHariprasad Shenai char s[100], *p; 1743c1d81b1cSDavid Howells struct adapter *adap = file_inode(file)->i_private; 1744688ea5feSHariprasad Shenai 1745688ea5feSHariprasad Shenai if (count > sizeof(s) - 1) 1746688ea5feSHariprasad Shenai return -EINVAL; 1747688ea5feSHariprasad Shenai if (copy_from_user(s, buf, count)) 1748688ea5feSHariprasad Shenai return -EFAULT; 1749688ea5feSHariprasad Shenai for (i = count; i > 0 && isspace(s[i - 1]); i--) 1750688ea5feSHariprasad Shenai ; 1751688ea5feSHariprasad Shenai s[i] = '\0'; 1752688ea5feSHariprasad Shenai 1753688ea5feSHariprasad Shenai for (p = s, i = 9; i >= 0; i--) { 1754688ea5feSHariprasad Shenai key[i] = 0; 1755688ea5feSHariprasad Shenai for (j = 0; j < 8; j++, p++) { 1756688ea5feSHariprasad Shenai if (!isxdigit(*p)) 1757688ea5feSHariprasad Shenai return -EINVAL; 1758688ea5feSHariprasad Shenai key[i] = (key[i] << 4) | hex2val(*p); 1759688ea5feSHariprasad Shenai } 1760688ea5feSHariprasad Shenai } 1761688ea5feSHariprasad Shenai 1762688ea5feSHariprasad Shenai t4_write_rss_key(adap, key, -1); 1763688ea5feSHariprasad Shenai return count; 1764688ea5feSHariprasad Shenai } 1765688ea5feSHariprasad Shenai 1766688ea5feSHariprasad Shenai static const struct file_operations rss_key_debugfs_fops = { 1767688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1768688ea5feSHariprasad Shenai .open = rss_key_open, 1769688ea5feSHariprasad Shenai .read = seq_read, 1770688ea5feSHariprasad Shenai .llseek = seq_lseek, 1771688ea5feSHariprasad Shenai .release = single_release, 1772688ea5feSHariprasad Shenai .write = rss_key_write 1773688ea5feSHariprasad Shenai }; 1774688ea5feSHariprasad Shenai 1775688ea5feSHariprasad Shenai /* PF RSS Configuration. 1776688ea5feSHariprasad Shenai */ 1777688ea5feSHariprasad Shenai 1778688ea5feSHariprasad Shenai struct rss_pf_conf { 1779688ea5feSHariprasad Shenai u32 rss_pf_map; 1780688ea5feSHariprasad Shenai u32 rss_pf_mask; 1781688ea5feSHariprasad Shenai u32 rss_pf_config; 1782688ea5feSHariprasad Shenai }; 1783688ea5feSHariprasad Shenai 1784688ea5feSHariprasad Shenai static int rss_pf_config_show(struct seq_file *seq, void *v, int idx) 1785688ea5feSHariprasad Shenai { 1786688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1787688ea5feSHariprasad Shenai 1788688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1789688ea5feSHariprasad Shenai /* use the 0th entry to dump the PF Map Index Size */ 1790688ea5feSHariprasad Shenai pfconf = seq->private + offsetof(struct seq_tab, data); 1791688ea5feSHariprasad Shenai seq_printf(seq, "PF Map Index Size = %d\n\n", 1792688ea5feSHariprasad Shenai LKPIDXSIZE_G(pfconf->rss_pf_map)); 1793688ea5feSHariprasad Shenai 1794688ea5feSHariprasad Shenai seq_puts(seq, " RSS PF VF Hash Tuple Enable Default\n"); 1795688ea5feSHariprasad Shenai seq_puts(seq, " Enable IPF Mask Mask IPv6 IPv4 UDP Queue\n"); 1796688ea5feSHariprasad Shenai seq_puts(seq, " PF Map Chn Prt Map Size Size Four Two Four Two Four Ch1 Ch0\n"); 1797688ea5feSHariprasad Shenai } else { 1798688ea5feSHariprasad Shenai #define G_PFnLKPIDX(map, n) \ 1799688ea5feSHariprasad Shenai (((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M) 1800688ea5feSHariprasad Shenai #define G_PFnMSKSIZE(mask, n) \ 1801688ea5feSHariprasad Shenai (((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M) 1802688ea5feSHariprasad Shenai 1803688ea5feSHariprasad Shenai pfconf = v; 1804688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3s %3d %3d %3d %3s %3s %3s %3s %3s %3d %3d\n", 1805688ea5feSHariprasad Shenai idx, 1806688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & MAPENABLE_F), 1807688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & CHNENABLE_F), 1808688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & PRTENABLE_F), 1809688ea5feSHariprasad Shenai G_PFnLKPIDX(pfconf->rss_pf_map, idx), 1810688ea5feSHariprasad Shenai G_PFnMSKSIZE(pfconf->rss_pf_mask, idx), 1811688ea5feSHariprasad Shenai IVFWIDTH_G(pfconf->rss_pf_config), 1812688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F), 1813688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F), 1814688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F), 1815688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F), 1816688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F), 1817688ea5feSHariprasad Shenai CH1DEFAULTQUEUE_G(pfconf->rss_pf_config), 1818688ea5feSHariprasad Shenai CH0DEFAULTQUEUE_G(pfconf->rss_pf_config)); 1819688ea5feSHariprasad Shenai 1820688ea5feSHariprasad Shenai #undef G_PFnLKPIDX 1821688ea5feSHariprasad Shenai #undef G_PFnMSKSIZE 1822688ea5feSHariprasad Shenai } 1823688ea5feSHariprasad Shenai return 0; 1824688ea5feSHariprasad Shenai } 1825688ea5feSHariprasad Shenai 1826688ea5feSHariprasad Shenai static int rss_pf_config_open(struct inode *inode, struct file *file) 1827688ea5feSHariprasad Shenai { 1828688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1829688ea5feSHariprasad Shenai struct seq_tab *p; 1830688ea5feSHariprasad Shenai u32 rss_pf_map, rss_pf_mask; 1831688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1832688ea5feSHariprasad Shenai int pf; 1833688ea5feSHariprasad Shenai 1834688ea5feSHariprasad Shenai p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show); 1835688ea5feSHariprasad Shenai if (!p) 1836688ea5feSHariprasad Shenai return -ENOMEM; 1837688ea5feSHariprasad Shenai 1838688ea5feSHariprasad Shenai pfconf = (struct rss_pf_conf *)p->data; 1839688ea5feSHariprasad Shenai rss_pf_map = t4_read_rss_pf_map(adapter); 1840688ea5feSHariprasad Shenai rss_pf_mask = t4_read_rss_pf_mask(adapter); 1841688ea5feSHariprasad Shenai for (pf = 0; pf < 8; pf++) { 1842688ea5feSHariprasad Shenai pfconf[pf].rss_pf_map = rss_pf_map; 1843688ea5feSHariprasad Shenai pfconf[pf].rss_pf_mask = rss_pf_mask; 1844688ea5feSHariprasad Shenai t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config); 1845688ea5feSHariprasad Shenai } 1846688ea5feSHariprasad Shenai return 0; 1847688ea5feSHariprasad Shenai } 1848688ea5feSHariprasad Shenai 1849688ea5feSHariprasad Shenai static const struct file_operations rss_pf_config_debugfs_fops = { 1850688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1851688ea5feSHariprasad Shenai .open = rss_pf_config_open, 1852688ea5feSHariprasad Shenai .read = seq_read, 1853688ea5feSHariprasad Shenai .llseek = seq_lseek, 1854688ea5feSHariprasad Shenai .release = seq_release_private 1855688ea5feSHariprasad Shenai }; 1856688ea5feSHariprasad Shenai 1857688ea5feSHariprasad Shenai /* VF RSS Configuration. 1858688ea5feSHariprasad Shenai */ 1859688ea5feSHariprasad Shenai 1860688ea5feSHariprasad Shenai struct rss_vf_conf { 1861688ea5feSHariprasad Shenai u32 rss_vf_vfl; 1862688ea5feSHariprasad Shenai u32 rss_vf_vfh; 1863688ea5feSHariprasad Shenai }; 1864688ea5feSHariprasad Shenai 1865688ea5feSHariprasad Shenai static int rss_vf_config_show(struct seq_file *seq, void *v, int idx) 1866688ea5feSHariprasad Shenai { 1867688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1868688ea5feSHariprasad Shenai seq_puts(seq, " RSS Hash Tuple Enable\n"); 1869688ea5feSHariprasad Shenai seq_puts(seq, " Enable IVF Dis Enb IPv6 IPv4 UDP Def Secret Key\n"); 1870688ea5feSHariprasad Shenai seq_puts(seq, " VF Chn Prt Map VLAN uP Four Two Four Two Four Que Idx Hash\n"); 1871688ea5feSHariprasad Shenai } else { 1872688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf = v; 1873688ea5feSHariprasad Shenai 1874688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3d %3s %3s %3s %3s %3s %3s %3s %4d %3d %#10x\n", 1875688ea5feSHariprasad Shenai idx, 1876688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFCHNEN_F), 1877688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFPRTEN_F), 1878688ea5feSHariprasad Shenai VFLKPIDX_G(vfconf->rss_vf_vfh), 1879688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFVLNEX_F), 1880688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFUPEN_F), 1881688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1882688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F), 1883688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1884688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F), 1885688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F), 1886688ea5feSHariprasad Shenai DEFAULTQUEUE_G(vfconf->rss_vf_vfh), 1887688ea5feSHariprasad Shenai KEYINDEX_G(vfconf->rss_vf_vfh), 1888688ea5feSHariprasad Shenai vfconf->rss_vf_vfl); 1889688ea5feSHariprasad Shenai } 1890688ea5feSHariprasad Shenai return 0; 1891688ea5feSHariprasad Shenai } 1892688ea5feSHariprasad Shenai 1893688ea5feSHariprasad Shenai static int rss_vf_config_open(struct inode *inode, struct file *file) 1894688ea5feSHariprasad Shenai { 1895688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1896688ea5feSHariprasad Shenai struct seq_tab *p; 1897688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf; 18983ccc6cf7SHariprasad Shenai int vf, vfcount = adapter->params.arch.vfcount; 1899688ea5feSHariprasad Shenai 19003ccc6cf7SHariprasad Shenai p = seq_open_tab(file, vfcount, sizeof(*vfconf), 1, rss_vf_config_show); 1901688ea5feSHariprasad Shenai if (!p) 1902688ea5feSHariprasad Shenai return -ENOMEM; 1903688ea5feSHariprasad Shenai 1904688ea5feSHariprasad Shenai vfconf = (struct rss_vf_conf *)p->data; 19053ccc6cf7SHariprasad Shenai for (vf = 0; vf < vfcount; vf++) { 1906688ea5feSHariprasad Shenai t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl, 1907688ea5feSHariprasad Shenai &vfconf[vf].rss_vf_vfh); 1908688ea5feSHariprasad Shenai } 1909688ea5feSHariprasad Shenai return 0; 1910688ea5feSHariprasad Shenai } 1911688ea5feSHariprasad Shenai 1912688ea5feSHariprasad Shenai static const struct file_operations rss_vf_config_debugfs_fops = { 1913688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1914688ea5feSHariprasad Shenai .open = rss_vf_config_open, 1915688ea5feSHariprasad Shenai .read = seq_read, 1916688ea5feSHariprasad Shenai .llseek = seq_lseek, 1917688ea5feSHariprasad Shenai .release = seq_release_private 1918688ea5feSHariprasad Shenai }; 1919688ea5feSHariprasad Shenai 19203051fa61SHariprasad Shenai /** 19213051fa61SHariprasad Shenai * ethqset2pinfo - return port_info of an Ethernet Queue Set 19223051fa61SHariprasad Shenai * @adap: the adapter 19233051fa61SHariprasad Shenai * @qset: Ethernet Queue Set 19243051fa61SHariprasad Shenai */ 19253051fa61SHariprasad Shenai static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset) 19263051fa61SHariprasad Shenai { 19273051fa61SHariprasad Shenai int pidx; 19283051fa61SHariprasad Shenai 19293051fa61SHariprasad Shenai for_each_port(adap, pidx) { 19303051fa61SHariprasad Shenai struct port_info *pi = adap2pinfo(adap, pidx); 19313051fa61SHariprasad Shenai 19323051fa61SHariprasad Shenai if (qset >= pi->first_qset && 19333051fa61SHariprasad Shenai qset < pi->first_qset + pi->nqsets) 19343051fa61SHariprasad Shenai return pi; 19353051fa61SHariprasad Shenai } 19363051fa61SHariprasad Shenai 19373051fa61SHariprasad Shenai /* should never happen! */ 19383051fa61SHariprasad Shenai BUG_ON(1); 19393051fa61SHariprasad Shenai return NULL; 19403051fa61SHariprasad Shenai } 19413051fa61SHariprasad Shenai 1942dc9daab2SHariprasad Shenai static int sge_qinfo_show(struct seq_file *seq, void *v) 1943dc9daab2SHariprasad Shenai { 1944dc9daab2SHariprasad Shenai struct adapter *adap = seq->private; 1945dc9daab2SHariprasad Shenai int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4); 1946e106a4d9SHariprasad Shenai int iscsi_entries = DIV_ROUND_UP(adap->sge.ofldqsets, 4); 1947dc9daab2SHariprasad Shenai int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4); 1948dc9daab2SHariprasad Shenai int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4); 1949dc9daab2SHariprasad Shenai int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4); 1950dc9daab2SHariprasad Shenai int i, r = (uintptr_t)v - 1; 1951e106a4d9SHariprasad Shenai int iscsi_idx = r - eth_entries; 1952e106a4d9SHariprasad Shenai int rdma_idx = iscsi_idx - iscsi_entries; 1953dc9daab2SHariprasad Shenai int ciq_idx = rdma_idx - rdma_entries; 1954dc9daab2SHariprasad Shenai int ctrl_idx = ciq_idx - ciq_entries; 1955dc9daab2SHariprasad Shenai int fq_idx = ctrl_idx - ctrl_entries; 1956dc9daab2SHariprasad Shenai 1957dc9daab2SHariprasad Shenai if (r) 1958dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); 1959dc9daab2SHariprasad Shenai 1960dc9daab2SHariprasad Shenai #define S3(fmt_spec, s, v) \ 1961dc9daab2SHariprasad Shenai do { \ 1962dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s", s); \ 1963dc9daab2SHariprasad Shenai for (i = 0; i < n; ++i) \ 1964dc9daab2SHariprasad Shenai seq_printf(seq, " %16" fmt_spec, v); \ 1965dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); \ 1966dc9daab2SHariprasad Shenai } while (0) 1967dc9daab2SHariprasad Shenai #define S(s, v) S3("s", s, v) 1968e106a4d9SHariprasad Shenai #define T3(fmt_spec, s, v) S3(fmt_spec, s, tx[i].v) 1969dc9daab2SHariprasad Shenai #define T(s, v) S3("u", s, tx[i].v) 1970e106a4d9SHariprasad Shenai #define TL(s, v) T3("lu", s, v) 1971e106a4d9SHariprasad Shenai #define R3(fmt_spec, s, v) S3(fmt_spec, s, rx[i].v) 1972dc9daab2SHariprasad Shenai #define R(s, v) S3("u", s, rx[i].v) 1973e106a4d9SHariprasad Shenai #define RL(s, v) R3("lu", s, v) 1974dc9daab2SHariprasad Shenai 1975dc9daab2SHariprasad Shenai if (r < eth_entries) { 1976dc9daab2SHariprasad Shenai int base_qset = r * 4; 1977dc9daab2SHariprasad Shenai const struct sge_eth_rxq *rx = &adap->sge.ethrxq[base_qset]; 1978dc9daab2SHariprasad Shenai const struct sge_eth_txq *tx = &adap->sge.ethtxq[base_qset]; 1979dc9daab2SHariprasad Shenai int n = min(4, adap->sge.ethqsets - 4 * r); 1980dc9daab2SHariprasad Shenai 1981dc9daab2SHariprasad Shenai S("QType:", "Ethernet"); 1982dc9daab2SHariprasad Shenai S("Interface:", 1983dc9daab2SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 1984dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1985dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1986dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1987dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1988dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 19893051fa61SHariprasad Shenai #ifdef CONFIG_CHELSIO_T4_DCB 1990dc9daab2SHariprasad Shenai T("DCB Prio:", dcb_prio); 1991dc9daab2SHariprasad Shenai S3("u", "DCB PGID:", 1992dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >> 1993dc9daab2SHariprasad Shenai 4*(7-tx[i].dcb_prio)) & 0xf); 1994dc9daab2SHariprasad Shenai S3("u", "DCB PFC:", 1995dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >> 1996dc9daab2SHariprasad Shenai 1*(7-tx[i].dcb_prio)) & 0x1); 1997dc9daab2SHariprasad Shenai #endif 1998dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1999dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 2000dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 2001dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 2002dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 2003dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 2004dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 2005dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 2006dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 2007dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 2008dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 2009dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 2010dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 2011dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 2012e106a4d9SHariprasad Shenai RL("RxPackets:", stats.pkts); 2013e106a4d9SHariprasad Shenai RL("RxCSO:", stats.rx_cso); 2014e106a4d9SHariprasad Shenai RL("VLANxtract:", stats.vlan_ex); 2015e106a4d9SHariprasad Shenai RL("LROmerged:", stats.lro_merged); 2016e106a4d9SHariprasad Shenai RL("LROpackets:", stats.lro_pkts); 2017e106a4d9SHariprasad Shenai RL("RxDrops:", stats.rx_drops); 2018e106a4d9SHariprasad Shenai TL("TSO:", tso); 2019e106a4d9SHariprasad Shenai TL("TxCSO:", tx_cso); 2020e106a4d9SHariprasad Shenai TL("VLANins:", vlan_ins); 2021e106a4d9SHariprasad Shenai TL("TxQFull:", q.stops); 2022e106a4d9SHariprasad Shenai TL("TxQRestarts:", q.restarts); 2023e106a4d9SHariprasad Shenai TL("TxMapErr:", mapping_err); 2024e106a4d9SHariprasad Shenai RL("FLAllocErr:", fl.alloc_failed); 2025e106a4d9SHariprasad Shenai RL("FLLrgAlcErr:", fl.large_alloc_failed); 2026e106a4d9SHariprasad Shenai RL("FLStarving:", fl.starving); 2027dc9daab2SHariprasad Shenai 2028e106a4d9SHariprasad Shenai } else if (iscsi_idx < iscsi_entries) { 2029e106a4d9SHariprasad Shenai const struct sge_ofld_rxq *rx = 2030e106a4d9SHariprasad Shenai &adap->sge.ofldrxq[iscsi_idx * 4]; 2031e106a4d9SHariprasad Shenai const struct sge_ofld_txq *tx = 2032e106a4d9SHariprasad Shenai &adap->sge.ofldtxq[iscsi_idx * 4]; 2033e106a4d9SHariprasad Shenai int n = min(4, adap->sge.ofldqsets - 4 * iscsi_idx); 2034e106a4d9SHariprasad Shenai 2035e106a4d9SHariprasad Shenai S("QType:", "iSCSI"); 2036dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 2037dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 2038dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 2039dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 2040dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 2041dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 2042dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 2043dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 2044dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 2045dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 2046dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 2047dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 2048dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 2049dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 2050dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 2051dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 2052dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 2053dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 2054dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 2055e106a4d9SHariprasad Shenai RL("RxPackets:", stats.pkts); 2056e106a4d9SHariprasad Shenai RL("RxImmPkts:", stats.imm); 2057e106a4d9SHariprasad Shenai RL("RxNoMem:", stats.nomem); 2058e106a4d9SHariprasad Shenai RL("FLAllocErr:", fl.alloc_failed); 2059e106a4d9SHariprasad Shenai RL("FLLrgAlcErr:", fl.large_alloc_failed); 2060e106a4d9SHariprasad Shenai RL("FLStarving:", fl.starving); 2061e106a4d9SHariprasad Shenai 2062dc9daab2SHariprasad Shenai } else if (rdma_idx < rdma_entries) { 2063dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = 2064dc9daab2SHariprasad Shenai &adap->sge.rdmarxq[rdma_idx * 4]; 2065dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaqs - 4 * rdma_idx); 2066dc9daab2SHariprasad Shenai 2067dc9daab2SHariprasad Shenai S("QType:", "RDMA-CPL"); 2068f36e58e5SHariprasad Shenai S("Interface:", 2069f36e58e5SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 2070dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 2071dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 2072dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 2073dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 2074dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 2075dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 2076dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 2077dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 2078dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 2079dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 2080dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 2081dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 2082dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 2083dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 2084e106a4d9SHariprasad Shenai RL("RxPackets:", stats.pkts); 2085e106a4d9SHariprasad Shenai RL("RxImmPkts:", stats.imm); 2086e106a4d9SHariprasad Shenai RL("RxNoMem:", stats.nomem); 2087e106a4d9SHariprasad Shenai RL("FLAllocErr:", fl.alloc_failed); 2088e106a4d9SHariprasad Shenai RL("FLLrgAlcErr:", fl.large_alloc_failed); 2089e106a4d9SHariprasad Shenai RL("FLStarving:", fl.starving); 2090e106a4d9SHariprasad Shenai 2091dc9daab2SHariprasad Shenai } else if (ciq_idx < ciq_entries) { 2092dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = &adap->sge.rdmaciq[ciq_idx * 4]; 2093dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaciqs - 4 * ciq_idx); 2094dc9daab2SHariprasad Shenai 2095dc9daab2SHariprasad Shenai S("QType:", "RDMA-CIQ"); 2096f36e58e5SHariprasad Shenai S("Interface:", 2097f36e58e5SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 2098dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 2099dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 2100dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 2101dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 2102dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 2103dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 2104dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 2105dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 2106e106a4d9SHariprasad Shenai RL("RxAN:", stats.an); 2107e106a4d9SHariprasad Shenai RL("RxNoMem:", stats.nomem); 2108e106a4d9SHariprasad Shenai 2109dc9daab2SHariprasad Shenai } else if (ctrl_idx < ctrl_entries) { 2110dc9daab2SHariprasad Shenai const struct sge_ctrl_txq *tx = &adap->sge.ctrlq[ctrl_idx * 4]; 2111dc9daab2SHariprasad Shenai int n = min(4, adap->params.nports - 4 * ctrl_idx); 2112dc9daab2SHariprasad Shenai 2113dc9daab2SHariprasad Shenai S("QType:", "Control"); 2114dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 2115dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 2116dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 2117dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 2118dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 2119e106a4d9SHariprasad Shenai TL("TxQFull:", q.stops); 2120e106a4d9SHariprasad Shenai TL("TxQRestarts:", q.restarts); 2121dc9daab2SHariprasad Shenai } else if (fq_idx == 0) { 2122dc9daab2SHariprasad Shenai const struct sge_rspq *evtq = &adap->sge.fw_evtq; 2123dc9daab2SHariprasad Shenai 2124dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); 2125dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); 2126dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size); 2127dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len); 2128dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx); 2129dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); 2130dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr delay:", 2131dc9daab2SHariprasad Shenai qtimer_val(adap, evtq)); 2132dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 2133dc9daab2SHariprasad Shenai adap->sge.counter_val[evtq->pktcnt_idx]); 2134dc9daab2SHariprasad Shenai } 2135dc9daab2SHariprasad Shenai #undef R 2136e106a4d9SHariprasad Shenai #undef RL 2137dc9daab2SHariprasad Shenai #undef T 2138e106a4d9SHariprasad Shenai #undef TL 2139dc9daab2SHariprasad Shenai #undef S 2140e106a4d9SHariprasad Shenai #undef R3 2141e106a4d9SHariprasad Shenai #undef T3 2142dc9daab2SHariprasad Shenai #undef S3 2143dc9daab2SHariprasad Shenai return 0; 2144dc9daab2SHariprasad Shenai } 2145dc9daab2SHariprasad Shenai 2146dc9daab2SHariprasad Shenai static int sge_queue_entries(const struct adapter *adap) 2147dc9daab2SHariprasad Shenai { 2148dc9daab2SHariprasad Shenai return DIV_ROUND_UP(adap->sge.ethqsets, 4) + 2149dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.ofldqsets, 4) + 2150dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaqs, 4) + 2151dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaciqs, 4) + 2152dc9daab2SHariprasad Shenai DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1; 2153dc9daab2SHariprasad Shenai } 2154dc9daab2SHariprasad Shenai 2155dc9daab2SHariprasad Shenai static void *sge_queue_start(struct seq_file *seq, loff_t *pos) 2156dc9daab2SHariprasad Shenai { 2157dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 2158dc9daab2SHariprasad Shenai 2159dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 2160dc9daab2SHariprasad Shenai } 2161dc9daab2SHariprasad Shenai 2162dc9daab2SHariprasad Shenai static void sge_queue_stop(struct seq_file *seq, void *v) 2163dc9daab2SHariprasad Shenai { 2164dc9daab2SHariprasad Shenai } 2165dc9daab2SHariprasad Shenai 2166dc9daab2SHariprasad Shenai static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) 2167dc9daab2SHariprasad Shenai { 2168dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 2169dc9daab2SHariprasad Shenai 2170dc9daab2SHariprasad Shenai ++*pos; 2171dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 2172dc9daab2SHariprasad Shenai } 2173dc9daab2SHariprasad Shenai 2174dc9daab2SHariprasad Shenai static const struct seq_operations sge_qinfo_seq_ops = { 2175dc9daab2SHariprasad Shenai .start = sge_queue_start, 2176dc9daab2SHariprasad Shenai .next = sge_queue_next, 2177dc9daab2SHariprasad Shenai .stop = sge_queue_stop, 2178dc9daab2SHariprasad Shenai .show = sge_qinfo_show 2179dc9daab2SHariprasad Shenai }; 2180dc9daab2SHariprasad Shenai 2181dc9daab2SHariprasad Shenai static int sge_qinfo_open(struct inode *inode, struct file *file) 2182dc9daab2SHariprasad Shenai { 2183dc9daab2SHariprasad Shenai int res = seq_open(file, &sge_qinfo_seq_ops); 2184dc9daab2SHariprasad Shenai 2185dc9daab2SHariprasad Shenai if (!res) { 2186dc9daab2SHariprasad Shenai struct seq_file *seq = file->private_data; 2187dc9daab2SHariprasad Shenai 2188dc9daab2SHariprasad Shenai seq->private = inode->i_private; 2189dc9daab2SHariprasad Shenai } 2190dc9daab2SHariprasad Shenai return res; 2191dc9daab2SHariprasad Shenai } 2192dc9daab2SHariprasad Shenai 2193dc9daab2SHariprasad Shenai static const struct file_operations sge_qinfo_debugfs_fops = { 2194dc9daab2SHariprasad Shenai .owner = THIS_MODULE, 2195dc9daab2SHariprasad Shenai .open = sge_qinfo_open, 2196dc9daab2SHariprasad Shenai .read = seq_read, 2197dc9daab2SHariprasad Shenai .llseek = seq_lseek, 2198dc9daab2SHariprasad Shenai .release = seq_release, 2199dc9daab2SHariprasad Shenai }; 2200dc9daab2SHariprasad Shenai 220149216c1cSHariprasad Shenai int mem_open(struct inode *inode, struct file *file) 220249216c1cSHariprasad Shenai { 220349216c1cSHariprasad Shenai unsigned int mem; 220449216c1cSHariprasad Shenai struct adapter *adap; 220549216c1cSHariprasad Shenai 220649216c1cSHariprasad Shenai file->private_data = inode->i_private; 220749216c1cSHariprasad Shenai 220849216c1cSHariprasad Shenai mem = (uintptr_t)file->private_data & 0x3; 220949216c1cSHariprasad Shenai adap = file->private_data - mem; 221049216c1cSHariprasad Shenai 221149216c1cSHariprasad Shenai (void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH); 221249216c1cSHariprasad Shenai 221349216c1cSHariprasad Shenai return 0; 221449216c1cSHariprasad Shenai } 221549216c1cSHariprasad Shenai 2216fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 2217fd88b31aSHariprasad Shenai loff_t *ppos) 2218fd88b31aSHariprasad Shenai { 2219fd88b31aSHariprasad Shenai loff_t pos = *ppos; 2220fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 2221fd88b31aSHariprasad Shenai unsigned int mem = (uintptr_t)file->private_data & 3; 2222fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 2223fd88b31aSHariprasad Shenai __be32 *data; 2224fd88b31aSHariprasad Shenai int ret; 2225fd88b31aSHariprasad Shenai 2226fd88b31aSHariprasad Shenai if (pos < 0) 2227fd88b31aSHariprasad Shenai return -EINVAL; 2228fd88b31aSHariprasad Shenai if (pos >= avail) 2229fd88b31aSHariprasad Shenai return 0; 2230fd88b31aSHariprasad Shenai if (count > avail - pos) 2231fd88b31aSHariprasad Shenai count = avail - pos; 2232fd88b31aSHariprasad Shenai 2233fd88b31aSHariprasad Shenai data = t4_alloc_mem(count); 2234fd88b31aSHariprasad Shenai if (!data) 2235fd88b31aSHariprasad Shenai return -ENOMEM; 2236fd88b31aSHariprasad Shenai 2237fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 2238fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 2239fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 2240fd88b31aSHariprasad Shenai if (ret) { 2241fd88b31aSHariprasad Shenai t4_free_mem(data); 2242fd88b31aSHariprasad Shenai return ret; 2243fd88b31aSHariprasad Shenai } 2244fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 2245fd88b31aSHariprasad Shenai 2246fd88b31aSHariprasad Shenai t4_free_mem(data); 2247fd88b31aSHariprasad Shenai if (ret) 2248fd88b31aSHariprasad Shenai return -EFAULT; 2249fd88b31aSHariprasad Shenai 2250fd88b31aSHariprasad Shenai *ppos = pos + count; 2251fd88b31aSHariprasad Shenai return count; 2252fd88b31aSHariprasad Shenai } 2253fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 2254fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 2255fd88b31aSHariprasad Shenai .open = simple_open, 2256fd88b31aSHariprasad Shenai .read = mem_read, 2257fd88b31aSHariprasad Shenai .llseek = default_llseek, 2258fd88b31aSHariprasad Shenai }; 2259fd88b31aSHariprasad Shenai 2260fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 2261fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 2262fd88b31aSHariprasad Shenai { 2263e59b4e91SDavid Howells debugfs_create_file_size(name, S_IRUSR, adap->debugfs_root, 2264e59b4e91SDavid Howells (void *)adap + idx, &mem_debugfs_fops, 2265e59b4e91SDavid Howells size_mb << 20); 2266fd88b31aSHariprasad Shenai } 2267fd88b31aSHariprasad Shenai 22685b377d11SHariprasad Shenai static int blocked_fl_open(struct inode *inode, struct file *file) 22695b377d11SHariprasad Shenai { 22705b377d11SHariprasad Shenai file->private_data = inode->i_private; 22715b377d11SHariprasad Shenai return 0; 22725b377d11SHariprasad Shenai } 22735b377d11SHariprasad Shenai 22745b377d11SHariprasad Shenai static ssize_t blocked_fl_read(struct file *filp, char __user *ubuf, 22755b377d11SHariprasad Shenai size_t count, loff_t *ppos) 22765b377d11SHariprasad Shenai { 22775b377d11SHariprasad Shenai int len; 22785b377d11SHariprasad Shenai const struct adapter *adap = filp->private_data; 22795b377d11SHariprasad Shenai char *buf; 22805b377d11SHariprasad Shenai ssize_t size = (adap->sge.egr_sz + 3) / 4 + 22815b377d11SHariprasad Shenai adap->sge.egr_sz / 32 + 2; /* includes ,/\n/\0 */ 22825b377d11SHariprasad Shenai 22835b377d11SHariprasad Shenai buf = kzalloc(size, GFP_KERNEL); 22845b377d11SHariprasad Shenai if (!buf) 22855b377d11SHariprasad Shenai return -ENOMEM; 22865b377d11SHariprasad Shenai 22875b377d11SHariprasad Shenai len = snprintf(buf, size - 1, "%*pb\n", 22885b377d11SHariprasad Shenai adap->sge.egr_sz, adap->sge.blocked_fl); 22895b377d11SHariprasad Shenai len += sprintf(buf + len, "\n"); 22905b377d11SHariprasad Shenai size = simple_read_from_buffer(ubuf, count, ppos, buf, len); 22915b377d11SHariprasad Shenai t4_free_mem(buf); 22925b377d11SHariprasad Shenai return size; 22935b377d11SHariprasad Shenai } 22945b377d11SHariprasad Shenai 22955b377d11SHariprasad Shenai static ssize_t blocked_fl_write(struct file *filp, const char __user *ubuf, 22965b377d11SHariprasad Shenai size_t count, loff_t *ppos) 22975b377d11SHariprasad Shenai { 22985b377d11SHariprasad Shenai int err; 22995b377d11SHariprasad Shenai unsigned long *t; 23005b377d11SHariprasad Shenai struct adapter *adap = filp->private_data; 23015b377d11SHariprasad Shenai 23025b377d11SHariprasad Shenai t = kcalloc(BITS_TO_LONGS(adap->sge.egr_sz), sizeof(long), GFP_KERNEL); 23035b377d11SHariprasad Shenai if (!t) 23045b377d11SHariprasad Shenai return -ENOMEM; 23055b377d11SHariprasad Shenai 23065b377d11SHariprasad Shenai err = bitmap_parse_user(ubuf, count, t, adap->sge.egr_sz); 23075b377d11SHariprasad Shenai if (err) 23085b377d11SHariprasad Shenai return err; 23095b377d11SHariprasad Shenai 23105b377d11SHariprasad Shenai bitmap_copy(adap->sge.blocked_fl, t, adap->sge.egr_sz); 23115b377d11SHariprasad Shenai t4_free_mem(t); 23125b377d11SHariprasad Shenai return count; 23135b377d11SHariprasad Shenai } 23145b377d11SHariprasad Shenai 23155b377d11SHariprasad Shenai static const struct file_operations blocked_fl_fops = { 23165b377d11SHariprasad Shenai .owner = THIS_MODULE, 23175b377d11SHariprasad Shenai .open = blocked_fl_open, 23185b377d11SHariprasad Shenai .read = blocked_fl_read, 23195b377d11SHariprasad Shenai .write = blocked_fl_write, 23205b377d11SHariprasad Shenai .llseek = generic_file_llseek, 23215b377d11SHariprasad Shenai }; 23225b377d11SHariprasad Shenai 23235888111cSHariprasad Shenai struct mem_desc { 23245888111cSHariprasad Shenai unsigned int base; 23255888111cSHariprasad Shenai unsigned int limit; 23265888111cSHariprasad Shenai unsigned int idx; 23275888111cSHariprasad Shenai }; 23285888111cSHariprasad Shenai 23295888111cSHariprasad Shenai static int mem_desc_cmp(const void *a, const void *b) 23305888111cSHariprasad Shenai { 23315888111cSHariprasad Shenai return ((const struct mem_desc *)a)->base - 23325888111cSHariprasad Shenai ((const struct mem_desc *)b)->base; 23335888111cSHariprasad Shenai } 23345888111cSHariprasad Shenai 23355888111cSHariprasad Shenai static void mem_region_show(struct seq_file *seq, const char *name, 23365888111cSHariprasad Shenai unsigned int from, unsigned int to) 23375888111cSHariprasad Shenai { 23385888111cSHariprasad Shenai char buf[40]; 23395888111cSHariprasad Shenai 23405888111cSHariprasad Shenai string_get_size((u64)to - from + 1, 1, STRING_UNITS_2, buf, 23415888111cSHariprasad Shenai sizeof(buf)); 23425888111cSHariprasad Shenai seq_printf(seq, "%-15s %#x-%#x [%s]\n", name, from, to, buf); 23435888111cSHariprasad Shenai } 23445888111cSHariprasad Shenai 23455888111cSHariprasad Shenai static int meminfo_show(struct seq_file *seq, void *v) 23465888111cSHariprasad Shenai { 23475888111cSHariprasad Shenai static const char * const memory[] = { "EDC0:", "EDC1:", "MC:", 23485888111cSHariprasad Shenai "MC0:", "MC1:"}; 23495888111cSHariprasad Shenai static const char * const region[] = { 23505888111cSHariprasad Shenai "DBQ contexts:", "IMSG contexts:", "FLM cache:", "TCBs:", 23515888111cSHariprasad Shenai "Pstructs:", "Timers:", "Rx FL:", "Tx FL:", "Pstruct FL:", 23525888111cSHariprasad Shenai "Tx payload:", "Rx payload:", "LE hash:", "iSCSI region:", 23535888111cSHariprasad Shenai "TDDP region:", "TPT region:", "STAG region:", "RQ region:", 23545888111cSHariprasad Shenai "RQUDP region:", "PBL region:", "TXPBL region:", 23555888111cSHariprasad Shenai "DBVFIFO region:", "ULPRX state:", "ULPTX state:", 23565888111cSHariprasad Shenai "On-chip queues:" 23575888111cSHariprasad Shenai }; 23585888111cSHariprasad Shenai 23595888111cSHariprasad Shenai int i, n; 23605888111cSHariprasad Shenai u32 lo, hi, used, alloc; 23615888111cSHariprasad Shenai struct mem_desc avail[4]; 23625888111cSHariprasad Shenai struct mem_desc mem[ARRAY_SIZE(region) + 3]; /* up to 3 holes */ 23635888111cSHariprasad Shenai struct mem_desc *md = mem; 23645888111cSHariprasad Shenai struct adapter *adap = seq->private; 23655888111cSHariprasad Shenai 23665888111cSHariprasad Shenai for (i = 0; i < ARRAY_SIZE(mem); i++) { 23675888111cSHariprasad Shenai mem[i].limit = 0; 23685888111cSHariprasad Shenai mem[i].idx = i; 23695888111cSHariprasad Shenai } 23705888111cSHariprasad Shenai 23715888111cSHariprasad Shenai /* Find and sort the populated memory ranges */ 23725888111cSHariprasad Shenai i = 0; 23735888111cSHariprasad Shenai lo = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 23745888111cSHariprasad Shenai if (lo & EDRAM0_ENABLE_F) { 23755888111cSHariprasad Shenai hi = t4_read_reg(adap, MA_EDRAM0_BAR_A); 23765888111cSHariprasad Shenai avail[i].base = EDRAM0_BASE_G(hi) << 20; 23775888111cSHariprasad Shenai avail[i].limit = avail[i].base + (EDRAM0_SIZE_G(hi) << 20); 23785888111cSHariprasad Shenai avail[i].idx = 0; 23795888111cSHariprasad Shenai i++; 23805888111cSHariprasad Shenai } 23815888111cSHariprasad Shenai if (lo & EDRAM1_ENABLE_F) { 23825888111cSHariprasad Shenai hi = t4_read_reg(adap, MA_EDRAM1_BAR_A); 23835888111cSHariprasad Shenai avail[i].base = EDRAM1_BASE_G(hi) << 20; 23845888111cSHariprasad Shenai avail[i].limit = avail[i].base + (EDRAM1_SIZE_G(hi) << 20); 23855888111cSHariprasad Shenai avail[i].idx = 1; 23865888111cSHariprasad Shenai i++; 23875888111cSHariprasad Shenai } 23885888111cSHariprasad Shenai 23895888111cSHariprasad Shenai if (is_t5(adap->params.chip)) { 23905888111cSHariprasad Shenai if (lo & EXT_MEM0_ENABLE_F) { 23915888111cSHariprasad Shenai hi = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 23925888111cSHariprasad Shenai avail[i].base = EXT_MEM0_BASE_G(hi) << 20; 23935888111cSHariprasad Shenai avail[i].limit = 23945888111cSHariprasad Shenai avail[i].base + (EXT_MEM0_SIZE_G(hi) << 20); 23955888111cSHariprasad Shenai avail[i].idx = 3; 23965888111cSHariprasad Shenai i++; 23975888111cSHariprasad Shenai } 23985888111cSHariprasad Shenai if (lo & EXT_MEM1_ENABLE_F) { 23995888111cSHariprasad Shenai hi = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 24005888111cSHariprasad Shenai avail[i].base = EXT_MEM1_BASE_G(hi) << 20; 24015888111cSHariprasad Shenai avail[i].limit = 24025888111cSHariprasad Shenai avail[i].base + (EXT_MEM1_SIZE_G(hi) << 20); 24035888111cSHariprasad Shenai avail[i].idx = 4; 24045888111cSHariprasad Shenai i++; 24055888111cSHariprasad Shenai } 24065888111cSHariprasad Shenai } else { 24075888111cSHariprasad Shenai if (lo & EXT_MEM_ENABLE_F) { 24085888111cSHariprasad Shenai hi = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 24095888111cSHariprasad Shenai avail[i].base = EXT_MEM_BASE_G(hi) << 20; 24105888111cSHariprasad Shenai avail[i].limit = 24115888111cSHariprasad Shenai avail[i].base + (EXT_MEM_SIZE_G(hi) << 20); 24125888111cSHariprasad Shenai avail[i].idx = 2; 24135888111cSHariprasad Shenai i++; 24145888111cSHariprasad Shenai } 24155888111cSHariprasad Shenai } 24165888111cSHariprasad Shenai if (!i) /* no memory available */ 24175888111cSHariprasad Shenai return 0; 24185888111cSHariprasad Shenai sort(avail, i, sizeof(struct mem_desc), mem_desc_cmp, NULL); 24195888111cSHariprasad Shenai 24205888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, SGE_DBQ_CTXT_BADDR_A); 24215888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, SGE_IMSG_CTXT_BADDR_A); 24225888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, SGE_FLM_CACHE_BADDR_A); 24235888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_TCB_BASE_A); 24245888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_MM_BASE_A); 24255888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_TIMER_BASE_A); 24265888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_MM_RX_FLST_BASE_A); 24275888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_MM_TX_FLST_BASE_A); 24285888111cSHariprasad Shenai (md++)->base = t4_read_reg(adap, TP_CMM_MM_PS_FLST_BASE_A); 24295888111cSHariprasad Shenai 24305888111cSHariprasad Shenai /* the next few have explicit upper bounds */ 24315888111cSHariprasad Shenai md->base = t4_read_reg(adap, TP_PMM_TX_BASE_A); 24325888111cSHariprasad Shenai md->limit = md->base - 1 + 24335888111cSHariprasad Shenai t4_read_reg(adap, TP_PMM_TX_PAGE_SIZE_A) * 24345888111cSHariprasad Shenai PMTXMAXPAGE_G(t4_read_reg(adap, TP_PMM_TX_MAX_PAGE_A)); 24355888111cSHariprasad Shenai md++; 24365888111cSHariprasad Shenai 24375888111cSHariprasad Shenai md->base = t4_read_reg(adap, TP_PMM_RX_BASE_A); 24385888111cSHariprasad Shenai md->limit = md->base - 1 + 24395888111cSHariprasad Shenai t4_read_reg(adap, TP_PMM_RX_PAGE_SIZE_A) * 24405888111cSHariprasad Shenai PMRXMAXPAGE_G(t4_read_reg(adap, TP_PMM_RX_MAX_PAGE_A)); 24415888111cSHariprasad Shenai md++; 24425888111cSHariprasad Shenai 24435888111cSHariprasad Shenai if (t4_read_reg(adap, LE_DB_CONFIG_A) & HASHEN_F) { 24445888111cSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adap->params.chip) <= CHELSIO_T5) { 24455888111cSHariprasad Shenai hi = t4_read_reg(adap, LE_DB_TID_HASHBASE_A) / 4; 24465888111cSHariprasad Shenai md->base = t4_read_reg(adap, LE_DB_HASH_TID_BASE_A); 24475888111cSHariprasad Shenai } else { 24485888111cSHariprasad Shenai hi = t4_read_reg(adap, LE_DB_HASH_TID_BASE_A); 24495888111cSHariprasad Shenai md->base = t4_read_reg(adap, 24505888111cSHariprasad Shenai LE_DB_HASH_TBL_BASE_ADDR_A); 24515888111cSHariprasad Shenai } 24525888111cSHariprasad Shenai md->limit = 0; 24535888111cSHariprasad Shenai } else { 24545888111cSHariprasad Shenai md->base = 0; 24555888111cSHariprasad Shenai md->idx = ARRAY_SIZE(region); /* hide it */ 24565888111cSHariprasad Shenai } 24575888111cSHariprasad Shenai md++; 24585888111cSHariprasad Shenai 24595888111cSHariprasad Shenai #define ulp_region(reg) do { \ 24605888111cSHariprasad Shenai md->base = t4_read_reg(adap, ULP_ ## reg ## _LLIMIT_A);\ 24615888111cSHariprasad Shenai (md++)->limit = t4_read_reg(adap, ULP_ ## reg ## _ULIMIT_A); \ 24625888111cSHariprasad Shenai } while (0) 24635888111cSHariprasad Shenai 24645888111cSHariprasad Shenai ulp_region(RX_ISCSI); 24655888111cSHariprasad Shenai ulp_region(RX_TDDP); 24665888111cSHariprasad Shenai ulp_region(TX_TPT); 24675888111cSHariprasad Shenai ulp_region(RX_STAG); 24685888111cSHariprasad Shenai ulp_region(RX_RQ); 24695888111cSHariprasad Shenai ulp_region(RX_RQUDP); 24705888111cSHariprasad Shenai ulp_region(RX_PBL); 24715888111cSHariprasad Shenai ulp_region(TX_PBL); 24725888111cSHariprasad Shenai #undef ulp_region 24735888111cSHariprasad Shenai md->base = 0; 24745888111cSHariprasad Shenai md->idx = ARRAY_SIZE(region); 24755888111cSHariprasad Shenai if (!is_t4(adap->params.chip)) { 24765888111cSHariprasad Shenai u32 size = 0; 24775888111cSHariprasad Shenai u32 sge_ctrl = t4_read_reg(adap, SGE_CONTROL2_A); 24785888111cSHariprasad Shenai u32 fifo_size = t4_read_reg(adap, SGE_DBVFIFO_SIZE_A); 24795888111cSHariprasad Shenai 24805888111cSHariprasad Shenai if (is_t5(adap->params.chip)) { 24815888111cSHariprasad Shenai if (sge_ctrl & VFIFO_ENABLE_F) 24825888111cSHariprasad Shenai size = DBVFIFO_SIZE_G(fifo_size); 24835888111cSHariprasad Shenai } else { 24845888111cSHariprasad Shenai size = T6_DBVFIFO_SIZE_G(fifo_size); 24855888111cSHariprasad Shenai } 24865888111cSHariprasad Shenai 24875888111cSHariprasad Shenai if (size) { 24885888111cSHariprasad Shenai md->base = BASEADDR_G(t4_read_reg(adap, 24895888111cSHariprasad Shenai SGE_DBVFIFO_BADDR_A)); 24905888111cSHariprasad Shenai md->limit = md->base + (size << 2) - 1; 24915888111cSHariprasad Shenai } 24925888111cSHariprasad Shenai } 24935888111cSHariprasad Shenai 24945888111cSHariprasad Shenai md++; 24955888111cSHariprasad Shenai 24965888111cSHariprasad Shenai md->base = t4_read_reg(adap, ULP_RX_CTX_BASE_A); 24975888111cSHariprasad Shenai md->limit = 0; 24985888111cSHariprasad Shenai md++; 24995888111cSHariprasad Shenai md->base = t4_read_reg(adap, ULP_TX_ERR_TABLE_BASE_A); 25005888111cSHariprasad Shenai md->limit = 0; 25015888111cSHariprasad Shenai md++; 25025888111cSHariprasad Shenai 25035888111cSHariprasad Shenai md->base = adap->vres.ocq.start; 25045888111cSHariprasad Shenai if (adap->vres.ocq.size) 25055888111cSHariprasad Shenai md->limit = md->base + adap->vres.ocq.size - 1; 25065888111cSHariprasad Shenai else 25075888111cSHariprasad Shenai md->idx = ARRAY_SIZE(region); /* hide it */ 25085888111cSHariprasad Shenai md++; 25095888111cSHariprasad Shenai 25105888111cSHariprasad Shenai /* add any address-space holes, there can be up to 3 */ 25115888111cSHariprasad Shenai for (n = 0; n < i - 1; n++) 25125888111cSHariprasad Shenai if (avail[n].limit < avail[n + 1].base) 25135888111cSHariprasad Shenai (md++)->base = avail[n].limit; 25145888111cSHariprasad Shenai if (avail[n].limit) 25155888111cSHariprasad Shenai (md++)->base = avail[n].limit; 25165888111cSHariprasad Shenai 25175888111cSHariprasad Shenai n = md - mem; 25185888111cSHariprasad Shenai sort(mem, n, sizeof(struct mem_desc), mem_desc_cmp, NULL); 25195888111cSHariprasad Shenai 25205888111cSHariprasad Shenai for (lo = 0; lo < i; lo++) 25215888111cSHariprasad Shenai mem_region_show(seq, memory[avail[lo].idx], avail[lo].base, 25225888111cSHariprasad Shenai avail[lo].limit - 1); 25235888111cSHariprasad Shenai 25245888111cSHariprasad Shenai seq_putc(seq, '\n'); 25255888111cSHariprasad Shenai for (i = 0; i < n; i++) { 25265888111cSHariprasad Shenai if (mem[i].idx >= ARRAY_SIZE(region)) 25275888111cSHariprasad Shenai continue; /* skip holes */ 25285888111cSHariprasad Shenai if (!mem[i].limit) 25295888111cSHariprasad Shenai mem[i].limit = i < n - 1 ? mem[i + 1].base - 1 : ~0; 25305888111cSHariprasad Shenai mem_region_show(seq, region[mem[i].idx], mem[i].base, 25315888111cSHariprasad Shenai mem[i].limit); 25325888111cSHariprasad Shenai } 25335888111cSHariprasad Shenai 25345888111cSHariprasad Shenai seq_putc(seq, '\n'); 25355888111cSHariprasad Shenai lo = t4_read_reg(adap, CIM_SDRAM_BASE_ADDR_A); 25365888111cSHariprasad Shenai hi = t4_read_reg(adap, CIM_SDRAM_ADDR_SIZE_A) + lo - 1; 25375888111cSHariprasad Shenai mem_region_show(seq, "uP RAM:", lo, hi); 25385888111cSHariprasad Shenai 25395888111cSHariprasad Shenai lo = t4_read_reg(adap, CIM_EXTMEM2_BASE_ADDR_A); 25405888111cSHariprasad Shenai hi = t4_read_reg(adap, CIM_EXTMEM2_ADDR_SIZE_A) + lo - 1; 25415888111cSHariprasad Shenai mem_region_show(seq, "uP Extmem2:", lo, hi); 25425888111cSHariprasad Shenai 25435888111cSHariprasad Shenai lo = t4_read_reg(adap, TP_PMM_RX_MAX_PAGE_A); 25445888111cSHariprasad Shenai seq_printf(seq, "\n%u Rx pages of size %uKiB for %u channels\n", 25455888111cSHariprasad Shenai PMRXMAXPAGE_G(lo), 25465888111cSHariprasad Shenai t4_read_reg(adap, TP_PMM_RX_PAGE_SIZE_A) >> 10, 25475888111cSHariprasad Shenai (lo & PMRXNUMCHN_F) ? 2 : 1); 25485888111cSHariprasad Shenai 25495888111cSHariprasad Shenai lo = t4_read_reg(adap, TP_PMM_TX_MAX_PAGE_A); 25505888111cSHariprasad Shenai hi = t4_read_reg(adap, TP_PMM_TX_PAGE_SIZE_A); 25515888111cSHariprasad Shenai seq_printf(seq, "%u Tx pages of size %u%ciB for %u channels\n", 25525888111cSHariprasad Shenai PMTXMAXPAGE_G(lo), 25535888111cSHariprasad Shenai hi >= (1 << 20) ? (hi >> 20) : (hi >> 10), 25545888111cSHariprasad Shenai hi >= (1 << 20) ? 'M' : 'K', 1 << PMTXNUMCHN_G(lo)); 25555888111cSHariprasad Shenai seq_printf(seq, "%u p-structs\n\n", 25565888111cSHariprasad Shenai t4_read_reg(adap, TP_CMM_MM_MAX_PSTRUCT_A)); 25575888111cSHariprasad Shenai 25585888111cSHariprasad Shenai for (i = 0; i < 4; i++) { 25595888111cSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adap->params.chip) > CHELSIO_T5) 25605888111cSHariprasad Shenai lo = t4_read_reg(adap, MPS_RX_MAC_BG_PG_CNT0_A + i * 4); 25615888111cSHariprasad Shenai else 25625888111cSHariprasad Shenai lo = t4_read_reg(adap, MPS_RX_PG_RSV0_A + i * 4); 25635888111cSHariprasad Shenai if (is_t5(adap->params.chip)) { 25645888111cSHariprasad Shenai used = T5_USED_G(lo); 25655888111cSHariprasad Shenai alloc = T5_ALLOC_G(lo); 25665888111cSHariprasad Shenai } else { 25675888111cSHariprasad Shenai used = USED_G(lo); 25685888111cSHariprasad Shenai alloc = ALLOC_G(lo); 25695888111cSHariprasad Shenai } 25705888111cSHariprasad Shenai /* For T6 these are MAC buffer groups */ 25715888111cSHariprasad Shenai seq_printf(seq, "Port %d using %u pages out of %u allocated\n", 25725888111cSHariprasad Shenai i, used, alloc); 25735888111cSHariprasad Shenai } 25745888111cSHariprasad Shenai for (i = 0; i < adap->params.arch.nchan; i++) { 25755888111cSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adap->params.chip) > CHELSIO_T5) 25765888111cSHariprasad Shenai lo = t4_read_reg(adap, 25775888111cSHariprasad Shenai MPS_RX_LPBK_BG_PG_CNT0_A + i * 4); 25785888111cSHariprasad Shenai else 25795888111cSHariprasad Shenai lo = t4_read_reg(adap, MPS_RX_PG_RSV4_A + i * 4); 25805888111cSHariprasad Shenai if (is_t5(adap->params.chip)) { 25815888111cSHariprasad Shenai used = T5_USED_G(lo); 25825888111cSHariprasad Shenai alloc = T5_ALLOC_G(lo); 25835888111cSHariprasad Shenai } else { 25845888111cSHariprasad Shenai used = USED_G(lo); 25855888111cSHariprasad Shenai alloc = ALLOC_G(lo); 25865888111cSHariprasad Shenai } 25875888111cSHariprasad Shenai /* For T6 these are MAC buffer groups */ 25885888111cSHariprasad Shenai seq_printf(seq, 25895888111cSHariprasad Shenai "Loopback %d using %u pages out of %u allocated\n", 25905888111cSHariprasad Shenai i, used, alloc); 25915888111cSHariprasad Shenai } 25925888111cSHariprasad Shenai return 0; 25935888111cSHariprasad Shenai } 25945888111cSHariprasad Shenai 25955888111cSHariprasad Shenai static int meminfo_open(struct inode *inode, struct file *file) 25965888111cSHariprasad Shenai { 25975888111cSHariprasad Shenai return single_open(file, meminfo_show, inode->i_private); 25985888111cSHariprasad Shenai } 25995888111cSHariprasad Shenai 26005888111cSHariprasad Shenai static const struct file_operations meminfo_fops = { 26015888111cSHariprasad Shenai .owner = THIS_MODULE, 26025888111cSHariprasad Shenai .open = meminfo_open, 26035888111cSHariprasad Shenai .read = seq_read, 26045888111cSHariprasad Shenai .llseek = seq_lseek, 26055888111cSHariprasad Shenai .release = single_release, 26065888111cSHariprasad Shenai }; 2607fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 2608fd88b31aSHariprasad Shenai */ 2609fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 2610fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 2611fd88b31aSHariprasad Shenai unsigned int nfiles) 2612fd88b31aSHariprasad Shenai { 2613fd88b31aSHariprasad Shenai int i; 2614fd88b31aSHariprasad Shenai 2615fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 2616fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 2617fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 2618fd88b31aSHariprasad Shenai adap->debugfs_root, 2619fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 2620fd88b31aSHariprasad Shenai files[i].ops); 2621fd88b31aSHariprasad Shenai } 2622fd88b31aSHariprasad Shenai 2623fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 2624fd88b31aSHariprasad Shenai { 2625fd88b31aSHariprasad Shenai int i; 26263ccc6cf7SHariprasad Shenai u32 size = 0; 262749216c1cSHariprasad Shenai struct dentry *de; 2628fd88b31aSHariprasad Shenai 2629fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 2630f1ff24aaSHariprasad Shenai { "cim_la", &cim_la_fops, S_IRUSR, 0 }, 263119689609SHariprasad Shenai { "cim_pif_la", &cim_pif_la_fops, S_IRUSR, 0 }, 263226fae93fSHariprasad Shenai { "cim_ma_la", &cim_ma_la_fops, S_IRUSR, 0 }, 263374b3092cSHariprasad Shenai { "cim_qcfg", &cim_qcfg_fops, S_IRUSR, 0 }, 2634b58b6676SHariprasad Shenai { "clk", &clk_debugfs_fops, S_IRUSR, 0 }, 263549aa284fSHariprasad Shenai { "devlog", &devlog_fops, S_IRUSR, 0 }, 2636bf7c781dSHariprasad Shenai { "mbox0", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 0 }, 2637bf7c781dSHariprasad Shenai { "mbox1", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 1 }, 2638bf7c781dSHariprasad Shenai { "mbox2", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 2 }, 2639bf7c781dSHariprasad Shenai { "mbox3", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 3 }, 2640bf7c781dSHariprasad Shenai { "mbox4", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 4 }, 2641bf7c781dSHariprasad Shenai { "mbox5", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 5 }, 2642bf7c781dSHariprasad Shenai { "mbox6", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 6 }, 2643bf7c781dSHariprasad Shenai { "mbox7", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 7 }, 2644fd88b31aSHariprasad Shenai { "l2t", &t4_l2t_fops, S_IRUSR, 0}, 2645ef82f662SHariprasad Shenai { "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 }, 2646688ea5feSHariprasad Shenai { "rss", &rss_debugfs_fops, S_IRUSR, 0 }, 2647688ea5feSHariprasad Shenai { "rss_config", &rss_config_debugfs_fops, S_IRUSR, 0 }, 2648688ea5feSHariprasad Shenai { "rss_key", &rss_key_debugfs_fops, S_IRUSR, 0 }, 2649688ea5feSHariprasad Shenai { "rss_pf_config", &rss_pf_config_debugfs_fops, S_IRUSR, 0 }, 2650688ea5feSHariprasad Shenai { "rss_vf_config", &rss_vf_config_debugfs_fops, S_IRUSR, 0 }, 2651dc9daab2SHariprasad Shenai { "sge_qinfo", &sge_qinfo_debugfs_fops, S_IRUSR, 0 }, 2652e5f0e43bSHariprasad Shenai { "ibq_tp0", &cim_ibq_fops, S_IRUSR, 0 }, 2653e5f0e43bSHariprasad Shenai { "ibq_tp1", &cim_ibq_fops, S_IRUSR, 1 }, 2654e5f0e43bSHariprasad Shenai { "ibq_ulp", &cim_ibq_fops, S_IRUSR, 2 }, 2655e5f0e43bSHariprasad Shenai { "ibq_sge0", &cim_ibq_fops, S_IRUSR, 3 }, 2656e5f0e43bSHariprasad Shenai { "ibq_sge1", &cim_ibq_fops, S_IRUSR, 4 }, 2657e5f0e43bSHariprasad Shenai { "ibq_ncsi", &cim_ibq_fops, S_IRUSR, 5 }, 2658c778af7dSHariprasad Shenai { "obq_ulp0", &cim_obq_fops, S_IRUSR, 0 }, 2659c778af7dSHariprasad Shenai { "obq_ulp1", &cim_obq_fops, S_IRUSR, 1 }, 2660c778af7dSHariprasad Shenai { "obq_ulp2", &cim_obq_fops, S_IRUSR, 2 }, 2661c778af7dSHariprasad Shenai { "obq_ulp3", &cim_obq_fops, S_IRUSR, 3 }, 2662c778af7dSHariprasad Shenai { "obq_sge", &cim_obq_fops, S_IRUSR, 4 }, 2663c778af7dSHariprasad Shenai { "obq_ncsi", &cim_obq_fops, S_IRUSR, 5 }, 26642d277b3bSHariprasad Shenai { "tp_la", &tp_la_fops, S_IRUSR, 0 }, 2665797ff0f5SHariprasad Shenai { "ulprx_la", &ulprx_la_fops, S_IRUSR, 0 }, 266670a5f3bbSHariprasad Shenai { "sensors", &sensors_debugfs_fops, S_IRUSR, 0 }, 2667b3bbe36aSHariprasad Shenai { "pm_stats", &pm_stats_debugfs_fops, S_IRUSR, 0 }, 26687864026bSHariprasad Shenai { "tx_rate", &tx_rate_debugfs_fops, S_IRUSR, 0 }, 2669bad43792SHariprasad Shenai { "cctrl", &cctrl_tbl_debugfs_fops, S_IRUSR, 0 }, 2670b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 2671b5a02f50SAnish Bhatt { "clip_tbl", &clip_tbl_debugfs_fops, S_IRUSR, 0 }, 2672b5a02f50SAnish Bhatt #endif 26735b377d11SHariprasad Shenai { "blocked_fl", &blocked_fl_fops, S_IRUSR | S_IWUSR, 0 }, 26745888111cSHariprasad Shenai { "meminfo", &meminfo_fops, S_IRUSR, 0 }, 2675fd88b31aSHariprasad Shenai }; 2676fd88b31aSHariprasad Shenai 2677c778af7dSHariprasad Shenai /* Debug FS nodes common to all T5 and later adapters. 2678c778af7dSHariprasad Shenai */ 2679c778af7dSHariprasad Shenai static struct t4_debugfs_entry t5_debugfs_files[] = { 2680c778af7dSHariprasad Shenai { "obq_sge_rx_q0", &cim_obq_fops, S_IRUSR, 6 }, 2681c778af7dSHariprasad Shenai { "obq_sge_rx_q1", &cim_obq_fops, S_IRUSR, 7 }, 2682c778af7dSHariprasad Shenai }; 2683c778af7dSHariprasad Shenai 2684fd88b31aSHariprasad Shenai add_debugfs_files(adap, 2685fd88b31aSHariprasad Shenai t4_debugfs_files, 2686fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 2687c778af7dSHariprasad Shenai if (!is_t4(adap->params.chip)) 2688c778af7dSHariprasad Shenai add_debugfs_files(adap, 2689c778af7dSHariprasad Shenai t5_debugfs_files, 2690c778af7dSHariprasad Shenai ARRAY_SIZE(t5_debugfs_files)); 2691fd88b31aSHariprasad Shenai 26926559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 26936559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 26946559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 26956559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 2696fd88b31aSHariprasad Shenai } 26976559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 26986559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 26996559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 2700fd88b31aSHariprasad Shenai } 27013ccc6cf7SHariprasad Shenai if (is_t5(adap->params.chip)) { 27026559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 27036559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 2704fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 27056559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 2706fd88b31aSHariprasad Shenai } 27076559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 27086559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 2709fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 27106559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 2711fd88b31aSHariprasad Shenai } 27123ccc6cf7SHariprasad Shenai } else { 27133ccc6cf7SHariprasad Shenai if (i & EXT_MEM_ENABLE_F) 27143ccc6cf7SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 27153ccc6cf7SHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 27163ccc6cf7SHariprasad Shenai EXT_MEM_SIZE_G(size)); 2717fd88b31aSHariprasad Shenai } 271849216c1cSHariprasad Shenai 2719c1d81b1cSDavid Howells de = debugfs_create_file_size("flash", S_IRUSR, adap->debugfs_root, adap, 2720c1d81b1cSDavid Howells &flash_debugfs_fops, adap->params.sf_size); 27210b2c2a93SHariprasad Shenai debugfs_create_bool("use_backdoor", S_IWUSR | S_IRUSR, 27220b2c2a93SHariprasad Shenai adap->debugfs_root, &adap->use_bd); 272349216c1cSHariprasad Shenai 2724fd88b31aSHariprasad Shenai return 0; 2725fd88b31aSHariprasad Shenai } 2726