Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7f02e1ce authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'hwlock-v4.19' of git://github.com/andersson/remoteproc 

Pull hwspinlock updates from Bjorn Andersson:
 "This introduces devres helpers and an API to request a lock by name,
  then migrates the sprd SPI driver to use these"

* tag 'hwlock-v4.19' of git://github.com/andersson/remoteproc:
  hwspinlock: Fix incorrect return pointers
  spi: sprd: Change to use devm_hwspin_lock_request_specific()
  spi: sprd: Replace of_hwspin_lock_get_id() with of_hwspin_lock_get_id_byname()
  hwspinlock: Fix one comment mistake
  hwspinlock: Remove redundant config
  hwspinlock: Add devm_xxx() APIs to register/unregister one hwlock controller
  hwspinlock: Add devm_xxx() APIs to request/free hwlock
  hwspinlock: Add one new API to support getting a specific hwlock by the name
parents 9a96d63a ddb34f48

drivers/hwspinlock/hwspinlock_core.c

+222 −1
Original line number Diff line number Diff line
@@ -367,6 +367,35 @@ int of_hwspin_lock_get_id(struct device_node *np, int index) 
}

EXPORT_SYMBOL_GPL(of_hwspin_lock_get_id);



/**

 * of_hwspin_lock_get_id_byname() - get lock id for an specified hwlock name

 * @np: device node from which to request the specific hwlock

 * @name: hwlock name

 *

 * This function provides a means for DT users of the hwspinlock module to

 * get the global lock id of a specific hwspinlock using the specified name of

 * the hwspinlock device, so that it can be requested using the normal

 * hwspin_lock_request_specific() API.

 *

 * Returns the global lock id number on success, -EPROBE_DEFER if the hwspinlock

 * device is not yet registered, -EINVAL on invalid args specifier value or an

 * appropriate error as returned from the OF parsing of the DT client node.

 */

int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name)

{

	int index;



	if (!name)

		return -EINVAL;



	index = of_property_match_string(np, "hwlock-names", name);

	if (index < 0)

		return index;



	return of_hwspin_lock_get_id(np, index);

}

EXPORT_SYMBOL_GPL(of_hwspin_lock_get_id_byname);



static int hwspin_lock_register_single(struct hwspinlock *hwlock, int id)

{

	struct hwspinlock *tmp;
@@ -500,6 +529,88 @@ int hwspin_lock_unregister(struct hwspinlock_device *bank) 
}

EXPORT_SYMBOL_GPL(hwspin_lock_unregister);



static void devm_hwspin_lock_unreg(struct device *dev, void *res)

{

	hwspin_lock_unregister(*(struct hwspinlock_device **)res);

}



static int devm_hwspin_lock_device_match(struct device *dev, void *res,

					 void *data)

{

	struct hwspinlock_device **bank = res;



	if (WARN_ON(!bank || !*bank))

		return 0;



	return *bank == data;

}



/**

 * devm_hwspin_lock_unregister() - unregister an hw spinlock device for

 *				   a managed device

 * @dev: the backing device

 * @bank: the hwspinlock device, which usually provides numerous hw locks

 *

 * This function should be called from the underlying platform-specific

 * implementation, to unregister an existing (and unused) hwspinlock.

 *

 * Should be called from a process context (might sleep)

 *

 * Returns 0 on success, or an appropriate error code on failure

 */

int devm_hwspin_lock_unregister(struct device *dev,

				struct hwspinlock_device *bank)

{

	int ret;



	ret = devres_release(dev, devm_hwspin_lock_unreg,

			     devm_hwspin_lock_device_match, bank);

	WARN_ON(ret);



	return ret;

}

EXPORT_SYMBOL_GPL(devm_hwspin_lock_unregister);



/**

 * devm_hwspin_lock_register() - register a new hw spinlock device for

 *				 a managed device

 * @dev: the backing device

 * @bank: the hwspinlock device, which usually provides numerous hw locks

 * @ops: hwspinlock handlers for this device

 * @base_id: id of the first hardware spinlock in this bank

 * @num_locks: number of hwspinlocks provided by this device

 *

 * This function should be called from the underlying platform-specific

 * implementation, to register a new hwspinlock device instance.

 *

 * Should be called from a process context (might sleep)

 *

 * Returns 0 on success, or an appropriate error code on failure

 */

int devm_hwspin_lock_register(struct device *dev,

			      struct hwspinlock_device *bank,

			      const struct hwspinlock_ops *ops,

			      int base_id, int num_locks)

{

	struct hwspinlock_device **ptr;

	int ret;



	ptr = devres_alloc(devm_hwspin_lock_unreg, sizeof(*ptr), GFP_KERNEL);

	if (!ptr)

		return -ENOMEM;



	ret = hwspin_lock_register(bank, dev, ops, base_id, num_locks);

	if (!ret) {

		*ptr = bank;

		devres_add(dev, ptr);

	} else {

		devres_free(ptr);

	}



	return ret;

}

EXPORT_SYMBOL_GPL(devm_hwspin_lock_register);



/**

 * __hwspin_lock_request() - tag an hwspinlock as used and power it up

 *
@@ -656,7 +767,7 @@ EXPORT_SYMBOL_GPL(hwspin_lock_request_specific); 
 *

 * This function mark @hwlock as free again.

 * Should only be called with an @hwlock that was retrieved from

 * an earlier call to omap_hwspin_lock_request{_specific}.

 * an earlier call to hwspin_lock_request{_specific}.

 *

 * Should be called from a process context (might sleep)

 *
@@ -706,6 +817,116 @@ int hwspin_lock_free(struct hwspinlock *hwlock) 
}

EXPORT_SYMBOL_GPL(hwspin_lock_free);



static int devm_hwspin_lock_match(struct device *dev, void *res, void *data)

{

	struct hwspinlock **hwlock = res;



	if (WARN_ON(!hwlock || !*hwlock))

		return 0;



	return *hwlock == data;

}



static void devm_hwspin_lock_release(struct device *dev, void *res)

{

	hwspin_lock_free(*(struct hwspinlock **)res);

}



/**

 * devm_hwspin_lock_free() - free a specific hwspinlock for a managed device

 * @dev: the device to free the specific hwspinlock

 * @hwlock: the specific hwspinlock to free

 *

 * This function mark @hwlock as free again.

 * Should only be called with an @hwlock that was retrieved from

 * an earlier call to hwspin_lock_request{_specific}.

 *

 * Should be called from a process context (might sleep)

 *

 * Returns 0 on success, or an appropriate error code on failure

 */

int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock)

{

	int ret;



	ret = devres_release(dev, devm_hwspin_lock_release,

			     devm_hwspin_lock_match, hwlock);

	WARN_ON(ret);



	return ret;

}

EXPORT_SYMBOL_GPL(devm_hwspin_lock_free);



/**

 * devm_hwspin_lock_request() - request an hwspinlock for a managed device

 * @dev: the device to request an hwspinlock

 *

 * This function should be called by users of the hwspinlock device,

 * in order to dynamically assign them an unused hwspinlock.

 * Usually the user of this lock will then have to communicate the lock's id

 * to the remote core before it can be used for synchronization (to get the

 * id of a given hwlock, use hwspin_lock_get_id()).

 *

 * Should be called from a process context (might sleep)

 *

 * Returns the address of the assigned hwspinlock, or NULL on error

 */

struct hwspinlock *devm_hwspin_lock_request(struct device *dev)

{

	struct hwspinlock **ptr, *hwlock;



	ptr = devres_alloc(devm_hwspin_lock_release, sizeof(*ptr), GFP_KERNEL);

	if (!ptr)

		return NULL;



	hwlock = hwspin_lock_request();

	if (hwlock) {

		*ptr = hwlock;

		devres_add(dev, ptr);

	} else {

		devres_free(ptr);

	}



	return hwlock;

}

EXPORT_SYMBOL_GPL(devm_hwspin_lock_request);



/**

 * devm_hwspin_lock_request_specific() - request for a specific hwspinlock for

 *					 a managed device

 * @dev: the device to request the specific hwspinlock

 * @id: index of the specific hwspinlock that is requested

 *

 * This function should be called by users of the hwspinlock module,

 * in order to assign them a specific hwspinlock.

 * Usually early board code will be calling this function in order to

 * reserve specific hwspinlock ids for predefined purposes.

 *

 * Should be called from a process context (might sleep)

 *

 * Returns the address of the assigned hwspinlock, or NULL on error

 */

struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev,

						     unsigned int id)

{

	struct hwspinlock **ptr, *hwlock;



	ptr = devres_alloc(devm_hwspin_lock_release, sizeof(*ptr), GFP_KERNEL);

	if (!ptr)

		return NULL;



	hwlock = hwspin_lock_request_specific(id);

	if (hwlock) {

		*ptr = hwlock;

		devres_add(dev, ptr);

	} else {

		devres_free(ptr);

	}



	return hwlock;

}

EXPORT_SYMBOL_GPL(devm_hwspin_lock_request_specific);



MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("Hardware spinlock interface");

MODULE_AUTHOR("Ohad Ben-Cohen <ohad@wizery.com>");

drivers/spi/spi-sprd-adi.c

+4 −7
Original line number Diff line number Diff line
@@ -459,13 +459,13 @@ static int sprd_adi_probe(struct platform_device *pdev) 
	sadi->slave_pbase = res->start + ADI_SLAVE_OFFSET;

	sadi->ctlr = ctlr;

	sadi->dev = &pdev->dev;

	ret = of_hwspin_lock_get_id(np, 0);

	ret = of_hwspin_lock_get_id_byname(np, "adi");

	if (ret < 0) {

		dev_err(&pdev->dev, "can not get the hardware spinlock\n");

		goto put_ctlr;

	}



	sadi->hwlock = hwspin_lock_request_specific(ret);

	sadi->hwlock = devm_hwspin_lock_request_specific(&pdev->dev, ret);

	if (!sadi->hwlock) {

		ret = -ENXIO;

		goto put_ctlr;
@@ -483,7 +483,7 @@ static int sprd_adi_probe(struct platform_device *pdev) 
	ret = devm_spi_register_controller(&pdev->dev, ctlr);

	if (ret) {

		dev_err(&pdev->dev, "failed to register SPI controller\n");

		goto free_hwlock;

		goto put_ctlr;

	}



	sadi->restart_handler.notifier_call = sprd_adi_restart_handler;
@@ -491,13 +491,11 @@ static int sprd_adi_probe(struct platform_device *pdev) 
	ret = register_restart_handler(&sadi->restart_handler);

	if (ret) {

		dev_err(&pdev->dev, "can not register restart handler\n");

		goto free_hwlock;

		goto put_ctlr;

	}



	return 0;



free_hwlock:

	hwspin_lock_free(sadi->hwlock);

put_ctlr:

	spi_controller_put(ctlr);

	return ret;
@@ -509,7 +507,6 @@ static int sprd_adi_remove(struct platform_device *pdev) 
	struct sprd_adi *sadi = spi_controller_get_devdata(ctlr);



	unregister_restart_handler(&sadi->restart_handler);

	hwspin_lock_free(sadi->hwlock);

	return 0;

}

include/linux/hwspinlock.h

+36 −1
Original line number Diff line number Diff line
@@ -52,7 +52,7 @@ struct hwspinlock_pdata { 
	int base_id;

};



#if defined(CONFIG_HWSPINLOCK) || defined(CONFIG_HWSPINLOCK_MODULE)

#ifdef CONFIG_HWSPINLOCK



int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,

		const struct hwspinlock_ops *ops, int base_id, int num_locks);
@@ -66,6 +66,17 @@ int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int, 
							unsigned long *);

int __hwspin_trylock(struct hwspinlock *, int, unsigned long *);

void __hwspin_unlock(struct hwspinlock *, int, unsigned long *);

int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name);

int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock);

struct hwspinlock *devm_hwspin_lock_request(struct device *dev);

struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev,

						     unsigned int id);

int devm_hwspin_lock_unregister(struct device *dev,

				struct hwspinlock_device *bank);

int devm_hwspin_lock_register(struct device *dev,

			      struct hwspinlock_device *bank,

			      const struct hwspinlock_ops *ops,

			      int base_id, int num_locks);



#else /* !CONFIG_HWSPINLOCK */
@@ -125,6 +136,30 @@ static inline int hwspin_lock_get_id(struct hwspinlock *hwlock) 
	return 0;

}



static inline

int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name)

{

	return 0;

}



static inline

int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock)

{

	return 0;

}



static inline struct hwspinlock *devm_hwspin_lock_request(struct device *dev)

{

	return ERR_PTR(-ENODEV);

}



static inline

struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev,

						     unsigned int id)

{

	return ERR_PTR(-ENODEV);

}



#endif /* !CONFIG_HWSPINLOCK */



/**