1fd88b31aSHariprasad Shenai /* 2fd88b31aSHariprasad Shenai * This file is part of the Chelsio T4 Ethernet driver for Linux. 3fd88b31aSHariprasad Shenai * 4fd88b31aSHariprasad Shenai * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved. 5fd88b31aSHariprasad Shenai * 6fd88b31aSHariprasad Shenai * This software is available to you under a choice of one of two 7fd88b31aSHariprasad Shenai * licenses. You may choose to be licensed under the terms of the GNU 8fd88b31aSHariprasad Shenai * General Public License (GPL) Version 2, available from the file 9fd88b31aSHariprasad Shenai * COPYING in the main directory of this source tree, or the 10fd88b31aSHariprasad Shenai * OpenIB.org BSD license below: 11fd88b31aSHariprasad Shenai * 12fd88b31aSHariprasad Shenai * Redistribution and use in source and binary forms, with or 13fd88b31aSHariprasad Shenai * without modification, are permitted provided that the following 14fd88b31aSHariprasad Shenai * conditions are met: 15fd88b31aSHariprasad Shenai * 16fd88b31aSHariprasad Shenai * - Redistributions of source code must retain the above 17fd88b31aSHariprasad Shenai * copyright notice, this list of conditions and the following 18fd88b31aSHariprasad Shenai * disclaimer. 19fd88b31aSHariprasad Shenai * 20fd88b31aSHariprasad Shenai * - Redistributions in binary form must reproduce the above 21fd88b31aSHariprasad Shenai * copyright notice, this list of conditions and the following 22fd88b31aSHariprasad Shenai * disclaimer in the documentation and/or other materials 23fd88b31aSHariprasad Shenai * provided with the distribution. 24fd88b31aSHariprasad Shenai * 25fd88b31aSHariprasad Shenai * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26fd88b31aSHariprasad Shenai * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27fd88b31aSHariprasad Shenai * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28fd88b31aSHariprasad Shenai * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29fd88b31aSHariprasad Shenai * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30fd88b31aSHariprasad Shenai * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31fd88b31aSHariprasad Shenai * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32fd88b31aSHariprasad Shenai * SOFTWARE. 33fd88b31aSHariprasad Shenai */ 34fd88b31aSHariprasad Shenai 35fd88b31aSHariprasad Shenai #include <linux/seq_file.h> 36fd88b31aSHariprasad Shenai #include <linux/debugfs.h> 37fd88b31aSHariprasad Shenai #include <linux/string_helpers.h> 38fd88b31aSHariprasad Shenai #include <linux/sort.h> 39fd88b31aSHariprasad Shenai 40fd88b31aSHariprasad Shenai #include "cxgb4.h" 41fd88b31aSHariprasad Shenai #include "t4_regs.h" 42fd88b31aSHariprasad Shenai #include "t4fw_api.h" 43fd88b31aSHariprasad Shenai #include "cxgb4_debugfs.h" 44fd88b31aSHariprasad Shenai #include "l2t.h" 45fd88b31aSHariprasad Shenai 46f1ff24aaSHariprasad Shenai /* generic seq_file support for showing a table of size rows x width. */ 47f1ff24aaSHariprasad Shenai static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos) 48f1ff24aaSHariprasad Shenai { 49f1ff24aaSHariprasad Shenai pos -= tb->skip_first; 50f1ff24aaSHariprasad Shenai return pos >= tb->rows ? NULL : &tb->data[pos * tb->width]; 51f1ff24aaSHariprasad Shenai } 52f1ff24aaSHariprasad Shenai 53f1ff24aaSHariprasad Shenai static void *seq_tab_start(struct seq_file *seq, loff_t *pos) 54f1ff24aaSHariprasad Shenai { 55f1ff24aaSHariprasad Shenai struct seq_tab *tb = seq->private; 56f1ff24aaSHariprasad Shenai 57f1ff24aaSHariprasad Shenai if (tb->skip_first && *pos == 0) 58f1ff24aaSHariprasad Shenai return SEQ_START_TOKEN; 59f1ff24aaSHariprasad Shenai 60f1ff24aaSHariprasad Shenai return seq_tab_get_idx(tb, *pos); 61f1ff24aaSHariprasad Shenai } 62f1ff24aaSHariprasad Shenai 63f1ff24aaSHariprasad Shenai static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos) 64f1ff24aaSHariprasad Shenai { 65f1ff24aaSHariprasad Shenai v = seq_tab_get_idx(seq->private, *pos + 1); 66f1ff24aaSHariprasad Shenai if (v) 67f1ff24aaSHariprasad Shenai ++*pos; 68f1ff24aaSHariprasad Shenai return v; 69f1ff24aaSHariprasad Shenai } 70f1ff24aaSHariprasad Shenai 71f1ff24aaSHariprasad Shenai static void seq_tab_stop(struct seq_file *seq, void *v) 72f1ff24aaSHariprasad Shenai { 73f1ff24aaSHariprasad Shenai } 74f1ff24aaSHariprasad Shenai 75f1ff24aaSHariprasad Shenai static int seq_tab_show(struct seq_file *seq, void *v) 76f1ff24aaSHariprasad Shenai { 77f1ff24aaSHariprasad Shenai const struct seq_tab *tb = seq->private; 78f1ff24aaSHariprasad Shenai 79f1ff24aaSHariprasad Shenai return tb->show(seq, v, ((char *)v - tb->data) / tb->width); 80f1ff24aaSHariprasad Shenai } 81f1ff24aaSHariprasad Shenai 82f1ff24aaSHariprasad Shenai static const struct seq_operations seq_tab_ops = { 83f1ff24aaSHariprasad Shenai .start = seq_tab_start, 84f1ff24aaSHariprasad Shenai .next = seq_tab_next, 85f1ff24aaSHariprasad Shenai .stop = seq_tab_stop, 86f1ff24aaSHariprasad Shenai .show = seq_tab_show 87f1ff24aaSHariprasad Shenai }; 88f1ff24aaSHariprasad Shenai 89f1ff24aaSHariprasad Shenai struct seq_tab *seq_open_tab(struct file *f, unsigned int rows, 90f1ff24aaSHariprasad Shenai unsigned int width, unsigned int have_header, 91f1ff24aaSHariprasad Shenai int (*show)(struct seq_file *seq, void *v, int i)) 92f1ff24aaSHariprasad Shenai { 93f1ff24aaSHariprasad Shenai struct seq_tab *p; 94f1ff24aaSHariprasad Shenai 95f1ff24aaSHariprasad Shenai p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width); 96f1ff24aaSHariprasad Shenai if (p) { 97f1ff24aaSHariprasad Shenai p->show = show; 98f1ff24aaSHariprasad Shenai p->rows = rows; 99f1ff24aaSHariprasad Shenai p->width = width; 100f1ff24aaSHariprasad Shenai p->skip_first = have_header != 0; 101f1ff24aaSHariprasad Shenai } 102f1ff24aaSHariprasad Shenai return p; 103f1ff24aaSHariprasad Shenai } 104f1ff24aaSHariprasad Shenai 105f1ff24aaSHariprasad Shenai static int cim_la_show(struct seq_file *seq, void *v, int idx) 106f1ff24aaSHariprasad Shenai { 107f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) 108f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC LS0Stat LS0Addr " 109f1ff24aaSHariprasad Shenai " LS0Data\n"); 110f1ff24aaSHariprasad Shenai else { 111f1ff24aaSHariprasad Shenai const u32 *p = v; 112f1ff24aaSHariprasad Shenai 113f1ff24aaSHariprasad Shenai seq_printf(seq, 114f1ff24aaSHariprasad Shenai " %02x %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n", 115f1ff24aaSHariprasad Shenai (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4, 116f1ff24aaSHariprasad Shenai p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5], 117f1ff24aaSHariprasad Shenai p[6], p[7]); 118f1ff24aaSHariprasad Shenai } 119f1ff24aaSHariprasad Shenai return 0; 120f1ff24aaSHariprasad Shenai } 121f1ff24aaSHariprasad Shenai 122f1ff24aaSHariprasad Shenai static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx) 123f1ff24aaSHariprasad Shenai { 124f1ff24aaSHariprasad Shenai if (v == SEQ_START_TOKEN) { 125f1ff24aaSHariprasad Shenai seq_puts(seq, "Status Data PC\n"); 126f1ff24aaSHariprasad Shenai } else { 127f1ff24aaSHariprasad Shenai const u32 *p = v; 128f1ff24aaSHariprasad Shenai 129f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %08x %08x\n", p[5] & 0xff, p[6], 130f1ff24aaSHariprasad Shenai p[7]); 131f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %02x%06x %02x%06x\n", 132f1ff24aaSHariprasad Shenai (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8, 133f1ff24aaSHariprasad Shenai p[4] & 0xff, p[5] >> 8); 134f1ff24aaSHariprasad Shenai seq_printf(seq, " %02x %x%07x %x%07x\n", (p[0] >> 4) & 0xff, 135f1ff24aaSHariprasad Shenai p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4); 136f1ff24aaSHariprasad Shenai } 137f1ff24aaSHariprasad Shenai return 0; 138f1ff24aaSHariprasad Shenai } 139f1ff24aaSHariprasad Shenai 140f1ff24aaSHariprasad Shenai static int cim_la_open(struct inode *inode, struct file *file) 141f1ff24aaSHariprasad Shenai { 142f1ff24aaSHariprasad Shenai int ret; 143f1ff24aaSHariprasad Shenai unsigned int cfg; 144f1ff24aaSHariprasad Shenai struct seq_tab *p; 145f1ff24aaSHariprasad Shenai struct adapter *adap = inode->i_private; 146f1ff24aaSHariprasad Shenai 147f1ff24aaSHariprasad Shenai ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg); 148f1ff24aaSHariprasad Shenai if (ret) 149f1ff24aaSHariprasad Shenai return ret; 150f1ff24aaSHariprasad Shenai 151f1ff24aaSHariprasad Shenai p = seq_open_tab(file, adap->params.cim_la_size / 8, 8 * sizeof(u32), 1, 152f1ff24aaSHariprasad Shenai cfg & UPDBGLACAPTPCONLY_F ? 153f1ff24aaSHariprasad Shenai cim_la_show_3in1 : cim_la_show); 154f1ff24aaSHariprasad Shenai if (!p) 155f1ff24aaSHariprasad Shenai return -ENOMEM; 156f1ff24aaSHariprasad Shenai 157f1ff24aaSHariprasad Shenai ret = t4_cim_read_la(adap, (u32 *)p->data, NULL); 158f1ff24aaSHariprasad Shenai if (ret) 159f1ff24aaSHariprasad Shenai seq_release_private(inode, file); 160f1ff24aaSHariprasad Shenai return ret; 161f1ff24aaSHariprasad Shenai } 162f1ff24aaSHariprasad Shenai 163f1ff24aaSHariprasad Shenai static const struct file_operations cim_la_fops = { 164f1ff24aaSHariprasad Shenai .owner = THIS_MODULE, 165f1ff24aaSHariprasad Shenai .open = cim_la_open, 166f1ff24aaSHariprasad Shenai .read = seq_read, 167f1ff24aaSHariprasad Shenai .llseek = seq_lseek, 168f1ff24aaSHariprasad Shenai .release = seq_release_private 169f1ff24aaSHariprasad Shenai }; 170f1ff24aaSHariprasad Shenai 171f1ff24aaSHariprasad Shenai /* Firmware Device Log dump. */ 17249aa284fSHariprasad Shenai static const char * const devlog_level_strings[] = { 17349aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_EMERG] = "EMERG", 17449aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_CRIT] = "CRIT", 17549aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_ERR] = "ERR", 17649aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_NOTICE] = "NOTICE", 17749aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_INFO] = "INFO", 17849aa284fSHariprasad Shenai [FW_DEVLOG_LEVEL_DEBUG] = "DEBUG" 17949aa284fSHariprasad Shenai }; 18049aa284fSHariprasad Shenai 18149aa284fSHariprasad Shenai static const char * const devlog_facility_strings[] = { 18249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_CORE] = "CORE", 18349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_SCHED] = "SCHED", 18449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TIMER] = "TIMER", 18549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RES] = "RES", 18649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_HW] = "HW", 18749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FLR] = "FLR", 18849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DMAQ] = "DMAQ", 18949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PHY] = "PHY", 19049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_MAC] = "MAC", 19149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_PORT] = "PORT", 19249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_VI] = "VI", 19349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FILTER] = "FILTER", 19449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ACL] = "ACL", 19549aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_TM] = "TM", 19649aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_QFC] = "QFC", 19749aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_DCB] = "DCB", 19849aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ETH] = "ETH", 19949aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_OFLD] = "OFLD", 20049aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_RI] = "RI", 20149aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_ISCSI] = "ISCSI", 20249aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FCOE] = "FCOE", 20349aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOISCSI] = "FOISCSI", 20449aa284fSHariprasad Shenai [FW_DEVLOG_FACILITY_FOFCOE] = "FOFCOE" 20549aa284fSHariprasad Shenai }; 20649aa284fSHariprasad Shenai 20749aa284fSHariprasad Shenai /* Information gathered by Device Log Open routine for the display routine. 20849aa284fSHariprasad Shenai */ 20949aa284fSHariprasad Shenai struct devlog_info { 21049aa284fSHariprasad Shenai unsigned int nentries; /* number of entries in log[] */ 21149aa284fSHariprasad Shenai unsigned int first; /* first [temporal] entry in log[] */ 21249aa284fSHariprasad Shenai struct fw_devlog_e log[0]; /* Firmware Device Log */ 21349aa284fSHariprasad Shenai }; 21449aa284fSHariprasad Shenai 21549aa284fSHariprasad Shenai /* Dump a Firmaware Device Log entry. 21649aa284fSHariprasad Shenai */ 21749aa284fSHariprasad Shenai static int devlog_show(struct seq_file *seq, void *v) 21849aa284fSHariprasad Shenai { 21949aa284fSHariprasad Shenai if (v == SEQ_START_TOKEN) 22049aa284fSHariprasad Shenai seq_printf(seq, "%10s %15s %8s %8s %s\n", 22149aa284fSHariprasad Shenai "Seq#", "Tstamp", "Level", "Facility", "Message"); 22249aa284fSHariprasad Shenai else { 22349aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 22449aa284fSHariprasad Shenai int fidx = (uintptr_t)v - 2; 22549aa284fSHariprasad Shenai unsigned long index; 22649aa284fSHariprasad Shenai struct fw_devlog_e *e; 22749aa284fSHariprasad Shenai 22849aa284fSHariprasad Shenai /* Get a pointer to the log entry to display. Skip unused log 22949aa284fSHariprasad Shenai * entries. 23049aa284fSHariprasad Shenai */ 23149aa284fSHariprasad Shenai index = dinfo->first + fidx; 23249aa284fSHariprasad Shenai if (index >= dinfo->nentries) 23349aa284fSHariprasad Shenai index -= dinfo->nentries; 23449aa284fSHariprasad Shenai e = &dinfo->log[index]; 23549aa284fSHariprasad Shenai if (e->timestamp == 0) 23649aa284fSHariprasad Shenai return 0; 23749aa284fSHariprasad Shenai 23849aa284fSHariprasad Shenai /* Print the message. This depends on the firmware using 23949aa284fSHariprasad Shenai * exactly the same formating strings as the kernel so we may 24049aa284fSHariprasad Shenai * eventually have to put a format interpreter in here ... 24149aa284fSHariprasad Shenai */ 24249aa284fSHariprasad Shenai seq_printf(seq, "%10d %15llu %8s %8s ", 24349aa284fSHariprasad Shenai e->seqno, e->timestamp, 24449aa284fSHariprasad Shenai (e->level < ARRAY_SIZE(devlog_level_strings) 24549aa284fSHariprasad Shenai ? devlog_level_strings[e->level] 24649aa284fSHariprasad Shenai : "UNKNOWN"), 24749aa284fSHariprasad Shenai (e->facility < ARRAY_SIZE(devlog_facility_strings) 24849aa284fSHariprasad Shenai ? devlog_facility_strings[e->facility] 24949aa284fSHariprasad Shenai : "UNKNOWN")); 25049aa284fSHariprasad Shenai seq_printf(seq, e->fmt, e->params[0], e->params[1], 25149aa284fSHariprasad Shenai e->params[2], e->params[3], e->params[4], 25249aa284fSHariprasad Shenai e->params[5], e->params[6], e->params[7]); 25349aa284fSHariprasad Shenai } 25449aa284fSHariprasad Shenai return 0; 25549aa284fSHariprasad Shenai } 25649aa284fSHariprasad Shenai 25749aa284fSHariprasad Shenai /* Sequential File Operations for Device Log. 25849aa284fSHariprasad Shenai */ 25949aa284fSHariprasad Shenai static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos) 26049aa284fSHariprasad Shenai { 26149aa284fSHariprasad Shenai if (pos > dinfo->nentries) 26249aa284fSHariprasad Shenai return NULL; 26349aa284fSHariprasad Shenai 26449aa284fSHariprasad Shenai return (void *)(uintptr_t)(pos + 1); 26549aa284fSHariprasad Shenai } 26649aa284fSHariprasad Shenai 26749aa284fSHariprasad Shenai static void *devlog_start(struct seq_file *seq, loff_t *pos) 26849aa284fSHariprasad Shenai { 26949aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 27049aa284fSHariprasad Shenai 27149aa284fSHariprasad Shenai return (*pos 27249aa284fSHariprasad Shenai ? devlog_get_idx(dinfo, *pos) 27349aa284fSHariprasad Shenai : SEQ_START_TOKEN); 27449aa284fSHariprasad Shenai } 27549aa284fSHariprasad Shenai 27649aa284fSHariprasad Shenai static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos) 27749aa284fSHariprasad Shenai { 27849aa284fSHariprasad Shenai struct devlog_info *dinfo = seq->private; 27949aa284fSHariprasad Shenai 28049aa284fSHariprasad Shenai (*pos)++; 28149aa284fSHariprasad Shenai return devlog_get_idx(dinfo, *pos); 28249aa284fSHariprasad Shenai } 28349aa284fSHariprasad Shenai 28449aa284fSHariprasad Shenai static void devlog_stop(struct seq_file *seq, void *v) 28549aa284fSHariprasad Shenai { 28649aa284fSHariprasad Shenai } 28749aa284fSHariprasad Shenai 28849aa284fSHariprasad Shenai static const struct seq_operations devlog_seq_ops = { 28949aa284fSHariprasad Shenai .start = devlog_start, 29049aa284fSHariprasad Shenai .next = devlog_next, 29149aa284fSHariprasad Shenai .stop = devlog_stop, 29249aa284fSHariprasad Shenai .show = devlog_show 29349aa284fSHariprasad Shenai }; 29449aa284fSHariprasad Shenai 29549aa284fSHariprasad Shenai /* Set up for reading the firmware's device log. We read the entire log here 29649aa284fSHariprasad Shenai * and then display it incrementally in devlog_show(). 29749aa284fSHariprasad Shenai */ 29849aa284fSHariprasad Shenai static int devlog_open(struct inode *inode, struct file *file) 29949aa284fSHariprasad Shenai { 30049aa284fSHariprasad Shenai struct adapter *adap = inode->i_private; 30149aa284fSHariprasad Shenai struct devlog_params *dparams = &adap->params.devlog; 30249aa284fSHariprasad Shenai struct devlog_info *dinfo; 30349aa284fSHariprasad Shenai unsigned int index; 30449aa284fSHariprasad Shenai u32 fseqno; 30549aa284fSHariprasad Shenai int ret; 30649aa284fSHariprasad Shenai 30749aa284fSHariprasad Shenai /* If we don't know where the log is we can't do anything. 30849aa284fSHariprasad Shenai */ 30949aa284fSHariprasad Shenai if (dparams->start == 0) 31049aa284fSHariprasad Shenai return -ENXIO; 31149aa284fSHariprasad Shenai 31249aa284fSHariprasad Shenai /* Allocate the space to read in the firmware's device log and set up 31349aa284fSHariprasad Shenai * for the iterated call to our display function. 31449aa284fSHariprasad Shenai */ 31549aa284fSHariprasad Shenai dinfo = __seq_open_private(file, &devlog_seq_ops, 31649aa284fSHariprasad Shenai sizeof(*dinfo) + dparams->size); 31749aa284fSHariprasad Shenai if (!dinfo) 31849aa284fSHariprasad Shenai return -ENOMEM; 31949aa284fSHariprasad Shenai 32049aa284fSHariprasad Shenai /* Record the basic log buffer information and read in the raw log. 32149aa284fSHariprasad Shenai */ 32249aa284fSHariprasad Shenai dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e)); 32349aa284fSHariprasad Shenai dinfo->first = 0; 32449aa284fSHariprasad Shenai spin_lock(&adap->win0_lock); 32549aa284fSHariprasad Shenai ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype, 32649aa284fSHariprasad Shenai dparams->start, dparams->size, (__be32 *)dinfo->log, 32749aa284fSHariprasad Shenai T4_MEMORY_READ); 32849aa284fSHariprasad Shenai spin_unlock(&adap->win0_lock); 32949aa284fSHariprasad Shenai if (ret) { 33049aa284fSHariprasad Shenai seq_release_private(inode, file); 33149aa284fSHariprasad Shenai return ret; 33249aa284fSHariprasad Shenai } 33349aa284fSHariprasad Shenai 33449aa284fSHariprasad Shenai /* Translate log multi-byte integral elements into host native format 33549aa284fSHariprasad Shenai * and determine where the first entry in the log is. 33649aa284fSHariprasad Shenai */ 33749aa284fSHariprasad Shenai for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) { 33849aa284fSHariprasad Shenai struct fw_devlog_e *e = &dinfo->log[index]; 33949aa284fSHariprasad Shenai int i; 34049aa284fSHariprasad Shenai __u32 seqno; 34149aa284fSHariprasad Shenai 34249aa284fSHariprasad Shenai if (e->timestamp == 0) 34349aa284fSHariprasad Shenai continue; 34449aa284fSHariprasad Shenai 34549aa284fSHariprasad Shenai e->timestamp = (__force __be64)be64_to_cpu(e->timestamp); 34649aa284fSHariprasad Shenai seqno = be32_to_cpu(e->seqno); 34749aa284fSHariprasad Shenai for (i = 0; i < 8; i++) 34849aa284fSHariprasad Shenai e->params[i] = 34949aa284fSHariprasad Shenai (__force __be32)be32_to_cpu(e->params[i]); 35049aa284fSHariprasad Shenai 35149aa284fSHariprasad Shenai if (seqno < fseqno) { 35249aa284fSHariprasad Shenai fseqno = seqno; 35349aa284fSHariprasad Shenai dinfo->first = index; 35449aa284fSHariprasad Shenai } 35549aa284fSHariprasad Shenai } 35649aa284fSHariprasad Shenai return 0; 35749aa284fSHariprasad Shenai } 35849aa284fSHariprasad Shenai 35949aa284fSHariprasad Shenai static const struct file_operations devlog_fops = { 36049aa284fSHariprasad Shenai .owner = THIS_MODULE, 36149aa284fSHariprasad Shenai .open = devlog_open, 36249aa284fSHariprasad Shenai .read = seq_read, 36349aa284fSHariprasad Shenai .llseek = seq_lseek, 36449aa284fSHariprasad Shenai .release = seq_release_private 36549aa284fSHariprasad Shenai }; 36649aa284fSHariprasad Shenai 367fd88b31aSHariprasad Shenai static ssize_t mem_read(struct file *file, char __user *buf, size_t count, 368fd88b31aSHariprasad Shenai loff_t *ppos) 369fd88b31aSHariprasad Shenai { 370fd88b31aSHariprasad Shenai loff_t pos = *ppos; 371fd88b31aSHariprasad Shenai loff_t avail = file_inode(file)->i_size; 372fd88b31aSHariprasad Shenai unsigned int mem = (uintptr_t)file->private_data & 3; 373fd88b31aSHariprasad Shenai struct adapter *adap = file->private_data - mem; 374fd88b31aSHariprasad Shenai __be32 *data; 375fd88b31aSHariprasad Shenai int ret; 376fd88b31aSHariprasad Shenai 377fd88b31aSHariprasad Shenai if (pos < 0) 378fd88b31aSHariprasad Shenai return -EINVAL; 379fd88b31aSHariprasad Shenai if (pos >= avail) 380fd88b31aSHariprasad Shenai return 0; 381fd88b31aSHariprasad Shenai if (count > avail - pos) 382fd88b31aSHariprasad Shenai count = avail - pos; 383fd88b31aSHariprasad Shenai 384fd88b31aSHariprasad Shenai data = t4_alloc_mem(count); 385fd88b31aSHariprasad Shenai if (!data) 386fd88b31aSHariprasad Shenai return -ENOMEM; 387fd88b31aSHariprasad Shenai 388fd88b31aSHariprasad Shenai spin_lock(&adap->win0_lock); 389fd88b31aSHariprasad Shenai ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ); 390fd88b31aSHariprasad Shenai spin_unlock(&adap->win0_lock); 391fd88b31aSHariprasad Shenai if (ret) { 392fd88b31aSHariprasad Shenai t4_free_mem(data); 393fd88b31aSHariprasad Shenai return ret; 394fd88b31aSHariprasad Shenai } 395fd88b31aSHariprasad Shenai ret = copy_to_user(buf, data, count); 396fd88b31aSHariprasad Shenai 397fd88b31aSHariprasad Shenai t4_free_mem(data); 398fd88b31aSHariprasad Shenai if (ret) 399fd88b31aSHariprasad Shenai return -EFAULT; 400fd88b31aSHariprasad Shenai 401fd88b31aSHariprasad Shenai *ppos = pos + count; 402fd88b31aSHariprasad Shenai return count; 403fd88b31aSHariprasad Shenai } 404fd88b31aSHariprasad Shenai 405fd88b31aSHariprasad Shenai static const struct file_operations mem_debugfs_fops = { 406fd88b31aSHariprasad Shenai .owner = THIS_MODULE, 407fd88b31aSHariprasad Shenai .open = simple_open, 408fd88b31aSHariprasad Shenai .read = mem_read, 409fd88b31aSHariprasad Shenai .llseek = default_llseek, 410fd88b31aSHariprasad Shenai }; 411fd88b31aSHariprasad Shenai 412fd88b31aSHariprasad Shenai static void add_debugfs_mem(struct adapter *adap, const char *name, 413fd88b31aSHariprasad Shenai unsigned int idx, unsigned int size_mb) 414fd88b31aSHariprasad Shenai { 415fd88b31aSHariprasad Shenai struct dentry *de; 416fd88b31aSHariprasad Shenai 417fd88b31aSHariprasad Shenai de = debugfs_create_file(name, S_IRUSR, adap->debugfs_root, 418fd88b31aSHariprasad Shenai (void *)adap + idx, &mem_debugfs_fops); 419fd88b31aSHariprasad Shenai if (de && de->d_inode) 420fd88b31aSHariprasad Shenai de->d_inode->i_size = size_mb << 20; 421fd88b31aSHariprasad Shenai } 422fd88b31aSHariprasad Shenai 423fd88b31aSHariprasad Shenai /* Add an array of Debug FS files. 424fd88b31aSHariprasad Shenai */ 425fd88b31aSHariprasad Shenai void add_debugfs_files(struct adapter *adap, 426fd88b31aSHariprasad Shenai struct t4_debugfs_entry *files, 427fd88b31aSHariprasad Shenai unsigned int nfiles) 428fd88b31aSHariprasad Shenai { 429fd88b31aSHariprasad Shenai int i; 430fd88b31aSHariprasad Shenai 431fd88b31aSHariprasad Shenai /* debugfs support is best effort */ 432fd88b31aSHariprasad Shenai for (i = 0; i < nfiles; i++) 433fd88b31aSHariprasad Shenai debugfs_create_file(files[i].name, files[i].mode, 434fd88b31aSHariprasad Shenai adap->debugfs_root, 435fd88b31aSHariprasad Shenai (void *)adap + files[i].data, 436fd88b31aSHariprasad Shenai files[i].ops); 437fd88b31aSHariprasad Shenai } 438fd88b31aSHariprasad Shenai 439fd88b31aSHariprasad Shenai int t4_setup_debugfs(struct adapter *adap) 440fd88b31aSHariprasad Shenai { 441fd88b31aSHariprasad Shenai int i; 442fd88b31aSHariprasad Shenai u32 size; 443fd88b31aSHariprasad Shenai 444fd88b31aSHariprasad Shenai static struct t4_debugfs_entry t4_debugfs_files[] = { 445f1ff24aaSHariprasad Shenai { "cim_la", &cim_la_fops, S_IRUSR, 0 }, 44649aa284fSHariprasad Shenai { "devlog", &devlog_fops, S_IRUSR, 0 }, 447fd88b31aSHariprasad Shenai { "l2t", &t4_l2t_fops, S_IRUSR, 0}, 448fd88b31aSHariprasad Shenai }; 449fd88b31aSHariprasad Shenai 450fd88b31aSHariprasad Shenai add_debugfs_files(adap, 451fd88b31aSHariprasad Shenai t4_debugfs_files, 452fd88b31aSHariprasad Shenai ARRAY_SIZE(t4_debugfs_files)); 453fd88b31aSHariprasad Shenai 4546559a7e8SHariprasad Shenai i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A); 4556559a7e8SHariprasad Shenai if (i & EDRAM0_ENABLE_F) { 4566559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM0_BAR_A); 4576559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size)); 458fd88b31aSHariprasad Shenai } 4596559a7e8SHariprasad Shenai if (i & EDRAM1_ENABLE_F) { 4606559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EDRAM1_BAR_A); 4616559a7e8SHariprasad Shenai add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size)); 462fd88b31aSHariprasad Shenai } 463fd88b31aSHariprasad Shenai if (is_t4(adap->params.chip)) { 4646559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A); 4656559a7e8SHariprasad Shenai if (i & EXT_MEM_ENABLE_F) 466fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc", MEM_MC, 4676559a7e8SHariprasad Shenai EXT_MEM_SIZE_G(size)); 468fd88b31aSHariprasad Shenai } else { 4696559a7e8SHariprasad Shenai if (i & EXT_MEM0_ENABLE_F) { 4706559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A); 471fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc0", MEM_MC0, 4726559a7e8SHariprasad Shenai EXT_MEM0_SIZE_G(size)); 473fd88b31aSHariprasad Shenai } 4746559a7e8SHariprasad Shenai if (i & EXT_MEM1_ENABLE_F) { 4756559a7e8SHariprasad Shenai size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A); 476fd88b31aSHariprasad Shenai add_debugfs_mem(adap, "mc1", MEM_MC1, 4776559a7e8SHariprasad Shenai EXT_MEM1_SIZE_G(size)); 478fd88b31aSHariprasad Shenai } 479fd88b31aSHariprasad Shenai } 480fd88b31aSHariprasad Shenai return 0; 481fd88b31aSHariprasad Shenai } 482