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 154f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 155f1ff24aaSHariprasad Shenai { 156f1ff24aaSHariprasad Shenai int ret; 157f1ff24aaSHariprasad Shenai unsigned int cfg; 158f1ff24aaSHariprasad Shenai struct seq_tab *p; 159f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 160f1ff24aaSHariprasad Shenai 161f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 162f1ff24aaSHariprasad Shenai if (ret) 163f1ff24aaSHariprasad Shenai return ret; 164f1ff24aaSHariprasad Shenai 165f1ff24aaSHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 8 * sizeof(u32), 1, 166f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 167f1ff24aaSHariprasad Shenai cim_la_show_3in1 : cim_la_show); 168f1ff24aaSHariprasad Shenai if (!p) 169f1ff24aaSHariprasad Shenai return -ENOMEM; 170f1ff24aaSHariprasad Shenai 171f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 172f1ff24aaSHariprasad Shenai if (ret) 173f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 174f1ff24aaSHariprasad Shenai return ret; 175f1ff24aaSHariprasad Shenai } 176f1ff24aaSHariprasad Shenai 177f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 178f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 179f1ff24aaSHariprasad Shenai .open = cim_la_open, 180f1ff24aaSHariprasad Shenai .read = seq_read, 181f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 182f1ff24aaSHariprasad Shenai .release = seq_release_private 183f1ff24aaSHariprasad Shenai }; 184f1ff24aaSHariprasad Shenai 18574b3092cSHariprasad Shenai static int cim_qcfg_show(struct seq_file *seq, void *v) 18674b3092cSHariprasad Shenai { 18774b3092cSHariprasad Shenai static const char * const qname[] = { 18874b3092cSHariprasad Shenai "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI", 18974b3092cSHariprasad Shenai "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI", 19074b3092cSHariprasad Shenai "SGE0-RX", "SGE1-RX" 19174b3092cSHariprasad Shenai }; 19274b3092cSHariprasad Shenai 19374b3092cSHariprasad Shenai int i; 19474b3092cSHariprasad Shenai struct adapter *adap = seq->private; 19574b3092cSHariprasad Shenai u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 19674b3092cSHariprasad Shenai u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 19774b3092cSHariprasad Shenai u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))]; 19874b3092cSHariprasad Shenai u16 thres[CIM_NUM_IBQ]; 19974b3092cSHariprasad Shenai u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr; 20074b3092cSHariprasad Shenai u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5]; 20174b3092cSHariprasad Shenai u32 *p = stat; 20274b3092cSHariprasad Shenai int cim_num_obq = is_t4(adap->params.chip) ? 20374b3092cSHariprasad Shenai CIM_NUM_OBQ : CIM_NUM_OBQ_T5; 20474b3092cSHariprasad Shenai 20574b3092cSHariprasad Shenai i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A : 20674b3092cSHariprasad Shenai UP_IBQ_0_SHADOW_RDADDR_A, 20774b3092cSHariprasad Shenai ARRAY_SIZE(stat), stat); 20874b3092cSHariprasad Shenai if (!i) { 20974b3092cSHariprasad Shenai if (is_t4(adap->params.chip)) { 21074b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A, 21174b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t4), obq_wr_t4); 21274b3092cSHariprasad Shenai wr = obq_wr_t4; 21374b3092cSHariprasad Shenai } else { 21474b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A, 21574b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t5), obq_wr_t5); 21674b3092cSHariprasad Shenai wr = obq_wr_t5; 21774b3092cSHariprasad Shenai } 21874b3092cSHariprasad Shenai } 21974b3092cSHariprasad Shenai if (i) 22074b3092cSHariprasad Shenai return i; 22174b3092cSHariprasad Shenai 22274b3092cSHariprasad Shenai t4_read_cimq_cfg(adap, base, size, thres); 22374b3092cSHariprasad Shenai 22474b3092cSHariprasad Shenai seq_printf(seq, 22574b3092cSHariprasad Shenai " Queue Base Size Thres RdPtr WrPtr SOP EOP Avail\n"); 22674b3092cSHariprasad Shenai for (i = 0; i < CIM_NUM_IBQ; i++, p += 4) 22774b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %5u %6x %4x %4u %4u %5u\n", 22874b3092cSHariprasad Shenai qname[i], base[i], size[i], thres[i], 22974b3092cSHariprasad Shenai IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]), 23074b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 23174b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 23274b3092cSHariprasad Shenai for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2) 23374b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %12x %4x %4u %4u %5u\n", 23474b3092cSHariprasad Shenai qname[i], base[i], size[i], 23574b3092cSHariprasad Shenai QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i], 23674b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 23774b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 23874b3092cSHariprasad Shenai return 0; 23974b3092cSHariprasad Shenai } 24074b3092cSHariprasad Shenai 24174b3092cSHariprasad Shenai static int cim_qcfg_open(struct inode *inode, struct file *file) 24274b3092cSHariprasad Shenai { 24374b3092cSHariprasad Shenai return single_open(file, cim_qcfg_show, inode->i_private); 24474b3092cSHariprasad Shenai } 24574b3092cSHariprasad Shenai 24674b3092cSHariprasad Shenai static const struct file_operations cim_qcfg_fops = { 24774b3092cSHariprasad Shenai .owner = THIS_MODULE, 24874b3092cSHariprasad Shenai .open = cim_qcfg_open, 24974b3092cSHariprasad Shenai .read = seq_read, 25074b3092cSHariprasad Shenai .llseek = seq_lseek, 25174b3092cSHariprasad Shenai .release = single_release, 25274b3092cSHariprasad Shenai }; 25374b3092cSHariprasad Shenai 254e5f0e43bSHariprasad Shenai static int cimq_show(struct seq_file *seq, void *v, int idx) 255e5f0e43bSHariprasad Shenai { 256e5f0e43bSHariprasad Shenai const u32 *p = v; 257e5f0e43bSHariprasad Shenai 258e5f0e43bSHariprasad Shenai seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1], 259e5f0e43bSHariprasad Shenai p[2], p[3]); 260e5f0e43bSHariprasad Shenai return 0; 261e5f0e43bSHariprasad Shenai } 262e5f0e43bSHariprasad Shenai 263e5f0e43bSHariprasad Shenai static int cim_ibq_open(struct inode *inode, struct file *file) 264e5f0e43bSHariprasad Shenai { 265e5f0e43bSHariprasad Shenai int ret; 266e5f0e43bSHariprasad Shenai struct seq_tab *p; 267e5f0e43bSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 268e5f0e43bSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 269e5f0e43bSHariprasad Shenai 270e5f0e43bSHariprasad Shenai p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 271e5f0e43bSHariprasad Shenai if (!p) 272e5f0e43bSHariprasad Shenai return -ENOMEM; 273e5f0e43bSHariprasad Shenai 274e5f0e43bSHariprasad Shenai ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4); 275e5f0e43bSHariprasad Shenai if (ret < 0) 276e5f0e43bSHariprasad Shenai seq_release_private(inode, file); 277e5f0e43bSHariprasad Shenai else 278e5f0e43bSHariprasad Shenai ret = 0; 279e5f0e43bSHariprasad Shenai return ret; 280e5f0e43bSHariprasad Shenai } 281e5f0e43bSHariprasad Shenai 282e5f0e43bSHariprasad Shenai static const struct file_operations cim_ibq_fops = { 283e5f0e43bSHariprasad Shenai .owner = THIS_MODULE, 284e5f0e43bSHariprasad Shenai .open = cim_ibq_open, 285e5f0e43bSHariprasad Shenai .read = seq_read, 286e5f0e43bSHariprasad Shenai .llseek = seq_lseek, 287e5f0e43bSHariprasad Shenai .release = seq_release_private 288e5f0e43bSHariprasad Shenai }; 289e5f0e43bSHariprasad Shenai 290c778af7dSHariprasad Shenai static int cim_obq_open(struct inode *inode, struct file *file) 291c778af7dSHariprasad Shenai { 292c778af7dSHariprasad Shenai int ret; 293c778af7dSHariprasad Shenai struct seq_tab *p; 294c778af7dSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 295c778af7dSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 296c778af7dSHariprasad Shenai 297c778af7dSHariprasad Shenai p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 298c778af7dSHariprasad Shenai if (!p) 299c778af7dSHariprasad Shenai return -ENOMEM; 300c778af7dSHariprasad Shenai 301c778af7dSHariprasad Shenai ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4); 302c778af7dSHariprasad Shenai if (ret < 0) { 303c778af7dSHariprasad Shenai seq_release_private(inode, file); 304c778af7dSHariprasad Shenai } else { 305c778af7dSHariprasad Shenai seq_tab_trim(p, ret / 4); 306c778af7dSHariprasad Shenai ret = 0; 307c778af7dSHariprasad Shenai } 308c778af7dSHariprasad Shenai return ret; 309c778af7dSHariprasad Shenai } 310c778af7dSHariprasad Shenai 311c778af7dSHariprasad Shenai static const struct file_operations cim_obq_fops = { 312c778af7dSHariprasad Shenai .owner = THIS_MODULE, 313c778af7dSHariprasad Shenai .open = cim_obq_open, 314c778af7dSHariprasad Shenai .read = seq_read, 315c778af7dSHariprasad Shenai .llseek = seq_lseek, 316c778af7dSHariprasad Shenai .release = seq_release_private 317c778af7dSHariprasad Shenai }; 318c778af7dSHariprasad Shenai 3192d277b3bSHariprasad Shenai struct field_desc { 3202d277b3bSHariprasad Shenai const char *name; 3212d277b3bSHariprasad Shenai unsigned int start; 3222d277b3bSHariprasad Shenai unsigned int width; 3232d277b3bSHariprasad Shenai }; 3242d277b3bSHariprasad Shenai 3252d277b3bSHariprasad Shenai static void field_desc_show(struct seq_file *seq, u64 v, 3262d277b3bSHariprasad Shenai const struct field_desc *p) 3272d277b3bSHariprasad Shenai { 3282d277b3bSHariprasad Shenai char buf[32]; 3292d277b3bSHariprasad Shenai int line_size = 0; 3302d277b3bSHariprasad Shenai 3312d277b3bSHariprasad Shenai while (p->name) { 3322d277b3bSHariprasad Shenai u64 mask = (1ULL << p->width) - 1; 3332d277b3bSHariprasad Shenai int len = scnprintf(buf, sizeof(buf), "%s: %llu", p->name, 3342d277b3bSHariprasad Shenai ((unsigned long long)v >> p->start) & mask); 3352d277b3bSHariprasad Shenai 3362d277b3bSHariprasad Shenai if (line_size + len >= 79) { 3372d277b3bSHariprasad Shenai line_size = 8; 3382d277b3bSHariprasad Shenai seq_puts(seq, "\n "); 3392d277b3bSHariprasad Shenai } 3402d277b3bSHariprasad Shenai seq_printf(seq, "%s ", buf); 3412d277b3bSHariprasad Shenai line_size += len + 1; 3422d277b3bSHariprasad Shenai p++; 3432d277b3bSHariprasad Shenai } 3442d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 3452d277b3bSHariprasad Shenai } 3462d277b3bSHariprasad Shenai 3472d277b3bSHariprasad Shenai static struct field_desc tp_la0[] = { 3482d277b3bSHariprasad Shenai { "RcfOpCodeOut", 60, 4 }, 3492d277b3bSHariprasad Shenai { "State", 56, 4 }, 3502d277b3bSHariprasad Shenai { "WcfState", 52, 4 }, 3512d277b3bSHariprasad Shenai { "RcfOpcSrcOut", 50, 2 }, 3522d277b3bSHariprasad Shenai { "CRxError", 49, 1 }, 3532d277b3bSHariprasad Shenai { "ERxError", 48, 1 }, 3542d277b3bSHariprasad Shenai { "SanityFailed", 47, 1 }, 3552d277b3bSHariprasad Shenai { "SpuriousMsg", 46, 1 }, 3562d277b3bSHariprasad Shenai { "FlushInputMsg", 45, 1 }, 3572d277b3bSHariprasad Shenai { "FlushInputCpl", 44, 1 }, 3582d277b3bSHariprasad Shenai { "RssUpBit", 43, 1 }, 3592d277b3bSHariprasad Shenai { "RssFilterHit", 42, 1 }, 3602d277b3bSHariprasad Shenai { "Tid", 32, 10 }, 3612d277b3bSHariprasad Shenai { "InitTcb", 31, 1 }, 3622d277b3bSHariprasad Shenai { "LineNumber", 24, 7 }, 3632d277b3bSHariprasad Shenai { "Emsg", 23, 1 }, 3642d277b3bSHariprasad Shenai { "EdataOut", 22, 1 }, 3652d277b3bSHariprasad Shenai { "Cmsg", 21, 1 }, 3662d277b3bSHariprasad Shenai { "CdataOut", 20, 1 }, 3672d277b3bSHariprasad Shenai { "EreadPdu", 19, 1 }, 3682d277b3bSHariprasad Shenai { "CreadPdu", 18, 1 }, 3692d277b3bSHariprasad Shenai { "TunnelPkt", 17, 1 }, 3702d277b3bSHariprasad Shenai { "RcfPeerFin", 16, 1 }, 3712d277b3bSHariprasad Shenai { "RcfReasonOut", 12, 4 }, 3722d277b3bSHariprasad Shenai { "TxCchannel", 10, 2 }, 3732d277b3bSHariprasad Shenai { "RcfTxChannel", 8, 2 }, 3742d277b3bSHariprasad Shenai { "RxEchannel", 6, 2 }, 3752d277b3bSHariprasad Shenai { "RcfRxChannel", 5, 1 }, 3762d277b3bSHariprasad Shenai { "RcfDataOutSrdy", 4, 1 }, 3772d277b3bSHariprasad Shenai { "RxDvld", 3, 1 }, 3782d277b3bSHariprasad Shenai { "RxOoDvld", 2, 1 }, 3792d277b3bSHariprasad Shenai { "RxCongestion", 1, 1 }, 3802d277b3bSHariprasad Shenai { "TxCongestion", 0, 1 }, 3812d277b3bSHariprasad Shenai { NULL } 3822d277b3bSHariprasad Shenai }; 3832d277b3bSHariprasad Shenai 3842d277b3bSHariprasad Shenai static int tp_la_show(struct seq_file *seq, void *v, int idx) 3852d277b3bSHariprasad Shenai { 3862d277b3bSHariprasad Shenai const u64 *p = v; 3872d277b3bSHariprasad Shenai 3882d277b3bSHariprasad Shenai field_desc_show(seq, *p, tp_la0); 3892d277b3bSHariprasad Shenai return 0; 3902d277b3bSHariprasad Shenai } 3912d277b3bSHariprasad Shenai 3922d277b3bSHariprasad Shenai static int tp_la_show2(struct seq_file *seq, void *v, int idx) 3932d277b3bSHariprasad Shenai { 3942d277b3bSHariprasad Shenai const u64 *p = v; 3952d277b3bSHariprasad Shenai 3962d277b3bSHariprasad Shenai if (idx) 3972d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 3982d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 3992d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 4002d277b3bSHariprasad Shenai field_desc_show(seq, p[1], tp_la0); 4012d277b3bSHariprasad Shenai return 0; 4022d277b3bSHariprasad Shenai } 4032d277b3bSHariprasad Shenai 4042d277b3bSHariprasad Shenai static int tp_la_show3(struct seq_file *seq, void *v, int idx) 4052d277b3bSHariprasad Shenai { 4062d277b3bSHariprasad Shenai static struct field_desc tp_la1[] = { 4072d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 4082d277b3bSHariprasad Shenai { "CplCmdOut", 48, 8 }, 4092d277b3bSHariprasad Shenai { "ESynOut", 47, 1 }, 4102d277b3bSHariprasad Shenai { "EAckOut", 46, 1 }, 4112d277b3bSHariprasad Shenai { "EFinOut", 45, 1 }, 4122d277b3bSHariprasad Shenai { "ERstOut", 44, 1 }, 4132d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 4142d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 4152d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 4162d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 4172d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 4182d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 4192d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 4202d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 4212d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 4222d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 4232d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 4242d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 4252d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 4262d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 4272d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 4282d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 4292d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 4302d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 4312d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 4322d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 4332d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 4342d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 4352d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 4362d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 4372d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 4382d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 4392d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 4402d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 4412d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 4422d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 4432d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 4442d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 4452d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 4462d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 4472d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 4482d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 4492d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 4502d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 4512d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 4522d277b3bSHariprasad Shenai { NULL } 4532d277b3bSHariprasad Shenai }; 4542d277b3bSHariprasad Shenai static struct field_desc tp_la2[] = { 4552d277b3bSHariprasad Shenai { "CplCmdIn", 56, 8 }, 4562d277b3bSHariprasad Shenai { "MpsVfVld", 55, 1 }, 4572d277b3bSHariprasad Shenai { "MpsPf", 52, 3 }, 4582d277b3bSHariprasad Shenai { "MpsVf", 44, 8 }, 4592d277b3bSHariprasad Shenai { "SynIn", 43, 1 }, 4602d277b3bSHariprasad Shenai { "AckIn", 42, 1 }, 4612d277b3bSHariprasad Shenai { "FinIn", 41, 1 }, 4622d277b3bSHariprasad Shenai { "RstIn", 40, 1 }, 4632d277b3bSHariprasad Shenai { "DataIn", 39, 1 }, 4642d277b3bSHariprasad Shenai { "DataInVld", 38, 1 }, 4652d277b3bSHariprasad Shenai { "PadIn", 37, 1 }, 4662d277b3bSHariprasad Shenai { "RxBufEmpty", 36, 1 }, 4672d277b3bSHariprasad Shenai { "RxDdp", 35, 1 }, 4682d277b3bSHariprasad Shenai { "RxFbCongestion", 34, 1 }, 4692d277b3bSHariprasad Shenai { "TxFbCongestion", 33, 1 }, 4702d277b3bSHariprasad Shenai { "TxPktSumSrdy", 32, 1 }, 4712d277b3bSHariprasad Shenai { "RcfUlpType", 28, 4 }, 4722d277b3bSHariprasad Shenai { "Eread", 27, 1 }, 4732d277b3bSHariprasad Shenai { "Ebypass", 26, 1 }, 4742d277b3bSHariprasad Shenai { "Esave", 25, 1 }, 4752d277b3bSHariprasad Shenai { "Static0", 24, 1 }, 4762d277b3bSHariprasad Shenai { "Cread", 23, 1 }, 4772d277b3bSHariprasad Shenai { "Cbypass", 22, 1 }, 4782d277b3bSHariprasad Shenai { "Csave", 21, 1 }, 4792d277b3bSHariprasad Shenai { "CPktOut", 20, 1 }, 4802d277b3bSHariprasad Shenai { "RxPagePoolFull", 18, 2 }, 4812d277b3bSHariprasad Shenai { "RxLpbkPkt", 17, 1 }, 4822d277b3bSHariprasad Shenai { "TxLpbkPkt", 16, 1 }, 4832d277b3bSHariprasad Shenai { "RxVfValid", 15, 1 }, 4842d277b3bSHariprasad Shenai { "SynLearned", 14, 1 }, 4852d277b3bSHariprasad Shenai { "SetDelEntry", 13, 1 }, 4862d277b3bSHariprasad Shenai { "SetInvEntry", 12, 1 }, 4872d277b3bSHariprasad Shenai { "CpcmdDvld", 11, 1 }, 4882d277b3bSHariprasad Shenai { "CpcmdSave", 10, 1 }, 4892d277b3bSHariprasad Shenai { "RxPstructsFull", 8, 2 }, 4902d277b3bSHariprasad Shenai { "EpcmdDvld", 7, 1 }, 4912d277b3bSHariprasad Shenai { "EpcmdFlush", 6, 1 }, 4922d277b3bSHariprasad Shenai { "EpcmdTrimPrefix", 5, 1 }, 4932d277b3bSHariprasad Shenai { "EpcmdTrimPostfix", 4, 1 }, 4942d277b3bSHariprasad Shenai { "ERssIp4Pkt", 3, 1 }, 4952d277b3bSHariprasad Shenai { "ERssIp6Pkt", 2, 1 }, 4962d277b3bSHariprasad Shenai { "ERssTcpUdpPkt", 1, 1 }, 4972d277b3bSHariprasad Shenai { "ERssFceFipPkt", 0, 1 }, 4982d277b3bSHariprasad Shenai { NULL } 4992d277b3bSHariprasad Shenai }; 5002d277b3bSHariprasad Shenai const u64 *p = v; 5012d277b3bSHariprasad Shenai 5022d277b3bSHariprasad Shenai if (idx) 5032d277b3bSHariprasad Shenai seq_putc(seq, '\n'); 5042d277b3bSHariprasad Shenai field_desc_show(seq, p[0], tp_la0); 5052d277b3bSHariprasad Shenai if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL) 5062d277b3bSHariprasad Shenai field_desc_show(seq, p[1], (p[0] & BIT(17)) ? tp_la2 : tp_la1); 5072d277b3bSHariprasad Shenai return 0; 5082d277b3bSHariprasad Shenai } 5092d277b3bSHariprasad Shenai 5102d277b3bSHariprasad Shenai static int tp_la_open(struct inode *inode, struct file *file) 5112d277b3bSHariprasad Shenai { 5122d277b3bSHariprasad Shenai struct seq_tab *p; 5132d277b3bSHariprasad Shenai struct adapter *adap = inode->i_private; 5142d277b3bSHariprasad Shenai 5152d277b3bSHariprasad Shenai switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) { 5162d277b3bSHariprasad Shenai case 2: 5172d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 5182d277b3bSHariprasad Shenai tp_la_show2); 5192d277b3bSHariprasad Shenai break; 5202d277b3bSHariprasad Shenai case 3: 5212d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0, 5222d277b3bSHariprasad Shenai tp_la_show3); 5232d277b3bSHariprasad Shenai break; 5242d277b3bSHariprasad Shenai default: 5252d277b3bSHariprasad Shenai p = seq_open_tab(file, TPLA_SIZE, sizeof(u64), 0, tp_la_show); 5262d277b3bSHariprasad Shenai } 5272d277b3bSHariprasad Shenai if (!p) 5282d277b3bSHariprasad Shenai return -ENOMEM; 5292d277b3bSHariprasad Shenai 5302d277b3bSHariprasad Shenai t4_tp_read_la(adap, (u64 *)p->data, NULL); 5312d277b3bSHariprasad Shenai return 0; 5322d277b3bSHariprasad Shenai } 5332d277b3bSHariprasad Shenai 5342d277b3bSHariprasad Shenai static ssize_t tp_la_write(struct file *file, const char __user *buf, 5352d277b3bSHariprasad Shenai size_t count, loff_t *pos) 5362d277b3bSHariprasad Shenai { 5372d277b3bSHariprasad Shenai int err; 5382d277b3bSHariprasad Shenai char s[32]; 5392d277b3bSHariprasad Shenai unsigned long val; 5402d277b3bSHariprasad Shenai size_t size = min(sizeof(s) - 1, count); 5412d277b3bSHariprasad Shenai struct adapter *adap = FILE_DATA(file)->i_private; 5422d277b3bSHariprasad Shenai 5432d277b3bSHariprasad Shenai if (copy_from_user(s, buf, size)) 5442d277b3bSHariprasad Shenai return -EFAULT; 5452d277b3bSHariprasad Shenai s[size] = '\0'; 5462d277b3bSHariprasad Shenai err = kstrtoul(s, 0, &val); 5472d277b3bSHariprasad Shenai if (err) 5482d277b3bSHariprasad Shenai return err; 5492d277b3bSHariprasad Shenai if (val > 0xffff) 5502d277b3bSHariprasad Shenai return -EINVAL; 5512d277b3bSHariprasad Shenai adap->params.tp.la_mask = val << 16; 5522d277b3bSHariprasad Shenai t4_set_reg_field(adap, TP_DBG_LA_CONFIG_A, 0xffff0000U, 5532d277b3bSHariprasad Shenai adap->params.tp.la_mask); 5542d277b3bSHariprasad Shenai return count; 5552d277b3bSHariprasad Shenai } 5562d277b3bSHariprasad Shenai 5572d277b3bSHariprasad Shenai static const struct file_operations tp_la_fops = { 5582d277b3bSHariprasad Shenai .owner = THIS_MODULE, 5592d277b3bSHariprasad Shenai .open = tp_la_open, 5602d277b3bSHariprasad Shenai .read = seq_read, 5612d277b3bSHariprasad Shenai .llseek = seq_lseek, 5622d277b3bSHariprasad Shenai .release = seq_release_private, 5632d277b3bSHariprasad Shenai .write = tp_la_write 5642d277b3bSHariprasad Shenai }; 5652d277b3bSHariprasad Shenai 566797ff0f5SHariprasad Shenai static int ulprx_la_show(struct seq_file *seq, void *v, int idx) 567797ff0f5SHariprasad Shenai { 568797ff0f5SHariprasad Shenai const u32 *p = v; 569797ff0f5SHariprasad Shenai 570797ff0f5SHariprasad Shenai if (v == SEQ_START_TOKEN) 571797ff0f5SHariprasad Shenai seq_puts(seq, " Pcmd Type Message" 572797ff0f5SHariprasad Shenai " Data\n"); 573797ff0f5SHariprasad Shenai else 574797ff0f5SHariprasad Shenai seq_printf(seq, "%08x%08x %4x %08x %08x%08x%08x%08x\n", 575797ff0f5SHariprasad Shenai p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]); 576797ff0f5SHariprasad Shenai return 0; 577797ff0f5SHariprasad Shenai } 578797ff0f5SHariprasad Shenai 579797ff0f5SHariprasad Shenai static int ulprx_la_open(struct inode *inode, struct file *file) 580797ff0f5SHariprasad Shenai { 581797ff0f5SHariprasad Shenai struct seq_tab *p; 582797ff0f5SHariprasad Shenai struct adapter *adap = inode->i_private; 583797ff0f5SHariprasad Shenai 584797ff0f5SHariprasad Shenai p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1, 585797ff0f5SHariprasad Shenai ulprx_la_show); 586797ff0f5SHariprasad Shenai if (!p) 587797ff0f5SHariprasad Shenai return -ENOMEM; 588797ff0f5SHariprasad Shenai 589797ff0f5SHariprasad Shenai t4_ulprx_read_la(adap, (u32 *)p->data); 590797ff0f5SHariprasad Shenai return 0; 591797ff0f5SHariprasad Shenai } 592797ff0f5SHariprasad Shenai 593797ff0f5SHariprasad Shenai static const struct file_operations ulprx_la_fops = { 594797ff0f5SHariprasad Shenai .owner = THIS_MODULE, 595797ff0f5SHariprasad Shenai .open = ulprx_la_open, 596797ff0f5SHariprasad Shenai .read = seq_read, 597797ff0f5SHariprasad Shenai .llseek = seq_lseek, 598797ff0f5SHariprasad Shenai .release = seq_release_private 599797ff0f5SHariprasad Shenai }; 600797ff0f5SHariprasad Shenai 601b3bbe36aSHariprasad Shenai /* Show the PM memory stats. These stats include: 602b3bbe36aSHariprasad Shenai * 603b3bbe36aSHariprasad Shenai * TX: 604b3bbe36aSHariprasad Shenai * Read: memory read operation 605b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 606b3bbe36aSHariprasad Shenai * Bypass + mem: cut-through and save copy 607b3bbe36aSHariprasad Shenai * 608b3bbe36aSHariprasad Shenai * RX: 609b3bbe36aSHariprasad Shenai * Read: memory read 610b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 611b3bbe36aSHariprasad Shenai * Flush: payload trim or drop 612b3bbe36aSHariprasad Shenai */ 613b3bbe36aSHariprasad Shenai static int pm_stats_show(struct seq_file *seq, void *v) 614b3bbe36aSHariprasad Shenai { 615b3bbe36aSHariprasad Shenai static const char * const tx_pm_stats[] = { 616b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Bypass + mem:" 617b3bbe36aSHariprasad Shenai }; 618b3bbe36aSHariprasad Shenai static const char * const rx_pm_stats[] = { 619b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Flush:" 620b3bbe36aSHariprasad Shenai }; 621b3bbe36aSHariprasad Shenai 622b3bbe36aSHariprasad Shenai int i; 623b3bbe36aSHariprasad Shenai u32 tx_cnt[PM_NSTATS], rx_cnt[PM_NSTATS]; 624b3bbe36aSHariprasad Shenai u64 tx_cyc[PM_NSTATS], rx_cyc[PM_NSTATS]; 625b3bbe36aSHariprasad Shenai struct adapter *adap = seq->private; 626b3bbe36aSHariprasad Shenai 627b3bbe36aSHariprasad Shenai t4_pmtx_get_stats(adap, tx_cnt, tx_cyc); 628b3bbe36aSHariprasad Shenai t4_pmrx_get_stats(adap, rx_cnt, rx_cyc); 629b3bbe36aSHariprasad Shenai 630b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Tx pcmds", "Tx bytes"); 631b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 632b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 633b3bbe36aSHariprasad Shenai tx_pm_stats[i], tx_cnt[i], tx_cyc[i]); 634b3bbe36aSHariprasad Shenai 635b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Rx pcmds", "Rx bytes"); 636b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 637b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 638b3bbe36aSHariprasad Shenai rx_pm_stats[i], rx_cnt[i], rx_cyc[i]); 639b3bbe36aSHariprasad Shenai return 0; 640b3bbe36aSHariprasad Shenai } 641b3bbe36aSHariprasad Shenai 642b3bbe36aSHariprasad Shenai static int pm_stats_open(struct inode *inode, struct file *file) 643b3bbe36aSHariprasad Shenai { 644b3bbe36aSHariprasad Shenai return single_open(file, pm_stats_show, inode->i_private); 645b3bbe36aSHariprasad Shenai } 646b3bbe36aSHariprasad Shenai 647b3bbe36aSHariprasad Shenai static ssize_t pm_stats_clear(struct file *file, const char __user *buf, 648b3bbe36aSHariprasad Shenai size_t count, loff_t *pos) 649b3bbe36aSHariprasad Shenai { 650b3bbe36aSHariprasad Shenai struct adapter *adap = FILE_DATA(file)->i_private; 651b3bbe36aSHariprasad Shenai 652b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0); 653b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0); 654b3bbe36aSHariprasad Shenai return count; 655b3bbe36aSHariprasad Shenai } 656b3bbe36aSHariprasad Shenai 657b3bbe36aSHariprasad Shenai static const struct file_operations pm_stats_debugfs_fops = { 658b3bbe36aSHariprasad Shenai .owner = THIS_MODULE, 659b3bbe36aSHariprasad Shenai .open = pm_stats_open, 660b3bbe36aSHariprasad Shenai .read = seq_read, 661b3bbe36aSHariprasad Shenai .llseek = seq_lseek, 662b3bbe36aSHariprasad Shenai .release = single_release, 663b3bbe36aSHariprasad Shenai .write = pm_stats_clear 664b3bbe36aSHariprasad Shenai }; 665b3bbe36aSHariprasad Shenai 666b58b6676SHariprasad Shenai /* Format a value in a unit that differs from the value's native unit by the 667b58b6676SHariprasad Shenai * given factor. 668b58b6676SHariprasad Shenai */ 669b58b6676SHariprasad Shenai static char *unit_conv(char *buf, size_t len, unsigned int val, 670b58b6676SHariprasad Shenai unsigned int factor) 671b58b6676SHariprasad Shenai { 672b58b6676SHariprasad Shenai unsigned int rem = val % factor; 673b58b6676SHariprasad Shenai 674b58b6676SHariprasad Shenai if (rem == 0) { 675b58b6676SHariprasad Shenai snprintf(buf, len, "%u", val / factor); 676b58b6676SHariprasad Shenai } else { 677b58b6676SHariprasad Shenai while (rem % 10 == 0) 678b58b6676SHariprasad Shenai rem /= 10; 679b58b6676SHariprasad Shenai snprintf(buf, len, "%u.%u", val / factor, rem); 680b58b6676SHariprasad Shenai } 681b58b6676SHariprasad Shenai return buf; 682b58b6676SHariprasad Shenai } 683b58b6676SHariprasad Shenai 684b58b6676SHariprasad Shenai static int clk_show(struct seq_file *seq, void *v) 685b58b6676SHariprasad Shenai { 686b58b6676SHariprasad Shenai char buf[32]; 687b58b6676SHariprasad Shenai struct adapter *adap = seq->private; 688b58b6676SHariprasad Shenai unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk; /* in ps */ 689b58b6676SHariprasad Shenai u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A); 690b58b6676SHariprasad Shenai unsigned int tre = TIMERRESOLUTION_G(res); 691b58b6676SHariprasad Shenai unsigned int dack_re = DELAYEDACKRESOLUTION_G(res); 692b58b6676SHariprasad Shenai unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */ 693b58b6676SHariprasad Shenai 694b58b6676SHariprasad Shenai seq_printf(seq, "Core clock period: %s ns\n", 695b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), cclk_ps, 1000)); 696b58b6676SHariprasad Shenai seq_printf(seq, "TP timer tick: %s us\n", 697b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000)); 698b58b6676SHariprasad Shenai seq_printf(seq, "TCP timestamp tick: %s us\n", 699b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), 700b58b6676SHariprasad Shenai (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000)); 701b58b6676SHariprasad Shenai seq_printf(seq, "DACK tick: %s us\n", 702b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000)); 703b58b6676SHariprasad Shenai seq_printf(seq, "DACK timer: %u us\n", 704b58b6676SHariprasad Shenai ((cclk_ps << dack_re) / 1000000) * 705b58b6676SHariprasad Shenai t4_read_reg(adap, TP_DACK_TIMER_A)); 706b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit min: %llu us\n", 707b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A)); 708b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit max: %llu us\n", 709b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A)); 710b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer min: %llu us\n", 711b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A)); 712b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer max: %llu us\n", 713b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A)); 714b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive idle timer: %llu us\n", 715b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A)); 716b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive interval: %llu us\n", 717b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A)); 718b58b6676SHariprasad Shenai seq_printf(seq, "Initial SRTT: %llu us\n", 719b58b6676SHariprasad Shenai tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A))); 720b58b6676SHariprasad Shenai seq_printf(seq, "FINWAIT2 timer: %llu us\n", 721b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A)); 722b58b6676SHariprasad Shenai 723b58b6676SHariprasad Shenai return 0; 724b58b6676SHariprasad Shenai } 725b58b6676SHariprasad Shenai 726b58b6676SHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(clk); 727b58b6676SHariprasad Shenai 728f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 72949aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 73049aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 73149aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 73249aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 73349aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 73449aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 73549aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 73649aa284fSHariprasad Shenai }; 73749aa284fSHariprasad Shenai 73849aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 73949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 74049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 74149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 74249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 74349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 74449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 74549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 74649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 74749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 74849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 74949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 75049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 75149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 75249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 75349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 75449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 75549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 75649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 75749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 75849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 75949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 76049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 76149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 76249aa284fSHariprasad Shenai }; 76349aa284fSHariprasad Shenai 76449aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 76549aa284fSHariprasad Shenai */ 76649aa284fSHariprasad Shenai struct devlog_info { 76749aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 76849aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 76949aa284fSHariprasad Shenai struct fw_devlog_e log[0]; /* Firmware Device Log */ 77049aa284fSHariprasad Shenai }; 77149aa284fSHariprasad Shenai 77249aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 77349aa284fSHariprasad Shenai */ 77449aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 77549aa284fSHariprasad Shenai { 77649aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 77749aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 77849aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 77949aa284fSHariprasad Shenai else { 78049aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 78149aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 78249aa284fSHariprasad Shenai unsigned long index; 78349aa284fSHariprasad Shenai struct fw_devlog_e *e; 78449aa284fSHariprasad Shenai 78549aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 78649aa284fSHariprasad Shenai * entries. 78749aa284fSHariprasad Shenai */ 78849aa284fSHariprasad Shenai index = dinfo->first + fidx; 78949aa284fSHariprasad Shenai if (index >= dinfo->nentries) 79049aa284fSHariprasad Shenai index -= dinfo->nentries; 79149aa284fSHariprasad Shenai e = &dinfo->log[index]; 79249aa284fSHariprasad Shenai if (e->timestamp == 0) 79349aa284fSHariprasad Shenai return 0; 79449aa284fSHariprasad Shenai 79549aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 79649aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 79749aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 79849aa284fSHariprasad Shenai */ 79949aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 80049aa284fSHariprasad Shenai e->seqno, e->timestamp, 80149aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 80249aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 80349aa284fSHariprasad Shenai : "UNKNOWN"), 80449aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 80549aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 80649aa284fSHariprasad Shenai : "UNKNOWN")); 80749aa284fSHariprasad Shenai seq_printf(seq, e->fmt, e->params[0], e->params[1], 80849aa284fSHariprasad Shenai e->params[2], e->params[3], e->params[4], 80949aa284fSHariprasad Shenai e->params[5], e->params[6], e->params[7]); 81049aa284fSHariprasad Shenai } 81149aa284fSHariprasad Shenai return 0; 81249aa284fSHariprasad Shenai } 81349aa284fSHariprasad Shenai 81449aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 81549aa284fSHariprasad Shenai */ 81649aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 81749aa284fSHariprasad Shenai { 81849aa284fSHariprasad Shenai if (pos > dinfo->nentries) 81949aa284fSHariprasad Shenai return NULL; 82049aa284fSHariprasad Shenai 82149aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 82249aa284fSHariprasad Shenai } 82349aa284fSHariprasad Shenai 82449aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 82549aa284fSHariprasad Shenai { 82649aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 82749aa284fSHariprasad Shenai 82849aa284fSHariprasad Shenai return (*pos 82949aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 83049aa284fSHariprasad Shenai : SEQ_START_TOKEN); 83149aa284fSHariprasad Shenai } 83249aa284fSHariprasad Shenai 83349aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 83449aa284fSHariprasad Shenai { 83549aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 83649aa284fSHariprasad Shenai 83749aa284fSHariprasad Shenai (*pos)++; 83849aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 83949aa284fSHariprasad Shenai } 84049aa284fSHariprasad Shenai 84149aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 84249aa284fSHariprasad Shenai { 84349aa284fSHariprasad Shenai } 84449aa284fSHariprasad Shenai 84549aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 84649aa284fSHariprasad Shenai .start = devlog_start, 84749aa284fSHariprasad Shenai .next = devlog_next, 84849aa284fSHariprasad Shenai .stop = devlog_stop, 84949aa284fSHariprasad Shenai .show = devlog_show 85049aa284fSHariprasad Shenai }; 85149aa284fSHariprasad Shenai 85249aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 85349aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 85449aa284fSHariprasad Shenai */ 85549aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 85649aa284fSHariprasad Shenai { 85749aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 85849aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 85949aa284fSHariprasad Shenai struct devlog_info *dinfo; 86049aa284fSHariprasad Shenai unsigned int index; 86149aa284fSHariprasad Shenai u32 fseqno; 86249aa284fSHariprasad Shenai int ret; 86349aa284fSHariprasad Shenai 86449aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 86549aa284fSHariprasad Shenai */ 86649aa284fSHariprasad Shenai if (dparams->start == 0) 86749aa284fSHariprasad Shenai return -ENXIO; 86849aa284fSHariprasad Shenai 86949aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 87049aa284fSHariprasad Shenai * for the iterated call to our display function. 87149aa284fSHariprasad Shenai */ 87249aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 87349aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 87449aa284fSHariprasad Shenai if (!dinfo) 87549aa284fSHariprasad Shenai return -ENOMEM; 87649aa284fSHariprasad Shenai 87749aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 87849aa284fSHariprasad Shenai */ 87949aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 88049aa284fSHariprasad Shenai dinfo->first = 0; 88149aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 88249aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 88349aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 88449aa284fSHariprasad Shenai T4_MEMORY_READ); 88549aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 88649aa284fSHariprasad Shenai if (ret) { 88749aa284fSHariprasad Shenai seq_release_private(inode, file); 88849aa284fSHariprasad Shenai return ret; 88949aa284fSHariprasad Shenai } 89049aa284fSHariprasad Shenai 89149aa284fSHariprasad Shenai /* Translate log multi-byte integral elements into host native format 89249aa284fSHariprasad Shenai * and determine where the first entry in the log is. 89349aa284fSHariprasad Shenai */ 89449aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 89549aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 89649aa284fSHariprasad Shenai int i; 89749aa284fSHariprasad Shenai __u32 seqno; 89849aa284fSHariprasad Shenai 89949aa284fSHariprasad Shenai if (e->timestamp == 0) 90049aa284fSHariprasad Shenai continue; 90149aa284fSHariprasad Shenai 90249aa284fSHariprasad Shenai e->timestamp = (__force __be64)be64_to_cpu(e->timestamp); 90349aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 90449aa284fSHariprasad Shenai for (i = 0; i < 8; i++) 90549aa284fSHariprasad Shenai e->params[i] = 90649aa284fSHariprasad Shenai (__force __be32)be32_to_cpu(e->params[i]); 90749aa284fSHariprasad Shenai 90849aa284fSHariprasad Shenai if (seqno < fseqno) { 90949aa284fSHariprasad Shenai fseqno = seqno; 91049aa284fSHariprasad Shenai dinfo->first = index; 91149aa284fSHariprasad Shenai } 91249aa284fSHariprasad Shenai } 91349aa284fSHariprasad Shenai return 0; 91449aa284fSHariprasad Shenai } 91549aa284fSHariprasad Shenai 91649aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 91749aa284fSHariprasad Shenai .owner = THIS_MODULE, 91849aa284fSHariprasad Shenai .open = devlog_open, 91949aa284fSHariprasad Shenai .read = seq_read, 92049aa284fSHariprasad Shenai .llseek = seq_lseek, 92149aa284fSHariprasad Shenai .release = seq_release_private 92249aa284fSHariprasad Shenai }; 92349aa284fSHariprasad Shenai 924bf7c781dSHariprasad Shenai static int mbox_show(struct seq_file *seq, void *v) 925bf7c781dSHariprasad Shenai { 926bf7c781dSHariprasad Shenai static const char * const owner[] = { "none", "FW", "driver", 927bf7c781dSHariprasad Shenai "unknown" }; 928bf7c781dSHariprasad Shenai 929bf7c781dSHariprasad Shenai int i; 930bf7c781dSHariprasad Shenai unsigned int mbox = (uintptr_t)seq->private & 7; 931bf7c781dSHariprasad Shenai struct adapter *adap = seq->private - mbox; 932bf7c781dSHariprasad Shenai void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 933bf7c781dSHariprasad Shenai unsigned int ctrl_reg = (is_t4(adap->params.chip) 934bf7c781dSHariprasad Shenai ? CIM_PF_MAILBOX_CTRL_A 935bf7c781dSHariprasad Shenai : CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A); 936bf7c781dSHariprasad Shenai void __iomem *ctrl = adap->regs + PF_REG(mbox, ctrl_reg); 937bf7c781dSHariprasad Shenai 938bf7c781dSHariprasad Shenai i = MBOWNER_G(readl(ctrl)); 939bf7c781dSHariprasad Shenai seq_printf(seq, "mailbox owned by %s\n\n", owner[i]); 940bf7c781dSHariprasad Shenai 941bf7c781dSHariprasad Shenai for (i = 0; i < MBOX_LEN; i += 8) 942bf7c781dSHariprasad Shenai seq_printf(seq, "%016llx\n", 943bf7c781dSHariprasad Shenai (unsigned long long)readq(addr + i)); 944bf7c781dSHariprasad Shenai return 0; 945bf7c781dSHariprasad Shenai } 946bf7c781dSHariprasad Shenai 947bf7c781dSHariprasad Shenai static int mbox_open(struct inode *inode, struct file *file) 948bf7c781dSHariprasad Shenai { 949bf7c781dSHariprasad Shenai return single_open(file, mbox_show, inode->i_private); 950bf7c781dSHariprasad Shenai } 951bf7c781dSHariprasad Shenai 952bf7c781dSHariprasad Shenai static ssize_t mbox_write(struct file *file, const char __user *buf, 953bf7c781dSHariprasad Shenai size_t count, loff_t *pos) 954bf7c781dSHariprasad Shenai { 955bf7c781dSHariprasad Shenai int i; 956bf7c781dSHariprasad Shenai char c = '\n', s[256]; 957bf7c781dSHariprasad Shenai unsigned long long data[8]; 958bf7c781dSHariprasad Shenai const struct inode *ino; 959bf7c781dSHariprasad Shenai unsigned int mbox; 960bf7c781dSHariprasad Shenai struct adapter *adap; 961bf7c781dSHariprasad Shenai void __iomem *addr; 962bf7c781dSHariprasad Shenai void __iomem *ctrl; 963bf7c781dSHariprasad Shenai 964bf7c781dSHariprasad Shenai if (count > sizeof(s) - 1 || !count) 965bf7c781dSHariprasad Shenai return -EINVAL; 966bf7c781dSHariprasad Shenai if (copy_from_user(s, buf, count)) 967bf7c781dSHariprasad Shenai return -EFAULT; 968bf7c781dSHariprasad Shenai s[count] = '\0'; 969bf7c781dSHariprasad Shenai 970bf7c781dSHariprasad Shenai if (sscanf(s, "%llx %llx %llx %llx %llx %llx %llx %llx%c", &data[0], 971bf7c781dSHariprasad Shenai &data[1], &data[2], &data[3], &data[4], &data[5], &data[6], 972bf7c781dSHariprasad Shenai &data[7], &c) < 8 || c != '\n') 973bf7c781dSHariprasad Shenai return -EINVAL; 974bf7c781dSHariprasad Shenai 975bf7c781dSHariprasad Shenai ino = FILE_DATA(file); 976bf7c781dSHariprasad Shenai mbox = (uintptr_t)ino->i_private & 7; 977bf7c781dSHariprasad Shenai adap = ino->i_private - mbox; 978bf7c781dSHariprasad Shenai addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); 979bf7c781dSHariprasad Shenai ctrl = addr + MBOX_LEN; 980bf7c781dSHariprasad Shenai 981bf7c781dSHariprasad Shenai if (MBOWNER_G(readl(ctrl)) != X_MBOWNER_PL) 982bf7c781dSHariprasad Shenai return -EBUSY; 983bf7c781dSHariprasad Shenai 984bf7c781dSHariprasad Shenai for (i = 0; i < 8; i++) 985bf7c781dSHariprasad Shenai writeq(data[i], addr + 8 * i); 986bf7c781dSHariprasad Shenai 987bf7c781dSHariprasad Shenai writel(MBMSGVALID_F | MBOWNER_V(X_MBOWNER_FW), ctrl); 988bf7c781dSHariprasad Shenai return count; 989bf7c781dSHariprasad Shenai } 990bf7c781dSHariprasad Shenai 991bf7c781dSHariprasad Shenai static const struct file_operations mbox_debugfs_fops = { 992bf7c781dSHariprasad Shenai .owner = THIS_MODULE, 993bf7c781dSHariprasad Shenai .open = mbox_open, 994bf7c781dSHariprasad Shenai .read = seq_read, 995bf7c781dSHariprasad Shenai .llseek = seq_lseek, 996bf7c781dSHariprasad Shenai .release = single_release, 997bf7c781dSHariprasad Shenai .write = mbox_write 998bf7c781dSHariprasad Shenai }; 999bf7c781dSHariprasad Shenai 100049216c1cSHariprasad Shenai static ssize_t flash_read(struct file *file, char __user *buf, size_t count, 100149216c1cSHariprasad Shenai loff_t *ppos) 100249216c1cSHariprasad Shenai { 100349216c1cSHariprasad Shenai loff_t pos = *ppos; 100449216c1cSHariprasad Shenai loff_t avail = FILE_DATA(file)->i_size; 100549216c1cSHariprasad Shenai struct adapter *adap = file->private_data; 100649216c1cSHariprasad Shenai 100749216c1cSHariprasad Shenai if (pos < 0) 100849216c1cSHariprasad Shenai return -EINVAL; 100949216c1cSHariprasad Shenai if (pos >= avail) 101049216c1cSHariprasad Shenai return 0; 101149216c1cSHariprasad Shenai if (count > avail - pos) 101249216c1cSHariprasad Shenai count = avail - pos; 101349216c1cSHariprasad Shenai 101449216c1cSHariprasad Shenai while (count) { 101549216c1cSHariprasad Shenai size_t len; 101649216c1cSHariprasad Shenai int ret, ofst; 101749216c1cSHariprasad Shenai u8 data[256]; 101849216c1cSHariprasad Shenai 101949216c1cSHariprasad Shenai ofst = pos & 3; 102049216c1cSHariprasad Shenai len = min(count + ofst, sizeof(data)); 102149216c1cSHariprasad Shenai ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4, 102249216c1cSHariprasad Shenai (u32 *)data, 1); 102349216c1cSHariprasad Shenai if (ret) 102449216c1cSHariprasad Shenai return ret; 102549216c1cSHariprasad Shenai 102649216c1cSHariprasad Shenai len -= ofst; 102749216c1cSHariprasad Shenai if (copy_to_user(buf, data + ofst, len)) 102849216c1cSHariprasad Shenai return -EFAULT; 102949216c1cSHariprasad Shenai 103049216c1cSHariprasad Shenai buf += len; 103149216c1cSHariprasad Shenai pos += len; 103249216c1cSHariprasad Shenai count -= len; 103349216c1cSHariprasad Shenai } 103449216c1cSHariprasad Shenai count = pos - *ppos; 103549216c1cSHariprasad Shenai *ppos = pos; 103649216c1cSHariprasad Shenai return count; 103749216c1cSHariprasad Shenai } 103849216c1cSHariprasad Shenai 103949216c1cSHariprasad Shenai static const struct file_operations flash_debugfs_fops = { 104049216c1cSHariprasad Shenai .owner = THIS_MODULE, 104149216c1cSHariprasad Shenai .open = mem_open, 104249216c1cSHariprasad Shenai .read = flash_read, 104349216c1cSHariprasad Shenai }; 104449216c1cSHariprasad Shenai 1045ef82f662SHariprasad Shenai static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask) 1046ef82f662SHariprasad Shenai { 1047ef82f662SHariprasad Shenai *mask = x | y; 1048ef82f662SHariprasad Shenai y = (__force u64)cpu_to_be64(y); 1049ef82f662SHariprasad Shenai memcpy(addr, (char *)&y + 2, ETH_ALEN); 1050ef82f662SHariprasad Shenai } 1051ef82f662SHariprasad Shenai 1052ef82f662SHariprasad Shenai static int mps_tcam_show(struct seq_file *seq, void *v) 1053ef82f662SHariprasad Shenai { 1054ef82f662SHariprasad Shenai if (v == SEQ_START_TOKEN) 1055ef82f662SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask Vld Ports PF" 1056ef82f662SHariprasad Shenai " VF Replication " 1057ef82f662SHariprasad Shenai "P0 P1 P2 P3 ML\n"); 1058ef82f662SHariprasad Shenai else { 1059ef82f662SHariprasad Shenai u64 mask; 1060ef82f662SHariprasad Shenai u8 addr[ETH_ALEN]; 1061ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 1062ef82f662SHariprasad Shenai unsigned int idx = (uintptr_t)v - 2; 1063ef82f662SHariprasad Shenai u64 tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx)); 1064ef82f662SHariprasad Shenai u64 tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx)); 1065ef82f662SHariprasad Shenai u32 cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx)); 1066ef82f662SHariprasad Shenai u32 cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx)); 1067ef82f662SHariprasad Shenai u32 rplc[4] = {0, 0, 0, 0}; 1068ef82f662SHariprasad Shenai 1069ef82f662SHariprasad Shenai if (tcamx & tcamy) { 1070ef82f662SHariprasad Shenai seq_printf(seq, "%3u -\n", idx); 1071ef82f662SHariprasad Shenai goto out; 1072ef82f662SHariprasad Shenai } 1073ef82f662SHariprasad Shenai 1074ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) { 1075ef82f662SHariprasad Shenai struct fw_ldst_cmd ldst_cmd; 1076ef82f662SHariprasad Shenai int ret; 1077ef82f662SHariprasad Shenai 1078ef82f662SHariprasad Shenai memset(&ldst_cmd, 0, sizeof(ldst_cmd)); 1079ef82f662SHariprasad Shenai ldst_cmd.op_to_addrspace = 1080ef82f662SHariprasad Shenai htonl(FW_CMD_OP_V(FW_LDST_CMD) | 1081ef82f662SHariprasad Shenai FW_CMD_REQUEST_F | 1082ef82f662SHariprasad Shenai FW_CMD_READ_F | 1083ef82f662SHariprasad Shenai FW_LDST_CMD_ADDRSPACE_V( 1084ef82f662SHariprasad Shenai FW_LDST_ADDRSPC_MPS)); 1085ef82f662SHariprasad Shenai ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd)); 1086ef82f662SHariprasad Shenai ldst_cmd.u.mps.fid_ctl = 1087ef82f662SHariprasad Shenai htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) | 1088ef82f662SHariprasad Shenai FW_LDST_CMD_CTL_V(idx)); 1089ef82f662SHariprasad Shenai ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, 1090ef82f662SHariprasad Shenai sizeof(ldst_cmd), &ldst_cmd); 1091ef82f662SHariprasad Shenai if (ret) 1092ef82f662SHariprasad Shenai dev_warn(adap->pdev_dev, "Can't read MPS " 1093ef82f662SHariprasad Shenai "replication map for idx %d: %d\n", 1094ef82f662SHariprasad Shenai idx, -ret); 1095ef82f662SHariprasad Shenai else { 1096ef82f662SHariprasad Shenai rplc[0] = ntohl(ldst_cmd.u.mps.rplc31_0); 1097ef82f662SHariprasad Shenai rplc[1] = ntohl(ldst_cmd.u.mps.rplc63_32); 1098ef82f662SHariprasad Shenai rplc[2] = ntohl(ldst_cmd.u.mps.rplc95_64); 1099ef82f662SHariprasad Shenai rplc[3] = ntohl(ldst_cmd.u.mps.rplc127_96); 1100ef82f662SHariprasad Shenai } 1101ef82f662SHariprasad Shenai } 1102ef82f662SHariprasad Shenai 1103ef82f662SHariprasad Shenai tcamxy2valmask(tcamx, tcamy, addr, &mask); 1104ef82f662SHariprasad Shenai seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x %012llx" 1105ef82f662SHariprasad Shenai "%3c %#x%4u%4d", 1106ef82f662SHariprasad Shenai idx, addr[0], addr[1], addr[2], addr[3], addr[4], 1107ef82f662SHariprasad Shenai addr[5], (unsigned long long)mask, 1108ef82f662SHariprasad Shenai (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', PORTMAP_G(cls_hi), 1109ef82f662SHariprasad Shenai PF_G(cls_lo), 1110ef82f662SHariprasad Shenai (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1); 1111ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) 1112ef82f662SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x", 1113ef82f662SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 1114ef82f662SHariprasad Shenai else 1115ef82f662SHariprasad Shenai seq_printf(seq, "%36c", ' '); 1116ef82f662SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 1117ef82f662SHariprasad Shenai SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo), 1118ef82f662SHariprasad Shenai SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo), 1119ef82f662SHariprasad Shenai (cls_lo >> MULTILISTEN0_S) & 0xf); 1120ef82f662SHariprasad Shenai } 1121ef82f662SHariprasad Shenai out: return 0; 1122ef82f662SHariprasad Shenai } 1123ef82f662SHariprasad Shenai 1124ef82f662SHariprasad Shenai static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos) 1125ef82f662SHariprasad Shenai { 1126ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 1127ef82f662SHariprasad Shenai int max_mac_addr = is_t4(adap->params.chip) ? 1128ef82f662SHariprasad Shenai NUM_MPS_CLS_SRAM_L_INSTANCES : 1129ef82f662SHariprasad Shenai NUM_MPS_T5_CLS_SRAM_L_INSTANCES; 1130ef82f662SHariprasad Shenai return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL); 1131ef82f662SHariprasad Shenai } 1132ef82f662SHariprasad Shenai 1133ef82f662SHariprasad Shenai static void *mps_tcam_start(struct seq_file *seq, loff_t *pos) 1134ef82f662SHariprasad Shenai { 1135ef82f662SHariprasad Shenai return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN; 1136ef82f662SHariprasad Shenai } 1137ef82f662SHariprasad Shenai 1138ef82f662SHariprasad Shenai static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos) 1139ef82f662SHariprasad Shenai { 1140ef82f662SHariprasad Shenai ++*pos; 1141ef82f662SHariprasad Shenai return mps_tcam_get_idx(seq, *pos); 1142ef82f662SHariprasad Shenai } 1143ef82f662SHariprasad Shenai 1144ef82f662SHariprasad Shenai static void mps_tcam_stop(struct seq_file *seq, void *v) 1145ef82f662SHariprasad Shenai { 1146ef82f662SHariprasad Shenai } 1147ef82f662SHariprasad Shenai 1148ef82f662SHariprasad Shenai static const struct seq_operations mps_tcam_seq_ops = { 1149ef82f662SHariprasad Shenai .start = mps_tcam_start, 1150ef82f662SHariprasad Shenai .next = mps_tcam_next, 1151ef82f662SHariprasad Shenai .stop = mps_tcam_stop, 1152ef82f662SHariprasad Shenai .show = mps_tcam_show 1153ef82f662SHariprasad Shenai }; 1154ef82f662SHariprasad Shenai 1155ef82f662SHariprasad Shenai static int mps_tcam_open(struct inode *inode, struct file *file) 1156ef82f662SHariprasad Shenai { 1157ef82f662SHariprasad Shenai int res = seq_open(file, &mps_tcam_seq_ops); 1158ef82f662SHariprasad Shenai 1159ef82f662SHariprasad Shenai if (!res) { 1160ef82f662SHariprasad Shenai struct seq_file *seq = file->private_data; 1161ef82f662SHariprasad Shenai 1162ef82f662SHariprasad Shenai seq->private = inode->i_private; 1163ef82f662SHariprasad Shenai } 1164ef82f662SHariprasad Shenai return res; 1165ef82f662SHariprasad Shenai } 1166ef82f662SHariprasad Shenai 1167ef82f662SHariprasad Shenai static const struct file_operations mps_tcam_debugfs_fops = { 1168ef82f662SHariprasad Shenai .owner = THIS_MODULE, 1169ef82f662SHariprasad Shenai .open = mps_tcam_open, 1170ef82f662SHariprasad Shenai .read = seq_read, 1171ef82f662SHariprasad Shenai .llseek = seq_lseek, 1172ef82f662SHariprasad Shenai .release = seq_release, 1173ef82f662SHariprasad Shenai }; 1174ef82f662SHariprasad Shenai 117570a5f3bbSHariprasad Shenai /* Display various sensor information. 117670a5f3bbSHariprasad Shenai */ 117770a5f3bbSHariprasad Shenai static int sensors_show(struct seq_file *seq, void *v) 117870a5f3bbSHariprasad Shenai { 117970a5f3bbSHariprasad Shenai struct adapter *adap = seq->private; 118070a5f3bbSHariprasad Shenai u32 param[7], val[7]; 118170a5f3bbSHariprasad Shenai int ret; 118270a5f3bbSHariprasad Shenai 118370a5f3bbSHariprasad Shenai /* Note that if the sensors haven't been initialized and turned on 118470a5f3bbSHariprasad Shenai * we'll get values of 0, so treat those as "<unknown>" ... 118570a5f3bbSHariprasad Shenai */ 118670a5f3bbSHariprasad Shenai param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 118770a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 118870a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP)); 118970a5f3bbSHariprasad Shenai param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 119070a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 119170a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD)); 119270a5f3bbSHariprasad Shenai ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, 119370a5f3bbSHariprasad Shenai param, val); 119470a5f3bbSHariprasad Shenai 119570a5f3bbSHariprasad Shenai if (ret < 0 || val[0] == 0) 119670a5f3bbSHariprasad Shenai seq_puts(seq, "Temperature: <unknown>\n"); 119770a5f3bbSHariprasad Shenai else 119870a5f3bbSHariprasad Shenai seq_printf(seq, "Temperature: %dC\n", val[0]); 119970a5f3bbSHariprasad Shenai 120070a5f3bbSHariprasad Shenai if (ret < 0 || val[1] == 0) 120170a5f3bbSHariprasad Shenai seq_puts(seq, "Core VDD: <unknown>\n"); 120270a5f3bbSHariprasad Shenai else 120370a5f3bbSHariprasad Shenai seq_printf(seq, "Core VDD: %dmV\n", val[1]); 120470a5f3bbSHariprasad Shenai 120570a5f3bbSHariprasad Shenai return 0; 120670a5f3bbSHariprasad Shenai } 120770a5f3bbSHariprasad Shenai 120870a5f3bbSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(sensors); 120970a5f3bbSHariprasad Shenai 1210b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 1211b5a02f50SAnish Bhatt static int clip_tbl_open(struct inode *inode, struct file *file) 1212b5a02f50SAnish Bhatt { 1213b5a02f50SAnish Bhatt return single_open(file, clip_tbl_show, PDE_DATA(inode)); 1214b5a02f50SAnish Bhatt } 1215b5a02f50SAnish Bhatt 1216b5a02f50SAnish Bhatt static const struct file_operations clip_tbl_debugfs_fops = { 1217b5a02f50SAnish Bhatt .owner = THIS_MODULE, 1218b5a02f50SAnish Bhatt .open = clip_tbl_open, 1219b5a02f50SAnish Bhatt .read = seq_read, 1220b5a02f50SAnish Bhatt .llseek = seq_lseek, 1221b5a02f50SAnish Bhatt .release = single_release 1222b5a02f50SAnish Bhatt }; 1223b5a02f50SAnish Bhatt #endif 1224b5a02f50SAnish Bhatt 1225688ea5feSHariprasad Shenai /*RSS Table. 1226688ea5feSHariprasad Shenai */ 1227688ea5feSHariprasad Shenai 1228688ea5feSHariprasad Shenai static int rss_show(struct seq_file *seq, void *v, int idx) 1229688ea5feSHariprasad Shenai { 1230688ea5feSHariprasad Shenai u16 *entry = v; 1231688ea5feSHariprasad Shenai 1232688ea5feSHariprasad Shenai seq_printf(seq, "%4d: %4u %4u %4u %4u %4u %4u %4u %4u\n", 1233688ea5feSHariprasad Shenai idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4], 1234688ea5feSHariprasad Shenai entry[5], entry[6], entry[7]); 1235688ea5feSHariprasad Shenai return 0; 1236688ea5feSHariprasad Shenai } 1237688ea5feSHariprasad Shenai 1238688ea5feSHariprasad Shenai static int rss_open(struct inode *inode, struct file *file) 1239688ea5feSHariprasad Shenai { 1240688ea5feSHariprasad Shenai int ret; 1241688ea5feSHariprasad Shenai struct seq_tab *p; 1242688ea5feSHariprasad Shenai struct adapter *adap = inode->i_private; 1243688ea5feSHariprasad Shenai 1244688ea5feSHariprasad Shenai p = seq_open_tab(file, RSS_NENTRIES / 8, 8 * sizeof(u16), 0, rss_show); 1245688ea5feSHariprasad Shenai if (!p) 1246688ea5feSHariprasad Shenai return -ENOMEM; 1247688ea5feSHariprasad Shenai 1248688ea5feSHariprasad Shenai ret = t4_read_rss(adap, (u16 *)p->data); 1249688ea5feSHariprasad Shenai if (ret) 1250688ea5feSHariprasad Shenai seq_release_private(inode, file); 1251688ea5feSHariprasad Shenai 1252688ea5feSHariprasad Shenai return ret; 1253688ea5feSHariprasad Shenai } 1254688ea5feSHariprasad Shenai 1255688ea5feSHariprasad Shenai static const struct file_operations rss_debugfs_fops = { 1256688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1257688ea5feSHariprasad Shenai .open = rss_open, 1258688ea5feSHariprasad Shenai .read = seq_read, 1259688ea5feSHariprasad Shenai .llseek = seq_lseek, 1260688ea5feSHariprasad Shenai .release = seq_release_private 1261688ea5feSHariprasad Shenai }; 1262688ea5feSHariprasad Shenai 1263688ea5feSHariprasad Shenai /* RSS Configuration. 1264688ea5feSHariprasad Shenai */ 1265688ea5feSHariprasad Shenai 1266688ea5feSHariprasad Shenai /* Small utility function to return the strings "yes" or "no" if the supplied 1267688ea5feSHariprasad Shenai * argument is non-zero. 1268688ea5feSHariprasad Shenai */ 1269688ea5feSHariprasad Shenai static const char *yesno(int x) 1270688ea5feSHariprasad Shenai { 1271688ea5feSHariprasad Shenai static const char *yes = "yes"; 1272688ea5feSHariprasad Shenai static const char *no = "no"; 1273688ea5feSHariprasad Shenai 1274688ea5feSHariprasad Shenai return x ? yes : no; 1275688ea5feSHariprasad Shenai } 1276688ea5feSHariprasad Shenai 1277688ea5feSHariprasad Shenai static int rss_config_show(struct seq_file *seq, void *v) 1278688ea5feSHariprasad Shenai { 1279688ea5feSHariprasad Shenai struct adapter *adapter = seq->private; 1280688ea5feSHariprasad Shenai static const char * const keymode[] = { 1281688ea5feSHariprasad Shenai "global", 1282688ea5feSHariprasad Shenai "global and per-VF scramble", 1283688ea5feSHariprasad Shenai "per-PF and per-VF scramble", 1284688ea5feSHariprasad Shenai "per-VF and per-VF scramble", 1285688ea5feSHariprasad Shenai }; 1286688ea5feSHariprasad Shenai u32 rssconf; 1287688ea5feSHariprasad Shenai 1288688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A); 1289688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf); 1290688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv6: %3s\n", yesno(rssconf & 1291688ea5feSHariprasad Shenai TNL4TUPENIPV6_F)); 1292688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv6: %3s\n", yesno(rssconf & 1293688ea5feSHariprasad Shenai TNL2TUPENIPV6_F)); 1294688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv4: %3s\n", yesno(rssconf & 1295688ea5feSHariprasad Shenai TNL4TUPENIPV4_F)); 1296688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv4: %3s\n", yesno(rssconf & 1297688ea5feSHariprasad Shenai TNL2TUPENIPV4_F)); 1298688ea5feSHariprasad Shenai seq_printf(seq, " TnlTcpSel: %3s\n", yesno(rssconf & TNLTCPSEL_F)); 1299688ea5feSHariprasad Shenai seq_printf(seq, " TnlIp6Sel: %3s\n", yesno(rssconf & TNLIP6SEL_F)); 1300688ea5feSHariprasad Shenai seq_printf(seq, " TnlVrtSel: %3s\n", yesno(rssconf & TNLVRTSEL_F)); 1301688ea5feSHariprasad Shenai seq_printf(seq, " TnlMapEn: %3s\n", yesno(rssconf & TNLMAPEN_F)); 1302688ea5feSHariprasad Shenai seq_printf(seq, " OfdHashSave: %3s\n", yesno(rssconf & 1303688ea5feSHariprasad Shenai OFDHASHSAVE_F)); 1304688ea5feSHariprasad Shenai seq_printf(seq, " OfdVrtSel: %3s\n", yesno(rssconf & OFDVRTSEL_F)); 1305688ea5feSHariprasad Shenai seq_printf(seq, " OfdMapEn: %3s\n", yesno(rssconf & OFDMAPEN_F)); 1306688ea5feSHariprasad Shenai seq_printf(seq, " OfdLkpEn: %3s\n", yesno(rssconf & OFDLKPEN_F)); 1307688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 1308688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 1309688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv6: %3s\n", yesno(rssconf & 1310688ea5feSHariprasad Shenai SYN2TUPENIPV6_F)); 1311688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv4: %3s\n", yesno(rssconf & 1312688ea5feSHariprasad Shenai SYN4TUPENIPV4_F)); 1313688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv4: %3s\n", yesno(rssconf & 1314688ea5feSHariprasad Shenai SYN2TUPENIPV4_F)); 1315688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 1316688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 1317688ea5feSHariprasad Shenai seq_printf(seq, " SynIp6Sel: %3s\n", yesno(rssconf & SYNIP6SEL_F)); 1318688ea5feSHariprasad Shenai seq_printf(seq, " SynVrt6Sel: %3s\n", yesno(rssconf & SYNVRTSEL_F)); 1319688ea5feSHariprasad Shenai seq_printf(seq, " SynMapEn: %3s\n", yesno(rssconf & SYNMAPEN_F)); 1320688ea5feSHariprasad Shenai seq_printf(seq, " SynLkpEn: %3s\n", yesno(rssconf & SYNLKPEN_F)); 1321688ea5feSHariprasad Shenai seq_printf(seq, " ChnEn: %3s\n", yesno(rssconf & 1322688ea5feSHariprasad Shenai CHANNELENABLE_F)); 1323688ea5feSHariprasad Shenai seq_printf(seq, " PrtEn: %3s\n", yesno(rssconf & 1324688ea5feSHariprasad Shenai PORTENABLE_F)); 1325688ea5feSHariprasad Shenai seq_printf(seq, " TnlAllLkp: %3s\n", yesno(rssconf & 1326688ea5feSHariprasad Shenai TNLALLLOOKUP_F)); 1327688ea5feSHariprasad Shenai seq_printf(seq, " VrtEn: %3s\n", yesno(rssconf & 1328688ea5feSHariprasad Shenai VIRTENABLE_F)); 1329688ea5feSHariprasad Shenai seq_printf(seq, " CngEn: %3s\n", yesno(rssconf & 1330688ea5feSHariprasad Shenai CONGESTIONENABLE_F)); 1331688ea5feSHariprasad Shenai seq_printf(seq, " HashToeplitz: %3s\n", yesno(rssconf & 1332688ea5feSHariprasad Shenai HASHTOEPLITZ_F)); 1333688ea5feSHariprasad Shenai seq_printf(seq, " Udp4En: %3s\n", yesno(rssconf & UDPENABLE_F)); 1334688ea5feSHariprasad Shenai seq_printf(seq, " Disable: %3s\n", yesno(rssconf & DISABLE_F)); 1335688ea5feSHariprasad Shenai 1336688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1337688ea5feSHariprasad Shenai 1338688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A); 1339688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf); 1340688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1341688ea5feSHariprasad Shenai seq_printf(seq, " MaskFilter: %3d\n", MASKFILTER_G(rssconf)); 1342688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 1343688ea5feSHariprasad Shenai seq_printf(seq, " HashAll: %3s\n", 1344688ea5feSHariprasad Shenai yesno(rssconf & HASHALL_F)); 1345688ea5feSHariprasad Shenai seq_printf(seq, " HashEth: %3s\n", 1346688ea5feSHariprasad Shenai yesno(rssconf & HASHETH_F)); 1347688ea5feSHariprasad Shenai } 1348688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 1349688ea5feSHariprasad Shenai 1350688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1351688ea5feSHariprasad Shenai 1352688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A); 1353688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf); 1354688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1355688ea5feSHariprasad Shenai seq_printf(seq, " RRCplMapEn: %3s\n", yesno(rssconf & 1356688ea5feSHariprasad Shenai RRCPLMAPEN_F)); 1357688ea5feSHariprasad Shenai seq_printf(seq, " RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf)); 1358688ea5feSHariprasad Shenai 1359688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1360688ea5feSHariprasad Shenai 1361688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A); 1362688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf); 1363688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1364688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 1365688ea5feSHariprasad Shenai 1366688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1367688ea5feSHariprasad Shenai 1368688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A); 1369688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf); 1370688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 1371688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddrX: %3d\n", 1372688ea5feSHariprasad Shenai KEYWRADDRX_G(rssconf)); 1373688ea5feSHariprasad Shenai seq_printf(seq, " KeyExtend: %3s\n", 1374688ea5feSHariprasad Shenai yesno(rssconf & KEYEXTEND_F)); 1375688ea5feSHariprasad Shenai } 1376688ea5feSHariprasad Shenai seq_printf(seq, " VfRdRg: %3s\n", yesno(rssconf & VFRDRG_F)); 1377688ea5feSHariprasad Shenai seq_printf(seq, " VfRdEn: %3s\n", yesno(rssconf & VFRDEN_F)); 1378688ea5feSHariprasad Shenai seq_printf(seq, " VfPerrEn: %3s\n", yesno(rssconf & VFPERREN_F)); 1379688ea5feSHariprasad Shenai seq_printf(seq, " KeyPerrEn: %3s\n", yesno(rssconf & KEYPERREN_F)); 1380688ea5feSHariprasad Shenai seq_printf(seq, " DisVfVlan: %3s\n", yesno(rssconf & 1381688ea5feSHariprasad Shenai DISABLEVLAN_F)); 1382688ea5feSHariprasad Shenai seq_printf(seq, " EnUpSwt: %3s\n", yesno(rssconf & ENABLEUP0_F)); 1383688ea5feSHariprasad Shenai seq_printf(seq, " HashDelay: %3d\n", HASHDELAY_G(rssconf)); 1384688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5) 1385688ea5feSHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", VFWRADDR_G(rssconf)); 1386688ea5feSHariprasad Shenai seq_printf(seq, " KeyMode: %s\n", keymode[KEYMODE_G(rssconf)]); 1387688ea5feSHariprasad Shenai seq_printf(seq, " VfWrEn: %3s\n", yesno(rssconf & VFWREN_F)); 1388688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrEn: %3s\n", yesno(rssconf & KEYWREN_F)); 1389688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddr: %3d\n", KEYWRADDR_G(rssconf)); 1390688ea5feSHariprasad Shenai 1391688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1392688ea5feSHariprasad Shenai 1393688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A); 1394688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf); 1395688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount3: %3s\n", yesno(rssconf & CHNCOUNT3_F)); 1396688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount2: %3s\n", yesno(rssconf & CHNCOUNT2_F)); 1397688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount1: %3s\n", yesno(rssconf & CHNCOUNT1_F)); 1398688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount0: %3s\n", yesno(rssconf & CHNCOUNT0_F)); 1399688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow3: %3s\n", yesno(rssconf & 1400688ea5feSHariprasad Shenai CHNUNDFLOW3_F)); 1401688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow2: %3s\n", yesno(rssconf & 1402688ea5feSHariprasad Shenai CHNUNDFLOW2_F)); 1403688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow1: %3s\n", yesno(rssconf & 1404688ea5feSHariprasad Shenai CHNUNDFLOW1_F)); 1405688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow0: %3s\n", yesno(rssconf & 1406688ea5feSHariprasad Shenai CHNUNDFLOW0_F)); 1407688ea5feSHariprasad Shenai seq_printf(seq, " RstChn3: %3s\n", yesno(rssconf & RSTCHN3_F)); 1408688ea5feSHariprasad Shenai seq_printf(seq, " RstChn2: %3s\n", yesno(rssconf & RSTCHN2_F)); 1409688ea5feSHariprasad Shenai seq_printf(seq, " RstChn1: %3s\n", yesno(rssconf & RSTCHN1_F)); 1410688ea5feSHariprasad Shenai seq_printf(seq, " RstChn0: %3s\n", yesno(rssconf & RSTCHN0_F)); 1411688ea5feSHariprasad Shenai seq_printf(seq, " UpdVld: %3s\n", yesno(rssconf & UPDVLD_F)); 1412688ea5feSHariprasad Shenai seq_printf(seq, " Xoff: %3s\n", yesno(rssconf & XOFF_F)); 1413688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn3: %3s\n", yesno(rssconf & UPDCHN3_F)); 1414688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn2: %3s\n", yesno(rssconf & UPDCHN2_F)); 1415688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn1: %3s\n", yesno(rssconf & UPDCHN1_F)); 1416688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn0: %3s\n", yesno(rssconf & UPDCHN0_F)); 1417688ea5feSHariprasad Shenai seq_printf(seq, " Queue: %3d\n", QUEUE_G(rssconf)); 1418688ea5feSHariprasad Shenai 1419688ea5feSHariprasad Shenai return 0; 1420688ea5feSHariprasad Shenai } 1421688ea5feSHariprasad Shenai 1422688ea5feSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(rss_config); 1423688ea5feSHariprasad Shenai 1424688ea5feSHariprasad Shenai /* RSS Secret Key. 1425688ea5feSHariprasad Shenai */ 1426688ea5feSHariprasad Shenai 1427688ea5feSHariprasad Shenai static int rss_key_show(struct seq_file *seq, void *v) 1428688ea5feSHariprasad Shenai { 1429688ea5feSHariprasad Shenai u32 key[10]; 1430688ea5feSHariprasad Shenai 1431688ea5feSHariprasad Shenai t4_read_rss_key(seq->private, key); 1432688ea5feSHariprasad Shenai seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1433688ea5feSHariprasad Shenai key[9], key[8], key[7], key[6], key[5], key[4], key[3], 1434688ea5feSHariprasad Shenai key[2], key[1], key[0]); 1435688ea5feSHariprasad Shenai return 0; 1436688ea5feSHariprasad Shenai } 1437688ea5feSHariprasad Shenai 1438688ea5feSHariprasad Shenai static int rss_key_open(struct inode *inode, struct file *file) 1439688ea5feSHariprasad Shenai { 1440688ea5feSHariprasad Shenai return single_open(file, rss_key_show, inode->i_private); 1441688ea5feSHariprasad Shenai } 1442688ea5feSHariprasad Shenai 1443688ea5feSHariprasad Shenai static ssize_t rss_key_write(struct file *file, const char __user *buf, 1444688ea5feSHariprasad Shenai size_t count, loff_t *pos) 1445688ea5feSHariprasad Shenai { 1446688ea5feSHariprasad Shenai int i, j; 1447688ea5feSHariprasad Shenai u32 key[10]; 1448688ea5feSHariprasad Shenai char s[100], *p; 1449688ea5feSHariprasad Shenai struct adapter *adap = FILE_DATA(file)->i_private; 1450688ea5feSHariprasad Shenai 1451688ea5feSHariprasad Shenai if (count > sizeof(s) - 1) 1452688ea5feSHariprasad Shenai return -EINVAL; 1453688ea5feSHariprasad Shenai if (copy_from_user(s, buf, count)) 1454688ea5feSHariprasad Shenai return -EFAULT; 1455688ea5feSHariprasad Shenai for (i = count; i > 0 && isspace(s[i - 1]); i--) 1456688ea5feSHariprasad Shenai ; 1457688ea5feSHariprasad Shenai s[i] = '\0'; 1458688ea5feSHariprasad Shenai 1459688ea5feSHariprasad Shenai for (p = s, i = 9; i >= 0; i--) { 1460688ea5feSHariprasad Shenai key[i] = 0; 1461688ea5feSHariprasad Shenai for (j = 0; j < 8; j++, p++) { 1462688ea5feSHariprasad Shenai if (!isxdigit(*p)) 1463688ea5feSHariprasad Shenai return -EINVAL; 1464688ea5feSHariprasad Shenai key[i] = (key[i] << 4) | hex2val(*p); 1465688ea5feSHariprasad Shenai } 1466688ea5feSHariprasad Shenai } 1467688ea5feSHariprasad Shenai 1468688ea5feSHariprasad Shenai t4_write_rss_key(adap, key, -1); 1469688ea5feSHariprasad Shenai return count; 1470688ea5feSHariprasad Shenai } 1471688ea5feSHariprasad Shenai 1472688ea5feSHariprasad Shenai static const struct file_operations rss_key_debugfs_fops = { 1473688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1474688ea5feSHariprasad Shenai .open = rss_key_open, 1475688ea5feSHariprasad Shenai .read = seq_read, 1476688ea5feSHariprasad Shenai .llseek = seq_lseek, 1477688ea5feSHariprasad Shenai .release = single_release, 1478688ea5feSHariprasad Shenai .write = rss_key_write 1479688ea5feSHariprasad Shenai }; 1480688ea5feSHariprasad Shenai 1481688ea5feSHariprasad Shenai /* PF RSS Configuration. 1482688ea5feSHariprasad Shenai */ 1483688ea5feSHariprasad Shenai 1484688ea5feSHariprasad Shenai struct rss_pf_conf { 1485688ea5feSHariprasad Shenai u32 rss_pf_map; 1486688ea5feSHariprasad Shenai u32 rss_pf_mask; 1487688ea5feSHariprasad Shenai u32 rss_pf_config; 1488688ea5feSHariprasad Shenai }; 1489688ea5feSHariprasad Shenai 1490688ea5feSHariprasad Shenai static int rss_pf_config_show(struct seq_file *seq, void *v, int idx) 1491688ea5feSHariprasad Shenai { 1492688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1493688ea5feSHariprasad Shenai 1494688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1495688ea5feSHariprasad Shenai /* use the 0th entry to dump the PF Map Index Size */ 1496688ea5feSHariprasad Shenai pfconf = seq->private + offsetof(struct seq_tab, data); 1497688ea5feSHariprasad Shenai seq_printf(seq, "PF Map Index Size = %d\n\n", 1498688ea5feSHariprasad Shenai LKPIDXSIZE_G(pfconf->rss_pf_map)); 1499688ea5feSHariprasad Shenai 1500688ea5feSHariprasad Shenai seq_puts(seq, " RSS PF VF Hash Tuple Enable Default\n"); 1501688ea5feSHariprasad Shenai seq_puts(seq, " Enable IPF Mask Mask IPv6 IPv4 UDP Queue\n"); 1502688ea5feSHariprasad Shenai seq_puts(seq, " PF Map Chn Prt Map Size Size Four Two Four Two Four Ch1 Ch0\n"); 1503688ea5feSHariprasad Shenai } else { 1504688ea5feSHariprasad Shenai #define G_PFnLKPIDX(map, n) \ 1505688ea5feSHariprasad Shenai (((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M) 1506688ea5feSHariprasad Shenai #define G_PFnMSKSIZE(mask, n) \ 1507688ea5feSHariprasad Shenai (((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M) 1508688ea5feSHariprasad Shenai 1509688ea5feSHariprasad Shenai pfconf = v; 1510688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3s %3d %3d %3d %3s %3s %3s %3s %3s %3d %3d\n", 1511688ea5feSHariprasad Shenai idx, 1512688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & MAPENABLE_F), 1513688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & CHNENABLE_F), 1514688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & PRTENABLE_F), 1515688ea5feSHariprasad Shenai G_PFnLKPIDX(pfconf->rss_pf_map, idx), 1516688ea5feSHariprasad Shenai G_PFnMSKSIZE(pfconf->rss_pf_mask, idx), 1517688ea5feSHariprasad Shenai IVFWIDTH_G(pfconf->rss_pf_config), 1518688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F), 1519688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F), 1520688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F), 1521688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F), 1522688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F), 1523688ea5feSHariprasad Shenai CH1DEFAULTQUEUE_G(pfconf->rss_pf_config), 1524688ea5feSHariprasad Shenai CH0DEFAULTQUEUE_G(pfconf->rss_pf_config)); 1525688ea5feSHariprasad Shenai 1526688ea5feSHariprasad Shenai #undef G_PFnLKPIDX 1527688ea5feSHariprasad Shenai #undef G_PFnMSKSIZE 1528688ea5feSHariprasad Shenai } 1529688ea5feSHariprasad Shenai return 0; 1530688ea5feSHariprasad Shenai } 1531688ea5feSHariprasad Shenai 1532688ea5feSHariprasad Shenai static int rss_pf_config_open(struct inode *inode, struct file *file) 1533688ea5feSHariprasad Shenai { 1534688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1535688ea5feSHariprasad Shenai struct seq_tab *p; 1536688ea5feSHariprasad Shenai u32 rss_pf_map, rss_pf_mask; 1537688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1538688ea5feSHariprasad Shenai int pf; 1539688ea5feSHariprasad Shenai 1540688ea5feSHariprasad Shenai p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show); 1541688ea5feSHariprasad Shenai if (!p) 1542688ea5feSHariprasad Shenai return -ENOMEM; 1543688ea5feSHariprasad Shenai 1544688ea5feSHariprasad Shenai pfconf = (struct rss_pf_conf *)p->data; 1545688ea5feSHariprasad Shenai rss_pf_map = t4_read_rss_pf_map(adapter); 1546688ea5feSHariprasad Shenai rss_pf_mask = t4_read_rss_pf_mask(adapter); 1547688ea5feSHariprasad Shenai for (pf = 0; pf < 8; pf++) { 1548688ea5feSHariprasad Shenai pfconf[pf].rss_pf_map = rss_pf_map; 1549688ea5feSHariprasad Shenai pfconf[pf].rss_pf_mask = rss_pf_mask; 1550688ea5feSHariprasad Shenai t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config); 1551688ea5feSHariprasad Shenai } 1552688ea5feSHariprasad Shenai return 0; 1553688ea5feSHariprasad Shenai } 1554688ea5feSHariprasad Shenai 1555688ea5feSHariprasad Shenai static const struct file_operations rss_pf_config_debugfs_fops = { 1556688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1557688ea5feSHariprasad Shenai .open = rss_pf_config_open, 1558688ea5feSHariprasad Shenai .read = seq_read, 1559688ea5feSHariprasad Shenai .llseek = seq_lseek, 1560688ea5feSHariprasad Shenai .release = seq_release_private 1561688ea5feSHariprasad Shenai }; 1562688ea5feSHariprasad Shenai 1563688ea5feSHariprasad Shenai /* VF RSS Configuration. 1564688ea5feSHariprasad Shenai */ 1565688ea5feSHariprasad Shenai 1566688ea5feSHariprasad Shenai struct rss_vf_conf { 1567688ea5feSHariprasad Shenai u32 rss_vf_vfl; 1568688ea5feSHariprasad Shenai u32 rss_vf_vfh; 1569688ea5feSHariprasad Shenai }; 1570688ea5feSHariprasad Shenai 1571688ea5feSHariprasad Shenai static int rss_vf_config_show(struct seq_file *seq, void *v, int idx) 1572688ea5feSHariprasad Shenai { 1573688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1574688ea5feSHariprasad Shenai seq_puts(seq, " RSS Hash Tuple Enable\n"); 1575688ea5feSHariprasad Shenai seq_puts(seq, " Enable IVF Dis Enb IPv6 IPv4 UDP Def Secret Key\n"); 1576688ea5feSHariprasad Shenai seq_puts(seq, " VF Chn Prt Map VLAN uP Four Two Four Two Four Que Idx Hash\n"); 1577688ea5feSHariprasad Shenai } else { 1578688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf = v; 1579688ea5feSHariprasad Shenai 1580688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3d %3s %3s %3s %3s %3s %3s %3s %4d %3d %#10x\n", 1581688ea5feSHariprasad Shenai idx, 1582688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFCHNEN_F), 1583688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFPRTEN_F), 1584688ea5feSHariprasad Shenai VFLKPIDX_G(vfconf->rss_vf_vfh), 1585688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFVLNEX_F), 1586688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFUPEN_F), 1587688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1588688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F), 1589688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1590688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F), 1591688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F), 1592688ea5feSHariprasad Shenai DEFAULTQUEUE_G(vfconf->rss_vf_vfh), 1593688ea5feSHariprasad Shenai KEYINDEX_G(vfconf->rss_vf_vfh), 1594688ea5feSHariprasad Shenai vfconf->rss_vf_vfl); 1595688ea5feSHariprasad Shenai } 1596688ea5feSHariprasad Shenai return 0; 1597688ea5feSHariprasad Shenai } 1598688ea5feSHariprasad Shenai 1599688ea5feSHariprasad Shenai static int rss_vf_config_open(struct inode *inode, struct file *file) 1600688ea5feSHariprasad Shenai { 1601688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1602688ea5feSHariprasad Shenai struct seq_tab *p; 1603688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf; 1604688ea5feSHariprasad Shenai int vf; 1605688ea5feSHariprasad Shenai 1606688ea5feSHariprasad Shenai p = seq_open_tab(file, 128, sizeof(*vfconf), 1, rss_vf_config_show); 1607688ea5feSHariprasad Shenai if (!p) 1608688ea5feSHariprasad Shenai return -ENOMEM; 1609688ea5feSHariprasad Shenai 1610688ea5feSHariprasad Shenai vfconf = (struct rss_vf_conf *)p->data; 1611688ea5feSHariprasad Shenai for (vf = 0; vf < 128; vf++) { 1612688ea5feSHariprasad Shenai t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl, 1613688ea5feSHariprasad Shenai &vfconf[vf].rss_vf_vfh); 1614688ea5feSHariprasad Shenai } 1615688ea5feSHariprasad Shenai return 0; 1616688ea5feSHariprasad Shenai } 1617688ea5feSHariprasad Shenai 1618688ea5feSHariprasad Shenai static const struct file_operations rss_vf_config_debugfs_fops = { 1619688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1620688ea5feSHariprasad Shenai .open = rss_vf_config_open, 1621688ea5feSHariprasad Shenai .read = seq_read, 1622688ea5feSHariprasad Shenai .llseek = seq_lseek, 1623688ea5feSHariprasad Shenai .release = seq_release_private 1624688ea5feSHariprasad Shenai }; 1625688ea5feSHariprasad Shenai 16263051fa61SHariprasad Shenai /** 16273051fa61SHariprasad Shenai * ethqset2pinfo - return port_info of an Ethernet Queue Set 16283051fa61SHariprasad Shenai * @adap: the adapter 16293051fa61SHariprasad Shenai * @qset: Ethernet Queue Set 16303051fa61SHariprasad Shenai */ 16313051fa61SHariprasad Shenai static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset) 16323051fa61SHariprasad Shenai { 16333051fa61SHariprasad Shenai int pidx; 16343051fa61SHariprasad Shenai 16353051fa61SHariprasad Shenai for_each_port(adap, pidx) { 16363051fa61SHariprasad Shenai struct port_info *pi = adap2pinfo(adap, pidx); 16373051fa61SHariprasad Shenai 16383051fa61SHariprasad Shenai if (qset >= pi->first_qset && 16393051fa61SHariprasad Shenai qset < pi->first_qset + pi->nqsets) 16403051fa61SHariprasad Shenai return pi; 16413051fa61SHariprasad Shenai } 16423051fa61SHariprasad Shenai 16433051fa61SHariprasad Shenai /* should never happen! */ 16443051fa61SHariprasad Shenai BUG_ON(1); 16453051fa61SHariprasad Shenai return NULL; 16463051fa61SHariprasad Shenai } 16473051fa61SHariprasad Shenai 1648dc9daab2SHariprasad Shenai static int sge_qinfo_show(struct seq_file *seq, void *v) 1649dc9daab2SHariprasad Shenai { 1650dc9daab2SHariprasad Shenai struct adapter *adap = seq->private; 1651dc9daab2SHariprasad Shenai int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4); 1652dc9daab2SHariprasad Shenai int toe_entries = DIV_ROUND_UP(adap->sge.ofldqsets, 4); 1653dc9daab2SHariprasad Shenai int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4); 1654dc9daab2SHariprasad Shenai int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4); 1655dc9daab2SHariprasad Shenai int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4); 1656dc9daab2SHariprasad Shenai int i, r = (uintptr_t)v - 1; 1657dc9daab2SHariprasad Shenai int toe_idx = r - eth_entries; 1658dc9daab2SHariprasad Shenai int rdma_idx = toe_idx - toe_entries; 1659dc9daab2SHariprasad Shenai int ciq_idx = rdma_idx - rdma_entries; 1660dc9daab2SHariprasad Shenai int ctrl_idx = ciq_idx - ciq_entries; 1661dc9daab2SHariprasad Shenai int fq_idx = ctrl_idx - ctrl_entries; 1662dc9daab2SHariprasad Shenai 1663dc9daab2SHariprasad Shenai if (r) 1664dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); 1665dc9daab2SHariprasad Shenai 1666dc9daab2SHariprasad Shenai #define S3(fmt_spec, s, v) \ 1667dc9daab2SHariprasad Shenai do { \ 1668dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s", s); \ 1669dc9daab2SHariprasad Shenai for (i = 0; i < n; ++i) \ 1670dc9daab2SHariprasad Shenai seq_printf(seq, " %16" fmt_spec, v); \ 1671dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); \ 1672dc9daab2SHariprasad Shenai } while (0) 1673dc9daab2SHariprasad Shenai #define S(s, v) S3("s", s, v) 1674dc9daab2SHariprasad Shenai #define T(s, v) S3("u", s, tx[i].v) 1675dc9daab2SHariprasad Shenai #define R(s, v) S3("u", s, rx[i].v) 1676dc9daab2SHariprasad Shenai 1677dc9daab2SHariprasad Shenai if (r < eth_entries) { 1678dc9daab2SHariprasad Shenai int base_qset = r * 4; 1679dc9daab2SHariprasad Shenai const struct sge_eth_rxq *rx = &adap->sge.ethrxq[base_qset]; 1680dc9daab2SHariprasad Shenai const struct sge_eth_txq *tx = &adap->sge.ethtxq[base_qset]; 1681dc9daab2SHariprasad Shenai int n = min(4, adap->sge.ethqsets - 4 * r); 1682dc9daab2SHariprasad Shenai 1683dc9daab2SHariprasad Shenai S("QType:", "Ethernet"); 1684dc9daab2SHariprasad Shenai S("Interface:", 1685dc9daab2SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 1686dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1687dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1688dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1689dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1690dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 16913051fa61SHariprasad Shenai #ifdef CONFIG_CHELSIO_T4_DCB 1692dc9daab2SHariprasad Shenai T("DCB Prio:", dcb_prio); 1693dc9daab2SHariprasad Shenai S3("u", "DCB PGID:", 1694dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >> 1695dc9daab2SHariprasad Shenai 4*(7-tx[i].dcb_prio)) & 0xf); 1696dc9daab2SHariprasad Shenai S3("u", "DCB PFC:", 1697dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >> 1698dc9daab2SHariprasad Shenai 1*(7-tx[i].dcb_prio)) & 0x1); 1699dc9daab2SHariprasad Shenai #endif 1700dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1701dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1702dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1703dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1704dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1705dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1706dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1707dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1708dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1709dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1710dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1711dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1712dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1713dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1714dc9daab2SHariprasad Shenai } else if (toe_idx < toe_entries) { 1715dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = &adap->sge.ofldrxq[toe_idx * 4]; 1716dc9daab2SHariprasad Shenai const struct sge_ofld_txq *tx = &adap->sge.ofldtxq[toe_idx * 4]; 1717dc9daab2SHariprasad Shenai int n = min(4, adap->sge.ofldqsets - 4 * toe_idx); 1718dc9daab2SHariprasad Shenai 1719dc9daab2SHariprasad Shenai S("QType:", "TOE"); 1720dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1721dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1722dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1723dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1724dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 1725dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1726dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1727dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1728dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1729dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1730dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1731dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1732dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1733dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1734dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1735dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1736dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1737dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1738dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1739dc9daab2SHariprasad Shenai } else if (rdma_idx < rdma_entries) { 1740dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = 1741dc9daab2SHariprasad Shenai &adap->sge.rdmarxq[rdma_idx * 4]; 1742dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaqs - 4 * rdma_idx); 1743dc9daab2SHariprasad Shenai 1744dc9daab2SHariprasad Shenai S("QType:", "RDMA-CPL"); 1745dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1746dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1747dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1748dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1749dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1750dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1751dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1752dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1753dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1754dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1755dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1756dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1757dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1758dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1759dc9daab2SHariprasad Shenai } else if (ciq_idx < ciq_entries) { 1760dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = &adap->sge.rdmaciq[ciq_idx * 4]; 1761dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaciqs - 4 * ciq_idx); 1762dc9daab2SHariprasad Shenai 1763dc9daab2SHariprasad Shenai S("QType:", "RDMA-CIQ"); 1764dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1765dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1766dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1767dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1768dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1769dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1770dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1771dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1772dc9daab2SHariprasad Shenai } else if (ctrl_idx < ctrl_entries) { 1773dc9daab2SHariprasad Shenai const struct sge_ctrl_txq *tx = &adap->sge.ctrlq[ctrl_idx * 4]; 1774dc9daab2SHariprasad Shenai int n = min(4, adap->params.nports - 4 * ctrl_idx); 1775dc9daab2SHariprasad Shenai 1776dc9daab2SHariprasad Shenai S("QType:", "Control"); 1777dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1778dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1779dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1780dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1781dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 1782dc9daab2SHariprasad Shenai } else if (fq_idx == 0) { 1783dc9daab2SHariprasad Shenai const struct sge_rspq *evtq = &adap->sge.fw_evtq; 1784dc9daab2SHariprasad Shenai 1785dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); 1786dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); 1787dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size); 1788dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len); 1789dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx); 1790dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); 1791dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr delay:", 1792dc9daab2SHariprasad Shenai qtimer_val(adap, evtq)); 1793dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 1794dc9daab2SHariprasad Shenai adap->sge.counter_val[evtq->pktcnt_idx]); 1795dc9daab2SHariprasad Shenai } 1796dc9daab2SHariprasad Shenai #undef R 1797dc9daab2SHariprasad Shenai #undef T 1798dc9daab2SHariprasad Shenai #undef S 1799dc9daab2SHariprasad Shenai #undef S3 1800dc9daab2SHariprasad Shenai return 0; 1801dc9daab2SHariprasad Shenai } 1802dc9daab2SHariprasad Shenai 1803dc9daab2SHariprasad Shenai static int sge_queue_entries(const struct adapter *adap) 1804dc9daab2SHariprasad Shenai { 1805dc9daab2SHariprasad Shenai return DIV_ROUND_UP(adap->sge.ethqsets, 4) + 1806dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.ofldqsets, 4) + 1807dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaqs, 4) + 1808dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaciqs, 4) + 1809dc9daab2SHariprasad Shenai DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1; 1810dc9daab2SHariprasad Shenai } 1811dc9daab2SHariprasad Shenai 1812dc9daab2SHariprasad Shenai static void *sge_queue_start(struct seq_file *seq, loff_t *pos) 1813dc9daab2SHariprasad Shenai { 1814dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 1815dc9daab2SHariprasad Shenai 1816dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1817dc9daab2SHariprasad Shenai } 1818dc9daab2SHariprasad Shenai 1819dc9daab2SHariprasad Shenai static void sge_queue_stop(struct seq_file *seq, void *v) 1820dc9daab2SHariprasad Shenai { 1821dc9daab2SHariprasad Shenai } 1822dc9daab2SHariprasad Shenai 1823dc9daab2SHariprasad Shenai static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) 1824dc9daab2SHariprasad Shenai { 1825dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 1826dc9daab2SHariprasad Shenai 1827dc9daab2SHariprasad Shenai ++*pos; 1828dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1829dc9daab2SHariprasad Shenai } 1830dc9daab2SHariprasad Shenai 1831dc9daab2SHariprasad Shenai static const struct seq_operations sge_qinfo_seq_ops = { 1832dc9daab2SHariprasad Shenai .start = sge_queue_start, 1833dc9daab2SHariprasad Shenai .next = sge_queue_next, 1834dc9daab2SHariprasad Shenai .stop = sge_queue_stop, 1835dc9daab2SHariprasad Shenai .show = sge_qinfo_show 1836dc9daab2SHariprasad Shenai }; 1837dc9daab2SHariprasad Shenai 1838dc9daab2SHariprasad Shenai static int sge_qinfo_open(struct inode *inode, struct file *file) 1839dc9daab2SHariprasad Shenai { 1840dc9daab2SHariprasad Shenai int res = seq_open(file, &sge_qinfo_seq_ops); 1841dc9daab2SHariprasad Shenai 1842dc9daab2SHariprasad Shenai if (!res) { 1843dc9daab2SHariprasad Shenai struct seq_file *seq = file->private_data; 1844dc9daab2SHariprasad Shenai 1845dc9daab2SHariprasad Shenai seq->private = inode->i_private; 1846dc9daab2SHariprasad Shenai } 1847dc9daab2SHariprasad Shenai return res; 1848dc9daab2SHariprasad Shenai } 1849dc9daab2SHariprasad Shenai 1850dc9daab2SHariprasad Shenai static const struct file_operations sge_qinfo_debugfs_fops = { 1851dc9daab2SHariprasad Shenai .owner = THIS_MODULE, 1852dc9daab2SHariprasad Shenai .open = sge_qinfo_open, 1853dc9daab2SHariprasad Shenai .read = seq_read, 1854dc9daab2SHariprasad Shenai .llseek = seq_lseek, 1855dc9daab2SHariprasad Shenai .release = seq_release, 1856dc9daab2SHariprasad Shenai }; 1857dc9daab2SHariprasad Shenai 185849216c1cSHariprasad Shenai int mem_open(struct inode *inode, struct file *file) 185949216c1cSHariprasad Shenai { 186049216c1cSHariprasad Shenai unsigned int mem; 186149216c1cSHariprasad Shenai struct adapter *adap; 186249216c1cSHariprasad Shenai 186349216c1cSHariprasad Shenai file->private_data = inode->i_private; 186449216c1cSHariprasad Shenai 186549216c1cSHariprasad Shenai mem = (uintptr_t)file->private_data & 0x3; 186649216c1cSHariprasad Shenai adap = file->private_data - mem; 186749216c1cSHariprasad Shenai 186849216c1cSHariprasad Shenai (void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH); 186949216c1cSHariprasad Shenai 187049216c1cSHariprasad Shenai return 0; 187149216c1cSHariprasad Shenai } 187249216c1cSHariprasad Shenai 1873fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 1874fd88b31aSHariprasad Shenai loff_t *ppos) 1875fd88b31aSHariprasad Shenai { 1876fd88b31aSHariprasad Shenai loff_t pos = *ppos; 1877fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 1878fd88b31aSHariprasad Shenai unsigned int mem = (uintptr_t)file->private_data & 3; 1879fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 1880fd88b31aSHariprasad Shenai __be32 *data; 1881fd88b31aSHariprasad Shenai int ret; 1882fd88b31aSHariprasad Shenai 1883fd88b31aSHariprasad Shenai if (pos < 0) 1884fd88b31aSHariprasad Shenai return -EINVAL; 1885fd88b31aSHariprasad Shenai if (pos >= avail) 1886fd88b31aSHariprasad Shenai return 0; 1887fd88b31aSHariprasad Shenai if (count > avail - pos) 1888fd88b31aSHariprasad Shenai count = avail - pos; 1889fd88b31aSHariprasad Shenai 1890fd88b31aSHariprasad Shenai data = t4_alloc_mem(count); 1891fd88b31aSHariprasad Shenai if (!data) 1892fd88b31aSHariprasad Shenai return -ENOMEM; 1893fd88b31aSHariprasad Shenai 1894fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 1895fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 1896fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 1897fd88b31aSHariprasad Shenai if (ret) { 1898fd88b31aSHariprasad Shenai t4_free_mem(data); 1899fd88b31aSHariprasad Shenai return ret; 1900fd88b31aSHariprasad Shenai } 1901fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 1902fd88b31aSHariprasad Shenai 1903fd88b31aSHariprasad Shenai t4_free_mem(data); 1904fd88b31aSHariprasad Shenai if (ret) 1905fd88b31aSHariprasad Shenai return -EFAULT; 1906fd88b31aSHariprasad Shenai 1907fd88b31aSHariprasad Shenai *ppos = pos + count; 1908fd88b31aSHariprasad Shenai return count; 1909fd88b31aSHariprasad Shenai } 1910fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 1911fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 1912fd88b31aSHariprasad Shenai .open = simple_open, 1913fd88b31aSHariprasad Shenai .read = mem_read, 1914fd88b31aSHariprasad Shenai .llseek = default_llseek, 1915fd88b31aSHariprasad Shenai }; 1916fd88b31aSHariprasad Shenai 191749216c1cSHariprasad Shenai static void set_debugfs_file_size(struct dentry *de, loff_t size) 191849216c1cSHariprasad Shenai { 191949216c1cSHariprasad Shenai if (!IS_ERR(de) && de->d_inode) 192049216c1cSHariprasad Shenai de->d_inode->i_size = size; 192149216c1cSHariprasad Shenai } 192249216c1cSHariprasad Shenai 1923fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 1924fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 1925fd88b31aSHariprasad Shenai { 1926fd88b31aSHariprasad Shenai struct dentry *de; 1927fd88b31aSHariprasad Shenai 1928fd88b31aSHariprasad Shenai de = debugfs_create_file(name, S_IRUSR, adap->debugfs_root, 1929fd88b31aSHariprasad Shenai (void *)adap + idx, &mem_debugfs_fops); 1930fd88b31aSHariprasad Shenai if (de && de->d_inode) 1931fd88b31aSHariprasad Shenai de->d_inode->i_size = size_mb << 20; 1932fd88b31aSHariprasad Shenai } 1933fd88b31aSHariprasad Shenai 1934fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 1935fd88b31aSHariprasad Shenai */ 1936fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 1937fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 1938fd88b31aSHariprasad Shenai unsigned int nfiles) 1939fd88b31aSHariprasad Shenai { 1940fd88b31aSHariprasad Shenai int i; 1941fd88b31aSHariprasad Shenai 1942fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 1943fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 1944fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 1945fd88b31aSHariprasad Shenai adap->debugfs_root, 1946fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 1947fd88b31aSHariprasad Shenai files[i].ops); 1948fd88b31aSHariprasad Shenai } 1949fd88b31aSHariprasad Shenai 1950fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 1951fd88b31aSHariprasad Shenai { 1952fd88b31aSHariprasad Shenai int i; 1953fd88b31aSHariprasad Shenai u32 size; 195449216c1cSHariprasad Shenai struct dentry *de; 1955fd88b31aSHariprasad Shenai 1956fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 1957f1ff24aaSHariprasad Shenai { "cim_la", &cim_la_fops, S_IRUSR, 0 }, 195874b3092cSHariprasad Shenai { "cim_qcfg", &cim_qcfg_fops, S_IRUSR, 0 }, 1959b58b6676SHariprasad Shenai { "clk", &clk_debugfs_fops, S_IRUSR, 0 }, 196049aa284fSHariprasad Shenai { "devlog", &devlog_fops, S_IRUSR, 0 }, 1961bf7c781dSHariprasad Shenai { "mbox0", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 0 }, 1962bf7c781dSHariprasad Shenai { "mbox1", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 1 }, 1963bf7c781dSHariprasad Shenai { "mbox2", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 2 }, 1964bf7c781dSHariprasad Shenai { "mbox3", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 3 }, 1965bf7c781dSHariprasad Shenai { "mbox4", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 4 }, 1966bf7c781dSHariprasad Shenai { "mbox5", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 5 }, 1967bf7c781dSHariprasad Shenai { "mbox6", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 6 }, 1968bf7c781dSHariprasad Shenai { "mbox7", &mbox_debugfs_fops, S_IRUSR | S_IWUSR, 7 }, 1969fd88b31aSHariprasad Shenai { "l2t", &t4_l2t_fops, S_IRUSR, 0}, 1970ef82f662SHariprasad Shenai { "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 }, 1971688ea5feSHariprasad Shenai { "rss", &rss_debugfs_fops, S_IRUSR, 0 }, 1972688ea5feSHariprasad Shenai { "rss_config", &rss_config_debugfs_fops, S_IRUSR, 0 }, 1973688ea5feSHariprasad Shenai { "rss_key", &rss_key_debugfs_fops, S_IRUSR, 0 }, 1974688ea5feSHariprasad Shenai { "rss_pf_config", &rss_pf_config_debugfs_fops, S_IRUSR, 0 }, 1975688ea5feSHariprasad Shenai { "rss_vf_config", &rss_vf_config_debugfs_fops, S_IRUSR, 0 }, 1976dc9daab2SHariprasad Shenai { "sge_qinfo", &sge_qinfo_debugfs_fops, S_IRUSR, 0 }, 1977e5f0e43bSHariprasad Shenai { "ibq_tp0", &cim_ibq_fops, S_IRUSR, 0 }, 1978e5f0e43bSHariprasad Shenai { "ibq_tp1", &cim_ibq_fops, S_IRUSR, 1 }, 1979e5f0e43bSHariprasad Shenai { "ibq_ulp", &cim_ibq_fops, S_IRUSR, 2 }, 1980e5f0e43bSHariprasad Shenai { "ibq_sge0", &cim_ibq_fops, S_IRUSR, 3 }, 1981e5f0e43bSHariprasad Shenai { "ibq_sge1", &cim_ibq_fops, S_IRUSR, 4 }, 1982e5f0e43bSHariprasad Shenai { "ibq_ncsi", &cim_ibq_fops, S_IRUSR, 5 }, 1983c778af7dSHariprasad Shenai { "obq_ulp0", &cim_obq_fops, S_IRUSR, 0 }, 1984c778af7dSHariprasad Shenai { "obq_ulp1", &cim_obq_fops, S_IRUSR, 1 }, 1985c778af7dSHariprasad Shenai { "obq_ulp2", &cim_obq_fops, S_IRUSR, 2 }, 1986c778af7dSHariprasad Shenai { "obq_ulp3", &cim_obq_fops, S_IRUSR, 3 }, 1987c778af7dSHariprasad Shenai { "obq_sge", &cim_obq_fops, S_IRUSR, 4 }, 1988c778af7dSHariprasad Shenai { "obq_ncsi", &cim_obq_fops, S_IRUSR, 5 }, 19892d277b3bSHariprasad Shenai { "tp_la", &tp_la_fops, S_IRUSR, 0 }, 1990797ff0f5SHariprasad Shenai { "ulprx_la", &ulprx_la_fops, S_IRUSR, 0 }, 199170a5f3bbSHariprasad Shenai { "sensors", &sensors_debugfs_fops, S_IRUSR, 0 }, 1992b3bbe36aSHariprasad Shenai { "pm_stats", &pm_stats_debugfs_fops, S_IRUSR, 0 }, 1993b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 1994b5a02f50SAnish Bhatt { "clip_tbl", &clip_tbl_debugfs_fops, S_IRUSR, 0 }, 1995b5a02f50SAnish Bhatt #endif 1996fd88b31aSHariprasad Shenai }; 1997fd88b31aSHariprasad Shenai 1998c778af7dSHariprasad Shenai /* Debug FS nodes common to all T5 and later adapters. 1999c778af7dSHariprasad Shenai */ 2000c778af7dSHariprasad Shenai static struct t4_debugfs_entry t5_debugfs_files[] = { 2001c778af7dSHariprasad Shenai { "obq_sge_rx_q0", &cim_obq_fops, S_IRUSR, 6 }, 2002c778af7dSHariprasad Shenai { "obq_sge_rx_q1", &cim_obq_fops, S_IRUSR, 7 }, 2003c778af7dSHariprasad Shenai }; 2004c778af7dSHariprasad Shenai 2005fd88b31aSHariprasad Shenai add_debugfs_files(adap, 2006fd88b31aSHariprasad Shenai t4_debugfs_files, 2007fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 2008c778af7dSHariprasad Shenai if (!is_t4(adap->params.chip)) 2009c778af7dSHariprasad Shenai add_debugfs_files(adap, 2010c778af7dSHariprasad Shenai t5_debugfs_files, 2011c778af7dSHariprasad Shenai ARRAY_SIZE(t5_debugfs_files)); 2012fd88b31aSHariprasad Shenai 20136559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 20146559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 20156559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 20166559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 2017fd88b31aSHariprasad Shenai } 20186559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 20196559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 20206559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 2021fd88b31aSHariprasad Shenai } 2022fd88b31aSHariprasad Shenai if (is_t4(adap->params.chip)) { 20236559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 20246559a7e8SHariprasad Shenai if (i & EXT_MEM_ENABLE_F) 2025fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 20266559a7e8SHariprasad Shenai EXT_MEM_SIZE_G(size)); 2027fd88b31aSHariprasad Shenai } else { 20286559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 20296559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 2030fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 20316559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 2032fd88b31aSHariprasad Shenai } 20336559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 20346559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 2035fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 20366559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 2037fd88b31aSHariprasad Shenai } 2038fd88b31aSHariprasad Shenai } 203949216c1cSHariprasad Shenai 204049216c1cSHariprasad Shenai de = debugfs_create_file("flash", S_IRUSR, adap->debugfs_root, adap, 204149216c1cSHariprasad Shenai &flash_debugfs_fops); 204249216c1cSHariprasad Shenai set_debugfs_file_size(de, adap->params.sf_size); 204349216c1cSHariprasad Shenai 2044fd88b31aSHariprasad Shenai return 0; 2045fd88b31aSHariprasad Shenai } 2046