Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * nvmem framework core.
4 *
5 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
6 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
7 */
8
9#include <linux/device.h>
10#include <linux/export.h>
11#include <linux/fs.h>
12#include <linux/idr.h>
13#include <linux/init.h>
14#include <linux/kref.h>
15#include <linux/module.h>
16#include <linux/nvmem-consumer.h>
17#include <linux/nvmem-provider.h>
18#include <linux/gpio/consumer.h>
19#include <linux/of.h>
20#include <linux/slab.h>
21
22struct nvmem_device {
23 struct module *owner;
24 struct device dev;
25 int stride;
26 int word_size;
27 int id;
28 struct kref refcnt;
29 size_t size;
30 bool read_only;
31 bool root_only;
32 int flags;
33 enum nvmem_type type;
34 struct bin_attribute eeprom;
35 struct device *base_dev;
36 struct list_head cells;
37 nvmem_reg_read_t reg_read;
38 nvmem_reg_write_t reg_write;
39 struct gpio_desc *wp_gpio;
40 void *priv;
41};
42
43#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
44
45#define FLAG_COMPAT BIT(0)
46
47struct nvmem_cell {
48 const char *name;
49 int offset;
50 int bytes;
51 int bit_offset;
52 int nbits;
53 struct device_node *np;
54 struct nvmem_device *nvmem;
55 struct list_head node;
56};
57
58static DEFINE_MUTEX(nvmem_mutex);
59static DEFINE_IDA(nvmem_ida);
60
61static DEFINE_MUTEX(nvmem_cell_mutex);
62static LIST_HEAD(nvmem_cell_tables);
63
64static DEFINE_MUTEX(nvmem_lookup_mutex);
65static LIST_HEAD(nvmem_lookup_list);
66
67static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
68
69static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
70 void *val, size_t bytes)
71{
72 if (nvmem->reg_read)
73 return nvmem->reg_read(nvmem->priv, offset, val, bytes);
74
75 return -EINVAL;
76}
77
78static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
79 void *val, size_t bytes)
80{
81 int ret;
82
83 if (nvmem->reg_write) {
84 gpiod_set_value_cansleep(nvmem->wp_gpio, 0);
85 ret = nvmem->reg_write(nvmem->priv, offset, val, bytes);
86 gpiod_set_value_cansleep(nvmem->wp_gpio, 1);
87 return ret;
88 }
89
90 return -EINVAL;
91}
92
93#ifdef CONFIG_NVMEM_SYSFS
94static const char * const nvmem_type_str[] = {
95 [NVMEM_TYPE_UNKNOWN] = "Unknown",
96 [NVMEM_TYPE_EEPROM] = "EEPROM",
97 [NVMEM_TYPE_OTP] = "OTP",
98 [NVMEM_TYPE_BATTERY_BACKED] = "Battery backed",
99};
100
101#ifdef CONFIG_DEBUG_LOCK_ALLOC
102static struct lock_class_key eeprom_lock_key;
103#endif
104
105static ssize_t type_show(struct device *dev,
106 struct device_attribute *attr, char *buf)
107{
108 struct nvmem_device *nvmem = to_nvmem_device(dev);
109
110 return sprintf(buf, "%s\n", nvmem_type_str[nvmem->type]);
111}
112
113static DEVICE_ATTR_RO(type);
114
115static struct attribute *nvmem_attrs[] = {
116 &dev_attr_type.attr,
117 NULL,
118};
119
120static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
121 struct bin_attribute *attr, char *buf,
122 loff_t pos, size_t count)
123{
124 struct device *dev;
125 struct nvmem_device *nvmem;
126 int rc;
127
128 if (attr->private)
129 dev = attr->private;
130 else
131 dev = container_of(kobj, struct device, kobj);
132 nvmem = to_nvmem_device(dev);
133
134 /* Stop the user from reading */
135 if (pos >= nvmem->size)
136 return 0;
137
138 if (!IS_ALIGNED(pos, nvmem->stride))
139 return -EINVAL;
140
141 if (count < nvmem->word_size)
142 return -EINVAL;
143
144 if (pos + count > nvmem->size)
145 count = nvmem->size - pos;
146
147 count = round_down(count, nvmem->word_size);
148
149 if (!nvmem->reg_read)
150 return -EPERM;
151
152 rc = nvmem_reg_read(nvmem, pos, buf, count);
153
154 if (rc)
155 return rc;
156
157 return count;
158}
159
160static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
161 struct bin_attribute *attr, char *buf,
162 loff_t pos, size_t count)
163{
164 struct device *dev;
165 struct nvmem_device *nvmem;
166 int rc;
167
168 if (attr->private)
169 dev = attr->private;
170 else
171 dev = container_of(kobj, struct device, kobj);
172 nvmem = to_nvmem_device(dev);
173
174 /* Stop the user from writing */
175 if (pos >= nvmem->size)
176 return -EFBIG;
177
178 if (!IS_ALIGNED(pos, nvmem->stride))
179 return -EINVAL;
180
181 if (count < nvmem->word_size)
182 return -EINVAL;
183
184 if (pos + count > nvmem->size)
185 count = nvmem->size - pos;
186
187 count = round_down(count, nvmem->word_size);
188
189 if (!nvmem->reg_write)
190 return -EPERM;
191
192 rc = nvmem_reg_write(nvmem, pos, buf, count);
193
194 if (rc)
195 return rc;
196
197 return count;
198}
199
200static umode_t nvmem_bin_attr_get_umode(struct nvmem_device *nvmem)
201{
202 umode_t mode = 0400;
203
204 if (!nvmem->root_only)
205 mode |= 0044;
206
207 if (!nvmem->read_only)
208 mode |= 0200;
209
210 if (!nvmem->reg_write)
211 mode &= ~0200;
212
213 if (!nvmem->reg_read)
214 mode &= ~0444;
215
216 return mode;
217}
218
219static umode_t nvmem_bin_attr_is_visible(struct kobject *kobj,
220 struct bin_attribute *attr, int i)
221{
222 struct device *dev = container_of(kobj, struct device, kobj);
223 struct nvmem_device *nvmem = to_nvmem_device(dev);
224
225 return nvmem_bin_attr_get_umode(nvmem);
226}
227
228/* default read/write permissions */
229static struct bin_attribute bin_attr_rw_nvmem = {
230 .attr = {
231 .name = "nvmem",
232 .mode = 0644,
233 },
234 .read = bin_attr_nvmem_read,
235 .write = bin_attr_nvmem_write,
236};
237
238static struct bin_attribute *nvmem_bin_attributes[] = {
239 &bin_attr_rw_nvmem,
240 NULL,
241};
242
243static const struct attribute_group nvmem_bin_group = {
244 .bin_attrs = nvmem_bin_attributes,
245 .attrs = nvmem_attrs,
246 .is_bin_visible = nvmem_bin_attr_is_visible,
247};
248
249static const struct attribute_group *nvmem_dev_groups[] = {
250 &nvmem_bin_group,
251 NULL,
252};
253
254static struct bin_attribute bin_attr_nvmem_eeprom_compat = {
255 .attr = {
256 .name = "eeprom",
257 },
258 .read = bin_attr_nvmem_read,
259 .write = bin_attr_nvmem_write,
260};
261
262/*
263 * nvmem_setup_compat() - Create an additional binary entry in
264 * drivers sys directory, to be backwards compatible with the older
265 * drivers/misc/eeprom drivers.
266 */
267static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
268 const struct nvmem_config *config)
269{
270 int rval;
271
272 if (!config->compat)
273 return 0;
274
275 if (!config->base_dev)
276 return -EINVAL;
277
278 nvmem->eeprom = bin_attr_nvmem_eeprom_compat;
279 nvmem->eeprom.attr.mode = nvmem_bin_attr_get_umode(nvmem);
280 nvmem->eeprom.size = nvmem->size;
281#ifdef CONFIG_DEBUG_LOCK_ALLOC
282 nvmem->eeprom.attr.key = &eeprom_lock_key;
283#endif
284 nvmem->eeprom.private = &nvmem->dev;
285 nvmem->base_dev = config->base_dev;
286
287 rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
288 if (rval) {
289 dev_err(&nvmem->dev,
290 "Failed to create eeprom binary file %d\n", rval);
291 return rval;
292 }
293
294 nvmem->flags |= FLAG_COMPAT;
295
296 return 0;
297}
298
299static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
300 const struct nvmem_config *config)
301{
302 if (config->compat)
303 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
304}
305
306#else /* CONFIG_NVMEM_SYSFS */
307
308static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
309 const struct nvmem_config *config)
310{
311 return -ENOSYS;
312}
313static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
314 const struct nvmem_config *config)
315{
316}
317
318#endif /* CONFIG_NVMEM_SYSFS */
319
320static void nvmem_release(struct device *dev)
321{
322 struct nvmem_device *nvmem = to_nvmem_device(dev);
323
324 ida_simple_remove(&nvmem_ida, nvmem->id);
325 gpiod_put(nvmem->wp_gpio);
326 kfree(nvmem);
327}
328
329static const struct device_type nvmem_provider_type = {
330 .release = nvmem_release,
331};
332
333static struct bus_type nvmem_bus_type = {
334 .name = "nvmem",
335};
336
337static void nvmem_cell_drop(struct nvmem_cell *cell)
338{
339 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
340 mutex_lock(&nvmem_mutex);
341 list_del(&cell->node);
342 mutex_unlock(&nvmem_mutex);
343 of_node_put(cell->np);
344 kfree_const(cell->name);
345 kfree(cell);
346}
347
348static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
349{
350 struct nvmem_cell *cell, *p;
351
352 list_for_each_entry_safe(cell, p, &nvmem->cells, node)
353 nvmem_cell_drop(cell);
354}
355
356static void nvmem_cell_add(struct nvmem_cell *cell)
357{
358 mutex_lock(&nvmem_mutex);
359 list_add_tail(&cell->node, &cell->nvmem->cells);
360 mutex_unlock(&nvmem_mutex);
361 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_ADD, cell);
362}
363
364static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
365 const struct nvmem_cell_info *info,
366 struct nvmem_cell *cell)
367{
368 cell->nvmem = nvmem;
369 cell->offset = info->offset;
370 cell->bytes = info->bytes;
371 cell->name = kstrdup_const(info->name, GFP_KERNEL);
372 if (!cell->name)
373 return -ENOMEM;
374
375 cell->bit_offset = info->bit_offset;
376 cell->nbits = info->nbits;
377
378 if (cell->nbits)
379 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
380 BITS_PER_BYTE);
381
382 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
383 dev_err(&nvmem->dev,
384 "cell %s unaligned to nvmem stride %d\n",
385 cell->name, nvmem->stride);
386 return -EINVAL;
387 }
388
389 return 0;
390}
391
392/**
393 * nvmem_add_cells() - Add cell information to an nvmem device
394 *
395 * @nvmem: nvmem device to add cells to.
396 * @info: nvmem cell info to add to the device
397 * @ncells: number of cells in info
398 *
399 * Return: 0 or negative error code on failure.
400 */
401static int nvmem_add_cells(struct nvmem_device *nvmem,
402 const struct nvmem_cell_info *info,
403 int ncells)
404{
405 struct nvmem_cell **cells;
406 int i, rval;
407
408 cells = kcalloc(ncells, sizeof(*cells), GFP_KERNEL);
409 if (!cells)
410 return -ENOMEM;
411
412 for (i = 0; i < ncells; i++) {
413 cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
414 if (!cells[i]) {
415 rval = -ENOMEM;
416 goto err;
417 }
418
419 rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
420 if (rval) {
421 kfree(cells[i]);
422 goto err;
423 }
424
425 nvmem_cell_add(cells[i]);
426 }
427
428 /* remove tmp array */
429 kfree(cells);
430
431 return 0;
432err:
433 while (i--)
434 nvmem_cell_drop(cells[i]);
435
436 kfree(cells);
437
438 return rval;
439}
440
441/**
442 * nvmem_register_notifier() - Register a notifier block for nvmem events.
443 *
444 * @nb: notifier block to be called on nvmem events.
445 *
446 * Return: 0 on success, negative error number on failure.
447 */
448int nvmem_register_notifier(struct notifier_block *nb)
449{
450 return blocking_notifier_chain_register(&nvmem_notifier, nb);
451}
452EXPORT_SYMBOL_GPL(nvmem_register_notifier);
453
454/**
455 * nvmem_unregister_notifier() - Unregister a notifier block for nvmem events.
456 *
457 * @nb: notifier block to be unregistered.
458 *
459 * Return: 0 on success, negative error number on failure.
460 */
461int nvmem_unregister_notifier(struct notifier_block *nb)
462{
463 return blocking_notifier_chain_unregister(&nvmem_notifier, nb);
464}
465EXPORT_SYMBOL_GPL(nvmem_unregister_notifier);
466
467static int nvmem_add_cells_from_table(struct nvmem_device *nvmem)
468{
469 const struct nvmem_cell_info *info;
470 struct nvmem_cell_table *table;
471 struct nvmem_cell *cell;
472 int rval = 0, i;
473
474 mutex_lock(&nvmem_cell_mutex);
475 list_for_each_entry(table, &nvmem_cell_tables, node) {
476 if (strcmp(nvmem_dev_name(nvmem), table->nvmem_name) == 0) {
477 for (i = 0; i < table->ncells; i++) {
478 info = &table->cells[i];
479
480 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
481 if (!cell) {
482 rval = -ENOMEM;
483 goto out;
484 }
485
486 rval = nvmem_cell_info_to_nvmem_cell(nvmem,
487 info,
488 cell);
489 if (rval) {
490 kfree(cell);
491 goto out;
492 }
493
494 nvmem_cell_add(cell);
495 }
496 }
497 }
498
499out:
500 mutex_unlock(&nvmem_cell_mutex);
501 return rval;
502}
503
504static struct nvmem_cell *
505nvmem_find_cell_by_name(struct nvmem_device *nvmem, const char *cell_id)
506{
507 struct nvmem_cell *iter, *cell = NULL;
508
509 mutex_lock(&nvmem_mutex);
510 list_for_each_entry(iter, &nvmem->cells, node) {
511 if (strcmp(cell_id, iter->name) == 0) {
512 cell = iter;
513 break;
514 }
515 }
516 mutex_unlock(&nvmem_mutex);
517
518 return cell;
519}
520
521static int nvmem_add_cells_from_of(struct nvmem_device *nvmem)
522{
523 struct device_node *parent, *child;
524 struct device *dev = &nvmem->dev;
525 struct nvmem_cell *cell;
526 const __be32 *addr;
527 int len;
528
529 parent = dev->of_node;
530
531 for_each_child_of_node(parent, child) {
532 addr = of_get_property(child, "reg", &len);
533 if (!addr || (len < 2 * sizeof(u32))) {
534 dev_err(dev, "nvmem: invalid reg on %pOF\n", child);
535 return -EINVAL;
536 }
537
538 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
539 if (!cell)
540 return -ENOMEM;
541
542 cell->nvmem = nvmem;
543 cell->np = of_node_get(child);
544 cell->offset = be32_to_cpup(addr++);
545 cell->bytes = be32_to_cpup(addr);
546 cell->name = kasprintf(GFP_KERNEL, "%pOFn", child);
547
548 addr = of_get_property(child, "bits", &len);
549 if (addr && len == (2 * sizeof(u32))) {
550 cell->bit_offset = be32_to_cpup(addr++);
551 cell->nbits = be32_to_cpup(addr);
552 }
553
554 if (cell->nbits)
555 cell->bytes = DIV_ROUND_UP(
556 cell->nbits + cell->bit_offset,
557 BITS_PER_BYTE);
558
559 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
560 dev_err(dev, "cell %s unaligned to nvmem stride %d\n",
561 cell->name, nvmem->stride);
562 /* Cells already added will be freed later. */
563 kfree_const(cell->name);
564 kfree(cell);
565 return -EINVAL;
566 }
567
568 nvmem_cell_add(cell);
569 }
570
571 return 0;
572}
573
574/**
575 * nvmem_register() - Register a nvmem device for given nvmem_config.
576 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
577 *
578 * @config: nvmem device configuration with which nvmem device is created.
579 *
580 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
581 * on success.
582 */
583
584struct nvmem_device *nvmem_register(const struct nvmem_config *config)
585{
586 struct nvmem_device *nvmem;
587 int rval;
588
589 if (!config->dev)
590 return ERR_PTR(-EINVAL);
591
592 if (!config->reg_read && !config->reg_write)
593 return ERR_PTR(-EINVAL);
594
595 nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
596 if (!nvmem)
597 return ERR_PTR(-ENOMEM);
598
599 rval = ida_simple_get(&nvmem_ida, 0, 0, GFP_KERNEL);
600 if (rval < 0) {
601 kfree(nvmem);
602 return ERR_PTR(rval);
603 }
604
605 if (config->wp_gpio)
606 nvmem->wp_gpio = config->wp_gpio;
607 else
608 nvmem->wp_gpio = gpiod_get_optional(config->dev, "wp",
609 GPIOD_OUT_HIGH);
610 if (IS_ERR(nvmem->wp_gpio)) {
611 ida_simple_remove(&nvmem_ida, nvmem->id);
612 rval = PTR_ERR(nvmem->wp_gpio);
613 kfree(nvmem);
614 return ERR_PTR(rval);
615 }
616
617 kref_init(&nvmem->refcnt);
618 INIT_LIST_HEAD(&nvmem->cells);
619
620 nvmem->id = rval;
621 nvmem->owner = config->owner;
622 if (!nvmem->owner && config->dev->driver)
623 nvmem->owner = config->dev->driver->owner;
624 nvmem->stride = config->stride ?: 1;
625 nvmem->word_size = config->word_size ?: 1;
626 nvmem->size = config->size;
627 nvmem->dev.type = &nvmem_provider_type;
628 nvmem->dev.bus = &nvmem_bus_type;
629 nvmem->dev.parent = config->dev;
630 nvmem->root_only = config->root_only;
631 nvmem->priv = config->priv;
632 nvmem->type = config->type;
633 nvmem->reg_read = config->reg_read;
634 nvmem->reg_write = config->reg_write;
635 if (!config->no_of_node)
636 nvmem->dev.of_node = config->dev->of_node;
637
638 switch (config->id) {
639 case NVMEM_DEVID_NONE:
640 dev_set_name(&nvmem->dev, "%s", config->name);
641 break;
642 case NVMEM_DEVID_AUTO:
643 dev_set_name(&nvmem->dev, "%s%d", config->name, nvmem->id);
644 break;
645 default:
646 dev_set_name(&nvmem->dev, "%s%d",
647 config->name ? : "nvmem",
648 config->name ? config->id : nvmem->id);
649 break;
650 }
651
652 nvmem->read_only = device_property_present(config->dev, "read-only") ||
653 config->read_only || !nvmem->reg_write;
654
655#ifdef CONFIG_NVMEM_SYSFS
656 nvmem->dev.groups = nvmem_dev_groups;
657#endif
658
659 dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
660
661 rval = device_register(&nvmem->dev);
662 if (rval)
663 goto err_put_device;
664
665 if (config->compat) {
666 rval = nvmem_sysfs_setup_compat(nvmem, config);
667 if (rval)
668 goto err_device_del;
669 }
670
671 if (config->cells) {
672 rval = nvmem_add_cells(nvmem, config->cells, config->ncells);
673 if (rval)
674 goto err_teardown_compat;
675 }
676
677 rval = nvmem_add_cells_from_table(nvmem);
678 if (rval)
679 goto err_remove_cells;
680
681 rval = nvmem_add_cells_from_of(nvmem);
682 if (rval)
683 goto err_remove_cells;
684
685 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
686
687 return nvmem;
688
689err_remove_cells:
690 nvmem_device_remove_all_cells(nvmem);
691err_teardown_compat:
692 if (config->compat)
693 nvmem_sysfs_remove_compat(nvmem, config);
694err_device_del:
695 device_del(&nvmem->dev);
696err_put_device:
697 put_device(&nvmem->dev);
698
699 return ERR_PTR(rval);
700}
701EXPORT_SYMBOL_GPL(nvmem_register);
702
703static void nvmem_device_release(struct kref *kref)
704{
705 struct nvmem_device *nvmem;
706
707 nvmem = container_of(kref, struct nvmem_device, refcnt);
708
709 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
710
711 if (nvmem->flags & FLAG_COMPAT)
712 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
713
714 nvmem_device_remove_all_cells(nvmem);
715 device_unregister(&nvmem->dev);
716}
717
718/**
719 * nvmem_unregister() - Unregister previously registered nvmem device
720 *
721 * @nvmem: Pointer to previously registered nvmem device.
722 */
723void nvmem_unregister(struct nvmem_device *nvmem)
724{
725 kref_put(&nvmem->refcnt, nvmem_device_release);
726}
727EXPORT_SYMBOL_GPL(nvmem_unregister);
728
729static void devm_nvmem_release(struct device *dev, void *res)
730{
731 nvmem_unregister(*(struct nvmem_device **)res);
732}
733
734/**
735 * devm_nvmem_register() - Register a managed nvmem device for given
736 * nvmem_config.
737 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
738 *
739 * @dev: Device that uses the nvmem device.
740 * @config: nvmem device configuration with which nvmem device is created.
741 *
742 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
743 * on success.
744 */
745struct nvmem_device *devm_nvmem_register(struct device *dev,
746 const struct nvmem_config *config)
747{
748 struct nvmem_device **ptr, *nvmem;
749
750 ptr = devres_alloc(devm_nvmem_release, sizeof(*ptr), GFP_KERNEL);
751 if (!ptr)
752 return ERR_PTR(-ENOMEM);
753
754 nvmem = nvmem_register(config);
755
756 if (!IS_ERR(nvmem)) {
757 *ptr = nvmem;
758 devres_add(dev, ptr);
759 } else {
760 devres_free(ptr);
761 }
762
763 return nvmem;
764}
765EXPORT_SYMBOL_GPL(devm_nvmem_register);
766
767static int devm_nvmem_match(struct device *dev, void *res, void *data)
768{
769 struct nvmem_device **r = res;
770
771 return *r == data;
772}
773
774/**
775 * devm_nvmem_unregister() - Unregister previously registered managed nvmem
776 * device.
777 *
778 * @dev: Device that uses the nvmem device.
779 * @nvmem: Pointer to previously registered nvmem device.
780 *
781 * Return: Will be negative on error or zero on success.
782 */
783int devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem)
784{
785 return devres_release(dev, devm_nvmem_release, devm_nvmem_match, nvmem);
786}
787EXPORT_SYMBOL(devm_nvmem_unregister);
788
789static struct nvmem_device *__nvmem_device_get(void *data,
790 int (*match)(struct device *dev, const void *data))
791{
792 struct nvmem_device *nvmem = NULL;
793 struct device *dev;
794
795 mutex_lock(&nvmem_mutex);
796 dev = bus_find_device(&nvmem_bus_type, NULL, data, match);
797 if (dev)
798 nvmem = to_nvmem_device(dev);
799 mutex_unlock(&nvmem_mutex);
800 if (!nvmem)
801 return ERR_PTR(-EPROBE_DEFER);
802
803 if (!try_module_get(nvmem->owner)) {
804 dev_err(&nvmem->dev,
805 "could not increase module refcount for cell %s\n",
806 nvmem_dev_name(nvmem));
807
808 put_device(&nvmem->dev);
809 return ERR_PTR(-EINVAL);
810 }
811
812 kref_get(&nvmem->refcnt);
813
814 return nvmem;
815}
816
817static void __nvmem_device_put(struct nvmem_device *nvmem)
818{
819 put_device(&nvmem->dev);
820 module_put(nvmem->owner);
821 kref_put(&nvmem->refcnt, nvmem_device_release);
822}
823
824#if IS_ENABLED(CONFIG_OF)
825/**
826 * of_nvmem_device_get() - Get nvmem device from a given id
827 *
828 * @np: Device tree node that uses the nvmem device.
829 * @id: nvmem name from nvmem-names property.
830 *
831 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
832 * on success.
833 */
834struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
835{
836
837 struct device_node *nvmem_np;
838 int index = 0;
839
840 if (id)
841 index = of_property_match_string(np, "nvmem-names", id);
842
843 nvmem_np = of_parse_phandle(np, "nvmem", index);
844 if (!nvmem_np)
845 return ERR_PTR(-ENOENT);
846
847 return __nvmem_device_get(nvmem_np, device_match_of_node);
848}
849EXPORT_SYMBOL_GPL(of_nvmem_device_get);
850#endif
851
852/**
853 * nvmem_device_get() - Get nvmem device from a given id
854 *
855 * @dev: Device that uses the nvmem device.
856 * @dev_name: name of the requested nvmem device.
857 *
858 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
859 * on success.
860 */
861struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
862{
863 if (dev->of_node) { /* try dt first */
864 struct nvmem_device *nvmem;
865
866 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
867
868 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
869 return nvmem;
870
871 }
872
873 return __nvmem_device_get((void *)dev_name, device_match_name);
874}
875EXPORT_SYMBOL_GPL(nvmem_device_get);
876
877/**
878 * nvmem_device_find() - Find nvmem device with matching function
879 *
880 * @data: Data to pass to match function
881 * @match: Callback function to check device
882 *
883 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
884 * on success.
885 */
886struct nvmem_device *nvmem_device_find(void *data,
887 int (*match)(struct device *dev, const void *data))
888{
889 return __nvmem_device_get(data, match);
890}
891EXPORT_SYMBOL_GPL(nvmem_device_find);
892
893static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
894{
895 struct nvmem_device **nvmem = res;
896
897 if (WARN_ON(!nvmem || !*nvmem))
898 return 0;
899
900 return *nvmem == data;
901}
902
903static void devm_nvmem_device_release(struct device *dev, void *res)
904{
905 nvmem_device_put(*(struct nvmem_device **)res);
906}
907
908/**
909 * devm_nvmem_device_put() - put alredy got nvmem device
910 *
911 * @dev: Device that uses the nvmem device.
912 * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
913 * that needs to be released.
914 */
915void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
916{
917 int ret;
918
919 ret = devres_release(dev, devm_nvmem_device_release,
920 devm_nvmem_device_match, nvmem);
921
922 WARN_ON(ret);
923}
924EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
925
926/**
927 * nvmem_device_put() - put alredy got nvmem device
928 *
929 * @nvmem: pointer to nvmem device that needs to be released.
930 */
931void nvmem_device_put(struct nvmem_device *nvmem)
932{
933 __nvmem_device_put(nvmem);
934}
935EXPORT_SYMBOL_GPL(nvmem_device_put);
936
937/**
938 * devm_nvmem_device_get() - Get nvmem cell of device form a given id
939 *
940 * @dev: Device that requests the nvmem device.
941 * @id: name id for the requested nvmem device.
942 *
943 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
944 * on success. The nvmem_cell will be freed by the automatically once the
945 * device is freed.
946 */
947struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
948{
949 struct nvmem_device **ptr, *nvmem;
950
951 ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
952 if (!ptr)
953 return ERR_PTR(-ENOMEM);
954
955 nvmem = nvmem_device_get(dev, id);
956 if (!IS_ERR(nvmem)) {
957 *ptr = nvmem;
958 devres_add(dev, ptr);
959 } else {
960 devres_free(ptr);
961 }
962
963 return nvmem;
964}
965EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
966
967static struct nvmem_cell *
968nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
969{
970 struct nvmem_cell *cell = ERR_PTR(-ENOENT);
971 struct nvmem_cell_lookup *lookup;
972 struct nvmem_device *nvmem;
973 const char *dev_id;
974
975 if (!dev)
976 return ERR_PTR(-EINVAL);
977
978 dev_id = dev_name(dev);
979
980 mutex_lock(&nvmem_lookup_mutex);
981
982 list_for_each_entry(lookup, &nvmem_lookup_list, node) {
983 if ((strcmp(lookup->dev_id, dev_id) == 0) &&
984 (strcmp(lookup->con_id, con_id) == 0)) {
985 /* This is the right entry. */
986 nvmem = __nvmem_device_get((void *)lookup->nvmem_name,
987 device_match_name);
988 if (IS_ERR(nvmem)) {
989 /* Provider may not be registered yet. */
990 cell = ERR_CAST(nvmem);
991 break;
992 }
993
994 cell = nvmem_find_cell_by_name(nvmem,
995 lookup->cell_name);
996 if (!cell) {
997 __nvmem_device_put(nvmem);
998 cell = ERR_PTR(-ENOENT);
999 }
1000 break;
1001 }
1002 }
1003
1004 mutex_unlock(&nvmem_lookup_mutex);
1005 return cell;
1006}
1007
1008#if IS_ENABLED(CONFIG_OF)
1009static struct nvmem_cell *
1010nvmem_find_cell_by_node(struct nvmem_device *nvmem, struct device_node *np)
1011{
1012 struct nvmem_cell *iter, *cell = NULL;
1013
1014 mutex_lock(&nvmem_mutex);
1015 list_for_each_entry(iter, &nvmem->cells, node) {
1016 if (np == iter->np) {
1017 cell = iter;
1018 break;
1019 }
1020 }
1021 mutex_unlock(&nvmem_mutex);
1022
1023 return cell;
1024}
1025
1026/**
1027 * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
1028 *
1029 * @np: Device tree node that uses the nvmem cell.
1030 * @id: nvmem cell name from nvmem-cell-names property, or NULL
1031 * for the cell at index 0 (the lone cell with no accompanying
1032 * nvmem-cell-names property).
1033 *
1034 * Return: Will be an ERR_PTR() on error or a valid pointer
1035 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1036 * nvmem_cell_put().
1037 */
1038struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
1039{
1040 struct device_node *cell_np, *nvmem_np;
1041 struct nvmem_device *nvmem;
1042 struct nvmem_cell *cell;
1043 int index = 0;
1044
1045 /* if cell name exists, find index to the name */
1046 if (id)
1047 index = of_property_match_string(np, "nvmem-cell-names", id);
1048
1049 cell_np = of_parse_phandle(np, "nvmem-cells", index);
1050 if (!cell_np)
1051 return ERR_PTR(-ENOENT);
1052
1053 nvmem_np = of_get_next_parent(cell_np);
1054 if (!nvmem_np)
1055 return ERR_PTR(-EINVAL);
1056
1057 nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1058 of_node_put(nvmem_np);
1059 if (IS_ERR(nvmem))
1060 return ERR_CAST(nvmem);
1061
1062 cell = nvmem_find_cell_by_node(nvmem, cell_np);
1063 if (!cell) {
1064 __nvmem_device_put(nvmem);
1065 return ERR_PTR(-ENOENT);
1066 }
1067
1068 return cell;
1069}
1070EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
1071#endif
1072
1073/**
1074 * nvmem_cell_get() - Get nvmem cell of device form a given cell name
1075 *
1076 * @dev: Device that requests the nvmem cell.
1077 * @id: nvmem cell name to get (this corresponds with the name from the
1078 * nvmem-cell-names property for DT systems and with the con_id from
1079 * the lookup entry for non-DT systems).
1080 *
1081 * Return: Will be an ERR_PTR() on error or a valid pointer
1082 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1083 * nvmem_cell_put().
1084 */
1085struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id)
1086{
1087 struct nvmem_cell *cell;
1088
1089 if (dev->of_node) { /* try dt first */
1090 cell = of_nvmem_cell_get(dev->of_node, id);
1091 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
1092 return cell;
1093 }
1094
1095 /* NULL cell id only allowed for device tree; invalid otherwise */
1096 if (!id)
1097 return ERR_PTR(-EINVAL);
1098
1099 return nvmem_cell_get_from_lookup(dev, id);
1100}
1101EXPORT_SYMBOL_GPL(nvmem_cell_get);
1102
1103static void devm_nvmem_cell_release(struct device *dev, void *res)
1104{
1105 nvmem_cell_put(*(struct nvmem_cell **)res);
1106}
1107
1108/**
1109 * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
1110 *
1111 * @dev: Device that requests the nvmem cell.
1112 * @id: nvmem cell name id to get.
1113 *
1114 * Return: Will be an ERR_PTR() on error or a valid pointer
1115 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1116 * automatically once the device is freed.
1117 */
1118struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
1119{
1120 struct nvmem_cell **ptr, *cell;
1121
1122 ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
1123 if (!ptr)
1124 return ERR_PTR(-ENOMEM);
1125
1126 cell = nvmem_cell_get(dev, id);
1127 if (!IS_ERR(cell)) {
1128 *ptr = cell;
1129 devres_add(dev, ptr);
1130 } else {
1131 devres_free(ptr);
1132 }
1133
1134 return cell;
1135}
1136EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
1137
1138static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
1139{
1140 struct nvmem_cell **c = res;
1141
1142 if (WARN_ON(!c || !*c))
1143 return 0;
1144
1145 return *c == data;
1146}
1147
1148/**
1149 * devm_nvmem_cell_put() - Release previously allocated nvmem cell
1150 * from devm_nvmem_cell_get.
1151 *
1152 * @dev: Device that requests the nvmem cell.
1153 * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get().
1154 */
1155void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
1156{
1157 int ret;
1158
1159 ret = devres_release(dev, devm_nvmem_cell_release,
1160 devm_nvmem_cell_match, cell);
1161
1162 WARN_ON(ret);
1163}
1164EXPORT_SYMBOL(devm_nvmem_cell_put);
1165
1166/**
1167 * nvmem_cell_put() - Release previously allocated nvmem cell.
1168 *
1169 * @cell: Previously allocated nvmem cell by nvmem_cell_get().
1170 */
1171void nvmem_cell_put(struct nvmem_cell *cell)
1172{
1173 struct nvmem_device *nvmem = cell->nvmem;
1174
1175 __nvmem_device_put(nvmem);
1176}
1177EXPORT_SYMBOL_GPL(nvmem_cell_put);
1178
1179static void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell, void *buf)
1180{
1181 u8 *p, *b;
1182 int i, extra, bit_offset = cell->bit_offset;
1183
1184 p = b = buf;
1185 if (bit_offset) {
1186 /* First shift */
1187 *b++ >>= bit_offset;
1188
1189 /* setup rest of the bytes if any */
1190 for (i = 1; i < cell->bytes; i++) {
1191 /* Get bits from next byte and shift them towards msb */
1192 *p |= *b << (BITS_PER_BYTE - bit_offset);
1193
1194 p = b;
1195 *b++ >>= bit_offset;
1196 }
1197 } else {
1198 /* point to the msb */
1199 p += cell->bytes - 1;
1200 }
1201
1202 /* result fits in less bytes */
1203 extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);
1204 while (--extra >= 0)
1205 *p-- = 0;
1206
1207 /* clear msb bits if any leftover in the last byte */
1208 *p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0);
1209}
1210
1211static int __nvmem_cell_read(struct nvmem_device *nvmem,
1212 struct nvmem_cell *cell,
1213 void *buf, size_t *len)
1214{
1215 int rc;
1216
1217 rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->bytes);
1218
1219 if (rc)
1220 return rc;
1221
1222 /* shift bits in-place */
1223 if (cell->bit_offset || cell->nbits)
1224 nvmem_shift_read_buffer_in_place(cell, buf);
1225
1226 if (len)
1227 *len = cell->bytes;
1228
1229 return 0;
1230}
1231
1232/**
1233 * nvmem_cell_read() - Read a given nvmem cell
1234 *
1235 * @cell: nvmem cell to be read.
1236 * @len: pointer to length of cell which will be populated on successful read;
1237 * can be NULL.
1238 *
1239 * Return: ERR_PTR() on error or a valid pointer to a buffer on success. The
1240 * buffer should be freed by the consumer with a kfree().
1241 */
1242void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
1243{
1244 struct nvmem_device *nvmem = cell->nvmem;
1245 u8 *buf;
1246 int rc;
1247
1248 if (!nvmem)
1249 return ERR_PTR(-EINVAL);
1250
1251 buf = kzalloc(cell->bytes, GFP_KERNEL);
1252 if (!buf)
1253 return ERR_PTR(-ENOMEM);
1254
1255 rc = __nvmem_cell_read(nvmem, cell, buf, len);
1256 if (rc) {
1257 kfree(buf);
1258 return ERR_PTR(rc);
1259 }
1260
1261 return buf;
1262}
1263EXPORT_SYMBOL_GPL(nvmem_cell_read);
1264
1265static void *nvmem_cell_prepare_write_buffer(struct nvmem_cell *cell,
1266 u8 *_buf, int len)
1267{
1268 struct nvmem_device *nvmem = cell->nvmem;
1269 int i, rc, nbits, bit_offset = cell->bit_offset;
1270 u8 v, *p, *buf, *b, pbyte, pbits;
1271
1272 nbits = cell->nbits;
1273 buf = kzalloc(cell->bytes, GFP_KERNEL);
1274 if (!buf)
1275 return ERR_PTR(-ENOMEM);
1276
1277 memcpy(buf, _buf, len);
1278 p = b = buf;
1279
1280 if (bit_offset) {
1281 pbyte = *b;
1282 *b <<= bit_offset;
1283
1284 /* setup the first byte with lsb bits from nvmem */
1285 rc = nvmem_reg_read(nvmem, cell->offset, &v, 1);
1286 if (rc)
1287 goto err;
1288 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1289
1290 /* setup rest of the byte if any */
1291 for (i = 1; i < cell->bytes; i++) {
1292 /* Get last byte bits and shift them towards lsb */
1293 pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1294 pbyte = *b;
1295 p = b;
1296 *b <<= bit_offset;
1297 *b++ |= pbits;
1298 }
1299 }
1300
1301 /* if it's not end on byte boundary */
1302 if ((nbits + bit_offset) % BITS_PER_BYTE) {
1303 /* setup the last byte with msb bits from nvmem */
1304 rc = nvmem_reg_read(nvmem,
1305 cell->offset + cell->bytes - 1, &v, 1);
1306 if (rc)
1307 goto err;
1308 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1309
1310 }
1311
1312 return buf;
1313err:
1314 kfree(buf);
1315 return ERR_PTR(rc);
1316}
1317
1318/**
1319 * nvmem_cell_write() - Write to a given nvmem cell
1320 *
1321 * @cell: nvmem cell to be written.
1322 * @buf: Buffer to be written.
1323 * @len: length of buffer to be written to nvmem cell.
1324 *
1325 * Return: length of bytes written or negative on failure.
1326 */
1327int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1328{
1329 struct nvmem_device *nvmem = cell->nvmem;
1330 int rc;
1331
1332 if (!nvmem || nvmem->read_only ||
1333 (cell->bit_offset == 0 && len != cell->bytes))
1334 return -EINVAL;
1335
1336 if (cell->bit_offset || cell->nbits) {
1337 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1338 if (IS_ERR(buf))
1339 return PTR_ERR(buf);
1340 }
1341
1342 rc = nvmem_reg_write(nvmem, cell->offset, buf, cell->bytes);
1343
1344 /* free the tmp buffer */
1345 if (cell->bit_offset || cell->nbits)
1346 kfree(buf);
1347
1348 if (rc)
1349 return rc;
1350
1351 return len;
1352}
1353EXPORT_SYMBOL_GPL(nvmem_cell_write);
1354
1355static int nvmem_cell_read_common(struct device *dev, const char *cell_id,
1356 void *val, size_t count)
1357{
1358 struct nvmem_cell *cell;
1359 void *buf;
1360 size_t len;
1361
1362 cell = nvmem_cell_get(dev, cell_id);
1363 if (IS_ERR(cell))
1364 return PTR_ERR(cell);
1365
1366 buf = nvmem_cell_read(cell, &len);
1367 if (IS_ERR(buf)) {
1368 nvmem_cell_put(cell);
1369 return PTR_ERR(buf);
1370 }
1371 if (len != count) {
1372 kfree(buf);
1373 nvmem_cell_put(cell);
1374 return -EINVAL;
1375 }
1376 memcpy(val, buf, count);
1377 kfree(buf);
1378 nvmem_cell_put(cell);
1379
1380 return 0;
1381}
1382
1383/**
1384 * nvmem_cell_read_u8() - Read a cell value as a u8
1385 *
1386 * @dev: Device that requests the nvmem cell.
1387 * @cell_id: Name of nvmem cell to read.
1388 * @val: pointer to output value.
1389 *
1390 * Return: 0 on success or negative errno.
1391 */
1392int nvmem_cell_read_u8(struct device *dev, const char *cell_id, u8 *val)
1393{
1394 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1395}
1396EXPORT_SYMBOL_GPL(nvmem_cell_read_u8);
1397
1398/**
1399 * nvmem_cell_read_u16() - Read a cell value as a u16
1400 *
1401 * @dev: Device that requests the nvmem cell.
1402 * @cell_id: Name of nvmem cell to read.
1403 * @val: pointer to output value.
1404 *
1405 * Return: 0 on success or negative errno.
1406 */
1407int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val)
1408{
1409 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1410}
1411EXPORT_SYMBOL_GPL(nvmem_cell_read_u16);
1412
1413/**
1414 * nvmem_cell_read_u32() - Read a cell value as a u32
1415 *
1416 * @dev: Device that requests the nvmem cell.
1417 * @cell_id: Name of nvmem cell to read.
1418 * @val: pointer to output value.
1419 *
1420 * Return: 0 on success or negative errno.
1421 */
1422int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val)
1423{
1424 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1425}
1426EXPORT_SYMBOL_GPL(nvmem_cell_read_u32);
1427
1428/**
1429 * nvmem_cell_read_u64() - Read a cell value as a u64
1430 *
1431 * @dev: Device that requests the nvmem cell.
1432 * @cell_id: Name of nvmem cell to read.
1433 * @val: pointer to output value.
1434 *
1435 * Return: 0 on success or negative errno.
1436 */
1437int nvmem_cell_read_u64(struct device *dev, const char *cell_id, u64 *val)
1438{
1439 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1440}
1441EXPORT_SYMBOL_GPL(nvmem_cell_read_u64);
1442
1443/**
1444 * nvmem_device_cell_read() - Read a given nvmem device and cell
1445 *
1446 * @nvmem: nvmem device to read from.
1447 * @info: nvmem cell info to be read.
1448 * @buf: buffer pointer which will be populated on successful read.
1449 *
1450 * Return: length of successful bytes read on success and negative
1451 * error code on error.
1452 */
1453ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
1454 struct nvmem_cell_info *info, void *buf)
1455{
1456 struct nvmem_cell cell;
1457 int rc;
1458 ssize_t len;
1459
1460 if (!nvmem)
1461 return -EINVAL;
1462
1463 rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1464 if (rc)
1465 return rc;
1466
1467 rc = __nvmem_cell_read(nvmem, &cell, buf, &len);
1468 if (rc)
1469 return rc;
1470
1471 return len;
1472}
1473EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
1474
1475/**
1476 * nvmem_device_cell_write() - Write cell to a given nvmem device
1477 *
1478 * @nvmem: nvmem device to be written to.
1479 * @info: nvmem cell info to be written.
1480 * @buf: buffer to be written to cell.
1481 *
1482 * Return: length of bytes written or negative error code on failure.
1483 */
1484int nvmem_device_cell_write(struct nvmem_device *nvmem,
1485 struct nvmem_cell_info *info, void *buf)
1486{
1487 struct nvmem_cell cell;
1488 int rc;
1489
1490 if (!nvmem)
1491 return -EINVAL;
1492
1493 rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1494 if (rc)
1495 return rc;
1496
1497 return nvmem_cell_write(&cell, buf, cell.bytes);
1498}
1499EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
1500
1501/**
1502 * nvmem_device_read() - Read from a given nvmem device
1503 *
1504 * @nvmem: nvmem device to read from.
1505 * @offset: offset in nvmem device.
1506 * @bytes: number of bytes to read.
1507 * @buf: buffer pointer which will be populated on successful read.
1508 *
1509 * Return: length of successful bytes read on success and negative
1510 * error code on error.
1511 */
1512int nvmem_device_read(struct nvmem_device *nvmem,
1513 unsigned int offset,
1514 size_t bytes, void *buf)
1515{
1516 int rc;
1517
1518 if (!nvmem)
1519 return -EINVAL;
1520
1521 rc = nvmem_reg_read(nvmem, offset, buf, bytes);
1522
1523 if (rc)
1524 return rc;
1525
1526 return bytes;
1527}
1528EXPORT_SYMBOL_GPL(nvmem_device_read);
1529
1530/**
1531 * nvmem_device_write() - Write cell to a given nvmem device
1532 *
1533 * @nvmem: nvmem device to be written to.
1534 * @offset: offset in nvmem device.
1535 * @bytes: number of bytes to write.
1536 * @buf: buffer to be written.
1537 *
1538 * Return: length of bytes written or negative error code on failure.
1539 */
1540int nvmem_device_write(struct nvmem_device *nvmem,
1541 unsigned int offset,
1542 size_t bytes, void *buf)
1543{
1544 int rc;
1545
1546 if (!nvmem)
1547 return -EINVAL;
1548
1549 rc = nvmem_reg_write(nvmem, offset, buf, bytes);
1550
1551 if (rc)
1552 return rc;
1553
1554
1555 return bytes;
1556}
1557EXPORT_SYMBOL_GPL(nvmem_device_write);
1558
1559/**
1560 * nvmem_add_cell_table() - register a table of cell info entries
1561 *
1562 * @table: table of cell info entries
1563 */
1564void nvmem_add_cell_table(struct nvmem_cell_table *table)
1565{
1566 mutex_lock(&nvmem_cell_mutex);
1567 list_add_tail(&table->node, &nvmem_cell_tables);
1568 mutex_unlock(&nvmem_cell_mutex);
1569}
1570EXPORT_SYMBOL_GPL(nvmem_add_cell_table);
1571
1572/**
1573 * nvmem_del_cell_table() - remove a previously registered cell info table
1574 *
1575 * @table: table of cell info entries
1576 */
1577void nvmem_del_cell_table(struct nvmem_cell_table *table)
1578{
1579 mutex_lock(&nvmem_cell_mutex);
1580 list_del(&table->node);
1581 mutex_unlock(&nvmem_cell_mutex);
1582}
1583EXPORT_SYMBOL_GPL(nvmem_del_cell_table);
1584
1585/**
1586 * nvmem_add_cell_lookups() - register a list of cell lookup entries
1587 *
1588 * @entries: array of cell lookup entries
1589 * @nentries: number of cell lookup entries in the array
1590 */
1591void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
1592{
1593 int i;
1594
1595 mutex_lock(&nvmem_lookup_mutex);
1596 for (i = 0; i < nentries; i++)
1597 list_add_tail(&entries[i].node, &nvmem_lookup_list);
1598 mutex_unlock(&nvmem_lookup_mutex);
1599}
1600EXPORT_SYMBOL_GPL(nvmem_add_cell_lookups);
1601
1602/**
1603 * nvmem_del_cell_lookups() - remove a list of previously added cell lookup
1604 * entries
1605 *
1606 * @entries: array of cell lookup entries
1607 * @nentries: number of cell lookup entries in the array
1608 */
1609void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
1610{
1611 int i;
1612
1613 mutex_lock(&nvmem_lookup_mutex);
1614 for (i = 0; i < nentries; i++)
1615 list_del(&entries[i].node);
1616 mutex_unlock(&nvmem_lookup_mutex);
1617}
1618EXPORT_SYMBOL_GPL(nvmem_del_cell_lookups);
1619
1620/**
1621 * nvmem_dev_name() - Get the name of a given nvmem device.
1622 *
1623 * @nvmem: nvmem device.
1624 *
1625 * Return: name of the nvmem device.
1626 */
1627const char *nvmem_dev_name(struct nvmem_device *nvmem)
1628{
1629 return dev_name(&nvmem->dev);
1630}
1631EXPORT_SYMBOL_GPL(nvmem_dev_name);
1632
1633static int __init nvmem_init(void)
1634{
1635 return bus_register(&nvmem_bus_type);
1636}
1637
1638static void __exit nvmem_exit(void)
1639{
1640 bus_unregister(&nvmem_bus_type);
1641}
1642
1643subsys_initcall(nvmem_init);
1644module_exit(nvmem_exit);
1645
1646MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
1647MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
1648MODULE_DESCRIPTION("nvmem Driver Core");
1649MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * nvmem framework core.
4 *
5 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
6 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
7 */
8
9#include <linux/device.h>
10#include <linux/export.h>
11#include <linux/fs.h>
12#include <linux/idr.h>
13#include <linux/init.h>
14#include <linux/kref.h>
15#include <linux/module.h>
16#include <linux/nvmem-consumer.h>
17#include <linux/nvmem-provider.h>
18#include <linux/gpio/consumer.h>
19#include <linux/of.h>
20#include <linux/slab.h>
21
22#include "internals.h"
23
24#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
25
26#define FLAG_COMPAT BIT(0)
27struct nvmem_cell_entry {
28 const char *name;
29 int offset;
30 size_t raw_len;
31 int bytes;
32 int bit_offset;
33 int nbits;
34 nvmem_cell_post_process_t read_post_process;
35 void *priv;
36 struct device_node *np;
37 struct nvmem_device *nvmem;
38 struct list_head node;
39};
40
41struct nvmem_cell {
42 struct nvmem_cell_entry *entry;
43 const char *id;
44 int index;
45};
46
47static DEFINE_MUTEX(nvmem_mutex);
48static DEFINE_IDA(nvmem_ida);
49
50static DEFINE_MUTEX(nvmem_cell_mutex);
51static LIST_HEAD(nvmem_cell_tables);
52
53static DEFINE_MUTEX(nvmem_lookup_mutex);
54static LIST_HEAD(nvmem_lookup_list);
55
56static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
57
58static int __nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
59 void *val, size_t bytes)
60{
61 if (nvmem->reg_read)
62 return nvmem->reg_read(nvmem->priv, offset, val, bytes);
63
64 return -EINVAL;
65}
66
67static int __nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
68 void *val, size_t bytes)
69{
70 int ret;
71
72 if (nvmem->reg_write) {
73 gpiod_set_value_cansleep(nvmem->wp_gpio, 0);
74 ret = nvmem->reg_write(nvmem->priv, offset, val, bytes);
75 gpiod_set_value_cansleep(nvmem->wp_gpio, 1);
76 return ret;
77 }
78
79 return -EINVAL;
80}
81
82static int nvmem_access_with_keepouts(struct nvmem_device *nvmem,
83 unsigned int offset, void *val,
84 size_t bytes, int write)
85{
86
87 unsigned int end = offset + bytes;
88 unsigned int kend, ksize;
89 const struct nvmem_keepout *keepout = nvmem->keepout;
90 const struct nvmem_keepout *keepoutend = keepout + nvmem->nkeepout;
91 int rc;
92
93 /*
94 * Skip all keepouts before the range being accessed.
95 * Keepouts are sorted.
96 */
97 while ((keepout < keepoutend) && (keepout->end <= offset))
98 keepout++;
99
100 while ((offset < end) && (keepout < keepoutend)) {
101 /* Access the valid portion before the keepout. */
102 if (offset < keepout->start) {
103 kend = min(end, keepout->start);
104 ksize = kend - offset;
105 if (write)
106 rc = __nvmem_reg_write(nvmem, offset, val, ksize);
107 else
108 rc = __nvmem_reg_read(nvmem, offset, val, ksize);
109
110 if (rc)
111 return rc;
112
113 offset += ksize;
114 val += ksize;
115 }
116
117 /*
118 * Now we're aligned to the start of this keepout zone. Go
119 * through it.
120 */
121 kend = min(end, keepout->end);
122 ksize = kend - offset;
123 if (!write)
124 memset(val, keepout->value, ksize);
125
126 val += ksize;
127 offset += ksize;
128 keepout++;
129 }
130
131 /*
132 * If we ran out of keepouts but there's still stuff to do, send it
133 * down directly
134 */
135 if (offset < end) {
136 ksize = end - offset;
137 if (write)
138 return __nvmem_reg_write(nvmem, offset, val, ksize);
139 else
140 return __nvmem_reg_read(nvmem, offset, val, ksize);
141 }
142
143 return 0;
144}
145
146static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
147 void *val, size_t bytes)
148{
149 if (!nvmem->nkeepout)
150 return __nvmem_reg_read(nvmem, offset, val, bytes);
151
152 return nvmem_access_with_keepouts(nvmem, offset, val, bytes, false);
153}
154
155static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
156 void *val, size_t bytes)
157{
158 if (!nvmem->nkeepout)
159 return __nvmem_reg_write(nvmem, offset, val, bytes);
160
161 return nvmem_access_with_keepouts(nvmem, offset, val, bytes, true);
162}
163
164#ifdef CONFIG_NVMEM_SYSFS
165static const char * const nvmem_type_str[] = {
166 [NVMEM_TYPE_UNKNOWN] = "Unknown",
167 [NVMEM_TYPE_EEPROM] = "EEPROM",
168 [NVMEM_TYPE_OTP] = "OTP",
169 [NVMEM_TYPE_BATTERY_BACKED] = "Battery backed",
170 [NVMEM_TYPE_FRAM] = "FRAM",
171};
172
173#ifdef CONFIG_DEBUG_LOCK_ALLOC
174static struct lock_class_key eeprom_lock_key;
175#endif
176
177static ssize_t type_show(struct device *dev,
178 struct device_attribute *attr, char *buf)
179{
180 struct nvmem_device *nvmem = to_nvmem_device(dev);
181
182 return sysfs_emit(buf, "%s\n", nvmem_type_str[nvmem->type]);
183}
184
185static DEVICE_ATTR_RO(type);
186
187static ssize_t force_ro_show(struct device *dev, struct device_attribute *attr,
188 char *buf)
189{
190 struct nvmem_device *nvmem = to_nvmem_device(dev);
191
192 return sysfs_emit(buf, "%d\n", nvmem->read_only);
193}
194
195static ssize_t force_ro_store(struct device *dev, struct device_attribute *attr,
196 const char *buf, size_t count)
197{
198 struct nvmem_device *nvmem = to_nvmem_device(dev);
199 int ret = kstrtobool(buf, &nvmem->read_only);
200
201 if (ret < 0)
202 return ret;
203
204 return count;
205}
206
207static DEVICE_ATTR_RW(force_ro);
208
209static struct attribute *nvmem_attrs[] = {
210 &dev_attr_force_ro.attr,
211 &dev_attr_type.attr,
212 NULL,
213};
214
215static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
216 struct bin_attribute *attr, char *buf,
217 loff_t pos, size_t count)
218{
219 struct device *dev;
220 struct nvmem_device *nvmem;
221 int rc;
222
223 if (attr->private)
224 dev = attr->private;
225 else
226 dev = kobj_to_dev(kobj);
227 nvmem = to_nvmem_device(dev);
228
229 if (!IS_ALIGNED(pos, nvmem->stride))
230 return -EINVAL;
231
232 if (count < nvmem->word_size)
233 return -EINVAL;
234
235 count = round_down(count, nvmem->word_size);
236
237 if (!nvmem->reg_read)
238 return -EPERM;
239
240 rc = nvmem_reg_read(nvmem, pos, buf, count);
241
242 if (rc)
243 return rc;
244
245 return count;
246}
247
248static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
249 struct bin_attribute *attr, char *buf,
250 loff_t pos, size_t count)
251{
252 struct device *dev;
253 struct nvmem_device *nvmem;
254 int rc;
255
256 if (attr->private)
257 dev = attr->private;
258 else
259 dev = kobj_to_dev(kobj);
260 nvmem = to_nvmem_device(dev);
261
262 if (!IS_ALIGNED(pos, nvmem->stride))
263 return -EINVAL;
264
265 if (count < nvmem->word_size)
266 return -EINVAL;
267
268 count = round_down(count, nvmem->word_size);
269
270 if (!nvmem->reg_write || nvmem->read_only)
271 return -EPERM;
272
273 rc = nvmem_reg_write(nvmem, pos, buf, count);
274
275 if (rc)
276 return rc;
277
278 return count;
279}
280
281static umode_t nvmem_bin_attr_get_umode(struct nvmem_device *nvmem)
282{
283 umode_t mode = 0400;
284
285 if (!nvmem->root_only)
286 mode |= 0044;
287
288 if (!nvmem->read_only)
289 mode |= 0200;
290
291 if (!nvmem->reg_write)
292 mode &= ~0200;
293
294 if (!nvmem->reg_read)
295 mode &= ~0444;
296
297 return mode;
298}
299
300static umode_t nvmem_bin_attr_is_visible(struct kobject *kobj,
301 const struct bin_attribute *attr,
302 int i)
303{
304 struct device *dev = kobj_to_dev(kobj);
305 struct nvmem_device *nvmem = to_nvmem_device(dev);
306
307 return nvmem_bin_attr_get_umode(nvmem);
308}
309
310static size_t nvmem_bin_attr_size(struct kobject *kobj,
311 const struct bin_attribute *attr,
312 int i)
313{
314 struct device *dev = kobj_to_dev(kobj);
315 struct nvmem_device *nvmem = to_nvmem_device(dev);
316
317 return nvmem->size;
318}
319
320static umode_t nvmem_attr_is_visible(struct kobject *kobj,
321 struct attribute *attr, int i)
322{
323 struct device *dev = kobj_to_dev(kobj);
324 struct nvmem_device *nvmem = to_nvmem_device(dev);
325
326 /*
327 * If the device has no .reg_write operation, do not allow
328 * configuration as read-write.
329 * If the device is set as read-only by configuration, it
330 * can be forced into read-write mode using the 'force_ro'
331 * attribute.
332 */
333 if (attr == &dev_attr_force_ro.attr && !nvmem->reg_write)
334 return 0; /* Attribute not visible */
335
336 return attr->mode;
337}
338
339static struct nvmem_cell *nvmem_create_cell(struct nvmem_cell_entry *entry,
340 const char *id, int index);
341
342static ssize_t nvmem_cell_attr_read(struct file *filp, struct kobject *kobj,
343 struct bin_attribute *attr, char *buf,
344 loff_t pos, size_t count)
345{
346 struct nvmem_cell_entry *entry;
347 struct nvmem_cell *cell = NULL;
348 size_t cell_sz, read_len;
349 void *content;
350
351 entry = attr->private;
352 cell = nvmem_create_cell(entry, entry->name, 0);
353 if (IS_ERR(cell))
354 return PTR_ERR(cell);
355
356 if (!cell)
357 return -EINVAL;
358
359 content = nvmem_cell_read(cell, &cell_sz);
360 if (IS_ERR(content)) {
361 read_len = PTR_ERR(content);
362 goto destroy_cell;
363 }
364
365 read_len = min_t(unsigned int, cell_sz - pos, count);
366 memcpy(buf, content + pos, read_len);
367 kfree(content);
368
369destroy_cell:
370 kfree_const(cell->id);
371 kfree(cell);
372
373 return read_len;
374}
375
376/* default read/write permissions */
377static struct bin_attribute bin_attr_rw_nvmem = {
378 .attr = {
379 .name = "nvmem",
380 .mode = 0644,
381 },
382 .read = bin_attr_nvmem_read,
383 .write = bin_attr_nvmem_write,
384};
385
386static struct bin_attribute *nvmem_bin_attributes[] = {
387 &bin_attr_rw_nvmem,
388 NULL,
389};
390
391static const struct attribute_group nvmem_bin_group = {
392 .bin_attrs = nvmem_bin_attributes,
393 .attrs = nvmem_attrs,
394 .is_bin_visible = nvmem_bin_attr_is_visible,
395 .bin_size = nvmem_bin_attr_size,
396 .is_visible = nvmem_attr_is_visible,
397};
398
399static const struct attribute_group *nvmem_dev_groups[] = {
400 &nvmem_bin_group,
401 NULL,
402};
403
404static struct bin_attribute bin_attr_nvmem_eeprom_compat = {
405 .attr = {
406 .name = "eeprom",
407 },
408 .read = bin_attr_nvmem_read,
409 .write = bin_attr_nvmem_write,
410};
411
412/*
413 * nvmem_setup_compat() - Create an additional binary entry in
414 * drivers sys directory, to be backwards compatible with the older
415 * drivers/misc/eeprom drivers.
416 */
417static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
418 const struct nvmem_config *config)
419{
420 int rval;
421
422 if (!config->compat)
423 return 0;
424
425 if (!config->base_dev)
426 return -EINVAL;
427
428 nvmem->eeprom = bin_attr_nvmem_eeprom_compat;
429 if (config->type == NVMEM_TYPE_FRAM)
430 nvmem->eeprom.attr.name = "fram";
431 nvmem->eeprom.attr.mode = nvmem_bin_attr_get_umode(nvmem);
432 nvmem->eeprom.size = nvmem->size;
433#ifdef CONFIG_DEBUG_LOCK_ALLOC
434 nvmem->eeprom.attr.key = &eeprom_lock_key;
435#endif
436 nvmem->eeprom.private = &nvmem->dev;
437 nvmem->base_dev = config->base_dev;
438
439 rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
440 if (rval) {
441 dev_err(&nvmem->dev,
442 "Failed to create eeprom binary file %d\n", rval);
443 return rval;
444 }
445
446 nvmem->flags |= FLAG_COMPAT;
447
448 return 0;
449}
450
451static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
452 const struct nvmem_config *config)
453{
454 if (config->compat)
455 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
456}
457
458static int nvmem_populate_sysfs_cells(struct nvmem_device *nvmem)
459{
460 struct attribute_group group = {
461 .name = "cells",
462 };
463 struct nvmem_cell_entry *entry;
464 struct bin_attribute *attrs;
465 unsigned int ncells = 0, i = 0;
466 int ret = 0;
467
468 mutex_lock(&nvmem_mutex);
469
470 if (list_empty(&nvmem->cells) || nvmem->sysfs_cells_populated)
471 goto unlock_mutex;
472
473 /* Allocate an array of attributes with a sentinel */
474 ncells = list_count_nodes(&nvmem->cells);
475 group.bin_attrs = devm_kcalloc(&nvmem->dev, ncells + 1,
476 sizeof(struct bin_attribute *), GFP_KERNEL);
477 if (!group.bin_attrs) {
478 ret = -ENOMEM;
479 goto unlock_mutex;
480 }
481
482 attrs = devm_kcalloc(&nvmem->dev, ncells, sizeof(struct bin_attribute), GFP_KERNEL);
483 if (!attrs) {
484 ret = -ENOMEM;
485 goto unlock_mutex;
486 }
487
488 /* Initialize each attribute to take the name and size of the cell */
489 list_for_each_entry(entry, &nvmem->cells, node) {
490 sysfs_bin_attr_init(&attrs[i]);
491 attrs[i].attr.name = devm_kasprintf(&nvmem->dev, GFP_KERNEL,
492 "%s@%x,%x", entry->name,
493 entry->offset,
494 entry->bit_offset);
495 attrs[i].attr.mode = 0444 & nvmem_bin_attr_get_umode(nvmem);
496 attrs[i].size = entry->bytes;
497 attrs[i].read = &nvmem_cell_attr_read;
498 attrs[i].private = entry;
499 if (!attrs[i].attr.name) {
500 ret = -ENOMEM;
501 goto unlock_mutex;
502 }
503
504 group.bin_attrs[i] = &attrs[i];
505 i++;
506 }
507
508 ret = device_add_group(&nvmem->dev, &group);
509 if (ret)
510 goto unlock_mutex;
511
512 nvmem->sysfs_cells_populated = true;
513
514unlock_mutex:
515 mutex_unlock(&nvmem_mutex);
516
517 return ret;
518}
519
520#else /* CONFIG_NVMEM_SYSFS */
521
522static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
523 const struct nvmem_config *config)
524{
525 return -ENOSYS;
526}
527static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
528 const struct nvmem_config *config)
529{
530}
531
532#endif /* CONFIG_NVMEM_SYSFS */
533
534static void nvmem_release(struct device *dev)
535{
536 struct nvmem_device *nvmem = to_nvmem_device(dev);
537
538 ida_free(&nvmem_ida, nvmem->id);
539 gpiod_put(nvmem->wp_gpio);
540 kfree(nvmem);
541}
542
543static const struct device_type nvmem_provider_type = {
544 .release = nvmem_release,
545};
546
547static struct bus_type nvmem_bus_type = {
548 .name = "nvmem",
549};
550
551static void nvmem_cell_entry_drop(struct nvmem_cell_entry *cell)
552{
553 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
554 mutex_lock(&nvmem_mutex);
555 list_del(&cell->node);
556 mutex_unlock(&nvmem_mutex);
557 of_node_put(cell->np);
558 kfree_const(cell->name);
559 kfree(cell);
560}
561
562static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
563{
564 struct nvmem_cell_entry *cell, *p;
565
566 list_for_each_entry_safe(cell, p, &nvmem->cells, node)
567 nvmem_cell_entry_drop(cell);
568}
569
570static void nvmem_cell_entry_add(struct nvmem_cell_entry *cell)
571{
572 mutex_lock(&nvmem_mutex);
573 list_add_tail(&cell->node, &cell->nvmem->cells);
574 mutex_unlock(&nvmem_mutex);
575 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_ADD, cell);
576}
577
578static int nvmem_cell_info_to_nvmem_cell_entry_nodup(struct nvmem_device *nvmem,
579 const struct nvmem_cell_info *info,
580 struct nvmem_cell_entry *cell)
581{
582 cell->nvmem = nvmem;
583 cell->offset = info->offset;
584 cell->raw_len = info->raw_len ?: info->bytes;
585 cell->bytes = info->bytes;
586 cell->name = info->name;
587 cell->read_post_process = info->read_post_process;
588 cell->priv = info->priv;
589
590 cell->bit_offset = info->bit_offset;
591 cell->nbits = info->nbits;
592 cell->np = info->np;
593
594 if (cell->nbits)
595 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
596 BITS_PER_BYTE);
597
598 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
599 dev_err(&nvmem->dev,
600 "cell %s unaligned to nvmem stride %d\n",
601 cell->name ?: "<unknown>", nvmem->stride);
602 return -EINVAL;
603 }
604
605 return 0;
606}
607
608static int nvmem_cell_info_to_nvmem_cell_entry(struct nvmem_device *nvmem,
609 const struct nvmem_cell_info *info,
610 struct nvmem_cell_entry *cell)
611{
612 int err;
613
614 err = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, cell);
615 if (err)
616 return err;
617
618 cell->name = kstrdup_const(info->name, GFP_KERNEL);
619 if (!cell->name)
620 return -ENOMEM;
621
622 return 0;
623}
624
625/**
626 * nvmem_add_one_cell() - Add one cell information to an nvmem device
627 *
628 * @nvmem: nvmem device to add cells to.
629 * @info: nvmem cell info to add to the device
630 *
631 * Return: 0 or negative error code on failure.
632 */
633int nvmem_add_one_cell(struct nvmem_device *nvmem,
634 const struct nvmem_cell_info *info)
635{
636 struct nvmem_cell_entry *cell;
637 int rval;
638
639 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
640 if (!cell)
641 return -ENOMEM;
642
643 rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, info, cell);
644 if (rval) {
645 kfree(cell);
646 return rval;
647 }
648
649 nvmem_cell_entry_add(cell);
650
651 return 0;
652}
653EXPORT_SYMBOL_GPL(nvmem_add_one_cell);
654
655/**
656 * nvmem_add_cells() - Add cell information to an nvmem device
657 *
658 * @nvmem: nvmem device to add cells to.
659 * @info: nvmem cell info to add to the device
660 * @ncells: number of cells in info
661 *
662 * Return: 0 or negative error code on failure.
663 */
664static int nvmem_add_cells(struct nvmem_device *nvmem,
665 const struct nvmem_cell_info *info,
666 int ncells)
667{
668 int i, rval;
669
670 for (i = 0; i < ncells; i++) {
671 rval = nvmem_add_one_cell(nvmem, &info[i]);
672 if (rval)
673 return rval;
674 }
675
676 return 0;
677}
678
679/**
680 * nvmem_register_notifier() - Register a notifier block for nvmem events.
681 *
682 * @nb: notifier block to be called on nvmem events.
683 *
684 * Return: 0 on success, negative error number on failure.
685 */
686int nvmem_register_notifier(struct notifier_block *nb)
687{
688 return blocking_notifier_chain_register(&nvmem_notifier, nb);
689}
690EXPORT_SYMBOL_GPL(nvmem_register_notifier);
691
692/**
693 * nvmem_unregister_notifier() - Unregister a notifier block for nvmem events.
694 *
695 * @nb: notifier block to be unregistered.
696 *
697 * Return: 0 on success, negative error number on failure.
698 */
699int nvmem_unregister_notifier(struct notifier_block *nb)
700{
701 return blocking_notifier_chain_unregister(&nvmem_notifier, nb);
702}
703EXPORT_SYMBOL_GPL(nvmem_unregister_notifier);
704
705static int nvmem_add_cells_from_table(struct nvmem_device *nvmem)
706{
707 const struct nvmem_cell_info *info;
708 struct nvmem_cell_table *table;
709 struct nvmem_cell_entry *cell;
710 int rval = 0, i;
711
712 mutex_lock(&nvmem_cell_mutex);
713 list_for_each_entry(table, &nvmem_cell_tables, node) {
714 if (strcmp(nvmem_dev_name(nvmem), table->nvmem_name) == 0) {
715 for (i = 0; i < table->ncells; i++) {
716 info = &table->cells[i];
717
718 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
719 if (!cell) {
720 rval = -ENOMEM;
721 goto out;
722 }
723
724 rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, info, cell);
725 if (rval) {
726 kfree(cell);
727 goto out;
728 }
729
730 nvmem_cell_entry_add(cell);
731 }
732 }
733 }
734
735out:
736 mutex_unlock(&nvmem_cell_mutex);
737 return rval;
738}
739
740static struct nvmem_cell_entry *
741nvmem_find_cell_entry_by_name(struct nvmem_device *nvmem, const char *cell_id)
742{
743 struct nvmem_cell_entry *iter, *cell = NULL;
744
745 mutex_lock(&nvmem_mutex);
746 list_for_each_entry(iter, &nvmem->cells, node) {
747 if (strcmp(cell_id, iter->name) == 0) {
748 cell = iter;
749 break;
750 }
751 }
752 mutex_unlock(&nvmem_mutex);
753
754 return cell;
755}
756
757static int nvmem_validate_keepouts(struct nvmem_device *nvmem)
758{
759 unsigned int cur = 0;
760 const struct nvmem_keepout *keepout = nvmem->keepout;
761 const struct nvmem_keepout *keepoutend = keepout + nvmem->nkeepout;
762
763 while (keepout < keepoutend) {
764 /* Ensure keepouts are sorted and don't overlap. */
765 if (keepout->start < cur) {
766 dev_err(&nvmem->dev,
767 "Keepout regions aren't sorted or overlap.\n");
768
769 return -ERANGE;
770 }
771
772 if (keepout->end < keepout->start) {
773 dev_err(&nvmem->dev,
774 "Invalid keepout region.\n");
775
776 return -EINVAL;
777 }
778
779 /*
780 * Validate keepouts (and holes between) don't violate
781 * word_size constraints.
782 */
783 if ((keepout->end - keepout->start < nvmem->word_size) ||
784 ((keepout->start != cur) &&
785 (keepout->start - cur < nvmem->word_size))) {
786
787 dev_err(&nvmem->dev,
788 "Keepout regions violate word_size constraints.\n");
789
790 return -ERANGE;
791 }
792
793 /* Validate keepouts don't violate stride (alignment). */
794 if (!IS_ALIGNED(keepout->start, nvmem->stride) ||
795 !IS_ALIGNED(keepout->end, nvmem->stride)) {
796
797 dev_err(&nvmem->dev,
798 "Keepout regions violate stride.\n");
799
800 return -EINVAL;
801 }
802
803 cur = keepout->end;
804 keepout++;
805 }
806
807 return 0;
808}
809
810static int nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct device_node *np)
811{
812 struct device *dev = &nvmem->dev;
813 struct device_node *child;
814 const __be32 *addr;
815 int len, ret;
816
817 for_each_child_of_node(np, child) {
818 struct nvmem_cell_info info = {0};
819
820 addr = of_get_property(child, "reg", &len);
821 if (!addr)
822 continue;
823 if (len < 2 * sizeof(u32)) {
824 dev_err(dev, "nvmem: invalid reg on %pOF\n", child);
825 of_node_put(child);
826 return -EINVAL;
827 }
828
829 info.offset = be32_to_cpup(addr++);
830 info.bytes = be32_to_cpup(addr);
831 info.name = kasprintf(GFP_KERNEL, "%pOFn", child);
832
833 addr = of_get_property(child, "bits", &len);
834 if (addr && len == (2 * sizeof(u32))) {
835 info.bit_offset = be32_to_cpup(addr++);
836 info.nbits = be32_to_cpup(addr);
837 if (info.bit_offset >= BITS_PER_BYTE || info.nbits < 1) {
838 dev_err(dev, "nvmem: invalid bits on %pOF\n", child);
839 of_node_put(child);
840 return -EINVAL;
841 }
842 }
843
844 info.np = of_node_get(child);
845
846 if (nvmem->fixup_dt_cell_info)
847 nvmem->fixup_dt_cell_info(nvmem, &info);
848
849 ret = nvmem_add_one_cell(nvmem, &info);
850 kfree(info.name);
851 if (ret) {
852 of_node_put(child);
853 return ret;
854 }
855 }
856
857 return 0;
858}
859
860static int nvmem_add_cells_from_legacy_of(struct nvmem_device *nvmem)
861{
862 return nvmem_add_cells_from_dt(nvmem, nvmem->dev.of_node);
863}
864
865static int nvmem_add_cells_from_fixed_layout(struct nvmem_device *nvmem)
866{
867 struct device_node *layout_np;
868 int err = 0;
869
870 layout_np = of_nvmem_layout_get_container(nvmem);
871 if (!layout_np)
872 return 0;
873
874 if (of_device_is_compatible(layout_np, "fixed-layout"))
875 err = nvmem_add_cells_from_dt(nvmem, layout_np);
876
877 of_node_put(layout_np);
878
879 return err;
880}
881
882int nvmem_layout_register(struct nvmem_layout *layout)
883{
884 int ret;
885
886 if (!layout->add_cells)
887 return -EINVAL;
888
889 /* Populate the cells */
890 ret = layout->add_cells(layout);
891 if (ret)
892 return ret;
893
894#ifdef CONFIG_NVMEM_SYSFS
895 ret = nvmem_populate_sysfs_cells(layout->nvmem);
896 if (ret) {
897 nvmem_device_remove_all_cells(layout->nvmem);
898 return ret;
899 }
900#endif
901
902 return 0;
903}
904EXPORT_SYMBOL_GPL(nvmem_layout_register);
905
906void nvmem_layout_unregister(struct nvmem_layout *layout)
907{
908 /* Keep the API even with an empty stub in case we need it later */
909}
910EXPORT_SYMBOL_GPL(nvmem_layout_unregister);
911
912/**
913 * nvmem_register() - Register a nvmem device for given nvmem_config.
914 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
915 *
916 * @config: nvmem device configuration with which nvmem device is created.
917 *
918 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
919 * on success.
920 */
921
922struct nvmem_device *nvmem_register(const struct nvmem_config *config)
923{
924 struct nvmem_device *nvmem;
925 int rval;
926
927 if (!config->dev)
928 return ERR_PTR(-EINVAL);
929
930 if (!config->reg_read && !config->reg_write)
931 return ERR_PTR(-EINVAL);
932
933 nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
934 if (!nvmem)
935 return ERR_PTR(-ENOMEM);
936
937 rval = ida_alloc(&nvmem_ida, GFP_KERNEL);
938 if (rval < 0) {
939 kfree(nvmem);
940 return ERR_PTR(rval);
941 }
942
943 nvmem->id = rval;
944
945 nvmem->dev.type = &nvmem_provider_type;
946 nvmem->dev.bus = &nvmem_bus_type;
947 nvmem->dev.parent = config->dev;
948
949 device_initialize(&nvmem->dev);
950
951 if (!config->ignore_wp)
952 nvmem->wp_gpio = gpiod_get_optional(config->dev, "wp",
953 GPIOD_OUT_HIGH);
954 if (IS_ERR(nvmem->wp_gpio)) {
955 rval = PTR_ERR(nvmem->wp_gpio);
956 nvmem->wp_gpio = NULL;
957 goto err_put_device;
958 }
959
960 kref_init(&nvmem->refcnt);
961 INIT_LIST_HEAD(&nvmem->cells);
962 nvmem->fixup_dt_cell_info = config->fixup_dt_cell_info;
963
964 nvmem->owner = config->owner;
965 if (!nvmem->owner && config->dev->driver)
966 nvmem->owner = config->dev->driver->owner;
967 nvmem->stride = config->stride ?: 1;
968 nvmem->word_size = config->word_size ?: 1;
969 nvmem->size = config->size;
970 nvmem->root_only = config->root_only;
971 nvmem->priv = config->priv;
972 nvmem->type = config->type;
973 nvmem->reg_read = config->reg_read;
974 nvmem->reg_write = config->reg_write;
975 nvmem->keepout = config->keepout;
976 nvmem->nkeepout = config->nkeepout;
977 if (config->of_node)
978 nvmem->dev.of_node = config->of_node;
979 else
980 nvmem->dev.of_node = config->dev->of_node;
981
982 switch (config->id) {
983 case NVMEM_DEVID_NONE:
984 rval = dev_set_name(&nvmem->dev, "%s", config->name);
985 break;
986 case NVMEM_DEVID_AUTO:
987 rval = dev_set_name(&nvmem->dev, "%s%d", config->name, nvmem->id);
988 break;
989 default:
990 rval = dev_set_name(&nvmem->dev, "%s%d",
991 config->name ? : "nvmem",
992 config->name ? config->id : nvmem->id);
993 break;
994 }
995
996 if (rval)
997 goto err_put_device;
998
999 nvmem->read_only = device_property_present(config->dev, "read-only") ||
1000 config->read_only || !nvmem->reg_write;
1001
1002#ifdef CONFIG_NVMEM_SYSFS
1003 nvmem->dev.groups = nvmem_dev_groups;
1004#endif
1005
1006 if (nvmem->nkeepout) {
1007 rval = nvmem_validate_keepouts(nvmem);
1008 if (rval)
1009 goto err_put_device;
1010 }
1011
1012 if (config->compat) {
1013 rval = nvmem_sysfs_setup_compat(nvmem, config);
1014 if (rval)
1015 goto err_put_device;
1016 }
1017
1018 if (config->cells) {
1019 rval = nvmem_add_cells(nvmem, config->cells, config->ncells);
1020 if (rval)
1021 goto err_remove_cells;
1022 }
1023
1024 rval = nvmem_add_cells_from_table(nvmem);
1025 if (rval)
1026 goto err_remove_cells;
1027
1028 if (config->add_legacy_fixed_of_cells) {
1029 rval = nvmem_add_cells_from_legacy_of(nvmem);
1030 if (rval)
1031 goto err_remove_cells;
1032 }
1033
1034 rval = nvmem_add_cells_from_fixed_layout(nvmem);
1035 if (rval)
1036 goto err_remove_cells;
1037
1038 dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
1039
1040 rval = device_add(&nvmem->dev);
1041 if (rval)
1042 goto err_remove_cells;
1043
1044 rval = nvmem_populate_layout(nvmem);
1045 if (rval)
1046 goto err_remove_dev;
1047
1048#ifdef CONFIG_NVMEM_SYSFS
1049 rval = nvmem_populate_sysfs_cells(nvmem);
1050 if (rval)
1051 goto err_destroy_layout;
1052#endif
1053
1054 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
1055
1056 return nvmem;
1057
1058#ifdef CONFIG_NVMEM_SYSFS
1059err_destroy_layout:
1060 nvmem_destroy_layout(nvmem);
1061#endif
1062err_remove_dev:
1063 device_del(&nvmem->dev);
1064err_remove_cells:
1065 nvmem_device_remove_all_cells(nvmem);
1066 if (config->compat)
1067 nvmem_sysfs_remove_compat(nvmem, config);
1068err_put_device:
1069 put_device(&nvmem->dev);
1070
1071 return ERR_PTR(rval);
1072}
1073EXPORT_SYMBOL_GPL(nvmem_register);
1074
1075static void nvmem_device_release(struct kref *kref)
1076{
1077 struct nvmem_device *nvmem;
1078
1079 nvmem = container_of(kref, struct nvmem_device, refcnt);
1080
1081 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
1082
1083 if (nvmem->flags & FLAG_COMPAT)
1084 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
1085
1086 nvmem_device_remove_all_cells(nvmem);
1087 nvmem_destroy_layout(nvmem);
1088 device_unregister(&nvmem->dev);
1089}
1090
1091/**
1092 * nvmem_unregister() - Unregister previously registered nvmem device
1093 *
1094 * @nvmem: Pointer to previously registered nvmem device.
1095 */
1096void nvmem_unregister(struct nvmem_device *nvmem)
1097{
1098 if (nvmem)
1099 kref_put(&nvmem->refcnt, nvmem_device_release);
1100}
1101EXPORT_SYMBOL_GPL(nvmem_unregister);
1102
1103static void devm_nvmem_unregister(void *nvmem)
1104{
1105 nvmem_unregister(nvmem);
1106}
1107
1108/**
1109 * devm_nvmem_register() - Register a managed nvmem device for given
1110 * nvmem_config.
1111 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
1112 *
1113 * @dev: Device that uses the nvmem device.
1114 * @config: nvmem device configuration with which nvmem device is created.
1115 *
1116 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
1117 * on success.
1118 */
1119struct nvmem_device *devm_nvmem_register(struct device *dev,
1120 const struct nvmem_config *config)
1121{
1122 struct nvmem_device *nvmem;
1123 int ret;
1124
1125 nvmem = nvmem_register(config);
1126 if (IS_ERR(nvmem))
1127 return nvmem;
1128
1129 ret = devm_add_action_or_reset(dev, devm_nvmem_unregister, nvmem);
1130 if (ret)
1131 return ERR_PTR(ret);
1132
1133 return nvmem;
1134}
1135EXPORT_SYMBOL_GPL(devm_nvmem_register);
1136
1137static struct nvmem_device *__nvmem_device_get(void *data,
1138 int (*match)(struct device *dev, const void *data))
1139{
1140 struct nvmem_device *nvmem = NULL;
1141 struct device *dev;
1142
1143 mutex_lock(&nvmem_mutex);
1144 dev = bus_find_device(&nvmem_bus_type, NULL, data, match);
1145 if (dev)
1146 nvmem = to_nvmem_device(dev);
1147 mutex_unlock(&nvmem_mutex);
1148 if (!nvmem)
1149 return ERR_PTR(-EPROBE_DEFER);
1150
1151 if (!try_module_get(nvmem->owner)) {
1152 dev_err(&nvmem->dev,
1153 "could not increase module refcount for cell %s\n",
1154 nvmem_dev_name(nvmem));
1155
1156 put_device(&nvmem->dev);
1157 return ERR_PTR(-EINVAL);
1158 }
1159
1160 kref_get(&nvmem->refcnt);
1161
1162 return nvmem;
1163}
1164
1165static void __nvmem_device_put(struct nvmem_device *nvmem)
1166{
1167 put_device(&nvmem->dev);
1168 module_put(nvmem->owner);
1169 kref_put(&nvmem->refcnt, nvmem_device_release);
1170}
1171
1172#if IS_ENABLED(CONFIG_OF)
1173/**
1174 * of_nvmem_device_get() - Get nvmem device from a given id
1175 *
1176 * @np: Device tree node that uses the nvmem device.
1177 * @id: nvmem name from nvmem-names property.
1178 *
1179 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1180 * on success.
1181 */
1182struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
1183{
1184
1185 struct device_node *nvmem_np;
1186 struct nvmem_device *nvmem;
1187 int index = 0;
1188
1189 if (id)
1190 index = of_property_match_string(np, "nvmem-names", id);
1191
1192 nvmem_np = of_parse_phandle(np, "nvmem", index);
1193 if (!nvmem_np)
1194 return ERR_PTR(-ENOENT);
1195
1196 nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1197 of_node_put(nvmem_np);
1198 return nvmem;
1199}
1200EXPORT_SYMBOL_GPL(of_nvmem_device_get);
1201#endif
1202
1203/**
1204 * nvmem_device_get() - Get nvmem device from a given id
1205 *
1206 * @dev: Device that uses the nvmem device.
1207 * @dev_name: name of the requested nvmem device.
1208 *
1209 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1210 * on success.
1211 */
1212struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
1213{
1214 if (dev->of_node) { /* try dt first */
1215 struct nvmem_device *nvmem;
1216
1217 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
1218
1219 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
1220 return nvmem;
1221
1222 }
1223
1224 return __nvmem_device_get((void *)dev_name, device_match_name);
1225}
1226EXPORT_SYMBOL_GPL(nvmem_device_get);
1227
1228/**
1229 * nvmem_device_find() - Find nvmem device with matching function
1230 *
1231 * @data: Data to pass to match function
1232 * @match: Callback function to check device
1233 *
1234 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1235 * on success.
1236 */
1237struct nvmem_device *nvmem_device_find(void *data,
1238 int (*match)(struct device *dev, const void *data))
1239{
1240 return __nvmem_device_get(data, match);
1241}
1242EXPORT_SYMBOL_GPL(nvmem_device_find);
1243
1244static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
1245{
1246 struct nvmem_device **nvmem = res;
1247
1248 if (WARN_ON(!nvmem || !*nvmem))
1249 return 0;
1250
1251 return *nvmem == data;
1252}
1253
1254static void devm_nvmem_device_release(struct device *dev, void *res)
1255{
1256 nvmem_device_put(*(struct nvmem_device **)res);
1257}
1258
1259/**
1260 * devm_nvmem_device_put() - put already got nvmem device
1261 *
1262 * @dev: Device that uses the nvmem device.
1263 * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
1264 * that needs to be released.
1265 */
1266void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
1267{
1268 int ret;
1269
1270 ret = devres_release(dev, devm_nvmem_device_release,
1271 devm_nvmem_device_match, nvmem);
1272
1273 WARN_ON(ret);
1274}
1275EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
1276
1277/**
1278 * nvmem_device_put() - put already got nvmem device
1279 *
1280 * @nvmem: pointer to nvmem device that needs to be released.
1281 */
1282void nvmem_device_put(struct nvmem_device *nvmem)
1283{
1284 __nvmem_device_put(nvmem);
1285}
1286EXPORT_SYMBOL_GPL(nvmem_device_put);
1287
1288/**
1289 * devm_nvmem_device_get() - Get nvmem device of device form a given id
1290 *
1291 * @dev: Device that requests the nvmem device.
1292 * @id: name id for the requested nvmem device.
1293 *
1294 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1295 * on success. The nvmem_device will be freed by the automatically once the
1296 * device is freed.
1297 */
1298struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
1299{
1300 struct nvmem_device **ptr, *nvmem;
1301
1302 ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
1303 if (!ptr)
1304 return ERR_PTR(-ENOMEM);
1305
1306 nvmem = nvmem_device_get(dev, id);
1307 if (!IS_ERR(nvmem)) {
1308 *ptr = nvmem;
1309 devres_add(dev, ptr);
1310 } else {
1311 devres_free(ptr);
1312 }
1313
1314 return nvmem;
1315}
1316EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
1317
1318static struct nvmem_cell *nvmem_create_cell(struct nvmem_cell_entry *entry,
1319 const char *id, int index)
1320{
1321 struct nvmem_cell *cell;
1322 const char *name = NULL;
1323
1324 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
1325 if (!cell)
1326 return ERR_PTR(-ENOMEM);
1327
1328 if (id) {
1329 name = kstrdup_const(id, GFP_KERNEL);
1330 if (!name) {
1331 kfree(cell);
1332 return ERR_PTR(-ENOMEM);
1333 }
1334 }
1335
1336 cell->id = name;
1337 cell->entry = entry;
1338 cell->index = index;
1339
1340 return cell;
1341}
1342
1343static struct nvmem_cell *
1344nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
1345{
1346 struct nvmem_cell_entry *cell_entry;
1347 struct nvmem_cell *cell = ERR_PTR(-ENOENT);
1348 struct nvmem_cell_lookup *lookup;
1349 struct nvmem_device *nvmem;
1350 const char *dev_id;
1351
1352 if (!dev)
1353 return ERR_PTR(-EINVAL);
1354
1355 dev_id = dev_name(dev);
1356
1357 mutex_lock(&nvmem_lookup_mutex);
1358
1359 list_for_each_entry(lookup, &nvmem_lookup_list, node) {
1360 if ((strcmp(lookup->dev_id, dev_id) == 0) &&
1361 (strcmp(lookup->con_id, con_id) == 0)) {
1362 /* This is the right entry. */
1363 nvmem = __nvmem_device_get((void *)lookup->nvmem_name,
1364 device_match_name);
1365 if (IS_ERR(nvmem)) {
1366 /* Provider may not be registered yet. */
1367 cell = ERR_CAST(nvmem);
1368 break;
1369 }
1370
1371 cell_entry = nvmem_find_cell_entry_by_name(nvmem,
1372 lookup->cell_name);
1373 if (!cell_entry) {
1374 __nvmem_device_put(nvmem);
1375 cell = ERR_PTR(-ENOENT);
1376 } else {
1377 cell = nvmem_create_cell(cell_entry, con_id, 0);
1378 if (IS_ERR(cell))
1379 __nvmem_device_put(nvmem);
1380 }
1381 break;
1382 }
1383 }
1384
1385 mutex_unlock(&nvmem_lookup_mutex);
1386 return cell;
1387}
1388
1389static void nvmem_layout_module_put(struct nvmem_device *nvmem)
1390{
1391 if (nvmem->layout && nvmem->layout->dev.driver)
1392 module_put(nvmem->layout->dev.driver->owner);
1393}
1394
1395#if IS_ENABLED(CONFIG_OF)
1396static struct nvmem_cell_entry *
1397nvmem_find_cell_entry_by_node(struct nvmem_device *nvmem, struct device_node *np)
1398{
1399 struct nvmem_cell_entry *iter, *cell = NULL;
1400
1401 mutex_lock(&nvmem_mutex);
1402 list_for_each_entry(iter, &nvmem->cells, node) {
1403 if (np == iter->np) {
1404 cell = iter;
1405 break;
1406 }
1407 }
1408 mutex_unlock(&nvmem_mutex);
1409
1410 return cell;
1411}
1412
1413static int nvmem_layout_module_get_optional(struct nvmem_device *nvmem)
1414{
1415 if (!nvmem->layout)
1416 return 0;
1417
1418 if (!nvmem->layout->dev.driver ||
1419 !try_module_get(nvmem->layout->dev.driver->owner))
1420 return -EPROBE_DEFER;
1421
1422 return 0;
1423}
1424
1425/**
1426 * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
1427 *
1428 * @np: Device tree node that uses the nvmem cell.
1429 * @id: nvmem cell name from nvmem-cell-names property, or NULL
1430 * for the cell at index 0 (the lone cell with no accompanying
1431 * nvmem-cell-names property).
1432 *
1433 * Return: Will be an ERR_PTR() on error or a valid pointer
1434 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1435 * nvmem_cell_put().
1436 */
1437struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
1438{
1439 struct device_node *cell_np, *nvmem_np;
1440 struct nvmem_device *nvmem;
1441 struct nvmem_cell_entry *cell_entry;
1442 struct nvmem_cell *cell;
1443 struct of_phandle_args cell_spec;
1444 int index = 0;
1445 int cell_index = 0;
1446 int ret;
1447
1448 /* if cell name exists, find index to the name */
1449 if (id)
1450 index = of_property_match_string(np, "nvmem-cell-names", id);
1451
1452 ret = of_parse_phandle_with_optional_args(np, "nvmem-cells",
1453 "#nvmem-cell-cells",
1454 index, &cell_spec);
1455 if (ret)
1456 return ERR_PTR(-ENOENT);
1457
1458 if (cell_spec.args_count > 1)
1459 return ERR_PTR(-EINVAL);
1460
1461 cell_np = cell_spec.np;
1462 if (cell_spec.args_count)
1463 cell_index = cell_spec.args[0];
1464
1465 nvmem_np = of_get_parent(cell_np);
1466 if (!nvmem_np) {
1467 of_node_put(cell_np);
1468 return ERR_PTR(-EINVAL);
1469 }
1470
1471 /* nvmem layouts produce cells within the nvmem-layout container */
1472 if (of_node_name_eq(nvmem_np, "nvmem-layout")) {
1473 nvmem_np = of_get_next_parent(nvmem_np);
1474 if (!nvmem_np) {
1475 of_node_put(cell_np);
1476 return ERR_PTR(-EINVAL);
1477 }
1478 }
1479
1480 nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1481 of_node_put(nvmem_np);
1482 if (IS_ERR(nvmem)) {
1483 of_node_put(cell_np);
1484 return ERR_CAST(nvmem);
1485 }
1486
1487 ret = nvmem_layout_module_get_optional(nvmem);
1488 if (ret) {
1489 of_node_put(cell_np);
1490 __nvmem_device_put(nvmem);
1491 return ERR_PTR(ret);
1492 }
1493
1494 cell_entry = nvmem_find_cell_entry_by_node(nvmem, cell_np);
1495 of_node_put(cell_np);
1496 if (!cell_entry) {
1497 __nvmem_device_put(nvmem);
1498 nvmem_layout_module_put(nvmem);
1499 if (nvmem->layout)
1500 return ERR_PTR(-EPROBE_DEFER);
1501 else
1502 return ERR_PTR(-ENOENT);
1503 }
1504
1505 cell = nvmem_create_cell(cell_entry, id, cell_index);
1506 if (IS_ERR(cell)) {
1507 __nvmem_device_put(nvmem);
1508 nvmem_layout_module_put(nvmem);
1509 }
1510
1511 return cell;
1512}
1513EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
1514#endif
1515
1516/**
1517 * nvmem_cell_get() - Get nvmem cell of device form a given cell name
1518 *
1519 * @dev: Device that requests the nvmem cell.
1520 * @id: nvmem cell name to get (this corresponds with the name from the
1521 * nvmem-cell-names property for DT systems and with the con_id from
1522 * the lookup entry for non-DT systems).
1523 *
1524 * Return: Will be an ERR_PTR() on error or a valid pointer
1525 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1526 * nvmem_cell_put().
1527 */
1528struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id)
1529{
1530 struct nvmem_cell *cell;
1531
1532 if (dev->of_node) { /* try dt first */
1533 cell = of_nvmem_cell_get(dev->of_node, id);
1534 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
1535 return cell;
1536 }
1537
1538 /* NULL cell id only allowed for device tree; invalid otherwise */
1539 if (!id)
1540 return ERR_PTR(-EINVAL);
1541
1542 return nvmem_cell_get_from_lookup(dev, id);
1543}
1544EXPORT_SYMBOL_GPL(nvmem_cell_get);
1545
1546static void devm_nvmem_cell_release(struct device *dev, void *res)
1547{
1548 nvmem_cell_put(*(struct nvmem_cell **)res);
1549}
1550
1551/**
1552 * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
1553 *
1554 * @dev: Device that requests the nvmem cell.
1555 * @id: nvmem cell name id to get.
1556 *
1557 * Return: Will be an ERR_PTR() on error or a valid pointer
1558 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1559 * automatically once the device is freed.
1560 */
1561struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
1562{
1563 struct nvmem_cell **ptr, *cell;
1564
1565 ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
1566 if (!ptr)
1567 return ERR_PTR(-ENOMEM);
1568
1569 cell = nvmem_cell_get(dev, id);
1570 if (!IS_ERR(cell)) {
1571 *ptr = cell;
1572 devres_add(dev, ptr);
1573 } else {
1574 devres_free(ptr);
1575 }
1576
1577 return cell;
1578}
1579EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
1580
1581static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
1582{
1583 struct nvmem_cell **c = res;
1584
1585 if (WARN_ON(!c || !*c))
1586 return 0;
1587
1588 return *c == data;
1589}
1590
1591/**
1592 * devm_nvmem_cell_put() - Release previously allocated nvmem cell
1593 * from devm_nvmem_cell_get.
1594 *
1595 * @dev: Device that requests the nvmem cell.
1596 * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get().
1597 */
1598void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
1599{
1600 int ret;
1601
1602 ret = devres_release(dev, devm_nvmem_cell_release,
1603 devm_nvmem_cell_match, cell);
1604
1605 WARN_ON(ret);
1606}
1607EXPORT_SYMBOL(devm_nvmem_cell_put);
1608
1609/**
1610 * nvmem_cell_put() - Release previously allocated nvmem cell.
1611 *
1612 * @cell: Previously allocated nvmem cell by nvmem_cell_get().
1613 */
1614void nvmem_cell_put(struct nvmem_cell *cell)
1615{
1616 struct nvmem_device *nvmem = cell->entry->nvmem;
1617
1618 if (cell->id)
1619 kfree_const(cell->id);
1620
1621 kfree(cell);
1622 __nvmem_device_put(nvmem);
1623 nvmem_layout_module_put(nvmem);
1624}
1625EXPORT_SYMBOL_GPL(nvmem_cell_put);
1626
1627static void nvmem_shift_read_buffer_in_place(struct nvmem_cell_entry *cell, void *buf)
1628{
1629 u8 *p, *b;
1630 int i, extra, bit_offset = cell->bit_offset;
1631
1632 p = b = buf;
1633 if (bit_offset) {
1634 /* First shift */
1635 *b++ >>= bit_offset;
1636
1637 /* setup rest of the bytes if any */
1638 for (i = 1; i < cell->bytes; i++) {
1639 /* Get bits from next byte and shift them towards msb */
1640 *p |= *b << (BITS_PER_BYTE - bit_offset);
1641
1642 p = b;
1643 *b++ >>= bit_offset;
1644 }
1645 } else {
1646 /* point to the msb */
1647 p += cell->bytes - 1;
1648 }
1649
1650 /* result fits in less bytes */
1651 extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);
1652 while (--extra >= 0)
1653 *p-- = 0;
1654
1655 /* clear msb bits if any leftover in the last byte */
1656 if (cell->nbits % BITS_PER_BYTE)
1657 *p &= GENMASK((cell->nbits % BITS_PER_BYTE) - 1, 0);
1658}
1659
1660static int __nvmem_cell_read(struct nvmem_device *nvmem,
1661 struct nvmem_cell_entry *cell,
1662 void *buf, size_t *len, const char *id, int index)
1663{
1664 int rc;
1665
1666 rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->raw_len);
1667
1668 if (rc)
1669 return rc;
1670
1671 /* shift bits in-place */
1672 if (cell->bit_offset || cell->nbits)
1673 nvmem_shift_read_buffer_in_place(cell, buf);
1674
1675 if (cell->read_post_process) {
1676 rc = cell->read_post_process(cell->priv, id, index,
1677 cell->offset, buf, cell->raw_len);
1678 if (rc)
1679 return rc;
1680 }
1681
1682 if (len)
1683 *len = cell->bytes;
1684
1685 return 0;
1686}
1687
1688/**
1689 * nvmem_cell_read() - Read a given nvmem cell
1690 *
1691 * @cell: nvmem cell to be read.
1692 * @len: pointer to length of cell which will be populated on successful read;
1693 * can be NULL.
1694 *
1695 * Return: ERR_PTR() on error or a valid pointer to a buffer on success. The
1696 * buffer should be freed by the consumer with a kfree().
1697 */
1698void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
1699{
1700 struct nvmem_cell_entry *entry = cell->entry;
1701 struct nvmem_device *nvmem = entry->nvmem;
1702 u8 *buf;
1703 int rc;
1704
1705 if (!nvmem)
1706 return ERR_PTR(-EINVAL);
1707
1708 buf = kzalloc(max_t(size_t, entry->raw_len, entry->bytes), GFP_KERNEL);
1709 if (!buf)
1710 return ERR_PTR(-ENOMEM);
1711
1712 rc = __nvmem_cell_read(nvmem, cell->entry, buf, len, cell->id, cell->index);
1713 if (rc) {
1714 kfree(buf);
1715 return ERR_PTR(rc);
1716 }
1717
1718 return buf;
1719}
1720EXPORT_SYMBOL_GPL(nvmem_cell_read);
1721
1722static void *nvmem_cell_prepare_write_buffer(struct nvmem_cell_entry *cell,
1723 u8 *_buf, int len)
1724{
1725 struct nvmem_device *nvmem = cell->nvmem;
1726 int i, rc, nbits, bit_offset = cell->bit_offset;
1727 u8 v, *p, *buf, *b, pbyte, pbits;
1728
1729 nbits = cell->nbits;
1730 buf = kzalloc(cell->bytes, GFP_KERNEL);
1731 if (!buf)
1732 return ERR_PTR(-ENOMEM);
1733
1734 memcpy(buf, _buf, len);
1735 p = b = buf;
1736
1737 if (bit_offset) {
1738 pbyte = *b;
1739 *b <<= bit_offset;
1740
1741 /* setup the first byte with lsb bits from nvmem */
1742 rc = nvmem_reg_read(nvmem, cell->offset, &v, 1);
1743 if (rc)
1744 goto err;
1745 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1746
1747 /* setup rest of the byte if any */
1748 for (i = 1; i < cell->bytes; i++) {
1749 /* Get last byte bits and shift them towards lsb */
1750 pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1751 pbyte = *b;
1752 p = b;
1753 *b <<= bit_offset;
1754 *b++ |= pbits;
1755 }
1756 }
1757
1758 /* if it's not end on byte boundary */
1759 if ((nbits + bit_offset) % BITS_PER_BYTE) {
1760 /* setup the last byte with msb bits from nvmem */
1761 rc = nvmem_reg_read(nvmem,
1762 cell->offset + cell->bytes - 1, &v, 1);
1763 if (rc)
1764 goto err;
1765 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1766
1767 }
1768
1769 return buf;
1770err:
1771 kfree(buf);
1772 return ERR_PTR(rc);
1773}
1774
1775static int __nvmem_cell_entry_write(struct nvmem_cell_entry *cell, void *buf, size_t len)
1776{
1777 struct nvmem_device *nvmem = cell->nvmem;
1778 int rc;
1779
1780 if (!nvmem || nvmem->read_only ||
1781 (cell->bit_offset == 0 && len != cell->bytes))
1782 return -EINVAL;
1783
1784 /*
1785 * Any cells which have a read_post_process hook are read-only because
1786 * we cannot reverse the operation and it might affect other cells,
1787 * too.
1788 */
1789 if (cell->read_post_process)
1790 return -EINVAL;
1791
1792 if (cell->bit_offset || cell->nbits) {
1793 if (len != BITS_TO_BYTES(cell->nbits) && len != cell->bytes)
1794 return -EINVAL;
1795 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1796 if (IS_ERR(buf))
1797 return PTR_ERR(buf);
1798 }
1799
1800 rc = nvmem_reg_write(nvmem, cell->offset, buf, cell->bytes);
1801
1802 /* free the tmp buffer */
1803 if (cell->bit_offset || cell->nbits)
1804 kfree(buf);
1805
1806 if (rc)
1807 return rc;
1808
1809 return len;
1810}
1811
1812/**
1813 * nvmem_cell_write() - Write to a given nvmem cell
1814 *
1815 * @cell: nvmem cell to be written.
1816 * @buf: Buffer to be written.
1817 * @len: length of buffer to be written to nvmem cell.
1818 *
1819 * Return: length of bytes written or negative on failure.
1820 */
1821int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1822{
1823 return __nvmem_cell_entry_write(cell->entry, buf, len);
1824}
1825
1826EXPORT_SYMBOL_GPL(nvmem_cell_write);
1827
1828static int nvmem_cell_read_common(struct device *dev, const char *cell_id,
1829 void *val, size_t count)
1830{
1831 struct nvmem_cell *cell;
1832 void *buf;
1833 size_t len;
1834
1835 cell = nvmem_cell_get(dev, cell_id);
1836 if (IS_ERR(cell))
1837 return PTR_ERR(cell);
1838
1839 buf = nvmem_cell_read(cell, &len);
1840 if (IS_ERR(buf)) {
1841 nvmem_cell_put(cell);
1842 return PTR_ERR(buf);
1843 }
1844 if (len != count) {
1845 kfree(buf);
1846 nvmem_cell_put(cell);
1847 return -EINVAL;
1848 }
1849 memcpy(val, buf, count);
1850 kfree(buf);
1851 nvmem_cell_put(cell);
1852
1853 return 0;
1854}
1855
1856/**
1857 * nvmem_cell_read_u8() - Read a cell value as a u8
1858 *
1859 * @dev: Device that requests the nvmem cell.
1860 * @cell_id: Name of nvmem cell to read.
1861 * @val: pointer to output value.
1862 *
1863 * Return: 0 on success or negative errno.
1864 */
1865int nvmem_cell_read_u8(struct device *dev, const char *cell_id, u8 *val)
1866{
1867 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1868}
1869EXPORT_SYMBOL_GPL(nvmem_cell_read_u8);
1870
1871/**
1872 * nvmem_cell_read_u16() - Read a cell value as a u16
1873 *
1874 * @dev: Device that requests the nvmem cell.
1875 * @cell_id: Name of nvmem cell to read.
1876 * @val: pointer to output value.
1877 *
1878 * Return: 0 on success or negative errno.
1879 */
1880int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val)
1881{
1882 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1883}
1884EXPORT_SYMBOL_GPL(nvmem_cell_read_u16);
1885
1886/**
1887 * nvmem_cell_read_u32() - Read a cell value as a u32
1888 *
1889 * @dev: Device that requests the nvmem cell.
1890 * @cell_id: Name of nvmem cell to read.
1891 * @val: pointer to output value.
1892 *
1893 * Return: 0 on success or negative errno.
1894 */
1895int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val)
1896{
1897 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1898}
1899EXPORT_SYMBOL_GPL(nvmem_cell_read_u32);
1900
1901/**
1902 * nvmem_cell_read_u64() - Read a cell value as a u64
1903 *
1904 * @dev: Device that requests the nvmem cell.
1905 * @cell_id: Name of nvmem cell to read.
1906 * @val: pointer to output value.
1907 *
1908 * Return: 0 on success or negative errno.
1909 */
1910int nvmem_cell_read_u64(struct device *dev, const char *cell_id, u64 *val)
1911{
1912 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1913}
1914EXPORT_SYMBOL_GPL(nvmem_cell_read_u64);
1915
1916static const void *nvmem_cell_read_variable_common(struct device *dev,
1917 const char *cell_id,
1918 size_t max_len, size_t *len)
1919{
1920 struct nvmem_cell *cell;
1921 int nbits;
1922 void *buf;
1923
1924 cell = nvmem_cell_get(dev, cell_id);
1925 if (IS_ERR(cell))
1926 return cell;
1927
1928 nbits = cell->entry->nbits;
1929 buf = nvmem_cell_read(cell, len);
1930 nvmem_cell_put(cell);
1931 if (IS_ERR(buf))
1932 return buf;
1933
1934 /*
1935 * If nbits is set then nvmem_cell_read() can significantly exaggerate
1936 * the length of the real data. Throw away the extra junk.
1937 */
1938 if (nbits)
1939 *len = DIV_ROUND_UP(nbits, 8);
1940
1941 if (*len > max_len) {
1942 kfree(buf);
1943 return ERR_PTR(-ERANGE);
1944 }
1945
1946 return buf;
1947}
1948
1949/**
1950 * nvmem_cell_read_variable_le_u32() - Read up to 32-bits of data as a little endian number.
1951 *
1952 * @dev: Device that requests the nvmem cell.
1953 * @cell_id: Name of nvmem cell to read.
1954 * @val: pointer to output value.
1955 *
1956 * Return: 0 on success or negative errno.
1957 */
1958int nvmem_cell_read_variable_le_u32(struct device *dev, const char *cell_id,
1959 u32 *val)
1960{
1961 size_t len;
1962 const u8 *buf;
1963 int i;
1964
1965 buf = nvmem_cell_read_variable_common(dev, cell_id, sizeof(*val), &len);
1966 if (IS_ERR(buf))
1967 return PTR_ERR(buf);
1968
1969 /* Copy w/ implicit endian conversion */
1970 *val = 0;
1971 for (i = 0; i < len; i++)
1972 *val |= buf[i] << (8 * i);
1973
1974 kfree(buf);
1975
1976 return 0;
1977}
1978EXPORT_SYMBOL_GPL(nvmem_cell_read_variable_le_u32);
1979
1980/**
1981 * nvmem_cell_read_variable_le_u64() - Read up to 64-bits of data as a little endian number.
1982 *
1983 * @dev: Device that requests the nvmem cell.
1984 * @cell_id: Name of nvmem cell to read.
1985 * @val: pointer to output value.
1986 *
1987 * Return: 0 on success or negative errno.
1988 */
1989int nvmem_cell_read_variable_le_u64(struct device *dev, const char *cell_id,
1990 u64 *val)
1991{
1992 size_t len;
1993 const u8 *buf;
1994 int i;
1995
1996 buf = nvmem_cell_read_variable_common(dev, cell_id, sizeof(*val), &len);
1997 if (IS_ERR(buf))
1998 return PTR_ERR(buf);
1999
2000 /* Copy w/ implicit endian conversion */
2001 *val = 0;
2002 for (i = 0; i < len; i++)
2003 *val |= (uint64_t)buf[i] << (8 * i);
2004
2005 kfree(buf);
2006
2007 return 0;
2008}
2009EXPORT_SYMBOL_GPL(nvmem_cell_read_variable_le_u64);
2010
2011/**
2012 * nvmem_device_cell_read() - Read a given nvmem device and cell
2013 *
2014 * @nvmem: nvmem device to read from.
2015 * @info: nvmem cell info to be read.
2016 * @buf: buffer pointer which will be populated on successful read.
2017 *
2018 * Return: length of successful bytes read on success and negative
2019 * error code on error.
2020 */
2021ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
2022 struct nvmem_cell_info *info, void *buf)
2023{
2024 struct nvmem_cell_entry cell;
2025 int rc;
2026 ssize_t len;
2027
2028 if (!nvmem)
2029 return -EINVAL;
2030
2031 rc = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, &cell);
2032 if (rc)
2033 return rc;
2034
2035 rc = __nvmem_cell_read(nvmem, &cell, buf, &len, NULL, 0);
2036 if (rc)
2037 return rc;
2038
2039 return len;
2040}
2041EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
2042
2043/**
2044 * nvmem_device_cell_write() - Write cell to a given nvmem device
2045 *
2046 * @nvmem: nvmem device to be written to.
2047 * @info: nvmem cell info to be written.
2048 * @buf: buffer to be written to cell.
2049 *
2050 * Return: length of bytes written or negative error code on failure.
2051 */
2052int nvmem_device_cell_write(struct nvmem_device *nvmem,
2053 struct nvmem_cell_info *info, void *buf)
2054{
2055 struct nvmem_cell_entry cell;
2056 int rc;
2057
2058 if (!nvmem)
2059 return -EINVAL;
2060
2061 rc = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, &cell);
2062 if (rc)
2063 return rc;
2064
2065 return __nvmem_cell_entry_write(&cell, buf, cell.bytes);
2066}
2067EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
2068
2069/**
2070 * nvmem_device_read() - Read from a given nvmem device
2071 *
2072 * @nvmem: nvmem device to read from.
2073 * @offset: offset in nvmem device.
2074 * @bytes: number of bytes to read.
2075 * @buf: buffer pointer which will be populated on successful read.
2076 *
2077 * Return: length of successful bytes read on success and negative
2078 * error code on error.
2079 */
2080int nvmem_device_read(struct nvmem_device *nvmem,
2081 unsigned int offset,
2082 size_t bytes, void *buf)
2083{
2084 int rc;
2085
2086 if (!nvmem)
2087 return -EINVAL;
2088
2089 rc = nvmem_reg_read(nvmem, offset, buf, bytes);
2090
2091 if (rc)
2092 return rc;
2093
2094 return bytes;
2095}
2096EXPORT_SYMBOL_GPL(nvmem_device_read);
2097
2098/**
2099 * nvmem_device_write() - Write cell to a given nvmem device
2100 *
2101 * @nvmem: nvmem device to be written to.
2102 * @offset: offset in nvmem device.
2103 * @bytes: number of bytes to write.
2104 * @buf: buffer to be written.
2105 *
2106 * Return: length of bytes written or negative error code on failure.
2107 */
2108int nvmem_device_write(struct nvmem_device *nvmem,
2109 unsigned int offset,
2110 size_t bytes, void *buf)
2111{
2112 int rc;
2113
2114 if (!nvmem)
2115 return -EINVAL;
2116
2117 rc = nvmem_reg_write(nvmem, offset, buf, bytes);
2118
2119 if (rc)
2120 return rc;
2121
2122
2123 return bytes;
2124}
2125EXPORT_SYMBOL_GPL(nvmem_device_write);
2126
2127/**
2128 * nvmem_add_cell_table() - register a table of cell info entries
2129 *
2130 * @table: table of cell info entries
2131 */
2132void nvmem_add_cell_table(struct nvmem_cell_table *table)
2133{
2134 mutex_lock(&nvmem_cell_mutex);
2135 list_add_tail(&table->node, &nvmem_cell_tables);
2136 mutex_unlock(&nvmem_cell_mutex);
2137}
2138EXPORT_SYMBOL_GPL(nvmem_add_cell_table);
2139
2140/**
2141 * nvmem_del_cell_table() - remove a previously registered cell info table
2142 *
2143 * @table: table of cell info entries
2144 */
2145void nvmem_del_cell_table(struct nvmem_cell_table *table)
2146{
2147 mutex_lock(&nvmem_cell_mutex);
2148 list_del(&table->node);
2149 mutex_unlock(&nvmem_cell_mutex);
2150}
2151EXPORT_SYMBOL_GPL(nvmem_del_cell_table);
2152
2153/**
2154 * nvmem_add_cell_lookups() - register a list of cell lookup entries
2155 *
2156 * @entries: array of cell lookup entries
2157 * @nentries: number of cell lookup entries in the array
2158 */
2159void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
2160{
2161 int i;
2162
2163 mutex_lock(&nvmem_lookup_mutex);
2164 for (i = 0; i < nentries; i++)
2165 list_add_tail(&entries[i].node, &nvmem_lookup_list);
2166 mutex_unlock(&nvmem_lookup_mutex);
2167}
2168EXPORT_SYMBOL_GPL(nvmem_add_cell_lookups);
2169
2170/**
2171 * nvmem_del_cell_lookups() - remove a list of previously added cell lookup
2172 * entries
2173 *
2174 * @entries: array of cell lookup entries
2175 * @nentries: number of cell lookup entries in the array
2176 */
2177void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
2178{
2179 int i;
2180
2181 mutex_lock(&nvmem_lookup_mutex);
2182 for (i = 0; i < nentries; i++)
2183 list_del(&entries[i].node);
2184 mutex_unlock(&nvmem_lookup_mutex);
2185}
2186EXPORT_SYMBOL_GPL(nvmem_del_cell_lookups);
2187
2188/**
2189 * nvmem_dev_name() - Get the name of a given nvmem device.
2190 *
2191 * @nvmem: nvmem device.
2192 *
2193 * Return: name of the nvmem device.
2194 */
2195const char *nvmem_dev_name(struct nvmem_device *nvmem)
2196{
2197 return dev_name(&nvmem->dev);
2198}
2199EXPORT_SYMBOL_GPL(nvmem_dev_name);
2200
2201/**
2202 * nvmem_dev_size() - Get the size of a given nvmem device.
2203 *
2204 * @nvmem: nvmem device.
2205 *
2206 * Return: size of the nvmem device.
2207 */
2208size_t nvmem_dev_size(struct nvmem_device *nvmem)
2209{
2210 return nvmem->size;
2211}
2212EXPORT_SYMBOL_GPL(nvmem_dev_size);
2213
2214static int __init nvmem_init(void)
2215{
2216 int ret;
2217
2218 ret = bus_register(&nvmem_bus_type);
2219 if (ret)
2220 return ret;
2221
2222 ret = nvmem_layout_bus_register();
2223 if (ret)
2224 bus_unregister(&nvmem_bus_type);
2225
2226 return ret;
2227}
2228
2229static void __exit nvmem_exit(void)
2230{
2231 nvmem_layout_bus_unregister();
2232 bus_unregister(&nvmem_bus_type);
2233}
2234
2235subsys_initcall(nvmem_init);
2236module_exit(nvmem_exit);
2237
2238MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
2239MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
2240MODULE_DESCRIPTION("nvmem Driver Core");