1 /*
2  * This file is part of the Chelsio T4 Ethernet driver for Linux.
3  *
4  * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34 
35 #include <linux/seq_file.h>
36 #include <linux/debugfs.h>
37 #include <linux/string_helpers.h>
38 #include <linux/sort.h>
39 #include <linux/ctype.h>
40 
41 #include "cxgb4.h"
42 #include "t4_regs.h"
43 #include "t4_values.h"
44 #include "t4fw_api.h"
45 #include "cxgb4_debugfs.h"
46 #include "clip_tbl.h"
47 #include "l2t.h"
48 #include "cudbg_if.h"
49 #include "cudbg_lib_common.h"
50 #include "cudbg_entity.h"
51 #include "cudbg_lib.h"
52 
53 /* generic seq_file support for showing a table of size rows x width. */
54 static void *seq_tab_get_idx(struct seq_tab *tb, loff_t pos)
55 {
56 	pos -= tb->skip_first;
57 	return pos >= tb->rows ? NULL : &tb->data[pos * tb->width];
58 }
59 
60 static void *seq_tab_start(struct seq_file *seq, loff_t *pos)
61 {
62 	struct seq_tab *tb = seq->private;
63 
64 	if (tb->skip_first && *pos == 0)
65 		return SEQ_START_TOKEN;
66 
67 	return seq_tab_get_idx(tb, *pos);
68 }
69 
70 static void *seq_tab_next(struct seq_file *seq, void *v, loff_t *pos)
71 {
72 	v = seq_tab_get_idx(seq->private, *pos + 1);
73 	if (v)
74 		++*pos;
75 	return v;
76 }
77 
78 static void seq_tab_stop(struct seq_file *seq, void *v)
79 {
80 }
81 
82 static int seq_tab_show(struct seq_file *seq, void *v)
83 {
84 	const struct seq_tab *tb = seq->private;
85 
86 	return tb->show(seq, v, ((char *)v - tb->data) / tb->width);
87 }
88 
89 static const struct seq_operations seq_tab_ops = {
90 	.start = seq_tab_start,
91 	.next  = seq_tab_next,
92 	.stop  = seq_tab_stop,
93 	.show  = seq_tab_show
94 };
95 
96 struct seq_tab *seq_open_tab(struct file *f, unsigned int rows,
97 			     unsigned int width, unsigned int have_header,
98 			     int (*show)(struct seq_file *seq, void *v, int i))
99 {
100 	struct seq_tab *p;
101 
102 	p = __seq_open_private(f, &seq_tab_ops, sizeof(*p) + rows * width);
103 	if (p) {
104 		p->show = show;
105 		p->rows = rows;
106 		p->width = width;
107 		p->skip_first = have_header != 0;
108 	}
109 	return p;
110 }
111 
112 /* Trim the size of a seq_tab to the supplied number of rows.  The operation is
113  * irreversible.
114  */
115 static int seq_tab_trim(struct seq_tab *p, unsigned int new_rows)
116 {
117 	if (new_rows > p->rows)
118 		return -EINVAL;
119 	p->rows = new_rows;
120 	return 0;
121 }
122 
123 static int cim_la_show(struct seq_file *seq, void *v, int idx)
124 {
125 	if (v == SEQ_START_TOKEN)
126 		seq_puts(seq, "Status   Data      PC     LS0Stat  LS0Addr "
127 			 "            LS0Data\n");
128 	else {
129 		const u32 *p = v;
130 
131 		seq_printf(seq,
132 			   "  %02x  %x%07x %x%07x %08x %08x %08x%08x%08x%08x\n",
133 			   (p[0] >> 4) & 0xff, p[0] & 0xf, p[1] >> 4,
134 			   p[1] & 0xf, p[2] >> 4, p[2] & 0xf, p[3], p[4], p[5],
135 			   p[6], p[7]);
136 	}
137 	return 0;
138 }
139 
140 static int cim_la_show_3in1(struct seq_file *seq, void *v, int idx)
141 {
142 	if (v == SEQ_START_TOKEN) {
143 		seq_puts(seq, "Status   Data      PC\n");
144 	} else {
145 		const u32 *p = v;
146 
147 		seq_printf(seq, "  %02x   %08x %08x\n", p[5] & 0xff, p[6],
148 			   p[7]);
149 		seq_printf(seq, "  %02x   %02x%06x %02x%06x\n",
150 			   (p[3] >> 8) & 0xff, p[3] & 0xff, p[4] >> 8,
151 			   p[4] & 0xff, p[5] >> 8);
152 		seq_printf(seq, "  %02x   %x%07x %x%07x\n", (p[0] >> 4) & 0xff,
153 			   p[0] & 0xf, p[1] >> 4, p[1] & 0xf, p[2] >> 4);
154 	}
155 	return 0;
156 }
157 
158 static int cim_la_show_t6(struct seq_file *seq, void *v, int idx)
159 {
160 	if (v == SEQ_START_TOKEN) {
161 		seq_puts(seq, "Status   Inst    Data      PC     LS0Stat  "
162 			 "LS0Addr  LS0Data  LS1Stat  LS1Addr  LS1Data\n");
163 	} else {
164 		const u32 *p = v;
165 
166 		seq_printf(seq, "  %02x   %04x%04x %04x%04x %04x%04x %08x %08x %08x %08x %08x %08x\n",
167 			   (p[9] >> 16) & 0xff,       /* Status */
168 			   p[9] & 0xffff, p[8] >> 16, /* Inst */
169 			   p[8] & 0xffff, p[7] >> 16, /* Data */
170 			   p[7] & 0xffff, p[6] >> 16, /* PC */
171 			   p[2], p[1], p[0],      /* LS0 Stat, Addr and Data */
172 			   p[5], p[4], p[3]);     /* LS1 Stat, Addr and Data */
173 	}
174 	return 0;
175 }
176 
177 static int cim_la_show_pc_t6(struct seq_file *seq, void *v, int idx)
178 {
179 	if (v == SEQ_START_TOKEN) {
180 		seq_puts(seq, "Status   Inst    Data      PC\n");
181 	} else {
182 		const u32 *p = v;
183 
184 		seq_printf(seq, "  %02x   %08x %08x %08x\n",
185 			   p[3] & 0xff, p[2], p[1], p[0]);
186 		seq_printf(seq, "  %02x   %02x%06x %02x%06x %02x%06x\n",
187 			   (p[6] >> 8) & 0xff, p[6] & 0xff, p[5] >> 8,
188 			   p[5] & 0xff, p[4] >> 8, p[4] & 0xff, p[3] >> 8);
189 		seq_printf(seq, "  %02x   %04x%04x %04x%04x %04x%04x\n",
190 			   (p[9] >> 16) & 0xff, p[9] & 0xffff, p[8] >> 16,
191 			   p[8] & 0xffff, p[7] >> 16, p[7] & 0xffff,
192 			   p[6] >> 16);
193 	}
194 	return 0;
195 }
196 
197 static int cim_la_open(struct inode *inode, struct file *file)
198 {
199 	int ret;
200 	unsigned int cfg;
201 	struct seq_tab *p;
202 	struct adapter *adap = inode->i_private;
203 
204 	ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
205 	if (ret)
206 		return ret;
207 
208 	if (is_t6(adap->params.chip)) {
209 		/* +1 to account for integer division of CIMLA_SIZE/10 */
210 		p = seq_open_tab(file, (adap->params.cim_la_size / 10) + 1,
211 				 10 * sizeof(u32), 1,
212 				 cfg & UPDBGLACAPTPCONLY_F ?
213 					cim_la_show_pc_t6 : cim_la_show_t6);
214 	} else {
215 		p = seq_open_tab(file, adap->params.cim_la_size / 8,
216 				 8 * sizeof(u32), 1,
217 				 cfg & UPDBGLACAPTPCONLY_F ? cim_la_show_3in1 :
218 							     cim_la_show);
219 	}
220 	if (!p)
221 		return -ENOMEM;
222 
223 	ret = t4_cim_read_la(adap, (u32 *)p->data, NULL);
224 	if (ret)
225 		seq_release_private(inode, file);
226 	return ret;
227 }
228 
229 static const struct file_operations cim_la_fops = {
230 	.owner   = THIS_MODULE,
231 	.open    = cim_la_open,
232 	.read    = seq_read,
233 	.llseek  = seq_lseek,
234 	.release = seq_release_private
235 };
236 
237 static int cim_pif_la_show(struct seq_file *seq, void *v, int idx)
238 {
239 	const u32 *p = v;
240 
241 	if (v == SEQ_START_TOKEN) {
242 		seq_puts(seq, "Cntl ID DataBE   Addr                 Data\n");
243 	} else if (idx < CIM_PIFLA_SIZE) {
244 		seq_printf(seq, " %02x  %02x  %04x  %08x %08x%08x%08x%08x\n",
245 			   (p[5] >> 22) & 0xff, (p[5] >> 16) & 0x3f,
246 			   p[5] & 0xffff, p[4], p[3], p[2], p[1], p[0]);
247 	} else {
248 		if (idx == CIM_PIFLA_SIZE)
249 			seq_puts(seq, "\nCntl ID               Data\n");
250 		seq_printf(seq, " %02x  %02x %08x%08x%08x%08x\n",
251 			   (p[4] >> 6) & 0xff, p[4] & 0x3f,
252 			   p[3], p[2], p[1], p[0]);
253 	}
254 	return 0;
255 }
256 
257 static int cim_pif_la_open(struct inode *inode, struct file *file)
258 {
259 	struct seq_tab *p;
260 	struct adapter *adap = inode->i_private;
261 
262 	p = seq_open_tab(file, 2 * CIM_PIFLA_SIZE, 6 * sizeof(u32), 1,
263 			 cim_pif_la_show);
264 	if (!p)
265 		return -ENOMEM;
266 
267 	t4_cim_read_pif_la(adap, (u32 *)p->data,
268 			   (u32 *)p->data + 6 * CIM_PIFLA_SIZE, NULL, NULL);
269 	return 0;
270 }
271 
272 static const struct file_operations cim_pif_la_fops = {
273 	.owner   = THIS_MODULE,
274 	.open    = cim_pif_la_open,
275 	.read    = seq_read,
276 	.llseek  = seq_lseek,
277 	.release = seq_release_private
278 };
279 
280 static int cim_ma_la_show(struct seq_file *seq, void *v, int idx)
281 {
282 	const u32 *p = v;
283 
284 	if (v == SEQ_START_TOKEN) {
285 		seq_puts(seq, "\n");
286 	} else if (idx < CIM_MALA_SIZE) {
287 		seq_printf(seq, "%02x%08x%08x%08x%08x\n",
288 			   p[4], p[3], p[2], p[1], p[0]);
289 	} else {
290 		if (idx == CIM_MALA_SIZE)
291 			seq_puts(seq,
292 				 "\nCnt ID Tag UE       Data       RDY VLD\n");
293 		seq_printf(seq, "%3u %2u  %x   %u %08x%08x  %u   %u\n",
294 			   (p[2] >> 10) & 0xff, (p[2] >> 7) & 7,
295 			   (p[2] >> 3) & 0xf, (p[2] >> 2) & 1,
296 			   (p[1] >> 2) | ((p[2] & 3) << 30),
297 			   (p[0] >> 2) | ((p[1] & 3) << 30), (p[0] >> 1) & 1,
298 			   p[0] & 1);
299 	}
300 	return 0;
301 }
302 
303 static int cim_ma_la_open(struct inode *inode, struct file *file)
304 {
305 	struct seq_tab *p;
306 	struct adapter *adap = inode->i_private;
307 
308 	p = seq_open_tab(file, 2 * CIM_MALA_SIZE, 5 * sizeof(u32), 1,
309 			 cim_ma_la_show);
310 	if (!p)
311 		return -ENOMEM;
312 
313 	t4_cim_read_ma_la(adap, (u32 *)p->data,
314 			  (u32 *)p->data + 5 * CIM_MALA_SIZE);
315 	return 0;
316 }
317 
318 static const struct file_operations cim_ma_la_fops = {
319 	.owner   = THIS_MODULE,
320 	.open    = cim_ma_la_open,
321 	.read    = seq_read,
322 	.llseek  = seq_lseek,
323 	.release = seq_release_private
324 };
325 
326 static int cim_qcfg_show(struct seq_file *seq, void *v)
327 {
328 	static const char * const qname[] = {
329 		"TP0", "TP1", "ULP", "SGE0", "SGE1", "NC-SI",
330 		"ULP0", "ULP1", "ULP2", "ULP3", "SGE", "NC-SI",
331 		"SGE0-RX", "SGE1-RX"
332 	};
333 
334 	int i;
335 	struct adapter *adap = seq->private;
336 	u16 base[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
337 	u16 size[CIM_NUM_IBQ + CIM_NUM_OBQ_T5];
338 	u32 stat[(4 * (CIM_NUM_IBQ + CIM_NUM_OBQ_T5))];
339 	u16 thres[CIM_NUM_IBQ];
340 	u32 obq_wr_t4[2 * CIM_NUM_OBQ], *wr;
341 	u32 obq_wr_t5[2 * CIM_NUM_OBQ_T5];
342 	u32 *p = stat;
343 	int cim_num_obq = is_t4(adap->params.chip) ?
344 				CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
345 
346 	i = t4_cim_read(adap, is_t4(adap->params.chip) ? UP_IBQ_0_RDADDR_A :
347 			UP_IBQ_0_SHADOW_RDADDR_A,
348 			ARRAY_SIZE(stat), stat);
349 	if (!i) {
350 		if (is_t4(adap->params.chip)) {
351 			i = t4_cim_read(adap, UP_OBQ_0_REALADDR_A,
352 					ARRAY_SIZE(obq_wr_t4), obq_wr_t4);
353 			wr = obq_wr_t4;
354 		} else {
355 			i = t4_cim_read(adap, UP_OBQ_0_SHADOW_REALADDR_A,
356 					ARRAY_SIZE(obq_wr_t5), obq_wr_t5);
357 			wr = obq_wr_t5;
358 		}
359 	}
360 	if (i)
361 		return i;
362 
363 	t4_read_cimq_cfg(adap, base, size, thres);
364 
365 	seq_printf(seq,
366 		   "  Queue  Base  Size Thres  RdPtr WrPtr  SOP  EOP Avail\n");
367 	for (i = 0; i < CIM_NUM_IBQ; i++, p += 4)
368 		seq_printf(seq, "%7s %5x %5u %5u %6x  %4x %4u %4u %5u\n",
369 			   qname[i], base[i], size[i], thres[i],
370 			   IBQRDADDR_G(p[0]), IBQWRADDR_G(p[1]),
371 			   QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
372 			   QUEREMFLITS_G(p[2]) * 16);
373 	for ( ; i < CIM_NUM_IBQ + cim_num_obq; i++, p += 4, wr += 2)
374 		seq_printf(seq, "%7s %5x %5u %12x  %4x %4u %4u %5u\n",
375 			   qname[i], base[i], size[i],
376 			   QUERDADDR_G(p[0]) & 0x3fff, wr[0] - base[i],
377 			   QUESOPCNT_G(p[3]), QUEEOPCNT_G(p[3]),
378 			   QUEREMFLITS_G(p[2]) * 16);
379 	return 0;
380 }
381 DEFINE_SHOW_ATTRIBUTE(cim_qcfg);
382 
383 static int cimq_show(struct seq_file *seq, void *v, int idx)
384 {
385 	const u32 *p = v;
386 
387 	seq_printf(seq, "%#06x: %08x %08x %08x %08x\n", idx * 16, p[0], p[1],
388 		   p[2], p[3]);
389 	return 0;
390 }
391 
392 static int cim_ibq_open(struct inode *inode, struct file *file)
393 {
394 	int ret;
395 	struct seq_tab *p;
396 	unsigned int qid = (uintptr_t)inode->i_private & 7;
397 	struct adapter *adap = inode->i_private - qid;
398 
399 	p = seq_open_tab(file, CIM_IBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
400 	if (!p)
401 		return -ENOMEM;
402 
403 	ret = t4_read_cim_ibq(adap, qid, (u32 *)p->data, CIM_IBQ_SIZE * 4);
404 	if (ret < 0)
405 		seq_release_private(inode, file);
406 	else
407 		ret = 0;
408 	return ret;
409 }
410 
411 static const struct file_operations cim_ibq_fops = {
412 	.owner   = THIS_MODULE,
413 	.open    = cim_ibq_open,
414 	.read    = seq_read,
415 	.llseek  = seq_lseek,
416 	.release = seq_release_private
417 };
418 
419 static int cim_obq_open(struct inode *inode, struct file *file)
420 {
421 	int ret;
422 	struct seq_tab *p;
423 	unsigned int qid = (uintptr_t)inode->i_private & 7;
424 	struct adapter *adap = inode->i_private - qid;
425 
426 	p = seq_open_tab(file, 6 * CIM_OBQ_SIZE, 4 * sizeof(u32), 0, cimq_show);
427 	if (!p)
428 		return -ENOMEM;
429 
430 	ret = t4_read_cim_obq(adap, qid, (u32 *)p->data, 6 * CIM_OBQ_SIZE * 4);
431 	if (ret < 0) {
432 		seq_release_private(inode, file);
433 	} else {
434 		seq_tab_trim(p, ret / 4);
435 		ret = 0;
436 	}
437 	return ret;
438 }
439 
440 static const struct file_operations cim_obq_fops = {
441 	.owner   = THIS_MODULE,
442 	.open    = cim_obq_open,
443 	.read    = seq_read,
444 	.llseek  = seq_lseek,
445 	.release = seq_release_private
446 };
447 
448 struct field_desc {
449 	const char *name;
450 	unsigned int start;
451 	unsigned int width;
452 };
453 
454 static void field_desc_show(struct seq_file *seq, u64 v,
455 			    const struct field_desc *p)
456 {
457 	char buf[32];
458 	int line_size = 0;
459 
460 	while (p->name) {
461 		u64 mask = (1ULL << p->width) - 1;
462 		int len = scnprintf(buf, sizeof(buf), "%s: %llu", p->name,
463 				    ((unsigned long long)v >> p->start) & mask);
464 
465 		if (line_size + len >= 79) {
466 			line_size = 8;
467 			seq_puts(seq, "\n        ");
468 		}
469 		seq_printf(seq, "%s ", buf);
470 		line_size += len + 1;
471 		p++;
472 	}
473 	seq_putc(seq, '\n');
474 }
475 
476 static struct field_desc tp_la0[] = {
477 	{ "RcfOpCodeOut", 60, 4 },
478 	{ "State", 56, 4 },
479 	{ "WcfState", 52, 4 },
480 	{ "RcfOpcSrcOut", 50, 2 },
481 	{ "CRxError", 49, 1 },
482 	{ "ERxError", 48, 1 },
483 	{ "SanityFailed", 47, 1 },
484 	{ "SpuriousMsg", 46, 1 },
485 	{ "FlushInputMsg", 45, 1 },
486 	{ "FlushInputCpl", 44, 1 },
487 	{ "RssUpBit", 43, 1 },
488 	{ "RssFilterHit", 42, 1 },
489 	{ "Tid", 32, 10 },
490 	{ "InitTcb", 31, 1 },
491 	{ "LineNumber", 24, 7 },
492 	{ "Emsg", 23, 1 },
493 	{ "EdataOut", 22, 1 },
494 	{ "Cmsg", 21, 1 },
495 	{ "CdataOut", 20, 1 },
496 	{ "EreadPdu", 19, 1 },
497 	{ "CreadPdu", 18, 1 },
498 	{ "TunnelPkt", 17, 1 },
499 	{ "RcfPeerFin", 16, 1 },
500 	{ "RcfReasonOut", 12, 4 },
501 	{ "TxCchannel", 10, 2 },
502 	{ "RcfTxChannel", 8, 2 },
503 	{ "RxEchannel", 6, 2 },
504 	{ "RcfRxChannel", 5, 1 },
505 	{ "RcfDataOutSrdy", 4, 1 },
506 	{ "RxDvld", 3, 1 },
507 	{ "RxOoDvld", 2, 1 },
508 	{ "RxCongestion", 1, 1 },
509 	{ "TxCongestion", 0, 1 },
510 	{ NULL }
511 };
512 
513 static int tp_la_show(struct seq_file *seq, void *v, int idx)
514 {
515 	const u64 *p = v;
516 
517 	field_desc_show(seq, *p, tp_la0);
518 	return 0;
519 }
520 
521 static int tp_la_show2(struct seq_file *seq, void *v, int idx)
522 {
523 	const u64 *p = v;
524 
525 	if (idx)
526 		seq_putc(seq, '\n');
527 	field_desc_show(seq, p[0], tp_la0);
528 	if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
529 		field_desc_show(seq, p[1], tp_la0);
530 	return 0;
531 }
532 
533 static int tp_la_show3(struct seq_file *seq, void *v, int idx)
534 {
535 	static struct field_desc tp_la1[] = {
536 		{ "CplCmdIn", 56, 8 },
537 		{ "CplCmdOut", 48, 8 },
538 		{ "ESynOut", 47, 1 },
539 		{ "EAckOut", 46, 1 },
540 		{ "EFinOut", 45, 1 },
541 		{ "ERstOut", 44, 1 },
542 		{ "SynIn", 43, 1 },
543 		{ "AckIn", 42, 1 },
544 		{ "FinIn", 41, 1 },
545 		{ "RstIn", 40, 1 },
546 		{ "DataIn", 39, 1 },
547 		{ "DataInVld", 38, 1 },
548 		{ "PadIn", 37, 1 },
549 		{ "RxBufEmpty", 36, 1 },
550 		{ "RxDdp", 35, 1 },
551 		{ "RxFbCongestion", 34, 1 },
552 		{ "TxFbCongestion", 33, 1 },
553 		{ "TxPktSumSrdy", 32, 1 },
554 		{ "RcfUlpType", 28, 4 },
555 		{ "Eread", 27, 1 },
556 		{ "Ebypass", 26, 1 },
557 		{ "Esave", 25, 1 },
558 		{ "Static0", 24, 1 },
559 		{ "Cread", 23, 1 },
560 		{ "Cbypass", 22, 1 },
561 		{ "Csave", 21, 1 },
562 		{ "CPktOut", 20, 1 },
563 		{ "RxPagePoolFull", 18, 2 },
564 		{ "RxLpbkPkt", 17, 1 },
565 		{ "TxLpbkPkt", 16, 1 },
566 		{ "RxVfValid", 15, 1 },
567 		{ "SynLearned", 14, 1 },
568 		{ "SetDelEntry", 13, 1 },
569 		{ "SetInvEntry", 12, 1 },
570 		{ "CpcmdDvld", 11, 1 },
571 		{ "CpcmdSave", 10, 1 },
572 		{ "RxPstructsFull", 8, 2 },
573 		{ "EpcmdDvld", 7, 1 },
574 		{ "EpcmdFlush", 6, 1 },
575 		{ "EpcmdTrimPrefix", 5, 1 },
576 		{ "EpcmdTrimPostfix", 4, 1 },
577 		{ "ERssIp4Pkt", 3, 1 },
578 		{ "ERssIp6Pkt", 2, 1 },
579 		{ "ERssTcpUdpPkt", 1, 1 },
580 		{ "ERssFceFipPkt", 0, 1 },
581 		{ NULL }
582 	};
583 	static struct field_desc tp_la2[] = {
584 		{ "CplCmdIn", 56, 8 },
585 		{ "MpsVfVld", 55, 1 },
586 		{ "MpsPf", 52, 3 },
587 		{ "MpsVf", 44, 8 },
588 		{ "SynIn", 43, 1 },
589 		{ "AckIn", 42, 1 },
590 		{ "FinIn", 41, 1 },
591 		{ "RstIn", 40, 1 },
592 		{ "DataIn", 39, 1 },
593 		{ "DataInVld", 38, 1 },
594 		{ "PadIn", 37, 1 },
595 		{ "RxBufEmpty", 36, 1 },
596 		{ "RxDdp", 35, 1 },
597 		{ "RxFbCongestion", 34, 1 },
598 		{ "TxFbCongestion", 33, 1 },
599 		{ "TxPktSumSrdy", 32, 1 },
600 		{ "RcfUlpType", 28, 4 },
601 		{ "Eread", 27, 1 },
602 		{ "Ebypass", 26, 1 },
603 		{ "Esave", 25, 1 },
604 		{ "Static0", 24, 1 },
605 		{ "Cread", 23, 1 },
606 		{ "Cbypass", 22, 1 },
607 		{ "Csave", 21, 1 },
608 		{ "CPktOut", 20, 1 },
609 		{ "RxPagePoolFull", 18, 2 },
610 		{ "RxLpbkPkt", 17, 1 },
611 		{ "TxLpbkPkt", 16, 1 },
612 		{ "RxVfValid", 15, 1 },
613 		{ "SynLearned", 14, 1 },
614 		{ "SetDelEntry", 13, 1 },
615 		{ "SetInvEntry", 12, 1 },
616 		{ "CpcmdDvld", 11, 1 },
617 		{ "CpcmdSave", 10, 1 },
618 		{ "RxPstructsFull", 8, 2 },
619 		{ "EpcmdDvld", 7, 1 },
620 		{ "EpcmdFlush", 6, 1 },
621 		{ "EpcmdTrimPrefix", 5, 1 },
622 		{ "EpcmdTrimPostfix", 4, 1 },
623 		{ "ERssIp4Pkt", 3, 1 },
624 		{ "ERssIp6Pkt", 2, 1 },
625 		{ "ERssTcpUdpPkt", 1, 1 },
626 		{ "ERssFceFipPkt", 0, 1 },
627 		{ NULL }
628 	};
629 	const u64 *p = v;
630 
631 	if (idx)
632 		seq_putc(seq, '\n');
633 	field_desc_show(seq, p[0], tp_la0);
634 	if (idx < (TPLA_SIZE / 2 - 1) || p[1] != ~0ULL)
635 		field_desc_show(seq, p[1], (p[0] & BIT(17)) ? tp_la2 : tp_la1);
636 	return 0;
637 }
638 
639 static int tp_la_open(struct inode *inode, struct file *file)
640 {
641 	struct seq_tab *p;
642 	struct adapter *adap = inode->i_private;
643 
644 	switch (DBGLAMODE_G(t4_read_reg(adap, TP_DBG_LA_CONFIG_A))) {
645 	case 2:
646 		p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0,
647 				 tp_la_show2);
648 		break;
649 	case 3:
650 		p = seq_open_tab(file, TPLA_SIZE / 2, 2 * sizeof(u64), 0,
651 				 tp_la_show3);
652 		break;
653 	default:
654 		p = seq_open_tab(file, TPLA_SIZE, sizeof(u64), 0, tp_la_show);
655 	}
656 	if (!p)
657 		return -ENOMEM;
658 
659 	t4_tp_read_la(adap, (u64 *)p->data, NULL);
660 	return 0;
661 }
662 
663 static ssize_t tp_la_write(struct file *file, const char __user *buf,
664 			   size_t count, loff_t *pos)
665 {
666 	int err;
667 	char s[32];
668 	unsigned long val;
669 	size_t size = min(sizeof(s) - 1, count);
670 	struct adapter *adap = file_inode(file)->i_private;
671 
672 	if (copy_from_user(s, buf, size))
673 		return -EFAULT;
674 	s[size] = '\0';
675 	err = kstrtoul(s, 0, &val);
676 	if (err)
677 		return err;
678 	if (val > 0xffff)
679 		return -EINVAL;
680 	adap->params.tp.la_mask = val << 16;
681 	t4_set_reg_field(adap, TP_DBG_LA_CONFIG_A, 0xffff0000U,
682 			 adap->params.tp.la_mask);
683 	return count;
684 }
685 
686 static const struct file_operations tp_la_fops = {
687 	.owner   = THIS_MODULE,
688 	.open    = tp_la_open,
689 	.read    = seq_read,
690 	.llseek  = seq_lseek,
691 	.release = seq_release_private,
692 	.write   = tp_la_write
693 };
694 
695 static int ulprx_la_show(struct seq_file *seq, void *v, int idx)
696 {
697 	const u32 *p = v;
698 
699 	if (v == SEQ_START_TOKEN)
700 		seq_puts(seq, "      Pcmd        Type   Message"
701 			 "                Data\n");
702 	else
703 		seq_printf(seq, "%08x%08x  %4x  %08x  %08x%08x%08x%08x\n",
704 			   p[1], p[0], p[2], p[3], p[7], p[6], p[5], p[4]);
705 	return 0;
706 }
707 
708 static int ulprx_la_open(struct inode *inode, struct file *file)
709 {
710 	struct seq_tab *p;
711 	struct adapter *adap = inode->i_private;
712 
713 	p = seq_open_tab(file, ULPRX_LA_SIZE, 8 * sizeof(u32), 1,
714 			 ulprx_la_show);
715 	if (!p)
716 		return -ENOMEM;
717 
718 	t4_ulprx_read_la(adap, (u32 *)p->data);
719 	return 0;
720 }
721 
722 static const struct file_operations ulprx_la_fops = {
723 	.owner   = THIS_MODULE,
724 	.open    = ulprx_la_open,
725 	.read    = seq_read,
726 	.llseek  = seq_lseek,
727 	.release = seq_release_private
728 };
729 
730 /* Show the PM memory stats.  These stats include:
731  *
732  * TX:
733  *   Read: memory read operation
734  *   Write Bypass: cut-through
735  *   Bypass + mem: cut-through and save copy
736  *
737  * RX:
738  *   Read: memory read
739  *   Write Bypass: cut-through
740  *   Flush: payload trim or drop
741  */
742 static int pm_stats_show(struct seq_file *seq, void *v)
743 {
744 	static const char * const tx_pm_stats[] = {
745 		"Read:", "Write bypass:", "Write mem:", "Bypass + mem:"
746 	};
747 	static const char * const rx_pm_stats[] = {
748 		"Read:", "Write bypass:", "Write mem:", "Flush:"
749 	};
750 
751 	int i;
752 	u32 tx_cnt[T6_PM_NSTATS], rx_cnt[T6_PM_NSTATS];
753 	u64 tx_cyc[T6_PM_NSTATS], rx_cyc[T6_PM_NSTATS];
754 	struct adapter *adap = seq->private;
755 
756 	t4_pmtx_get_stats(adap, tx_cnt, tx_cyc);
757 	t4_pmrx_get_stats(adap, rx_cnt, rx_cyc);
758 
759 	seq_printf(seq, "%13s %10s  %20s\n", " ", "Tx pcmds", "Tx bytes");
760 	for (i = 0; i < PM_NSTATS - 1; i++)
761 		seq_printf(seq, "%-13s %10u  %20llu\n",
762 			   tx_pm_stats[i], tx_cnt[i], tx_cyc[i]);
763 
764 	seq_printf(seq, "%13s %10s  %20s\n", " ", "Rx pcmds", "Rx bytes");
765 	for (i = 0; i < PM_NSTATS - 1; i++)
766 		seq_printf(seq, "%-13s %10u  %20llu\n",
767 			   rx_pm_stats[i], rx_cnt[i], rx_cyc[i]);
768 
769 	if (CHELSIO_CHIP_VERSION(adap->params.chip) > CHELSIO_T5) {
770 		/* In T5 the granularity of the total wait is too fine.
771 		 * It is not useful as it reaches the max value too fast.
772 		 * Hence display this Input FIFO wait for T6 onwards.
773 		 */
774 		seq_printf(seq, "%13s %10s  %20s\n",
775 			   " ", "Total wait", "Total Occupancy");
776 		seq_printf(seq, "Tx FIFO wait  %10u  %20llu\n",
777 			   tx_cnt[i], tx_cyc[i]);
778 		seq_printf(seq, "Rx FIFO wait  %10u  %20llu\n",
779 			   rx_cnt[i], rx_cyc[i]);
780 
781 		/* Skip index 6 as there is nothing useful ihere */
782 		i += 2;
783 
784 		/* At index 7, a new stat for read latency (count, total wait)
785 		 * is added.
786 		 */
787 		seq_printf(seq, "%13s %10s  %20s\n",
788 			   " ", "Reads", "Total wait");
789 		seq_printf(seq, "Tx latency    %10u  %20llu\n",
790 			   tx_cnt[i], tx_cyc[i]);
791 		seq_printf(seq, "Rx latency    %10u  %20llu\n",
792 			   rx_cnt[i], rx_cyc[i]);
793 	}
794 	return 0;
795 }
796 
797 static int pm_stats_open(struct inode *inode, struct file *file)
798 {
799 	return single_open(file, pm_stats_show, inode->i_private);
800 }
801 
802 static ssize_t pm_stats_clear(struct file *file, const char __user *buf,
803 			      size_t count, loff_t *pos)
804 {
805 	struct adapter *adap = file_inode(file)->i_private;
806 
807 	t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0);
808 	t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0);
809 	return count;
810 }
811 
812 static const struct file_operations pm_stats_debugfs_fops = {
813 	.owner   = THIS_MODULE,
814 	.open    = pm_stats_open,
815 	.read    = seq_read,
816 	.llseek  = seq_lseek,
817 	.release = single_release,
818 	.write   = pm_stats_clear
819 };
820 
821 static int tx_rate_show(struct seq_file *seq, void *v)
822 {
823 	u64 nrate[NCHAN], orate[NCHAN];
824 	struct adapter *adap = seq->private;
825 
826 	t4_get_chan_txrate(adap, nrate, orate);
827 	if (adap->params.arch.nchan == NCHAN) {
828 		seq_puts(seq, "              channel 0   channel 1   "
829 			 "channel 2   channel 3\n");
830 		seq_printf(seq, "NIC B/s:     %10llu  %10llu  %10llu  %10llu\n",
831 			   (unsigned long long)nrate[0],
832 			   (unsigned long long)nrate[1],
833 			   (unsigned long long)nrate[2],
834 			   (unsigned long long)nrate[3]);
835 		seq_printf(seq, "Offload B/s: %10llu  %10llu  %10llu  %10llu\n",
836 			   (unsigned long long)orate[0],
837 			   (unsigned long long)orate[1],
838 			   (unsigned long long)orate[2],
839 			   (unsigned long long)orate[3]);
840 	} else {
841 		seq_puts(seq, "              channel 0   channel 1\n");
842 		seq_printf(seq, "NIC B/s:     %10llu  %10llu\n",
843 			   (unsigned long long)nrate[0],
844 			   (unsigned long long)nrate[1]);
845 		seq_printf(seq, "Offload B/s: %10llu  %10llu\n",
846 			   (unsigned long long)orate[0],
847 			   (unsigned long long)orate[1]);
848 	}
849 	return 0;
850 }
851 DEFINE_SHOW_ATTRIBUTE(tx_rate);
852 
853 static int cctrl_tbl_show(struct seq_file *seq, void *v)
854 {
855 	static const char * const dec_fac[] = {
856 		"0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875",
857 		"0.9375" };
858 
859 	int i;
860 	u16 (*incr)[NCCTRL_WIN];
861 	struct adapter *adap = seq->private;
862 
863 	incr = kmalloc_array(NMTUS, sizeof(*incr), GFP_KERNEL);
864 	if (!incr)
865 		return -ENOMEM;
866 
867 	t4_read_cong_tbl(adap, incr);
868 
869 	for (i = 0; i < NCCTRL_WIN; ++i) {
870 		seq_printf(seq, "%2d: %4u %4u %4u %4u %4u %4u %4u %4u\n", i,
871 			   incr[0][i], incr[1][i], incr[2][i], incr[3][i],
872 			   incr[4][i], incr[5][i], incr[6][i], incr[7][i]);
873 		seq_printf(seq, "%8u %4u %4u %4u %4u %4u %4u %4u %5u %s\n",
874 			   incr[8][i], incr[9][i], incr[10][i], incr[11][i],
875 			   incr[12][i], incr[13][i], incr[14][i], incr[15][i],
876 			   adap->params.a_wnd[i],
877 			   dec_fac[adap->params.b_wnd[i]]);
878 	}
879 
880 	kfree(incr);
881 	return 0;
882 }
883 DEFINE_SHOW_ATTRIBUTE(cctrl_tbl);
884 
885 /* Format a value in a unit that differs from the value's native unit by the
886  * given factor.
887  */
888 static char *unit_conv(char *buf, size_t len, unsigned int val,
889 		       unsigned int factor)
890 {
891 	unsigned int rem = val % factor;
892 
893 	if (rem == 0) {
894 		snprintf(buf, len, "%u", val / factor);
895 	} else {
896 		while (rem % 10 == 0)
897 			rem /= 10;
898 		snprintf(buf, len, "%u.%u", val / factor, rem);
899 	}
900 	return buf;
901 }
902 
903 static int clk_show(struct seq_file *seq, void *v)
904 {
905 	char buf[32];
906 	struct adapter *adap = seq->private;
907 	unsigned int cclk_ps = 1000000000 / adap->params.vpd.cclk;  /* in ps */
908 	u32 res = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
909 	unsigned int tre = TIMERRESOLUTION_G(res);
910 	unsigned int dack_re = DELAYEDACKRESOLUTION_G(res);
911 	unsigned long long tp_tick_us = (cclk_ps << tre) / 1000000; /* in us */
912 
913 	seq_printf(seq, "Core clock period: %s ns\n",
914 		   unit_conv(buf, sizeof(buf), cclk_ps, 1000));
915 	seq_printf(seq, "TP timer tick: %s us\n",
916 		   unit_conv(buf, sizeof(buf), (cclk_ps << tre), 1000000));
917 	seq_printf(seq, "TCP timestamp tick: %s us\n",
918 		   unit_conv(buf, sizeof(buf),
919 			     (cclk_ps << TIMESTAMPRESOLUTION_G(res)), 1000000));
920 	seq_printf(seq, "DACK tick: %s us\n",
921 		   unit_conv(buf, sizeof(buf), (cclk_ps << dack_re), 1000000));
922 	seq_printf(seq, "DACK timer: %u us\n",
923 		   ((cclk_ps << dack_re) / 1000000) *
924 		   t4_read_reg(adap, TP_DACK_TIMER_A));
925 	seq_printf(seq, "Retransmit min: %llu us\n",
926 		   tp_tick_us * t4_read_reg(adap, TP_RXT_MIN_A));
927 	seq_printf(seq, "Retransmit max: %llu us\n",
928 		   tp_tick_us * t4_read_reg(adap, TP_RXT_MAX_A));
929 	seq_printf(seq, "Persist timer min: %llu us\n",
930 		   tp_tick_us * t4_read_reg(adap, TP_PERS_MIN_A));
931 	seq_printf(seq, "Persist timer max: %llu us\n",
932 		   tp_tick_us * t4_read_reg(adap, TP_PERS_MAX_A));
933 	seq_printf(seq, "Keepalive idle timer: %llu us\n",
934 		   tp_tick_us * t4_read_reg(adap, TP_KEEP_IDLE_A));
935 	seq_printf(seq, "Keepalive interval: %llu us\n",
936 		   tp_tick_us * t4_read_reg(adap, TP_KEEP_INTVL_A));
937 	seq_printf(seq, "Initial SRTT: %llu us\n",
938 		   tp_tick_us * INITSRTT_G(t4_read_reg(adap, TP_INIT_SRTT_A)));
939 	seq_printf(seq, "FINWAIT2 timer: %llu us\n",
940 		   tp_tick_us * t4_read_reg(adap, TP_FINWAIT2_TIMER_A));
941 
942 	return 0;
943 }
944 DEFINE_SHOW_ATTRIBUTE(clk);
945 
946 /* Firmware Device Log dump. */
947 static const char * const devlog_level_strings[] = {
948 	[FW_DEVLOG_LEVEL_EMERG]		= "EMERG",
949 	[FW_DEVLOG_LEVEL_CRIT]		= "CRIT",
950 	[FW_DEVLOG_LEVEL_ERR]		= "ERR",
951 	[FW_DEVLOG_LEVEL_NOTICE]	= "NOTICE",
952 	[FW_DEVLOG_LEVEL_INFO]		= "INFO",
953 	[FW_DEVLOG_LEVEL_DEBUG]		= "DEBUG"
954 };
955 
956 static const char * const devlog_facility_strings[] = {
957 	[FW_DEVLOG_FACILITY_CORE]	= "CORE",
958 	[FW_DEVLOG_FACILITY_CF]         = "CF",
959 	[FW_DEVLOG_FACILITY_SCHED]	= "SCHED",
960 	[FW_DEVLOG_FACILITY_TIMER]	= "TIMER",
961 	[FW_DEVLOG_FACILITY_RES]	= "RES",
962 	[FW_DEVLOG_FACILITY_HW]		= "HW",
963 	[FW_DEVLOG_FACILITY_FLR]	= "FLR",
964 	[FW_DEVLOG_FACILITY_DMAQ]	= "DMAQ",
965 	[FW_DEVLOG_FACILITY_PHY]	= "PHY",
966 	[FW_DEVLOG_FACILITY_MAC]	= "MAC",
967 	[FW_DEVLOG_FACILITY_PORT]	= "PORT",
968 	[FW_DEVLOG_FACILITY_VI]		= "VI",
969 	[FW_DEVLOG_FACILITY_FILTER]	= "FILTER",
970 	[FW_DEVLOG_FACILITY_ACL]	= "ACL",
971 	[FW_DEVLOG_FACILITY_TM]		= "TM",
972 	[FW_DEVLOG_FACILITY_QFC]	= "QFC",
973 	[FW_DEVLOG_FACILITY_DCB]	= "DCB",
974 	[FW_DEVLOG_FACILITY_ETH]	= "ETH",
975 	[FW_DEVLOG_FACILITY_OFLD]	= "OFLD",
976 	[FW_DEVLOG_FACILITY_RI]		= "RI",
977 	[FW_DEVLOG_FACILITY_ISCSI]	= "ISCSI",
978 	[FW_DEVLOG_FACILITY_FCOE]	= "FCOE",
979 	[FW_DEVLOG_FACILITY_FOISCSI]	= "FOISCSI",
980 	[FW_DEVLOG_FACILITY_FOFCOE]	= "FOFCOE"
981 };
982 
983 /* Information gathered by Device Log Open routine for the display routine.
984  */
985 struct devlog_info {
986 	unsigned int nentries;		/* number of entries in log[] */
987 	unsigned int first;		/* first [temporal] entry in log[] */
988 	struct fw_devlog_e log[0];	/* Firmware Device Log */
989 };
990 
991 /* Dump a Firmaware Device Log entry.
992  */
993 static int devlog_show(struct seq_file *seq, void *v)
994 {
995 	if (v == SEQ_START_TOKEN)
996 		seq_printf(seq, "%10s  %15s  %8s  %8s  %s\n",
997 			   "Seq#", "Tstamp", "Level", "Facility", "Message");
998 	else {
999 		struct devlog_info *dinfo = seq->private;
1000 		int fidx = (uintptr_t)v - 2;
1001 		unsigned long index;
1002 		struct fw_devlog_e *e;
1003 
1004 		/* Get a pointer to the log entry to display.  Skip unused log
1005 		 * entries.
1006 		 */
1007 		index = dinfo->first + fidx;
1008 		if (index >= dinfo->nentries)
1009 			index -= dinfo->nentries;
1010 		e = &dinfo->log[index];
1011 		if (e->timestamp == 0)
1012 			return 0;
1013 
1014 		/* Print the message.  This depends on the firmware using
1015 		 * exactly the same formating strings as the kernel so we may
1016 		 * eventually have to put a format interpreter in here ...
1017 		 */
1018 		seq_printf(seq, "%10d  %15llu  %8s  %8s  ",
1019 			   be32_to_cpu(e->seqno),
1020 			   be64_to_cpu(e->timestamp),
1021 			   (e->level < ARRAY_SIZE(devlog_level_strings)
1022 			    ? devlog_level_strings[e->level]
1023 			    : "UNKNOWN"),
1024 			   (e->facility < ARRAY_SIZE(devlog_facility_strings)
1025 			    ? devlog_facility_strings[e->facility]
1026 			    : "UNKNOWN"));
1027 		seq_printf(seq, e->fmt,
1028 			   be32_to_cpu(e->params[0]),
1029 			   be32_to_cpu(e->params[1]),
1030 			   be32_to_cpu(e->params[2]),
1031 			   be32_to_cpu(e->params[3]),
1032 			   be32_to_cpu(e->params[4]),
1033 			   be32_to_cpu(e->params[5]),
1034 			   be32_to_cpu(e->params[6]),
1035 			   be32_to_cpu(e->params[7]));
1036 	}
1037 	return 0;
1038 }
1039 
1040 /* Sequential File Operations for Device Log.
1041  */
1042 static inline void *devlog_get_idx(struct devlog_info *dinfo, loff_t pos)
1043 {
1044 	if (pos > dinfo->nentries)
1045 		return NULL;
1046 
1047 	return (void *)(uintptr_t)(pos + 1);
1048 }
1049 
1050 static void *devlog_start(struct seq_file *seq, loff_t *pos)
1051 {
1052 	struct devlog_info *dinfo = seq->private;
1053 
1054 	return (*pos
1055 		? devlog_get_idx(dinfo, *pos)
1056 		: SEQ_START_TOKEN);
1057 }
1058 
1059 static void *devlog_next(struct seq_file *seq, void *v, loff_t *pos)
1060 {
1061 	struct devlog_info *dinfo = seq->private;
1062 
1063 	(*pos)++;
1064 	return devlog_get_idx(dinfo, *pos);
1065 }
1066 
1067 static void devlog_stop(struct seq_file *seq, void *v)
1068 {
1069 }
1070 
1071 static const struct seq_operations devlog_seq_ops = {
1072 	.start = devlog_start,
1073 	.next  = devlog_next,
1074 	.stop  = devlog_stop,
1075 	.show  = devlog_show
1076 };
1077 
1078 /* Set up for reading the firmware's device log.  We read the entire log here
1079  * and then display it incrementally in devlog_show().
1080  */
1081 static int devlog_open(struct inode *inode, struct file *file)
1082 {
1083 	struct adapter *adap = inode->i_private;
1084 	struct devlog_params *dparams = &adap->params.devlog;
1085 	struct devlog_info *dinfo;
1086 	unsigned int index;
1087 	u32 fseqno;
1088 	int ret;
1089 
1090 	/* If we don't know where the log is we can't do anything.
1091 	 */
1092 	if (dparams->start == 0)
1093 		return -ENXIO;
1094 
1095 	/* Allocate the space to read in the firmware's device log and set up
1096 	 * for the iterated call to our display function.
1097 	 */
1098 	dinfo = __seq_open_private(file, &devlog_seq_ops,
1099 				   sizeof(*dinfo) + dparams->size);
1100 	if (!dinfo)
1101 		return -ENOMEM;
1102 
1103 	/* Record the basic log buffer information and read in the raw log.
1104 	 */
1105 	dinfo->nentries = (dparams->size / sizeof(struct fw_devlog_e));
1106 	dinfo->first = 0;
1107 	spin_lock(&adap->win0_lock);
1108 	ret = t4_memory_rw(adap, adap->params.drv_memwin, dparams->memtype,
1109 			   dparams->start, dparams->size, (__be32 *)dinfo->log,
1110 			   T4_MEMORY_READ);
1111 	spin_unlock(&adap->win0_lock);
1112 	if (ret) {
1113 		seq_release_private(inode, file);
1114 		return ret;
1115 	}
1116 
1117 	/* Find the earliest (lowest Sequence Number) log entry in the
1118 	 * circular Device Log.
1119 	 */
1120 	for (fseqno = ~((u32)0), index = 0; index < dinfo->nentries; index++) {
1121 		struct fw_devlog_e *e = &dinfo->log[index];
1122 		__u32 seqno;
1123 
1124 		if (e->timestamp == 0)
1125 			continue;
1126 
1127 		seqno = be32_to_cpu(e->seqno);
1128 		if (seqno < fseqno) {
1129 			fseqno = seqno;
1130 			dinfo->first = index;
1131 		}
1132 	}
1133 	return 0;
1134 }
1135 
1136 static const struct file_operations devlog_fops = {
1137 	.owner   = THIS_MODULE,
1138 	.open    = devlog_open,
1139 	.read    = seq_read,
1140 	.llseek  = seq_lseek,
1141 	.release = seq_release_private
1142 };
1143 
1144 /* Show Firmware Mailbox Command/Reply Log
1145  *
1146  * Note that we don't do any locking when dumping the Firmware Mailbox Log so
1147  * it's possible that we can catch things during a log update and therefore
1148  * see partially corrupted log entries.  But it's probably Good Enough(tm).
1149  * If we ever decide that we want to make sure that we're dumping a coherent
1150  * log, we'd need to perform locking in the mailbox logging and in
1151  * mboxlog_open() where we'd need to grab the entire mailbox log in one go
1152  * like we do for the Firmware Device Log.
1153  */
1154 static int mboxlog_show(struct seq_file *seq, void *v)
1155 {
1156 	struct adapter *adapter = seq->private;
1157 	struct mbox_cmd_log *log = adapter->mbox_log;
1158 	struct mbox_cmd *entry;
1159 	int entry_idx, i;
1160 
1161 	if (v == SEQ_START_TOKEN) {
1162 		seq_printf(seq,
1163 			   "%10s  %15s  %5s  %5s  %s\n",
1164 			   "Seq#", "Tstamp", "Atime", "Etime",
1165 			   "Command/Reply");
1166 		return 0;
1167 	}
1168 
1169 	entry_idx = log->cursor + ((uintptr_t)v - 2);
1170 	if (entry_idx >= log->size)
1171 		entry_idx -= log->size;
1172 	entry = mbox_cmd_log_entry(log, entry_idx);
1173 
1174 	/* skip over unused entries */
1175 	if (entry->timestamp == 0)
1176 		return 0;
1177 
1178 	seq_printf(seq, "%10u  %15llu  %5d  %5d",
1179 		   entry->seqno, entry->timestamp,
1180 		   entry->access, entry->execute);
1181 	for (i = 0; i < MBOX_LEN / 8; i++) {
1182 		u64 flit = entry->cmd[i];
1183 		u32 hi = (u32)(flit >> 32);
1184 		u32 lo = (u32)flit;
1185 
1186 		seq_printf(seq, "  %08x %08x", hi, lo);
1187 	}
1188 	seq_puts(seq, "\n");
1189 	return 0;
1190 }
1191 
1192 static inline void *mboxlog_get_idx(struct seq_file *seq, loff_t pos)
1193 {
1194 	struct adapter *adapter = seq->private;
1195 	struct mbox_cmd_log *log = adapter->mbox_log;
1196 
1197 	return ((pos <= log->size) ? (void *)(uintptr_t)(pos + 1) : NULL);
1198 }
1199 
1200 static void *mboxlog_start(struct seq_file *seq, loff_t *pos)
1201 {
1202 	return *pos ? mboxlog_get_idx(seq, *pos) : SEQ_START_TOKEN;
1203 }
1204 
1205 static void *mboxlog_next(struct seq_file *seq, void *v, loff_t *pos)
1206 {
1207 	++*pos;
1208 	return mboxlog_get_idx(seq, *pos);
1209 }
1210 
1211 static void mboxlog_stop(struct seq_file *seq, void *v)
1212 {
1213 }
1214 
1215 static const struct seq_operations mboxlog_seq_ops = {
1216 	.start = mboxlog_start,
1217 	.next  = mboxlog_next,
1218 	.stop  = mboxlog_stop,
1219 	.show  = mboxlog_show
1220 };
1221 
1222 static int mboxlog_open(struct inode *inode, struct file *file)
1223 {
1224 	int res = seq_open(file, &mboxlog_seq_ops);
1225 
1226 	if (!res) {
1227 		struct seq_file *seq = file->private_data;
1228 
1229 		seq->private = inode->i_private;
1230 	}
1231 	return res;
1232 }
1233 
1234 static const struct file_operations mboxlog_fops = {
1235 	.owner   = THIS_MODULE,
1236 	.open    = mboxlog_open,
1237 	.read    = seq_read,
1238 	.llseek  = seq_lseek,
1239 	.release = seq_release,
1240 };
1241 
1242 static int mbox_show(struct seq_file *seq, void *v)
1243 {
1244 	static const char * const owner[] = { "none", "FW", "driver",
1245 					      "unknown", "<unread>" };
1246 
1247 	int i;
1248 	unsigned int mbox = (uintptr_t)seq->private & 7;
1249 	struct adapter *adap = seq->private - mbox;
1250 	void __iomem *addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
1251 
1252 	/* For T4 we don't have a shadow copy of the Mailbox Control register.
1253 	 * And since reading that real register causes a side effect of
1254 	 * granting ownership, we're best of simply not reading it at all.
1255 	 */
1256 	if (is_t4(adap->params.chip)) {
1257 		i = 4; /* index of "<unread>" */
1258 	} else {
1259 		unsigned int ctrl_reg = CIM_PF_MAILBOX_CTRL_SHADOW_COPY_A;
1260 		void __iomem *ctrl = adap->regs + PF_REG(mbox, ctrl_reg);
1261 
1262 		i = MBOWNER_G(readl(ctrl));
1263 	}
1264 
1265 	seq_printf(seq, "mailbox owned by %s\n\n", owner[i]);
1266 
1267 	for (i = 0; i < MBOX_LEN; i += 8)
1268 		seq_printf(seq, "%016llx\n",
1269 			   (unsigned long long)readq(addr + i));
1270 	return 0;
1271 }
1272 
1273 static int mbox_open(struct inode *inode, struct file *file)
1274 {
1275 	return single_open(file, mbox_show, inode->i_private);
1276 }
1277 
1278 static ssize_t mbox_write(struct file *file, const char __user *buf,
1279 			  size_t count, loff_t *pos)
1280 {
1281 	int i;
1282 	char c = '\n', s[256];
1283 	unsigned long long data[8];
1284 	const struct inode *ino;
1285 	unsigned int mbox;
1286 	struct adapter *adap;
1287 	void __iomem *addr;
1288 	void __iomem *ctrl;
1289 
1290 	if (count > sizeof(s) - 1 || !count)
1291 		return -EINVAL;
1292 	if (copy_from_user(s, buf, count))
1293 		return -EFAULT;
1294 	s[count] = '\0';
1295 
1296 	if (sscanf(s, "%llx %llx %llx %llx %llx %llx %llx %llx%c", &data[0],
1297 		   &data[1], &data[2], &data[3], &data[4], &data[5], &data[6],
1298 		   &data[7], &c) < 8 || c != '\n')
1299 		return -EINVAL;
1300 
1301 	ino = file_inode(file);
1302 	mbox = (uintptr_t)ino->i_private & 7;
1303 	adap = ino->i_private - mbox;
1304 	addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
1305 	ctrl = addr + MBOX_LEN;
1306 
1307 	if (MBOWNER_G(readl(ctrl)) != X_MBOWNER_PL)
1308 		return -EBUSY;
1309 
1310 	for (i = 0; i < 8; i++)
1311 		writeq(data[i], addr + 8 * i);
1312 
1313 	writel(MBMSGVALID_F | MBOWNER_V(X_MBOWNER_FW), ctrl);
1314 	return count;
1315 }
1316 
1317 static const struct file_operations mbox_debugfs_fops = {
1318 	.owner   = THIS_MODULE,
1319 	.open    = mbox_open,
1320 	.read    = seq_read,
1321 	.llseek  = seq_lseek,
1322 	.release = single_release,
1323 	.write   = mbox_write
1324 };
1325 
1326 static int mps_trc_show(struct seq_file *seq, void *v)
1327 {
1328 	int enabled, i;
1329 	struct trace_params tp;
1330 	unsigned int trcidx = (uintptr_t)seq->private & 3;
1331 	struct adapter *adap = seq->private - trcidx;
1332 
1333 	t4_get_trace_filter(adap, &tp, trcidx, &enabled);
1334 	if (!enabled) {
1335 		seq_puts(seq, "tracer is disabled\n");
1336 		return 0;
1337 	}
1338 
1339 	if (tp.skip_ofst * 8 >= TRACE_LEN) {
1340 		dev_err(adap->pdev_dev, "illegal trace pattern skip offset\n");
1341 		return -EINVAL;
1342 	}
1343 	if (tp.port < 8) {
1344 		i = adap->chan_map[tp.port & 3];
1345 		if (i >= MAX_NPORTS) {
1346 			dev_err(adap->pdev_dev, "tracer %u is assigned "
1347 				"to non-existing port\n", trcidx);
1348 			return -EINVAL;
1349 		}
1350 		seq_printf(seq, "tracer is capturing %s %s, ",
1351 			   adap->port[i]->name, tp.port < 4 ? "Rx" : "Tx");
1352 	} else
1353 		seq_printf(seq, "tracer is capturing loopback %d, ",
1354 			   tp.port - 8);
1355 	seq_printf(seq, "snap length: %u, min length: %u\n", tp.snap_len,
1356 		   tp.min_len);
1357 	seq_printf(seq, "packets captured %smatch filter\n",
1358 		   tp.invert ? "do not " : "");
1359 
1360 	if (tp.skip_ofst) {
1361 		seq_puts(seq, "filter pattern: ");
1362 		for (i = 0; i < tp.skip_ofst * 2; i += 2)
1363 			seq_printf(seq, "%08x%08x", tp.data[i], tp.data[i + 1]);
1364 		seq_putc(seq, '/');
1365 		for (i = 0; i < tp.skip_ofst * 2; i += 2)
1366 			seq_printf(seq, "%08x%08x", tp.mask[i], tp.mask[i + 1]);
1367 		seq_puts(seq, "@0\n");
1368 	}
1369 
1370 	seq_puts(seq, "filter pattern: ");
1371 	for (i = tp.skip_ofst * 2; i < TRACE_LEN / 4; i += 2)
1372 		seq_printf(seq, "%08x%08x", tp.data[i], tp.data[i + 1]);
1373 	seq_putc(seq, '/');
1374 	for (i = tp.skip_ofst * 2; i < TRACE_LEN / 4; i += 2)
1375 		seq_printf(seq, "%08x%08x", tp.mask[i], tp.mask[i + 1]);
1376 	seq_printf(seq, "@%u\n", (tp.skip_ofst + tp.skip_len) * 8);
1377 	return 0;
1378 }
1379 
1380 static int mps_trc_open(struct inode *inode, struct file *file)
1381 {
1382 	return single_open(file, mps_trc_show, inode->i_private);
1383 }
1384 
1385 static unsigned int xdigit2int(unsigned char c)
1386 {
1387 	return isdigit(c) ? c - '0' : tolower(c) - 'a' + 10;
1388 }
1389 
1390 #define TRC_PORT_NONE 0xff
1391 #define TRC_RSS_ENABLE 0x33
1392 #define TRC_RSS_DISABLE 0x13
1393 
1394 /* Set an MPS trace filter.  Syntax is:
1395  *
1396  * disable
1397  *
1398  * to disable tracing, or
1399  *
1400  * interface qid=<qid no> [snaplen=<val>] [minlen=<val>] [not] [<pattern>]...
1401  *
1402  * where interface is one of rxN, txN, or loopbackN, N = 0..3, qid can be one
1403  * of the NIC's response qid obtained from sge_qinfo and pattern has the form
1404  *
1405  * <pattern data>[/<pattern mask>][@<anchor>]
1406  *
1407  * Up to 2 filter patterns can be specified.  If 2 are supplied the first one
1408  * must be anchored at 0.  An omitted mask is taken as a mask of 1s, an omitted
1409  * anchor is taken as 0.
1410  */
1411 static ssize_t mps_trc_write(struct file *file, const char __user *buf,
1412 			     size_t count, loff_t *pos)
1413 {
1414 	int i, enable, ret;
1415 	u32 *data, *mask;
1416 	struct trace_params tp;
1417 	const struct inode *ino;
1418 	unsigned int trcidx;
1419 	char *s, *p, *word, *end;
1420 	struct adapter *adap;
1421 	u32 j;
1422 
1423 	ino = file_inode(file);
1424 	trcidx = (uintptr_t)ino->i_private & 3;
1425 	adap = ino->i_private - trcidx;
1426 
1427 	/* Don't accept input more than 1K, can't be anything valid except lots
1428 	 * of whitespace.  Well, use less.
1429 	 */
1430 	if (count > 1024)
1431 		return -EFBIG;
1432 	p = s = kzalloc(count + 1, GFP_USER);
1433 	if (!s)
1434 		return -ENOMEM;
1435 	if (copy_from_user(s, buf, count)) {
1436 		count = -EFAULT;
1437 		goto out;
1438 	}
1439 
1440 	if (s[count - 1] == '\n')
1441 		s[count - 1] = '\0';
1442 
1443 	enable = strcmp("disable", s) != 0;
1444 	if (!enable)
1445 		goto apply;
1446 
1447 	/* enable or disable trace multi rss filter */
1448 	if (adap->trace_rss)
1449 		t4_write_reg(adap, MPS_TRC_CFG_A, TRC_RSS_ENABLE);
1450 	else
1451 		t4_write_reg(adap, MPS_TRC_CFG_A, TRC_RSS_DISABLE);
1452 
1453 	memset(&tp, 0, sizeof(tp));
1454 	tp.port = TRC_PORT_NONE;
1455 	i = 0;	/* counts pattern nibbles */
1456 
1457 	while (p) {
1458 		while (isspace(*p))
1459 			p++;
1460 		word = strsep(&p, " ");
1461 		if (!*word)
1462 			break;
1463 
1464 		if (!strncmp(word, "qid=", 4)) {
1465 			end = (char *)word + 4;
1466 			ret = kstrtouint(end, 10, &j);
1467 			if (ret)
1468 				goto out;
1469 			if (!adap->trace_rss) {
1470 				t4_write_reg(adap, MPS_T5_TRC_RSS_CONTROL_A, j);
1471 				continue;
1472 			}
1473 
1474 			switch (trcidx) {
1475 			case 0:
1476 				t4_write_reg(adap, MPS_TRC_RSS_CONTROL_A, j);
1477 				break;
1478 			case 1:
1479 				t4_write_reg(adap,
1480 					     MPS_TRC_FILTER1_RSS_CONTROL_A, j);
1481 				break;
1482 			case 2:
1483 				t4_write_reg(adap,
1484 					     MPS_TRC_FILTER2_RSS_CONTROL_A, j);
1485 				break;
1486 			case 3:
1487 				t4_write_reg(adap,
1488 					     MPS_TRC_FILTER3_RSS_CONTROL_A, j);
1489 				break;
1490 			}
1491 			continue;
1492 		}
1493 		if (!strncmp(word, "snaplen=", 8)) {
1494 			end = (char *)word + 8;
1495 			ret = kstrtouint(end, 10, &j);
1496 			if (ret || j > 9600) {
1497 inval:				count = -EINVAL;
1498 				goto out;
1499 			}
1500 			tp.snap_len = j;
1501 			continue;
1502 		}
1503 		if (!strncmp(word, "minlen=", 7)) {
1504 			end = (char *)word + 7;
1505 			ret = kstrtouint(end, 10, &j);
1506 			if (ret || j > TFMINPKTSIZE_M)
1507 				goto inval;
1508 			tp.min_len = j;
1509 			continue;
1510 		}
1511 		if (!strcmp(word, "not")) {
1512 			tp.invert = !tp.invert;
1513 			continue;
1514 		}
1515 		if (!strncmp(word, "loopback", 8) && tp.port == TRC_PORT_NONE) {
1516 			if (word[8] < '0' || word[8] > '3' || word[9])
1517 				goto inval;
1518 			tp.port = word[8] - '0' + 8;
1519 			continue;
1520 		}
1521 		if (!strncmp(word, "tx", 2) && tp.port == TRC_PORT_NONE) {
1522 			if (word[2] < '0' || word[2] > '3' || word[3])
1523 				goto inval;
1524 			tp.port = word[2] - '0' + 4;
1525 			if (adap->chan_map[tp.port & 3] >= MAX_NPORTS)
1526 				goto inval;
1527 			continue;
1528 		}
1529 		if (!strncmp(word, "rx", 2) && tp.port == TRC_PORT_NONE) {
1530 			if (word[2] < '0' || word[2] > '3' || word[3])
1531 				goto inval;
1532 			tp.port = word[2] - '0';
1533 			if (adap->chan_map[tp.port] >= MAX_NPORTS)
1534 				goto inval;
1535 			continue;
1536 		}
1537 		if (!isxdigit(*word))
1538 			goto inval;
1539 
1540 		/* we have found a trace pattern */
1541 		if (i) {                            /* split pattern */
1542 			if (tp.skip_len)            /* too many splits */
1543 				goto inval;
1544 			tp.skip_ofst = i / 16;
1545 		}
1546 
1547 		data = &tp.data[i / 8];
1548 		mask = &tp.mask[i / 8];
1549 		j = i;
1550 
1551 		while (isxdigit(*word)) {
1552 			if (i >= TRACE_LEN * 2) {
1553 				count = -EFBIG;
1554 				goto out;
1555 			}
1556 			*data = (*data << 4) + xdigit2int(*word++);
1557 			if (++i % 8 == 0)
1558 				data++;
1559 		}
1560 		if (*word == '/') {
1561 			word++;
1562 			while (isxdigit(*word)) {
1563 				if (j >= i)         /* mask longer than data */
1564 					goto inval;
1565 				*mask = (*mask << 4) + xdigit2int(*word++);
1566 				if (++j % 8 == 0)
1567 					mask++;
1568 			}
1569 			if (i != j)                 /* mask shorter than data */
1570 				goto inval;
1571 		} else {                            /* no mask, use all 1s */
1572 			for ( ; i - j >= 8; j += 8)
1573 				*mask++ = 0xffffffff;
1574 			if (i % 8)
1575 				*mask = (1 << (i % 8) * 4) - 1;
1576 		}
1577 		if (*word == '@') {
1578 			end = (char *)word + 1;
1579 			ret = kstrtouint(end, 10, &j);
1580 			if (*end && *end != '\n')
1581 				goto inval;
1582 			if (j & 7)          /* doesn't start at multiple of 8 */
1583 				goto inval;
1584 			j /= 8;
1585 			if (j < tp.skip_ofst)     /* overlaps earlier pattern */
1586 				goto inval;
1587 			if (j - tp.skip_ofst > 31)            /* skip too big */
1588 				goto inval;
1589 			tp.skip_len = j - tp.skip_ofst;
1590 		}
1591 		if (i % 8) {
1592 			*data <<= (8 - i % 8) * 4;
1593 			*mask <<= (8 - i % 8) * 4;
1594 			i = (i + 15) & ~15;         /* 8-byte align */
1595 		}
1596 	}
1597 
1598 	if (tp.port == TRC_PORT_NONE)
1599 		goto inval;
1600 
1601 apply:
1602 	i = t4_set_trace_filter(adap, &tp, trcidx, enable);
1603 	if (i)
1604 		count = i;
1605 out:
1606 	kfree(s);
1607 	return count;
1608 }
1609 
1610 static const struct file_operations mps_trc_debugfs_fops = {
1611 	.owner   = THIS_MODULE,
1612 	.open    = mps_trc_open,
1613 	.read    = seq_read,
1614 	.llseek  = seq_lseek,
1615 	.release = single_release,
1616 	.write   = mps_trc_write
1617 };
1618 
1619 static ssize_t flash_read(struct file *file, char __user *buf, size_t count,
1620 			  loff_t *ppos)
1621 {
1622 	loff_t pos = *ppos;
1623 	loff_t avail = file_inode(file)->i_size;
1624 	struct adapter *adap = file->private_data;
1625 
1626 	if (pos < 0)
1627 		return -EINVAL;
1628 	if (pos >= avail)
1629 		return 0;
1630 	if (count > avail - pos)
1631 		count = avail - pos;
1632 
1633 	while (count) {
1634 		size_t len;
1635 		int ret, ofst;
1636 		u8 data[256];
1637 
1638 		ofst = pos & 3;
1639 		len = min(count + ofst, sizeof(data));
1640 		ret = t4_read_flash(adap, pos - ofst, (len + 3) / 4,
1641 				    (u32 *)data, 1);
1642 		if (ret)
1643 			return ret;
1644 
1645 		len -= ofst;
1646 		if (copy_to_user(buf, data + ofst, len))
1647 			return -EFAULT;
1648 
1649 		buf += len;
1650 		pos += len;
1651 		count -= len;
1652 	}
1653 	count = pos - *ppos;
1654 	*ppos = pos;
1655 	return count;
1656 }
1657 
1658 static const struct file_operations flash_debugfs_fops = {
1659 	.owner   = THIS_MODULE,
1660 	.open    = mem_open,
1661 	.read    = flash_read,
1662 	.llseek  = default_llseek,
1663 };
1664 
1665 static inline void tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask)
1666 {
1667 	*mask = x | y;
1668 	y = (__force u64)cpu_to_be64(y);
1669 	memcpy(addr, (char *)&y + 2, ETH_ALEN);
1670 }
1671 
1672 static int mps_tcam_show(struct seq_file *seq, void *v)
1673 {
1674 	struct adapter *adap = seq->private;
1675 	unsigned int chip_ver = CHELSIO_CHIP_VERSION(adap->params.chip);
1676 	if (v == SEQ_START_TOKEN) {
1677 		if (chip_ver > CHELSIO_T5) {
1678 			seq_puts(seq, "Idx  Ethernet address     Mask     "
1679 				 "  VNI   Mask   IVLAN Vld "
1680 				 "DIP_Hit   Lookup  Port "
1681 				 "Vld Ports PF  VF                           "
1682 				 "Replication                                "
1683 				 "    P0 P1 P2 P3  ML\n");
1684 		} else {
1685 			if (adap->params.arch.mps_rplc_size > 128)
1686 				seq_puts(seq, "Idx  Ethernet address     Mask     "
1687 					 "Vld Ports PF  VF                           "
1688 					 "Replication                                "
1689 					 "    P0 P1 P2 P3  ML\n");
1690 			else
1691 				seq_puts(seq, "Idx  Ethernet address     Mask     "
1692 					 "Vld Ports PF  VF              Replication"
1693 					 "	         P0 P1 P2 P3  ML\n");
1694 		}
1695 	} else {
1696 		u64 mask;
1697 		u8 addr[ETH_ALEN];
1698 		bool replicate, dip_hit = false, vlan_vld = false;
1699 		unsigned int idx = (uintptr_t)v - 2;
1700 		u64 tcamy, tcamx, val;
1701 		u32 cls_lo, cls_hi, ctl, data2, vnix = 0, vniy = 0;
1702 		u32 rplc[8] = {0};
1703 		u8 lookup_type = 0, port_num = 0;
1704 		u16 ivlan = 0;
1705 
1706 		if (chip_ver > CHELSIO_T5) {
1707 			/* CtlCmdType - 0: Read, 1: Write
1708 			 * CtlTcamSel - 0: TCAM0, 1: TCAM1
1709 			 * CtlXYBitSel- 0: Y bit, 1: X bit
1710 			 */
1711 
1712 			/* Read tcamy */
1713 			ctl = CTLCMDTYPE_V(0) | CTLXYBITSEL_V(0);
1714 			if (idx < 256)
1715 				ctl |= CTLTCAMINDEX_V(idx) | CTLTCAMSEL_V(0);
1716 			else
1717 				ctl |= CTLTCAMINDEX_V(idx - 256) |
1718 				       CTLTCAMSEL_V(1);
1719 			t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl);
1720 			val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A);
1721 			tcamy = DMACH_G(val) << 32;
1722 			tcamy |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A);
1723 			data2 = t4_read_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A);
1724 			lookup_type = DATALKPTYPE_G(data2);
1725 			/* 0 - Outer header, 1 - Inner header
1726 			 * [71:48] bit locations are overloaded for
1727 			 * outer vs. inner lookup types.
1728 			 */
1729 			if (lookup_type && (lookup_type != DATALKPTYPE_M)) {
1730 				/* Inner header VNI */
1731 				vniy = (data2 & DATAVIDH2_F) |
1732 				       (DATAVIDH1_G(data2) << 16) | VIDL_G(val);
1733 				dip_hit = data2 & DATADIPHIT_F;
1734 			} else {
1735 				vlan_vld = data2 & DATAVIDH2_F;
1736 				ivlan = VIDL_G(val);
1737 			}
1738 			port_num = DATAPORTNUM_G(data2);
1739 
1740 			/* Read tcamx. Change the control param */
1741 			vnix = 0;
1742 			ctl |= CTLXYBITSEL_V(1);
1743 			t4_write_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A, ctl);
1744 			val = t4_read_reg(adap, MPS_CLS_TCAM_DATA1_A);
1745 			tcamx = DMACH_G(val) << 32;
1746 			tcamx |= t4_read_reg(adap, MPS_CLS_TCAM_DATA0_A);
1747 			data2 = t4_read_reg(adap, MPS_CLS_TCAM_DATA2_CTL_A);
1748 			if (lookup_type && (lookup_type != DATALKPTYPE_M)) {
1749 				/* Inner header VNI mask */
1750 				vnix = (data2 & DATAVIDH2_F) |
1751 				       (DATAVIDH1_G(data2) << 16) | VIDL_G(val);
1752 			}
1753 		} else {
1754 			tcamy = t4_read_reg64(adap, MPS_CLS_TCAM_Y_L(idx));
1755 			tcamx = t4_read_reg64(adap, MPS_CLS_TCAM_X_L(idx));
1756 		}
1757 
1758 		cls_lo = t4_read_reg(adap, MPS_CLS_SRAM_L(idx));
1759 		cls_hi = t4_read_reg(adap, MPS_CLS_SRAM_H(idx));
1760 
1761 		if (tcamx & tcamy) {
1762 			seq_printf(seq, "%3u         -\n", idx);
1763 			goto out;
1764 		}
1765 
1766 		rplc[0] = rplc[1] = rplc[2] = rplc[3] = 0;
1767 		if (chip_ver > CHELSIO_T5)
1768 			replicate = (cls_lo & T6_REPLICATE_F);
1769 		else
1770 			replicate = (cls_lo & REPLICATE_F);
1771 
1772 		if (replicate) {
1773 			struct fw_ldst_cmd ldst_cmd;
1774 			int ret;
1775 			struct fw_ldst_mps_rplc mps_rplc;
1776 			u32 ldst_addrspc;
1777 
1778 			memset(&ldst_cmd, 0, sizeof(ldst_cmd));
1779 			ldst_addrspc =
1780 				FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MPS);
1781 			ldst_cmd.op_to_addrspace =
1782 				htonl(FW_CMD_OP_V(FW_LDST_CMD) |
1783 				      FW_CMD_REQUEST_F |
1784 				      FW_CMD_READ_F |
1785 				      ldst_addrspc);
1786 			ldst_cmd.cycles_to_len16 = htonl(FW_LEN16(ldst_cmd));
1787 			ldst_cmd.u.mps.rplc.fid_idx =
1788 				htons(FW_LDST_CMD_FID_V(FW_LDST_MPS_RPLC) |
1789 				      FW_LDST_CMD_IDX_V(idx));
1790 			ret = t4_wr_mbox(adap, adap->mbox, &ldst_cmd,
1791 					 sizeof(ldst_cmd), &ldst_cmd);
1792 			if (ret)
1793 				dev_warn(adap->pdev_dev, "Can't read MPS "
1794 					 "replication map for idx %d: %d\n",
1795 					 idx, -ret);
1796 			else {
1797 				mps_rplc = ldst_cmd.u.mps.rplc;
1798 				rplc[0] = ntohl(mps_rplc.rplc31_0);
1799 				rplc[1] = ntohl(mps_rplc.rplc63_32);
1800 				rplc[2] = ntohl(mps_rplc.rplc95_64);
1801 				rplc[3] = ntohl(mps_rplc.rplc127_96);
1802 				if (adap->params.arch.mps_rplc_size > 128) {
1803 					rplc[4] = ntohl(mps_rplc.rplc159_128);
1804 					rplc[5] = ntohl(mps_rplc.rplc191_160);
1805 					rplc[6] = ntohl(mps_rplc.rplc223_192);
1806 					rplc[7] = ntohl(mps_rplc.rplc255_224);
1807 				}
1808 			}
1809 		}
1810 
1811 		tcamxy2valmask(tcamx, tcamy, addr, &mask);
1812 		if (chip_ver > CHELSIO_T5) {
1813 			/* Inner header lookup */
1814 			if (lookup_type && (lookup_type != DATALKPTYPE_M)) {
1815 				seq_printf(seq,
1816 					   "%3u %02x:%02x:%02x:%02x:%02x:%02x "
1817 					   "%012llx %06x %06x    -    -   %3c"
1818 					   "      'I'  %4x   "
1819 					   "%3c   %#x%4u%4d", idx, addr[0],
1820 					   addr[1], addr[2], addr[3],
1821 					   addr[4], addr[5],
1822 					   (unsigned long long)mask,
1823 					   vniy, (vnix | vniy),
1824 					   dip_hit ? 'Y' : 'N',
1825 					   port_num,
1826 					   (cls_lo & T6_SRAM_VLD_F) ? 'Y' : 'N',
1827 					   PORTMAP_G(cls_hi),
1828 					   T6_PF_G(cls_lo),
1829 					   (cls_lo & T6_VF_VALID_F) ?
1830 					   T6_VF_G(cls_lo) : -1);
1831 			} else {
1832 				seq_printf(seq,
1833 					   "%3u %02x:%02x:%02x:%02x:%02x:%02x "
1834 					   "%012llx    -       -   ",
1835 					   idx, addr[0], addr[1], addr[2],
1836 					   addr[3], addr[4], addr[5],
1837 					   (unsigned long long)mask);
1838 
1839 				if (vlan_vld)
1840 					seq_printf(seq, "%4u   Y     ", ivlan);
1841 				else
1842 					seq_puts(seq, "  -    N     ");
1843 
1844 				seq_printf(seq,
1845 					   "-      %3c  %4x   %3c   %#x%4u%4d",
1846 					   lookup_type ? 'I' : 'O', port_num,
1847 					   (cls_lo & T6_SRAM_VLD_F) ? 'Y' : 'N',
1848 					   PORTMAP_G(cls_hi),
1849 					   T6_PF_G(cls_lo),
1850 					   (cls_lo & T6_VF_VALID_F) ?
1851 					   T6_VF_G(cls_lo) : -1);
1852 			}
1853 		} else
1854 			seq_printf(seq, "%3u %02x:%02x:%02x:%02x:%02x:%02x "
1855 				   "%012llx%3c   %#x%4u%4d",
1856 				   idx, addr[0], addr[1], addr[2], addr[3],
1857 				   addr[4], addr[5], (unsigned long long)mask,
1858 				   (cls_lo & SRAM_VLD_F) ? 'Y' : 'N',
1859 				   PORTMAP_G(cls_hi),
1860 				   PF_G(cls_lo),
1861 				   (cls_lo & VF_VALID_F) ? VF_G(cls_lo) : -1);
1862 
1863 		if (replicate) {
1864 			if (adap->params.arch.mps_rplc_size > 128)
1865 				seq_printf(seq, " %08x %08x %08x %08x "
1866 					   "%08x %08x %08x %08x",
1867 					   rplc[7], rplc[6], rplc[5], rplc[4],
1868 					   rplc[3], rplc[2], rplc[1], rplc[0]);
1869 			else
1870 				seq_printf(seq, " %08x %08x %08x %08x",
1871 					   rplc[3], rplc[2], rplc[1], rplc[0]);
1872 		} else {
1873 			if (adap->params.arch.mps_rplc_size > 128)
1874 				seq_printf(seq, "%72c", ' ');
1875 			else
1876 				seq_printf(seq, "%36c", ' ');
1877 		}
1878 
1879 		if (chip_ver > CHELSIO_T5)
1880 			seq_printf(seq, "%4u%3u%3u%3u %#x\n",
1881 				   T6_SRAM_PRIO0_G(cls_lo),
1882 				   T6_SRAM_PRIO1_G(cls_lo),
1883 				   T6_SRAM_PRIO2_G(cls_lo),
1884 				   T6_SRAM_PRIO3_G(cls_lo),
1885 				   (cls_lo >> T6_MULTILISTEN0_S) & 0xf);
1886 		else
1887 			seq_printf(seq, "%4u%3u%3u%3u %#x\n",
1888 				   SRAM_PRIO0_G(cls_lo), SRAM_PRIO1_G(cls_lo),
1889 				   SRAM_PRIO2_G(cls_lo), SRAM_PRIO3_G(cls_lo),
1890 				   (cls_lo >> MULTILISTEN0_S) & 0xf);
1891 	}
1892 out:	return 0;
1893 }
1894 
1895 static inline void *mps_tcam_get_idx(struct seq_file *seq, loff_t pos)
1896 {
1897 	struct adapter *adap = seq->private;
1898 	int max_mac_addr = is_t4(adap->params.chip) ?
1899 				NUM_MPS_CLS_SRAM_L_INSTANCES :
1900 				NUM_MPS_T5_CLS_SRAM_L_INSTANCES;
1901 	return ((pos <= max_mac_addr) ? (void *)(uintptr_t)(pos + 1) : NULL);
1902 }
1903 
1904 static void *mps_tcam_start(struct seq_file *seq, loff_t *pos)
1905 {
1906 	return *pos ? mps_tcam_get_idx(seq, *pos) : SEQ_START_TOKEN;
1907 }
1908 
1909 static void *mps_tcam_next(struct seq_file *seq, void *v, loff_t *pos)
1910 {
1911 	++*pos;
1912 	return mps_tcam_get_idx(seq, *pos);
1913 }
1914 
1915 static void mps_tcam_stop(struct seq_file *seq, void *v)
1916 {
1917 }
1918 
1919 static const struct seq_operations mps_tcam_seq_ops = {
1920 	.start = mps_tcam_start,
1921 	.next  = mps_tcam_next,
1922 	.stop  = mps_tcam_stop,
1923 	.show  = mps_tcam_show
1924 };
1925 
1926 static int mps_tcam_open(struct inode *inode, struct file *file)
1927 {
1928 	int res = seq_open(file, &mps_tcam_seq_ops);
1929 
1930 	if (!res) {
1931 		struct seq_file *seq = file->private_data;
1932 
1933 		seq->private = inode->i_private;
1934 	}
1935 	return res;
1936 }
1937 
1938 static const struct file_operations mps_tcam_debugfs_fops = {
1939 	.owner   = THIS_MODULE,
1940 	.open    = mps_tcam_open,
1941 	.read    = seq_read,
1942 	.llseek  = seq_lseek,
1943 	.release = seq_release,
1944 };
1945 
1946 /* Display various sensor information.
1947  */
1948 static int sensors_show(struct seq_file *seq, void *v)
1949 {
1950 	struct adapter *adap = seq->private;
1951 	u32 param[7], val[7];
1952 	int ret;
1953 
1954 	/* Note that if the sensors haven't been initialized and turned on
1955 	 * we'll get values of 0, so treat those as "<unknown>" ...
1956 	 */
1957 	param[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
1958 		    FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) |
1959 		    FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_TMP));
1960 	param[1] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
1961 		    FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DIAG) |
1962 		    FW_PARAMS_PARAM_Y_V(FW_PARAM_DEV_DIAG_VDD));
1963 	ret = t4_query_params(adap, adap->mbox, adap->pf, 0, 2,
1964 			      param, val);
1965 
1966 	if (ret < 0 || val[0] == 0)
1967 		seq_puts(seq, "Temperature: <unknown>\n");
1968 	else
1969 		seq_printf(seq, "Temperature: %dC\n", val[0]);
1970 
1971 	if (ret < 0 || val[1] == 0)
1972 		seq_puts(seq, "Core VDD:    <unknown>\n");
1973 	else
1974 		seq_printf(seq, "Core VDD:    %dmV\n", val[1]);
1975 
1976 	return 0;
1977 }
1978 DEFINE_SHOW_ATTRIBUTE(sensors);
1979 
1980 #if IS_ENABLED(CONFIG_IPV6)
1981 DEFINE_SHOW_ATTRIBUTE(clip_tbl);
1982 #endif
1983 
1984 /*RSS Table.
1985  */
1986 
1987 static int rss_show(struct seq_file *seq, void *v, int idx)
1988 {
1989 	u16 *entry = v;
1990 
1991 	seq_printf(seq, "%4d:  %4u  %4u  %4u  %4u  %4u  %4u  %4u  %4u\n",
1992 		   idx * 8, entry[0], entry[1], entry[2], entry[3], entry[4],
1993 		   entry[5], entry[6], entry[7]);
1994 	return 0;
1995 }
1996 
1997 static int rss_open(struct inode *inode, struct file *file)
1998 {
1999 	struct adapter *adap = inode->i_private;
2000 	int ret, nentries;
2001 	struct seq_tab *p;
2002 
2003 	nentries = t4_chip_rss_size(adap);
2004 	p = seq_open_tab(file, nentries / 8, 8 * sizeof(u16), 0, rss_show);
2005 	if (!p)
2006 		return -ENOMEM;
2007 
2008 	ret = t4_read_rss(adap, (u16 *)p->data);
2009 	if (ret)
2010 		seq_release_private(inode, file);
2011 
2012 	return ret;
2013 }
2014 
2015 static const struct file_operations rss_debugfs_fops = {
2016 	.owner   = THIS_MODULE,
2017 	.open    = rss_open,
2018 	.read    = seq_read,
2019 	.llseek  = seq_lseek,
2020 	.release = seq_release_private
2021 };
2022 
2023 /* RSS Configuration.
2024  */
2025 
2026 /* Small utility function to return the strings "yes" or "no" if the supplied
2027  * argument is non-zero.
2028  */
2029 static const char *yesno(int x)
2030 {
2031 	static const char *yes = "yes";
2032 	static const char *no = "no";
2033 
2034 	return x ? yes : no;
2035 }
2036 
2037 static int rss_config_show(struct seq_file *seq, void *v)
2038 {
2039 	struct adapter *adapter = seq->private;
2040 	static const char * const keymode[] = {
2041 		"global",
2042 		"global and per-VF scramble",
2043 		"per-PF and per-VF scramble",
2044 		"per-VF and per-VF scramble",
2045 	};
2046 	u32 rssconf;
2047 
2048 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_A);
2049 	seq_printf(seq, "TP_RSS_CONFIG: %#x\n", rssconf);
2050 	seq_printf(seq, "  Tnl4TupEnIpv6: %3s\n", yesno(rssconf &
2051 							TNL4TUPENIPV6_F));
2052 	seq_printf(seq, "  Tnl2TupEnIpv6: %3s\n", yesno(rssconf &
2053 							TNL2TUPENIPV6_F));
2054 	seq_printf(seq, "  Tnl4TupEnIpv4: %3s\n", yesno(rssconf &
2055 							TNL4TUPENIPV4_F));
2056 	seq_printf(seq, "  Tnl2TupEnIpv4: %3s\n", yesno(rssconf &
2057 							TNL2TUPENIPV4_F));
2058 	seq_printf(seq, "  TnlTcpSel:     %3s\n", yesno(rssconf & TNLTCPSEL_F));
2059 	seq_printf(seq, "  TnlIp6Sel:     %3s\n", yesno(rssconf & TNLIP6SEL_F));
2060 	seq_printf(seq, "  TnlVrtSel:     %3s\n", yesno(rssconf & TNLVRTSEL_F));
2061 	seq_printf(seq, "  TnlMapEn:      %3s\n", yesno(rssconf & TNLMAPEN_F));
2062 	seq_printf(seq, "  OfdHashSave:   %3s\n", yesno(rssconf &
2063 							OFDHASHSAVE_F));
2064 	seq_printf(seq, "  OfdVrtSel:     %3s\n", yesno(rssconf & OFDVRTSEL_F));
2065 	seq_printf(seq, "  OfdMapEn:      %3s\n", yesno(rssconf & OFDMAPEN_F));
2066 	seq_printf(seq, "  OfdLkpEn:      %3s\n", yesno(rssconf & OFDLKPEN_F));
2067 	seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &
2068 							SYN4TUPENIPV6_F));
2069 	seq_printf(seq, "  Syn2TupEnIpv6: %3s\n", yesno(rssconf &
2070 							SYN2TUPENIPV6_F));
2071 	seq_printf(seq, "  Syn4TupEnIpv4: %3s\n", yesno(rssconf &
2072 							SYN4TUPENIPV4_F));
2073 	seq_printf(seq, "  Syn2TupEnIpv4: %3s\n", yesno(rssconf &
2074 							SYN2TUPENIPV4_F));
2075 	seq_printf(seq, "  Syn4TupEnIpv6: %3s\n", yesno(rssconf &
2076 							SYN4TUPENIPV6_F));
2077 	seq_printf(seq, "  SynIp6Sel:     %3s\n", yesno(rssconf & SYNIP6SEL_F));
2078 	seq_printf(seq, "  SynVrt6Sel:    %3s\n", yesno(rssconf & SYNVRTSEL_F));
2079 	seq_printf(seq, "  SynMapEn:      %3s\n", yesno(rssconf & SYNMAPEN_F));
2080 	seq_printf(seq, "  SynLkpEn:      %3s\n", yesno(rssconf & SYNLKPEN_F));
2081 	seq_printf(seq, "  ChnEn:         %3s\n", yesno(rssconf &
2082 							CHANNELENABLE_F));
2083 	seq_printf(seq, "  PrtEn:         %3s\n", yesno(rssconf &
2084 							PORTENABLE_F));
2085 	seq_printf(seq, "  TnlAllLkp:     %3s\n", yesno(rssconf &
2086 							TNLALLLOOKUP_F));
2087 	seq_printf(seq, "  VrtEn:         %3s\n", yesno(rssconf &
2088 							VIRTENABLE_F));
2089 	seq_printf(seq, "  CngEn:         %3s\n", yesno(rssconf &
2090 							CONGESTIONENABLE_F));
2091 	seq_printf(seq, "  HashToeplitz:  %3s\n", yesno(rssconf &
2092 							HASHTOEPLITZ_F));
2093 	seq_printf(seq, "  Udp4En:        %3s\n", yesno(rssconf & UDPENABLE_F));
2094 	seq_printf(seq, "  Disable:       %3s\n", yesno(rssconf & DISABLE_F));
2095 
2096 	seq_puts(seq, "\n");
2097 
2098 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_TNL_A);
2099 	seq_printf(seq, "TP_RSS_CONFIG_TNL: %#x\n", rssconf);
2100 	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
2101 	seq_printf(seq, "  MaskFilter:    %3d\n", MASKFILTER_G(rssconf));
2102 	if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {
2103 		seq_printf(seq, "  HashAll:     %3s\n",
2104 			   yesno(rssconf & HASHALL_F));
2105 		seq_printf(seq, "  HashEth:     %3s\n",
2106 			   yesno(rssconf & HASHETH_F));
2107 	}
2108 	seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));
2109 
2110 	seq_puts(seq, "\n");
2111 
2112 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_OFD_A);
2113 	seq_printf(seq, "TP_RSS_CONFIG_OFD: %#x\n", rssconf);
2114 	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
2115 	seq_printf(seq, "  RRCplMapEn:    %3s\n", yesno(rssconf &
2116 							RRCPLMAPEN_F));
2117 	seq_printf(seq, "  RRCplQueWidth: %3d\n", RRCPLQUEWIDTH_G(rssconf));
2118 
2119 	seq_puts(seq, "\n");
2120 
2121 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_SYN_A);
2122 	seq_printf(seq, "TP_RSS_CONFIG_SYN: %#x\n", rssconf);
2123 	seq_printf(seq, "  MaskSize:      %3d\n", MASKSIZE_G(rssconf));
2124 	seq_printf(seq, "  UseWireCh:     %3s\n", yesno(rssconf & USEWIRECH_F));
2125 
2126 	seq_puts(seq, "\n");
2127 
2128 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);
2129 	seq_printf(seq, "TP_RSS_CONFIG_VRT: %#x\n", rssconf);
2130 	if (CHELSIO_CHIP_VERSION(adapter->params.chip) > CHELSIO_T5) {
2131 		seq_printf(seq, "  KeyWrAddrX:     %3d\n",
2132 			   KEYWRADDRX_G(rssconf));
2133 		seq_printf(seq, "  KeyExtend:      %3s\n",
2134 			   yesno(rssconf & KEYEXTEND_F));
2135 	}
2136 	seq_printf(seq, "  VfRdRg:        %3s\n", yesno(rssconf & VFRDRG_F));
2137 	seq_printf(seq, "  VfRdEn:        %3s\n", yesno(rssconf & VFRDEN_F));
2138 	seq_printf(seq, "  VfPerrEn:      %3s\n", yesno(rssconf & VFPERREN_F));
2139 	seq_printf(seq, "  KeyPerrEn:     %3s\n", yesno(rssconf & KEYPERREN_F));
2140 	seq_printf(seq, "  DisVfVlan:     %3s\n", yesno(rssconf &
2141 							DISABLEVLAN_F));
2142 	seq_printf(seq, "  EnUpSwt:       %3s\n", yesno(rssconf & ENABLEUP0_F));
2143 	seq_printf(seq, "  HashDelay:     %3d\n", HASHDELAY_G(rssconf));
2144 	if (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5)
2145 		seq_printf(seq, "  VfWrAddr:      %3d\n", VFWRADDR_G(rssconf));
2146 	else
2147 		seq_printf(seq, "  VfWrAddr:      %3d\n",
2148 			   T6_VFWRADDR_G(rssconf));
2149 	seq_printf(seq, "  KeyMode:       %s\n", keymode[KEYMODE_G(rssconf)]);
2150 	seq_printf(seq, "  VfWrEn:        %3s\n", yesno(rssconf & VFWREN_F));
2151 	seq_printf(seq, "  KeyWrEn:       %3s\n", yesno(rssconf & KEYWREN_F));
2152 	seq_printf(seq, "  KeyWrAddr:     %3d\n", KEYWRADDR_G(rssconf));
2153 
2154 	seq_puts(seq, "\n");
2155 
2156 	rssconf = t4_read_reg(adapter, TP_RSS_CONFIG_CNG_A);
2157 	seq_printf(seq, "TP_RSS_CONFIG_CNG: %#x\n", rssconf);
2158 	seq_printf(seq, "  ChnCount3:     %3s\n", yesno(rssconf & CHNCOUNT3_F));
2159 	seq_printf(seq, "  ChnCount2:     %3s\n", yesno(rssconf & CHNCOUNT2_F));
2160 	seq_printf(seq, "  ChnCount1:     %3s\n", yesno(rssconf & CHNCOUNT1_F));
2161 	seq_printf(seq, "  ChnCount0:     %3s\n", yesno(rssconf & CHNCOUNT0_F));
2162 	seq_printf(seq, "  ChnUndFlow3:   %3s\n", yesno(rssconf &
2163 							CHNUNDFLOW3_F));
2164 	seq_printf(seq, "  ChnUndFlow2:   %3s\n", yesno(rssconf &
2165 							CHNUNDFLOW2_F));
2166 	seq_printf(seq, "  ChnUndFlow1:   %3s\n", yesno(rssconf &
2167 							CHNUNDFLOW1_F));
2168 	seq_printf(seq, "  ChnUndFlow0:   %3s\n", yesno(rssconf &
2169 							CHNUNDFLOW0_F));
2170 	seq_printf(seq, "  RstChn3:       %3s\n", yesno(rssconf & RSTCHN3_F));
2171 	seq_printf(seq, "  RstChn2:       %3s\n", yesno(rssconf & RSTCHN2_F));
2172 	seq_printf(seq, "  RstChn1:       %3s\n", yesno(rssconf & RSTCHN1_F));
2173 	seq_printf(seq, "  RstChn0:       %3s\n", yesno(rssconf & RSTCHN0_F));
2174 	seq_printf(seq, "  UpdVld:        %3s\n", yesno(rssconf & UPDVLD_F));
2175 	seq_printf(seq, "  Xoff:          %3s\n", yesno(rssconf & XOFF_F));
2176 	seq_printf(seq, "  UpdChn3:       %3s\n", yesno(rssconf & UPDCHN3_F));
2177 	seq_printf(seq, "  UpdChn2:       %3s\n", yesno(rssconf & UPDCHN2_F));
2178 	seq_printf(seq, "  UpdChn1:       %3s\n", yesno(rssconf & UPDCHN1_F));
2179 	seq_printf(seq, "  UpdChn0:       %3s\n", yesno(rssconf & UPDCHN0_F));
2180 	seq_printf(seq, "  Queue:         %3d\n", QUEUE_G(rssconf));
2181 
2182 	return 0;
2183 }
2184 DEFINE_SHOW_ATTRIBUTE(rss_config);
2185 
2186 /* RSS Secret Key.
2187  */
2188 
2189 static int rss_key_show(struct seq_file *seq, void *v)
2190 {
2191 	u32 key[10];
2192 
2193 	t4_read_rss_key(seq->private, key, true);
2194 	seq_printf(seq, "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
2195 		   key[9], key[8], key[7], key[6], key[5], key[4], key[3],
2196 		   key[2], key[1], key[0]);
2197 	return 0;
2198 }
2199 
2200 static int rss_key_open(struct inode *inode, struct file *file)
2201 {
2202 	return single_open(file, rss_key_show, inode->i_private);
2203 }
2204 
2205 static ssize_t rss_key_write(struct file *file, const char __user *buf,
2206 			     size_t count, loff_t *pos)
2207 {
2208 	int i, j;
2209 	u32 key[10];
2210 	char s[100], *p;
2211 	struct adapter *adap = file_inode(file)->i_private;
2212 
2213 	if (count > sizeof(s) - 1)
2214 		return -EINVAL;
2215 	if (copy_from_user(s, buf, count))
2216 		return -EFAULT;
2217 	for (i = count; i > 0 && isspace(s[i - 1]); i--)
2218 		;
2219 	s[i] = '\0';
2220 
2221 	for (p = s, i = 9; i >= 0; i--) {
2222 		key[i] = 0;
2223 		for (j = 0; j < 8; j++, p++) {
2224 			if (!isxdigit(*p))
2225 				return -EINVAL;
2226 			key[i] = (key[i] << 4) | hex2val(*p);
2227 		}
2228 	}
2229 
2230 	t4_write_rss_key(adap, key, -1, true);
2231 	return count;
2232 }
2233 
2234 static const struct file_operations rss_key_debugfs_fops = {
2235 	.owner   = THIS_MODULE,
2236 	.open    = rss_key_open,
2237 	.read    = seq_read,
2238 	.llseek  = seq_lseek,
2239 	.release = single_release,
2240 	.write   = rss_key_write
2241 };
2242 
2243 /* PF RSS Configuration.
2244  */
2245 
2246 struct rss_pf_conf {
2247 	u32 rss_pf_map;
2248 	u32 rss_pf_mask;
2249 	u32 rss_pf_config;
2250 };
2251 
2252 static int rss_pf_config_show(struct seq_file *seq, void *v, int idx)
2253 {
2254 	struct rss_pf_conf *pfconf;
2255 
2256 	if (v == SEQ_START_TOKEN) {
2257 		/* use the 0th entry to dump the PF Map Index Size */
2258 		pfconf = seq->private + offsetof(struct seq_tab, data);
2259 		seq_printf(seq, "PF Map Index Size = %d\n\n",
2260 			   LKPIDXSIZE_G(pfconf->rss_pf_map));
2261 
2262 		seq_puts(seq, "     RSS              PF   VF    Hash Tuple Enable         Default\n");
2263 		seq_puts(seq, "     Enable       IPF Mask Mask  IPv6      IPv4      UDP   Queue\n");
2264 		seq_puts(seq, " PF  Map Chn Prt  Map Size Size  Four Two  Four Two  Four  Ch1  Ch0\n");
2265 	} else {
2266 		#define G_PFnLKPIDX(map, n) \
2267 			(((map) >> PF1LKPIDX_S*(n)) & PF0LKPIDX_M)
2268 		#define G_PFnMSKSIZE(mask, n) \
2269 			(((mask) >> PF1MSKSIZE_S*(n)) & PF1MSKSIZE_M)
2270 
2271 		pfconf = v;
2272 		seq_printf(seq, "%3d  %3s %3s %3s  %3d  %3d  %3d   %3s %3s   %3s %3s   %3s  %3d  %3d\n",
2273 			   idx,
2274 			   yesno(pfconf->rss_pf_config & MAPENABLE_F),
2275 			   yesno(pfconf->rss_pf_config & CHNENABLE_F),
2276 			   yesno(pfconf->rss_pf_config & PRTENABLE_F),
2277 			   G_PFnLKPIDX(pfconf->rss_pf_map, idx),
2278 			   G_PFnMSKSIZE(pfconf->rss_pf_mask, idx),
2279 			   IVFWIDTH_G(pfconf->rss_pf_config),
2280 			   yesno(pfconf->rss_pf_config & IP6FOURTUPEN_F),
2281 			   yesno(pfconf->rss_pf_config & IP6TWOTUPEN_F),
2282 			   yesno(pfconf->rss_pf_config & IP4FOURTUPEN_F),
2283 			   yesno(pfconf->rss_pf_config & IP4TWOTUPEN_F),
2284 			   yesno(pfconf->rss_pf_config & UDPFOURTUPEN_F),
2285 			   CH1DEFAULTQUEUE_G(pfconf->rss_pf_config),
2286 			   CH0DEFAULTQUEUE_G(pfconf->rss_pf_config));
2287 
2288 		#undef G_PFnLKPIDX
2289 		#undef G_PFnMSKSIZE
2290 	}
2291 	return 0;
2292 }
2293 
2294 static int rss_pf_config_open(struct inode *inode, struct file *file)
2295 {
2296 	struct adapter *adapter = inode->i_private;
2297 	struct seq_tab *p;
2298 	u32 rss_pf_map, rss_pf_mask;
2299 	struct rss_pf_conf *pfconf;
2300 	int pf;
2301 
2302 	p = seq_open_tab(file, 8, sizeof(*pfconf), 1, rss_pf_config_show);
2303 	if (!p)
2304 		return -ENOMEM;
2305 
2306 	pfconf = (struct rss_pf_conf *)p->data;
2307 	rss_pf_map = t4_read_rss_pf_map(adapter, true);
2308 	rss_pf_mask = t4_read_rss_pf_mask(adapter, true);
2309 	for (pf = 0; pf < 8; pf++) {
2310 		pfconf[pf].rss_pf_map = rss_pf_map;
2311 		pfconf[pf].rss_pf_mask = rss_pf_mask;
2312 		t4_read_rss_pf_config(adapter, pf, &pfconf[pf].rss_pf_config,
2313 				      true);
2314 	}
2315 	return 0;
2316 }
2317 
2318 static const struct file_operations rss_pf_config_debugfs_fops = {
2319 	.owner   = THIS_MODULE,
2320 	.open    = rss_pf_config_open,
2321 	.read    = seq_read,
2322 	.llseek  = seq_lseek,
2323 	.release = seq_release_private
2324 };
2325 
2326 /* VF RSS Configuration.
2327  */
2328 
2329 struct rss_vf_conf {
2330 	u32 rss_vf_vfl;
2331 	u32 rss_vf_vfh;
2332 };
2333 
2334 static int rss_vf_config_show(struct seq_file *seq, void *v, int idx)
2335 {
2336 	if (v == SEQ_START_TOKEN) {
2337 		seq_puts(seq, "     RSS                     Hash Tuple Enable\n");
2338 		seq_puts(seq, "     Enable   IVF  Dis  Enb  IPv6      IPv4      UDP    Def  Secret Key\n");
2339 		seq_puts(seq, " VF  Chn Prt  Map  VLAN  uP  Four Two  Four Two  Four   Que  Idx       Hash\n");
2340 	} else {
2341 		struct rss_vf_conf *vfconf = v;
2342 
2343 		seq_printf(seq, "%3d  %3s %3s  %3d   %3s %3s   %3s %3s   %3s  %3s   %3s  %4d  %3d %#10x\n",
2344 			   idx,
2345 			   yesno(vfconf->rss_vf_vfh & VFCHNEN_F),
2346 			   yesno(vfconf->rss_vf_vfh & VFPRTEN_F),
2347 			   VFLKPIDX_G(vfconf->rss_vf_vfh),
2348 			   yesno(vfconf->rss_vf_vfh & VFVLNEX_F),
2349 			   yesno(vfconf->rss_vf_vfh & VFUPEN_F),
2350 			   yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),
2351 			   yesno(vfconf->rss_vf_vfh & VFIP6TWOTUPEN_F),
2352 			   yesno(vfconf->rss_vf_vfh & VFIP4FOURTUPEN_F),
2353 			   yesno(vfconf->rss_vf_vfh & VFIP4TWOTUPEN_F),
2354 			   yesno(vfconf->rss_vf_vfh & ENABLEUDPHASH_F),
2355 			   DEFAULTQUEUE_G(vfconf->rss_vf_vfh),
2356 			   KEYINDEX_G(vfconf->rss_vf_vfh),
2357 			   vfconf->rss_vf_vfl);
2358 	}
2359 	return 0;
2360 }
2361 
2362 static int rss_vf_config_open(struct inode *inode, struct file *file)
2363 {
2364 	struct adapter *adapter = inode->i_private;
2365 	struct seq_tab *p;
2366 	struct rss_vf_conf *vfconf;
2367 	int vf, vfcount = adapter->params.arch.vfcount;
2368 
2369 	p = seq_open_tab(file, vfcount, sizeof(*vfconf), 1, rss_vf_config_show);
2370 	if (!p)
2371 		return -ENOMEM;
2372 
2373 	vfconf = (struct rss_vf_conf *)p->data;
2374 	for (vf = 0; vf < vfcount; vf++) {
2375 		t4_read_rss_vf_config(adapter, vf, &vfconf[vf].rss_vf_vfl,
2376 				      &vfconf[vf].rss_vf_vfh, true);
2377 	}
2378 	return 0;
2379 }
2380 
2381 static const struct file_operations rss_vf_config_debugfs_fops = {
2382 	.owner   = THIS_MODULE,
2383 	.open    = rss_vf_config_open,
2384 	.read    = seq_read,
2385 	.llseek  = seq_lseek,
2386 	.release = seq_release_private
2387 };
2388 
2389 #ifdef CONFIG_CHELSIO_T4_DCB
2390 extern char *dcb_ver_array[];
2391 
2392 /* Data Center Briging information for each port.
2393  */
2394 static int dcb_info_show(struct seq_file *seq, void *v)
2395 {
2396 	struct adapter *adap = seq->private;
2397 
2398 	if (v == SEQ_START_TOKEN) {
2399 		seq_puts(seq, "Data Center Bridging Information\n");
2400 	} else {
2401 		int port = (uintptr_t)v - 2;
2402 		struct net_device *dev = adap->port[port];
2403 		struct port_info *pi = netdev2pinfo(dev);
2404 		struct port_dcb_info *dcb = &pi->dcb;
2405 
2406 		seq_puts(seq, "\n");
2407 		seq_printf(seq, "Port: %d (DCB negotiated: %s)\n",
2408 			   port,
2409 			   cxgb4_dcb_enabled(dev) ? "yes" : "no");
2410 
2411 		if (cxgb4_dcb_enabled(dev))
2412 			seq_printf(seq, "[ DCBx Version %s ]\n",
2413 				   dcb_ver_array[dcb->dcb_version]);
2414 
2415 		if (dcb->msgs) {
2416 			int i;
2417 
2418 			seq_puts(seq, "\n  Index\t\t\t  :\t");
2419 			for (i = 0; i < 8; i++)
2420 				seq_printf(seq, " %3d", i);
2421 			seq_puts(seq, "\n\n");
2422 		}
2423 
2424 		if (dcb->msgs & CXGB4_DCB_FW_PGID) {
2425 			int prio, pgid;
2426 
2427 			seq_puts(seq, "  Priority Group IDs\t  :\t");
2428 			for (prio = 0; prio < 8; prio++) {
2429 				pgid = (dcb->pgid >> 4 * (7 - prio)) & 0xf;
2430 				seq_printf(seq, " %3d", pgid);
2431 			}
2432 			seq_puts(seq, "\n");
2433 		}
2434 
2435 		if (dcb->msgs & CXGB4_DCB_FW_PGRATE) {
2436 			int pg;
2437 
2438 			seq_puts(seq, "  Priority Group BW(%)\t  :\t");
2439 			for (pg = 0; pg < 8; pg++)
2440 				seq_printf(seq, " %3d", dcb->pgrate[pg]);
2441 			seq_puts(seq, "\n");
2442 
2443 			if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
2444 				seq_puts(seq, "  TSA Algorithm\t\t  :\t");
2445 				for (pg = 0; pg < 8; pg++)
2446 					seq_printf(seq, " %3d", dcb->tsa[pg]);
2447 				seq_puts(seq, "\n");
2448 			}
2449 
2450 			seq_printf(seq, "  Max PG Traffic Classes  [%3d  ]\n",
2451 				   dcb->pg_num_tcs_supported);
2452 
2453 			seq_puts(seq, "\n");
2454 		}
2455 
2456 		if (dcb->msgs & CXGB4_DCB_FW_PRIORATE) {
2457 			int prio;
2458 
2459 			seq_puts(seq, "  Priority Rate\t:\t");
2460 			for (prio = 0; prio < 8; prio++)
2461 				seq_printf(seq, " %3d", dcb->priorate[prio]);
2462 			seq_puts(seq, "\n");
2463 		}
2464 
2465 		if (dcb->msgs & CXGB4_DCB_FW_PFC) {
2466 			int prio;
2467 
2468 			seq_puts(seq, "  Priority Flow Control   :\t");
2469 			for (prio = 0; prio < 8; prio++) {
2470 				int pfcen = (dcb->pfcen >> 1 * (7 - prio))
2471 					    & 0x1;
2472 				seq_printf(seq, " %3d", pfcen);
2473 			}
2474 			seq_puts(seq, "\n");
2475 
2476 			seq_printf(seq, "  Max PFC Traffic Classes [%3d  ]\n",
2477 				   dcb->pfc_num_tcs_supported);
2478 
2479 			seq_puts(seq, "\n");
2480 		}
2481 
2482 		if (dcb->msgs & CXGB4_DCB_FW_APP_ID) {
2483 			int app, napps;
2484 
2485 			seq_puts(seq, "  Application Information:\n");
2486 			seq_puts(seq, "  App    Priority    Selection         Protocol\n");
2487 			seq_puts(seq, "  Index  Map         Field             ID\n");
2488 			for (app = 0, napps = 0;
2489 			     app < CXGB4_MAX_DCBX_APP_SUPPORTED; app++) {
2490 				struct app_priority *ap;
2491 				static const char * const sel_names[] = {
2492 					"Ethertype",
2493 					"Socket TCP",
2494 					"Socket UDP",
2495 					"Socket All",
2496 				};
2497 				const char *sel_name;
2498 
2499 				ap = &dcb->app_priority[app];
2500 				/* skip empty slots */
2501 				if (ap->protocolid == 0)
2502 					continue;
2503 				napps++;
2504 
2505 				if (ap->sel_field < ARRAY_SIZE(sel_names))
2506 					sel_name = sel_names[ap->sel_field];
2507 				else
2508 					sel_name = "UNKNOWN";
2509 
2510 				seq_printf(seq, "  %3d    %#04x        %-10s (%d)    %#06x (%d)\n",
2511 					   app,
2512 					   ap->user_prio_map,
2513 					   sel_name, ap->sel_field,
2514 					   ap->protocolid, ap->protocolid);
2515 			}
2516 			if (napps == 0)
2517 				seq_puts(seq, "    --- None ---\n");
2518 		}
2519 	}
2520 	return 0;
2521 }
2522 
2523 static inline void *dcb_info_get_idx(struct adapter *adap, loff_t pos)
2524 {
2525 	return (pos <= adap->params.nports
2526 		? (void *)((uintptr_t)pos + 1)
2527 		: NULL);
2528 }
2529 
2530 static void *dcb_info_start(struct seq_file *seq, loff_t *pos)
2531 {
2532 	struct adapter *adap = seq->private;
2533 
2534 	return (*pos
2535 		? dcb_info_get_idx(adap, *pos)
2536 		: SEQ_START_TOKEN);
2537 }
2538 
2539 static void dcb_info_stop(struct seq_file *seq, void *v)
2540 {
2541 }
2542 
2543 static void *dcb_info_next(struct seq_file *seq, void *v, loff_t *pos)
2544 {
2545 	struct adapter *adap = seq->private;
2546 
2547 	(*pos)++;
2548 	return dcb_info_get_idx(adap, *pos);
2549 }
2550 
2551 static const struct seq_operations dcb_info_seq_ops = {
2552 	.start = dcb_info_start,
2553 	.next  = dcb_info_next,
2554 	.stop  = dcb_info_stop,
2555 	.show  = dcb_info_show
2556 };
2557 
2558 static int dcb_info_open(struct inode *inode, struct file *file)
2559 {
2560 	int res = seq_open(file, &dcb_info_seq_ops);
2561 
2562 	if (!res) {
2563 		struct seq_file *seq = file->private_data;
2564 
2565 		seq->private = inode->i_private;
2566 	}
2567 	return res;
2568 }
2569 
2570 static const struct file_operations dcb_info_debugfs_fops = {
2571 	.owner   = THIS_MODULE,
2572 	.open    = dcb_info_open,
2573 	.read    = seq_read,
2574 	.llseek  = seq_lseek,
2575 	.release = seq_release,
2576 };
2577 #endif /* CONFIG_CHELSIO_T4_DCB */
2578 
2579 static int resources_show(struct seq_file *seq, void *v)
2580 {
2581 	struct adapter *adapter = seq->private;
2582 	struct pf_resources *pfres = &adapter->params.pfres;
2583 
2584 	#define S(desc, fmt, var) \
2585 		seq_printf(seq, "%-60s " fmt "\n", \
2586 			   desc " (" #var "):", pfres->var)
2587 
2588 	S("Virtual Interfaces", "%d", nvi);
2589 	S("Egress Queues", "%d", neq);
2590 	S("Ethernet Control", "%d", nethctrl);
2591 	S("Ingress Queues/w Free Lists/Interrupts", "%d", niqflint);
2592 	S("Ingress Queues", "%d", niq);
2593 	S("Traffic Class", "%d", tc);
2594 	S("Port Access Rights Mask", "%#x", pmask);
2595 	S("MAC Address Filters", "%d", nexactf);
2596 	S("Firmware Command Read Capabilities", "%#x", r_caps);
2597 	S("Firmware Command Write/Execute Capabilities", "%#x", wx_caps);
2598 
2599 	#undef S
2600 
2601 	return 0;
2602 }
2603 DEFINE_SHOW_ATTRIBUTE(resources);
2604 
2605 /**
2606  * ethqset2pinfo - return port_info of an Ethernet Queue Set
2607  * @adap: the adapter
2608  * @qset: Ethernet Queue Set
2609  */
2610 static inline struct port_info *ethqset2pinfo(struct adapter *adap, int qset)
2611 {
2612 	int pidx;
2613 
2614 	for_each_port(adap, pidx) {
2615 		struct port_info *pi = adap2pinfo(adap, pidx);
2616 
2617 		if (qset >= pi->first_qset &&
2618 		    qset < pi->first_qset + pi->nqsets)
2619 			return pi;
2620 	}
2621 
2622 	/* should never happen! */
2623 	BUG();
2624 	return NULL;
2625 }
2626 
2627 static int sge_qinfo_uld_txq_entries(const struct adapter *adap, int uld)
2628 {
2629 	const struct sge_uld_txq_info *utxq_info = adap->sge.uld_txq_info[uld];
2630 
2631 	if (!utxq_info)
2632 		return 0;
2633 
2634 	return DIV_ROUND_UP(utxq_info->ntxq, 4);
2635 }
2636 
2637 static int sge_qinfo_uld_rspq_entries(const struct adapter *adap, int uld,
2638 				      bool ciq)
2639 {
2640 	const struct sge_uld_rxq_info *urxq_info = adap->sge.uld_rxq_info[uld];
2641 
2642 	if (!urxq_info)
2643 		return 0;
2644 
2645 	return ciq ? DIV_ROUND_UP(urxq_info->nciq, 4) :
2646 		     DIV_ROUND_UP(urxq_info->nrxq, 4);
2647 }
2648 
2649 static int sge_qinfo_uld_rxq_entries(const struct adapter *adap, int uld)
2650 {
2651 	return sge_qinfo_uld_rspq_entries(adap, uld, false);
2652 }
2653 
2654 static int sge_qinfo_uld_ciq_entries(const struct adapter *adap, int uld)
2655 {
2656 	return sge_qinfo_uld_rspq_entries(adap, uld, true);
2657 }
2658 
2659 static int sge_qinfo_show(struct seq_file *seq, void *v)
2660 {
2661 	int uld_rxq_entries[CXGB4_ULD_MAX] = { 0 };
2662 	int uld_ciq_entries[CXGB4_ULD_MAX] = { 0 };
2663 	int uld_txq_entries[CXGB4_TX_MAX] = { 0 };
2664 	const struct sge_uld_txq_info *utxq_info;
2665 	const struct sge_uld_rxq_info *urxq_info;
2666 	struct adapter *adap = seq->private;
2667 	int i, n, r = (uintptr_t)v - 1;
2668 	int eth_entries, ctrl_entries;
2669 	struct sge *s = &adap->sge;
2670 
2671 	eth_entries = DIV_ROUND_UP(adap->sge.ethqsets, 4);
2672 	ctrl_entries = DIV_ROUND_UP(MAX_CTRL_QUEUES, 4);
2673 
2674 	mutex_lock(&uld_mutex);
2675 	if (s->uld_txq_info)
2676 		for (i = 0; i < ARRAY_SIZE(uld_txq_entries); i++)
2677 			uld_txq_entries[i] = sge_qinfo_uld_txq_entries(adap, i);
2678 
2679 	if (s->uld_rxq_info) {
2680 		for (i = 0; i < ARRAY_SIZE(uld_rxq_entries); i++) {
2681 			uld_rxq_entries[i] = sge_qinfo_uld_rxq_entries(adap, i);
2682 			uld_ciq_entries[i] = sge_qinfo_uld_ciq_entries(adap, i);
2683 		}
2684 	}
2685 
2686 	if (r)
2687 		seq_putc(seq, '\n');
2688 
2689 #define S3(fmt_spec, s, v) \
2690 do { \
2691 	seq_printf(seq, "%-12s", s); \
2692 	for (i = 0; i < n; ++i) \
2693 		seq_printf(seq, " %16" fmt_spec, v); \
2694 		seq_putc(seq, '\n'); \
2695 } while (0)
2696 #define S(s, v) S3("s", s, v)
2697 #define T3(fmt_spec, s, v) S3(fmt_spec, s, tx[i].v)
2698 #define T(s, v) S3("u", s, tx[i].v)
2699 #define TL(s, v) T3("lu", s, v)
2700 #define R3(fmt_spec, s, v) S3(fmt_spec, s, rx[i].v)
2701 #define R(s, v) S3("u", s, rx[i].v)
2702 #define RL(s, v) R3("lu", s, v)
2703 
2704 	if (r < eth_entries) {
2705 		int base_qset = r * 4;
2706 		const struct sge_eth_rxq *rx = &s->ethrxq[base_qset];
2707 		const struct sge_eth_txq *tx = &s->ethtxq[base_qset];
2708 
2709 		n = min(4, s->ethqsets - 4 * r);
2710 
2711 		S("QType:", "Ethernet");
2712 		S("Interface:",
2713 		  rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A");
2714 		T("TxQ ID:", q.cntxt_id);
2715 		T("TxQ size:", q.size);
2716 		T("TxQ inuse:", q.in_use);
2717 		T("TxQ CIDX:", q.cidx);
2718 		T("TxQ PIDX:", q.pidx);
2719 #ifdef CONFIG_CHELSIO_T4_DCB
2720 		T("DCB Prio:", dcb_prio);
2721 		S3("u", "DCB PGID:",
2722 		   (ethqset2pinfo(adap, base_qset + i)->dcb.pgid >>
2723 		    4*(7-tx[i].dcb_prio)) & 0xf);
2724 		S3("u", "DCB PFC:",
2725 		   (ethqset2pinfo(adap, base_qset + i)->dcb.pfcen >>
2726 		    1*(7-tx[i].dcb_prio)) & 0x1);
2727 #endif
2728 		R("RspQ ID:", rspq.abs_id);
2729 		R("RspQ size:", rspq.size);
2730 		R("RspQE size:", rspq.iqe_len);
2731 		R("RspQ CIDX:", rspq.cidx);
2732 		R("RspQ Gen:", rspq.gen);
2733 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2734 		S3("u", "Intr pktcnt:", s->counter_val[rx[i].rspq.pktcnt_idx]);
2735 		R("FL ID:", fl.cntxt_id);
2736 		R("FL size:", fl.size - 8);
2737 		R("FL pend:", fl.pend_cred);
2738 		R("FL avail:", fl.avail);
2739 		R("FL PIDX:", fl.pidx);
2740 		R("FL CIDX:", fl.cidx);
2741 		RL("RxPackets:", stats.pkts);
2742 		RL("RxCSO:", stats.rx_cso);
2743 		RL("VLANxtract:", stats.vlan_ex);
2744 		RL("LROmerged:", stats.lro_merged);
2745 		RL("LROpackets:", stats.lro_pkts);
2746 		RL("RxDrops:", stats.rx_drops);
2747 		RL("RxBadPkts:", stats.bad_rx_pkts);
2748 		TL("TSO:", tso);
2749 		TL("TxCSO:", tx_cso);
2750 		TL("VLANins:", vlan_ins);
2751 		TL("TxQFull:", q.stops);
2752 		TL("TxQRestarts:", q.restarts);
2753 		TL("TxMapErr:", mapping_err);
2754 		RL("FLAllocErr:", fl.alloc_failed);
2755 		RL("FLLrgAlcErr:", fl.large_alloc_failed);
2756 		RL("FLMapErr:", fl.mapping_err);
2757 		RL("FLLow:", fl.low);
2758 		RL("FLStarving:", fl.starving);
2759 
2760 		goto unlock;
2761 	}
2762 
2763 	r -= eth_entries;
2764 	if (r < uld_txq_entries[CXGB4_TX_OFLD]) {
2765 		const struct sge_uld_txq *tx;
2766 
2767 		utxq_info = s->uld_txq_info[CXGB4_TX_OFLD];
2768 		tx = &utxq_info->uldtxq[r * 4];
2769 		n = min(4, utxq_info->ntxq - 4 * r);
2770 
2771 		S("QType:", "OFLD-TXQ");
2772 		T("TxQ ID:", q.cntxt_id);
2773 		T("TxQ size:", q.size);
2774 		T("TxQ inuse:", q.in_use);
2775 		T("TxQ CIDX:", q.cidx);
2776 		T("TxQ PIDX:", q.pidx);
2777 
2778 		goto unlock;
2779 	}
2780 
2781 	r -= uld_txq_entries[CXGB4_TX_OFLD];
2782 	if (r < uld_rxq_entries[CXGB4_ULD_RDMA]) {
2783 		const struct sge_ofld_rxq *rx;
2784 
2785 		urxq_info = s->uld_rxq_info[CXGB4_ULD_RDMA];
2786 		rx = &urxq_info->uldrxq[r * 4];
2787 		n = min(4, urxq_info->nrxq - 4 * r);
2788 
2789 		S("QType:", "RDMA-CPL");
2790 		S("Interface:",
2791 		  rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A");
2792 		R("RspQ ID:", rspq.abs_id);
2793 		R("RspQ size:", rspq.size);
2794 		R("RspQE size:", rspq.iqe_len);
2795 		R("RspQ CIDX:", rspq.cidx);
2796 		R("RspQ Gen:", rspq.gen);
2797 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2798 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2799 		R("FL ID:", fl.cntxt_id);
2800 		R("FL size:", fl.size - 8);
2801 		R("FL pend:", fl.pend_cred);
2802 		R("FL avail:", fl.avail);
2803 		R("FL PIDX:", fl.pidx);
2804 		R("FL CIDX:", fl.cidx);
2805 
2806 		goto unlock;
2807 	}
2808 
2809 	r -= uld_rxq_entries[CXGB4_ULD_RDMA];
2810 	if (r < uld_ciq_entries[CXGB4_ULD_RDMA]) {
2811 		const struct sge_ofld_rxq *rx;
2812 		int ciq_idx = 0;
2813 
2814 		urxq_info = s->uld_rxq_info[CXGB4_ULD_RDMA];
2815 		ciq_idx = urxq_info->nrxq + (r * 4);
2816 		rx = &urxq_info->uldrxq[ciq_idx];
2817 		n = min(4, urxq_info->nciq - 4 * r);
2818 
2819 		S("QType:", "RDMA-CIQ");
2820 		S("Interface:",
2821 		  rx[i].rspq.netdev ? rx[i].rspq.netdev->name : "N/A");
2822 		R("RspQ ID:", rspq.abs_id);
2823 		R("RspQ size:", rspq.size);
2824 		R("RspQE size:", rspq.iqe_len);
2825 		R("RspQ CIDX:", rspq.cidx);
2826 		R("RspQ Gen:", rspq.gen);
2827 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2828 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2829 
2830 		goto unlock;
2831 	}
2832 
2833 	r -= uld_ciq_entries[CXGB4_ULD_RDMA];
2834 	if (r < uld_rxq_entries[CXGB4_ULD_ISCSI]) {
2835 		const struct sge_ofld_rxq *rx;
2836 
2837 		urxq_info = s->uld_rxq_info[CXGB4_ULD_ISCSI];
2838 		rx = &urxq_info->uldrxq[r * 4];
2839 		n = min(4, urxq_info->nrxq - 4 * r);
2840 
2841 		S("QType:", "iSCSI");
2842 		R("RspQ ID:", rspq.abs_id);
2843 		R("RspQ size:", rspq.size);
2844 		R("RspQE size:", rspq.iqe_len);
2845 		R("RspQ CIDX:", rspq.cidx);
2846 		R("RspQ Gen:", rspq.gen);
2847 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2848 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2849 		R("FL ID:", fl.cntxt_id);
2850 		R("FL size:", fl.size - 8);
2851 		R("FL pend:", fl.pend_cred);
2852 		R("FL avail:", fl.avail);
2853 		R("FL PIDX:", fl.pidx);
2854 		R("FL CIDX:", fl.cidx);
2855 
2856 		goto unlock;
2857 	}
2858 
2859 	r -= uld_rxq_entries[CXGB4_ULD_ISCSI];
2860 	if (r < uld_rxq_entries[CXGB4_ULD_ISCSIT]) {
2861 		const struct sge_ofld_rxq *rx;
2862 
2863 		urxq_info = s->uld_rxq_info[CXGB4_ULD_ISCSIT];
2864 		rx = &urxq_info->uldrxq[r * 4];
2865 		n = min(4, urxq_info->nrxq - 4 * r);
2866 
2867 		S("QType:", "iSCSIT");
2868 		R("RspQ ID:", rspq.abs_id);
2869 		R("RspQ size:", rspq.size);
2870 		R("RspQE size:", rspq.iqe_len);
2871 		R("RspQ CIDX:", rspq.cidx);
2872 		R("RspQ Gen:", rspq.gen);
2873 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2874 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2875 		R("FL ID:", fl.cntxt_id);
2876 		R("FL size:", fl.size - 8);
2877 		R("FL pend:", fl.pend_cred);
2878 		R("FL avail:", fl.avail);
2879 		R("FL PIDX:", fl.pidx);
2880 		R("FL CIDX:", fl.cidx);
2881 
2882 		goto unlock;
2883 	}
2884 
2885 	r -= uld_rxq_entries[CXGB4_ULD_ISCSIT];
2886 	if (r < uld_rxq_entries[CXGB4_ULD_TLS]) {
2887 		const struct sge_ofld_rxq *rx;
2888 
2889 		urxq_info = s->uld_rxq_info[CXGB4_ULD_TLS];
2890 		rx = &urxq_info->uldrxq[r * 4];
2891 		n = min(4, urxq_info->nrxq - 4 * r);
2892 
2893 		S("QType:", "TLS");
2894 		R("RspQ ID:", rspq.abs_id);
2895 		R("RspQ size:", rspq.size);
2896 		R("RspQE size:", rspq.iqe_len);
2897 		R("RspQ CIDX:", rspq.cidx);
2898 		R("RspQ Gen:", rspq.gen);
2899 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2900 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2901 		R("FL ID:", fl.cntxt_id);
2902 		R("FL size:", fl.size - 8);
2903 		R("FL pend:", fl.pend_cred);
2904 		R("FL avail:", fl.avail);
2905 		R("FL PIDX:", fl.pidx);
2906 		R("FL CIDX:", fl.cidx);
2907 
2908 		goto unlock;
2909 	}
2910 
2911 	r -= uld_rxq_entries[CXGB4_ULD_TLS];
2912 	if (r < uld_txq_entries[CXGB4_TX_CRYPTO]) {
2913 		const struct sge_ofld_rxq *rx;
2914 		const struct sge_uld_txq *tx;
2915 
2916 		utxq_info = s->uld_txq_info[CXGB4_TX_CRYPTO];
2917 		urxq_info = s->uld_rxq_info[CXGB4_ULD_CRYPTO];
2918 		tx = &utxq_info->uldtxq[r * 4];
2919 		rx = &urxq_info->uldrxq[r * 4];
2920 		n = min(4, utxq_info->ntxq - 4 * r);
2921 
2922 		S("QType:", "Crypto");
2923 		T("TxQ ID:", q.cntxt_id);
2924 		T("TxQ size:", q.size);
2925 		T("TxQ inuse:", q.in_use);
2926 		T("TxQ CIDX:", q.cidx);
2927 		T("TxQ PIDX:", q.pidx);
2928 		R("RspQ ID:", rspq.abs_id);
2929 		R("RspQ size:", rspq.size);
2930 		R("RspQE size:", rspq.iqe_len);
2931 		R("RspQ CIDX:", rspq.cidx);
2932 		R("RspQ Gen:", rspq.gen);
2933 		S3("u", "Intr delay:", qtimer_val(adap, &rx[i].rspq));
2934 		S3("u", "Intr pktcnt:",	s->counter_val[rx[i].rspq.pktcnt_idx]);
2935 		R("FL ID:", fl.cntxt_id);
2936 		R("FL size:", fl.size - 8);
2937 		R("FL pend:", fl.pend_cred);
2938 		R("FL avail:", fl.avail);
2939 		R("FL PIDX:", fl.pidx);
2940 		R("FL CIDX:", fl.cidx);
2941 
2942 		goto unlock;
2943 	}
2944 
2945 	r -= uld_txq_entries[CXGB4_TX_CRYPTO];
2946 	if (r < ctrl_entries) {
2947 		const struct sge_ctrl_txq *tx = &s->ctrlq[r * 4];
2948 
2949 		n = min(4, adap->params.nports - 4 * r);
2950 
2951 		S("QType:", "Control");
2952 		T("TxQ ID:", q.cntxt_id);
2953 		T("TxQ size:", q.size);
2954 		T("TxQ inuse:", q.in_use);
2955 		T("TxQ CIDX:", q.cidx);
2956 		T("TxQ PIDX:", q.pidx);
2957 		TL("TxQFull:", q.stops);
2958 		TL("TxQRestarts:", q.restarts);
2959 
2960 		goto unlock;
2961 	}
2962 
2963 	r -= ctrl_entries;
2964 	if (r < 1) {
2965 		const struct sge_rspq *evtq = &s->fw_evtq;
2966 
2967 		seq_printf(seq, "%-12s %16s\n", "QType:", "FW event queue");
2968 		seq_printf(seq, "%-12s %16u\n", "RspQ ID:", evtq->abs_id);
2969 		seq_printf(seq, "%-12s %16u\n", "RspQ size:", evtq->size);
2970 		seq_printf(seq, "%-12s %16u\n", "RspQE size:", evtq->iqe_len);
2971 		seq_printf(seq, "%-12s %16u\n", "RspQ CIDX:", evtq->cidx);
2972 		seq_printf(seq, "%-12s %16u\n", "RspQ Gen:", evtq->gen);
2973 		seq_printf(seq, "%-12s %16u\n", "Intr delay:",
2974 			   qtimer_val(adap, evtq));
2975 		seq_printf(seq, "%-12s %16u\n", "Intr pktcnt:",
2976 			   s->counter_val[evtq->pktcnt_idx]);
2977 
2978 		goto unlock;
2979 	}
2980 
2981 unlock:
2982 	mutex_unlock(&uld_mutex);
2983 #undef R
2984 #undef RL
2985 #undef T
2986 #undef TL
2987 #undef S
2988 #undef R3
2989 #undef T3
2990 #undef S3
2991 	return 0;
2992 }
2993 
2994 static int sge_queue_entries(const struct adapter *adap)
2995 {
2996 	int tot_uld_entries = 0;
2997 	int i;
2998 
2999 	mutex_lock(&uld_mutex);
3000 	for (i = 0; i < CXGB4_TX_MAX; i++)
3001 		tot_uld_entries += sge_qinfo_uld_txq_entries(adap, i);
3002 
3003 	for (i = 0; i < CXGB4_ULD_MAX; i++) {
3004 		tot_uld_entries += sge_qinfo_uld_rxq_entries(adap, i);
3005 		tot_uld_entries += sge_qinfo_uld_ciq_entries(adap, i);
3006 	}
3007 	mutex_unlock(&uld_mutex);
3008 
3009 	return DIV_ROUND_UP(adap->sge.ethqsets, 4) +
3010 	       tot_uld_entries +
3011 	       DIV_ROUND_UP(MAX_CTRL_QUEUES, 4) + 1;
3012 }
3013 
3014 static void *sge_queue_start(struct seq_file *seq, loff_t *pos)
3015 {
3016 	int entries = sge_queue_entries(seq->private);
3017 
3018 	return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
3019 }
3020 
3021 static void sge_queue_stop(struct seq_file *seq, void *v)
3022 {
3023 }
3024 
3025 static void *sge_queue_next(struct seq_file *seq, void *v, loff_t *pos)
3026 {
3027 	int entries = sge_queue_entries(seq->private);
3028 
3029 	++*pos;
3030 	return *pos < entries ? (void *)((uintptr_t)*pos + 1) : NULL;
3031 }
3032 
3033 static const struct seq_operations sge_qinfo_seq_ops = {
3034 	.start = sge_queue_start,
3035 	.next  = sge_queue_next,
3036 	.stop  = sge_queue_stop,
3037 	.show  = sge_qinfo_show
3038 };
3039 
3040 static int sge_qinfo_open(struct inode *inode, struct file *file)
3041 {
3042 	int res = seq_open(file, &sge_qinfo_seq_ops);
3043 
3044 	if (!res) {
3045 		struct seq_file *seq = file->private_data;
3046 
3047 		seq->private = inode->i_private;
3048 	}
3049 	return res;
3050 }
3051 
3052 static const struct file_operations sge_qinfo_debugfs_fops = {
3053 	.owner   = THIS_MODULE,
3054 	.open    = sge_qinfo_open,
3055 	.read    = seq_read,
3056 	.llseek  = seq_lseek,
3057 	.release = seq_release,
3058 };
3059 
3060 int mem_open(struct inode *inode, struct file *file)
3061 {
3062 	unsigned int mem;
3063 	struct adapter *adap;
3064 
3065 	file->private_data = inode->i_private;
3066 
3067 	mem = (uintptr_t)file->private_data & 0x7;
3068 	adap = file->private_data - mem;
3069 
3070 	(void)t4_fwcache(adap, FW_PARAM_DEV_FWCACHE_FLUSH);
3071 
3072 	return 0;
3073 }
3074 
3075 static ssize_t mem_read(struct file *file, char __user *buf, size_t count,
3076 			loff_t *ppos)
3077 {
3078 	loff_t pos = *ppos;
3079 	loff_t avail = file_inode(file)->i_size;
3080 	unsigned int mem = (uintptr_t)file->private_data & 0x7;
3081 	struct adapter *adap = file->private_data - mem;
3082 	__be32 *data;
3083 	int ret;
3084 
3085 	if (pos < 0)
3086 		return -EINVAL;
3087 	if (pos >= avail)
3088 		return 0;
3089 	if (count > avail - pos)
3090 		count = avail - pos;
3091 
3092 	data = kvzalloc(count, GFP_KERNEL);
3093 	if (!data)
3094 		return -ENOMEM;
3095 
3096 	spin_lock(&adap->win0_lock);
3097 	ret = t4_memory_rw(adap, 0, mem, pos, count, data, T4_MEMORY_READ);
3098 	spin_unlock(&adap->win0_lock);
3099 	if (ret) {
3100 		kvfree(data);
3101 		return ret;
3102 	}
3103 	ret = copy_to_user(buf, data, count);
3104 
3105 	kvfree(data);
3106 	if (ret)
3107 		return -EFAULT;
3108 
3109 	*ppos = pos + count;
3110 	return count;
3111 }
3112 static const struct file_operations mem_debugfs_fops = {
3113 	.owner   = THIS_MODULE,
3114 	.open    = simple_open,
3115 	.read    = mem_read,
3116 	.llseek  = default_llseek,
3117 };
3118 
3119 static int tid_info_show(struct seq_file *seq, void *v)
3120 {
3121 	unsigned int tid_start = 0;
3122 	struct adapter *adap = seq->private;
3123 	const struct tid_info *t = &adap->tids;
3124 	enum chip_type chip = CHELSIO_CHIP_VERSION(adap->params.chip);
3125 
3126 	if (chip > CHELSIO_T5)
3127 		tid_start = t4_read_reg(adap, LE_DB_ACTIVE_TABLE_START_INDEX_A);
3128 
3129 	if (t4_read_reg(adap, LE_DB_CONFIG_A) & HASHEN_F) {
3130 		unsigned int sb;
3131 		seq_printf(seq, "Connections in use: %u\n",
3132 			   atomic_read(&t->conns_in_use));
3133 
3134 		if (chip <= CHELSIO_T5)
3135 			sb = t4_read_reg(adap, LE_DB_SERVER_INDEX_A) / 4;
3136 		else
3137 			sb = t4_read_reg(adap, LE_DB_SRVR_START_INDEX_A);
3138 
3139 		if (sb) {
3140 			seq_printf(seq, "TID range: %u..%u/%u..%u", tid_start,
3141 				   sb - 1, adap->tids.hash_base,
3142 				   t->ntids - 1);
3143 			seq_printf(seq, ", in use: %u/%u\n",
3144 				   atomic_read(&t->tids_in_use),
3145 				   atomic_read(&t->hash_tids_in_use));
3146 		} else if (adap->flags & CXGB4_FW_OFLD_CONN) {
3147 			seq_printf(seq, "TID range: %u..%u/%u..%u",
3148 				   t->aftid_base,
3149 				   t->aftid_end,
3150 				   adap->tids.hash_base,
3151 				   t->ntids - 1);
3152 			seq_printf(seq, ", in use: %u/%u\n",
3153 				   atomic_read(&t->tids_in_use),
3154 				   atomic_read(&t->hash_tids_in_use));
3155 		} else {
3156 			seq_printf(seq, "TID range: %u..%u",
3157 				   adap->tids.hash_base,
3158 				   t->ntids - 1);
3159 			seq_printf(seq, ", in use: %u\n",
3160 				   atomic_read(&t->hash_tids_in_use));
3161 		}
3162 	} else if (t->ntids) {
3163 		seq_printf(seq, "Connections in use: %u\n",
3164 			   atomic_read(&t->conns_in_use));
3165 
3166 		seq_printf(seq, "TID range: %u..%u", tid_start,
3167 			   tid_start + t->ntids - 1);
3168 		seq_printf(seq, ", in use: %u\n",
3169 			   atomic_read(&t->tids_in_use));
3170 	}
3171 
3172 	if (t->nstids)
3173 		seq_printf(seq, "STID range: %u..%u, in use-IPv4/IPv6: %u/%u\n",
3174 			   (!t->stid_base &&
3175 			   (chip <= CHELSIO_T5)) ?
3176 			   t->stid_base + 1 : t->stid_base,
3177 			   t->stid_base + t->nstids - 1,
3178 			   t->stids_in_use - t->v6_stids_in_use,
3179 			   t->v6_stids_in_use);
3180 
3181 	if (t->natids)
3182 		seq_printf(seq, "ATID range: 0..%u, in use: %u\n",
3183 			   t->natids - 1, t->atids_in_use);
3184 	seq_printf(seq, "FTID range: %u..%u\n", t->ftid_base,
3185 		   t->ftid_base + t->nftids - 1);
3186 	if (t->nsftids)
3187 		seq_printf(seq, "SFTID range: %u..%u in use: %u\n",
3188 			   t->sftid_base, t->sftid_base + t->nsftids - 2,
3189 			   t->sftids_in_use);
3190 	if (t->ntids)
3191 		seq_printf(seq, "HW TID usage: %u IP users, %u IPv6 users\n",
3192 			   t4_read_reg(adap, LE_DB_ACT_CNT_IPV4_A),
3193 			   t4_read_reg(adap, LE_DB_ACT_CNT_IPV6_A));
3194 	return 0;
3195 }
3196 DEFINE_SHOW_ATTRIBUTE(tid_info);
3197 
3198 static void add_debugfs_mem(struct adapter *adap, const char *name,
3199 			    unsigned int idx, unsigned int size_mb)
3200 {
3201 	debugfs_create_file_size(name, 0400, adap->debugfs_root,
3202 				 (void *)adap + idx, &mem_debugfs_fops,
3203 				 size_mb << 20);
3204 }
3205 
3206 static ssize_t blocked_fl_read(struct file *filp, char __user *ubuf,
3207 			       size_t count, loff_t *ppos)
3208 {
3209 	int len;
3210 	const struct adapter *adap = filp->private_data;
3211 	char *buf;
3212 	ssize_t size = (adap->sge.egr_sz + 3) / 4 +
3213 			adap->sge.egr_sz / 32 + 2; /* includes ,/\n/\0 */
3214 
3215 	buf = kzalloc(size, GFP_KERNEL);
3216 	if (!buf)
3217 		return -ENOMEM;
3218 
3219 	len = snprintf(buf, size - 1, "%*pb\n",
3220 		       adap->sge.egr_sz, adap->sge.blocked_fl);
3221 	len += sprintf(buf + len, "\n");
3222 	size = simple_read_from_buffer(ubuf, count, ppos, buf, len);
3223 	kvfree(buf);
3224 	return size;
3225 }
3226 
3227 static ssize_t blocked_fl_write(struct file *filp, const char __user *ubuf,
3228 				size_t count, loff_t *ppos)
3229 {
3230 	int err;
3231 	unsigned long *t;
3232 	struct adapter *adap = filp->private_data;
3233 
3234 	t = kcalloc(BITS_TO_LONGS(adap->sge.egr_sz), sizeof(long), GFP_KERNEL);
3235 	if (!t)
3236 		return -ENOMEM;
3237 
3238 	err = bitmap_parse_user(ubuf, count, t, adap->sge.egr_sz);
3239 	if (err)
3240 		return err;
3241 
3242 	bitmap_copy(adap->sge.blocked_fl, t, adap->sge.egr_sz);
3243 	kvfree(t);
3244 	return count;
3245 }
3246 
3247 static const struct file_operations blocked_fl_fops = {
3248 	.owner   = THIS_MODULE,
3249 	.open    = simple_open,
3250 	.read    = blocked_fl_read,
3251 	.write   = blocked_fl_write,
3252 	.llseek  = generic_file_llseek,
3253 };
3254 
3255 static void mem_region_show(struct seq_file *seq, const char *name,
3256 			    unsigned int from, unsigned int to)
3257 {
3258 	char buf[40];
3259 
3260 	string_get_size((u64)to - from + 1, 1, STRING_UNITS_2, buf,
3261 			sizeof(buf));
3262 	seq_printf(seq, "%-15s %#x-%#x [%s]\n", name, from, to, buf);
3263 }
3264 
3265 static int meminfo_show(struct seq_file *seq, void *v)
3266 {
3267 	static const char * const memory[] = { "EDC0:", "EDC1:", "MC:",
3268 					       "MC0:", "MC1:", "HMA:"};
3269 	struct adapter *adap = seq->private;
3270 	struct cudbg_meminfo meminfo;
3271 	int i, rc;
3272 
3273 	memset(&meminfo, 0, sizeof(struct cudbg_meminfo));
3274 	rc = cudbg_fill_meminfo(adap, &meminfo);
3275 	if (rc)
3276 		return -ENXIO;
3277 
3278 	for (i = 0; i < meminfo.avail_c; i++)
3279 		mem_region_show(seq, memory[meminfo.avail[i].idx],
3280 				meminfo.avail[i].base,
3281 				meminfo.avail[i].limit - 1);
3282 
3283 	seq_putc(seq, '\n');
3284 	for (i = 0; i < meminfo.mem_c; i++) {
3285 		if (meminfo.mem[i].idx >= ARRAY_SIZE(cudbg_region))
3286 			continue;                        /* skip holes */
3287 		if (!meminfo.mem[i].limit)
3288 			meminfo.mem[i].limit =
3289 				i < meminfo.mem_c - 1 ?
3290 				meminfo.mem[i + 1].base - 1 : ~0;
3291 		mem_region_show(seq, cudbg_region[meminfo.mem[i].idx],
3292 				meminfo.mem[i].base, meminfo.mem[i].limit);
3293 	}
3294 
3295 	seq_putc(seq, '\n');
3296 	mem_region_show(seq, "uP RAM:", meminfo.up_ram_lo, meminfo.up_ram_hi);
3297 	mem_region_show(seq, "uP Extmem2:", meminfo.up_extmem2_lo,
3298 			meminfo.up_extmem2_hi);
3299 
3300 	seq_printf(seq, "\n%u Rx pages (%u free) of size %uKiB for %u channels\n",
3301 		   meminfo.rx_pages_data[0], meminfo.free_rx_cnt,
3302 		   meminfo.rx_pages_data[1], meminfo.rx_pages_data[2]);
3303 
3304 	seq_printf(seq, "%u Tx pages (%u free) of size %u%ciB for %u channels\n",
3305 		   meminfo.tx_pages_data[0], meminfo.free_tx_cnt,
3306 		   meminfo.tx_pages_data[1], meminfo.tx_pages_data[2],
3307 		   meminfo.tx_pages_data[3]);
3308 
3309 	seq_printf(seq, "%u p-structs (%u free)\n\n",
3310 		   meminfo.p_structs, meminfo.p_structs_free_cnt);
3311 
3312 	for (i = 0; i < 4; i++)
3313 		/* For T6 these are MAC buffer groups */
3314 		seq_printf(seq, "Port %d using %u pages out of %u allocated\n",
3315 			   i, meminfo.port_used[i], meminfo.port_alloc[i]);
3316 
3317 	for (i = 0; i < adap->params.arch.nchan; i++)
3318 		/* For T6 these are MAC buffer groups */
3319 		seq_printf(seq,
3320 			   "Loopback %d using %u pages out of %u allocated\n",
3321 			   i, meminfo.loopback_used[i],
3322 			   meminfo.loopback_alloc[i]);
3323 
3324 	return 0;
3325 }
3326 DEFINE_SHOW_ATTRIBUTE(meminfo);
3327 
3328 static int chcr_stats_show(struct seq_file *seq, void *v)
3329 {
3330 	struct adapter *adap = seq->private;
3331 
3332 	seq_puts(seq, "Chelsio Crypto Accelerator Stats \n");
3333 	seq_printf(seq, "Cipher Ops: %10u \n",
3334 		   atomic_read(&adap->chcr_stats.cipher_rqst));
3335 	seq_printf(seq, "Digest Ops: %10u \n",
3336 		   atomic_read(&adap->chcr_stats.digest_rqst));
3337 	seq_printf(seq, "Aead Ops: %10u \n",
3338 		   atomic_read(&adap->chcr_stats.aead_rqst));
3339 	seq_printf(seq, "Completion: %10u \n",
3340 		   atomic_read(&adap->chcr_stats.complete));
3341 	seq_printf(seq, "Error: %10u \n",
3342 		   atomic_read(&adap->chcr_stats.error));
3343 	seq_printf(seq, "Fallback: %10u \n",
3344 		   atomic_read(&adap->chcr_stats.fallback));
3345 	seq_printf(seq, "IPSec PDU: %10u\n",
3346 		   atomic_read(&adap->chcr_stats.ipsec_cnt));
3347 	return 0;
3348 }
3349 DEFINE_SHOW_ATTRIBUTE(chcr_stats);
3350 
3351 #define PRINT_ADAP_STATS(string, value) \
3352 	seq_printf(seq, "%-25s %-20llu\n", (string), \
3353 		   (unsigned long long)(value))
3354 
3355 #define PRINT_CH_STATS(string, value) \
3356 do { \
3357 	seq_printf(seq, "%-25s ", (string)); \
3358 	for (i = 0; i < adap->params.arch.nchan; i++) \
3359 		seq_printf(seq, "%-20llu ", \
3360 			   (unsigned long long)stats.value[i]); \
3361 	seq_printf(seq, "\n"); \
3362 } while (0)
3363 
3364 #define PRINT_CH_STATS2(string, value) \
3365 do { \
3366 	seq_printf(seq, "%-25s ", (string)); \
3367 	for (i = 0; i < adap->params.arch.nchan; i++) \
3368 		seq_printf(seq, "%-20llu ", \
3369 			   (unsigned long long)stats[i].value); \
3370 	seq_printf(seq, "\n"); \
3371 } while (0)
3372 
3373 static void show_tcp_stats(struct seq_file *seq)
3374 {
3375 	struct adapter *adap = seq->private;
3376 	struct tp_tcp_stats v4, v6;
3377 
3378 	spin_lock(&adap->stats_lock);
3379 	t4_tp_get_tcp_stats(adap, &v4, &v6, false);
3380 	spin_unlock(&adap->stats_lock);
3381 
3382 	PRINT_ADAP_STATS("tcp_ipv4_out_rsts:", v4.tcp_out_rsts);
3383 	PRINT_ADAP_STATS("tcp_ipv4_in_segs:", v4.tcp_in_segs);
3384 	PRINT_ADAP_STATS("tcp_ipv4_out_segs:", v4.tcp_out_segs);
3385 	PRINT_ADAP_STATS("tcp_ipv4_retrans_segs:", v4.tcp_retrans_segs);
3386 	PRINT_ADAP_STATS("tcp_ipv6_out_rsts:", v6.tcp_out_rsts);
3387 	PRINT_ADAP_STATS("tcp_ipv6_in_segs:", v6.tcp_in_segs);
3388 	PRINT_ADAP_STATS("tcp_ipv6_out_segs:", v6.tcp_out_segs);
3389 	PRINT_ADAP_STATS("tcp_ipv6_retrans_segs:", v6.tcp_retrans_segs);
3390 }
3391 
3392 static void show_ddp_stats(struct seq_file *seq)
3393 {
3394 	struct adapter *adap = seq->private;
3395 	struct tp_usm_stats stats;
3396 
3397 	spin_lock(&adap->stats_lock);
3398 	t4_get_usm_stats(adap, &stats, false);
3399 	spin_unlock(&adap->stats_lock);
3400 
3401 	PRINT_ADAP_STATS("usm_ddp_frames:", stats.frames);
3402 	PRINT_ADAP_STATS("usm_ddp_octets:", stats.octets);
3403 	PRINT_ADAP_STATS("usm_ddp_drops:", stats.drops);
3404 }
3405 
3406 static void show_rdma_stats(struct seq_file *seq)
3407 {
3408 	struct adapter *adap = seq->private;
3409 	struct tp_rdma_stats stats;
3410 
3411 	spin_lock(&adap->stats_lock);
3412 	t4_tp_get_rdma_stats(adap, &stats, false);
3413 	spin_unlock(&adap->stats_lock);
3414 
3415 	PRINT_ADAP_STATS("rdma_no_rqe_mod_defer:", stats.rqe_dfr_mod);
3416 	PRINT_ADAP_STATS("rdma_no_rqe_pkt_defer:", stats.rqe_dfr_pkt);
3417 }
3418 
3419 static void show_tp_err_adapter_stats(struct seq_file *seq)
3420 {
3421 	struct adapter *adap = seq->private;
3422 	struct tp_err_stats stats;
3423 
3424 	spin_lock(&adap->stats_lock);
3425 	t4_tp_get_err_stats(adap, &stats, false);
3426 	spin_unlock(&adap->stats_lock);
3427 
3428 	PRINT_ADAP_STATS("tp_err_ofld_no_neigh:", stats.ofld_no_neigh);
3429 	PRINT_ADAP_STATS("tp_err_ofld_cong_defer:", stats.ofld_cong_defer);
3430 }
3431 
3432 static void show_cpl_stats(struct seq_file *seq)
3433 {
3434 	struct adapter *adap = seq->private;
3435 	struct tp_cpl_stats stats;
3436 	u8 i;
3437 
3438 	spin_lock(&adap->stats_lock);
3439 	t4_tp_get_cpl_stats(adap, &stats, false);
3440 	spin_unlock(&adap->stats_lock);
3441 
3442 	PRINT_CH_STATS("tp_cpl_requests:", req);
3443 	PRINT_CH_STATS("tp_cpl_responses:", rsp);
3444 }
3445 
3446 static void show_tp_err_channel_stats(struct seq_file *seq)
3447 {
3448 	struct adapter *adap = seq->private;
3449 	struct tp_err_stats stats;
3450 	u8 i;
3451 
3452 	spin_lock(&adap->stats_lock);
3453 	t4_tp_get_err_stats(adap, &stats, false);
3454 	spin_unlock(&adap->stats_lock);
3455 
3456 	PRINT_CH_STATS("tp_mac_in_errs:", mac_in_errs);
3457 	PRINT_CH_STATS("tp_hdr_in_errs:", hdr_in_errs);
3458 	PRINT_CH_STATS("tp_tcp_in_errs:", tcp_in_errs);
3459 	PRINT_CH_STATS("tp_tcp6_in_errs:", tcp6_in_errs);
3460 	PRINT_CH_STATS("tp_tnl_cong_drops:", tnl_cong_drops);
3461 	PRINT_CH_STATS("tp_tnl_tx_drops:", tnl_tx_drops);
3462 	PRINT_CH_STATS("tp_ofld_vlan_drops:", ofld_vlan_drops);
3463 	PRINT_CH_STATS("tp_ofld_chan_drops:", ofld_chan_drops);
3464 }
3465 
3466 static void show_fcoe_stats(struct seq_file *seq)
3467 {
3468 	struct adapter *adap = seq->private;
3469 	struct tp_fcoe_stats stats[NCHAN];
3470 	u8 i;
3471 
3472 	spin_lock(&adap->stats_lock);
3473 	for (i = 0; i < adap->params.arch.nchan; i++)
3474 		t4_get_fcoe_stats(adap, i, &stats[i], false);
3475 	spin_unlock(&adap->stats_lock);
3476 
3477 	PRINT_CH_STATS2("fcoe_octets_ddp", octets_ddp);
3478 	PRINT_CH_STATS2("fcoe_frames_ddp", frames_ddp);
3479 	PRINT_CH_STATS2("fcoe_frames_drop", frames_drop);
3480 }
3481 
3482 #undef PRINT_CH_STATS2
3483 #undef PRINT_CH_STATS
3484 #undef PRINT_ADAP_STATS
3485 
3486 static int tp_stats_show(struct seq_file *seq, void *v)
3487 {
3488 	struct adapter *adap = seq->private;
3489 
3490 	seq_puts(seq, "\n--------Adapter Stats--------\n");
3491 	show_tcp_stats(seq);
3492 	show_ddp_stats(seq);
3493 	show_rdma_stats(seq);
3494 	show_tp_err_adapter_stats(seq);
3495 
3496 	seq_puts(seq, "\n-------- Channel Stats --------\n");
3497 	if (adap->params.arch.nchan == NCHAN)
3498 		seq_printf(seq, "%-25s %-20s %-20s %-20s %-20s\n",
3499 			   " ", "channel 0", "channel 1",
3500 			   "channel 2", "channel 3");
3501 	else
3502 		seq_printf(seq, "%-25s %-20s %-20s\n",
3503 			   " ", "channel 0", "channel 1");
3504 	show_cpl_stats(seq);
3505 	show_tp_err_channel_stats(seq);
3506 	show_fcoe_stats(seq);
3507 
3508 	return 0;
3509 }
3510 DEFINE_SHOW_ATTRIBUTE(tp_stats);
3511 
3512 /* Add an array of Debug FS files.
3513  */
3514 void add_debugfs_files(struct adapter *adap,
3515 		       struct t4_debugfs_entry *files,
3516 		       unsigned int nfiles)
3517 {
3518 	int i;
3519 
3520 	/* debugfs support is best effort */
3521 	for (i = 0; i < nfiles; i++)
3522 		debugfs_create_file(files[i].name, files[i].mode,
3523 				    adap->debugfs_root,
3524 				    (void *)adap + files[i].data,
3525 				    files[i].ops);
3526 }
3527 
3528 int t4_setup_debugfs(struct adapter *adap)
3529 {
3530 	int i;
3531 	u32 size = 0;
3532 	struct dentry *de;
3533 
3534 	static struct t4_debugfs_entry t4_debugfs_files[] = {
3535 		{ "cim_la", &cim_la_fops, 0400, 0 },
3536 		{ "cim_pif_la", &cim_pif_la_fops, 0400, 0 },
3537 		{ "cim_ma_la", &cim_ma_la_fops, 0400, 0 },
3538 		{ "cim_qcfg", &cim_qcfg_fops, 0400, 0 },
3539 		{ "clk", &clk_fops, 0400, 0 },
3540 		{ "devlog", &devlog_fops, 0400, 0 },
3541 		{ "mboxlog", &mboxlog_fops, 0400, 0 },
3542 		{ "mbox0", &mbox_debugfs_fops, 0600, 0 },
3543 		{ "mbox1", &mbox_debugfs_fops, 0600, 1 },
3544 		{ "mbox2", &mbox_debugfs_fops, 0600, 2 },
3545 		{ "mbox3", &mbox_debugfs_fops, 0600, 3 },
3546 		{ "mbox4", &mbox_debugfs_fops, 0600, 4 },
3547 		{ "mbox5", &mbox_debugfs_fops, 0600, 5 },
3548 		{ "mbox6", &mbox_debugfs_fops, 0600, 6 },
3549 		{ "mbox7", &mbox_debugfs_fops, 0600, 7 },
3550 		{ "trace0", &mps_trc_debugfs_fops, 0600, 0 },
3551 		{ "trace1", &mps_trc_debugfs_fops, 0600, 1 },
3552 		{ "trace2", &mps_trc_debugfs_fops, 0600, 2 },
3553 		{ "trace3", &mps_trc_debugfs_fops, 0600, 3 },
3554 		{ "l2t", &t4_l2t_fops, 0400, 0},
3555 		{ "mps_tcam", &mps_tcam_debugfs_fops, 0400, 0 },
3556 		{ "rss", &rss_debugfs_fops, 0400, 0 },
3557 		{ "rss_config", &rss_config_fops, 0400, 0 },
3558 		{ "rss_key", &rss_key_debugfs_fops, 0400, 0 },
3559 		{ "rss_pf_config", &rss_pf_config_debugfs_fops, 0400, 0 },
3560 		{ "rss_vf_config", &rss_vf_config_debugfs_fops, 0400, 0 },
3561 		{ "resources", &resources_fops, 0400, 0 },
3562 #ifdef CONFIG_CHELSIO_T4_DCB
3563 		{ "dcb_info", &dcb_info_debugfs_fops, 0400, 0 },
3564 #endif
3565 		{ "sge_qinfo", &sge_qinfo_debugfs_fops, 0400, 0 },
3566 		{ "ibq_tp0",  &cim_ibq_fops, 0400, 0 },
3567 		{ "ibq_tp1",  &cim_ibq_fops, 0400, 1 },
3568 		{ "ibq_ulp",  &cim_ibq_fops, 0400, 2 },
3569 		{ "ibq_sge0", &cim_ibq_fops, 0400, 3 },
3570 		{ "ibq_sge1", &cim_ibq_fops, 0400, 4 },
3571 		{ "ibq_ncsi", &cim_ibq_fops, 0400, 5 },
3572 		{ "obq_ulp0", &cim_obq_fops, 0400, 0 },
3573 		{ "obq_ulp1", &cim_obq_fops, 0400, 1 },
3574 		{ "obq_ulp2", &cim_obq_fops, 0400, 2 },
3575 		{ "obq_ulp3", &cim_obq_fops, 0400, 3 },
3576 		{ "obq_sge",  &cim_obq_fops, 0400, 4 },
3577 		{ "obq_ncsi", &cim_obq_fops, 0400, 5 },
3578 		{ "tp_la", &tp_la_fops, 0400, 0 },
3579 		{ "ulprx_la", &ulprx_la_fops, 0400, 0 },
3580 		{ "sensors", &sensors_fops, 0400, 0 },
3581 		{ "pm_stats", &pm_stats_debugfs_fops, 0400, 0 },
3582 		{ "tx_rate", &tx_rate_fops, 0400, 0 },
3583 		{ "cctrl", &cctrl_tbl_fops, 0400, 0 },
3584 #if IS_ENABLED(CONFIG_IPV6)
3585 		{ "clip_tbl", &clip_tbl_fops, 0400, 0 },
3586 #endif
3587 		{ "tids", &tid_info_fops, 0400, 0},
3588 		{ "blocked_fl", &blocked_fl_fops, 0600, 0 },
3589 		{ "meminfo", &meminfo_fops, 0400, 0 },
3590 		{ "crypto", &chcr_stats_fops, 0400, 0 },
3591 		{ "tp_stats", &tp_stats_fops, 0400, 0 },
3592 	};
3593 
3594 	/* Debug FS nodes common to all T5 and later adapters.
3595 	 */
3596 	static struct t4_debugfs_entry t5_debugfs_files[] = {
3597 		{ "obq_sge_rx_q0", &cim_obq_fops, 0400, 6 },
3598 		{ "obq_sge_rx_q1", &cim_obq_fops, 0400, 7 },
3599 	};
3600 
3601 	add_debugfs_files(adap,
3602 			  t4_debugfs_files,
3603 			  ARRAY_SIZE(t4_debugfs_files));
3604 	if (!is_t4(adap->params.chip))
3605 		add_debugfs_files(adap,
3606 				  t5_debugfs_files,
3607 				  ARRAY_SIZE(t5_debugfs_files));
3608 
3609 	i = t4_read_reg(adap, MA_TARGET_MEM_ENABLE_A);
3610 	if (i & EDRAM0_ENABLE_F) {
3611 		size = t4_read_reg(adap, MA_EDRAM0_BAR_A);
3612 		add_debugfs_mem(adap, "edc0", MEM_EDC0, EDRAM0_SIZE_G(size));
3613 	}
3614 	if (i & EDRAM1_ENABLE_F) {
3615 		size = t4_read_reg(adap, MA_EDRAM1_BAR_A);
3616 		add_debugfs_mem(adap, "edc1", MEM_EDC1, EDRAM1_SIZE_G(size));
3617 	}
3618 	if (is_t5(adap->params.chip)) {
3619 		if (i & EXT_MEM0_ENABLE_F) {
3620 			size = t4_read_reg(adap, MA_EXT_MEMORY0_BAR_A);
3621 			add_debugfs_mem(adap, "mc0", MEM_MC0,
3622 					EXT_MEM0_SIZE_G(size));
3623 		}
3624 		if (i & EXT_MEM1_ENABLE_F) {
3625 			size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A);
3626 			add_debugfs_mem(adap, "mc1", MEM_MC1,
3627 					EXT_MEM1_SIZE_G(size));
3628 		}
3629 	} else {
3630 		if (i & EXT_MEM_ENABLE_F) {
3631 			size = t4_read_reg(adap, MA_EXT_MEMORY_BAR_A);
3632 			add_debugfs_mem(adap, "mc", MEM_MC,
3633 					EXT_MEM_SIZE_G(size));
3634 		}
3635 
3636 		if (i & HMA_MUX_F) {
3637 			size = t4_read_reg(adap, MA_EXT_MEMORY1_BAR_A);
3638 			add_debugfs_mem(adap, "hma", MEM_HMA,
3639 					EXT_MEM1_SIZE_G(size));
3640 		}
3641 	}
3642 
3643 	de = debugfs_create_file_size("flash", 0400, adap->debugfs_root, adap,
3644 				      &flash_debugfs_fops, adap->params.sf_size);
3645 	debugfs_create_bool("use_backdoor", 0600,
3646 			    adap->debugfs_root, &adap->use_bd);
3647 	debugfs_create_bool("trace_rss", 0600,
3648 			    adap->debugfs_root, &adap->trace_rss);
3649 
3650 	return 0;
3651 }
3652