Merge remote-tracking branch 'regmap/topic/lock' into regmap-next
This commit is contained in:
commit
db760fbecd
|
@ -39,14 +39,12 @@ struct regmap_format {
|
|||
unsigned int (*parse_val)(void *buf);
|
||||
};
|
||||
|
||||
typedef void (*regmap_lock)(struct regmap *map);
|
||||
typedef void (*regmap_unlock)(struct regmap *map);
|
||||
|
||||
struct regmap {
|
||||
struct mutex mutex;
|
||||
spinlock_t spinlock;
|
||||
regmap_lock lock;
|
||||
regmap_unlock unlock;
|
||||
void *lock_arg; /* This is passed to lock/unlock functions */
|
||||
|
||||
struct device *dev; /* Device we do I/O on */
|
||||
void *work_buf; /* Scratch buffer used to format I/O */
|
||||
|
|
|
@ -214,23 +214,27 @@ static unsigned int regmap_parse_32_native(void *buf)
|
|||
return *(u32 *)buf;
|
||||
}
|
||||
|
||||
static void regmap_lock_mutex(struct regmap *map)
|
||||
static void regmap_lock_mutex(void *__map)
|
||||
{
|
||||
struct regmap *map = __map;
|
||||
mutex_lock(&map->mutex);
|
||||
}
|
||||
|
||||
static void regmap_unlock_mutex(struct regmap *map)
|
||||
static void regmap_unlock_mutex(void *__map)
|
||||
{
|
||||
struct regmap *map = __map;
|
||||
mutex_unlock(&map->mutex);
|
||||
}
|
||||
|
||||
static void regmap_lock_spinlock(struct regmap *map)
|
||||
static void regmap_lock_spinlock(void *__map)
|
||||
{
|
||||
struct regmap *map = __map;
|
||||
spin_lock(&map->spinlock);
|
||||
}
|
||||
|
||||
static void regmap_unlock_spinlock(struct regmap *map)
|
||||
static void regmap_unlock_spinlock(void *__map)
|
||||
{
|
||||
struct regmap *map = __map;
|
||||
spin_unlock(&map->spinlock);
|
||||
}
|
||||
|
||||
|
@ -335,14 +339,21 @@ struct regmap *regmap_init(struct device *dev,
|
|||
goto err;
|
||||
}
|
||||
|
||||
if (bus->fast_io) {
|
||||
spin_lock_init(&map->spinlock);
|
||||
map->lock = regmap_lock_spinlock;
|
||||
map->unlock = regmap_unlock_spinlock;
|
||||
if (config->lock && config->unlock) {
|
||||
map->lock = config->lock;
|
||||
map->unlock = config->unlock;
|
||||
map->lock_arg = config->lock_arg;
|
||||
} else {
|
||||
mutex_init(&map->mutex);
|
||||
map->lock = regmap_lock_mutex;
|
||||
map->unlock = regmap_unlock_mutex;
|
||||
if (bus->fast_io) {
|
||||
spin_lock_init(&map->spinlock);
|
||||
map->lock = regmap_lock_spinlock;
|
||||
map->unlock = regmap_unlock_spinlock;
|
||||
} else {
|
||||
mutex_init(&map->mutex);
|
||||
map->lock = regmap_lock_mutex;
|
||||
map->unlock = regmap_unlock_mutex;
|
||||
}
|
||||
map->lock_arg = map;
|
||||
}
|
||||
map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
|
||||
map->format.pad_bytes = config->pad_bits / 8;
|
||||
|
@ -994,11 +1005,11 @@ int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
|
|||
if (reg % map->reg_stride)
|
||||
return -EINVAL;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
ret = _regmap_write(map, reg, val);
|
||||
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1030,11 +1041,11 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
|
|||
if (reg % map->reg_stride)
|
||||
return -EINVAL;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
ret = _regmap_raw_write(map, reg, val, val_len);
|
||||
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1066,7 +1077,7 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
|
|||
if (reg % map->reg_stride)
|
||||
return -EINVAL;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
/* No formatting is require if val_byte is 1 */
|
||||
if (val_bytes == 1) {
|
||||
|
@ -1102,7 +1113,7 @@ int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
|
|||
kfree(wval);
|
||||
|
||||
out:
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(regmap_bulk_write);
|
||||
|
@ -1197,11 +1208,11 @@ int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
|
|||
if (reg % map->reg_stride)
|
||||
return -EINVAL;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
ret = _regmap_read(map, reg, val);
|
||||
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1231,7 +1242,7 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
|
|||
if (reg % map->reg_stride)
|
||||
return -EINVAL;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
|
||||
map->cache_type == REGCACHE_NONE) {
|
||||
|
@ -1253,7 +1264,7 @@ int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
|
|||
}
|
||||
|
||||
out:
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1360,9 +1371,9 @@ int regmap_update_bits(struct regmap *map, unsigned int reg,
|
|||
bool change;
|
||||
int ret;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
ret = _regmap_update_bits(map, reg, mask, val, &change);
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -1386,9 +1397,9 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
|
|||
{
|
||||
int ret;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
ret = _regmap_update_bits(map, reg, mask, val, change);
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(regmap_update_bits_check);
|
||||
|
@ -1417,7 +1428,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
|
|||
if (map->patch)
|
||||
return -EBUSY;
|
||||
|
||||
map->lock(map);
|
||||
map->lock(map->lock_arg);
|
||||
|
||||
bypass = map->cache_bypass;
|
||||
|
||||
|
@ -1445,7 +1456,7 @@ int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
|
|||
out:
|
||||
map->cache_bypass = bypass;
|
||||
|
||||
map->unlock(map);
|
||||
map->unlock(map->lock_arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -54,6 +54,9 @@ enum regmap_endian {
|
|||
REGMAP_ENDIAN_NATIVE,
|
||||
};
|
||||
|
||||
typedef void (*regmap_lock)(void *);
|
||||
typedef void (*regmap_unlock)(void *);
|
||||
|
||||
/**
|
||||
* Configuration for the register map of a device.
|
||||
*
|
||||
|
@ -76,6 +79,12 @@ enum regmap_endian {
|
|||
* @precious_reg: Optional callback returning true if the rgister
|
||||
* should not be read outside of a call from the driver
|
||||
* (eg, a clear on read interrupt status register).
|
||||
* @lock: Optional lock callback (overrides regmap's default lock
|
||||
* function, based on spinlock or mutex).
|
||||
* @unlock: As above for unlocking.
|
||||
* @lock_arg: this field is passed as the only argument of lock/unlock
|
||||
* functions (ignored in case regular lock/unlock functions
|
||||
* are not overridden).
|
||||
*
|
||||
* @max_register: Optional, specifies the maximum valid register index.
|
||||
* @reg_defaults: Power on reset values for registers (for use with
|
||||
|
@ -117,6 +126,9 @@ struct regmap_config {
|
|||
bool (*readable_reg)(struct device *dev, unsigned int reg);
|
||||
bool (*volatile_reg)(struct device *dev, unsigned int reg);
|
||||
bool (*precious_reg)(struct device *dev, unsigned int reg);
|
||||
regmap_lock lock;
|
||||
regmap_unlock unlock;
|
||||
void *lock_arg;
|
||||
|
||||
unsigned int max_register;
|
||||
const struct reg_default *reg_defaults;
|
||||
|
@ -186,7 +198,9 @@ typedef void (*regmap_hw_free_context)(void *context);
|
|||
* Description of a hardware bus for the register map infrastructure.
|
||||
*
|
||||
* @fast_io: Register IO is fast. Use a spinlock instead of a mutex
|
||||
* to perform locking.
|
||||
* to perform locking. This field is ignored if custom lock/unlock
|
||||
* functions are used (see fields lock/unlock of
|
||||
* struct regmap_config).
|
||||
* @write: Write operation.
|
||||
* @gather_write: Write operation with split register/value, return -ENOTSUPP
|
||||
* if not implemented on a given device.
|
||||
|
|
Loading…
Reference in a new issue