Merge tag 'hwlock-v5.3' of git://github.com/andersson/remoteproc

Pull hwspinlock updates from Bjorn Andersson: "This contains support for hardware spinlock TI K3 AM65x and J721E family of SoCs, support for using hwspinlocks from atomic context and better error reporting when dealing with hardware disabled in DeviceTree" * tag 'hwlock-v5.3' of git://github.com/andersson/remoteproc: hwspinlock: add the 'in_atomic' API hwspinlock: document the hwspinlock 'raw' API hwspinlock: stm32: implement the relax() ops hwspinlock: ignore disabled device hwspinlock/omap: Add a trace during probe hwspinlock/omap: Add support for TI K3 SoCs dt-bindings: hwlock: Update OMAP binding for TI K3 SoCs

Linus Torvalds committed 7 years ago

Commit 57ab5f72 parents fdcec00 360aa647 files · +206 −22Browse files

Unified · Split

7 files

Documentation/devicetree/bindings/hwlock/omap-hwspinlock.txt +20 −5
Documentation/hwspinlock.txt +81 −0
drivers/hwspinlock/Kconfig +1 −1
drivers/hwspinlock/hwspinlock_core.c +35 −13
drivers/hwspinlock/omap_hwspinlock.c +4 −0
drivers/hwspinlock/stm32_hwspinlock.c +7 −0
include/linux/hwspinlock.h +58 −3

Documentation/devicetree/bindings/hwlock/omap-hwspinlock.txt+20−5

-OMAP4+ HwSpinlock Driver
+TI HwSpinlock for OMAP and K3 based SoCs
-========================
+=========================================
 Required properties:
-- compatible:		Should be "ti,omap4-hwspinlock" for
+- compatible:		Should be one of the following,
-			    OMAP44xx, OMAP54xx, AM33xx, AM43xx, DRA7xx SoCs
+			  "ti,omap4-hwspinlock" for
+				OMAP44xx, OMAP54xx, AM33xx, AM43xx, DRA7xx SoCs
+			  "ti,am654-hwspinlock" for
+				K3 AM65x and J721E SoCs
 - reg:			Contains the hwspinlock module register address space
 			(base address and length)
 - ti,hwmods:		Name of the hwmod associated with the hwspinlock device
+			(for OMAP architecture based SoCs only)
 - #hwlock-cells:	Should be 1. The OMAP hwspinlock users will use a
 			0-indexed relative hwlock number as the argument
 			specifier value for requesting a specific hwspinlock
 Example:
-/* OMAP4 */
+1. OMAP4 SoCs
 hwspinlock: spinlock@4a0f6000 {
 	compatible = "ti,omap4-hwspinlock";
 	reg = <0x4a0f6000 0x1000>;
 	ti,hwmods = "spinlock";
 	#hwlock-cells = <1>;
 };
+2. AM65x SoCs and J721E SoCs
+&cbass_main {
+	cbass_main_navss: interconnect0 {
+		hwspinlock: spinlock@30e00000 {
+			compatible = "ti,am654-hwspinlock";
+			reg = <0x00 0x30e00000 0x00 0x1000>;
+			#hwlock-cells = <1>;
+		};
+	};
+};

Documentation/hwspinlock.txt+81−0

@@ -134,6 +134,39 @@ notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs). · 133 unmodified lines
134		134
135	The function will never sleep.	135	The function will never sleep.
136		136
		137	::
		138
		139	int hwspin_lock_timeout_raw(struct hwspinlock *hwlock, unsigned int timeout);
		140
		141	Lock a previously-assigned hwspinlock with a timeout limit (specified in
		142	msecs). If the hwspinlock is already taken, the function will busy loop
		143	waiting for it to be released, but give up when the timeout elapses.
		144
		145	Caution: User must protect the routine of getting hardware lock with mutex
		146	or spinlock to avoid dead-lock, that will let user can do some time-consuming
		147	or sleepable operations under the hardware lock.
		148
		149	Returns 0 when successful and an appropriate error code otherwise (most
		150	notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs).
		151
		152	The function will never sleep.
		153
		154	::
		155
		156	int hwspin_lock_timeout_in_atomic(struct hwspinlock *hwlock, unsigned int to);
		157
		158	Lock a previously-assigned hwspinlock with a timeout limit (specified in
		159	msecs). If the hwspinlock is already taken, the function will busy loop
		160	waiting for it to be released, but give up when the timeout elapses.
		161
		162	This function shall be called only from an atomic context and the timeout
		163	value shall not exceed a few msecs.
		164
		165	Returns 0 when successful and an appropriate error code otherwise (most
		166	notably -ETIMEDOUT if the hwspinlock is still busy after timeout msecs).
		167
		168	The function will never sleep.
		169
137	::	170	::
138		171
139	int hwspin_trylock(struct hwspinlock *hwlock);	172	int hwspin_trylock(struct hwspinlock *hwlock);
@@ -184,6 +217,34 @@ Returns 0 on success and an appropriate error code otherwise (most · 44 unmodified lines
184	notably -EBUSY if the hwspinlock was already taken).	217	notably -EBUSY if the hwspinlock was already taken).
185	The function will never sleep.	218	The function will never sleep.
186		219
		220	::
		221
		222	int hwspin_trylock_raw(struct hwspinlock *hwlock);
		223
		224	Attempt to lock a previously-assigned hwspinlock, but immediately fail if
		225	it is already taken.
		226
		227	Caution: User must protect the routine of getting hardware lock with mutex
		228	or spinlock to avoid dead-lock, that will let user can do some time-consuming
		229	or sleepable operations under the hardware lock.
		230
		231	Returns 0 on success and an appropriate error code otherwise (most
		232	notably -EBUSY if the hwspinlock was already taken).
		233	The function will never sleep.
		234
		235	::
		236
		237	int hwspin_trylock_in_atomic(struct hwspinlock *hwlock);
		238
		239	Attempt to lock a previously-assigned hwspinlock, but immediately fail if
		240	it is already taken.
		241
		242	This function shall be called only from an atomic context.
		243
		244	Returns 0 on success and an appropriate error code otherwise (most
		245	notably -EBUSY if the hwspinlock was already taken).
		246	The function will never sleep.
		247
187	::	248	::
188		249
189	void hwspin_unlock(struct hwspinlock *hwlock);	250	void hwspin_unlock(struct hwspinlock *hwlock);
@@ -220,6 +281,26 @@ Upon a successful return from this function, preemption is reenabled, · 30 unmodified lines
220	and the state of the local interrupts is restored to the state saved at	281	and the state of the local interrupts is restored to the state saved at
221	the given flags. This function will never sleep.	282	the given flags. This function will never sleep.
222		283
		284	::
		285
		286	void hwspin_unlock_raw(struct hwspinlock *hwlock);
		287
		288	Unlock a previously-locked hwspinlock.
		289
		290	The caller should never unlock an hwspinlock which is already unlocked.
		291	Doing so is considered a bug (there is no protection against this).
		292	This function will never sleep.
		293
		294	::
		295
		296	void hwspin_unlock_in_atomic(struct hwspinlock *hwlock);
		297
		298	Unlock a previously-locked hwspinlock.
		299
		300	The caller should never unlock an hwspinlock which is already unlocked.
		301	Doing so is considered a bug (there is no protection against this).
		302	This function will never sleep.
		303
223	::	304	::
224		305
225	int hwspin_lock_get_id(struct hwspinlock *hwlock);	306	int hwspin_lock_get_id(struct hwspinlock *hwlock);

drivers/hwspinlock/Kconfig+1−1

@@ -9,7 +9,7 @@ menuconfig HWSPINLOCK · 8 unmodified lines
9	config HWSPINLOCK_OMAP	9	config HWSPINLOCK_OMAP
10	tristate "OMAP Hardware Spinlock device"	10	tristate "OMAP Hardware Spinlock device"
11	depends on HWSPINLOCK	11	depends on HWSPINLOCK
12	depends on ARCH_OMAP4 \|\| SOC_OMAP5 \|\| SOC_DRA7XX \|\| SOC_AM33XX \|\| SOC_AM43XX	12	depends on ARCH_OMAP4 \|\| SOC_OMAP5 \|\| SOC_DRA7XX \|\| SOC_AM33XX \|\| SOC_AM43XX \|\| ARCH_K3
13	help	13	help
14	Say y here to support the OMAP Hardware Spinlock device (firstly	14	Say y here to support the OMAP Hardware Spinlock device (firstly
15	introduced in OMAP4).	15	introduced in OMAP4).

drivers/hwspinlock/hwspinlock_core.c+35−13

 #define pr_fmt(fmt)    "%s: " fmt, __func__
+#include <linux/delay.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include "hwspinlock_internal.h"
+/* retry delay used in atomic context */
+#define HWSPINLOCK_RETRY_DELAY_US	100
 /* radix tree tags */
 #define HWSPINLOCK_UNUSED	(0) /* tags an hwspinlock as unused */
  * user need some time-consuming or sleepable operations under the hardware
  * lock, they need one sleepable lock (like mutex) to protect the operations.
  *
- * If the mode is not HWLOCK_RAW, upon a successful return from this function,
+ * If the mode is neither HWLOCK_IN_ATOMIC nor HWLOCK_RAW, upon a successful
- * preemption (and possibly interrupts) is disabled, so the caller must not
+ * return from this function, preemption (and possibly interrupts) is disabled,
- * sleep, and is advised to release the hwspinlock as soon as possible. This is
+ * so the caller must not sleep, and is advised to release the hwspinlock as
- * required in order to minimize remote cores polling on the hardware
+ * soon as possible. This is required in order to minimize remote cores polling
- * interconnect.
+ * on the hardware interconnect.
  *
  * The user decides whether local interrupts are disabled or not, and if yes,
  * whether he wants their previous state to be saved. It is up to the user
 		ret = spin_trylock_irq(&hwlock->lock);
 		break;
 	case HWLOCK_RAW:
+	case HWLOCK_IN_ATOMIC:
 		ret = 1;
 		break;
 	default:
 			spin_unlock_irq(&hwlock->lock);
 			break;
 		case HWLOCK_RAW:
+		case HWLOCK_IN_ATOMIC:
 			/* Nothing to do */
 			break;
 		default:
  * user need some time-consuming or sleepable operations under the hardware
  * lock, they need one sleepable lock (like mutex) to protect the operations.
  *
- * If the mode is not HWLOCK_RAW, upon a successful return from this function,
+ * If the mode is HWLOCK_IN_ATOMIC (called from an atomic context) the timeout
- * preemption is disabled (and possibly local interrupts, too), so the caller
+ * is handled with busy-waiting delays, hence shall not exceed few msecs.
- * must not sleep, and is advised to release the hwspinlock as soon as possible.
+ *
- * This is required in order to minimize remote cores polling on the
+ * If the mode is neither HWLOCK_IN_ATOMIC nor HWLOCK_RAW, upon a successful
- * hardware interconnect.
+ * return from this function, preemption (and possibly interrupts) is disabled,
+ * so the caller must not sleep, and is advised to release the hwspinlock as
+ * soon as possible. This is required in order to minimize remote cores polling
+ * on the hardware interconnect.
  *
  * The user decides whether local interrupts are disabled or not, and if yes,
  * whether he wants their previous state to be saved. It is up to the user
 					int mode, unsigned long *flags)
 {
 	int ret;
-	unsigned long expire;
+	unsigned long expire, atomic_delay = 0;
 	expire = msecs_to_jiffies(to) + jiffies;
 		 * The lock is already taken, let's check if the user wants
 		 * us to try again
 		 */
-		if (time_is_before_eq_jiffies(expire))
+		if (mode == HWLOCK_IN_ATOMIC) {
-			return -ETIMEDOUT;
+			udelay(HWSPINLOCK_RETRY_DELAY_US);
+			atomic_delay += HWSPINLOCK_RETRY_DELAY_US;
+			if (atomic_delay > to * 1000)
+				return -ETIMEDOUT;
+		} else {
+			if (time_is_before_eq_jiffies(expire))
+				return -ETIMEDOUT;
+		}
 		/*
 		 * Allow platform-specific relax handlers to prevent
 		spin_unlock_irq(&hwlock->lock);
 		break;
 	case HWLOCK_RAW:
+	case HWLOCK_IN_ATOMIC:
 		/* Nothing to do */
 		break;
 	default:
 	if (ret)
 		return ret;
+	if (!of_device_is_available(args.np)) {
+		ret = -ENOENT;
+		goto out;
+	}
 	/* Find the hwspinlock device: we need its base_id */
 	ret = -EPROBE_DEFER;
 	rcu_read_lock();

drivers/hwspinlock/omap_hwspinlock.c+4−0

 	if (ret)
 		goto reg_fail;
+	dev_dbg(&pdev->dev, "Registered %d locks with HwSpinlock core\n",
+		num_locks);
 	return 0;
 reg_fail:
 static const struct of_device_id omap_hwspinlock_of_match[] = {
 	{ .compatible = "ti,omap4-hwspinlock", },
+	{ .compatible = "ti,am654-hwspinlock", },
 	{ /* end */ },
 };
 MODULE_DEVICE_TABLE(of, omap_hwspinlock_of_match);

drivers/hwspinlock/stm32_hwspinlock.c+7−0

  */
 #include <linux/clk.h>
+#include <linux/delay.h>
 #include <linux/hwspinlock.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
 	writel(STM32_MUTEX_COREID, lock_addr);
 }
+static void stm32_hwspinlock_relax(struct hwspinlock *lock)
+{
+	ndelay(50);
+}
 static const struct hwspinlock_ops stm32_hwspinlock_ops = {
 	.trylock	= stm32_hwspinlock_trylock,
 	.unlock		= stm32_hwspinlock_unlock,
+	.relax		= stm32_hwspinlock_relax,
 };
 static int stm32_hwspinlock_probe(struct platform_device *pdev)

include/linux/hwspinlock.h+58−3

@@ -14,9 +14,10 @@ · 13 unmodified lines
14	#include <linux/sched.h>	14	#include <linux/sched.h>
15		15
16	/* hwspinlock mode argument */	16	/* hwspinlock mode argument */
17	#define HWLOCK_IRQSTATE 0x01 /* Disable interrupts, save state */	17	#define HWLOCK_IRQSTATE 0x01 /* Disable interrupts, save state */
18	#define HWLOCK_IRQ 0x02 /* Disable interrupts, don't save state */	18	#define HWLOCK_IRQ 0x02 /* Disable interrupts, don't save state */
19	#define HWLOCK_RAW 0x03	19	#define HWLOCK_RAW 0x03
		20	#define HWLOCK_IN_ATOMIC 0x04 /* Called while in atomic context */
20		21
21	struct device;	22	struct device;
22	struct device_node;	23	struct device_node;
@@ -222,6 +223,23 @@ static inline int hwspin_trylock_raw(struct hwspinlock *hwlock) · 199 unmodified lines
222	return __hwspin_trylock(hwlock, HWLOCK_RAW, NULL);	223	return __hwspin_trylock(hwlock, HWLOCK_RAW, NULL);
223	}	224	}
224		225
		226	/**
		227	* hwspin_trylock_in_atomic() - attempt to lock a specific hwspinlock
		228	* @hwlock: an hwspinlock which we want to trylock
		229	*
		230	* This function attempts to lock an hwspinlock, and will immediately fail
		231	* if the hwspinlock is already taken.
		232	*
		233	* This function shall be called only from an atomic context.
		234	*
		235	* Returns 0 if we successfully locked the hwspinlock, -EBUSY if
		236	* the hwspinlock was already taken, and -EINVAL if @hwlock is invalid.
		237	*/
		238	static inline int hwspin_trylock_in_atomic(struct hwspinlock *hwlock)
		239	{
		240	return __hwspin_trylock(hwlock, HWLOCK_IN_ATOMIC, NULL);
		241	}
		242
225	/**	243	/**
226	* hwspin_trylock() - attempt to lock a specific hwspinlock	244	* hwspin_trylock() - attempt to lock a specific hwspinlock
227	* @hwlock: an hwspinlock which we want to trylock	245	* @hwlock: an hwspinlock which we want to trylock
@@ -312,6 +330,28 @@ int hwspin_lock_timeout_raw(struct hwspinlock *hwlock, unsigned int to) · 84 unmodified lines
312	return __hwspin_lock_timeout(hwlock, to, HWLOCK_RAW, NULL);	330	return __hwspin_lock_timeout(hwlock, to, HWLOCK_RAW, NULL);
313	}	331	}
314		332
		333	/**
		334	* hwspin_lock_timeout_in_atomic() - lock an hwspinlock with timeout limit
		335	* @hwlock: the hwspinlock to be locked
		336	* @to: timeout value in msecs
		337	*
		338	* This function locks the underlying @hwlock. If the @hwlock
		339	* is already taken, the function will busy loop waiting for it to
		340	* be released, but give up when @timeout msecs have elapsed.
		341	*
		342	* This function shall be called only from an atomic context and the timeout
		343	* value shall not exceed a few msecs.
		344	*
		345	* Returns 0 when the @hwlock was successfully taken, and an appropriate
		346	* error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still
		347	* busy after @timeout msecs). The function will never sleep.
		348	*/
		349	static inline
		350	int hwspin_lock_timeout_in_atomic(struct hwspinlock *hwlock, unsigned int to)
		351	{
		352	return __hwspin_lock_timeout(hwlock, to, HWLOCK_IN_ATOMIC, NULL);
		353	}
		354
315	/**	355	/**
316	* hwspin_lock_timeout() - lock an hwspinlock with timeout limit	356	* hwspin_lock_timeout() - lock an hwspinlock with timeout limit
317	* @hwlock: the hwspinlock to be locked	357	* @hwlock: the hwspinlock to be locked
@@ -386,6 +426,21 @@ static inline void hwspin_unlock_raw(struct hwspinlock *hwlock) · 68 unmodified lines
386	__hwspin_unlock(hwlock, HWLOCK_RAW, NULL);	426	__hwspin_unlock(hwlock, HWLOCK_RAW, NULL);
387	}	427	}
388		428
		429	/**
		430	* hwspin_unlock_in_atomic() - unlock hwspinlock
		431	* @hwlock: a previously-acquired hwspinlock which we want to unlock
		432	*
		433	* This function will unlock a specific hwspinlock.
		434	*
		435	* @hwlock must be already locked (e.g. by hwspin_trylock()) before calling
		436	* this function: it is a bug to call unlock on a @hwlock that is already
		437	* unlocked.
		438	*/
		439	static inline void hwspin_unlock_in_atomic(struct hwspinlock *hwlock)
		440	{
		441	__hwspin_unlock(hwlock, HWLOCK_IN_ATOMIC, NULL);
		442	}
		443
389	/**	444	/**
390	* hwspin_unlock() - unlock hwspinlock	445	* hwspin_unlock() - unlock hwspinlock
391	* @hwlock: a previously-acquired hwspinlock which we want to unlock	446	* @hwlock: a previously-acquired hwspinlock which we want to unlock

Merge tag 'hwlock-v5.3' of git://github.com/andersson/remoteproc

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code