1 // SPDX-License-Identifier: GPL-2.0
3 * nvmem framework core.
5 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
6 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
9 #include <linux/device.h>
10 #include <linux/export.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>
20 #include <linux/slab.h>
22 #include "internals.h"
24 #define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
26 #define FLAG_COMPAT BIT(0)
27 struct nvmem_cell_entry {
34 nvmem_cell_post_process_t read_post_process;
36 struct device_node *np;
37 struct nvmem_device *nvmem;
38 struct list_head node;
42 struct nvmem_cell_entry *entry;
47 static DEFINE_MUTEX(nvmem_mutex);
48 static DEFINE_IDA(nvmem_ida);
50 static DEFINE_MUTEX(nvmem_cell_mutex);
51 static LIST_HEAD(nvmem_cell_tables);
53 static DEFINE_MUTEX(nvmem_lookup_mutex);
54 static LIST_HEAD(nvmem_lookup_list);
56 static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
58 static int __nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
59 void *val, size_t bytes)
62 return nvmem->reg_read(nvmem->priv, offset, val, bytes);
67 static int __nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
68 void *val, size_t bytes)
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);
82 static int nvmem_access_with_keepouts(struct nvmem_device *nvmem,
83 unsigned int offset, void *val,
84 size_t bytes, int write)
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;
94 * Skip all keepouts before the range being accessed.
95 * Keepouts are sorted.
97 while ((keepout < keepoutend) && (keepout->end <= offset))
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;
106 rc = __nvmem_reg_write(nvmem, offset, val, ksize);
108 rc = __nvmem_reg_read(nvmem, offset, val, ksize);
118 * Now we're aligned to the start of this keepout zone. Go
121 kend = min(end, keepout->end);
122 ksize = kend - offset;
124 memset(val, keepout->value, ksize);
132 * If we ran out of keepouts but there's still stuff to do, send it
136 ksize = end - offset;
138 return __nvmem_reg_write(nvmem, offset, val, ksize);
140 return __nvmem_reg_read(nvmem, offset, val, ksize);
146 static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
147 void *val, size_t bytes)
149 if (!nvmem->nkeepout)
150 return __nvmem_reg_read(nvmem, offset, val, bytes);
152 return nvmem_access_with_keepouts(nvmem, offset, val, bytes, false);
155 static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
156 void *val, size_t bytes)
158 if (!nvmem->nkeepout)
159 return __nvmem_reg_write(nvmem, offset, val, bytes);
161 return nvmem_access_with_keepouts(nvmem, offset, val, bytes, true);
164 #ifdef CONFIG_NVMEM_SYSFS
165 static 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",
173 #ifdef CONFIG_DEBUG_LOCK_ALLOC
174 static struct lock_class_key eeprom_lock_key;
177 static ssize_t type_show(struct device *dev,
178 struct device_attribute *attr, char *buf)
180 struct nvmem_device *nvmem = to_nvmem_device(dev);
182 return sprintf(buf, "%s\n", nvmem_type_str[nvmem->type]);
185 static DEVICE_ATTR_RO(type);
187 static struct attribute *nvmem_attrs[] = {
192 static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
193 struct bin_attribute *attr, char *buf,
194 loff_t pos, size_t count)
197 struct nvmem_device *nvmem;
203 dev = kobj_to_dev(kobj);
204 nvmem = to_nvmem_device(dev);
206 /* Stop the user from reading */
207 if (pos >= nvmem->size)
210 if (!IS_ALIGNED(pos, nvmem->stride))
213 if (count < nvmem->word_size)
216 if (pos + count > nvmem->size)
217 count = nvmem->size - pos;
219 count = round_down(count, nvmem->word_size);
221 if (!nvmem->reg_read)
224 rc = nvmem_reg_read(nvmem, pos, buf, count);
232 static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
233 struct bin_attribute *attr, char *buf,
234 loff_t pos, size_t count)
237 struct nvmem_device *nvmem;
243 dev = kobj_to_dev(kobj);
244 nvmem = to_nvmem_device(dev);
246 /* Stop the user from writing */
247 if (pos >= nvmem->size)
250 if (!IS_ALIGNED(pos, nvmem->stride))
253 if (count < nvmem->word_size)
256 if (pos + count > nvmem->size)
257 count = nvmem->size - pos;
259 count = round_down(count, nvmem->word_size);
261 if (!nvmem->reg_write)
264 rc = nvmem_reg_write(nvmem, pos, buf, count);
272 static umode_t nvmem_bin_attr_get_umode(struct nvmem_device *nvmem)
276 if (!nvmem->root_only)
279 if (!nvmem->read_only)
282 if (!nvmem->reg_write)
285 if (!nvmem->reg_read)
291 static umode_t nvmem_bin_attr_is_visible(struct kobject *kobj,
292 struct bin_attribute *attr, int i)
294 struct device *dev = kobj_to_dev(kobj);
295 struct nvmem_device *nvmem = to_nvmem_device(dev);
297 attr->size = nvmem->size;
299 return nvmem_bin_attr_get_umode(nvmem);
302 static struct nvmem_cell *nvmem_create_cell(struct nvmem_cell_entry *entry,
303 const char *id, int index);
305 static ssize_t nvmem_cell_attr_read(struct file *filp, struct kobject *kobj,
306 struct bin_attribute *attr, char *buf,
307 loff_t pos, size_t count)
309 struct nvmem_cell_entry *entry;
310 struct nvmem_cell *cell = NULL;
311 size_t cell_sz, read_len;
314 entry = attr->private;
315 cell = nvmem_create_cell(entry, entry->name, 0);
317 return PTR_ERR(cell);
322 content = nvmem_cell_read(cell, &cell_sz);
323 if (IS_ERR(content)) {
324 read_len = PTR_ERR(content);
328 read_len = min_t(unsigned int, cell_sz - pos, count);
329 memcpy(buf, content + pos, read_len);
333 kfree_const(cell->id);
339 /* default read/write permissions */
340 static struct bin_attribute bin_attr_rw_nvmem = {
345 .read = bin_attr_nvmem_read,
346 .write = bin_attr_nvmem_write,
349 static struct bin_attribute *nvmem_bin_attributes[] = {
354 static const struct attribute_group nvmem_bin_group = {
355 .bin_attrs = nvmem_bin_attributes,
356 .attrs = nvmem_attrs,
357 .is_bin_visible = nvmem_bin_attr_is_visible,
360 /* Cell attributes will be dynamically allocated */
361 static struct attribute_group nvmem_cells_group = {
365 static const struct attribute_group *nvmem_dev_groups[] = {
370 static const struct attribute_group *nvmem_cells_groups[] = {
375 static struct bin_attribute bin_attr_nvmem_eeprom_compat = {
379 .read = bin_attr_nvmem_read,
380 .write = bin_attr_nvmem_write,
384 * nvmem_setup_compat() - Create an additional binary entry in
385 * drivers sys directory, to be backwards compatible with the older
386 * drivers/misc/eeprom drivers.
388 static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
389 const struct nvmem_config *config)
396 if (!config->base_dev)
399 if (config->type == NVMEM_TYPE_FRAM)
400 bin_attr_nvmem_eeprom_compat.attr.name = "fram";
402 nvmem->eeprom = bin_attr_nvmem_eeprom_compat;
403 nvmem->eeprom.attr.mode = nvmem_bin_attr_get_umode(nvmem);
404 nvmem->eeprom.size = nvmem->size;
405 #ifdef CONFIG_DEBUG_LOCK_ALLOC
406 nvmem->eeprom.attr.key = &eeprom_lock_key;
408 nvmem->eeprom.private = &nvmem->dev;
409 nvmem->base_dev = config->base_dev;
411 rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
414 "Failed to create eeprom binary file %d\n", rval);
418 nvmem->flags |= FLAG_COMPAT;
423 static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
424 const struct nvmem_config *config)
427 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
430 static int nvmem_populate_sysfs_cells(struct nvmem_device *nvmem)
432 struct bin_attribute **cells_attrs, *attrs;
433 struct nvmem_cell_entry *entry;
434 unsigned int ncells = 0, i = 0;
437 mutex_lock(&nvmem_mutex);
439 if (list_empty(&nvmem->cells) || nvmem->sysfs_cells_populated) {
440 nvmem_cells_group.bin_attrs = NULL;
444 /* Allocate an array of attributes with a sentinel */
445 ncells = list_count_nodes(&nvmem->cells);
446 cells_attrs = devm_kcalloc(&nvmem->dev, ncells + 1,
447 sizeof(struct bin_attribute *), GFP_KERNEL);
453 attrs = devm_kcalloc(&nvmem->dev, ncells, sizeof(struct bin_attribute), GFP_KERNEL);
459 /* Initialize each attribute to take the name and size of the cell */
460 list_for_each_entry(entry, &nvmem->cells, node) {
461 sysfs_bin_attr_init(&attrs[i]);
462 attrs[i].attr.name = devm_kasprintf(&nvmem->dev, GFP_KERNEL,
463 "%s@%x,%x", entry->name,
466 attrs[i].attr.mode = 0444;
467 attrs[i].size = entry->bytes;
468 attrs[i].read = &nvmem_cell_attr_read;
469 attrs[i].private = entry;
470 if (!attrs[i].attr.name) {
475 cells_attrs[i] = &attrs[i];
479 nvmem_cells_group.bin_attrs = cells_attrs;
481 ret = devm_device_add_groups(&nvmem->dev, nvmem_cells_groups);
485 nvmem->sysfs_cells_populated = true;
488 mutex_unlock(&nvmem_mutex);
493 #else /* CONFIG_NVMEM_SYSFS */
495 static int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
496 const struct nvmem_config *config)
500 static void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
501 const struct nvmem_config *config)
505 #endif /* CONFIG_NVMEM_SYSFS */
507 static void nvmem_release(struct device *dev)
509 struct nvmem_device *nvmem = to_nvmem_device(dev);
511 ida_free(&nvmem_ida, nvmem->id);
512 gpiod_put(nvmem->wp_gpio);
516 static const struct device_type nvmem_provider_type = {
517 .release = nvmem_release,
520 static struct bus_type nvmem_bus_type = {
524 static void nvmem_cell_entry_drop(struct nvmem_cell_entry *cell)
526 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE, cell);
527 mutex_lock(&nvmem_mutex);
528 list_del(&cell->node);
529 mutex_unlock(&nvmem_mutex);
530 of_node_put(cell->np);
531 kfree_const(cell->name);
535 static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
537 struct nvmem_cell_entry *cell, *p;
539 list_for_each_entry_safe(cell, p, &nvmem->cells, node)
540 nvmem_cell_entry_drop(cell);
543 static void nvmem_cell_entry_add(struct nvmem_cell_entry *cell)
545 mutex_lock(&nvmem_mutex);
546 list_add_tail(&cell->node, &cell->nvmem->cells);
547 mutex_unlock(&nvmem_mutex);
548 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_ADD, cell);
551 static int nvmem_cell_info_to_nvmem_cell_entry_nodup(struct nvmem_device *nvmem,
552 const struct nvmem_cell_info *info,
553 struct nvmem_cell_entry *cell)
556 cell->offset = info->offset;
557 cell->raw_len = info->raw_len ?: info->bytes;
558 cell->bytes = info->bytes;
559 cell->name = info->name;
560 cell->read_post_process = info->read_post_process;
561 cell->priv = info->priv;
563 cell->bit_offset = info->bit_offset;
564 cell->nbits = info->nbits;
568 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
571 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
573 "cell %s unaligned to nvmem stride %d\n",
574 cell->name ?: "<unknown>", nvmem->stride);
581 static int nvmem_cell_info_to_nvmem_cell_entry(struct nvmem_device *nvmem,
582 const struct nvmem_cell_info *info,
583 struct nvmem_cell_entry *cell)
587 err = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, cell);
591 cell->name = kstrdup_const(info->name, GFP_KERNEL);
599 * nvmem_add_one_cell() - Add one cell information to an nvmem device
601 * @nvmem: nvmem device to add cells to.
602 * @info: nvmem cell info to add to the device
604 * Return: 0 or negative error code on failure.
606 int nvmem_add_one_cell(struct nvmem_device *nvmem,
607 const struct nvmem_cell_info *info)
609 struct nvmem_cell_entry *cell;
612 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
616 rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, info, cell);
622 nvmem_cell_entry_add(cell);
626 EXPORT_SYMBOL_GPL(nvmem_add_one_cell);
629 * nvmem_add_cells() - Add cell information to an nvmem device
631 * @nvmem: nvmem device to add cells to.
632 * @info: nvmem cell info to add to the device
633 * @ncells: number of cells in info
635 * Return: 0 or negative error code on failure.
637 static int nvmem_add_cells(struct nvmem_device *nvmem,
638 const struct nvmem_cell_info *info,
643 for (i = 0; i < ncells; i++) {
644 rval = nvmem_add_one_cell(nvmem, &info[i]);
653 * nvmem_register_notifier() - Register a notifier block for nvmem events.
655 * @nb: notifier block to be called on nvmem events.
657 * Return: 0 on success, negative error number on failure.
659 int nvmem_register_notifier(struct notifier_block *nb)
661 return blocking_notifier_chain_register(&nvmem_notifier, nb);
663 EXPORT_SYMBOL_GPL(nvmem_register_notifier);
666 * nvmem_unregister_notifier() - Unregister a notifier block for nvmem events.
668 * @nb: notifier block to be unregistered.
670 * Return: 0 on success, negative error number on failure.
672 int nvmem_unregister_notifier(struct notifier_block *nb)
674 return blocking_notifier_chain_unregister(&nvmem_notifier, nb);
676 EXPORT_SYMBOL_GPL(nvmem_unregister_notifier);
678 static int nvmem_add_cells_from_table(struct nvmem_device *nvmem)
680 const struct nvmem_cell_info *info;
681 struct nvmem_cell_table *table;
682 struct nvmem_cell_entry *cell;
685 mutex_lock(&nvmem_cell_mutex);
686 list_for_each_entry(table, &nvmem_cell_tables, node) {
687 if (strcmp(nvmem_dev_name(nvmem), table->nvmem_name) == 0) {
688 for (i = 0; i < table->ncells; i++) {
689 info = &table->cells[i];
691 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
697 rval = nvmem_cell_info_to_nvmem_cell_entry(nvmem, info, cell);
703 nvmem_cell_entry_add(cell);
709 mutex_unlock(&nvmem_cell_mutex);
713 static struct nvmem_cell_entry *
714 nvmem_find_cell_entry_by_name(struct nvmem_device *nvmem, const char *cell_id)
716 struct nvmem_cell_entry *iter, *cell = NULL;
718 mutex_lock(&nvmem_mutex);
719 list_for_each_entry(iter, &nvmem->cells, node) {
720 if (strcmp(cell_id, iter->name) == 0) {
725 mutex_unlock(&nvmem_mutex);
730 static int nvmem_validate_keepouts(struct nvmem_device *nvmem)
732 unsigned int cur = 0;
733 const struct nvmem_keepout *keepout = nvmem->keepout;
734 const struct nvmem_keepout *keepoutend = keepout + nvmem->nkeepout;
736 while (keepout < keepoutend) {
737 /* Ensure keepouts are sorted and don't overlap. */
738 if (keepout->start < cur) {
740 "Keepout regions aren't sorted or overlap.\n");
745 if (keepout->end < keepout->start) {
747 "Invalid keepout region.\n");
753 * Validate keepouts (and holes between) don't violate
754 * word_size constraints.
756 if ((keepout->end - keepout->start < nvmem->word_size) ||
757 ((keepout->start != cur) &&
758 (keepout->start - cur < nvmem->word_size))) {
761 "Keepout regions violate word_size constraints.\n");
766 /* Validate keepouts don't violate stride (alignment). */
767 if (!IS_ALIGNED(keepout->start, nvmem->stride) ||
768 !IS_ALIGNED(keepout->end, nvmem->stride)) {
771 "Keepout regions violate stride.\n");
783 static int nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct device_node *np)
785 struct device *dev = &nvmem->dev;
786 struct device_node *child;
790 for_each_child_of_node(np, child) {
791 struct nvmem_cell_info info = {0};
793 addr = of_get_property(child, "reg", &len);
796 if (len < 2 * sizeof(u32)) {
797 dev_err(dev, "nvmem: invalid reg on %pOF\n", child);
802 info.offset = be32_to_cpup(addr++);
803 info.bytes = be32_to_cpup(addr);
804 info.name = kasprintf(GFP_KERNEL, "%pOFn", child);
806 addr = of_get_property(child, "bits", &len);
807 if (addr && len == (2 * sizeof(u32))) {
808 info.bit_offset = be32_to_cpup(addr++);
809 info.nbits = be32_to_cpup(addr);
812 info.np = of_node_get(child);
814 if (nvmem->fixup_dt_cell_info)
815 nvmem->fixup_dt_cell_info(nvmem, &info);
817 ret = nvmem_add_one_cell(nvmem, &info);
828 static int nvmem_add_cells_from_legacy_of(struct nvmem_device *nvmem)
830 return nvmem_add_cells_from_dt(nvmem, nvmem->dev.of_node);
833 static int nvmem_add_cells_from_fixed_layout(struct nvmem_device *nvmem)
835 struct device_node *layout_np;
838 layout_np = of_nvmem_layout_get_container(nvmem);
842 if (of_device_is_compatible(layout_np, "fixed-layout"))
843 err = nvmem_add_cells_from_dt(nvmem, layout_np);
845 of_node_put(layout_np);
850 int nvmem_layout_register(struct nvmem_layout *layout)
854 if (!layout->add_cells)
857 /* Populate the cells */
858 ret = layout->add_cells(layout);
862 #ifdef CONFIG_NVMEM_SYSFS
863 ret = nvmem_populate_sysfs_cells(layout->nvmem);
865 nvmem_device_remove_all_cells(layout->nvmem);
872 EXPORT_SYMBOL_GPL(nvmem_layout_register);
874 void nvmem_layout_unregister(struct nvmem_layout *layout)
876 /* Keep the API even with an empty stub in case we need it later */
878 EXPORT_SYMBOL_GPL(nvmem_layout_unregister);
881 * nvmem_register() - Register a nvmem device for given nvmem_config.
882 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
884 * @config: nvmem device configuration with which nvmem device is created.
886 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
890 struct nvmem_device *nvmem_register(const struct nvmem_config *config)
892 struct nvmem_device *nvmem;
896 return ERR_PTR(-EINVAL);
898 if (!config->reg_read && !config->reg_write)
899 return ERR_PTR(-EINVAL);
901 nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
903 return ERR_PTR(-ENOMEM);
905 rval = ida_alloc(&nvmem_ida, GFP_KERNEL);
908 return ERR_PTR(rval);
913 nvmem->dev.type = &nvmem_provider_type;
914 nvmem->dev.bus = &nvmem_bus_type;
915 nvmem->dev.parent = config->dev;
917 device_initialize(&nvmem->dev);
919 if (!config->ignore_wp)
920 nvmem->wp_gpio = gpiod_get_optional(config->dev, "wp",
922 if (IS_ERR(nvmem->wp_gpio)) {
923 rval = PTR_ERR(nvmem->wp_gpio);
924 nvmem->wp_gpio = NULL;
928 kref_init(&nvmem->refcnt);
929 INIT_LIST_HEAD(&nvmem->cells);
930 nvmem->fixup_dt_cell_info = config->fixup_dt_cell_info;
932 nvmem->owner = config->owner;
933 if (!nvmem->owner && config->dev->driver)
934 nvmem->owner = config->dev->driver->owner;
935 nvmem->stride = config->stride ?: 1;
936 nvmem->word_size = config->word_size ?: 1;
937 nvmem->size = config->size;
938 nvmem->root_only = config->root_only;
939 nvmem->priv = config->priv;
940 nvmem->type = config->type;
941 nvmem->reg_read = config->reg_read;
942 nvmem->reg_write = config->reg_write;
943 nvmem->keepout = config->keepout;
944 nvmem->nkeepout = config->nkeepout;
946 nvmem->dev.of_node = config->of_node;
948 nvmem->dev.of_node = config->dev->of_node;
950 switch (config->id) {
951 case NVMEM_DEVID_NONE:
952 rval = dev_set_name(&nvmem->dev, "%s", config->name);
954 case NVMEM_DEVID_AUTO:
955 rval = dev_set_name(&nvmem->dev, "%s%d", config->name, nvmem->id);
958 rval = dev_set_name(&nvmem->dev, "%s%d",
959 config->name ? : "nvmem",
960 config->name ? config->id : nvmem->id);
967 nvmem->read_only = device_property_present(config->dev, "read-only") ||
968 config->read_only || !nvmem->reg_write;
970 #ifdef CONFIG_NVMEM_SYSFS
971 nvmem->dev.groups = nvmem_dev_groups;
974 if (nvmem->nkeepout) {
975 rval = nvmem_validate_keepouts(nvmem);
980 if (config->compat) {
981 rval = nvmem_sysfs_setup_compat(nvmem, config);
987 rval = nvmem_add_cells(nvmem, config->cells, config->ncells);
989 goto err_remove_cells;
992 rval = nvmem_add_cells_from_table(nvmem);
994 goto err_remove_cells;
996 if (config->add_legacy_fixed_of_cells) {
997 rval = nvmem_add_cells_from_legacy_of(nvmem);
999 goto err_remove_cells;
1002 rval = nvmem_add_cells_from_fixed_layout(nvmem);
1004 goto err_remove_cells;
1006 dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
1008 rval = device_add(&nvmem->dev);
1010 goto err_remove_cells;
1012 rval = nvmem_populate_layout(nvmem);
1014 goto err_remove_dev;
1016 #ifdef CONFIG_NVMEM_SYSFS
1017 rval = nvmem_populate_sysfs_cells(nvmem);
1019 goto err_destroy_layout;
1022 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
1026 #ifdef CONFIG_NVMEM_SYSFS
1028 nvmem_destroy_layout(nvmem);
1031 device_del(&nvmem->dev);
1033 nvmem_device_remove_all_cells(nvmem);
1035 nvmem_sysfs_remove_compat(nvmem, config);
1037 put_device(&nvmem->dev);
1039 return ERR_PTR(rval);
1041 EXPORT_SYMBOL_GPL(nvmem_register);
1043 static void nvmem_device_release(struct kref *kref)
1045 struct nvmem_device *nvmem;
1047 nvmem = container_of(kref, struct nvmem_device, refcnt);
1049 blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
1051 if (nvmem->flags & FLAG_COMPAT)
1052 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
1054 nvmem_device_remove_all_cells(nvmem);
1055 nvmem_destroy_layout(nvmem);
1056 device_unregister(&nvmem->dev);
1060 * nvmem_unregister() - Unregister previously registered nvmem device
1062 * @nvmem: Pointer to previously registered nvmem device.
1064 void nvmem_unregister(struct nvmem_device *nvmem)
1067 kref_put(&nvmem->refcnt, nvmem_device_release);
1069 EXPORT_SYMBOL_GPL(nvmem_unregister);
1071 static void devm_nvmem_unregister(void *nvmem)
1073 nvmem_unregister(nvmem);
1077 * devm_nvmem_register() - Register a managed nvmem device for given
1079 * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
1081 * @dev: Device that uses the nvmem device.
1082 * @config: nvmem device configuration with which nvmem device is created.
1084 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
1087 struct nvmem_device *devm_nvmem_register(struct device *dev,
1088 const struct nvmem_config *config)
1090 struct nvmem_device *nvmem;
1093 nvmem = nvmem_register(config);
1097 ret = devm_add_action_or_reset(dev, devm_nvmem_unregister, nvmem);
1099 return ERR_PTR(ret);
1103 EXPORT_SYMBOL_GPL(devm_nvmem_register);
1105 static struct nvmem_device *__nvmem_device_get(void *data,
1106 int (*match)(struct device *dev, const void *data))
1108 struct nvmem_device *nvmem = NULL;
1111 mutex_lock(&nvmem_mutex);
1112 dev = bus_find_device(&nvmem_bus_type, NULL, data, match);
1114 nvmem = to_nvmem_device(dev);
1115 mutex_unlock(&nvmem_mutex);
1117 return ERR_PTR(-EPROBE_DEFER);
1119 if (!try_module_get(nvmem->owner)) {
1120 dev_err(&nvmem->dev,
1121 "could not increase module refcount for cell %s\n",
1122 nvmem_dev_name(nvmem));
1124 put_device(&nvmem->dev);
1125 return ERR_PTR(-EINVAL);
1128 kref_get(&nvmem->refcnt);
1133 static void __nvmem_device_put(struct nvmem_device *nvmem)
1135 put_device(&nvmem->dev);
1136 module_put(nvmem->owner);
1137 kref_put(&nvmem->refcnt, nvmem_device_release);
1140 #if IS_ENABLED(CONFIG_OF)
1142 * of_nvmem_device_get() - Get nvmem device from a given id
1144 * @np: Device tree node that uses the nvmem device.
1145 * @id: nvmem name from nvmem-names property.
1147 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1150 struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
1153 struct device_node *nvmem_np;
1154 struct nvmem_device *nvmem;
1158 index = of_property_match_string(np, "nvmem-names", id);
1160 nvmem_np = of_parse_phandle(np, "nvmem", index);
1162 return ERR_PTR(-ENOENT);
1164 nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1165 of_node_put(nvmem_np);
1168 EXPORT_SYMBOL_GPL(of_nvmem_device_get);
1172 * nvmem_device_get() - Get nvmem device from a given id
1174 * @dev: Device that uses the nvmem device.
1175 * @dev_name: name of the requested nvmem device.
1177 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1180 struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
1182 if (dev->of_node) { /* try dt first */
1183 struct nvmem_device *nvmem;
1185 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
1187 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
1192 return __nvmem_device_get((void *)dev_name, device_match_name);
1194 EXPORT_SYMBOL_GPL(nvmem_device_get);
1197 * nvmem_device_find() - Find nvmem device with matching function
1199 * @data: Data to pass to match function
1200 * @match: Callback function to check device
1202 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
1205 struct nvmem_device *nvmem_device_find(void *data,
1206 int (*match)(struct device *dev, const void *data))
1208 return __nvmem_device_get(data, match);
1210 EXPORT_SYMBOL_GPL(nvmem_device_find);
1212 static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
1214 struct nvmem_device **nvmem = res;
1216 if (WARN_ON(!nvmem || !*nvmem))
1219 return *nvmem == data;
1222 static void devm_nvmem_device_release(struct device *dev, void *res)
1224 nvmem_device_put(*(struct nvmem_device **)res);
1228 * devm_nvmem_device_put() - put alredy got nvmem device
1230 * @dev: Device that uses the nvmem device.
1231 * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
1232 * that needs to be released.
1234 void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
1238 ret = devres_release(dev, devm_nvmem_device_release,
1239 devm_nvmem_device_match, nvmem);
1243 EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
1246 * nvmem_device_put() - put alredy got nvmem device
1248 * @nvmem: pointer to nvmem device that needs to be released.
1250 void nvmem_device_put(struct nvmem_device *nvmem)
1252 __nvmem_device_put(nvmem);
1254 EXPORT_SYMBOL_GPL(nvmem_device_put);
1257 * devm_nvmem_device_get() - Get nvmem cell of device form a given id
1259 * @dev: Device that requests the nvmem device.
1260 * @id: name id for the requested nvmem device.
1262 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
1263 * on success. The nvmem_cell will be freed by the automatically once the
1266 struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
1268 struct nvmem_device **ptr, *nvmem;
1270 ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
1272 return ERR_PTR(-ENOMEM);
1274 nvmem = nvmem_device_get(dev, id);
1275 if (!IS_ERR(nvmem)) {
1277 devres_add(dev, ptr);
1284 EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
1286 static struct nvmem_cell *nvmem_create_cell(struct nvmem_cell_entry *entry,
1287 const char *id, int index)
1289 struct nvmem_cell *cell;
1290 const char *name = NULL;
1292 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
1294 return ERR_PTR(-ENOMEM);
1297 name = kstrdup_const(id, GFP_KERNEL);
1300 return ERR_PTR(-ENOMEM);
1305 cell->entry = entry;
1306 cell->index = index;
1311 static struct nvmem_cell *
1312 nvmem_cell_get_from_lookup(struct device *dev, const char *con_id)
1314 struct nvmem_cell_entry *cell_entry;
1315 struct nvmem_cell *cell = ERR_PTR(-ENOENT);
1316 struct nvmem_cell_lookup *lookup;
1317 struct nvmem_device *nvmem;
1321 return ERR_PTR(-EINVAL);
1323 dev_id = dev_name(dev);
1325 mutex_lock(&nvmem_lookup_mutex);
1327 list_for_each_entry(lookup, &nvmem_lookup_list, node) {
1328 if ((strcmp(lookup->dev_id, dev_id) == 0) &&
1329 (strcmp(lookup->con_id, con_id) == 0)) {
1330 /* This is the right entry. */
1331 nvmem = __nvmem_device_get((void *)lookup->nvmem_name,
1333 if (IS_ERR(nvmem)) {
1334 /* Provider may not be registered yet. */
1335 cell = ERR_CAST(nvmem);
1339 cell_entry = nvmem_find_cell_entry_by_name(nvmem,
1342 __nvmem_device_put(nvmem);
1343 cell = ERR_PTR(-ENOENT);
1345 cell = nvmem_create_cell(cell_entry, con_id, 0);
1347 __nvmem_device_put(nvmem);
1353 mutex_unlock(&nvmem_lookup_mutex);
1357 static void nvmem_layout_module_put(struct nvmem_device *nvmem)
1359 if (nvmem->layout && nvmem->layout->dev.driver)
1360 module_put(nvmem->layout->dev.driver->owner);
1363 #if IS_ENABLED(CONFIG_OF)
1364 static struct nvmem_cell_entry *
1365 nvmem_find_cell_entry_by_node(struct nvmem_device *nvmem, struct device_node *np)
1367 struct nvmem_cell_entry *iter, *cell = NULL;
1369 mutex_lock(&nvmem_mutex);
1370 list_for_each_entry(iter, &nvmem->cells, node) {
1371 if (np == iter->np) {
1376 mutex_unlock(&nvmem_mutex);
1381 static int nvmem_layout_module_get_optional(struct nvmem_device *nvmem)
1386 if (!nvmem->layout->dev.driver ||
1387 !try_module_get(nvmem->layout->dev.driver->owner))
1388 return -EPROBE_DEFER;
1394 * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
1396 * @np: Device tree node that uses the nvmem cell.
1397 * @id: nvmem cell name from nvmem-cell-names property, or NULL
1398 * for the cell at index 0 (the lone cell with no accompanying
1399 * nvmem-cell-names property).
1401 * Return: Will be an ERR_PTR() on error or a valid pointer
1402 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1405 struct nvmem_cell *of_nvmem_cell_get(struct device_node *np, const char *id)
1407 struct device_node *cell_np, *nvmem_np;
1408 struct nvmem_device *nvmem;
1409 struct nvmem_cell_entry *cell_entry;
1410 struct nvmem_cell *cell;
1411 struct of_phandle_args cell_spec;
1416 /* if cell name exists, find index to the name */
1418 index = of_property_match_string(np, "nvmem-cell-names", id);
1420 ret = of_parse_phandle_with_optional_args(np, "nvmem-cells",
1421 "#nvmem-cell-cells",
1424 return ERR_PTR(-ENOENT);
1426 if (cell_spec.args_count > 1)
1427 return ERR_PTR(-EINVAL);
1429 cell_np = cell_spec.np;
1430 if (cell_spec.args_count)
1431 cell_index = cell_spec.args[0];
1433 nvmem_np = of_get_parent(cell_np);
1435 of_node_put(cell_np);
1436 return ERR_PTR(-EINVAL);
1439 /* nvmem layouts produce cells within the nvmem-layout container */
1440 if (of_node_name_eq(nvmem_np, "nvmem-layout")) {
1441 nvmem_np = of_get_next_parent(nvmem_np);
1443 of_node_put(cell_np);
1444 return ERR_PTR(-EINVAL);
1448 nvmem = __nvmem_device_get(nvmem_np, device_match_of_node);
1449 of_node_put(nvmem_np);
1450 if (IS_ERR(nvmem)) {
1451 of_node_put(cell_np);
1452 return ERR_CAST(nvmem);
1455 ret = nvmem_layout_module_get_optional(nvmem);
1457 of_node_put(cell_np);
1458 __nvmem_device_put(nvmem);
1459 return ERR_PTR(ret);
1462 cell_entry = nvmem_find_cell_entry_by_node(nvmem, cell_np);
1463 of_node_put(cell_np);
1465 __nvmem_device_put(nvmem);
1466 nvmem_layout_module_put(nvmem);
1468 return ERR_PTR(-EPROBE_DEFER);
1470 return ERR_PTR(-ENOENT);
1473 cell = nvmem_create_cell(cell_entry, id, cell_index);
1475 __nvmem_device_put(nvmem);
1476 nvmem_layout_module_put(nvmem);
1481 EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
1485 * nvmem_cell_get() - Get nvmem cell of device form a given cell name
1487 * @dev: Device that requests the nvmem cell.
1488 * @id: nvmem cell name to get (this corresponds with the name from the
1489 * nvmem-cell-names property for DT systems and with the con_id from
1490 * the lookup entry for non-DT systems).
1492 * Return: Will be an ERR_PTR() on error or a valid pointer
1493 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1496 struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id)
1498 struct nvmem_cell *cell;
1500 if (dev->of_node) { /* try dt first */
1501 cell = of_nvmem_cell_get(dev->of_node, id);
1502 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
1506 /* NULL cell id only allowed for device tree; invalid otherwise */
1508 return ERR_PTR(-EINVAL);
1510 return nvmem_cell_get_from_lookup(dev, id);
1512 EXPORT_SYMBOL_GPL(nvmem_cell_get);
1514 static void devm_nvmem_cell_release(struct device *dev, void *res)
1516 nvmem_cell_put(*(struct nvmem_cell **)res);
1520 * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
1522 * @dev: Device that requests the nvmem cell.
1523 * @id: nvmem cell name id to get.
1525 * Return: Will be an ERR_PTR() on error or a valid pointer
1526 * to a struct nvmem_cell. The nvmem_cell will be freed by the
1527 * automatically once the device is freed.
1529 struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
1531 struct nvmem_cell **ptr, *cell;
1533 ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
1535 return ERR_PTR(-ENOMEM);
1537 cell = nvmem_cell_get(dev, id);
1538 if (!IS_ERR(cell)) {
1540 devres_add(dev, ptr);
1547 EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
1549 static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
1551 struct nvmem_cell **c = res;
1553 if (WARN_ON(!c || !*c))
1560 * devm_nvmem_cell_put() - Release previously allocated nvmem cell
1561 * from devm_nvmem_cell_get.
1563 * @dev: Device that requests the nvmem cell.
1564 * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get().
1566 void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
1570 ret = devres_release(dev, devm_nvmem_cell_release,
1571 devm_nvmem_cell_match, cell);
1575 EXPORT_SYMBOL(devm_nvmem_cell_put);
1578 * nvmem_cell_put() - Release previously allocated nvmem cell.
1580 * @cell: Previously allocated nvmem cell by nvmem_cell_get().
1582 void nvmem_cell_put(struct nvmem_cell *cell)
1584 struct nvmem_device *nvmem = cell->entry->nvmem;
1587 kfree_const(cell->id);
1590 __nvmem_device_put(nvmem);
1591 nvmem_layout_module_put(nvmem);
1593 EXPORT_SYMBOL_GPL(nvmem_cell_put);
1595 static void nvmem_shift_read_buffer_in_place(struct nvmem_cell_entry *cell, void *buf)
1598 int i, extra, bit_offset = cell->bit_offset;
1603 *b++ >>= bit_offset;
1605 /* setup rest of the bytes if any */
1606 for (i = 1; i < cell->bytes; i++) {
1607 /* Get bits from next byte and shift them towards msb */
1608 *p |= *b << (BITS_PER_BYTE - bit_offset);
1611 *b++ >>= bit_offset;
1614 /* point to the msb */
1615 p += cell->bytes - 1;
1618 /* result fits in less bytes */
1619 extra = cell->bytes - DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE);
1620 while (--extra >= 0)
1623 /* clear msb bits if any leftover in the last byte */
1624 if (cell->nbits % BITS_PER_BYTE)
1625 *p &= GENMASK((cell->nbits % BITS_PER_BYTE) - 1, 0);
1628 static int __nvmem_cell_read(struct nvmem_device *nvmem,
1629 struct nvmem_cell_entry *cell,
1630 void *buf, size_t *len, const char *id, int index)
1634 rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->raw_len);
1639 /* shift bits in-place */
1640 if (cell->bit_offset || cell->nbits)
1641 nvmem_shift_read_buffer_in_place(cell, buf);
1643 if (cell->read_post_process) {
1644 rc = cell->read_post_process(cell->priv, id, index,
1645 cell->offset, buf, cell->raw_len);
1657 * nvmem_cell_read() - Read a given nvmem cell
1659 * @cell: nvmem cell to be read.
1660 * @len: pointer to length of cell which will be populated on successful read;
1663 * Return: ERR_PTR() on error or a valid pointer to a buffer on success. The
1664 * buffer should be freed by the consumer with a kfree().
1666 void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
1668 struct nvmem_cell_entry *entry = cell->entry;
1669 struct nvmem_device *nvmem = entry->nvmem;
1674 return ERR_PTR(-EINVAL);
1676 buf = kzalloc(max_t(size_t, entry->raw_len, entry->bytes), GFP_KERNEL);
1678 return ERR_PTR(-ENOMEM);
1680 rc = __nvmem_cell_read(nvmem, cell->entry, buf, len, cell->id, cell->index);
1688 EXPORT_SYMBOL_GPL(nvmem_cell_read);
1690 static void *nvmem_cell_prepare_write_buffer(struct nvmem_cell_entry *cell,
1693 struct nvmem_device *nvmem = cell->nvmem;
1694 int i, rc, nbits, bit_offset = cell->bit_offset;
1695 u8 v, *p, *buf, *b, pbyte, pbits;
1697 nbits = cell->nbits;
1698 buf = kzalloc(cell->bytes, GFP_KERNEL);
1700 return ERR_PTR(-ENOMEM);
1702 memcpy(buf, _buf, len);
1709 /* setup the first byte with lsb bits from nvmem */
1710 rc = nvmem_reg_read(nvmem, cell->offset, &v, 1);
1713 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1715 /* setup rest of the byte if any */
1716 for (i = 1; i < cell->bytes; i++) {
1717 /* Get last byte bits and shift them towards lsb */
1718 pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1726 /* if it's not end on byte boundary */
1727 if ((nbits + bit_offset) % BITS_PER_BYTE) {
1728 /* setup the last byte with msb bits from nvmem */
1729 rc = nvmem_reg_read(nvmem,
1730 cell->offset + cell->bytes - 1, &v, 1);
1733 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1743 static int __nvmem_cell_entry_write(struct nvmem_cell_entry *cell, void *buf, size_t len)
1745 struct nvmem_device *nvmem = cell->nvmem;
1748 if (!nvmem || nvmem->read_only ||
1749 (cell->bit_offset == 0 && len != cell->bytes))
1753 * Any cells which have a read_post_process hook are read-only because
1754 * we cannot reverse the operation and it might affect other cells,
1757 if (cell->read_post_process)
1760 if (cell->bit_offset || cell->nbits) {
1761 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1763 return PTR_ERR(buf);
1766 rc = nvmem_reg_write(nvmem, cell->offset, buf, cell->bytes);
1768 /* free the tmp buffer */
1769 if (cell->bit_offset || cell->nbits)
1779 * nvmem_cell_write() - Write to a given nvmem cell
1781 * @cell: nvmem cell to be written.
1782 * @buf: Buffer to be written.
1783 * @len: length of buffer to be written to nvmem cell.
1785 * Return: length of bytes written or negative on failure.
1787 int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1789 return __nvmem_cell_entry_write(cell->entry, buf, len);
1792 EXPORT_SYMBOL_GPL(nvmem_cell_write);
1794 static int nvmem_cell_read_common(struct device *dev, const char *cell_id,
1795 void *val, size_t count)
1797 struct nvmem_cell *cell;
1801 cell = nvmem_cell_get(dev, cell_id);
1803 return PTR_ERR(cell);
1805 buf = nvmem_cell_read(cell, &len);
1807 nvmem_cell_put(cell);
1808 return PTR_ERR(buf);
1812 nvmem_cell_put(cell);
1815 memcpy(val, buf, count);
1817 nvmem_cell_put(cell);
1823 * nvmem_cell_read_u8() - Read a cell value as a u8
1825 * @dev: Device that requests the nvmem cell.
1826 * @cell_id: Name of nvmem cell to read.
1827 * @val: pointer to output value.
1829 * Return: 0 on success or negative errno.
1831 int nvmem_cell_read_u8(struct device *dev, const char *cell_id, u8 *val)
1833 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1835 EXPORT_SYMBOL_GPL(nvmem_cell_read_u8);
1838 * nvmem_cell_read_u16() - Read a cell value as a u16
1840 * @dev: Device that requests the nvmem cell.
1841 * @cell_id: Name of nvmem cell to read.
1842 * @val: pointer to output value.
1844 * Return: 0 on success or negative errno.
1846 int nvmem_cell_read_u16(struct device *dev, const char *cell_id, u16 *val)
1848 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1850 EXPORT_SYMBOL_GPL(nvmem_cell_read_u16);
1853 * nvmem_cell_read_u32() - Read a cell value as a u32
1855 * @dev: Device that requests the nvmem cell.
1856 * @cell_id: Name of nvmem cell to read.
1857 * @val: pointer to output value.
1859 * Return: 0 on success or negative errno.
1861 int nvmem_cell_read_u32(struct device *dev, const char *cell_id, u32 *val)
1863 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1865 EXPORT_SYMBOL_GPL(nvmem_cell_read_u32);
1868 * nvmem_cell_read_u64() - Read a cell value as a u64
1870 * @dev: Device that requests the nvmem cell.
1871 * @cell_id: Name of nvmem cell to read.
1872 * @val: pointer to output value.
1874 * Return: 0 on success or negative errno.
1876 int nvmem_cell_read_u64(struct device *dev, const char *cell_id, u64 *val)
1878 return nvmem_cell_read_common(dev, cell_id, val, sizeof(*val));
1880 EXPORT_SYMBOL_GPL(nvmem_cell_read_u64);
1882 static const void *nvmem_cell_read_variable_common(struct device *dev,
1883 const char *cell_id,
1884 size_t max_len, size_t *len)
1886 struct nvmem_cell *cell;
1890 cell = nvmem_cell_get(dev, cell_id);
1894 nbits = cell->entry->nbits;
1895 buf = nvmem_cell_read(cell, len);
1896 nvmem_cell_put(cell);
1901 * If nbits is set then nvmem_cell_read() can significantly exaggerate
1902 * the length of the real data. Throw away the extra junk.
1905 *len = DIV_ROUND_UP(nbits, 8);
1907 if (*len > max_len) {
1909 return ERR_PTR(-ERANGE);
1916 * nvmem_cell_read_variable_le_u32() - Read up to 32-bits of data as a little endian number.
1918 * @dev: Device that requests the nvmem cell.
1919 * @cell_id: Name of nvmem cell to read.
1920 * @val: pointer to output value.
1922 * Return: 0 on success or negative errno.
1924 int nvmem_cell_read_variable_le_u32(struct device *dev, const char *cell_id,
1931 buf = nvmem_cell_read_variable_common(dev, cell_id, sizeof(*val), &len);
1933 return PTR_ERR(buf);
1935 /* Copy w/ implicit endian conversion */
1937 for (i = 0; i < len; i++)
1938 *val |= buf[i] << (8 * i);
1944 EXPORT_SYMBOL_GPL(nvmem_cell_read_variable_le_u32);
1947 * nvmem_cell_read_variable_le_u64() - Read up to 64-bits of data as a little endian number.
1949 * @dev: Device that requests the nvmem cell.
1950 * @cell_id: Name of nvmem cell to read.
1951 * @val: pointer to output value.
1953 * Return: 0 on success or negative errno.
1955 int nvmem_cell_read_variable_le_u64(struct device *dev, const char *cell_id,
1962 buf = nvmem_cell_read_variable_common(dev, cell_id, sizeof(*val), &len);
1964 return PTR_ERR(buf);
1966 /* Copy w/ implicit endian conversion */
1968 for (i = 0; i < len; i++)
1969 *val |= (uint64_t)buf[i] << (8 * i);
1975 EXPORT_SYMBOL_GPL(nvmem_cell_read_variable_le_u64);
1978 * nvmem_device_cell_read() - Read a given nvmem device and cell
1980 * @nvmem: nvmem device to read from.
1981 * @info: nvmem cell info to be read.
1982 * @buf: buffer pointer which will be populated on successful read.
1984 * Return: length of successful bytes read on success and negative
1985 * error code on error.
1987 ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
1988 struct nvmem_cell_info *info, void *buf)
1990 struct nvmem_cell_entry cell;
1997 rc = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, &cell);
2001 rc = __nvmem_cell_read(nvmem, &cell, buf, &len, NULL, 0);
2007 EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
2010 * nvmem_device_cell_write() - Write cell to a given nvmem device
2012 * @nvmem: nvmem device to be written to.
2013 * @info: nvmem cell info to be written.
2014 * @buf: buffer to be written to cell.
2016 * Return: length of bytes written or negative error code on failure.
2018 int nvmem_device_cell_write(struct nvmem_device *nvmem,
2019 struct nvmem_cell_info *info, void *buf)
2021 struct nvmem_cell_entry cell;
2027 rc = nvmem_cell_info_to_nvmem_cell_entry_nodup(nvmem, info, &cell);
2031 return __nvmem_cell_entry_write(&cell, buf, cell.bytes);
2033 EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
2036 * nvmem_device_read() - Read from a given nvmem device
2038 * @nvmem: nvmem device to read from.
2039 * @offset: offset in nvmem device.
2040 * @bytes: number of bytes to read.
2041 * @buf: buffer pointer which will be populated on successful read.
2043 * Return: length of successful bytes read on success and negative
2044 * error code on error.
2046 int nvmem_device_read(struct nvmem_device *nvmem,
2047 unsigned int offset,
2048 size_t bytes, void *buf)
2055 rc = nvmem_reg_read(nvmem, offset, buf, bytes);
2062 EXPORT_SYMBOL_GPL(nvmem_device_read);
2065 * nvmem_device_write() - Write cell to a given nvmem device
2067 * @nvmem: nvmem device to be written to.
2068 * @offset: offset in nvmem device.
2069 * @bytes: number of bytes to write.
2070 * @buf: buffer to be written.
2072 * Return: length of bytes written or negative error code on failure.
2074 int nvmem_device_write(struct nvmem_device *nvmem,
2075 unsigned int offset,
2076 size_t bytes, void *buf)
2083 rc = nvmem_reg_write(nvmem, offset, buf, bytes);
2091 EXPORT_SYMBOL_GPL(nvmem_device_write);
2094 * nvmem_add_cell_table() - register a table of cell info entries
2096 * @table: table of cell info entries
2098 void nvmem_add_cell_table(struct nvmem_cell_table *table)
2100 mutex_lock(&nvmem_cell_mutex);
2101 list_add_tail(&table->node, &nvmem_cell_tables);
2102 mutex_unlock(&nvmem_cell_mutex);
2104 EXPORT_SYMBOL_GPL(nvmem_add_cell_table);
2107 * nvmem_del_cell_table() - remove a previously registered cell info table
2109 * @table: table of cell info entries
2111 void nvmem_del_cell_table(struct nvmem_cell_table *table)
2113 mutex_lock(&nvmem_cell_mutex);
2114 list_del(&table->node);
2115 mutex_unlock(&nvmem_cell_mutex);
2117 EXPORT_SYMBOL_GPL(nvmem_del_cell_table);
2120 * nvmem_add_cell_lookups() - register a list of cell lookup entries
2122 * @entries: array of cell lookup entries
2123 * @nentries: number of cell lookup entries in the array
2125 void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
2129 mutex_lock(&nvmem_lookup_mutex);
2130 for (i = 0; i < nentries; i++)
2131 list_add_tail(&entries[i].node, &nvmem_lookup_list);
2132 mutex_unlock(&nvmem_lookup_mutex);
2134 EXPORT_SYMBOL_GPL(nvmem_add_cell_lookups);
2137 * nvmem_del_cell_lookups() - remove a list of previously added cell lookup
2140 * @entries: array of cell lookup entries
2141 * @nentries: number of cell lookup entries in the array
2143 void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries)
2147 mutex_lock(&nvmem_lookup_mutex);
2148 for (i = 0; i < nentries; i++)
2149 list_del(&entries[i].node);
2150 mutex_unlock(&nvmem_lookup_mutex);
2152 EXPORT_SYMBOL_GPL(nvmem_del_cell_lookups);
2155 * nvmem_dev_name() - Get the name of a given nvmem device.
2157 * @nvmem: nvmem device.
2159 * Return: name of the nvmem device.
2161 const char *nvmem_dev_name(struct nvmem_device *nvmem)
2163 return dev_name(&nvmem->dev);
2165 EXPORT_SYMBOL_GPL(nvmem_dev_name);
2168 * nvmem_dev_size() - Get the size of a given nvmem device.
2170 * @nvmem: nvmem device.
2172 * Return: size of the nvmem device.
2174 size_t nvmem_dev_size(struct nvmem_device *nvmem)
2178 EXPORT_SYMBOL_GPL(nvmem_dev_size);
2180 static int __init nvmem_init(void)
2184 ret = bus_register(&nvmem_bus_type);
2188 ret = nvmem_layout_bus_register();
2190 bus_unregister(&nvmem_bus_type);
2195 static void __exit nvmem_exit(void)
2197 nvmem_layout_bus_unregister();
2198 bus_unregister(&nvmem_bus_type);
2201 subsys_initcall(nvmem_init);
2202 module_exit(nvmem_exit);
2204 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
2205 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
2206 MODULE_DESCRIPTION("nvmem Driver Core");