2018-09-21 20:40:20 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2015-07-27 18:13:19 +07:00
|
|
|
/*
|
|
|
|
* nvmem framework core.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
|
|
|
|
* Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/export.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/init.h>
|
2018-09-21 20:40:08 +07:00
|
|
|
#include <linux/kref.h>
|
2015-07-27 18:13:19 +07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/nvmem-consumer.h>
|
|
|
|
#include <linux/nvmem-provider.h>
|
|
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/slab.h>
|
2019-04-16 16:59:24 +07:00
|
|
|
#include "nvmem.h"
|
2016-02-27 02:59:19 +07:00
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
struct nvmem_cell {
|
|
|
|
const char *name;
|
|
|
|
int offset;
|
|
|
|
int bytes;
|
|
|
|
int bit_offset;
|
|
|
|
int nbits;
|
2018-11-06 22:41:41 +07:00
|
|
|
struct device_node *np;
|
2015-07-27 18:13:19 +07:00
|
|
|
struct nvmem_device *nvmem;
|
|
|
|
struct list_head node;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(nvmem_mutex);
|
|
|
|
static DEFINE_IDA(nvmem_ida);
|
|
|
|
|
2018-09-21 20:40:15 +07:00
|
|
|
static DEFINE_MUTEX(nvmem_cell_mutex);
|
|
|
|
static LIST_HEAD(nvmem_cell_tables);
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
static DEFINE_MUTEX(nvmem_lookup_mutex);
|
|
|
|
static LIST_HEAD(nvmem_lookup_list);
|
|
|
|
|
2018-09-21 20:40:19 +07:00
|
|
|
static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
|
|
|
|
|
2016-02-27 02:59:19 +07:00
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
|
|
|
|
void *val, size_t bytes)
|
|
|
|
{
|
|
|
|
if (nvmem->reg_read)
|
|
|
|
return nvmem->reg_read(nvmem->priv, offset, val, bytes);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
|
|
|
|
void *val, size_t bytes)
|
|
|
|
{
|
|
|
|
if (nvmem->reg_write)
|
|
|
|
return nvmem->reg_write(nvmem->priv, offset, val, bytes);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-07-27 18:13:19 +07:00
|
|
|
|
|
|
|
static void nvmem_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = to_nvmem_device(dev);
|
|
|
|
|
|
|
|
ida_simple_remove(&nvmem_ida, nvmem->id);
|
|
|
|
kfree(nvmem);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct device_type nvmem_provider_type = {
|
|
|
|
.release = nvmem_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct bus_type nvmem_bus_type = {
|
|
|
|
.name = "nvmem",
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
|
|
|
|
{
|
|
|
|
struct device *d;
|
|
|
|
|
|
|
|
if (!nvmem_np)
|
|
|
|
return NULL;
|
|
|
|
|
2019-07-24 05:18:33 +07:00
|
|
|
d = bus_find_device_by_of_node(&nvmem_bus_type, nvmem_np);
|
2015-07-27 18:13:19 +07:00
|
|
|
|
|
|
|
if (!d)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return to_nvmem_device(d);
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
static struct nvmem_device *nvmem_find(const char *name)
|
|
|
|
{
|
|
|
|
struct device *d;
|
|
|
|
|
|
|
|
d = bus_find_device_by_name(&nvmem_bus_type, NULL, name);
|
|
|
|
|
|
|
|
if (!d)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return to_nvmem_device(d);
|
|
|
|
}
|
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
static void nvmem_cell_drop(struct nvmem_cell *cell)
|
|
|
|
{
|
2018-09-21 20:40:19 +07:00
|
|
|
blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
|
2018-09-21 20:40:14 +07:00
|
|
|
mutex_lock(&nvmem_mutex);
|
2015-07-27 18:13:19 +07:00
|
|
|
list_del(&cell->node);
|
2018-09-21 20:40:14 +07:00
|
|
|
mutex_unlock(&nvmem_mutex);
|
2018-11-06 22:41:41 +07:00
|
|
|
of_node_put(cell->np);
|
2018-10-04 00:47:04 +07:00
|
|
|
kfree(cell->name);
|
2015-07-27 18:13:19 +07:00
|
|
|
kfree(cell);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
|
|
|
|
{
|
2018-09-21 20:40:05 +07:00
|
|
|
struct nvmem_cell *cell, *p;
|
2015-07-27 18:13:19 +07:00
|
|
|
|
2018-09-21 20:40:14 +07:00
|
|
|
list_for_each_entry_safe(cell, p, &nvmem->cells, node)
|
|
|
|
nvmem_cell_drop(cell);
|
2015-07-27 18:13:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nvmem_cell_add(struct nvmem_cell *cell)
|
|
|
|
{
|
2018-09-21 20:40:14 +07:00
|
|
|
mutex_lock(&nvmem_mutex);
|
|
|
|
list_add_tail(&cell->node, &cell->nvmem->cells);
|
|
|
|
mutex_unlock(&nvmem_mutex);
|
2018-09-21 20:40:19 +07:00
|
|
|
blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_ADD, cell);
|
2015-07-27 18:13:19 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
|
|
|
|
const struct nvmem_cell_info *info,
|
|
|
|
struct nvmem_cell *cell)
|
|
|
|
{
|
|
|
|
cell->nvmem = nvmem;
|
|
|
|
cell->offset = info->offset;
|
|
|
|
cell->bytes = info->bytes;
|
|
|
|
cell->name = info->name;
|
|
|
|
|
|
|
|
cell->bit_offset = info->bit_offset;
|
|
|
|
cell->nbits = info->nbits;
|
|
|
|
|
|
|
|
if (cell->nbits)
|
|
|
|
cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
|
|
|
|
BITS_PER_BYTE);
|
|
|
|
|
|
|
|
if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
|
|
|
|
dev_err(&nvmem->dev,
|
|
|
|
"cell %s unaligned to nvmem stride %d\n",
|
|
|
|
cell->name, nvmem->stride);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-05-11 18:06:56 +07:00
|
|
|
/**
|
|
|
|
* nvmem_add_cells() - Add cell information to an nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device to add cells to.
|
|
|
|
* @info: nvmem cell info to add to the device
|
|
|
|
* @ncells: number of cells in info
|
|
|
|
*
|
|
|
|
* Return: 0 or negative error code on failure.
|
|
|
|
*/
|
2018-09-21 20:40:26 +07:00
|
|
|
static int nvmem_add_cells(struct nvmem_device *nvmem,
|
2018-05-11 18:06:56 +07:00
|
|
|
const struct nvmem_cell_info *info,
|
|
|
|
int ncells)
|
2015-07-27 18:13:19 +07:00
|
|
|
{
|
|
|
|
struct nvmem_cell **cells;
|
|
|
|
int i, rval;
|
|
|
|
|
2018-05-11 18:06:56 +07:00
|
|
|
cells = kcalloc(ncells, sizeof(*cells), GFP_KERNEL);
|
2015-07-27 18:13:19 +07:00
|
|
|
if (!cells)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2018-05-11 18:06:56 +07:00
|
|
|
for (i = 0; i < ncells; i++) {
|
2015-07-27 18:13:19 +07:00
|
|
|
cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
|
|
|
|
if (!cells[i]) {
|
|
|
|
rval = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rval) {
|
2015-07-27 18:13:19 +07:00
|
|
|
kfree(cells[i]);
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
nvmem_cell_add(cells[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* remove tmp array */
|
|
|
|
kfree(cells);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
err:
|
2016-02-09 04:04:29 +07:00
|
|
|
while (i--)
|
2015-07-27 18:13:19 +07:00
|
|
|
nvmem_cell_drop(cells[i]);
|
|
|
|
|
2016-02-09 04:04:29 +07:00
|
|
|
kfree(cells);
|
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:19 +07:00
|
|
|
/**
|
|
|
|
* nvmem_register_notifier() - Register a notifier block for nvmem events.
|
|
|
|
*
|
|
|
|
* @nb: notifier block to be called on nvmem events.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, negative error number on failure.
|
|
|
|
*/
|
|
|
|
int nvmem_register_notifier(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_register(&nvmem_notifier, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_register_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_unregister_notifier() - Unregister a notifier block for nvmem events.
|
|
|
|
*
|
|
|
|
* @nb: notifier block to be unregistered.
|
|
|
|
*
|
|
|
|
* Return: 0 on success, negative error number on failure.
|
|
|
|
*/
|
|
|
|
int nvmem_unregister_notifier(struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_unregister(&nvmem_notifier, nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_unregister_notifier);
|
|
|
|
|
2018-09-21 20:40:15 +07:00
|
|
|
static int nvmem_add_cells_from_table(struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
const struct nvmem_cell_info *info;
|
|
|
|
struct nvmem_cell_table *table;
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
int rval = 0, i;
|
|
|
|
|
|
|
|
mutex_lock(&nvmem_cell_mutex);
|
|
|
|
list_for_each_entry(table, &nvmem_cell_tables, node) {
|
|
|
|
if (strcmp(nvmem_dev_name(nvmem), table->nvmem_name) == 0) {
|
|
|
|
for (i = 0; i < table->ncells; i++) {
|
|
|
|
info = &table->cells[i];
|
|
|
|
|
|
|
|
cell = kzalloc(sizeof(*cell), GFP_KERNEL);
|
|
|
|
if (!cell) {
|
|
|
|
rval = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rval = nvmem_cell_info_to_nvmem_cell(nvmem,
|
|
|
|
info,
|
|
|
|
cell);
|
|
|
|
if (rval) {
|
|
|
|
kfree(cell);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
nvmem_cell_add(cell);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&nvmem_cell_mutex);
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
static struct nvmem_cell *
|
|
|
|
nvmem_find_cell_by_name(struct nvmem_device *nvmem, const char *cell_id)
|
|
|
|
{
|
2019-01-28 22:55:02 +07:00
|
|
|
struct nvmem_cell *iter, *cell = NULL;
|
2018-09-21 20:40:17 +07:00
|
|
|
|
|
|
|
mutex_lock(&nvmem_mutex);
|
2019-01-28 22:55:02 +07:00
|
|
|
list_for_each_entry(iter, &nvmem->cells, node) {
|
|
|
|
if (strcmp(cell_id, iter->name) == 0) {
|
|
|
|
cell = iter;
|
2018-09-21 20:40:17 +07:00
|
|
|
break;
|
2019-01-28 22:55:02 +07:00
|
|
|
}
|
2018-09-21 20:40:17 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&nvmem_mutex);
|
|
|
|
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:16 +07:00
|
|
|
static int nvmem_add_cells_from_of(struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
struct device_node *parent, *child;
|
|
|
|
struct device *dev = &nvmem->dev;
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
const __be32 *addr;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
parent = dev->of_node;
|
|
|
|
|
|
|
|
for_each_child_of_node(parent, child) {
|
|
|
|
addr = of_get_property(child, "reg", &len);
|
|
|
|
if (!addr || (len < 2 * sizeof(u32))) {
|
|
|
|
dev_err(dev, "nvmem: invalid reg on %pOF\n", child);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cell = kzalloc(sizeof(*cell), GFP_KERNEL);
|
|
|
|
if (!cell)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
cell->nvmem = nvmem;
|
2018-11-06 22:41:41 +07:00
|
|
|
cell->np = of_node_get(child);
|
2018-09-21 20:40:16 +07:00
|
|
|
cell->offset = be32_to_cpup(addr++);
|
|
|
|
cell->bytes = be32_to_cpup(addr);
|
2018-10-04 00:47:04 +07:00
|
|
|
cell->name = kasprintf(GFP_KERNEL, "%pOFn", child);
|
2018-09-21 20:40:16 +07:00
|
|
|
|
|
|
|
addr = of_get_property(child, "bits", &len);
|
|
|
|
if (addr && len == (2 * sizeof(u32))) {
|
|
|
|
cell->bit_offset = be32_to_cpup(addr++);
|
|
|
|
cell->nbits = be32_to_cpup(addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cell->nbits)
|
|
|
|
cell->bytes = DIV_ROUND_UP(
|
|
|
|
cell->nbits + cell->bit_offset,
|
|
|
|
BITS_PER_BYTE);
|
|
|
|
|
|
|
|
if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
|
|
|
|
dev_err(dev, "cell %s unaligned to nvmem stride %d\n",
|
|
|
|
cell->name, nvmem->stride);
|
|
|
|
/* Cells already added will be freed later. */
|
2018-10-04 00:47:04 +07:00
|
|
|
kfree(cell->name);
|
2018-09-21 20:40:16 +07:00
|
|
|
kfree(cell);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
nvmem_cell_add(cell);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
/**
|
|
|
|
* nvmem_register() - Register a nvmem device for given nvmem_config.
|
|
|
|
* Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
|
|
|
|
*
|
|
|
|
* @config: nvmem device configuration with which nvmem device is created.
|
|
|
|
*
|
|
|
|
* Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
|
|
|
|
* on success.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct nvmem_device *nvmem_register(const struct nvmem_config *config)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem;
|
|
|
|
int rval;
|
|
|
|
|
|
|
|
if (!config->dev)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
|
|
|
|
if (!nvmem)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
rval = ida_simple_get(&nvmem_ida, 0, 0, GFP_KERNEL);
|
|
|
|
if (rval < 0) {
|
|
|
|
kfree(nvmem);
|
|
|
|
return ERR_PTR(rval);
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:08 +07:00
|
|
|
kref_init(&nvmem->refcnt);
|
2018-09-21 20:40:14 +07:00
|
|
|
INIT_LIST_HEAD(&nvmem->cells);
|
2018-09-21 20:40:08 +07:00
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
nvmem->id = rval;
|
|
|
|
nvmem->owner = config->owner;
|
2017-10-20 23:57:42 +07:00
|
|
|
if (!nvmem->owner && config->dev->driver)
|
|
|
|
nvmem->owner = config->dev->driver->owner;
|
2017-12-15 21:06:05 +07:00
|
|
|
nvmem->stride = config->stride ?: 1;
|
|
|
|
nvmem->word_size = config->word_size ?: 1;
|
2016-04-25 02:28:05 +07:00
|
|
|
nvmem->size = config->size;
|
2015-07-27 18:13:19 +07:00
|
|
|
nvmem->dev.type = &nvmem_provider_type;
|
|
|
|
nvmem->dev.bus = &nvmem_bus_type;
|
|
|
|
nvmem->dev.parent = config->dev;
|
2016-04-25 02:28:05 +07:00
|
|
|
nvmem->priv = config->priv;
|
2018-11-30 18:53:20 +07:00
|
|
|
nvmem->type = config->type;
|
2016-04-25 02:28:05 +07:00
|
|
|
nvmem->reg_read = config->reg_read;
|
|
|
|
nvmem->reg_write = config->reg_write;
|
2018-11-30 18:53:25 +07:00
|
|
|
if (!config->no_of_node)
|
|
|
|
nvmem->dev.of_node = config->dev->of_node;
|
2018-03-09 21:46:56 +07:00
|
|
|
|
|
|
|
if (config->id == -1 && config->name) {
|
|
|
|
dev_set_name(&nvmem->dev, "%s", config->name);
|
|
|
|
} else {
|
|
|
|
dev_set_name(&nvmem->dev, "%s%d",
|
|
|
|
config->name ? : "nvmem",
|
|
|
|
config->name ? config->id : nvmem->id);
|
|
|
|
}
|
2015-07-27 18:13:19 +07:00
|
|
|
|
2019-01-28 22:55:00 +07:00
|
|
|
nvmem->read_only = device_property_present(config->dev, "read-only") ||
|
|
|
|
config->read_only || !nvmem->reg_write;
|
2015-07-27 18:13:19 +07:00
|
|
|
|
2019-04-16 16:59:24 +07:00
|
|
|
nvmem->dev.groups = nvmem_sysfs_get_groups(nvmem, config);
|
2015-07-27 18:13:19 +07:00
|
|
|
|
|
|
|
device_initialize(&nvmem->dev);
|
|
|
|
|
|
|
|
dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
|
|
|
|
|
|
|
|
rval = device_add(&nvmem->dev);
|
2016-02-27 02:59:19 +07:00
|
|
|
if (rval)
|
2017-06-09 16:59:07 +07:00
|
|
|
goto err_put_device;
|
2016-02-27 02:59:19 +07:00
|
|
|
|
|
|
|
if (config->compat) {
|
2019-04-16 16:59:24 +07:00
|
|
|
rval = nvmem_sysfs_setup_compat(nvmem, config);
|
2016-02-27 02:59:19 +07:00
|
|
|
if (rval)
|
2017-06-09 16:59:07 +07:00
|
|
|
goto err_device_del;
|
2015-07-27 18:13:19 +07:00
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:07 +07:00
|
|
|
if (config->cells) {
|
|
|
|
rval = nvmem_add_cells(nvmem, config->cells, config->ncells);
|
|
|
|
if (rval)
|
|
|
|
goto err_teardown_compat;
|
|
|
|
}
|
2015-07-27 18:13:19 +07:00
|
|
|
|
2018-09-21 20:40:15 +07:00
|
|
|
rval = nvmem_add_cells_from_table(nvmem);
|
|
|
|
if (rval)
|
|
|
|
goto err_remove_cells;
|
|
|
|
|
2018-09-21 20:40:16 +07:00
|
|
|
rval = nvmem_add_cells_from_of(nvmem);
|
|
|
|
if (rval)
|
|
|
|
goto err_remove_cells;
|
|
|
|
|
2019-02-15 17:42:59 +07:00
|
|
|
blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
|
2018-09-21 20:40:19 +07:00
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
return nvmem;
|
2017-06-09 16:59:07 +07:00
|
|
|
|
2018-09-21 20:40:15 +07:00
|
|
|
err_remove_cells:
|
|
|
|
nvmem_device_remove_all_cells(nvmem);
|
2018-09-21 20:40:07 +07:00
|
|
|
err_teardown_compat:
|
|
|
|
if (config->compat)
|
2019-04-16 16:59:24 +07:00
|
|
|
nvmem_sysfs_remove_compat(nvmem, config);
|
2017-06-09 16:59:07 +07:00
|
|
|
err_device_del:
|
|
|
|
device_del(&nvmem->dev);
|
|
|
|
err_put_device:
|
|
|
|
put_device(&nvmem->dev);
|
|
|
|
|
2016-02-27 02:59:19 +07:00
|
|
|
return ERR_PTR(rval);
|
2015-07-27 18:13:19 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_register);
|
|
|
|
|
2018-09-21 20:40:08 +07:00
|
|
|
static void nvmem_device_release(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem;
|
|
|
|
|
|
|
|
nvmem = container_of(kref, struct nvmem_device, refcnt);
|
|
|
|
|
2018-09-21 20:40:19 +07:00
|
|
|
blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
|
|
|
|
|
2018-09-21 20:40:08 +07:00
|
|
|
if (nvmem->flags & FLAG_COMPAT)
|
|
|
|
device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
|
|
|
|
|
|
|
|
nvmem_device_remove_all_cells(nvmem);
|
|
|
|
device_del(&nvmem->dev);
|
|
|
|
put_device(&nvmem->dev);
|
|
|
|
}
|
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
/**
|
|
|
|
* nvmem_unregister() - Unregister previously registered nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: Pointer to previously registered nvmem device.
|
|
|
|
*/
|
2018-09-21 20:40:13 +07:00
|
|
|
void nvmem_unregister(struct nvmem_device *nvmem)
|
2015-07-27 18:13:19 +07:00
|
|
|
{
|
2018-09-21 20:40:08 +07:00
|
|
|
kref_put(&nvmem->refcnt, nvmem_device_release);
|
2015-07-27 18:13:19 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_unregister);
|
|
|
|
|
2018-03-09 21:46:57 +07:00
|
|
|
static void devm_nvmem_release(struct device *dev, void *res)
|
|
|
|
{
|
2018-09-21 20:40:13 +07:00
|
|
|
nvmem_unregister(*(struct nvmem_device **)res);
|
2018-03-09 21:46:57 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_register() - Register a managed nvmem device for given
|
|
|
|
* nvmem_config.
|
|
|
|
* Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
|
|
|
|
*
|
2018-05-11 18:07:02 +07:00
|
|
|
* @dev: Device that uses the nvmem device.
|
2018-03-09 21:46:57 +07:00
|
|
|
* @config: nvmem device configuration with which nvmem device is created.
|
|
|
|
*
|
|
|
|
* Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
|
|
|
|
* on success.
|
|
|
|
*/
|
|
|
|
struct nvmem_device *devm_nvmem_register(struct device *dev,
|
|
|
|
const struct nvmem_config *config)
|
|
|
|
{
|
|
|
|
struct nvmem_device **ptr, *nvmem;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_nvmem_release, sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
nvmem = nvmem_register(config);
|
|
|
|
|
|
|
|
if (!IS_ERR(nvmem)) {
|
|
|
|
*ptr = nvmem;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
} else {
|
|
|
|
devres_free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nvmem;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_nvmem_register);
|
|
|
|
|
|
|
|
static int devm_nvmem_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct nvmem_device **r = res;
|
|
|
|
|
|
|
|
return *r == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_unregister() - Unregister previously registered managed nvmem
|
|
|
|
* device.
|
|
|
|
*
|
2018-05-11 18:07:02 +07:00
|
|
|
* @dev: Device that uses the nvmem device.
|
2018-03-09 21:46:57 +07:00
|
|
|
* @nvmem: Pointer to previously registered nvmem device.
|
|
|
|
*
|
|
|
|
* Return: Will be an negative on error or a zero on success.
|
|
|
|
*/
|
|
|
|
int devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
return devres_release(dev, devm_nvmem_release, devm_nvmem_match, nvmem);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(devm_nvmem_unregister);
|
|
|
|
|
2015-07-27 18:13:34 +07:00
|
|
|
static struct nvmem_device *__nvmem_device_get(struct device_node *np,
|
2018-09-21 20:40:17 +07:00
|
|
|
const char *nvmem_name)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = NULL;
|
|
|
|
|
2018-09-21 20:40:14 +07:00
|
|
|
mutex_lock(&nvmem_mutex);
|
2018-09-21 20:40:17 +07:00
|
|
|
nvmem = np ? of_nvmem_find(np) : nvmem_find(nvmem_name);
|
2015-07-27 18:13:34 +07:00
|
|
|
mutex_unlock(&nvmem_mutex);
|
2018-09-21 20:40:14 +07:00
|
|
|
if (!nvmem)
|
|
|
|
return ERR_PTR(-EPROBE_DEFER);
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
if (!try_module_get(nvmem->owner)) {
|
|
|
|
dev_err(&nvmem->dev,
|
|
|
|
"could not increase module refcount for cell %s\n",
|
2018-09-21 20:40:04 +07:00
|
|
|
nvmem_dev_name(nvmem));
|
2015-07-27 18:13:34 +07:00
|
|
|
|
2019-01-28 22:55:05 +07:00
|
|
|
put_device(&nvmem->dev);
|
2015-07-27 18:13:34 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:08 +07:00
|
|
|
kref_get(&nvmem->refcnt);
|
|
|
|
|
2015-07-27 18:13:34 +07:00
|
|
|
return nvmem;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __nvmem_device_put(struct nvmem_device *nvmem)
|
|
|
|
{
|
2019-01-28 22:55:05 +07:00
|
|
|
put_device(&nvmem->dev);
|
2015-07-27 18:13:34 +07:00
|
|
|
module_put(nvmem->owner);
|
2018-09-21 20:40:08 +07:00
|
|
|
kref_put(&nvmem->refcnt, nvmem_device_release);
|
2015-07-27 18:13:34 +07:00
|
|
|
}
|
|
|
|
|
2017-09-11 16:00:14 +07:00
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
2015-07-27 18:13:45 +07:00
|
|
|
/**
|
|
|
|
* of_nvmem_device_get() - Get nvmem device from a given id
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @np: Device tree node that uses the nvmem device.
|
2015-07-27 18:13:45 +07:00
|
|
|
* @id: nvmem name from nvmem-names property.
|
|
|
|
*
|
|
|
|
* Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
|
|
|
|
* on success.
|
|
|
|
*/
|
|
|
|
struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct device_node *nvmem_np;
|
2019-01-28 22:55:03 +07:00
|
|
|
int index = 0;
|
2015-07-27 18:13:45 +07:00
|
|
|
|
2019-01-28 22:55:03 +07:00
|
|
|
if (id)
|
|
|
|
index = of_property_match_string(np, "nvmem-names", id);
|
2015-07-27 18:13:45 +07:00
|
|
|
|
|
|
|
nvmem_np = of_parse_phandle(np, "nvmem", index);
|
|
|
|
if (!nvmem_np)
|
2019-01-28 22:55:03 +07:00
|
|
|
return ERR_PTR(-ENOENT);
|
2015-07-27 18:13:45 +07:00
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
return __nvmem_device_get(nvmem_np, NULL);
|
2015-07-27 18:13:45 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_nvmem_device_get);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_device_get() - Get nvmem device from a given id
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that uses the nvmem device.
|
|
|
|
* @dev_name: name of the requested nvmem device.
|
2015-07-27 18:13:45 +07:00
|
|
|
*
|
|
|
|
* Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
|
|
|
|
* on success.
|
|
|
|
*/
|
|
|
|
struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
|
|
|
|
{
|
|
|
|
if (dev->of_node) { /* try dt first */
|
|
|
|
struct nvmem_device *nvmem;
|
|
|
|
|
|
|
|
nvmem = of_nvmem_device_get(dev->of_node, dev_name);
|
|
|
|
|
|
|
|
if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
|
|
|
|
return nvmem;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-01-28 22:55:04 +07:00
|
|
|
return __nvmem_device_get(NULL, dev_name);
|
2015-07-27 18:13:45 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_get);
|
|
|
|
|
|
|
|
static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct nvmem_device **nvmem = res;
|
|
|
|
|
|
|
|
if (WARN_ON(!nvmem || !*nvmem))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return *nvmem == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void devm_nvmem_device_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
nvmem_device_put(*(struct nvmem_device **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_device_put() - put alredy got nvmem device
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that uses the nvmem device.
|
2015-07-27 18:13:45 +07:00
|
|
|
* @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
|
|
|
|
* that needs to be released.
|
|
|
|
*/
|
|
|
|
void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = devres_release(dev, devm_nvmem_device_release,
|
|
|
|
devm_nvmem_device_match, nvmem);
|
|
|
|
|
|
|
|
WARN_ON(ret);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_device_put() - put alredy got nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: pointer to nvmem device that needs to be released.
|
|
|
|
*/
|
|
|
|
void nvmem_device_put(struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
__nvmem_device_put(nvmem);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_put);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_device_get() - Get nvmem cell of device form a given id
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that requests the nvmem device.
|
|
|
|
* @id: name id for the requested nvmem device.
|
2015-07-27 18:13:45 +07:00
|
|
|
*
|
|
|
|
* Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
|
|
|
|
* on success. The nvmem_cell will be freed by the automatically once the
|
|
|
|
* device is freed.
|
|
|
|
*/
|
|
|
|
struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
|
|
|
|
{
|
|
|
|
struct nvmem_device **ptr, *nvmem;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
nvmem = nvmem_device_get(dev, id);
|
|
|
|
if (!IS_ERR(nvmem)) {
|
|
|
|
*ptr = nvmem;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
} else {
|
|
|
|
devres_free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return nvmem;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
static struct nvmem_cell *
|
|
|
|
nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
2018-09-21 20:40:17 +07:00
|
|
|
struct nvmem_cell *cell = ERR_PTR(-ENOENT);
|
|
|
|
struct nvmem_cell_lookup *lookup;
|
2015-07-27 18:13:34 +07:00
|
|
|
struct nvmem_device *nvmem;
|
2018-09-21 20:40:17 +07:00
|
|
|
const char *dev_id;
|
2015-07-27 18:13:34 +07:00
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
if (!dev)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
dev_id = dev_name(dev);
|
|
|
|
|
|
|
|
mutex_lock(&nvmem_lookup_mutex);
|
|
|
|
|
|
|
|
list_for_each_entry(lookup, &nvmem_lookup_list, node) {
|
|
|
|
if ((strcmp(lookup->dev_id, dev_id) == 0) &&
|
|
|
|
(strcmp(lookup->con_id, con_id) == 0)) {
|
|
|
|
/* This is the right entry. */
|
|
|
|
nvmem = __nvmem_device_get(NULL, lookup->nvmem_name);
|
2018-10-03 14:31:11 +07:00
|
|
|
if (IS_ERR(nvmem)) {
|
2018-09-21 20:40:17 +07:00
|
|
|
/* Provider may not be registered yet. */
|
2018-10-03 14:31:11 +07:00
|
|
|
cell = ERR_CAST(nvmem);
|
2019-01-28 22:55:06 +07:00
|
|
|
break;
|
2018-09-21 20:40:17 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
cell = nvmem_find_cell_by_name(nvmem,
|
|
|
|
lookup->cell_name);
|
|
|
|
if (!cell) {
|
|
|
|
__nvmem_device_put(nvmem);
|
2018-10-03 14:31:11 +07:00
|
|
|
cell = ERR_PTR(-ENOENT);
|
2018-09-21 20:40:17 +07:00
|
|
|
}
|
2019-01-28 22:55:06 +07:00
|
|
|
break;
|
2018-09-21 20:40:17 +07:00
|
|
|
}
|
|
|
|
}
|
2015-07-27 18:13:34 +07:00
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
mutex_unlock(&nvmem_lookup_mutex);
|
2015-07-27 18:13:34 +07:00
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
|
2017-09-11 16:00:14 +07:00
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
2018-10-03 04:11:12 +07:00
|
|
|
static struct nvmem_cell *
|
2018-11-06 22:41:41 +07:00
|
|
|
nvmem_find_cell_by_node(struct nvmem_device *nvmem, struct device_node *np)
|
2018-10-03 04:11:12 +07:00
|
|
|
{
|
2019-01-28 22:55:02 +07:00
|
|
|
struct nvmem_cell *iter, *cell = NULL;
|
2018-10-03 04:11:12 +07:00
|
|
|
|
|
|
|
mutex_lock(&nvmem_mutex);
|
2019-01-28 22:55:02 +07:00
|
|
|
list_for_each_entry(iter, &nvmem->cells, node) {
|
|
|
|
if (np == iter->np) {
|
|
|
|
cell = iter;
|
2018-10-03 04:11:12 +07:00
|
|
|
break;
|
2019-01-28 22:55:02 +07:00
|
|
|
}
|
2018-10-03 04:11:12 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&nvmem_mutex);
|
|
|
|
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
|
2015-07-27 18:13:34 +07:00
|
|
|
/**
|
|
|
|
* of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @np: Device tree node that uses the nvmem cell.
|
2018-09-21 20:40:21 +07:00
|
|
|
* @id: nvmem cell name from nvmem-cell-names property, or NULL
|
|
|
|
* for the cell at index 0 (the lone cell with no accompanying
|
|
|
|
* nvmem-cell-names property).
|
2015-07-27 18:13:34 +07:00
|
|
|
*
|
|
|
|
* Return: Will be an ERR_PTR() on error or a valid pointer
|
|
|
|
* to a struct nvmem_cell. The nvmem_cell will be freed by the
|
|
|
|
* nvmem_cell_put().
|
|
|
|
*/
|
2018-09-21 20:40:21 +07:00
|
|
|
struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
|
|
|
struct device_node *cell_np, *nvmem_np;
|
|
|
|
struct nvmem_device *nvmem;
|
2018-09-21 20:40:16 +07:00
|
|
|
struct nvmem_cell *cell;
|
2017-01-23 06:02:40 +07:00
|
|
|
int index = 0;
|
2015-07-27 18:13:34 +07:00
|
|
|
|
2017-01-23 06:02:40 +07:00
|
|
|
/* if cell name exists, find index to the name */
|
2018-09-21 20:40:21 +07:00
|
|
|
if (id)
|
|
|
|
index = of_property_match_string(np, "nvmem-cell-names", id);
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
cell_np = of_parse_phandle(np, "nvmem-cells", index);
|
|
|
|
if (!cell_np)
|
2019-01-28 22:55:01 +07:00
|
|
|
return ERR_PTR(-ENOENT);
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
nvmem_np = of_get_next_parent(cell_np);
|
|
|
|
if (!nvmem_np)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
nvmem = __nvmem_device_get(nvmem_np, NULL);
|
2017-09-11 16:00:12 +07:00
|
|
|
of_node_put(nvmem_np);
|
2015-07-27 18:13:34 +07:00
|
|
|
if (IS_ERR(nvmem))
|
|
|
|
return ERR_CAST(nvmem);
|
|
|
|
|
2018-11-06 22:41:41 +07:00
|
|
|
cell = nvmem_find_cell_by_node(nvmem, cell_np);
|
2015-07-27 18:13:34 +07:00
|
|
|
if (!cell) {
|
2018-09-21 20:40:16 +07:00
|
|
|
__nvmem_device_put(nvmem);
|
|
|
|
return ERR_PTR(-ENOENT);
|
2015-07-27 18:13:34 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_cell_get() - Get nvmem cell of device form a given cell name
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that requests the nvmem cell.
|
2018-09-21 20:40:21 +07:00
|
|
|
* @id: nvmem cell name to get (this corresponds with the name from the
|
|
|
|
* nvmem-cell-names property for DT systems and with the con_id from
|
|
|
|
* the lookup entry for non-DT systems).
|
2015-07-27 18:13:34 +07:00
|
|
|
*
|
|
|
|
* Return: Will be an ERR_PTR() on error or a valid pointer
|
|
|
|
* to a struct nvmem_cell. The nvmem_cell will be freed by the
|
|
|
|
* nvmem_cell_put().
|
|
|
|
*/
|
2018-09-21 20:40:21 +07:00
|
|
|
struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
|
|
|
|
if (dev->of_node) { /* try dt first */
|
2018-09-21 20:40:21 +07:00
|
|
|
cell = of_nvmem_cell_get(dev->of_node, id);
|
2015-07-27 18:13:34 +07:00
|
|
|
if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
|
2018-09-21 20:40:21 +07:00
|
|
|
/* NULL cell id only allowed for device tree; invalid otherwise */
|
|
|
|
if (!id)
|
2018-06-19 00:30:43 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2018-09-21 20:40:21 +07:00
|
|
|
return nvmem_cell_get_from_lookup(dev, id);
|
2015-07-27 18:13:34 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_get);
|
|
|
|
|
|
|
|
static void devm_nvmem_cell_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
nvmem_cell_put(*(struct nvmem_cell **)res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_cell_get() - Get nvmem cell of device form a given id
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that requests the nvmem cell.
|
|
|
|
* @id: nvmem cell name id to get.
|
2015-07-27 18:13:34 +07:00
|
|
|
*
|
|
|
|
* Return: Will be an ERR_PTR() on error or a valid pointer
|
|
|
|
* to a struct nvmem_cell. The nvmem_cell will be freed by the
|
|
|
|
* automatically once the device is freed.
|
|
|
|
*/
|
|
|
|
struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
|
|
|
|
{
|
|
|
|
struct nvmem_cell **ptr, *cell;
|
|
|
|
|
|
|
|
ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
|
|
|
|
if (!ptr)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
cell = nvmem_cell_get(dev, id);
|
|
|
|
if (!IS_ERR(cell)) {
|
|
|
|
*ptr = cell;
|
|
|
|
devres_add(dev, ptr);
|
|
|
|
} else {
|
|
|
|
devres_free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cell;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
|
|
|
|
|
|
|
|
static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
struct nvmem_cell **c = res;
|
|
|
|
|
|
|
|
if (WARN_ON(!c || !*c))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return *c == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_nvmem_cell_put() - Release previously allocated nvmem cell
|
|
|
|
* from devm_nvmem_cell_get.
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @dev: Device that requests the nvmem cell.
|
|
|
|
* @cell: Previously allocated nvmem cell by devm_nvmem_cell_get().
|
2015-07-27 18:13:34 +07:00
|
|
|
*/
|
|
|
|
void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = devres_release(dev, devm_nvmem_cell_release,
|
|
|
|
devm_nvmem_cell_match, cell);
|
|
|
|
|
|
|
|
WARN_ON(ret);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(devm_nvmem_cell_put);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_cell_put() - Release previously allocated nvmem cell.
|
|
|
|
*
|
2017-01-23 06:02:39 +07:00
|
|
|
* @cell: Previously allocated nvmem cell by nvmem_cell_get().
|
2015-07-27 18:13:34 +07:00
|
|
|
*/
|
|
|
|
void nvmem_cell_put(struct nvmem_cell *cell)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = cell->nvmem;
|
|
|
|
|
|
|
|
__nvmem_device_put(nvmem);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_put);
|
|
|
|
|
2017-09-11 16:00:13 +07:00
|
|
|
static void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell, void *buf)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
|
|
|
u8 *p, *b;
|
2019-04-13 17:32:58 +07:00
|
|
|
int i, extra, bit_offset = cell->bit_offset;
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
p = b = buf;
|
|
|
|
if (bit_offset) {
|
|
|
|
/* First shift */
|
|
|
|
*b++ >>= bit_offset;
|
|
|
|
|
|
|
|
/* setup rest of the bytes if any */
|
|
|
|
for (i = 1; i < cell->bytes; i++) {
|
|
|
|
/* Get bits from next byte and shift them towards msb */
|
|
|
|
*p |= *b << (BITS_PER_BYTE - bit_offset);
|
|
|
|
|
|
|
|
p = b;
|
|
|
|
*b++ >>= bit_offset;
|
|
|
|
}
|
2019-04-13 17:32:58 +07:00
|
|
|
} else {
|
|
|
|
/* point to the msb */
|
|
|
|
p += cell->bytes - 1;
|
2015-07-27 18:13:34 +07:00
|
|
|
}
|
2019-04-13 17:32:58 +07:00
|
|
|
|
|
|
|
/* result fits in less bytes */
|
|
|
|
extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);
|
|
|
|
while (--extra >= 0)
|
|
|
|
*p-- = 0;
|
|
|
|
|
2015-07-27 18:13:34 +07:00
|
|
|
/* clear msb bits if any leftover in the last byte */
|
|
|
|
*p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __nvmem_cell_read(struct nvmem_device *nvmem,
|
|
|
|
struct nvmem_cell *cell,
|
|
|
|
void *buf, size_t *len)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->bytes);
|
2015-07-27 18:13:34 +07:00
|
|
|
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:34 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* shift bits in-place */
|
2015-09-30 19:35:15 +07:00
|
|
|
if (cell->bit_offset || cell->nbits)
|
2015-07-27 18:13:34 +07:00
|
|
|
nvmem_shift_read_buffer_in_place(cell, buf);
|
|
|
|
|
2017-01-23 06:02:38 +07:00
|
|
|
if (len)
|
|
|
|
*len = cell->bytes;
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_cell_read() - Read a given nvmem cell
|
|
|
|
*
|
|
|
|
* @cell: nvmem cell to be read.
|
2017-01-23 06:02:38 +07:00
|
|
|
* @len: pointer to length of cell which will be populated on successful read;
|
|
|
|
* can be NULL.
|
2015-07-27 18:13:34 +07:00
|
|
|
*
|
2017-01-04 23:18:11 +07:00
|
|
|
* Return: ERR_PTR() on error or a valid pointer to a buffer on success. The
|
|
|
|
* buffer should be freed by the consumer with a kfree().
|
2015-07-27 18:13:34 +07:00
|
|
|
*/
|
|
|
|
void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = cell->nvmem;
|
|
|
|
u8 *buf;
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem)
|
2015-07-27 18:13:34 +07:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
buf = kzalloc(cell->bytes, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
rc = __nvmem_cell_read(nvmem, cell, buf, len);
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc) {
|
2015-07-27 18:13:34 +07:00
|
|
|
kfree(buf);
|
|
|
|
return ERR_PTR(rc);
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_read);
|
|
|
|
|
2017-09-11 16:00:13 +07:00
|
|
|
static void *nvmem_cell_prepare_write_buffer(struct nvmem_cell *cell,
|
|
|
|
u8 *_buf, int len)
|
2015-07-27 18:13:34 +07:00
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = cell->nvmem;
|
|
|
|
int i, rc, nbits, bit_offset = cell->bit_offset;
|
|
|
|
u8 v, *p, *buf, *b, pbyte, pbits;
|
|
|
|
|
|
|
|
nbits = cell->nbits;
|
|
|
|
buf = kzalloc(cell->bytes, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
memcpy(buf, _buf, len);
|
|
|
|
p = b = buf;
|
|
|
|
|
|
|
|
if (bit_offset) {
|
|
|
|
pbyte = *b;
|
|
|
|
*b <<= bit_offset;
|
|
|
|
|
|
|
|
/* setup the first byte with lsb bits from nvmem */
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_read(nvmem, cell->offset, &v, 1);
|
2018-05-11 18:07:03 +07:00
|
|
|
if (rc)
|
|
|
|
goto err;
|
2015-07-27 18:13:34 +07:00
|
|
|
*b++ |= GENMASK(bit_offset - 1, 0) & v;
|
|
|
|
|
|
|
|
/* setup rest of the byte if any */
|
|
|
|
for (i = 1; i < cell->bytes; i++) {
|
|
|
|
/* Get last byte bits and shift them towards lsb */
|
|
|
|
pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
|
|
|
|
pbyte = *b;
|
|
|
|
p = b;
|
|
|
|
*b <<= bit_offset;
|
|
|
|
*b++ |= pbits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if it's not end on byte boundary */
|
|
|
|
if ((nbits + bit_offset) % BITS_PER_BYTE) {
|
|
|
|
/* setup the last byte with msb bits from nvmem */
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_read(nvmem,
|
2015-07-27 18:13:34 +07:00
|
|
|
cell->offset + cell->bytes - 1, &v, 1);
|
2018-05-11 18:07:03 +07:00
|
|
|
if (rc)
|
|
|
|
goto err;
|
2015-07-27 18:13:34 +07:00
|
|
|
*p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
2018-05-11 18:07:03 +07:00
|
|
|
err:
|
|
|
|
kfree(buf);
|
|
|
|
return ERR_PTR(rc);
|
2015-07-27 18:13:34 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_cell_write() - Write to a given nvmem cell
|
|
|
|
*
|
|
|
|
* @cell: nvmem cell to be written.
|
|
|
|
* @buf: Buffer to be written.
|
|
|
|
* @len: length of buffer to be written to nvmem cell.
|
|
|
|
*
|
|
|
|
* Return: length of bytes written or negative on failure.
|
|
|
|
*/
|
|
|
|
int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
|
|
|
|
{
|
|
|
|
struct nvmem_device *nvmem = cell->nvmem;
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem || nvmem->read_only ||
|
2015-07-27 18:13:34 +07:00
|
|
|
(cell->bit_offset == 0 && len != cell->bytes))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (cell->bit_offset || cell->nbits) {
|
|
|
|
buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
|
|
|
|
if (IS_ERR(buf))
|
|
|
|
return PTR_ERR(buf);
|
|
|
|
}
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_write(nvmem, cell->offset, buf, cell->bytes);
|
2015-07-27 18:13:34 +07:00
|
|
|
|
|
|
|
/* free the tmp buffer */
|
2015-09-30 19:36:10 +07:00
|
|
|
if (cell->bit_offset || cell->nbits)
|
2015-07-27 18:13:34 +07:00
|
|
|
kfree(buf);
|
|
|
|
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:34 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_write);
|
|
|
|
|
2019-04-13 17:32:57 +07:00
|
|
|
/**
|
|
|
|
* nvmem_cell_read_u16() - Read a cell value as an u16
|
|
|
|
*
|
|
|
|
* @dev: Device that requests the nvmem cell.
|
|
|
|
* @cell_id: Name of nvmem cell to read.
|
|
|
|
* @val: pointer to output value.
|
|
|
|
*
|
|
|
|
* Return: 0 on success or negative errno.
|
|
|
|
*/
|
|
|
|
int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val)
|
|
|
|
{
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
void *buf;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
cell = nvmem_cell_get(dev, cell_id);
|
|
|
|
if (IS_ERR(cell))
|
|
|
|
return PTR_ERR(cell);
|
|
|
|
|
|
|
|
buf = nvmem_cell_read(cell, &len);
|
|
|
|
if (IS_ERR(buf)) {
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
return PTR_ERR(buf);
|
|
|
|
}
|
|
|
|
if (len != sizeof(*val)) {
|
|
|
|
kfree(buf);
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
memcpy(val, buf, sizeof(*val));
|
|
|
|
kfree(buf);
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_read_u16);
|
|
|
|
|
2017-07-26 16:34:46 +07:00
|
|
|
/**
|
|
|
|
* nvmem_cell_read_u32() - Read a cell value as an u32
|
|
|
|
*
|
|
|
|
* @dev: Device that requests the nvmem cell.
|
|
|
|
* @cell_id: Name of nvmem cell to read.
|
|
|
|
* @val: pointer to output value.
|
|
|
|
*
|
|
|
|
* Return: 0 on success or negative errno.
|
|
|
|
*/
|
|
|
|
int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val)
|
|
|
|
{
|
|
|
|
struct nvmem_cell *cell;
|
|
|
|
void *buf;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
cell = nvmem_cell_get(dev, cell_id);
|
|
|
|
if (IS_ERR(cell))
|
|
|
|
return PTR_ERR(cell);
|
|
|
|
|
|
|
|
buf = nvmem_cell_read(cell, &len);
|
|
|
|
if (IS_ERR(buf)) {
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
return PTR_ERR(buf);
|
|
|
|
}
|
|
|
|
if (len != sizeof(*val)) {
|
|
|
|
kfree(buf);
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
memcpy(val, buf, sizeof(*val));
|
|
|
|
|
|
|
|
kfree(buf);
|
|
|
|
nvmem_cell_put(cell);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_cell_read_u32);
|
|
|
|
|
2015-07-27 18:13:45 +07:00
|
|
|
/**
|
|
|
|
* nvmem_device_cell_read() - Read a given nvmem device and cell
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device to read from.
|
|
|
|
* @info: nvmem cell info to be read.
|
|
|
|
* @buf: buffer pointer which will be populated on successful read.
|
|
|
|
*
|
|
|
|
* Return: length of successful bytes read on success and negative
|
|
|
|
* error code on error.
|
|
|
|
*/
|
|
|
|
ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
|
|
|
|
struct nvmem_cell_info *info, void *buf)
|
|
|
|
{
|
|
|
|
struct nvmem_cell cell;
|
|
|
|
int rc;
|
|
|
|
ssize_t len;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem)
|
2015-07-27 18:13:45 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:45 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
rc = __nvmem_cell_read(nvmem, &cell, buf, &len);
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:45 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_device_cell_write() - Write cell to a given nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device to be written to.
|
2017-01-23 06:02:39 +07:00
|
|
|
* @info: nvmem cell info to be written.
|
2015-07-27 18:13:45 +07:00
|
|
|
* @buf: buffer to be written to cell.
|
|
|
|
*
|
|
|
|
* Return: length of bytes written or negative error code on failure.
|
2018-09-21 20:40:23 +07:00
|
|
|
*/
|
2015-07-27 18:13:45 +07:00
|
|
|
int nvmem_device_cell_write(struct nvmem_device *nvmem,
|
|
|
|
struct nvmem_cell_info *info, void *buf)
|
|
|
|
{
|
|
|
|
struct nvmem_cell cell;
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem)
|
2015-07-27 18:13:45 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:45 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
return nvmem_cell_write(&cell, buf, cell.bytes);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_device_read() - Read from a given nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device to read from.
|
|
|
|
* @offset: offset in nvmem device.
|
|
|
|
* @bytes: number of bytes to read.
|
|
|
|
* @buf: buffer pointer which will be populated on successful read.
|
|
|
|
*
|
|
|
|
* Return: length of successful bytes read on success and negative
|
|
|
|
* error code on error.
|
|
|
|
*/
|
|
|
|
int nvmem_device_read(struct nvmem_device *nvmem,
|
|
|
|
unsigned int offset,
|
|
|
|
size_t bytes, void *buf)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem)
|
2015-07-27 18:13:45 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_read(nvmem, offset, buf, bytes);
|
2015-07-27 18:13:45 +07:00
|
|
|
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:45 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_read);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_device_write() - Write cell to a given nvmem device
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device to be written to.
|
|
|
|
* @offset: offset in nvmem device.
|
|
|
|
* @bytes: number of bytes to write.
|
|
|
|
* @buf: buffer to be written.
|
|
|
|
*
|
|
|
|
* Return: length of bytes written or negative error code on failure.
|
2018-09-21 20:40:23 +07:00
|
|
|
*/
|
2015-07-27 18:13:45 +07:00
|
|
|
int nvmem_device_write(struct nvmem_device *nvmem,
|
|
|
|
unsigned int offset,
|
|
|
|
size_t bytes, void *buf)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
if (!nvmem)
|
2015-07-27 18:13:45 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-25 02:28:05 +07:00
|
|
|
rc = nvmem_reg_write(nvmem, offset, buf, bytes);
|
2015-07-27 18:13:45 +07:00
|
|
|
|
remove lots of IS_ERR_VALUE abuses
Most users of IS_ERR_VALUE() in the kernel are wrong, as they
pass an 'int' into a function that takes an 'unsigned long'
argument. This happens to work because the type is sign-extended
on 64-bit architectures before it gets converted into an
unsigned type.
However, anything that passes an 'unsigned short' or 'unsigned int'
argument into IS_ERR_VALUE() is guaranteed to be broken, as are
8-bit integers and types that are wider than 'unsigned long'.
Andrzej Hajda has already fixed a lot of the worst abusers that
were causing actual bugs, but it would be nice to prevent any
users that are not passing 'unsigned long' arguments.
This patch changes all users of IS_ERR_VALUE() that I could find
on 32-bit ARM randconfig builds and x86 allmodconfig. For the
moment, this doesn't change the definition of IS_ERR_VALUE()
because there are probably still architecture specific users
elsewhere.
Almost all the warnings I got are for files that are better off
using 'if (err)' or 'if (err < 0)'.
The only legitimate user I could find that we get a warning for
is the (32-bit only) freescale fman driver, so I did not remove
the IS_ERR_VALUE() there but changed the type to 'unsigned long'.
For 9pfs, I just worked around one user whose calling conventions
are so obscure that I did not dare change the behavior.
I was using this definition for testing:
#define IS_ERR_VALUE(x) ((unsigned long*)NULL == (typeof (x)*)NULL && \
unlikely((unsigned long long)(x) >= (unsigned long long)(typeof(x))-MAX_ERRNO))
which ends up making all 16-bit or wider types work correctly with
the most plausible interpretation of what IS_ERR_VALUE() was supposed
to return according to its users, but also causes a compile-time
warning for any users that do not pass an 'unsigned long' argument.
I suggested this approach earlier this year, but back then we ended
up deciding to just fix the users that are obviously broken. After
the initial warning that caused me to get involved in the discussion
(fs/gfs2/dir.c) showed up again in the mainline kernel, Linus
asked me to send the whole thing again.
[ Updated the 9p parts as per Al Viro - Linus ]
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Andrzej Hajda <a.hajda@samsung.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://lkml.org/lkml/2016/1/7/363
Link: https://lkml.org/lkml/2016/5/27/486
Acked-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> # For nvmem part
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-28 04:23:25 +07:00
|
|
|
if (rc)
|
2015-07-27 18:13:45 +07:00
|
|
|
return rc;
|
|
|
|
|
|
|
|
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_device_write);
|
|
|
|
|
2018-09-21 20:40:15 +07:00
|
|
|
/**
|
|
|
|
* nvmem_add_cell_table() - register a table of cell info entries
|
|
|
|
*
|
|
|
|
* @table: table of cell info entries
|
|
|
|
*/
|
|
|
|
void nvmem_add_cell_table(struct nvmem_cell_table *table)
|
|
|
|
{
|
|
|
|
mutex_lock(&nvmem_cell_mutex);
|
|
|
|
list_add_tail(&table->node, &nvmem_cell_tables);
|
|
|
|
mutex_unlock(&nvmem_cell_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_add_cell_table);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_del_cell_table() - remove a previously registered cell info table
|
|
|
|
*
|
|
|
|
* @table: table of cell info entries
|
|
|
|
*/
|
|
|
|
void nvmem_del_cell_table(struct nvmem_cell_table *table)
|
|
|
|
{
|
|
|
|
mutex_lock(&nvmem_cell_mutex);
|
|
|
|
list_del(&table->node);
|
|
|
|
mutex_unlock(&nvmem_cell_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_del_cell_table);
|
|
|
|
|
2018-09-21 20:40:17 +07:00
|
|
|
/**
|
|
|
|
* nvmem_add_cell_lookups() - register a list of cell lookup entries
|
|
|
|
*
|
|
|
|
* @entries: array of cell lookup entries
|
|
|
|
* @nentries: number of cell lookup entries in the array
|
|
|
|
*/
|
|
|
|
void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&nvmem_lookup_mutex);
|
|
|
|
for (i = 0; i < nentries; i++)
|
|
|
|
list_add_tail(&entries[i].node, &nvmem_lookup_list);
|
|
|
|
mutex_unlock(&nvmem_lookup_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_add_cell_lookups);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nvmem_del_cell_lookups() - remove a list of previously added cell lookup
|
|
|
|
* entries
|
|
|
|
*
|
|
|
|
* @entries: array of cell lookup entries
|
|
|
|
* @nentries: number of cell lookup entries in the array
|
|
|
|
*/
|
|
|
|
void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mutex_lock(&nvmem_lookup_mutex);
|
|
|
|
for (i = 0; i < nentries; i++)
|
|
|
|
list_del(&entries[i].node);
|
|
|
|
mutex_unlock(&nvmem_lookup_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_del_cell_lookups);
|
|
|
|
|
2018-09-21 20:40:03 +07:00
|
|
|
/**
|
|
|
|
* nvmem_dev_name() - Get the name of a given nvmem device.
|
|
|
|
*
|
|
|
|
* @nvmem: nvmem device.
|
|
|
|
*
|
|
|
|
* Return: name of the nvmem device.
|
|
|
|
*/
|
|
|
|
const char *nvmem_dev_name(struct nvmem_device *nvmem)
|
|
|
|
{
|
|
|
|
return dev_name(&nvmem->dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(nvmem_dev_name);
|
|
|
|
|
2015-07-27 18:13:19 +07:00
|
|
|
static int __init nvmem_init(void)
|
|
|
|
{
|
|
|
|
return bus_register(&nvmem_bus_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit nvmem_exit(void)
|
|
|
|
{
|
|
|
|
bus_unregister(&nvmem_bus_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
subsys_initcall(nvmem_init);
|
|
|
|
module_exit(nvmem_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
|
|
|
|
MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
|
|
|
|
MODULE_DESCRIPTION("nvmem Driver Core");
|
|
|
|
MODULE_LICENSE("GPL v2");
|