Commit e4be3f3a authored by Nishanth Menon's avatar Nishanth Menon
Browse files

bus: omap_l3_noc: improve readability by using helper for slave event parsing 



Current interrupt handler does the first level parse to identify the
slave and then handles the slave even identification, reporting and
clearing of event as well. It is hence logical to split the handler
into two where the primary handler just parses the flagmux till it
identifies a slave and the slave handling, reporting and clearing is
done in a helper function.

While at it update the documentation in kerneldoc style.

Signed-off-by: default avatarNishanth Menon <nm@ti.com>
Acked-by: default avatarSantosh Shilimkar <santosh.shilimkar@ti.com>
Acked-by: default avatarPeter Ujfalusi <peter.ujfalusi@ti.com>
Tested-by: default avatarDarren Etheridge <detheridge@ti.com>
Tested-by: default avatarSekhar Nori <nsekhar@ti.com>
parent c98aa7aa

drivers/bus/omap_l3_noc.c

+113 −98
Original line number Diff line number Diff line
@@ -26,14 +26,20 @@ 


#include "omap_l3_noc.h"



/*

 * 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

 *	3) Print the logged information.

 *	4) Add dump stack to provide kernel trace.

/**

 * 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)

 *

 * Two Types of errors :

 * 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:

 *	1) Custom errors in L3 :

 *		Target like DMM/FW/EMIF generates SRESP=ERR error

 *	2) Standard L3 error:
@@ -49,42 +55,19 @@ 
 *	can be trapped as well. But the trapping is implemented as part

 *	secure software and hence need not be implemented here.

 */

static irqreturn_t l3_interrupt_handler(int irq, void *_l3)

static int l3_handle_target(struct omap_l3 *l3, void __iomem *base,

			    struct l3_flagmux_data *flag_mux, int err_src)

{



	struct omap_l3 *l3 = _l3;

	int inttype, i, k;

	int err_src = 0;

	u32 std_err_main, err_reg, clear, masterid;

	void __iomem *base, *l3_targ_base;

	int k;

	u32 std_err_main, clear, masterid;

	void __iomem *l3_targ_base;

	void __iomem *l3_targ_stderr, *l3_targ_slvofslsb, *l3_targ_mstaddr;

	char *target_name, *master_name = "UN IDENTIFIED";

	struct l3_target_data *l3_targ_inst;

	struct l3_flagmux_data *flag_mux;

	struct l3_masters_data *master;

	char *target_name, *master_name = "UN IDENTIFIED";

	char *err_description;

	char err_string[30] = { 0 };



	/* Get the Type of interrupt */

	inttype = irq == l3->app_irq ? L3_APPLICATION_ERROR : L3_DEBUG_ERROR;



	for (i = 0; i < l3->num_modules; i++) {

		/*

		 * Read the regerr register of the clock domain

		 * to determine the source

		 */

		base = l3->l3_base[i];

		flag_mux = l3->l3_flagmux[i];

		err_reg = readl_relaxed(base + flag_mux->offset +

					L3_FLAGMUX_REGERR0 + (inttype << 3));



		/* Get the corresponding error and analyse */

		if (err_reg) {

			bool std_err = true;



			/* Identify the source from control status register */

			err_src = __ffs(err_reg);



	/* We DONOT expect err_src to go out of bounds */

	BUG_ON(err_src > MAX_CLKDM_TARGETS);
@@ -96,37 +79,12 @@ static irqreturn_t l3_interrupt_handler(int irq, void *_l3) 
		target_name = L3_TARGET_NOT_SUPPORTED;

	}



			/*

			 * If we do not know of a register offset to decode

			 * and clear, then mask.

			 */

			if (target_name == L3_TARGET_NOT_SUPPORTED) {

				u32 mask_val;

				void __iomem *mask_reg;



				/*

				 * Certain plaforms may have "undocumented"

				 * status pending on boot.. So dont generate

				 * a severe warning here.

				 */

				dev_err(l3->dev,

					"L3 %s error: target %d mod:%d %s\n",

					inttype ? "debug" : "application",

					err_src, i, "(unclearable)");



				mask_reg = base + flag_mux->offset +

					   L3_FLAGMUX_MASK0 + (inttype << 3);

				mask_val = readl_relaxed(mask_reg);

				mask_val &= ~(1 << err_src);

				writel_relaxed(mask_val, mask_reg);



				break;

			}

	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;

	l3_targ_slvofslsb = l3_targ_base + L3_TARG_STDERRLOG_SLVOFSLSB;



	std_err_main = readl_relaxed(l3_targ_stderr);
@@ -137,8 +95,7 @@ static irqreturn_t l3_interrupt_handler(int irq, void *_l3) 
			 ": At Address: 0x%08X ",

			 readl_relaxed(l3_targ_slvofslsb));



				l3_targ_mstaddr = l3_targ_base +

						L3_TARG_STDERRLOG_MSTADDR;

		l3_targ_mstaddr = l3_targ_base + L3_TARG_STDERRLOG_MSTADDR;

		break;



	case CUSTOM_ERROR:
@@ -149,21 +106,16 @@ static irqreturn_t l3_interrupt_handler(int irq, void *_l3) 
		break;



	default:

				std_err = false;

		/* Nothing to be handled here as of now */

				break;

		return 0;

	}



			if (!std_err)

				break;



	/* STDERRLOG_MSTADDR Stores the NTTP master address. */

	masterid = (readl_relaxed(l3_targ_mstaddr) &

				    l3->mst_addr_mask) >>

					__ffs(l3->mst_addr_mask);

		    l3->mst_addr_mask) >> __ffs(l3->mst_addr_mask);



			for (k = 0, master = l3->l3_masters;

			     k < l3->num_masters; k++, master++) {

	for (k = 0, master = l3->l3_masters; k < l3->num_masters;

	     k++, master++) {

		if (masterid == master->id) {

			master_name = master->name;

			break;
@@ -176,10 +128,73 @@ static irqreturn_t l3_interrupt_handler(int irq, void *_l3) 
	     err_description,

	     master_name, target_name,

	     err_string);



	/* 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;



	/* Get the Type of interrupt */

	inttype = irq == l3->app_irq ? L3_APPLICATION_ERROR : L3_DEBUG_ERROR;



	for (i = 0; i < l3->num_modules; i++) {

		/*

		 * Read the regerr register of the clock domain

		 * to determine the source

		 */

		base = l3->l3_base[i];

		flag_mux = l3->l3_flagmux[i];

		err_reg = readl_relaxed(base + flag_mux->offset +

					L3_FLAGMUX_REGERR0 + (inttype << 3));



		/* Get the corresponding error and analyse */

		if (err_reg) {

			/* Identify the source from control status register */

			err_src = __ffs(err_reg);



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



			/*

			 * 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.

			 */

			if (ret) {

				dev_err(l3->dev,

					"L3 %s error: target %d mod:%d %s\n",

					inttype ? "debug" : "application",

					err_src, i, "(unclearable)");



				mask_reg = base + flag_mux->offset +

					   L3_FLAGMUX_MASK0 + (inttype << 3);

				mask_val = readl_relaxed(mask_reg);

				mask_val &= ~(1 << err_src);

				writel_relaxed(mask_val, mask_reg);

			}



			/* Error found so break the for loop */

			break;

		}

CRA Git | Maintained and supported by SUSTech CRA and CCSE