omap_l3_noc.c 10.4 KB
Newer Older
1
/*
2
 * OMAP L3 Interconnect error handling driver
3
 *
4
 * Copyright (C) 2011-2015 Texas Instruments Incorporated - http://www.ti.com/
5 6 7 8
 *	Santosh Shilimkar <santosh.shilimkar@ti.com>
 *	Sricharan <r.sricharan@ti.com>
 *
 * This program is free software; you can redistribute it and/or modify
9 10
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
11
 *
12 13 14
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 16
 * GNU General Public License for more details.
 */
17 18
#include <linux/init.h>
#include <linux/interrupt.h>
19
#include <linux/io.h>
20
#include <linux/kernel.h>
21 22 23 24
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/of.h>
#include <linux/platform_device.h>
25 26 27 28
#include <linux/slab.h>

#include "omap_l3_noc.h"

29 30 31 32 33 34
/**
 * l3_handle_target() - Handle Target specific parse and reporting
 * @l3:		pointer to l3 struct
 * @base:	base address of clkdm
 * @flag_mux:	flagmux corresponding to the event
 * @err_src:	error source index of the slave (target)
35
 *
36 37 38 39 40 41 42
 * This does the second part of the error interrupt handling:
 *	3) Parse in the slave information
 *	4) Print the logged information.
 *	5) Add dump stack to provide kernel trace.
 *	6) Clear the source if known.
 *
 * This handles two types of errors:
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
 *	1) Custom errors in L3 :
 *		Target like DMM/FW/EMIF generates SRESP=ERR error
 *	2) Standard L3 error:
 *		- Unsupported CMD.
 *			L3 tries to access target while it is idle
 *		- OCP disconnect.
 *		- Address hole error:
 *			If DSS/ISS/FDIF/USBHOSTFS access a target where they
 *			do not have connectivity, the error is logged in
 *			their default target which is DMM2.
 *
 *	On High Secure devices, firewall errors are possible and those
 *	can be trapped as well. But the trapping is implemented as part
 *	secure software and hence need not be implemented here.
 */
58 59
static int l3_handle_target(struct omap_l3 *l3, void __iomem *base,
			    struct l3_flagmux_data *flag_mux, int err_src)
60
{
61 62
	int k;
	u32 std_err_main, clear, masterid;
63
	u8 op_code, m_req_info;
64
	void __iomem *l3_targ_base;
65
	void __iomem *l3_targ_stderr, *l3_targ_slvofslsb, *l3_targ_mstaddr;
66
	void __iomem *l3_targ_hdr, *l3_targ_info;
67
	struct l3_target_data *l3_targ_inst;
68
	struct l3_masters_data *master;
69
	char *target_name, *master_name = "UN IDENTIFIED";
70 71
	char *err_description;
	char err_string[30] = { 0 };
72
	char info_string[60] = { 0 };
73

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
	/* We DONOT expect err_src to go out of bounds */
	BUG_ON(err_src > MAX_CLKDM_TARGETS);

	if (err_src < flag_mux->num_targ_data) {
		l3_targ_inst = &flag_mux->l3_targ[err_src];
		target_name = l3_targ_inst->name;
		l3_targ_base = base + l3_targ_inst->offset;
	} else {
		target_name = L3_TARGET_NOT_SUPPORTED;
	}

	if (target_name == L3_TARGET_NOT_SUPPORTED)
		return -ENODEV;

	/* Read the stderrlog_main_source from clk domain */
	l3_targ_stderr = l3_targ_base + L3_TARG_STDERRLOG_MAIN;
	l3_targ_slvofslsb = l3_targ_base + L3_TARG_STDERRLOG_SLVOFSLSB;

	std_err_main = readl_relaxed(l3_targ_stderr);

	switch (std_err_main & CUSTOM_ERROR) {
	case STANDARD_ERROR:
		err_description = "Standard";
		snprintf(err_string, sizeof(err_string),
			 ": At Address: 0x%08X ",
			 readl_relaxed(l3_targ_slvofslsb));

		l3_targ_mstaddr = l3_targ_base + L3_TARG_STDERRLOG_MSTADDR;
102
		l3_targ_hdr = l3_targ_base + L3_TARG_STDERRLOG_HDR;
103
		l3_targ_info = l3_targ_base + L3_TARG_STDERRLOG_INFO;
104 105 106 107 108 109 110
		break;

	case CUSTOM_ERROR:
		err_description = "Custom";

		l3_targ_mstaddr = l3_targ_base +
				  L3_TARG_STDERRLOG_CINFO_MSTADDR;
111
		l3_targ_hdr = l3_targ_base + L3_TARG_STDERRLOG_CINFO_OPCODE;
112
		l3_targ_info = l3_targ_base + L3_TARG_STDERRLOG_CINFO_INFO;
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
		break;

	default:
		/* Nothing to be handled here as of now */
		return 0;
	}

	/* STDERRLOG_MSTADDR Stores the NTTP master address. */
	masterid = (readl_relaxed(l3_targ_mstaddr) &
		    l3->mst_addr_mask) >> __ffs(l3->mst_addr_mask);

	for (k = 0, master = l3->l3_masters; k < l3->num_masters;
	     k++, master++) {
		if (masterid == master->id) {
			master_name = master->name;
			break;
		}
	}

132 133
	op_code = readl_relaxed(l3_targ_hdr) & 0x7;

134 135 136 137 138 139 140
	m_req_info = readl_relaxed(l3_targ_info) & 0xF;
	snprintf(info_string, sizeof(info_string),
		 ": %s in %s mode during %s access",
		 (m_req_info & BIT(0)) ? "Opcode Fetch" : "Data Access",
		 (m_req_info & BIT(1)) ? "Supervisor" : "User",
		 (m_req_info & BIT(3)) ? "Debug" : "Functional");

141
	WARN(true,
142
	     "%s:L3 %s Error: MASTER %s TARGET %s (%s)%s%s\n",
143 144 145
	     dev_name(l3->dev),
	     err_description,
	     master_name, target_name,
146
	     l3_transaction_type[op_code],
147
	     err_string, info_string);
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175

	/* clear the std error log*/
	clear = std_err_main | CLEAR_STDERR_LOG;
	writel_relaxed(clear, l3_targ_stderr);

	return 0;
}

/**
 * l3_interrupt_handler() - interrupt handler for l3 events
 * @irq:	irq number
 * @_l3:	pointer to l3 structure
 *
 * Interrupt Handler for L3 error detection.
 *	1) Identify the L3 clockdomain partition to which the error belongs to.
 *	2) Identify the slave where the error information is logged
 *	... handle the slave event..
 *	7) if the slave is unknown, mask out the slave.
 */
static irqreturn_t l3_interrupt_handler(int irq, void *_l3)
{
	struct omap_l3 *l3 = _l3;
	int inttype, i, ret;
	int err_src = 0;
	u32 err_reg, mask_val;
	void __iomem *base, *mask_reg;
	struct l3_flagmux_data *flag_mux;

176
	/* Get the Type of interrupt */
177
	inttype = irq == l3->app_irq ? L3_APPLICATION_ERROR : L3_DEBUG_ERROR;
178

179
	for (i = 0; i < l3->num_modules; i++) {
180 181 182 183
		/*
		 * Read the regerr register of the clock domain
		 * to determine the source
		 */
184
		base = l3->l3_base[i];
185 186
		flag_mux = l3->l3_flagmux[i];
		err_reg = readl_relaxed(base + flag_mux->offset +
187
					L3_FLAGMUX_REGERR0 + (inttype << 3));
188

189 190 191
		err_reg &= ~(inttype ? flag_mux->mask_app_bits :
				flag_mux->mask_dbg_bits);

192 193 194
		/* Get the corresponding error and analyse */
		if (err_reg) {
			/* Identify the source from control status register */
195
			err_src = __ffs(err_reg);
196

197
			ret = l3_handle_target(l3, base, flag_mux, err_src);
198

199
			/*
200 201 202 203
			 * Certain plaforms may have "undocumented" status
			 * pending on boot. So dont generate a severe warning
			 * here. Just mask it off to prevent the error from
			 * reoccuring and locking up the system.
204
			 */
205
			if (ret) {
206 207 208 209 210
				dev_err(l3->dev,
					"L3 %s error: target %d mod:%d %s\n",
					inttype ? "debug" : "application",
					err_src, i, "(unclearable)");

211
				mask_reg = base + flag_mux->offset +
212 213 214 215
					   L3_FLAGMUX_MASK0 + (inttype << 3);
				mask_val = readl_relaxed(mask_reg);
				mask_val &= ~(1 << err_src);
				writel_relaxed(mask_val, mask_reg);
216 217 218 219 220 221

				/* Mark these bits as to be ignored */
				if (inttype)
					flag_mux->mask_app_bits |= 1 << err_src;
				else
					flag_mux->mask_dbg_bits |= 1 << err_src;
222 223
			}

224
			/* Error found so break the for loop */
225
			return IRQ_HANDLED;
226 227
		}
	}
228 229 230 231 232

	dev_err(l3->dev, "L3 %s IRQ not handled!!\n",
		inttype ? "debug" : "application");

	return IRQ_NONE;
233 234
}

235
static const struct of_device_id l3_noc_match[] = {
236 237
	{.compatible = "ti,omap4-l3-noc", .data = &omap4_l3_data},
	{.compatible = "ti,omap5-l3-noc", .data = &omap5_l3_data},
238
	{.compatible = "ti,dra7-l3-noc", .data = &dra_l3_data},
239
	{.compatible = "ti,am4372-l3-noc", .data = &am4372_l3_data},
240 241 242 243
	{},
};
MODULE_DEVICE_TABLE(of, l3_noc_match);

244
static int omap_l3_probe(struct platform_device *pdev)
245
{
246
	const struct of_device_id *of_id;
247
	static struct omap_l3 *l3;
248
	int ret, i, res_idx;
249

250 251 252 253 254 255
	of_id = of_match_device(l3_noc_match, &pdev->dev);
	if (!of_id) {
		dev_err(&pdev->dev, "OF data missing\n");
		return -EINVAL;
	}

256
	l3 = devm_kzalloc(&pdev->dev, sizeof(*l3), GFP_KERNEL);
257
	if (!l3)
258
		return -ENOMEM;
259

260
	memcpy(l3, of_id->data, sizeof(*l3));
261
	l3->dev = &pdev->dev;
262 263
	platform_set_drvdata(pdev, l3);

264
	/* Get mem resources */
265 266 267 268 269 270 271 272 273 274
	for (i = 0, res_idx = 0; i < l3->num_modules; i++) {
		struct resource	*res;

		if (l3->l3_base[i] == L3_BASE_IS_SUBMODULE) {
			/* First entry cannot be submodule */
			BUG_ON(i == 0);
			l3->l3_base[i] = l3->l3_base[i - 1];
			continue;
		}
		res = platform_get_resource(pdev, IORESOURCE_MEM, res_idx);
275 276
		l3->l3_base[i] = devm_ioremap_resource(&pdev->dev, res);
		if (IS_ERR(l3->l3_base[i])) {
277
			dev_err(l3->dev, "ioremap %d failed\n", i);
278 279
			return PTR_ERR(l3->l3_base[i]);
		}
280
		res_idx++;
281 282 283 284 285
	}

	/*
	 * Setup interrupt Handlers
	 */
286
	l3->debug_irq = platform_get_irq(pdev, 0);
287
	ret = devm_request_irq(l3->dev, l3->debug_irq, l3_interrupt_handler,
288
			       0x0, "l3-dbg-irq", l3);
289
	if (ret) {
290
		dev_err(l3->dev, "request_irq failed for %d\n",
291
			l3->debug_irq);
292
		return ret;
293 294
	}

295
	l3->app_irq = platform_get_irq(pdev, 1);
296
	ret = devm_request_irq(l3->dev, l3->app_irq, l3_interrupt_handler,
297
			       0x0, "l3-app-irq", l3);
298
	if (ret)
299
		dev_err(l3->dev, "request_irq failed for %d\n", l3->app_irq);
300

301 302 303
	return ret;
}

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
#ifdef	CONFIG_PM

/**
 * l3_resume_noirq() - resume function for l3_noc
 * @dev:	pointer to l3_noc device structure
 *
 * We only have the resume handler only since we
 * have already maintained the delta register
 * configuration as part of configuring the system
 */
static int l3_resume_noirq(struct device *dev)
{
	struct omap_l3 *l3 = dev_get_drvdata(dev);
	int i;
	struct l3_flagmux_data *flag_mux;
	void __iomem *base, *mask_regx = NULL;
	u32 mask_val;

	for (i = 0; i < l3->num_modules; i++) {
		base = l3->l3_base[i];
		flag_mux = l3->l3_flagmux[i];
		if (!flag_mux->mask_app_bits && !flag_mux->mask_dbg_bits)
			continue;

		mask_regx = base + flag_mux->offset + L3_FLAGMUX_MASK0 +
			   (L3_APPLICATION_ERROR << 3);
		mask_val = readl_relaxed(mask_regx);
		mask_val &= ~(flag_mux->mask_app_bits);

		writel_relaxed(mask_val, mask_regx);
		mask_regx = base + flag_mux->offset + L3_FLAGMUX_MASK0 +
			   (L3_DEBUG_ERROR << 3);
		mask_val = readl_relaxed(mask_regx);
		mask_val &= ~(flag_mux->mask_dbg_bits);

		writel_relaxed(mask_val, mask_regx);
	}

	/* Dummy read to force OCP barrier */
	if (mask_regx)
		(void)readl(mask_regx);

	return 0;
}

static const struct dev_pm_ops l3_dev_pm_ops = {
	.resume_noirq		= l3_resume_noirq,
};

#define L3_DEV_PM_OPS (&l3_dev_pm_ops)
#else
#define L3_DEV_PM_OPS NULL
#endif

358 359
static struct platform_driver omap_l3_driver = {
	.probe		= omap_l3_probe,
360 361
	.driver		= {
		.name		= "omap_l3_noc",
362
		.pm		= L3_DEV_PM_OPS,
363
		.of_match_table = of_match_ptr(l3_noc_match),
364 365 366
	},
};

367
static int __init omap_l3_init(void)
368
{
369
	return platform_driver_register(&omap_l3_driver);
370
}
371
postcore_initcall_sync(omap_l3_init);
372

373
static void __exit omap_l3_exit(void)
374
{
375
	platform_driver_unregister(&omap_l3_driver);
376
}
377
module_exit(omap_l3_exit);