[mirror_ubuntu-artful-kernel.git] / drivers / nvmem / core.c

/*
 * nvmem framework core.
 *
 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/device.h>
#include <linux/export.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/nvmem-consumer.h>
#include <linux/nvmem-provider.h>
#include <linux/of.h>
#include <linux/regmap.h>
#include <linux/slab.h>

struct nvmem_device {
	const char		*name;
	struct regmap		*regmap;
	struct module		*owner;
	struct device		dev;
	int			stride;
	int			word_size;
	int			ncells;
	int			id;
	int			users;
	size_t			size;
	bool			read_only;
};

struct nvmem_cell {
	const char		*name;
	int			offset;
	int			bytes;
	int			bit_offset;
	int			nbits;
	struct nvmem_device	*nvmem;
	struct list_head	node;
};

static DEFINE_MUTEX(nvmem_mutex);
static DEFINE_IDA(nvmem_ida);

static LIST_HEAD(nvmem_cells);
static DEFINE_MUTEX(nvmem_cells_mutex);

#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)

static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
				    struct bin_attribute *attr,
				    char *buf, loff_t pos, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct nvmem_device *nvmem = to_nvmem_device(dev);
	int rc;

	/* Stop the user from reading */
	if (pos > nvmem->size)
		return 0;

	if (pos + count > nvmem->size)
		count = nvmem->size - pos;

	count = round_down(count, nvmem->word_size);

	rc = regmap_raw_read(nvmem->regmap, pos, buf, count);

	if (IS_ERR_VALUE(rc))
		return rc;

	return count;
}

static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
				     struct bin_attribute *attr,
				     char *buf, loff_t pos, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct nvmem_device *nvmem = to_nvmem_device(dev);
	int rc;

	/* Stop the user from writing */
	if (pos > nvmem->size)
		return 0;

	if (pos + count > nvmem->size)
		count = nvmem->size - pos;

	count = round_down(count, nvmem->word_size);

	rc = regmap_raw_write(nvmem->regmap, pos, buf, count);

	if (IS_ERR_VALUE(rc))
		return rc;

	return count;
}

/* default read/write permissions */
static struct bin_attribute bin_attr_rw_nvmem = {
	.attr	= {
		.name	= "nvmem",
		.mode	= S_IWUSR | S_IRUGO,
	},
	.read	= bin_attr_nvmem_read,
	.write	= bin_attr_nvmem_write,
};

static struct bin_attribute *nvmem_bin_rw_attributes[] = {
	&bin_attr_rw_nvmem,
	NULL,
};

static const struct attribute_group nvmem_bin_rw_group = {
	.bin_attrs	= nvmem_bin_rw_attributes,
};

static const struct attribute_group *nvmem_rw_dev_groups[] = {
	&nvmem_bin_rw_group,
	NULL,
};

/* read only permission */
static struct bin_attribute bin_attr_ro_nvmem = {
	.attr	= {
		.name	= "nvmem",
		.mode	= S_IRUGO,
	},
	.read	= bin_attr_nvmem_read,
};

static struct bin_attribute *nvmem_bin_ro_attributes[] = {
	&bin_attr_ro_nvmem,
	NULL,
};

static const struct attribute_group nvmem_bin_ro_group = {
	.bin_attrs	= nvmem_bin_ro_attributes,
};

static const struct attribute_group *nvmem_ro_dev_groups[] = {
	&nvmem_bin_ro_group,
	NULL,
};

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 int of_nvmem_match(struct device *dev, void *nvmem_np)
{
	return dev->of_node == nvmem_np;
}

static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
{
	struct device *d;

	if (!nvmem_np)
		return NULL;

	d = bus_find_device(&nvmem_bus_type, NULL, nvmem_np, of_nvmem_match);

	if (!d)
		return NULL;

	return to_nvmem_device(d);
}

static struct nvmem_cell *nvmem_find_cell(const char *cell_id)
{
	struct nvmem_cell *p;

	list_for_each_entry(p, &nvmem_cells, node)
		if (p && !strcmp(p->name, cell_id))
			return p;

	return NULL;
}

static void nvmem_cell_drop(struct nvmem_cell *cell)
{
	mutex_lock(&nvmem_cells_mutex);
	list_del(&cell->node);
	mutex_unlock(&nvmem_cells_mutex);
	kfree(cell);
}

static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
{
	struct nvmem_cell *cell;
	struct list_head *p, *n;

	list_for_each_safe(p, n, &nvmem_cells) {
		cell = list_entry(p, struct nvmem_cell, node);
		if (cell->nvmem == nvmem)
			nvmem_cell_drop(cell);
	}
}

static void nvmem_cell_add(struct nvmem_cell *cell)
{
	mutex_lock(&nvmem_cells_mutex);
	list_add_tail(&cell->node, &nvmem_cells);
	mutex_unlock(&nvmem_cells_mutex);
}

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

static int nvmem_add_cells(struct nvmem_device *nvmem,
			   const struct nvmem_config *cfg)
{
	struct nvmem_cell **cells;
	const struct nvmem_cell_info *info = cfg->cells;
	int i, rval;

	cells = kcalloc(cfg->ncells, sizeof(*cells), GFP_KERNEL);
	if (!cells)
		return -ENOMEM;

	for (i = 0; i < cfg->ncells; i++) {
		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]);
		if (IS_ERR_VALUE(rval)) {
			kfree(cells[i]);
			goto err;
		}

		nvmem_cell_add(cells[i]);
	}

	nvmem->ncells = cfg->ncells;
	/* remove tmp array */
	kfree(cells);

	return 0;
err:
	while (--i)
		nvmem_cell_drop(cells[i]);

	return rval;
}

/**
 * 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;
	struct device_node *np;
	struct regmap *rm;
	int rval;

	if (!config->dev)
		return ERR_PTR(-EINVAL);

	rm = dev_get_regmap(config->dev, NULL);
	if (!rm) {
		dev_err(config->dev, "Regmap not found\n");
		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);
	}

	nvmem->id = rval;
	nvmem->regmap = rm;
	nvmem->owner = config->owner;
	nvmem->stride = regmap_get_reg_stride(rm);
	nvmem->word_size = regmap_get_val_bytes(rm);
	nvmem->size = regmap_get_max_register(rm) + nvmem->stride;
	nvmem->dev.type = &nvmem_provider_type;
	nvmem->dev.bus = &nvmem_bus_type;
	nvmem->dev.parent = config->dev;
	np = config->dev->of_node;
	nvmem->dev.of_node = np;
	dev_set_name(&nvmem->dev, "%s%d",
		     config->name ? : "nvmem", config->id);

	nvmem->read_only = of_property_read_bool(np, "read-only") |
			   config->read_only;

	nvmem->dev.groups = nvmem->read_only ? nvmem_ro_dev_groups :
					       nvmem_rw_dev_groups;

	device_initialize(&nvmem->dev);

	dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);

	rval = device_add(&nvmem->dev);
	if (rval) {
		ida_simple_remove(&nvmem_ida, nvmem->id);
		kfree(nvmem);
		return ERR_PTR(rval);
	}

	if (config->cells)
		nvmem_add_cells(nvmem, config);

	return nvmem;
}
EXPORT_SYMBOL_GPL(nvmem_register);

/**
 * nvmem_unregister() - Unregister previously registered nvmem device
 *
 * @nvmem: Pointer to previously registered nvmem device.
 *
 * Return: Will be an negative on error or a zero on success.
 */
int nvmem_unregister(struct nvmem_device *nvmem)
{
	if (nvmem->users)
		return -EBUSY;

	nvmem_device_remove_all_cells(nvmem);
	device_del(&nvmem->dev);

	return 0;
}
EXPORT_SYMBOL_GPL(nvmem_unregister);

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");
Commit	Line	Data
eace75cf SK	1	/*
	2	* nvmem framework core.
	3	*
	4	* Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
	5	* Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 and
	9	* only version 2 as published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/device.h>
	18	#include <linux/export.h>
	19	#include <linux/fs.h>
	20	#include <linux/idr.h>
	21	#include <linux/init.h>
	22	#include <linux/module.h>
	23	#include <linux/nvmem-consumer.h>
	24	#include <linux/nvmem-provider.h>
	25	#include <linux/of.h>
	26	#include <linux/regmap.h>
	27	#include <linux/slab.h>
	28
	29	struct nvmem_device {
	30	const char *name;
	31	struct regmap *regmap;
	32	struct module *owner;
	33	struct device dev;
	34	int stride;
	35	int word_size;
	36	int ncells;
	37	int id;
	38	int users;
	39	size_t size;
	40	bool read_only;
	41	};
	42
	43	struct nvmem_cell {
	44	const char *name;
	45	int offset;
	46	int bytes;
	47	int bit_offset;
	48	int nbits;
	49	struct nvmem_device *nvmem;
	50	struct list_head node;
	51	};
	52
	53	static DEFINE_MUTEX(nvmem_mutex);
	54	static DEFINE_IDA(nvmem_ida);
	55
	56	static LIST_HEAD(nvmem_cells);
	57	static DEFINE_MUTEX(nvmem_cells_mutex);
	58
	59	#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
	60
	61	static ssize_t bin_attr_nvmem_read(struct file filp, struct kobject kobj,
	62	struct bin_attribute *attr,
	63	char *buf, loff_t pos, size_t count)
	64	{
65	struct device *dev = container_of(kobj, struct device, kobj);
66	struct nvmem_device *nvmem = to_nvmem_device(dev);
67	int rc;
68
69	/* Stop the user from reading */
70	if (pos > nvmem->size)
71	return 0;
72
73	if (pos + count > nvmem->size)
74	count = nvmem->size - pos;
75
76	count = round_down(count, nvmem->word_size);
77
78	rc = regmap_raw_read(nvmem->regmap, pos, buf, count);
79
80	if (IS_ERR_VALUE(rc))
81	return rc;
82
83	return count;
84	}
85
86	static ssize_t bin_attr_nvmem_write(struct file filp, struct kobject kobj,
87	struct bin_attribute *attr,
88	char *buf, loff_t pos, size_t count)
89	{
90	struct device *dev = container_of(kobj, struct device, kobj);
91	struct nvmem_device *nvmem = to_nvmem_device(dev);
92	int rc;
93
94	/* Stop the user from writing */
95	if (pos > nvmem->size)
96	return 0;
97
98	if (pos + count > nvmem->size)
99	count = nvmem->size - pos;
100
101	count = round_down(count, nvmem->word_size);
102
103	rc = regmap_raw_write(nvmem->regmap, pos, buf, count);
104
105	if (IS_ERR_VALUE(rc))
106	return rc;
107
108	return count;
109	}
110
111	/* default read/write permissions */
112	static struct bin_attribute bin_attr_rw_nvmem = {
113	.attr = {
114	.name = "nvmem",
115	.mode = S_IWUSR \| S_IRUGO,
116	},
117	.read = bin_attr_nvmem_read,
118	.write = bin_attr_nvmem_write,
119	};
120
121	static struct bin_attribute *nvmem_bin_rw_attributes[] = {
122	&bin_attr_rw_nvmem,
123	NULL,
124	};
125
126	static const struct attribute_group nvmem_bin_rw_group = {
127	.bin_attrs = nvmem_bin_rw_attributes,
128	};
129
130	static const struct attribute_group *nvmem_rw_dev_groups[] = {
131	&nvmem_bin_rw_group,
132	NULL,
133	};
134
135	/* read only permission */
136	static struct bin_attribute bin_attr_ro_nvmem = {
137	.attr = {
138	.name = "nvmem",
139	.mode = S_IRUGO,
140	},
141	.read = bin_attr_nvmem_read,
142	};
143
144	static struct bin_attribute *nvmem_bin_ro_attributes[] = {
145	&bin_attr_ro_nvmem,
146	NULL,
147	};
148
149	static const struct attribute_group nvmem_bin_ro_group = {
150	.bin_attrs = nvmem_bin_ro_attributes,
151	};
152
153	static const struct attribute_group *nvmem_ro_dev_groups[] = {
154	&nvmem_bin_ro_group,
155	NULL,
156	};
157
158	static void nvmem_release(struct device *dev)
159	{
160	struct nvmem_device *nvmem = to_nvmem_device(dev);
161
162	ida_simple_remove(&nvmem_ida, nvmem->id);
163	kfree(nvmem);
164	}
165
166	static const struct device_type nvmem_provider_type = {
167	.release = nvmem_release,
168	};
169
170	static struct bus_type nvmem_bus_type = {
171	.name = "nvmem",
172	};
173
174	static int of_nvmem_match(struct device dev, void nvmem_np)
175	{
176	return dev->of_node == nvmem_np;
177	}
178
179	static struct nvmem_device of_nvmem_find(struct device_node nvmem_np)
180	{
181	struct device *d;
182
183	if (!nvmem_np)
184	return NULL;
185
186	d = bus_find_device(&nvmem_bus_type, NULL, nvmem_np, of_nvmem_match);
187
188	if (!d)
189	return NULL;
190
191	return to_nvmem_device(d);
192	}
193
194	static struct nvmem_cell nvmem_find_cell(const char cell_id)
195	{
196	struct nvmem_cell *p;
197
198	list_for_each_entry(p, &nvmem_cells, node)
199	if (p && !strcmp(p->name, cell_id))
200	return p;
201
202	return NULL;
203	}
204
205	static void nvmem_cell_drop(struct nvmem_cell *cell)
206	{
207	mutex_lock(&nvmem_cells_mutex);
208	list_del(&cell->node);
209	mutex_unlock(&nvmem_cells_mutex);
210	kfree(cell);
211	}
212
213	static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
214	{
215	struct nvmem_cell *cell;
216	struct list_head p, n;
217
218	list_for_each_safe(p, n, &nvmem_cells) {
219	cell = list_entry(p, struct nvmem_cell, node);
220	if (cell->nvmem == nvmem)
221	nvmem_cell_drop(cell);
222	}
223	}
224
225	static void nvmem_cell_add(struct nvmem_cell *cell)
226	{
227	mutex_lock(&nvmem_cells_mutex);
228	list_add_tail(&cell->node, &nvmem_cells);
229	mutex_unlock(&nvmem_cells_mutex);
230	}
231
232	static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
233	const struct nvmem_cell_info *info,
234	struct nvmem_cell *cell)
235	{
236	cell->nvmem = nvmem;
237	cell->offset = info->offset;
238	cell->bytes = info->bytes;
239	cell->name = info->name;
240
241	cell->bit_offset = info->bit_offset;
242	cell->nbits = info->nbits;
243
244	if (cell->nbits)
245	cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
246	BITS_PER_BYTE);
247
248	if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
249	dev_err(&nvmem->dev,
250	"cell %s unaligned to nvmem stride %d\n",
251	cell->name, nvmem->stride);
252	return -EINVAL;
253	}
254
255	return 0;
256	}
257
258	static int nvmem_add_cells(struct nvmem_device *nvmem,
259	const struct nvmem_config *cfg)
260	{
261	struct nvmem_cell **cells;
262	const struct nvmem_cell_info *info = cfg->cells;
263	int i, rval;
264
265	cells = kcalloc(cfg->ncells, sizeof(*cells), GFP_KERNEL);
266	if (!cells)
267	return -ENOMEM;
268
269	for (i = 0; i < cfg->ncells; i++) {
270	cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
271	if (!cells[i]) {
272	rval = -ENOMEM;
273	goto err;
274	}
275
276	rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
277	if (IS_ERR_VALUE(rval)) {
278	kfree(cells[i]);
279	goto err;
280	}
281
282	nvmem_cell_add(cells[i]);
283	}
284
285	nvmem->ncells = cfg->ncells;
286	/* remove tmp array */
287	kfree(cells);
288
289	return 0;
290	err:
291	while (--i)
292	nvmem_cell_drop(cells[i]);
293
294	return rval;
295	}
296
297	/**
298	* nvmem_register() - Register a nvmem device for given nvmem_config.
299	* Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
300	*
301	* @config: nvmem device configuration with which nvmem device is created.
302	*
303	* Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
304	* on success.
305	*/
306
307	struct nvmem_device nvmem_register(const struct nvmem_config config)
308	{
309	struct nvmem_device *nvmem;
310	struct device_node *np;
311	struct regmap *rm;
312	int rval;
313
314	if (!config->dev)
315	return ERR_PTR(-EINVAL);
316
317	rm = dev_get_regmap(config->dev, NULL);
318	if (!rm) {
319	dev_err(config->dev, "Regmap not found\n");
320	return ERR_PTR(-EINVAL);
321	}
322
323	nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
324	if (!nvmem)
325	return ERR_PTR(-ENOMEM);
326
327	rval = ida_simple_get(&nvmem_ida, 0, 0, GFP_KERNEL);
328	if (rval < 0) {
329	kfree(nvmem);
330	return ERR_PTR(rval);
331	}
332
333	nvmem->id = rval;
334	nvmem->regmap = rm;
335	nvmem->owner = config->owner;
336	nvmem->stride = regmap_get_reg_stride(rm);
337	nvmem->word_size = regmap_get_val_bytes(rm);
338	nvmem->size = regmap_get_max_register(rm) + nvmem->stride;
339	nvmem->dev.type = &nvmem_provider_type;
340	nvmem->dev.bus = &nvmem_bus_type;
341	nvmem->dev.parent = config->dev;
342	np = config->dev->of_node;
343	nvmem->dev.of_node = np;
344	dev_set_name(&nvmem->dev, "%s%d",
345	config->name ? : "nvmem", config->id);
346
347	nvmem->read_only = of_property_read_bool(np, "read-only") \|
348	config->read_only;
349
350	nvmem->dev.groups = nvmem->read_only ? nvmem_ro_dev_groups :
351	nvmem_rw_dev_groups;
352
353	device_initialize(&nvmem->dev);
354
355	dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
356
357	rval = device_add(&nvmem->dev);
358	if (rval) {
359	ida_simple_remove(&nvmem_ida, nvmem->id);
360	kfree(nvmem);
361	return ERR_PTR(rval);
362	}
363
364	if (config->cells)
365	nvmem_add_cells(nvmem, config);
366
367	return nvmem;
368	}
369	EXPORT_SYMBOL_GPL(nvmem_register);
370
371	/**
372	* nvmem_unregister() - Unregister previously registered nvmem device
373	*
374	* @nvmem: Pointer to previously registered nvmem device.
375	*
376	* Return: Will be an negative on error or a zero on success.
377	*/
378	int nvmem_unregister(struct nvmem_device *nvmem)
379	{
380	if (nvmem->users)
381	return -EBUSY;
382
383	nvmem_device_remove_all_cells(nvmem);
384	device_del(&nvmem->dev);
385
386	return 0;
387	}
388	EXPORT_SYMBOL_GPL(nvmem_unregister);
389
390	static int __init nvmem_init(void)
391	{
392	return bus_register(&nvmem_bus_type);
393	}
394
395	static void __exit nvmem_exit(void)
396	{
397	bus_unregister(&nvmem_bus_type);
398	}
399
400	subsys_initcall(nvmem_init);
401	module_exit(nvmem_exit);
402
403	MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
404	MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
405	MODULE_DESCRIPTION("nvmem Driver Core");
406	MODULE_LICENSE("GPL v2");