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" 43fd88b31aSHariprasad Shenai #include "t4fw_api.h" 44fd88b31aSHariprasad Shenai #include "cxgb4_debugfs.h" 45b5a02f50SAnish Bhatt #include "clip_tbl.h" 46fd88b31aSHariprasad Shenai #include "l2t.h" 47fd88b31aSHariprasad Shenai 48f1ff24aaSHariprasad Shenai /* generic seq_file support for showing a table of size rows x width. */ 49f1ff24aaSHariprasad Shenai static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos) 50f1ff24aaSHariprasad Shenai { 51f1ff24aaSHariprasad Shenai pos -= tb->skip_first; 52f1ff24aaSHariprasad Shenai return pos >= tb->rows ? NULL : &tb->data[pos * tb->width]; 53f1ff24aaSHariprasad Shenai } 54f1ff24aaSHariprasad Shenai 55f1ff24aaSHariprasad Shenai static void *seq_tab_start(struct seq_file *seq, loff_t *pos) 56f1ff24aaSHariprasad Shenai { 57f1ff24aaSHariprasad Shenai struct seq_tab *tb = seq->private; 58f1ff24aaSHariprasad Shenai 59f1ff24aaSHariprasad Shenai if (tb->skip_first && *pos == 0) 60f1ff24aaSHariprasad Shenai return SEQ_START_TOKEN; 61f1ff24aaSHariprasad Shenai 62f1ff24aaSHariprasad Shenai return seq_tab_get_idx(tb, *pos); 63f1ff24aaSHariprasad Shenai } 64f1ff24aaSHariprasad Shenai 65f1ff24aaSHariprasad Shenai static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos) 66f1ff24aaSHariprasad Shenai { 67f1ff24aaSHariprasad Shenai v = seq_tab_get_idx(seq->private, *pos + 1); 68f1ff24aaSHariprasad Shenai if (v) 69f1ff24aaSHariprasad Shenai ++*pos; 70f1ff24aaSHariprasad Shenai return v; 71f1ff24aaSHariprasad Shenai } 72f1ff24aaSHariprasad Shenai 73f1ff24aaSHariprasad Shenai static void seq_tab_stop(struct seq_file *seq, void *v) 74f1ff24aaSHariprasad Shenai { 75f1ff24aaSHariprasad Shenai } 76f1ff24aaSHariprasad Shenai 77f1ff24aaSHariprasad Shenai static int seq_tab_show(struct seq_file *seq, void *v) 78f1ff24aaSHariprasad Shenai { 79f1ff24aaSHariprasad Shenai const struct seq_tab *tb = seq->private; 80f1ff24aaSHariprasad Shenai 81f1ff24aaSHariprasad Shenai return tb->show(seq, v, ((char *)v - tb->data) / tb->width); 82f1ff24aaSHariprasad Shenai } 83f1ff24aaSHariprasad Shenai 84f1ff24aaSHariprasad Shenai static const struct seq_operations seq_tab_ops = { 85f1ff24aaSHariprasad Shenai .start = seq_tab_start, 86f1ff24aaSHariprasad Shenai .next = seq_tab_next, 87f1ff24aaSHariprasad Shenai .stop = seq_tab_stop, 88f1ff24aaSHariprasad Shenai .show = seq_tab_show 89f1ff24aaSHariprasad Shenai }; 90f1ff24aaSHariprasad Shenai 91f1ff24aaSHariprasad Shenai struct seq_tab *seq_open_tab(struct file *f, unsigned int rows, 92f1ff24aaSHariprasad Shenai unsigned int width, unsigned int have_header, 93f1ff24aaSHariprasad Shenai int (*show)(struct seq_file *seq, void *v, int i)) 94f1ff24aaSHariprasad Shenai { 95f1ff24aaSHariprasad Shenai struct seq_tab *p; 96f1ff24aaSHariprasad Shenai 97f1ff24aaSHariprasad Shenai p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width); 98f1ff24aaSHariprasad Shenai if (p) { 99f1ff24aaSHariprasad Shenai p->show = show; 100f1ff24aaSHariprasad Shenai p->rows = rows; 101f1ff24aaSHariprasad Shenai p->width = width; 102f1ff24aaSHariprasad Shenai p->skip_first = have_header != 0; 103f1ff24aaSHariprasad Shenai } 104f1ff24aaSHariprasad Shenai return p; 105f1ff24aaSHariprasad Shenai } 106f1ff24aaSHariprasad Shenai 107c778af7dSHariprasad Shenai /* Trim the size of a seq_tab to the supplied number of rows. The operation is 108c778af7dSHariprasad Shenai * irreversible. 109c778af7dSHariprasad Shenai */ 110c778af7dSHariprasad Shenai static int seq_tab_trim(struct seq_tab *p, unsigned int new_rows) 111c778af7dSHariprasad Shenai { 112c778af7dSHariprasad Shenai if (new_rows > p->rows) 113c778af7dSHariprasad Shenai return -EINVAL; 114c778af7dSHariprasad Shenai p->rows = new_rows; 115c778af7dSHariprasad Shenai return 0; 116c778af7dSHariprasad Shenai } 117c778af7dSHariprasad Shenai 118f1ff24aaSHariprasad Shenai static int cim_la_show(struct seq_file *seq, void *v, int idx) 119f1ff24aaSHariprasad Shenai { 120f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) 121f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC LS0Stat LS0Addr " 122f1ff24aaSHariprasad Shenai " LS0Data\n"); 123f1ff24aaSHariprasad Shenai else { 124f1ff24aaSHariprasad Shenai const u32 *p = v; 125f1ff24aaSHariprasad Shenai 126f1ff24aaSHariprasad Shenai seq_printf(seq, 127f1ff24aaSHariprasad Shenai " %02x %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n", 128f1ff24aaSHariprasad Shenai (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4, 129f1ff24aaSHariprasad Shenai p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5], 130f1ff24aaSHariprasad Shenai p[6], p[7]); 131f1ff24aaSHariprasad Shenai } 132f1ff24aaSHariprasad Shenai return 0; 133f1ff24aaSHariprasad Shenai } 134f1ff24aaSHariprasad Shenai 135f1ff24aaSHariprasad Shenai static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx) 136f1ff24aaSHariprasad Shenai { 137f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) { 138f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC\n"); 139f1ff24aaSHariprasad Shenai } else { 140f1ff24aaSHariprasad Shenai const u32 *p = v; 141f1ff24aaSHariprasad Shenai 142f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %08x %08x\n", p[5] & 0xff, p[6], 143f1ff24aaSHariprasad Shenai p[7]); 144f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x\n", 145f1ff24aaSHariprasad Shenai (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8, 146f1ff24aaSHariprasad Shenai p[4] & 0xff, p[5] >> 8); 147f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %x%07x %x%07x\n", (p[0] >> 4) & 0xff, 148f1ff24aaSHariprasad Shenai p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4); 149f1ff24aaSHariprasad Shenai } 150f1ff24aaSHariprasad Shenai return 0; 151f1ff24aaSHariprasad Shenai } 152f1ff24aaSHariprasad Shenai 153f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 154f1ff24aaSHariprasad Shenai { 155f1ff24aaSHariprasad Shenai int ret; 156f1ff24aaSHariprasad Shenai unsigned int cfg; 157f1ff24aaSHariprasad Shenai struct seq_tab *p; 158f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 159f1ff24aaSHariprasad Shenai 160f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 161f1ff24aaSHariprasad Shenai if (ret) 162f1ff24aaSHariprasad Shenai return ret; 163f1ff24aaSHariprasad Shenai 164f1ff24aaSHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 8 * sizeof(u32), 1, 165f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 166f1ff24aaSHariprasad Shenai cim_la_show_3in1 : cim_la_show); 167f1ff24aaSHariprasad Shenai if (!p) 168f1ff24aaSHariprasad Shenai return -ENOMEM; 169f1ff24aaSHariprasad Shenai 170f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 171f1ff24aaSHariprasad Shenai if (ret) 172f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 173f1ff24aaSHariprasad Shenai return ret; 174f1ff24aaSHariprasad Shenai } 175f1ff24aaSHariprasad Shenai 176f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 177f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 178f1ff24aaSHariprasad Shenai .open = cim_la_open, 179f1ff24aaSHariprasad Shenai .read = seq_read, 180f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 181f1ff24aaSHariprasad Shenai .release = seq_release_private 182f1ff24aaSHariprasad Shenai }; 183f1ff24aaSHariprasad Shenai 18474b3092cSHariprasad Shenai static int cim_qcfg_show(struct seq_file *seq, void *v) 18574b3092cSHariprasad Shenai { 18674b3092cSHariprasad Shenai static const char * const qname[] = { 18774b3092cSHariprasad Shenai "TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI", 18874b3092cSHariprasad Shenai "ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI", 18974b3092cSHariprasad Shenai "SGE0-RX", "SGE1-RX" 19074b3092cSHariprasad Shenai }; 19174b3092cSHariprasad Shenai 19274b3092cSHariprasad Shenai int i; 19374b3092cSHariprasad Shenai struct adapter *adap = seq->private; 19474b3092cSHariprasad Shenai u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 19574b3092cSHariprasad Shenai u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5]; 19674b3092cSHariprasad Shenai u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))]; 19774b3092cSHariprasad Shenai u16 thres[CIM_NUM_IBQ]; 19874b3092cSHariprasad Shenai u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr; 19974b3092cSHariprasad Shenai u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5]; 20074b3092cSHariprasad Shenai u32 *p = stat; 20174b3092cSHariprasad Shenai int cim_num_obq = is_t4(adap->params.chip) ? 20274b3092cSHariprasad Shenai CIM_NUM_OBQ : CIM_NUM_OBQ_T5; 20374b3092cSHariprasad Shenai 20474b3092cSHariprasad Shenai i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A : 20574b3092cSHariprasad Shenai UP_IBQ_0_SHADOW_RDADDR_A, 20674b3092cSHariprasad Shenai ARRAY_SIZE(stat), stat); 20774b3092cSHariprasad Shenai if (!i) { 20874b3092cSHariprasad Shenai if (is_t4(adap->params.chip)) { 20974b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A, 21074b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t4), obq_wr_t4); 21174b3092cSHariprasad Shenai wr = obq_wr_t4; 21274b3092cSHariprasad Shenai } else { 21374b3092cSHariprasad Shenai i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A, 21474b3092cSHariprasad Shenai ARRAY_SIZE(obq_wr_t5), obq_wr_t5); 21574b3092cSHariprasad Shenai wr = obq_wr_t5; 21674b3092cSHariprasad Shenai } 21774b3092cSHariprasad Shenai } 21874b3092cSHariprasad Shenai if (i) 21974b3092cSHariprasad Shenai return i; 22074b3092cSHariprasad Shenai 22174b3092cSHariprasad Shenai t4_read_cimq_cfg(adap, base, size, thres); 22274b3092cSHariprasad Shenai 22374b3092cSHariprasad Shenai seq_printf(seq, 22474b3092cSHariprasad Shenai " Queue Base Size Thres RdPtr WrPtr SOP EOP Avail\n"); 22574b3092cSHariprasad Shenai for (i = 0; i < CIM_NUM_IBQ; i++, p += 4) 22674b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %5u %6x %4x %4u %4u %5u\n", 22774b3092cSHariprasad Shenai qname[i], base[i], size[i], thres[i], 22874b3092cSHariprasad Shenai IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]), 22974b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 23074b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 23174b3092cSHariprasad Shenai for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2) 23274b3092cSHariprasad Shenai seq_printf(seq, "%7s %5x %5u %12x %4x %4u %4u %5u\n", 23374b3092cSHariprasad Shenai qname[i], base[i], size[i], 23474b3092cSHariprasad Shenai QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i], 23574b3092cSHariprasad Shenai QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]), 23674b3092cSHariprasad Shenai QUEREMFLITS_G(p[2]) * 16); 23774b3092cSHariprasad Shenai return 0; 23874b3092cSHariprasad Shenai } 23974b3092cSHariprasad Shenai 24074b3092cSHariprasad Shenai static int cim_qcfg_open(struct inode *inode, struct file *file) 24174b3092cSHariprasad Shenai { 24274b3092cSHariprasad Shenai return single_open(file, cim_qcfg_show, inode->i_private); 24374b3092cSHariprasad Shenai } 24474b3092cSHariprasad Shenai 24574b3092cSHariprasad Shenai static const struct file_operations cim_qcfg_fops = { 24674b3092cSHariprasad Shenai .owner = THIS_MODULE, 24774b3092cSHariprasad Shenai .open = cim_qcfg_open, 24874b3092cSHariprasad Shenai .read = seq_read, 24974b3092cSHariprasad Shenai .llseek = seq_lseek, 25074b3092cSHariprasad Shenai .release = single_release, 25174b3092cSHariprasad Shenai }; 25274b3092cSHariprasad Shenai 253e5f0e43bSHariprasad Shenai static int cimq_show(struct seq_file *seq, void *v, int idx) 254e5f0e43bSHariprasad Shenai { 255e5f0e43bSHariprasad Shenai const u32 *p = v; 256e5f0e43bSHariprasad Shenai 257e5f0e43bSHariprasad Shenai seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1], 258e5f0e43bSHariprasad Shenai p[2], p[3]); 259e5f0e43bSHariprasad Shenai return 0; 260e5f0e43bSHariprasad Shenai } 261e5f0e43bSHariprasad Shenai 262e5f0e43bSHariprasad Shenai static int cim_ibq_open(struct inode *inode, struct file *file) 263e5f0e43bSHariprasad Shenai { 264e5f0e43bSHariprasad Shenai int ret; 265e5f0e43bSHariprasad Shenai struct seq_tab *p; 266e5f0e43bSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 267e5f0e43bSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 268e5f0e43bSHariprasad Shenai 269e5f0e43bSHariprasad Shenai p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 270e5f0e43bSHariprasad Shenai if (!p) 271e5f0e43bSHariprasad Shenai return -ENOMEM; 272e5f0e43bSHariprasad Shenai 273e5f0e43bSHariprasad Shenai ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4); 274e5f0e43bSHariprasad Shenai if (ret < 0) 275e5f0e43bSHariprasad Shenai seq_release_private(inode, file); 276e5f0e43bSHariprasad Shenai else 277e5f0e43bSHariprasad Shenai ret = 0; 278e5f0e43bSHariprasad Shenai return ret; 279e5f0e43bSHariprasad Shenai } 280e5f0e43bSHariprasad Shenai 281e5f0e43bSHariprasad Shenai static const struct file_operations cim_ibq_fops = { 282e5f0e43bSHariprasad Shenai .owner = THIS_MODULE, 283e5f0e43bSHariprasad Shenai .open = cim_ibq_open, 284e5f0e43bSHariprasad Shenai .read = seq_read, 285e5f0e43bSHariprasad Shenai .llseek = seq_lseek, 286e5f0e43bSHariprasad Shenai .release = seq_release_private 287e5f0e43bSHariprasad Shenai }; 288e5f0e43bSHariprasad Shenai 289c778af7dSHariprasad Shenai static int cim_obq_open(struct inode *inode, struct file *file) 290c778af7dSHariprasad Shenai { 291c778af7dSHariprasad Shenai int ret; 292c778af7dSHariprasad Shenai struct seq_tab *p; 293c778af7dSHariprasad Shenai unsigned int qid = (uintptr_t)inode->i_private & 7; 294c778af7dSHariprasad Shenai struct adapter *adap = inode->i_private - qid; 295c778af7dSHariprasad Shenai 296c778af7dSHariprasad Shenai p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show); 297c778af7dSHariprasad Shenai if (!p) 298c778af7dSHariprasad Shenai return -ENOMEM; 299c778af7dSHariprasad Shenai 300c778af7dSHariprasad Shenai ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4); 301c778af7dSHariprasad Shenai if (ret < 0) { 302c778af7dSHariprasad Shenai seq_release_private(inode, file); 303c778af7dSHariprasad Shenai } else { 304c778af7dSHariprasad Shenai seq_tab_trim(p, ret / 4); 305c778af7dSHariprasad Shenai ret = 0; 306c778af7dSHariprasad Shenai } 307c778af7dSHariprasad Shenai return ret; 308c778af7dSHariprasad Shenai } 309c778af7dSHariprasad Shenai 310c778af7dSHariprasad Shenai static const struct file_operations cim_obq_fops = { 311c778af7dSHariprasad Shenai .owner = THIS_MODULE, 312c778af7dSHariprasad Shenai .open = cim_obq_open, 313c778af7dSHariprasad Shenai .read = seq_read, 314c778af7dSHariprasad Shenai .llseek = seq_lseek, 315c778af7dSHariprasad Shenai .release = seq_release_private 316c778af7dSHariprasad Shenai }; 317c778af7dSHariprasad Shenai 318b3bbe36aSHariprasad Shenai /* Show the PM memory stats. These stats include: 319b3bbe36aSHariprasad Shenai * 320b3bbe36aSHariprasad Shenai * TX: 321b3bbe36aSHariprasad Shenai * Read: memory read operation 322b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 323b3bbe36aSHariprasad Shenai * Bypass + mem: cut-through and save copy 324b3bbe36aSHariprasad Shenai * 325b3bbe36aSHariprasad Shenai * RX: 326b3bbe36aSHariprasad Shenai * Read: memory read 327b3bbe36aSHariprasad Shenai * Write Bypass: cut-through 328b3bbe36aSHariprasad Shenai * Flush: payload trim or drop 329b3bbe36aSHariprasad Shenai */ 330b3bbe36aSHariprasad Shenai static int pm_stats_show(struct seq_file *seq, void *v) 331b3bbe36aSHariprasad Shenai { 332b3bbe36aSHariprasad Shenai static const char * const tx_pm_stats[] = { 333b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Bypass + mem:" 334b3bbe36aSHariprasad Shenai }; 335b3bbe36aSHariprasad Shenai static const char * const rx_pm_stats[] = { 336b3bbe36aSHariprasad Shenai "Read:", "Write bypass:", "Write mem:", "Flush:" 337b3bbe36aSHariprasad Shenai }; 338b3bbe36aSHariprasad Shenai 339b3bbe36aSHariprasad Shenai int i; 340b3bbe36aSHariprasad Shenai u32 tx_cnt[PM_NSTATS], rx_cnt[PM_NSTATS]; 341b3bbe36aSHariprasad Shenai u64 tx_cyc[PM_NSTATS], rx_cyc[PM_NSTATS]; 342b3bbe36aSHariprasad Shenai struct adapter *adap = seq->private; 343b3bbe36aSHariprasad Shenai 344b3bbe36aSHariprasad Shenai t4_pmtx_get_stats(adap, tx_cnt, tx_cyc); 345b3bbe36aSHariprasad Shenai t4_pmrx_get_stats(adap, rx_cnt, rx_cyc); 346b3bbe36aSHariprasad Shenai 347b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Tx pcmds", "Tx bytes"); 348b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 349b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 350b3bbe36aSHariprasad Shenai tx_pm_stats[i], tx_cnt[i], tx_cyc[i]); 351b3bbe36aSHariprasad Shenai 352b3bbe36aSHariprasad Shenai seq_printf(seq, "%13s %10s %20s\n", " ", "Rx pcmds", "Rx bytes"); 353b3bbe36aSHariprasad Shenai for (i = 0; i < PM_NSTATS - 1; i++) 354b3bbe36aSHariprasad Shenai seq_printf(seq, "%-13s %10u %20llu\n", 355b3bbe36aSHariprasad Shenai rx_pm_stats[i], rx_cnt[i], rx_cyc[i]); 356b3bbe36aSHariprasad Shenai return 0; 357b3bbe36aSHariprasad Shenai } 358b3bbe36aSHariprasad Shenai 359b3bbe36aSHariprasad Shenai static int pm_stats_open(struct inode *inode, struct file *file) 360b3bbe36aSHariprasad Shenai { 361b3bbe36aSHariprasad Shenai return single_open(file, pm_stats_show, inode->i_private); 362b3bbe36aSHariprasad Shenai } 363b3bbe36aSHariprasad Shenai 364b3bbe36aSHariprasad Shenai static ssize_t pm_stats_clear(struct file *file, const char __user *buf, 365b3bbe36aSHariprasad Shenai size_t count, loff_t *pos) 366b3bbe36aSHariprasad Shenai { 367b3bbe36aSHariprasad Shenai struct adapter *adap = FILE_DATA(file)->i_private; 368b3bbe36aSHariprasad Shenai 369b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0); 370b3bbe36aSHariprasad Shenai t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0); 371b3bbe36aSHariprasad Shenai return count; 372b3bbe36aSHariprasad Shenai } 373b3bbe36aSHariprasad Shenai 374b3bbe36aSHariprasad Shenai static const struct file_operations pm_stats_debugfs_fops = { 375b3bbe36aSHariprasad Shenai .owner = THIS_MODULE, 376b3bbe36aSHariprasad Shenai .open = pm_stats_open, 377b3bbe36aSHariprasad Shenai .read = seq_read, 378b3bbe36aSHariprasad Shenai .llseek = seq_lseek, 379b3bbe36aSHariprasad Shenai .release = single_release, 380b3bbe36aSHariprasad Shenai .write = pm_stats_clear 381b3bbe36aSHariprasad Shenai }; 382b3bbe36aSHariprasad Shenai 383b58b6676SHariprasad Shenai /* Format a value in a unit that differs from the value's native unit by the 384b58b6676SHariprasad Shenai * given factor. 385b58b6676SHariprasad Shenai */ 386b58b6676SHariprasad Shenai static char *unit_conv(char *buf, size_t len, unsigned int val, 387b58b6676SHariprasad Shenai unsigned int factor) 388b58b6676SHariprasad Shenai { 389b58b6676SHariprasad Shenai unsigned int rem = val % factor; 390b58b6676SHariprasad Shenai 391b58b6676SHariprasad Shenai if (rem == 0) { 392b58b6676SHariprasad Shenai snprintf(buf, len, "%u", val / factor); 393b58b6676SHariprasad Shenai } else { 394b58b6676SHariprasad Shenai while (rem % 10 == 0) 395b58b6676SHariprasad Shenai rem /= 10; 396b58b6676SHariprasad Shenai snprintf(buf, len, "%u.%u", val / factor, rem); 397b58b6676SHariprasad Shenai } 398b58b6676SHariprasad Shenai return buf; 399b58b6676SHariprasad Shenai } 400b58b6676SHariprasad Shenai 401b58b6676SHariprasad Shenai static int clk_show(struct seq_file *seq, void *v) 402b58b6676SHariprasad Shenai { 403b58b6676SHariprasad Shenai char buf[32]; 404b58b6676SHariprasad Shenai struct adapter *adap = seq->private; 405b58b6676SHariprasad Shenai unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk; /* in ps */ 406b58b6676SHariprasad Shenai u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A); 407b58b6676SHariprasad Shenai unsigned int tre = TIMERRESOLUTION_G(res); 408b58b6676SHariprasad Shenai unsigned int dack_re = DELAYEDACKRESOLUTION_G(res); 409b58b6676SHariprasad Shenai unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */ 410b58b6676SHariprasad Shenai 411b58b6676SHariprasad Shenai seq_printf(seq, "Core clock period: %s ns\n", 412b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), cclk_ps, 1000)); 413b58b6676SHariprasad Shenai seq_printf(seq, "TP timer tick: %s us\n", 414b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000)); 415b58b6676SHariprasad Shenai seq_printf(seq, "TCP timestamp tick: %s us\n", 416b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), 417b58b6676SHariprasad Shenai (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000)); 418b58b6676SHariprasad Shenai seq_printf(seq, "DACK tick: %s us\n", 419b58b6676SHariprasad Shenai unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000)); 420b58b6676SHariprasad Shenai seq_printf(seq, "DACK timer: %u us\n", 421b58b6676SHariprasad Shenai ((cclk_ps << dack_re) / 1000000) * 422b58b6676SHariprasad Shenai t4_read_reg(adap, TP_DACK_TIMER_A)); 423b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit min: %llu us\n", 424b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A)); 425b58b6676SHariprasad Shenai seq_printf(seq, "Retransmit max: %llu us\n", 426b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A)); 427b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer min: %llu us\n", 428b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A)); 429b58b6676SHariprasad Shenai seq_printf(seq, "Persist timer max: %llu us\n", 430b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A)); 431b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive idle timer: %llu us\n", 432b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A)); 433b58b6676SHariprasad Shenai seq_printf(seq, "Keepalive interval: %llu us\n", 434b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A)); 435b58b6676SHariprasad Shenai seq_printf(seq, "Initial SRTT: %llu us\n", 436b58b6676SHariprasad Shenai tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A))); 437b58b6676SHariprasad Shenai seq_printf(seq, "FINWAIT2 timer: %llu us\n", 438b58b6676SHariprasad Shenai tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A)); 439b58b6676SHariprasad Shenai 440b58b6676SHariprasad Shenai return 0; 441b58b6676SHariprasad Shenai } 442b58b6676SHariprasad Shenai 443b58b6676SHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(clk); 444b58b6676SHariprasad Shenai 445f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 44649aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 44749aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 44849aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 44949aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 45049aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 45149aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 45249aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 45349aa284fSHariprasad Shenai }; 45449aa284fSHariprasad Shenai 45549aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 45649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 45749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 45849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 45949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 46049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 46149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 46249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 46349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 46449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 46549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 46649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 46749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 46849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 46949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 47049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 47149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 47249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 47349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 47449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 47549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 47649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 47749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 47849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 47949aa284fSHariprasad Shenai }; 48049aa284fSHariprasad Shenai 48149aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 48249aa284fSHariprasad Shenai */ 48349aa284fSHariprasad Shenai struct devlog_info { 48449aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 48549aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 48649aa284fSHariprasad Shenai struct fw_devlog_e log[0]; /* Firmware Device Log */ 48749aa284fSHariprasad Shenai }; 48849aa284fSHariprasad Shenai 48949aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 49049aa284fSHariprasad Shenai */ 49149aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 49249aa284fSHariprasad Shenai { 49349aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 49449aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 49549aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 49649aa284fSHariprasad Shenai else { 49749aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 49849aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 49949aa284fSHariprasad Shenai unsigned long index; 50049aa284fSHariprasad Shenai struct fw_devlog_e *e; 50149aa284fSHariprasad Shenai 50249aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 50349aa284fSHariprasad Shenai * entries. 50449aa284fSHariprasad Shenai */ 50549aa284fSHariprasad Shenai index = dinfo->first + fidx; 50649aa284fSHariprasad Shenai if (index >= dinfo->nentries) 50749aa284fSHariprasad Shenai index -= dinfo->nentries; 50849aa284fSHariprasad Shenai e = &dinfo->log[index]; 50949aa284fSHariprasad Shenai if (e->timestamp == 0) 51049aa284fSHariprasad Shenai return 0; 51149aa284fSHariprasad Shenai 51249aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 51349aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 51449aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 51549aa284fSHariprasad Shenai */ 51649aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 51749aa284fSHariprasad Shenai e->seqno, e->timestamp, 51849aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 51949aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 52049aa284fSHariprasad Shenai : "UNKNOWN"), 52149aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 52249aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 52349aa284fSHariprasad Shenai : "UNKNOWN")); 52449aa284fSHariprasad Shenai seq_printf(seq, e->fmt, e->params[0], e->params[1], 52549aa284fSHariprasad Shenai e->params[2], e->params[3], e->params[4], 52649aa284fSHariprasad Shenai e->params[5], e->params[6], e->params[7]); 52749aa284fSHariprasad Shenai } 52849aa284fSHariprasad Shenai return 0; 52949aa284fSHariprasad Shenai } 53049aa284fSHariprasad Shenai 53149aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 53249aa284fSHariprasad Shenai */ 53349aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 53449aa284fSHariprasad Shenai { 53549aa284fSHariprasad Shenai if (pos > dinfo->nentries) 53649aa284fSHariprasad Shenai return NULL; 53749aa284fSHariprasad Shenai 53849aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 53949aa284fSHariprasad Shenai } 54049aa284fSHariprasad Shenai 54149aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 54249aa284fSHariprasad Shenai { 54349aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 54449aa284fSHariprasad Shenai 54549aa284fSHariprasad Shenai return (*pos 54649aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 54749aa284fSHariprasad Shenai : SEQ_START_TOKEN); 54849aa284fSHariprasad Shenai } 54949aa284fSHariprasad Shenai 55049aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 55149aa284fSHariprasad Shenai { 55249aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 55349aa284fSHariprasad Shenai 55449aa284fSHariprasad Shenai (*pos)++; 55549aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 55649aa284fSHariprasad Shenai } 55749aa284fSHariprasad Shenai 55849aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 55949aa284fSHariprasad Shenai { 56049aa284fSHariprasad Shenai } 56149aa284fSHariprasad Shenai 56249aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 56349aa284fSHariprasad Shenai .start = devlog_start, 56449aa284fSHariprasad Shenai .next = devlog_next, 56549aa284fSHariprasad Shenai .stop = devlog_stop, 56649aa284fSHariprasad Shenai .show = devlog_show 56749aa284fSHariprasad Shenai }; 56849aa284fSHariprasad Shenai 56949aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 57049aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 57149aa284fSHariprasad Shenai */ 57249aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 57349aa284fSHariprasad Shenai { 57449aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 57549aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 57649aa284fSHariprasad Shenai struct devlog_info *dinfo; 57749aa284fSHariprasad Shenai unsigned int index; 57849aa284fSHariprasad Shenai u32 fseqno; 57949aa284fSHariprasad Shenai int ret; 58049aa284fSHariprasad Shenai 58149aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 58249aa284fSHariprasad Shenai */ 58349aa284fSHariprasad Shenai if (dparams->start == 0) 58449aa284fSHariprasad Shenai return -ENXIO; 58549aa284fSHariprasad Shenai 58649aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 58749aa284fSHariprasad Shenai * for the iterated call to our display function. 58849aa284fSHariprasad Shenai */ 58949aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 59049aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 59149aa284fSHariprasad Shenai if (!dinfo) 59249aa284fSHariprasad Shenai return -ENOMEM; 59349aa284fSHariprasad Shenai 59449aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 59549aa284fSHariprasad Shenai */ 59649aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 59749aa284fSHariprasad Shenai dinfo->first = 0; 59849aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 59949aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 60049aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 60149aa284fSHariprasad Shenai T4_MEMORY_READ); 60249aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 60349aa284fSHariprasad Shenai if (ret) { 60449aa284fSHariprasad Shenai seq_release_private(inode, file); 60549aa284fSHariprasad Shenai return ret; 60649aa284fSHariprasad Shenai } 60749aa284fSHariprasad Shenai 60849aa284fSHariprasad Shenai /* Translate log multi-byte integral elements into host native format 60949aa284fSHariprasad Shenai * and determine where the first entry in the log is. 61049aa284fSHariprasad Shenai */ 61149aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 61249aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 61349aa284fSHariprasad Shenai int i; 61449aa284fSHariprasad Shenai __u32 seqno; 61549aa284fSHariprasad Shenai 61649aa284fSHariprasad Shenai if (e->timestamp == 0) 61749aa284fSHariprasad Shenai continue; 61849aa284fSHariprasad Shenai 61949aa284fSHariprasad Shenai e->timestamp = (__force __be64)be64_to_cpu(e->timestamp); 62049aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 62149aa284fSHariprasad Shenai for (i = 0; i < 8; i++) 62249aa284fSHariprasad Shenai e->params[i] = 62349aa284fSHariprasad Shenai (__force __be32)be32_to_cpu(e->params[i]); 62449aa284fSHariprasad Shenai 62549aa284fSHariprasad Shenai if (seqno < fseqno) { 62649aa284fSHariprasad Shenai fseqno = seqno; 62749aa284fSHariprasad Shenai dinfo->first = index; 62849aa284fSHariprasad Shenai } 62949aa284fSHariprasad Shenai } 63049aa284fSHariprasad Shenai return 0; 63149aa284fSHariprasad Shenai } 63249aa284fSHariprasad Shenai 63349aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 63449aa284fSHariprasad Shenai .owner = THIS_MODULE, 63549aa284fSHariprasad Shenai .open = devlog_open, 63649aa284fSHariprasad Shenai .read = seq_read, 63749aa284fSHariprasad Shenai .llseek = seq_lseek, 63849aa284fSHariprasad Shenai .release = seq_release_private 63949aa284fSHariprasad Shenai }; 64049aa284fSHariprasad Shenai 64149216c1cSHariprasad Shenai static ssize_t flash_read(struct file *file, char __user *buf, size_t count, 64249216c1cSHariprasad Shenai loff_t *ppos) 64349216c1cSHariprasad Shenai { 64449216c1cSHariprasad Shenai loff_t pos = *ppos; 64549216c1cSHariprasad Shenai loff_t avail = FILE_DATA(file)->i_size; 64649216c1cSHariprasad Shenai struct adapter *adap = file->private_data; 64749216c1cSHariprasad Shenai 64849216c1cSHariprasad Shenai if (pos < 0) 64949216c1cSHariprasad Shenai return -EINVAL; 65049216c1cSHariprasad Shenai if (pos >= avail) 65149216c1cSHariprasad Shenai return 0; 65249216c1cSHariprasad Shenai if (count > avail - pos) 65349216c1cSHariprasad Shenai count = avail - pos; 65449216c1cSHariprasad Shenai 65549216c1cSHariprasad Shenai while (count) { 65649216c1cSHariprasad Shenai size_t len; 65749216c1cSHariprasad Shenai int ret, ofst; 65849216c1cSHariprasad Shenai u8 data[256]; 65949216c1cSHariprasad Shenai 66049216c1cSHariprasad Shenai ofst = pos & 3; 66149216c1cSHariprasad Shenai len = min(count + ofst, sizeof(data)); 66249216c1cSHariprasad Shenai ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4, 66349216c1cSHariprasad Shenai (u32 *)data, 1); 66449216c1cSHariprasad Shenai if (ret) 66549216c1cSHariprasad Shenai return ret; 66649216c1cSHariprasad Shenai 66749216c1cSHariprasad Shenai len -= ofst; 66849216c1cSHariprasad Shenai if (copy_to_user(buf, data + ofst, len)) 66949216c1cSHariprasad Shenai return -EFAULT; 67049216c1cSHariprasad Shenai 67149216c1cSHariprasad Shenai buf += len; 67249216c1cSHariprasad Shenai pos += len; 67349216c1cSHariprasad Shenai count -= len; 67449216c1cSHariprasad Shenai } 67549216c1cSHariprasad Shenai count = pos - *ppos; 67649216c1cSHariprasad Shenai *ppos = pos; 67749216c1cSHariprasad Shenai return count; 67849216c1cSHariprasad Shenai } 67949216c1cSHariprasad Shenai 68049216c1cSHariprasad Shenai static const struct file_operations flash_debugfs_fops = { 68149216c1cSHariprasad Shenai .owner = THIS_MODULE, 68249216c1cSHariprasad Shenai .open = mem_open, 68349216c1cSHariprasad Shenai .read = flash_read, 68449216c1cSHariprasad Shenai }; 68549216c1cSHariprasad Shenai 686ef82f662SHariprasad Shenai static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask) 687ef82f662SHariprasad Shenai { 688ef82f662SHariprasad Shenai *mask = x | y; 689ef82f662SHariprasad Shenai y = (__force u64)cpu_to_be64(y); 690ef82f662SHariprasad Shenai memcpy(addr, (char *)&y + 2, ETH_ALEN); 691ef82f662SHariprasad Shenai } 692ef82f662SHariprasad Shenai 693ef82f662SHariprasad Shenai static int mps_tcam_show(struct seq_file *seq, void *v) 694ef82f662SHariprasad Shenai { 695ef82f662SHariprasad Shenai if (v == SEQ_START_TOKEN) 696ef82f662SHariprasad Shenai seq_puts(seq, "Idx Ethernet address Mask Vld Ports PF" 697ef82f662SHariprasad Shenai " VF Replication " 698ef82f662SHariprasad Shenai "P0 P1 P2 P3 ML\n"); 699ef82f662SHariprasad Shenai else { 700ef82f662SHariprasad Shenai u64 mask; 701ef82f662SHariprasad Shenai u8 addr[ETH_ALEN]; 702ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 703ef82f662SHariprasad Shenai unsigned int idx = (uintptr_t)v - 2; 704ef82f662SHariprasad Shenai u64 tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx)); 705ef82f662SHariprasad Shenai u64 tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx)); 706ef82f662SHariprasad Shenai u32 cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx)); 707ef82f662SHariprasad Shenai u32 cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx)); 708ef82f662SHariprasad Shenai u32 rplc[4] = {0, 0, 0, 0}; 709ef82f662SHariprasad Shenai 710ef82f662SHariprasad Shenai if (tcamx & tcamy) { 711ef82f662SHariprasad Shenai seq_printf(seq, "%3u -\n", idx); 712ef82f662SHariprasad Shenai goto out; 713ef82f662SHariprasad Shenai } 714ef82f662SHariprasad Shenai 715ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) { 716ef82f662SHariprasad Shenai struct fw_ldst_cmd ldst_cmd; 717ef82f662SHariprasad Shenai int ret; 718ef82f662SHariprasad Shenai 719ef82f662SHariprasad Shenai memset(&ldst_cmd, 0, sizeof(ldst_cmd)); 720ef82f662SHariprasad Shenai ldst_cmd.op_to_addrspace = 721ef82f662SHariprasad Shenai htonl(FW_CMD_OP_V(FW_LDST_CMD) | 722ef82f662SHariprasad Shenai FW_CMD_REQUEST_F | 723ef82f662SHariprasad Shenai FW_CMD_READ_F | 724ef82f662SHariprasad Shenai FW_LDST_CMD_ADDRSPACE_V( 725ef82f662SHariprasad Shenai FW_LDST_ADDRSPC_MPS)); 726ef82f662SHariprasad Shenai ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd)); 727ef82f662SHariprasad Shenai ldst_cmd.u.mps.fid_ctl = 728ef82f662SHariprasad Shenai htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) | 729ef82f662SHariprasad Shenai FW_LDST_CMD_CTL_V(idx)); 730ef82f662SHariprasad Shenai ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd, 731ef82f662SHariprasad Shenai sizeof(ldst_cmd), &ldst_cmd); 732ef82f662SHariprasad Shenai if (ret) 733ef82f662SHariprasad Shenai dev_warn(adap->pdev_dev, "Can't read MPS " 734ef82f662SHariprasad Shenai "replication map for idx %d: %d\n", 735ef82f662SHariprasad Shenai idx, -ret); 736ef82f662SHariprasad Shenai else { 737ef82f662SHariprasad Shenai rplc[0] = ntohl(ldst_cmd.u.mps.rplc31_0); 738ef82f662SHariprasad Shenai rplc[1] = ntohl(ldst_cmd.u.mps.rplc63_32); 739ef82f662SHariprasad Shenai rplc[2] = ntohl(ldst_cmd.u.mps.rplc95_64); 740ef82f662SHariprasad Shenai rplc[3] = ntohl(ldst_cmd.u.mps.rplc127_96); 741ef82f662SHariprasad Shenai } 742ef82f662SHariprasad Shenai } 743ef82f662SHariprasad Shenai 744ef82f662SHariprasad Shenai tcamxy2valmask(tcamx, tcamy, addr, &mask); 745ef82f662SHariprasad Shenai seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x %012llx" 746ef82f662SHariprasad Shenai "%3c %#x%4u%4d", 747ef82f662SHariprasad Shenai idx, addr[0], addr[1], addr[2], addr[3], addr[4], 748ef82f662SHariprasad Shenai addr[5], (unsigned long long)mask, 749ef82f662SHariprasad Shenai (cls_lo & SRAM_VLD_F) ? 'Y' : 'N', PORTMAP_G(cls_hi), 750ef82f662SHariprasad Shenai PF_G(cls_lo), 751ef82f662SHariprasad Shenai (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1); 752ef82f662SHariprasad Shenai if (cls_lo & REPLICATE_F) 753ef82f662SHariprasad Shenai seq_printf(seq, " %08x %08x %08x %08x", 754ef82f662SHariprasad Shenai rplc[3], rplc[2], rplc[1], rplc[0]); 755ef82f662SHariprasad Shenai else 756ef82f662SHariprasad Shenai seq_printf(seq, "%36c", ' '); 757ef82f662SHariprasad Shenai seq_printf(seq, "%4u%3u%3u%3u %#x\n", 758ef82f662SHariprasad Shenai SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo), 759ef82f662SHariprasad Shenai SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo), 760ef82f662SHariprasad Shenai (cls_lo >> MULTILISTEN0_S) & 0xf); 761ef82f662SHariprasad Shenai } 762ef82f662SHariprasad Shenai out: return 0; 763ef82f662SHariprasad Shenai } 764ef82f662SHariprasad Shenai 765ef82f662SHariprasad Shenai static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos) 766ef82f662SHariprasad Shenai { 767ef82f662SHariprasad Shenai struct adapter *adap = seq->private; 768ef82f662SHariprasad Shenai int max_mac_addr = is_t4(adap->params.chip) ? 769ef82f662SHariprasad Shenai NUM_MPS_CLS_SRAM_L_INSTANCES : 770ef82f662SHariprasad Shenai NUM_MPS_T5_CLS_SRAM_L_INSTANCES; 771ef82f662SHariprasad Shenai return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL); 772ef82f662SHariprasad Shenai } 773ef82f662SHariprasad Shenai 774ef82f662SHariprasad Shenai static void *mps_tcam_start(struct seq_file *seq, loff_t *pos) 775ef82f662SHariprasad Shenai { 776ef82f662SHariprasad Shenai return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN; 777ef82f662SHariprasad Shenai } 778ef82f662SHariprasad Shenai 779ef82f662SHariprasad Shenai static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos) 780ef82f662SHariprasad Shenai { 781ef82f662SHariprasad Shenai ++*pos; 782ef82f662SHariprasad Shenai return mps_tcam_get_idx(seq, *pos); 783ef82f662SHariprasad Shenai } 784ef82f662SHariprasad Shenai 785ef82f662SHariprasad Shenai static void mps_tcam_stop(struct seq_file *seq, void *v) 786ef82f662SHariprasad Shenai { 787ef82f662SHariprasad Shenai } 788ef82f662SHariprasad Shenai 789ef82f662SHariprasad Shenai static const struct seq_operations mps_tcam_seq_ops = { 790ef82f662SHariprasad Shenai .start = mps_tcam_start, 791ef82f662SHariprasad Shenai .next = mps_tcam_next, 792ef82f662SHariprasad Shenai .stop = mps_tcam_stop, 793ef82f662SHariprasad Shenai .show = mps_tcam_show 794ef82f662SHariprasad Shenai }; 795ef82f662SHariprasad Shenai 796ef82f662SHariprasad Shenai static int mps_tcam_open(struct inode *inode, struct file *file) 797ef82f662SHariprasad Shenai { 798ef82f662SHariprasad Shenai int res = seq_open(file, &mps_tcam_seq_ops); 799ef82f662SHariprasad Shenai 800ef82f662SHariprasad Shenai if (!res) { 801ef82f662SHariprasad Shenai struct seq_file *seq = file->private_data; 802ef82f662SHariprasad Shenai 803ef82f662SHariprasad Shenai seq->private = inode->i_private; 804ef82f662SHariprasad Shenai } 805ef82f662SHariprasad Shenai return res; 806ef82f662SHariprasad Shenai } 807ef82f662SHariprasad Shenai 808ef82f662SHariprasad Shenai static const struct file_operations mps_tcam_debugfs_fops = { 809ef82f662SHariprasad Shenai .owner = THIS_MODULE, 810ef82f662SHariprasad Shenai .open = mps_tcam_open, 811ef82f662SHariprasad Shenai .read = seq_read, 812ef82f662SHariprasad Shenai .llseek = seq_lseek, 813ef82f662SHariprasad Shenai .release = seq_release, 814ef82f662SHariprasad Shenai }; 815ef82f662SHariprasad Shenai 81670a5f3bbSHariprasad Shenai /* Display various sensor information. 81770a5f3bbSHariprasad Shenai */ 81870a5f3bbSHariprasad Shenai static int sensors_show(struct seq_file *seq, void *v) 81970a5f3bbSHariprasad Shenai { 82070a5f3bbSHariprasad Shenai struct adapter *adap = seq->private; 82170a5f3bbSHariprasad Shenai u32 param[7], val[7]; 82270a5f3bbSHariprasad Shenai int ret; 82370a5f3bbSHariprasad Shenai 82470a5f3bbSHariprasad Shenai /* Note that if the sensors haven't been initialized and turned on 82570a5f3bbSHariprasad Shenai * we'll get values of 0, so treat those as "<unknown>" ... 82670a5f3bbSHariprasad Shenai */ 82770a5f3bbSHariprasad Shenai param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 82870a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 82970a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP)); 83070a5f3bbSHariprasad Shenai param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 83170a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) | 83270a5f3bbSHariprasad Shenai FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD)); 83370a5f3bbSHariprasad Shenai ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, 83470a5f3bbSHariprasad Shenai param, val); 83570a5f3bbSHariprasad Shenai 83670a5f3bbSHariprasad Shenai if (ret < 0 || val[0] == 0) 83770a5f3bbSHariprasad Shenai seq_puts(seq, "Temperature: <unknown>\n"); 83870a5f3bbSHariprasad Shenai else 83970a5f3bbSHariprasad Shenai seq_printf(seq, "Temperature: %dC\n", val[0]); 84070a5f3bbSHariprasad Shenai 84170a5f3bbSHariprasad Shenai if (ret < 0 || val[1] == 0) 84270a5f3bbSHariprasad Shenai seq_puts(seq, "Core VDD: <unknown>\n"); 84370a5f3bbSHariprasad Shenai else 84470a5f3bbSHariprasad Shenai seq_printf(seq, "Core VDD: %dmV\n", val[1]); 84570a5f3bbSHariprasad Shenai 84670a5f3bbSHariprasad Shenai return 0; 84770a5f3bbSHariprasad Shenai } 84870a5f3bbSHariprasad Shenai 84970a5f3bbSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(sensors); 85070a5f3bbSHariprasad Shenai 851b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 852b5a02f50SAnish Bhatt static int clip_tbl_open(struct inode *inode, struct file *file) 853b5a02f50SAnish Bhatt { 854b5a02f50SAnish Bhatt return single_open(file, clip_tbl_show, PDE_DATA(inode)); 855b5a02f50SAnish Bhatt } 856b5a02f50SAnish Bhatt 857b5a02f50SAnish Bhatt static const struct file_operations clip_tbl_debugfs_fops = { 858b5a02f50SAnish Bhatt .owner = THIS_MODULE, 859b5a02f50SAnish Bhatt .open = clip_tbl_open, 860b5a02f50SAnish Bhatt .read = seq_read, 861b5a02f50SAnish Bhatt .llseek = seq_lseek, 862b5a02f50SAnish Bhatt .release = single_release 863b5a02f50SAnish Bhatt }; 864b5a02f50SAnish Bhatt #endif 865b5a02f50SAnish Bhatt 866688ea5feSHariprasad Shenai /*RSS Table. 867688ea5feSHariprasad Shenai */ 868688ea5feSHariprasad Shenai 869688ea5feSHariprasad Shenai static int rss_show(struct seq_file *seq, void *v, int idx) 870688ea5feSHariprasad Shenai { 871688ea5feSHariprasad Shenai u16 *entry = v; 872688ea5feSHariprasad Shenai 873688ea5feSHariprasad Shenai seq_printf(seq, "%4d: %4u %4u %4u %4u %4u %4u %4u %4u\n", 874688ea5feSHariprasad Shenai idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4], 875688ea5feSHariprasad Shenai entry[5], entry[6], entry[7]); 876688ea5feSHariprasad Shenai return 0; 877688ea5feSHariprasad Shenai } 878688ea5feSHariprasad Shenai 879688ea5feSHariprasad Shenai static int rss_open(struct inode *inode, struct file *file) 880688ea5feSHariprasad Shenai { 881688ea5feSHariprasad Shenai int ret; 882688ea5feSHariprasad Shenai struct seq_tab *p; 883688ea5feSHariprasad Shenai struct adapter *adap = inode->i_private; 884688ea5feSHariprasad Shenai 885688ea5feSHariprasad Shenai p = seq_open_tab(file, RSS_NENTRIES / 8, 8 * sizeof(u16), 0, rss_show); 886688ea5feSHariprasad Shenai if (!p) 887688ea5feSHariprasad Shenai return -ENOMEM; 888688ea5feSHariprasad Shenai 889688ea5feSHariprasad Shenai ret = t4_read_rss(adap, (u16 *)p->data); 890688ea5feSHariprasad Shenai if (ret) 891688ea5feSHariprasad Shenai seq_release_private(inode, file); 892688ea5feSHariprasad Shenai 893688ea5feSHariprasad Shenai return ret; 894688ea5feSHariprasad Shenai } 895688ea5feSHariprasad Shenai 896688ea5feSHariprasad Shenai static const struct file_operations rss_debugfs_fops = { 897688ea5feSHariprasad Shenai .owner = THIS_MODULE, 898688ea5feSHariprasad Shenai .open = rss_open, 899688ea5feSHariprasad Shenai .read = seq_read, 900688ea5feSHariprasad Shenai .llseek = seq_lseek, 901688ea5feSHariprasad Shenai .release = seq_release_private 902688ea5feSHariprasad Shenai }; 903688ea5feSHariprasad Shenai 904688ea5feSHariprasad Shenai /* RSS Configuration. 905688ea5feSHariprasad Shenai */ 906688ea5feSHariprasad Shenai 907688ea5feSHariprasad Shenai /* Small utility function to return the strings "yes" or "no" if the supplied 908688ea5feSHariprasad Shenai * argument is non-zero. 909688ea5feSHariprasad Shenai */ 910688ea5feSHariprasad Shenai static const char *yesno(int x) 911688ea5feSHariprasad Shenai { 912688ea5feSHariprasad Shenai static const char *yes = "yes"; 913688ea5feSHariprasad Shenai static const char *no = "no"; 914688ea5feSHariprasad Shenai 915688ea5feSHariprasad Shenai return x ? yes : no; 916688ea5feSHariprasad Shenai } 917688ea5feSHariprasad Shenai 918688ea5feSHariprasad Shenai static int rss_config_show(struct seq_file *seq, void *v) 919688ea5feSHariprasad Shenai { 920688ea5feSHariprasad Shenai struct adapter *adapter = seq->private; 921688ea5feSHariprasad Shenai static const char * const keymode[] = { 922688ea5feSHariprasad Shenai "global", 923688ea5feSHariprasad Shenai "global and per-VF scramble", 924688ea5feSHariprasad Shenai "per-PF and per-VF scramble", 925688ea5feSHariprasad Shenai "per-VF and per-VF scramble", 926688ea5feSHariprasad Shenai }; 927688ea5feSHariprasad Shenai u32 rssconf; 928688ea5feSHariprasad Shenai 929688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A); 930688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf); 931688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv6: %3s\n", yesno(rssconf & 932688ea5feSHariprasad Shenai TNL4TUPENIPV6_F)); 933688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv6: %3s\n", yesno(rssconf & 934688ea5feSHariprasad Shenai TNL2TUPENIPV6_F)); 935688ea5feSHariprasad Shenai seq_printf(seq, " Tnl4TupEnIpv4: %3s\n", yesno(rssconf & 936688ea5feSHariprasad Shenai TNL4TUPENIPV4_F)); 937688ea5feSHariprasad Shenai seq_printf(seq, " Tnl2TupEnIpv4: %3s\n", yesno(rssconf & 938688ea5feSHariprasad Shenai TNL2TUPENIPV4_F)); 939688ea5feSHariprasad Shenai seq_printf(seq, " TnlTcpSel: %3s\n", yesno(rssconf & TNLTCPSEL_F)); 940688ea5feSHariprasad Shenai seq_printf(seq, " TnlIp6Sel: %3s\n", yesno(rssconf & TNLIP6SEL_F)); 941688ea5feSHariprasad Shenai seq_printf(seq, " TnlVrtSel: %3s\n", yesno(rssconf & TNLVRTSEL_F)); 942688ea5feSHariprasad Shenai seq_printf(seq, " TnlMapEn: %3s\n", yesno(rssconf & TNLMAPEN_F)); 943688ea5feSHariprasad Shenai seq_printf(seq, " OfdHashSave: %3s\n", yesno(rssconf & 944688ea5feSHariprasad Shenai OFDHASHSAVE_F)); 945688ea5feSHariprasad Shenai seq_printf(seq, " OfdVrtSel: %3s\n", yesno(rssconf & OFDVRTSEL_F)); 946688ea5feSHariprasad Shenai seq_printf(seq, " OfdMapEn: %3s\n", yesno(rssconf & OFDMAPEN_F)); 947688ea5feSHariprasad Shenai seq_printf(seq, " OfdLkpEn: %3s\n", yesno(rssconf & OFDLKPEN_F)); 948688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 949688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 950688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv6: %3s\n", yesno(rssconf & 951688ea5feSHariprasad Shenai SYN2TUPENIPV6_F)); 952688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv4: %3s\n", yesno(rssconf & 953688ea5feSHariprasad Shenai SYN4TUPENIPV4_F)); 954688ea5feSHariprasad Shenai seq_printf(seq, " Syn2TupEnIpv4: %3s\n", yesno(rssconf & 955688ea5feSHariprasad Shenai SYN2TUPENIPV4_F)); 956688ea5feSHariprasad Shenai seq_printf(seq, " Syn4TupEnIpv6: %3s\n", yesno(rssconf & 957688ea5feSHariprasad Shenai SYN4TUPENIPV6_F)); 958688ea5feSHariprasad Shenai seq_printf(seq, " SynIp6Sel: %3s\n", yesno(rssconf & SYNIP6SEL_F)); 959688ea5feSHariprasad Shenai seq_printf(seq, " SynVrt6Sel: %3s\n", yesno(rssconf & SYNVRTSEL_F)); 960688ea5feSHariprasad Shenai seq_printf(seq, " SynMapEn: %3s\n", yesno(rssconf & SYNMAPEN_F)); 961688ea5feSHariprasad Shenai seq_printf(seq, " SynLkpEn: %3s\n", yesno(rssconf & SYNLKPEN_F)); 962688ea5feSHariprasad Shenai seq_printf(seq, " ChnEn: %3s\n", yesno(rssconf & 963688ea5feSHariprasad Shenai CHANNELENABLE_F)); 964688ea5feSHariprasad Shenai seq_printf(seq, " PrtEn: %3s\n", yesno(rssconf & 965688ea5feSHariprasad Shenai PORTENABLE_F)); 966688ea5feSHariprasad Shenai seq_printf(seq, " TnlAllLkp: %3s\n", yesno(rssconf & 967688ea5feSHariprasad Shenai TNLALLLOOKUP_F)); 968688ea5feSHariprasad Shenai seq_printf(seq, " VrtEn: %3s\n", yesno(rssconf & 969688ea5feSHariprasad Shenai VIRTENABLE_F)); 970688ea5feSHariprasad Shenai seq_printf(seq, " CngEn: %3s\n", yesno(rssconf & 971688ea5feSHariprasad Shenai CONGESTIONENABLE_F)); 972688ea5feSHariprasad Shenai seq_printf(seq, " HashToeplitz: %3s\n", yesno(rssconf & 973688ea5feSHariprasad Shenai HASHTOEPLITZ_F)); 974688ea5feSHariprasad Shenai seq_printf(seq, " Udp4En: %3s\n", yesno(rssconf & UDPENABLE_F)); 975688ea5feSHariprasad Shenai seq_printf(seq, " Disable: %3s\n", yesno(rssconf & DISABLE_F)); 976688ea5feSHariprasad Shenai 977688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 978688ea5feSHariprasad Shenai 979688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A); 980688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf); 981688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 982688ea5feSHariprasad Shenai seq_printf(seq, " MaskFilter: %3d\n", MASKFILTER_G(rssconf)); 983688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 984688ea5feSHariprasad Shenai seq_printf(seq, " HashAll: %3s\n", 985688ea5feSHariprasad Shenai yesno(rssconf & HASHALL_F)); 986688ea5feSHariprasad Shenai seq_printf(seq, " HashEth: %3s\n", 987688ea5feSHariprasad Shenai yesno(rssconf & HASHETH_F)); 988688ea5feSHariprasad Shenai } 989688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 990688ea5feSHariprasad Shenai 991688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 992688ea5feSHariprasad Shenai 993688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A); 994688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf); 995688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 996688ea5feSHariprasad Shenai seq_printf(seq, " RRCplMapEn: %3s\n", yesno(rssconf & 997688ea5feSHariprasad Shenai RRCPLMAPEN_F)); 998688ea5feSHariprasad Shenai seq_printf(seq, " RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf)); 999688ea5feSHariprasad Shenai 1000688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1001688ea5feSHariprasad Shenai 1002688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A); 1003688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf); 1004688ea5feSHariprasad Shenai seq_printf(seq, " MaskSize: %3d\n", MASKSIZE_G(rssconf)); 1005688ea5feSHariprasad Shenai seq_printf(seq, " UseWireCh: %3s\n", yesno(rssconf & USEWIRECH_F)); 1006688ea5feSHariprasad Shenai 1007688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1008688ea5feSHariprasad Shenai 1009688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A); 1010688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf); 1011688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) { 1012688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddrX: %3d\n", 1013688ea5feSHariprasad Shenai KEYWRADDRX_G(rssconf)); 1014688ea5feSHariprasad Shenai seq_printf(seq, " KeyExtend: %3s\n", 1015688ea5feSHariprasad Shenai yesno(rssconf & KEYEXTEND_F)); 1016688ea5feSHariprasad Shenai } 1017688ea5feSHariprasad Shenai seq_printf(seq, " VfRdRg: %3s\n", yesno(rssconf & VFRDRG_F)); 1018688ea5feSHariprasad Shenai seq_printf(seq, " VfRdEn: %3s\n", yesno(rssconf & VFRDEN_F)); 1019688ea5feSHariprasad Shenai seq_printf(seq, " VfPerrEn: %3s\n", yesno(rssconf & VFPERREN_F)); 1020688ea5feSHariprasad Shenai seq_printf(seq, " KeyPerrEn: %3s\n", yesno(rssconf & KEYPERREN_F)); 1021688ea5feSHariprasad Shenai seq_printf(seq, " DisVfVlan: %3s\n", yesno(rssconf & 1022688ea5feSHariprasad Shenai DISABLEVLAN_F)); 1023688ea5feSHariprasad Shenai seq_printf(seq, " EnUpSwt: %3s\n", yesno(rssconf & ENABLEUP0_F)); 1024688ea5feSHariprasad Shenai seq_printf(seq, " HashDelay: %3d\n", HASHDELAY_G(rssconf)); 1025688ea5feSHariprasad Shenai if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5) 1026688ea5feSHariprasad Shenai seq_printf(seq, " VfWrAddr: %3d\n", VFWRADDR_G(rssconf)); 1027688ea5feSHariprasad Shenai seq_printf(seq, " KeyMode: %s\n", keymode[KEYMODE_G(rssconf)]); 1028688ea5feSHariprasad Shenai seq_printf(seq, " VfWrEn: %3s\n", yesno(rssconf & VFWREN_F)); 1029688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrEn: %3s\n", yesno(rssconf & KEYWREN_F)); 1030688ea5feSHariprasad Shenai seq_printf(seq, " KeyWrAddr: %3d\n", KEYWRADDR_G(rssconf)); 1031688ea5feSHariprasad Shenai 1032688ea5feSHariprasad Shenai seq_puts(seq, "\n"); 1033688ea5feSHariprasad Shenai 1034688ea5feSHariprasad Shenai rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A); 1035688ea5feSHariprasad Shenai seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf); 1036688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount3: %3s\n", yesno(rssconf & CHNCOUNT3_F)); 1037688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount2: %3s\n", yesno(rssconf & CHNCOUNT2_F)); 1038688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount1: %3s\n", yesno(rssconf & CHNCOUNT1_F)); 1039688ea5feSHariprasad Shenai seq_printf(seq, " ChnCount0: %3s\n", yesno(rssconf & CHNCOUNT0_F)); 1040688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow3: %3s\n", yesno(rssconf & 1041688ea5feSHariprasad Shenai CHNUNDFLOW3_F)); 1042688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow2: %3s\n", yesno(rssconf & 1043688ea5feSHariprasad Shenai CHNUNDFLOW2_F)); 1044688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow1: %3s\n", yesno(rssconf & 1045688ea5feSHariprasad Shenai CHNUNDFLOW1_F)); 1046688ea5feSHariprasad Shenai seq_printf(seq, " ChnUndFlow0: %3s\n", yesno(rssconf & 1047688ea5feSHariprasad Shenai CHNUNDFLOW0_F)); 1048688ea5feSHariprasad Shenai seq_printf(seq, " RstChn3: %3s\n", yesno(rssconf & RSTCHN3_F)); 1049688ea5feSHariprasad Shenai seq_printf(seq, " RstChn2: %3s\n", yesno(rssconf & RSTCHN2_F)); 1050688ea5feSHariprasad Shenai seq_printf(seq, " RstChn1: %3s\n", yesno(rssconf & RSTCHN1_F)); 1051688ea5feSHariprasad Shenai seq_printf(seq, " RstChn0: %3s\n", yesno(rssconf & RSTCHN0_F)); 1052688ea5feSHariprasad Shenai seq_printf(seq, " UpdVld: %3s\n", yesno(rssconf & UPDVLD_F)); 1053688ea5feSHariprasad Shenai seq_printf(seq, " Xoff: %3s\n", yesno(rssconf & XOFF_F)); 1054688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn3: %3s\n", yesno(rssconf & UPDCHN3_F)); 1055688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn2: %3s\n", yesno(rssconf & UPDCHN2_F)); 1056688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn1: %3s\n", yesno(rssconf & UPDCHN1_F)); 1057688ea5feSHariprasad Shenai seq_printf(seq, " UpdChn0: %3s\n", yesno(rssconf & UPDCHN0_F)); 1058688ea5feSHariprasad Shenai seq_printf(seq, " Queue: %3d\n", QUEUE_G(rssconf)); 1059688ea5feSHariprasad Shenai 1060688ea5feSHariprasad Shenai return 0; 1061688ea5feSHariprasad Shenai } 1062688ea5feSHariprasad Shenai 1063688ea5feSHariprasad Shenai DEFINE_SIMPLE_DEBUGFS_FILE(rss_config); 1064688ea5feSHariprasad Shenai 1065688ea5feSHariprasad Shenai /* RSS Secret Key. 1066688ea5feSHariprasad Shenai */ 1067688ea5feSHariprasad Shenai 1068688ea5feSHariprasad Shenai static int rss_key_show(struct seq_file *seq, void *v) 1069688ea5feSHariprasad Shenai { 1070688ea5feSHariprasad Shenai u32 key[10]; 1071688ea5feSHariprasad Shenai 1072688ea5feSHariprasad Shenai t4_read_rss_key(seq->private, key); 1073688ea5feSHariprasad Shenai seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", 1074688ea5feSHariprasad Shenai key[9], key[8], key[7], key[6], key[5], key[4], key[3], 1075688ea5feSHariprasad Shenai key[2], key[1], key[0]); 1076688ea5feSHariprasad Shenai return 0; 1077688ea5feSHariprasad Shenai } 1078688ea5feSHariprasad Shenai 1079688ea5feSHariprasad Shenai static int rss_key_open(struct inode *inode, struct file *file) 1080688ea5feSHariprasad Shenai { 1081688ea5feSHariprasad Shenai return single_open(file, rss_key_show, inode->i_private); 1082688ea5feSHariprasad Shenai } 1083688ea5feSHariprasad Shenai 1084688ea5feSHariprasad Shenai static ssize_t rss_key_write(struct file *file, const char __user *buf, 1085688ea5feSHariprasad Shenai size_t count, loff_t *pos) 1086688ea5feSHariprasad Shenai { 1087688ea5feSHariprasad Shenai int i, j; 1088688ea5feSHariprasad Shenai u32 key[10]; 1089688ea5feSHariprasad Shenai char s[100], *p; 1090688ea5feSHariprasad Shenai struct adapter *adap = FILE_DATA(file)->i_private; 1091688ea5feSHariprasad Shenai 1092688ea5feSHariprasad Shenai if (count > sizeof(s) - 1) 1093688ea5feSHariprasad Shenai return -EINVAL; 1094688ea5feSHariprasad Shenai if (copy_from_user(s, buf, count)) 1095688ea5feSHariprasad Shenai return -EFAULT; 1096688ea5feSHariprasad Shenai for (i = count; i > 0 && isspace(s[i - 1]); i--) 1097688ea5feSHariprasad Shenai ; 1098688ea5feSHariprasad Shenai s[i] = '\0'; 1099688ea5feSHariprasad Shenai 1100688ea5feSHariprasad Shenai for (p = s, i = 9; i >= 0; i--) { 1101688ea5feSHariprasad Shenai key[i] = 0; 1102688ea5feSHariprasad Shenai for (j = 0; j < 8; j++, p++) { 1103688ea5feSHariprasad Shenai if (!isxdigit(*p)) 1104688ea5feSHariprasad Shenai return -EINVAL; 1105688ea5feSHariprasad Shenai key[i] = (key[i] << 4) | hex2val(*p); 1106688ea5feSHariprasad Shenai } 1107688ea5feSHariprasad Shenai } 1108688ea5feSHariprasad Shenai 1109688ea5feSHariprasad Shenai t4_write_rss_key(adap, key, -1); 1110688ea5feSHariprasad Shenai return count; 1111688ea5feSHariprasad Shenai } 1112688ea5feSHariprasad Shenai 1113688ea5feSHariprasad Shenai static const struct file_operations rss_key_debugfs_fops = { 1114688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1115688ea5feSHariprasad Shenai .open = rss_key_open, 1116688ea5feSHariprasad Shenai .read = seq_read, 1117688ea5feSHariprasad Shenai .llseek = seq_lseek, 1118688ea5feSHariprasad Shenai .release = single_release, 1119688ea5feSHariprasad Shenai .write = rss_key_write 1120688ea5feSHariprasad Shenai }; 1121688ea5feSHariprasad Shenai 1122688ea5feSHariprasad Shenai /* PF RSS Configuration. 1123688ea5feSHariprasad Shenai */ 1124688ea5feSHariprasad Shenai 1125688ea5feSHariprasad Shenai struct rss_pf_conf { 1126688ea5feSHariprasad Shenai u32 rss_pf_map; 1127688ea5feSHariprasad Shenai u32 rss_pf_mask; 1128688ea5feSHariprasad Shenai u32 rss_pf_config; 1129688ea5feSHariprasad Shenai }; 1130688ea5feSHariprasad Shenai 1131688ea5feSHariprasad Shenai static int rss_pf_config_show(struct seq_file *seq, void *v, int idx) 1132688ea5feSHariprasad Shenai { 1133688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1134688ea5feSHariprasad Shenai 1135688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1136688ea5feSHariprasad Shenai /* use the 0th entry to dump the PF Map Index Size */ 1137688ea5feSHariprasad Shenai pfconf = seq->private + offsetof(struct seq_tab, data); 1138688ea5feSHariprasad Shenai seq_printf(seq, "PF Map Index Size = %d\n\n", 1139688ea5feSHariprasad Shenai LKPIDXSIZE_G(pfconf->rss_pf_map)); 1140688ea5feSHariprasad Shenai 1141688ea5feSHariprasad Shenai seq_puts(seq, " RSS PF VF Hash Tuple Enable Default\n"); 1142688ea5feSHariprasad Shenai seq_puts(seq, " Enable IPF Mask Mask IPv6 IPv4 UDP Queue\n"); 1143688ea5feSHariprasad Shenai seq_puts(seq, " PF Map Chn Prt Map Size Size Four Two Four Two Four Ch1 Ch0\n"); 1144688ea5feSHariprasad Shenai } else { 1145688ea5feSHariprasad Shenai #define G_PFnLKPIDX(map, n) \ 1146688ea5feSHariprasad Shenai (((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M) 1147688ea5feSHariprasad Shenai #define G_PFnMSKSIZE(mask, n) \ 1148688ea5feSHariprasad Shenai (((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M) 1149688ea5feSHariprasad Shenai 1150688ea5feSHariprasad Shenai pfconf = v; 1151688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3s %3d %3d %3d %3s %3s %3s %3s %3s %3d %3d\n", 1152688ea5feSHariprasad Shenai idx, 1153688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & MAPENABLE_F), 1154688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & CHNENABLE_F), 1155688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & PRTENABLE_F), 1156688ea5feSHariprasad Shenai G_PFnLKPIDX(pfconf->rss_pf_map, idx), 1157688ea5feSHariprasad Shenai G_PFnMSKSIZE(pfconf->rss_pf_mask, idx), 1158688ea5feSHariprasad Shenai IVFWIDTH_G(pfconf->rss_pf_config), 1159688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F), 1160688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F), 1161688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F), 1162688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F), 1163688ea5feSHariprasad Shenai yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F), 1164688ea5feSHariprasad Shenai CH1DEFAULTQUEUE_G(pfconf->rss_pf_config), 1165688ea5feSHariprasad Shenai CH0DEFAULTQUEUE_G(pfconf->rss_pf_config)); 1166688ea5feSHariprasad Shenai 1167688ea5feSHariprasad Shenai #undef G_PFnLKPIDX 1168688ea5feSHariprasad Shenai #undef G_PFnMSKSIZE 1169688ea5feSHariprasad Shenai } 1170688ea5feSHariprasad Shenai return 0; 1171688ea5feSHariprasad Shenai } 1172688ea5feSHariprasad Shenai 1173688ea5feSHariprasad Shenai static int rss_pf_config_open(struct inode *inode, struct file *file) 1174688ea5feSHariprasad Shenai { 1175688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1176688ea5feSHariprasad Shenai struct seq_tab *p; 1177688ea5feSHariprasad Shenai u32 rss_pf_map, rss_pf_mask; 1178688ea5feSHariprasad Shenai struct rss_pf_conf *pfconf; 1179688ea5feSHariprasad Shenai int pf; 1180688ea5feSHariprasad Shenai 1181688ea5feSHariprasad Shenai p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show); 1182688ea5feSHariprasad Shenai if (!p) 1183688ea5feSHariprasad Shenai return -ENOMEM; 1184688ea5feSHariprasad Shenai 1185688ea5feSHariprasad Shenai pfconf = (struct rss_pf_conf *)p->data; 1186688ea5feSHariprasad Shenai rss_pf_map = t4_read_rss_pf_map(adapter); 1187688ea5feSHariprasad Shenai rss_pf_mask = t4_read_rss_pf_mask(adapter); 1188688ea5feSHariprasad Shenai for (pf = 0; pf < 8; pf++) { 1189688ea5feSHariprasad Shenai pfconf[pf].rss_pf_map = rss_pf_map; 1190688ea5feSHariprasad Shenai pfconf[pf].rss_pf_mask = rss_pf_mask; 1191688ea5feSHariprasad Shenai t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config); 1192688ea5feSHariprasad Shenai } 1193688ea5feSHariprasad Shenai return 0; 1194688ea5feSHariprasad Shenai } 1195688ea5feSHariprasad Shenai 1196688ea5feSHariprasad Shenai static const struct file_operations rss_pf_config_debugfs_fops = { 1197688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1198688ea5feSHariprasad Shenai .open = rss_pf_config_open, 1199688ea5feSHariprasad Shenai .read = seq_read, 1200688ea5feSHariprasad Shenai .llseek = seq_lseek, 1201688ea5feSHariprasad Shenai .release = seq_release_private 1202688ea5feSHariprasad Shenai }; 1203688ea5feSHariprasad Shenai 1204688ea5feSHariprasad Shenai /* VF RSS Configuration. 1205688ea5feSHariprasad Shenai */ 1206688ea5feSHariprasad Shenai 1207688ea5feSHariprasad Shenai struct rss_vf_conf { 1208688ea5feSHariprasad Shenai u32 rss_vf_vfl; 1209688ea5feSHariprasad Shenai u32 rss_vf_vfh; 1210688ea5feSHariprasad Shenai }; 1211688ea5feSHariprasad Shenai 1212688ea5feSHariprasad Shenai static int rss_vf_config_show(struct seq_file *seq, void *v, int idx) 1213688ea5feSHariprasad Shenai { 1214688ea5feSHariprasad Shenai if (v == SEQ_START_TOKEN) { 1215688ea5feSHariprasad Shenai seq_puts(seq, " RSS Hash Tuple Enable\n"); 1216688ea5feSHariprasad Shenai seq_puts(seq, " Enable IVF Dis Enb IPv6 IPv4 UDP Def Secret Key\n"); 1217688ea5feSHariprasad Shenai seq_puts(seq, " VF Chn Prt Map VLAN uP Four Two Four Two Four Que Idx Hash\n"); 1218688ea5feSHariprasad Shenai } else { 1219688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf = v; 1220688ea5feSHariprasad Shenai 1221688ea5feSHariprasad Shenai seq_printf(seq, "%3d %3s %3s %3d %3s %3s %3s %3s %3s %3s %3s %4d %3d %#10x\n", 1222688ea5feSHariprasad Shenai idx, 1223688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFCHNEN_F), 1224688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFPRTEN_F), 1225688ea5feSHariprasad Shenai VFLKPIDX_G(vfconf->rss_vf_vfh), 1226688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFVLNEX_F), 1227688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFUPEN_F), 1228688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1229688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F), 1230688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F), 1231688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F), 1232688ea5feSHariprasad Shenai yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F), 1233688ea5feSHariprasad Shenai DEFAULTQUEUE_G(vfconf->rss_vf_vfh), 1234688ea5feSHariprasad Shenai KEYINDEX_G(vfconf->rss_vf_vfh), 1235688ea5feSHariprasad Shenai vfconf->rss_vf_vfl); 1236688ea5feSHariprasad Shenai } 1237688ea5feSHariprasad Shenai return 0; 1238688ea5feSHariprasad Shenai } 1239688ea5feSHariprasad Shenai 1240688ea5feSHariprasad Shenai static int rss_vf_config_open(struct inode *inode, struct file *file) 1241688ea5feSHariprasad Shenai { 1242688ea5feSHariprasad Shenai struct adapter *adapter = inode->i_private; 1243688ea5feSHariprasad Shenai struct seq_tab *p; 1244688ea5feSHariprasad Shenai struct rss_vf_conf *vfconf; 1245688ea5feSHariprasad Shenai int vf; 1246688ea5feSHariprasad Shenai 1247688ea5feSHariprasad Shenai p = seq_open_tab(file, 128, sizeof(*vfconf), 1, rss_vf_config_show); 1248688ea5feSHariprasad Shenai if (!p) 1249688ea5feSHariprasad Shenai return -ENOMEM; 1250688ea5feSHariprasad Shenai 1251688ea5feSHariprasad Shenai vfconf = (struct rss_vf_conf *)p->data; 1252688ea5feSHariprasad Shenai for (vf = 0; vf < 128; vf++) { 1253688ea5feSHariprasad Shenai t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl, 1254688ea5feSHariprasad Shenai &vfconf[vf].rss_vf_vfh); 1255688ea5feSHariprasad Shenai } 1256688ea5feSHariprasad Shenai return 0; 1257688ea5feSHariprasad Shenai } 1258688ea5feSHariprasad Shenai 1259688ea5feSHariprasad Shenai static const struct file_operations rss_vf_config_debugfs_fops = { 1260688ea5feSHariprasad Shenai .owner = THIS_MODULE, 1261688ea5feSHariprasad Shenai .open = rss_vf_config_open, 1262688ea5feSHariprasad Shenai .read = seq_read, 1263688ea5feSHariprasad Shenai .llseek = seq_lseek, 1264688ea5feSHariprasad Shenai .release = seq_release_private 1265688ea5feSHariprasad Shenai }; 1266688ea5feSHariprasad Shenai 12673051fa61SHariprasad Shenai /** 12683051fa61SHariprasad Shenai * ethqset2pinfo - return port_info of an Ethernet Queue Set 12693051fa61SHariprasad Shenai * @adap: the adapter 12703051fa61SHariprasad Shenai * @qset: Ethernet Queue Set 12713051fa61SHariprasad Shenai */ 12723051fa61SHariprasad Shenai static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset) 12733051fa61SHariprasad Shenai { 12743051fa61SHariprasad Shenai int pidx; 12753051fa61SHariprasad Shenai 12763051fa61SHariprasad Shenai for_each_port(adap, pidx) { 12773051fa61SHariprasad Shenai struct port_info *pi = adap2pinfo(adap, pidx); 12783051fa61SHariprasad Shenai 12793051fa61SHariprasad Shenai if (qset >= pi->first_qset && 12803051fa61SHariprasad Shenai qset < pi->first_qset + pi->nqsets) 12813051fa61SHariprasad Shenai return pi; 12823051fa61SHariprasad Shenai } 12833051fa61SHariprasad Shenai 12843051fa61SHariprasad Shenai /* should never happen! */ 12853051fa61SHariprasad Shenai BUG_ON(1); 12863051fa61SHariprasad Shenai return NULL; 12873051fa61SHariprasad Shenai } 12883051fa61SHariprasad Shenai 1289dc9daab2SHariprasad Shenai static int sge_qinfo_show(struct seq_file *seq, void *v) 1290dc9daab2SHariprasad Shenai { 1291dc9daab2SHariprasad Shenai struct adapter *adap = seq->private; 1292dc9daab2SHariprasad Shenai int eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4); 1293dc9daab2SHariprasad Shenai int toe_entries = DIV_ROUND_UP(adap->sge.ofldqsets, 4); 1294dc9daab2SHariprasad Shenai int rdma_entries = DIV_ROUND_UP(adap->sge.rdmaqs, 4); 1295dc9daab2SHariprasad Shenai int ciq_entries = DIV_ROUND_UP(adap->sge.rdmaciqs, 4); 1296dc9daab2SHariprasad Shenai int ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4); 1297dc9daab2SHariprasad Shenai int i, r = (uintptr_t)v - 1; 1298dc9daab2SHariprasad Shenai int toe_idx = r - eth_entries; 1299dc9daab2SHariprasad Shenai int rdma_idx = toe_idx - toe_entries; 1300dc9daab2SHariprasad Shenai int ciq_idx = rdma_idx - rdma_entries; 1301dc9daab2SHariprasad Shenai int ctrl_idx = ciq_idx - ciq_entries; 1302dc9daab2SHariprasad Shenai int fq_idx = ctrl_idx - ctrl_entries; 1303dc9daab2SHariprasad Shenai 1304dc9daab2SHariprasad Shenai if (r) 1305dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); 1306dc9daab2SHariprasad Shenai 1307dc9daab2SHariprasad Shenai #define S3(fmt_spec, s, v) \ 1308dc9daab2SHariprasad Shenai do { \ 1309dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s", s); \ 1310dc9daab2SHariprasad Shenai for (i = 0; i < n; ++i) \ 1311dc9daab2SHariprasad Shenai seq_printf(seq, " %16" fmt_spec, v); \ 1312dc9daab2SHariprasad Shenai seq_putc(seq, '\n'); \ 1313dc9daab2SHariprasad Shenai } while (0) 1314dc9daab2SHariprasad Shenai #define S(s, v) S3("s", s, v) 1315dc9daab2SHariprasad Shenai #define T(s, v) S3("u", s, tx[i].v) 1316dc9daab2SHariprasad Shenai #define R(s, v) S3("u", s, rx[i].v) 1317dc9daab2SHariprasad Shenai 1318dc9daab2SHariprasad Shenai if (r < eth_entries) { 1319dc9daab2SHariprasad Shenai int base_qset = r * 4; 1320dc9daab2SHariprasad Shenai const struct sge_eth_rxq *rx = &adap->sge.ethrxq[base_qset]; 1321dc9daab2SHariprasad Shenai const struct sge_eth_txq *tx = &adap->sge.ethtxq[base_qset]; 1322dc9daab2SHariprasad Shenai int n = min(4, adap->sge.ethqsets - 4 * r); 1323dc9daab2SHariprasad Shenai 1324dc9daab2SHariprasad Shenai S("QType:", "Ethernet"); 1325dc9daab2SHariprasad Shenai S("Interface:", 1326dc9daab2SHariprasad Shenai rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A"); 1327dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1328dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1329dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1330dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1331dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 13323051fa61SHariprasad Shenai #ifdef CONFIG_CHELSIO_T4_DCB 1333dc9daab2SHariprasad Shenai T("DCB Prio:", dcb_prio); 1334dc9daab2SHariprasad Shenai S3("u", "DCB PGID:", 1335dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >> 1336dc9daab2SHariprasad Shenai 4*(7-tx[i].dcb_prio)) & 0xf); 1337dc9daab2SHariprasad Shenai S3("u", "DCB PFC:", 1338dc9daab2SHariprasad Shenai (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >> 1339dc9daab2SHariprasad Shenai 1*(7-tx[i].dcb_prio)) & 0x1); 1340dc9daab2SHariprasad Shenai #endif 1341dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1342dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1343dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1344dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1345dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1346dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1347dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1348dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1349dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1350dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1351dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1352dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1353dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1354dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1355dc9daab2SHariprasad Shenai } else if (toe_idx < toe_entries) { 1356dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = &adap->sge.ofldrxq[toe_idx * 4]; 1357dc9daab2SHariprasad Shenai const struct sge_ofld_txq *tx = &adap->sge.ofldtxq[toe_idx * 4]; 1358dc9daab2SHariprasad Shenai int n = min(4, adap->sge.ofldqsets - 4 * toe_idx); 1359dc9daab2SHariprasad Shenai 1360dc9daab2SHariprasad Shenai S("QType:", "TOE"); 1361dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1362dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1363dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1364dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1365dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 1366dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1367dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1368dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1369dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1370dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1371dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1372dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1373dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1374dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1375dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1376dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1377dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1378dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1379dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1380dc9daab2SHariprasad Shenai } else if (rdma_idx < rdma_entries) { 1381dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = 1382dc9daab2SHariprasad Shenai &adap->sge.rdmarxq[rdma_idx * 4]; 1383dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaqs - 4 * rdma_idx); 1384dc9daab2SHariprasad Shenai 1385dc9daab2SHariprasad Shenai S("QType:", "RDMA-CPL"); 1386dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1387dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1388dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1389dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1390dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1391dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1392dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1393dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1394dc9daab2SHariprasad Shenai R("FL ID:", fl.cntxt_id); 1395dc9daab2SHariprasad Shenai R("FL size:", fl.size - 8); 1396dc9daab2SHariprasad Shenai R("FL pend:", fl.pend_cred); 1397dc9daab2SHariprasad Shenai R("FL avail:", fl.avail); 1398dc9daab2SHariprasad Shenai R("FL PIDX:", fl.pidx); 1399dc9daab2SHariprasad Shenai R("FL CIDX:", fl.cidx); 1400dc9daab2SHariprasad Shenai } else if (ciq_idx < ciq_entries) { 1401dc9daab2SHariprasad Shenai const struct sge_ofld_rxq *rx = &adap->sge.rdmaciq[ciq_idx * 4]; 1402dc9daab2SHariprasad Shenai int n = min(4, adap->sge.rdmaciqs - 4 * ciq_idx); 1403dc9daab2SHariprasad Shenai 1404dc9daab2SHariprasad Shenai S("QType:", "RDMA-CIQ"); 1405dc9daab2SHariprasad Shenai R("RspQ ID:", rspq.abs_id); 1406dc9daab2SHariprasad Shenai R("RspQ size:", rspq.size); 1407dc9daab2SHariprasad Shenai R("RspQE size:", rspq.iqe_len); 1408dc9daab2SHariprasad Shenai R("RspQ CIDX:", rspq.cidx); 1409dc9daab2SHariprasad Shenai R("RspQ Gen:", rspq.gen); 1410dc9daab2SHariprasad Shenai S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq)); 1411dc9daab2SHariprasad Shenai S3("u", "Intr pktcnt:", 1412dc9daab2SHariprasad Shenai adap->sge.counter_val[rx[i].rspq.pktcnt_idx]); 1413dc9daab2SHariprasad Shenai } else if (ctrl_idx < ctrl_entries) { 1414dc9daab2SHariprasad Shenai const struct sge_ctrl_txq *tx = &adap->sge.ctrlq[ctrl_idx * 4]; 1415dc9daab2SHariprasad Shenai int n = min(4, adap->params.nports - 4 * ctrl_idx); 1416dc9daab2SHariprasad Shenai 1417dc9daab2SHariprasad Shenai S("QType:", "Control"); 1418dc9daab2SHariprasad Shenai T("TxQ ID:", q.cntxt_id); 1419dc9daab2SHariprasad Shenai T("TxQ size:", q.size); 1420dc9daab2SHariprasad Shenai T("TxQ inuse:", q.in_use); 1421dc9daab2SHariprasad Shenai T("TxQ CIDX:", q.cidx); 1422dc9daab2SHariprasad Shenai T("TxQ PIDX:", q.pidx); 1423dc9daab2SHariprasad Shenai } else if (fq_idx == 0) { 1424dc9daab2SHariprasad Shenai const struct sge_rspq *evtq = &adap->sge.fw_evtq; 1425dc9daab2SHariprasad Shenai 1426dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue"); 1427dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id); 1428dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size); 1429dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len); 1430dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx); 1431dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen); 1432dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr delay:", 1433dc9daab2SHariprasad Shenai qtimer_val(adap, evtq)); 1434dc9daab2SHariprasad Shenai seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:", 1435dc9daab2SHariprasad Shenai adap->sge.counter_val[evtq->pktcnt_idx]); 1436dc9daab2SHariprasad Shenai } 1437dc9daab2SHariprasad Shenai #undef R 1438dc9daab2SHariprasad Shenai #undef T 1439dc9daab2SHariprasad Shenai #undef S 1440dc9daab2SHariprasad Shenai #undef S3 1441dc9daab2SHariprasad Shenai return 0; 1442dc9daab2SHariprasad Shenai } 1443dc9daab2SHariprasad Shenai 1444dc9daab2SHariprasad Shenai static int sge_queue_entries(const struct adapter *adap) 1445dc9daab2SHariprasad Shenai { 1446dc9daab2SHariprasad Shenai return DIV_ROUND_UP(adap->sge.ethqsets, 4) + 1447dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.ofldqsets, 4) + 1448dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaqs, 4) + 1449dc9daab2SHariprasad Shenai DIV_ROUND_UP(adap->sge.rdmaciqs, 4) + 1450dc9daab2SHariprasad Shenai DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1; 1451dc9daab2SHariprasad Shenai } 1452dc9daab2SHariprasad Shenai 1453dc9daab2SHariprasad Shenai static void *sge_queue_start(struct seq_file *seq, loff_t *pos) 1454dc9daab2SHariprasad Shenai { 1455dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 1456dc9daab2SHariprasad Shenai 1457dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1458dc9daab2SHariprasad Shenai } 1459dc9daab2SHariprasad Shenai 1460dc9daab2SHariprasad Shenai static void sge_queue_stop(struct seq_file *seq, void *v) 1461dc9daab2SHariprasad Shenai { 1462dc9daab2SHariprasad Shenai } 1463dc9daab2SHariprasad Shenai 1464dc9daab2SHariprasad Shenai static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos) 1465dc9daab2SHariprasad Shenai { 1466dc9daab2SHariprasad Shenai int entries = sge_queue_entries(seq->private); 1467dc9daab2SHariprasad Shenai 1468dc9daab2SHariprasad Shenai ++*pos; 1469dc9daab2SHariprasad Shenai return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL; 1470dc9daab2SHariprasad Shenai } 1471dc9daab2SHariprasad Shenai 1472dc9daab2SHariprasad Shenai static const struct seq_operations sge_qinfo_seq_ops = { 1473dc9daab2SHariprasad Shenai .start = sge_queue_start, 1474dc9daab2SHariprasad Shenai .next = sge_queue_next, 1475dc9daab2SHariprasad Shenai .stop = sge_queue_stop, 1476dc9daab2SHariprasad Shenai .show = sge_qinfo_show 1477dc9daab2SHariprasad Shenai }; 1478dc9daab2SHariprasad Shenai 1479dc9daab2SHariprasad Shenai static int sge_qinfo_open(struct inode *inode, struct file *file) 1480dc9daab2SHariprasad Shenai { 1481dc9daab2SHariprasad Shenai int res = seq_open(file, &sge_qinfo_seq_ops); 1482dc9daab2SHariprasad Shenai 1483dc9daab2SHariprasad Shenai if (!res) { 1484dc9daab2SHariprasad Shenai struct seq_file *seq = file->private_data; 1485dc9daab2SHariprasad Shenai 1486dc9daab2SHariprasad Shenai seq->private = inode->i_private; 1487dc9daab2SHariprasad Shenai } 1488dc9daab2SHariprasad Shenai return res; 1489dc9daab2SHariprasad Shenai } 1490dc9daab2SHariprasad Shenai 1491dc9daab2SHariprasad Shenai static const struct file_operations sge_qinfo_debugfs_fops = { 1492dc9daab2SHariprasad Shenai .owner = THIS_MODULE, 1493dc9daab2SHariprasad Shenai .open = sge_qinfo_open, 1494dc9daab2SHariprasad Shenai .read = seq_read, 1495dc9daab2SHariprasad Shenai .llseek = seq_lseek, 1496dc9daab2SHariprasad Shenai .release = seq_release, 1497dc9daab2SHariprasad Shenai }; 1498dc9daab2SHariprasad Shenai 149949216c1cSHariprasad Shenai int mem_open(struct inode *inode, struct file *file) 150049216c1cSHariprasad Shenai { 150149216c1cSHariprasad Shenai unsigned int mem; 150249216c1cSHariprasad Shenai struct adapter *adap; 150349216c1cSHariprasad Shenai 150449216c1cSHariprasad Shenai file->private_data = inode->i_private; 150549216c1cSHariprasad Shenai 150649216c1cSHariprasad Shenai mem = (uintptr_t)file->private_data & 0x3; 150749216c1cSHariprasad Shenai adap = file->private_data - mem; 150849216c1cSHariprasad Shenai 150949216c1cSHariprasad Shenai (void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH); 151049216c1cSHariprasad Shenai 151149216c1cSHariprasad Shenai return 0; 151249216c1cSHariprasad Shenai } 151349216c1cSHariprasad Shenai 1514fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 1515fd88b31aSHariprasad Shenai loff_t *ppos) 1516fd88b31aSHariprasad Shenai { 1517fd88b31aSHariprasad Shenai loff_t pos = *ppos; 1518fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 1519fd88b31aSHariprasad Shenai unsigned int mem = (uintptr_t)file->private_data & 3; 1520fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 1521fd88b31aSHariprasad Shenai __be32 *data; 1522fd88b31aSHariprasad Shenai int ret; 1523fd88b31aSHariprasad Shenai 1524fd88b31aSHariprasad Shenai if (pos < 0) 1525fd88b31aSHariprasad Shenai return -EINVAL; 1526fd88b31aSHariprasad Shenai if (pos >= avail) 1527fd88b31aSHariprasad Shenai return 0; 1528fd88b31aSHariprasad Shenai if (count > avail - pos) 1529fd88b31aSHariprasad Shenai count = avail - pos; 1530fd88b31aSHariprasad Shenai 1531fd88b31aSHariprasad Shenai data = t4_alloc_mem(count); 1532fd88b31aSHariprasad Shenai if (!data) 1533fd88b31aSHariprasad Shenai return -ENOMEM; 1534fd88b31aSHariprasad Shenai 1535fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 1536fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 1537fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 1538fd88b31aSHariprasad Shenai if (ret) { 1539fd88b31aSHariprasad Shenai t4_free_mem(data); 1540fd88b31aSHariprasad Shenai return ret; 1541fd88b31aSHariprasad Shenai } 1542fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 1543fd88b31aSHariprasad Shenai 1544fd88b31aSHariprasad Shenai t4_free_mem(data); 1545fd88b31aSHariprasad Shenai if (ret) 1546fd88b31aSHariprasad Shenai return -EFAULT; 1547fd88b31aSHariprasad Shenai 1548fd88b31aSHariprasad Shenai *ppos = pos + count; 1549fd88b31aSHariprasad Shenai return count; 1550fd88b31aSHariprasad Shenai } 1551fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 1552fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 1553fd88b31aSHariprasad Shenai .open = simple_open, 1554fd88b31aSHariprasad Shenai .read = mem_read, 1555fd88b31aSHariprasad Shenai .llseek = default_llseek, 1556fd88b31aSHariprasad Shenai }; 1557fd88b31aSHariprasad Shenai 155849216c1cSHariprasad Shenai static void set_debugfs_file_size(struct dentry *de, loff_t size) 155949216c1cSHariprasad Shenai { 156049216c1cSHariprasad Shenai if (!IS_ERR(de) && de->d_inode) 156149216c1cSHariprasad Shenai de->d_inode->i_size = size; 156249216c1cSHariprasad Shenai } 156349216c1cSHariprasad Shenai 1564fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 1565fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 1566fd88b31aSHariprasad Shenai { 1567fd88b31aSHariprasad Shenai struct dentry *de; 1568fd88b31aSHariprasad Shenai 1569fd88b31aSHariprasad Shenai de = debugfs_create_file(name, S_IRUSR, adap->debugfs_root, 1570fd88b31aSHariprasad Shenai (void *)adap + idx, &mem_debugfs_fops); 1571fd88b31aSHariprasad Shenai if (de && de->d_inode) 1572fd88b31aSHariprasad Shenai de->d_inode->i_size = size_mb << 20; 1573fd88b31aSHariprasad Shenai } 1574fd88b31aSHariprasad Shenai 1575fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 1576fd88b31aSHariprasad Shenai */ 1577fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 1578fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 1579fd88b31aSHariprasad Shenai unsigned int nfiles) 1580fd88b31aSHariprasad Shenai { 1581fd88b31aSHariprasad Shenai int i; 1582fd88b31aSHariprasad Shenai 1583fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 1584fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 1585fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 1586fd88b31aSHariprasad Shenai adap->debugfs_root, 1587fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 1588fd88b31aSHariprasad Shenai files[i].ops); 1589fd88b31aSHariprasad Shenai } 1590fd88b31aSHariprasad Shenai 1591fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 1592fd88b31aSHariprasad Shenai { 1593fd88b31aSHariprasad Shenai int i; 1594fd88b31aSHariprasad Shenai u32 size; 159549216c1cSHariprasad Shenai struct dentry *de; 1596fd88b31aSHariprasad Shenai 1597fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 1598f1ff24aaSHariprasad Shenai { "cim_la", &cim_la_fops, S_IRUSR, 0 }, 159974b3092cSHariprasad Shenai { "cim_qcfg", &cim_qcfg_fops, S_IRUSR, 0 }, 1600b58b6676SHariprasad Shenai { "clk", &clk_debugfs_fops, S_IRUSR, 0 }, 160149aa284fSHariprasad Shenai { "devlog", &devlog_fops, S_IRUSR, 0 }, 1602fd88b31aSHariprasad Shenai { "l2t", &t4_l2t_fops, S_IRUSR, 0}, 1603ef82f662SHariprasad Shenai { "mps_tcam", &mps_tcam_debugfs_fops, S_IRUSR, 0 }, 1604688ea5feSHariprasad Shenai { "rss", &rss_debugfs_fops, S_IRUSR, 0 }, 1605688ea5feSHariprasad Shenai { "rss_config", &rss_config_debugfs_fops, S_IRUSR, 0 }, 1606688ea5feSHariprasad Shenai { "rss_key", &rss_key_debugfs_fops, S_IRUSR, 0 }, 1607688ea5feSHariprasad Shenai { "rss_pf_config", &rss_pf_config_debugfs_fops, S_IRUSR, 0 }, 1608688ea5feSHariprasad Shenai { "rss_vf_config", &rss_vf_config_debugfs_fops, S_IRUSR, 0 }, 1609dc9daab2SHariprasad Shenai { "sge_qinfo", &sge_qinfo_debugfs_fops, S_IRUSR, 0 }, 1610e5f0e43bSHariprasad Shenai { "ibq_tp0", &cim_ibq_fops, S_IRUSR, 0 }, 1611e5f0e43bSHariprasad Shenai { "ibq_tp1", &cim_ibq_fops, S_IRUSR, 1 }, 1612e5f0e43bSHariprasad Shenai { "ibq_ulp", &cim_ibq_fops, S_IRUSR, 2 }, 1613e5f0e43bSHariprasad Shenai { "ibq_sge0", &cim_ibq_fops, S_IRUSR, 3 }, 1614e5f0e43bSHariprasad Shenai { "ibq_sge1", &cim_ibq_fops, S_IRUSR, 4 }, 1615e5f0e43bSHariprasad Shenai { "ibq_ncsi", &cim_ibq_fops, S_IRUSR, 5 }, 1616c778af7dSHariprasad Shenai { "obq_ulp0", &cim_obq_fops, S_IRUSR, 0 }, 1617c778af7dSHariprasad Shenai { "obq_ulp1", &cim_obq_fops, S_IRUSR, 1 }, 1618c778af7dSHariprasad Shenai { "obq_ulp2", &cim_obq_fops, S_IRUSR, 2 }, 1619c778af7dSHariprasad Shenai { "obq_ulp3", &cim_obq_fops, S_IRUSR, 3 }, 1620c778af7dSHariprasad Shenai { "obq_sge", &cim_obq_fops, S_IRUSR, 4 }, 1621c778af7dSHariprasad Shenai { "obq_ncsi", &cim_obq_fops, S_IRUSR, 5 }, 162270a5f3bbSHariprasad Shenai { "sensors", &sensors_debugfs_fops, S_IRUSR, 0 }, 1623b3bbe36aSHariprasad Shenai { "pm_stats", &pm_stats_debugfs_fops, S_IRUSR, 0 }, 1624b5a02f50SAnish Bhatt #if IS_ENABLED(CONFIG_IPV6) 1625b5a02f50SAnish Bhatt { "clip_tbl", &clip_tbl_debugfs_fops, S_IRUSR, 0 }, 1626b5a02f50SAnish Bhatt #endif 1627fd88b31aSHariprasad Shenai }; 1628fd88b31aSHariprasad Shenai 1629c778af7dSHariprasad Shenai /* Debug FS nodes common to all T5 and later adapters. 1630c778af7dSHariprasad Shenai */ 1631c778af7dSHariprasad Shenai static struct t4_debugfs_entry t5_debugfs_files[] = { 1632c778af7dSHariprasad Shenai { "obq_sge_rx_q0", &cim_obq_fops, S_IRUSR, 6 }, 1633c778af7dSHariprasad Shenai { "obq_sge_rx_q1", &cim_obq_fops, S_IRUSR, 7 }, 1634c778af7dSHariprasad Shenai }; 1635c778af7dSHariprasad Shenai 1636fd88b31aSHariprasad Shenai add_debugfs_files(adap, 1637fd88b31aSHariprasad Shenai t4_debugfs_files, 1638fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 1639c778af7dSHariprasad Shenai if (!is_t4(adap->params.chip)) 1640c778af7dSHariprasad Shenai add_debugfs_files(adap, 1641c778af7dSHariprasad Shenai t5_debugfs_files, 1642c778af7dSHariprasad Shenai ARRAY_SIZE(t5_debugfs_files)); 1643fd88b31aSHariprasad Shenai 16446559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 16456559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 16466559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 16476559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 1648fd88b31aSHariprasad Shenai } 16496559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 16506559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 16516559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 1652fd88b31aSHariprasad Shenai } 1653fd88b31aSHariprasad Shenai if (is_t4(adap->params.chip)) { 16546559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 16556559a7e8SHariprasad Shenai if (i & EXT_MEM_ENABLE_F) 1656fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 16576559a7e8SHariprasad Shenai EXT_MEM_SIZE_G(size)); 1658fd88b31aSHariprasad Shenai } else { 16596559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 16606559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 1661fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 16626559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 1663fd88b31aSHariprasad Shenai } 16646559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 16656559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 1666fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 16676559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 1668fd88b31aSHariprasad Shenai } 1669fd88b31aSHariprasad Shenai } 167049216c1cSHariprasad Shenai 167149216c1cSHariprasad Shenai de = debugfs_create_file("flash", S_IRUSR, adap->debugfs_root, adap, 167249216c1cSHariprasad Shenai &flash_debugfs_fops); 167349216c1cSHariprasad Shenai set_debugfs_file_size(de, adap->params.sf_size); 167449216c1cSHariprasad Shenai 1675fd88b31aSHariprasad Shenai return 0; 1676fd88b31aSHariprasad Shenai } 1677