[mirror_ubuntu-hirsute-kernel.git] / arch / mips / sibyte / common / bus_watcher.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2002,2003 Broadcom Corporation
 */

/*
 * The Bus Watcher monitors internal bus transactions and maintains
 * counts of transactions with error status, logging details and
 * causing one of several interrupts.  This driver provides a handler
 * for those interrupts which aggregates the counts (to avoid
 * saturating the 8-bit counters) and provides a presence in
 * /proc/bus_watcher if PROC_FS is on.
 */

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <asm/io.h>

#include <asm/sibyte/sb1250.h>
#include <asm/sibyte/sb1250_regs.h>
#include <asm/sibyte/sb1250_int.h>
#include <asm/sibyte/sb1250_scd.h>
#if defined(CONFIG_SIBYTE_BCM1x55) || defined(CONFIG_SIBYTE_BCM1x80)
#include <asm/sibyte/bcm1480_regs.h>
#endif


struct bw_stats_struct {
	uint64_t status;
	uint32_t l2_err;
	uint32_t memio_err;
	int status_printed;
	unsigned long l2_cor_d;
	unsigned long l2_bad_d;
	unsigned long l2_cor_t;
	unsigned long l2_bad_t;
	unsigned long mem_cor_d;
	unsigned long mem_bad_d;
	unsigned long bus_error;
} bw_stats;


static void print_summary(uint32_t status, uint32_t l2_err,
			  uint32_t memio_err)
{
	printk("Bus watcher error counters: %08x %08x\n", l2_err, memio_err);
	printk("\nLast recorded signature:\n");
	printk("Request %02x from %d, answered by %d with Dcode %d\n",
	       (unsigned int)(G_SCD_BERR_TID(status) & 0x3f),
	       (int)(G_SCD_BERR_TID(status) >> 6),
	       (int)G_SCD_BERR_RID(status),
	       (int)G_SCD_BERR_DCODE(status));
}

/*
 * check_bus_watcher is exported for use in situations where we want
 * to see the most recent status of the bus watcher, which might have
 * already been destructively read out of the registers.
 *
 * notes: this is currently used by the cache error handler
 *	  should provide locking against the interrupt handler
 */
void check_bus_watcher(void)
{
	u32 status, l2_err, memio_err;

#if defined(CONFIG_SIBYTE_BCM112X) || defined(CONFIG_SIBYTE_SB1250)
	/* Use non-destructive register */
	status = csr_in32(IOADDR(A_SCD_BUS_ERR_STATUS_DEBUG));
#elif defined(CONFIG_SIBYTE_BCM1x55) || defined(CONFIG_SIBYTE_BCM1x80)
	/* Use non-destructive register */
	/* Same as 1250 except BUS_ERR_STATUS_DEBUG is in a different place. */
	status = csr_in32(IOADDR(A_BCM1480_BUS_ERR_STATUS_DEBUG));
#else
#error bus watcher being built for unknown Sibyte SOC!
#endif
	if (!(status & 0x7fffffff)) {
		printk("Using last values reaped by bus watcher driver\n");
		status = bw_stats.status;
		l2_err = bw_stats.l2_err;
		memio_err = bw_stats.memio_err;
	} else {
		l2_err = csr_in32(IOADDR(A_BUS_L2_ERRORS));
		memio_err = csr_in32(IOADDR(A_BUS_MEM_IO_ERRORS));
	}
	if (status & ~(1UL << 31))
		print_summary(status, l2_err, memio_err);
	else
		printk("Bus watcher indicates no error\n");
}

#ifdef CONFIG_PROC_FS

/* For simplicity, I want to assume a single read is required each
   time */
static int bw_proc_show(struct seq_file *m, void *v)
{
	struct bw_stats_struct *stats = m->private;

	seq_puts(m, "SiByte Bus Watcher statistics\n");
	seq_puts(m, "-----------------------------\n");
	seq_printf(m, "L2-d-cor %8ld\nL2-d-bad %8ld\n",
		   stats->l2_cor_d, stats->l2_bad_d);
	seq_printf(m, "L2-t-cor %8ld\nL2-t-bad %8ld\n",
		   stats->l2_cor_t, stats->l2_bad_t);
	seq_printf(m, "MC-d-cor %8ld\nMC-d-bad %8ld\n",
		   stats->mem_cor_d, stats->mem_bad_d);
	seq_printf(m, "IO-err   %8ld\n", stats->bus_error);
	seq_puts(m, "\nLast recorded signature:\n");
	seq_printf(m, "Request %02x from %d, answered by %d with Dcode %d\n",
		   (unsigned int)(G_SCD_BERR_TID(stats->status) & 0x3f),
		   (int)(G_SCD_BERR_TID(stats->status) >> 6),
		   (int)G_SCD_BERR_RID(stats->status),
		   (int)G_SCD_BERR_DCODE(stats->status));
	/* XXXKW indicate multiple errors between printings, or stats
	   collection (or both)? */
	if (stats->status & M_SCD_BERR_MULTERRS)
		seq_puts(m, "Multiple errors observed since last check.\n");
	if (stats->status_printed) {
		seq_puts(m, "(no change since last printing)\n");
	} else {
		stats->status_printed = 1;
	}

	return 0;
}

static void create_proc_decoder(struct bw_stats_struct *stats)
{
	struct proc_dir_entry *ent;

	ent = proc_create_single_data("bus_watcher", S_IWUSR | S_IRUGO, NULL,
			bw_proc_show, stats);
	if (!ent) {
		printk(KERN_INFO "Unable to initialize bus_watcher /proc entry\n");
		return;
	}
}

#endif /* CONFIG_PROC_FS */

/*
 * sibyte_bw_int - handle bus watcher interrupts and accumulate counts
 *
 * notes: possible re-entry due to multiple sources
 *	  should check/indicate saturation
 */
static irqreturn_t sibyte_bw_int(int irq, void *data)
{
	struct bw_stats_struct *stats = data;
	unsigned long cntr;
#ifdef CONFIG_SIBYTE_BW_TRACE
	int i;
#endif

#ifdef CONFIG_SIBYTE_BW_TRACE
	csr_out32(M_SCD_TRACE_CFG_FREEZE, IOADDR(A_SCD_TRACE_CFG));
	csr_out32(M_SCD_TRACE_CFG_START_READ, IOADDR(A_SCD_TRACE_CFG));

	for (i=0; i<256*6; i++)
		printk("%016llx\n",
		       (long long)__raw_readq(IOADDR(A_SCD_TRACE_READ)));

	csr_out32(M_SCD_TRACE_CFG_RESET, IOADDR(A_SCD_TRACE_CFG));
	csr_out32(M_SCD_TRACE_CFG_START, IOADDR(A_SCD_TRACE_CFG));
#endif

	/* Destructive read, clears register and interrupt */
	stats->status = csr_in32(IOADDR(A_SCD_BUS_ERR_STATUS));
	stats->status_printed = 0;

	stats->l2_err = cntr = csr_in32(IOADDR(A_BUS_L2_ERRORS));
	stats->l2_cor_d += G_SCD_L2ECC_CORR_D(cntr);
	stats->l2_bad_d += G_SCD_L2ECC_BAD_D(cntr);
	stats->l2_cor_t += G_SCD_L2ECC_CORR_T(cntr);
	stats->l2_bad_t += G_SCD_L2ECC_BAD_T(cntr);
	csr_out32(0, IOADDR(A_BUS_L2_ERRORS));

	stats->memio_err = cntr = csr_in32(IOADDR(A_BUS_MEM_IO_ERRORS));
	stats->mem_cor_d += G_SCD_MEM_ECC_CORR(cntr);
	stats->mem_bad_d += G_SCD_MEM_ECC_BAD(cntr);
	stats->bus_error += G_SCD_MEM_BUSERR(cntr);
	csr_out32(0, IOADDR(A_BUS_MEM_IO_ERRORS));

	return IRQ_HANDLED;
}

int __init sibyte_bus_watcher(void)
{
	memset(&bw_stats, 0, sizeof(struct bw_stats_struct));
	bw_stats.status_printed = 1;

	if (request_irq(K_INT_BAD_ECC, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
		printk("Failed to register bus watcher BAD_ECC irq\n");
		return -1;
	}
	if (request_irq(K_INT_COR_ECC, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
		free_irq(K_INT_BAD_ECC, &bw_stats);
		printk("Failed to register bus watcher COR_ECC irq\n");
		return -1;
	}
	if (request_irq(K_INT_IO_BUS, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
		free_irq(K_INT_BAD_ECC, &bw_stats);
		free_irq(K_INT_COR_ECC, &bw_stats);
		printk("Failed to register bus watcher IO_BUS irq\n");
		return -1;
	}

#ifdef CONFIG_PROC_FS
	create_proc_decoder(&bw_stats);
#endif

#ifdef CONFIG_SIBYTE_BW_TRACE
	csr_out32((M_SCD_TRSEQ_ASAMPLE | M_SCD_TRSEQ_DSAMPLE |
		   K_SCD_TRSEQ_TRIGGER_ALL),
		  IOADDR(A_SCD_TRACE_SEQUENCE_0));
	csr_out32(M_SCD_TRACE_CFG_RESET, IOADDR(A_SCD_TRACE_CFG));
	csr_out32(M_SCD_TRACE_CFG_START, IOADDR(A_SCD_TRACE_CFG));
#endif

	return 0;
}

device_initcall(sibyte_bus_watcher);
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
1da177e4 LT	3	* Copyright (C) 2002,2003 Broadcom Corporation
1da177e4 LT	4	*/
1da177e4 LT	5
42a3b4f2	6	/*
1da177e4 LT	7	* The Bus Watcher monitors internal bus transactions and maintains
	8	* counts of transactions with error status, logging details and
	9	* causing one of several interrupts. This driver provides a handler
	10	* for those interrupts which aggregates the counts (to avoid
	11	* saturating the 8-bit counters) and provides a presence in
	12	* /proc/bus_watcher if PROC_FS is on.
	13	*/
	14
1da177e4 LT	15	#include <linux/init.h>
	16	#include <linux/kernel.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/sched.h>
	19	#include <linux/proc_fs.h>
24270156	20	#include <linux/seq_file.h>
1da177e4 LT	21	#include <asm/io.h>
	22
	23	#include <asm/sibyte/sb1250.h>
	24	#include <asm/sibyte/sb1250_regs.h>
	25	#include <asm/sibyte/sb1250_int.h>
	26	#include <asm/sibyte/sb1250_scd.h>
ae5b0e09 RB	27	#if defined(CONFIG_SIBYTE_BCM1x55) \|\| defined(CONFIG_SIBYTE_BCM1x80)
	28	#include <asm/sibyte/bcm1480_regs.h>
	29	#endif
1da177e4 LT	30
	31
	32	struct bw_stats_struct {
	33	uint64_t status;
	34	uint32_t l2_err;
	35	uint32_t memio_err;
	36	int status_printed;
	37	unsigned long l2_cor_d;
	38	unsigned long l2_bad_d;
	39	unsigned long l2_cor_t;
	40	unsigned long l2_bad_t;
	41	unsigned long mem_cor_d;
	42	unsigned long mem_bad_d;
	43	unsigned long bus_error;
	44	} bw_stats;
	45
	46
	47	static void print_summary(uint32_t status, uint32_t l2_err,
	48	uint32_t memio_err)
	49	{
	50	printk("Bus watcher error counters: %08x %08x\n", l2_err, memio_err);
	51	printk("\nLast recorded signature:\n");
	52	printk("Request %02x from %d, answered by %d with Dcode %d\n",
	53	(unsigned int)(G_SCD_BERR_TID(status) & 0x3f),
	54	(int)(G_SCD_BERR_TID(status) >> 6),
	55	(int)G_SCD_BERR_RID(status),
	56	(int)G_SCD_BERR_DCODE(status));
	57	}
	58
	59	/*
	60	* check_bus_watcher is exported for use in situations where we want
	61	* to see the most recent status of the bus watcher, which might have
	62	* already been destructively read out of the registers.
	63	*
	64	* notes: this is currently used by the cache error handler
70342287	65	* should provide locking against the interrupt handler
1da177e4 LT	66	*/
	67	void check_bus_watcher(void)
	68	{
	69	u32 status, l2_err, memio_err;
	70
dd0bc75e	71	#if defined(CONFIG_SIBYTE_BCM112X) \|\| defined(CONFIG_SIBYTE_SB1250)
1da177e4 LT	72	/* Use non-destructive register */
1da177e4 LT	73	status = csr_in32(IOADDR(A_SCD_BUS_ERR_STATUS_DEBUG));
ae5b0e09 RB	74	#elif defined(CONFIG_SIBYTE_BCM1x55) \|\| defined(CONFIG_SIBYTE_BCM1x80)
	75	/* Use non-destructive register */
	76	/* Same as 1250 except BUS_ERR_STATUS_DEBUG is in a different place. */
	77	status = csr_in32(IOADDR(A_BCM1480_BUS_ERR_STATUS_DEBUG));
	78	#else
	79	#error bus watcher being built for unknown Sibyte SOC!
1da177e4 LT	80	#endif
	81	if (!(status & 0x7fffffff)) {
	82	printk("Using last values reaped by bus watcher driver\n");
	83	status = bw_stats.status;
	84	l2_err = bw_stats.l2_err;
	85	memio_err = bw_stats.memio_err;
	86	} else {
	87	l2_err = csr_in32(IOADDR(A_BUS_L2_ERRORS));
	88	memio_err = csr_in32(IOADDR(A_BUS_MEM_IO_ERRORS));
	89	}
	90	if (status & ~(1UL << 31))
	91	print_summary(status, l2_err, memio_err);
	92	else
	93	printk("Bus watcher indicates no error\n");
	94	}
	95
24270156 DH	96	#ifdef CONFIG_PROC_FS
	97
	98	/* For simplicity, I want to assume a single read is required each
	99	time */
	100	static int bw_proc_show(struct seq_file m, void v)
1da177e4	101	{
24270156 DH	102	struct bw_stats_struct *stats = m->private;
	103
	104	seq_puts(m, "SiByte Bus Watcher statistics\n");
	105	seq_puts(m, "-----------------------------\n");
	106	seq_printf(m, "L2-d-cor %8ld\nL2-d-bad %8ld\n",
	107	stats->l2_cor_d, stats->l2_bad_d);
	108	seq_printf(m, "L2-t-cor %8ld\nL2-t-bad %8ld\n",
	109	stats->l2_cor_t, stats->l2_bad_t);
	110	seq_printf(m, "MC-d-cor %8ld\nMC-d-bad %8ld\n",
	111	stats->mem_cor_d, stats->mem_bad_d);
	112	seq_printf(m, "IO-err %8ld\n", stats->bus_error);
	113	seq_puts(m, "\nLast recorded signature:\n");
	114	seq_printf(m, "Request %02x from %d, answered by %d with Dcode %d\n",
	115	(unsigned int)(G_SCD_BERR_TID(stats->status) & 0x3f),
	116	(int)(G_SCD_BERR_TID(stats->status) >> 6),
	117	(int)G_SCD_BERR_RID(stats->status),
	118	(int)G_SCD_BERR_DCODE(stats->status));
1da177e4	119	/* XXXKW indicate multiple errors between printings, or stats
70342287	120	collection (or both)? */
1da177e4	121	if (stats->status & M_SCD_BERR_MULTERRS)
24270156	122	seq_puts(m, "Multiple errors observed since last check.\n");
1da177e4	123	if (stats->status_printed) {
24270156	124	seq_puts(m, "(no change since last printing)\n");
1da177e4 LT	125	} else {
	126	stats->status_printed = 1;
	127	}
	128
24270156	129	return 0;
1da177e4 LT	130	}
1da177e4 LT	131
1da177e4 LT	132	static void create_proc_decoder(struct bw_stats_struct *stats)
	133	{
	134	struct proc_dir_entry *ent;
42a3b4f2	135
3f3942ac CH	136	ent = proc_create_single_data("bus_watcher", S_IWUSR \| S_IRUGO, NULL,
3f3942ac CH	137	bw_proc_show, stats);
1da177e4 LT	138	if (!ent) {
	139	printk(KERN_INFO "Unable to initialize bus_watcher /proc entry\n");
	140	return;
	141	}
	142	}
	143
	144	#endif /* CONFIG_PROC_FS */
	145
	146	/*
	147	* sibyte_bw_int - handle bus watcher interrupts and accumulate counts
	148	*
	149	* notes: possible re-entry due to multiple sources
70342287	150	* should check/indicate saturation
1da177e4	151	*/
36d98e79	152	static irqreturn_t sibyte_bw_int(int irq, void *data)
1da177e4 LT	153	{
	154	struct bw_stats_struct *stats = data;
	155	unsigned long cntr;
	156	#ifdef CONFIG_SIBYTE_BW_TRACE
	157	int i;
	158	#endif
1da177e4 LT	159
	160	#ifdef CONFIG_SIBYTE_BW_TRACE
	161	csr_out32(M_SCD_TRACE_CFG_FREEZE, IOADDR(A_SCD_TRACE_CFG));
	162	csr_out32(M_SCD_TRACE_CFG_START_READ, IOADDR(A_SCD_TRACE_CFG));
	163
	164	for (i=0; i<256*6; i++)
	165	printk("%016llx\n",
65bda1a9	166	(long long)__raw_readq(IOADDR(A_SCD_TRACE_READ)));
1da177e4 LT	167
	168	csr_out32(M_SCD_TRACE_CFG_RESET, IOADDR(A_SCD_TRACE_CFG));
	169	csr_out32(M_SCD_TRACE_CFG_START, IOADDR(A_SCD_TRACE_CFG));
	170	#endif
	171
	172	/* Destructive read, clears register and interrupt */
	173	stats->status = csr_in32(IOADDR(A_SCD_BUS_ERR_STATUS));
	174	stats->status_printed = 0;
	175
	176	stats->l2_err = cntr = csr_in32(IOADDR(A_BUS_L2_ERRORS));
	177	stats->l2_cor_d += G_SCD_L2ECC_CORR_D(cntr);
	178	stats->l2_bad_d += G_SCD_L2ECC_BAD_D(cntr);
	179	stats->l2_cor_t += G_SCD_L2ECC_CORR_T(cntr);
	180	stats->l2_bad_t += G_SCD_L2ECC_BAD_T(cntr);
	181	csr_out32(0, IOADDR(A_BUS_L2_ERRORS));
	182
	183	stats->memio_err = cntr = csr_in32(IOADDR(A_BUS_MEM_IO_ERRORS));
	184	stats->mem_cor_d += G_SCD_MEM_ECC_CORR(cntr);
	185	stats->mem_bad_d += G_SCD_MEM_ECC_BAD(cntr);
	186	stats->bus_error += G_SCD_MEM_BUSERR(cntr);
	187	csr_out32(0, IOADDR(A_BUS_MEM_IO_ERRORS));
	188
1da177e4 LT	189	return IRQ_HANDLED;
	190	}
	191
	192	int __init sibyte_bus_watcher(void)
	193	{
	194	memset(&bw_stats, 0, sizeof(struct bw_stats_struct));
	195	bw_stats.status_printed = 1;
	196
	197	if (request_irq(K_INT_BAD_ECC, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
	198	printk("Failed to register bus watcher BAD_ECC irq\n");
	199	return -1;
	200	}
	201	if (request_irq(K_INT_COR_ECC, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
	202	free_irq(K_INT_BAD_ECC, &bw_stats);
	203	printk("Failed to register bus watcher COR_ECC irq\n");
	204	return -1;
	205	}
	206	if (request_irq(K_INT_IO_BUS, sibyte_bw_int, 0, "Bus watcher", &bw_stats)) {
	207	free_irq(K_INT_BAD_ECC, &bw_stats);
	208	free_irq(K_INT_COR_ECC, &bw_stats);
	209	printk("Failed to register bus watcher IO_BUS irq\n");
	210	return -1;
	211	}
	212
	213	#ifdef CONFIG_PROC_FS
	214	create_proc_decoder(&bw_stats);
	215	#endif
	216
	217	#ifdef CONFIG_SIBYTE_BW_TRACE
	218	csr_out32((M_SCD_TRSEQ_ASAMPLE \| M_SCD_TRSEQ_DSAMPLE \|
	219	K_SCD_TRSEQ_TRIGGER_ALL),
	220	IOADDR(A_SCD_TRACE_SEQUENCE_0));
	221	csr_out32(M_SCD_TRACE_CFG_RESET, IOADDR(A_SCD_TRACE_CFG));
	222	csr_out32(M_SCD_TRACE_CFG_START, IOADDR(A_SCD_TRACE_CFG));
	223	#endif
	224
	225	return 0;
	226	}
	227
486fcde4	228	device_initcall(sibyte_bus_watcher);