redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

hwspinlock updates for v4.19 

This introduces devres helpers and an API to request a lock by name,
 then migrates the sprd SPI driver to use these.
 -----BEGIN PGP SIGNATURE-----
 
 iQJPBAABCAA5FiEEBd4DzF816k8JZtUlCx85Pw2ZrcUFAlt3P8obHGJqb3JuLmFu
 ZGVyc3NvbkBsaW5hcm8ub3JnAAoJEAsfOT8Nma3FlMYQAMn/GJ6HrmuvamXFVNRc
 33iExGw0c2a1WL0LN1Fe/rNkOOApb8+smaf053aqFOfcjhsxOeeFvKOuMrkLzpmL
 o7Ls9EFhLUwwRAfPaSOM+AQtaxm0ZhKrE6hY5W03cfVcA7JOd6q6qatx1Nx/G7bB
 KKxDmWvZ0fO+DQhaVKc1maaAiwpJFmIWU8HSaRzoupf/+ETz+Blro5dy7QQuiDx8
 xe8uKAEoIjeuscZZx0huuHVO5jw0dMH70mU2l+N27B7MhzU+v/X95G4GjeTsiu3u
 6ZDQWgMPWhD8FBuUSgeNJ3O6zeKRuUfZ+qhn67lqdRzhvEeGhoB2JEFR3elaNiJB
 W8BWb6N34Ysq8Z+fY4CzQRzEA9bonp3IDBGoh9wPPm8+10NZH2OHEeyeO5ftYuW6
 uiLCGnf3Rm2Z0jN5iEJncJwHDNRcIFqwobOBEv8t6Ja8w3KlaaVPDrJ24tbn+GoW
 Oz5Y9j/mic0VESpZJd96eS/GfVg7MfNY8oufOnm4irUAFXPhcBYGkL6xUwnQzSiy
 356HKSI4iIUUEZul/9QBDCNHcGKfAcgRkcJJY6zoagnHoB5DVbTQuS/se+eSqhFe
 nCkcbW/+bGiXoT9RiOhWrOcooS77R3CCrbFHAUv3VTyv0tvw01YFelorP6o7mCsK
 rb6nj7/eCzXz0MyA2BdTfVQ5
 =zanh
 -----END PGP SIGNATURE-----

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
hifive-unleashed-5.1
Linus Torvalds 2018-08-18 16:45:27 -07:00
parent 9a96d63aa8 ddb34f480d
commit 7f02e1ce4a
3 changed files with 262 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
drivers/hwspinlock/hwspinlock_core.c
View File

@ -367,6 +367,35 @@ out:
}
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 @@ out:
}
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>");

11
drivers/spi/spi-sprd-adi.c
View File

@ -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;
}

37
include/linux/hwspinlock.h
View File

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