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/*
2 * nvmem framework core.
3 *
4 * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
5 * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 and
9 * only version 2 as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17#include <linux/device.h>
18#include <linux/export.h>
19#include <linux/fs.h>
20#include <linux/idr.h>
21#include <linux/init.h>
22#include <linux/module.h>
23#include <linux/nvmem-consumer.h>
24#include <linux/nvmem-provider.h>
25#include <linux/of.h>
26#include <linux/regmap.h>
27#include <linux/slab.h>
28
29struct nvmem_device {
30 const char *name;
31 struct regmap *regmap;
32 struct module *owner;
33 struct device dev;
34 int stride;
35 int word_size;
36 int ncells;
37 int id;
38 int users;
39 size_t size;
40 bool read_only;
41 int flags;
42 struct bin_attribute eeprom;
43 struct device *base_dev;
44};
45
46#define FLAG_COMPAT BIT(0)
47
48struct nvmem_cell {
49 const char *name;
50 int offset;
51 int bytes;
52 int bit_offset;
53 int nbits;
54 struct nvmem_device *nvmem;
55 struct list_head node;
56};
57
58static DEFINE_MUTEX(nvmem_mutex);
59static DEFINE_IDA(nvmem_ida);
60
61static LIST_HEAD(nvmem_cells);
62static DEFINE_MUTEX(nvmem_cells_mutex);
63
64#ifdef CONFIG_DEBUG_LOCK_ALLOC
65static struct lock_class_key eeprom_lock_key;
66#endif
67
68#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
69
70static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj,
71 struct bin_attribute *attr,
72 char *buf, loff_t pos, size_t count)
73{
74 struct device *dev;
75 struct nvmem_device *nvmem;
76 int rc;
77
78 if (attr->private)
79 dev = attr->private;
80 else
81 dev = container_of(kobj, struct device, kobj);
82 nvmem = to_nvmem_device(dev);
83
84 /* Stop the user from reading */
85 if (pos >= nvmem->size)
86 return 0;
87
88 if (count < nvmem->word_size)
89 return -EINVAL;
90
91 if (pos + count > nvmem->size)
92 count = nvmem->size - pos;
93
94 count = round_down(count, nvmem->word_size);
95
96 rc = regmap_raw_read(nvmem->regmap, pos, buf, count);
97
98 if (IS_ERR_VALUE(rc))
99 return rc;
100
101 return count;
102}
103
104static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj,
105 struct bin_attribute *attr,
106 char *buf, loff_t pos, size_t count)
107{
108 struct device *dev;
109 struct nvmem_device *nvmem;
110 int rc;
111
112 if (attr->private)
113 dev = attr->private;
114 else
115 dev = container_of(kobj, struct device, kobj);
116 nvmem = to_nvmem_device(dev);
117
118 /* Stop the user from writing */
119 if (pos >= nvmem->size)
120 return 0;
121
122 if (count < nvmem->word_size)
123 return -EINVAL;
124
125 if (pos + count > nvmem->size)
126 count = nvmem->size - pos;
127
128 count = round_down(count, nvmem->word_size);
129
130 rc = regmap_raw_write(nvmem->regmap, pos, buf, count);
131
132 if (IS_ERR_VALUE(rc))
133 return rc;
134
135 return count;
136}
137
138/* default read/write permissions */
139static struct bin_attribute bin_attr_rw_nvmem = {
140 .attr = {
141 .name = "nvmem",
142 .mode = S_IWUSR | S_IRUGO,
143 },
144 .read = bin_attr_nvmem_read,
145 .write = bin_attr_nvmem_write,
146};
147
148static struct bin_attribute *nvmem_bin_rw_attributes[] = {
149 &bin_attr_rw_nvmem,
150 NULL,
151};
152
153static const struct attribute_group nvmem_bin_rw_group = {
154 .bin_attrs = nvmem_bin_rw_attributes,
155};
156
157static const struct attribute_group *nvmem_rw_dev_groups[] = {
158 &nvmem_bin_rw_group,
159 NULL,
160};
161
162/* read only permission */
163static struct bin_attribute bin_attr_ro_nvmem = {
164 .attr = {
165 .name = "nvmem",
166 .mode = S_IRUGO,
167 },
168 .read = bin_attr_nvmem_read,
169};
170
171static struct bin_attribute *nvmem_bin_ro_attributes[] = {
172 &bin_attr_ro_nvmem,
173 NULL,
174};
175
176static const struct attribute_group nvmem_bin_ro_group = {
177 .bin_attrs = nvmem_bin_ro_attributes,
178};
179
180static const struct attribute_group *nvmem_ro_dev_groups[] = {
181 &nvmem_bin_ro_group,
182 NULL,
183};
184
185/* default read/write permissions, root only */
186static struct bin_attribute bin_attr_rw_root_nvmem = {
187 .attr = {
188 .name = "nvmem",
189 .mode = S_IWUSR | S_IRUSR,
190 },
191 .read = bin_attr_nvmem_read,
192 .write = bin_attr_nvmem_write,
193};
194
195static struct bin_attribute *nvmem_bin_rw_root_attributes[] = {
196 &bin_attr_rw_root_nvmem,
197 NULL,
198};
199
200static const struct attribute_group nvmem_bin_rw_root_group = {
201 .bin_attrs = nvmem_bin_rw_root_attributes,
202};
203
204static const struct attribute_group *nvmem_rw_root_dev_groups[] = {
205 &nvmem_bin_rw_root_group,
206 NULL,
207};
208
209/* read only permission, root only */
210static struct bin_attribute bin_attr_ro_root_nvmem = {
211 .attr = {
212 .name = "nvmem",
213 .mode = S_IRUSR,
214 },
215 .read = bin_attr_nvmem_read,
216};
217
218static struct bin_attribute *nvmem_bin_ro_root_attributes[] = {
219 &bin_attr_ro_root_nvmem,
220 NULL,
221};
222
223static const struct attribute_group nvmem_bin_ro_root_group = {
224 .bin_attrs = nvmem_bin_ro_root_attributes,
225};
226
227static const struct attribute_group *nvmem_ro_root_dev_groups[] = {
228 &nvmem_bin_ro_root_group,
229 NULL,
230};
231
232static void nvmem_release(struct device *dev)
233{
234 struct nvmem_device *nvmem = to_nvmem_device(dev);
235
236 ida_simple_remove(&nvmem_ida, nvmem->id);
237 kfree(nvmem);
238}
239
240static const struct device_type nvmem_provider_type = {
241 .release = nvmem_release,
242};
243
244static struct bus_type nvmem_bus_type = {
245 .name = "nvmem",
246};
247
248static int of_nvmem_match(struct device *dev, void *nvmem_np)
249{
250 return dev->of_node == nvmem_np;
251}
252
253static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
254{
255 struct device *d;
256
257 if (!nvmem_np)
258 return NULL;
259
260 d = bus_find_device(&nvmem_bus_type, NULL, nvmem_np, of_nvmem_match);
261
262 if (!d)
263 return NULL;
264
265 return to_nvmem_device(d);
266}
267
268static struct nvmem_cell *nvmem_find_cell(const char *cell_id)
269{
270 struct nvmem_cell *p;
271
272 list_for_each_entry(p, &nvmem_cells, node)
273 if (p && !strcmp(p->name, cell_id))
274 return p;
275
276 return NULL;
277}
278
279static void nvmem_cell_drop(struct nvmem_cell *cell)
280{
281 mutex_lock(&nvmem_cells_mutex);
282 list_del(&cell->node);
283 mutex_unlock(&nvmem_cells_mutex);
284 kfree(cell);
285}
286
287static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
288{
289 struct nvmem_cell *cell;
290 struct list_head *p, *n;
291
292 list_for_each_safe(p, n, &nvmem_cells) {
293 cell = list_entry(p, struct nvmem_cell, node);
294 if (cell->nvmem == nvmem)
295 nvmem_cell_drop(cell);
296 }
297}
298
299static void nvmem_cell_add(struct nvmem_cell *cell)
300{
301 mutex_lock(&nvmem_cells_mutex);
302 list_add_tail(&cell->node, &nvmem_cells);
303 mutex_unlock(&nvmem_cells_mutex);
304}
305
306static int nvmem_cell_info_to_nvmem_cell(struct nvmem_device *nvmem,
307 const struct nvmem_cell_info *info,
308 struct nvmem_cell *cell)
309{
310 cell->nvmem = nvmem;
311 cell->offset = info->offset;
312 cell->bytes = info->bytes;
313 cell->name = info->name;
314
315 cell->bit_offset = info->bit_offset;
316 cell->nbits = info->nbits;
317
318 if (cell->nbits)
319 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
320 BITS_PER_BYTE);
321
322 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
323 dev_err(&nvmem->dev,
324 "cell %s unaligned to nvmem stride %d\n",
325 cell->name, nvmem->stride);
326 return -EINVAL;
327 }
328
329 return 0;
330}
331
332static int nvmem_add_cells(struct nvmem_device *nvmem,
333 const struct nvmem_config *cfg)
334{
335 struct nvmem_cell **cells;
336 const struct nvmem_cell_info *info = cfg->cells;
337 int i, rval;
338
339 cells = kcalloc(cfg->ncells, sizeof(*cells), GFP_KERNEL);
340 if (!cells)
341 return -ENOMEM;
342
343 for (i = 0; i < cfg->ncells; i++) {
344 cells[i] = kzalloc(sizeof(**cells), GFP_KERNEL);
345 if (!cells[i]) {
346 rval = -ENOMEM;
347 goto err;
348 }
349
350 rval = nvmem_cell_info_to_nvmem_cell(nvmem, &info[i], cells[i]);
351 if (IS_ERR_VALUE(rval)) {
352 kfree(cells[i]);
353 goto err;
354 }
355
356 nvmem_cell_add(cells[i]);
357 }
358
359 nvmem->ncells = cfg->ncells;
360 /* remove tmp array */
361 kfree(cells);
362
363 return 0;
364err:
365 while (i--)
366 nvmem_cell_drop(cells[i]);
367
368 kfree(cells);
369
370 return rval;
371}
372
373/*
374 * nvmem_setup_compat() - Create an additional binary entry in
375 * drivers sys directory, to be backwards compatible with the older
376 * drivers/misc/eeprom drivers.
377 */
378static int nvmem_setup_compat(struct nvmem_device *nvmem,
379 const struct nvmem_config *config)
380{
381 int rval;
382
383 if (!config->base_dev)
384 return -EINVAL;
385
386 if (nvmem->read_only)
387 nvmem->eeprom = bin_attr_ro_root_nvmem;
388 else
389 nvmem->eeprom = bin_attr_rw_root_nvmem;
390 nvmem->eeprom.attr.name = "eeprom";
391 nvmem->eeprom.size = nvmem->size;
392#ifdef CONFIG_DEBUG_LOCK_ALLOC
393 nvmem->eeprom.attr.key = &eeprom_lock_key;
394#endif
395 nvmem->eeprom.private = &nvmem->dev;
396 nvmem->base_dev = config->base_dev;
397
398 rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
399 if (rval) {
400 dev_err(&nvmem->dev,
401 "Failed to create eeprom binary file %d\n", rval);
402 return rval;
403 }
404
405 nvmem->flags |= FLAG_COMPAT;
406
407 return 0;
408}
409
410/**
411 * nvmem_register() - Register a nvmem device for given nvmem_config.
412 * Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
413 *
414 * @config: nvmem device configuration with which nvmem device is created.
415 *
416 * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
417 * on success.
418 */
419
420struct nvmem_device *nvmem_register(const struct nvmem_config *config)
421{
422 struct nvmem_device *nvmem;
423 struct device_node *np;
424 struct regmap *rm;
425 int rval;
426
427 if (!config->dev)
428 return ERR_PTR(-EINVAL);
429
430 rm = dev_get_regmap(config->dev, NULL);
431 if (!rm) {
432 dev_err(config->dev, "Regmap not found\n");
433 return ERR_PTR(-EINVAL);
434 }
435
436 nvmem = kzalloc(sizeof(*nvmem), GFP_KERNEL);
437 if (!nvmem)
438 return ERR_PTR(-ENOMEM);
439
440 rval = ida_simple_get(&nvmem_ida, 0, 0, GFP_KERNEL);
441 if (rval < 0) {
442 kfree(nvmem);
443 return ERR_PTR(rval);
444 }
445
446 nvmem->id = rval;
447 nvmem->regmap = rm;
448 nvmem->owner = config->owner;
449 nvmem->stride = regmap_get_reg_stride(rm);
450 nvmem->word_size = regmap_get_val_bytes(rm);
451 nvmem->size = regmap_get_max_register(rm) + nvmem->stride;
452 nvmem->dev.type = &nvmem_provider_type;
453 nvmem->dev.bus = &nvmem_bus_type;
454 nvmem->dev.parent = config->dev;
455 np = config->dev->of_node;
456 nvmem->dev.of_node = np;
457 dev_set_name(&nvmem->dev, "%s%d",
458 config->name ? : "nvmem", config->id);
459
460 nvmem->read_only = of_property_read_bool(np, "read-only") |
461 config->read_only;
462
463 if (config->root_only)
464 nvmem->dev.groups = nvmem->read_only ?
465 nvmem_ro_root_dev_groups :
466 nvmem_rw_root_dev_groups;
467 else
468 nvmem->dev.groups = nvmem->read_only ?
469 nvmem_ro_dev_groups :
470 nvmem_rw_dev_groups;
471
472 device_initialize(&nvmem->dev);
473
474 dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
475
476 rval = device_add(&nvmem->dev);
477 if (rval)
478 goto out;
479
480 if (config->compat) {
481 rval = nvmem_setup_compat(nvmem, config);
482 if (rval)
483 goto out;
484 }
485
486 if (config->cells)
487 nvmem_add_cells(nvmem, config);
488
489 return nvmem;
490out:
491 ida_simple_remove(&nvmem_ida, nvmem->id);
492 kfree(nvmem);
493 return ERR_PTR(rval);
494}
495EXPORT_SYMBOL_GPL(nvmem_register);
496
497/**
498 * nvmem_unregister() - Unregister previously registered nvmem device
499 *
500 * @nvmem: Pointer to previously registered nvmem device.
501 *
502 * Return: Will be an negative on error or a zero on success.
503 */
504int nvmem_unregister(struct nvmem_device *nvmem)
505{
506 mutex_lock(&nvmem_mutex);
507 if (nvmem->users) {
508 mutex_unlock(&nvmem_mutex);
509 return -EBUSY;
510 }
511 mutex_unlock(&nvmem_mutex);
512
513 if (nvmem->flags & FLAG_COMPAT)
514 device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
515
516 nvmem_device_remove_all_cells(nvmem);
517 device_del(&nvmem->dev);
518
519 return 0;
520}
521EXPORT_SYMBOL_GPL(nvmem_unregister);
522
523static struct nvmem_device *__nvmem_device_get(struct device_node *np,
524 struct nvmem_cell **cellp,
525 const char *cell_id)
526{
527 struct nvmem_device *nvmem = NULL;
528
529 mutex_lock(&nvmem_mutex);
530
531 if (np) {
532 nvmem = of_nvmem_find(np);
533 if (!nvmem) {
534 mutex_unlock(&nvmem_mutex);
535 return ERR_PTR(-EPROBE_DEFER);
536 }
537 } else {
538 struct nvmem_cell *cell = nvmem_find_cell(cell_id);
539
540 if (cell) {
541 nvmem = cell->nvmem;
542 *cellp = cell;
543 }
544
545 if (!nvmem) {
546 mutex_unlock(&nvmem_mutex);
547 return ERR_PTR(-ENOENT);
548 }
549 }
550
551 nvmem->users++;
552 mutex_unlock(&nvmem_mutex);
553
554 if (!try_module_get(nvmem->owner)) {
555 dev_err(&nvmem->dev,
556 "could not increase module refcount for cell %s\n",
557 nvmem->name);
558
559 mutex_lock(&nvmem_mutex);
560 nvmem->users--;
561 mutex_unlock(&nvmem_mutex);
562
563 return ERR_PTR(-EINVAL);
564 }
565
566 return nvmem;
567}
568
569static void __nvmem_device_put(struct nvmem_device *nvmem)
570{
571 module_put(nvmem->owner);
572 mutex_lock(&nvmem_mutex);
573 nvmem->users--;
574 mutex_unlock(&nvmem_mutex);
575}
576
577static int nvmem_match(struct device *dev, void *data)
578{
579 return !strcmp(dev_name(dev), data);
580}
581
582static struct nvmem_device *nvmem_find(const char *name)
583{
584 struct device *d;
585
586 d = bus_find_device(&nvmem_bus_type, NULL, (void *)name, nvmem_match);
587
588 if (!d)
589 return NULL;
590
591 return to_nvmem_device(d);
592}
593
594#if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
595/**
596 * of_nvmem_device_get() - Get nvmem device from a given id
597 *
598 * @dev node: Device tree node that uses the nvmem device
599 * @id: nvmem name from nvmem-names property.
600 *
601 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
602 * on success.
603 */
604struct nvmem_device *of_nvmem_device_get(struct device_node *np, const char *id)
605{
606
607 struct device_node *nvmem_np;
608 int index;
609
610 index = of_property_match_string(np, "nvmem-names", id);
611
612 nvmem_np = of_parse_phandle(np, "nvmem", index);
613 if (!nvmem_np)
614 return ERR_PTR(-EINVAL);
615
616 return __nvmem_device_get(nvmem_np, NULL, NULL);
617}
618EXPORT_SYMBOL_GPL(of_nvmem_device_get);
619#endif
620
621/**
622 * nvmem_device_get() - Get nvmem device from a given id
623 *
624 * @dev : Device that uses the nvmem device
625 * @id: nvmem name from nvmem-names property.
626 *
627 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_device
628 * on success.
629 */
630struct nvmem_device *nvmem_device_get(struct device *dev, const char *dev_name)
631{
632 if (dev->of_node) { /* try dt first */
633 struct nvmem_device *nvmem;
634
635 nvmem = of_nvmem_device_get(dev->of_node, dev_name);
636
637 if (!IS_ERR(nvmem) || PTR_ERR(nvmem) == -EPROBE_DEFER)
638 return nvmem;
639
640 }
641
642 return nvmem_find(dev_name);
643}
644EXPORT_SYMBOL_GPL(nvmem_device_get);
645
646static int devm_nvmem_device_match(struct device *dev, void *res, void *data)
647{
648 struct nvmem_device **nvmem = res;
649
650 if (WARN_ON(!nvmem || !*nvmem))
651 return 0;
652
653 return *nvmem == data;
654}
655
656static void devm_nvmem_device_release(struct device *dev, void *res)
657{
658 nvmem_device_put(*(struct nvmem_device **)res);
659}
660
661/**
662 * devm_nvmem_device_put() - put alredy got nvmem device
663 *
664 * @nvmem: pointer to nvmem device allocated by devm_nvmem_cell_get(),
665 * that needs to be released.
666 */
667void devm_nvmem_device_put(struct device *dev, struct nvmem_device *nvmem)
668{
669 int ret;
670
671 ret = devres_release(dev, devm_nvmem_device_release,
672 devm_nvmem_device_match, nvmem);
673
674 WARN_ON(ret);
675}
676EXPORT_SYMBOL_GPL(devm_nvmem_device_put);
677
678/**
679 * nvmem_device_put() - put alredy got nvmem device
680 *
681 * @nvmem: pointer to nvmem device that needs to be released.
682 */
683void nvmem_device_put(struct nvmem_device *nvmem)
684{
685 __nvmem_device_put(nvmem);
686}
687EXPORT_SYMBOL_GPL(nvmem_device_put);
688
689/**
690 * devm_nvmem_device_get() - Get nvmem cell of device form a given id
691 *
692 * @dev node: Device tree node that uses the nvmem cell
693 * @id: nvmem name in nvmems property.
694 *
695 * Return: ERR_PTR() on error or a valid pointer to a struct nvmem_cell
696 * on success. The nvmem_cell will be freed by the automatically once the
697 * device is freed.
698 */
699struct nvmem_device *devm_nvmem_device_get(struct device *dev, const char *id)
700{
701 struct nvmem_device **ptr, *nvmem;
702
703 ptr = devres_alloc(devm_nvmem_device_release, sizeof(*ptr), GFP_KERNEL);
704 if (!ptr)
705 return ERR_PTR(-ENOMEM);
706
707 nvmem = nvmem_device_get(dev, id);
708 if (!IS_ERR(nvmem)) {
709 *ptr = nvmem;
710 devres_add(dev, ptr);
711 } else {
712 devres_free(ptr);
713 }
714
715 return nvmem;
716}
717EXPORT_SYMBOL_GPL(devm_nvmem_device_get);
718
719static struct nvmem_cell *nvmem_cell_get_from_list(const char *cell_id)
720{
721 struct nvmem_cell *cell = NULL;
722 struct nvmem_device *nvmem;
723
724 nvmem = __nvmem_device_get(NULL, &cell, cell_id);
725 if (IS_ERR(nvmem))
726 return ERR_CAST(nvmem);
727
728 return cell;
729}
730
731#if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
732/**
733 * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
734 *
735 * @dev node: Device tree node that uses the nvmem cell
736 * @id: nvmem cell name from nvmem-cell-names property.
737 *
738 * Return: Will be an ERR_PTR() on error or a valid pointer
739 * to a struct nvmem_cell. The nvmem_cell will be freed by the
740 * nvmem_cell_put().
741 */
742struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
743 const char *name)
744{
745 struct device_node *cell_np, *nvmem_np;
746 struct nvmem_cell *cell;
747 struct nvmem_device *nvmem;
748 const __be32 *addr;
749 int rval, len, index;
750
751 index = of_property_match_string(np, "nvmem-cell-names", name);
752
753 cell_np = of_parse_phandle(np, "nvmem-cells", index);
754 if (!cell_np)
755 return ERR_PTR(-EINVAL);
756
757 nvmem_np = of_get_next_parent(cell_np);
758 if (!nvmem_np)
759 return ERR_PTR(-EINVAL);
760
761 nvmem = __nvmem_device_get(nvmem_np, NULL, NULL);
762 if (IS_ERR(nvmem))
763 return ERR_CAST(nvmem);
764
765 addr = of_get_property(cell_np, "reg", &len);
766 if (!addr || (len < 2 * sizeof(u32))) {
767 dev_err(&nvmem->dev, "nvmem: invalid reg on %s\n",
768 cell_np->full_name);
769 rval = -EINVAL;
770 goto err_mem;
771 }
772
773 cell = kzalloc(sizeof(*cell), GFP_KERNEL);
774 if (!cell) {
775 rval = -ENOMEM;
776 goto err_mem;
777 }
778
779 cell->nvmem = nvmem;
780 cell->offset = be32_to_cpup(addr++);
781 cell->bytes = be32_to_cpup(addr);
782 cell->name = cell_np->name;
783
784 addr = of_get_property(cell_np, "bits", &len);
785 if (addr && len == (2 * sizeof(u32))) {
786 cell->bit_offset = be32_to_cpup(addr++);
787 cell->nbits = be32_to_cpup(addr);
788 }
789
790 if (cell->nbits)
791 cell->bytes = DIV_ROUND_UP(cell->nbits + cell->bit_offset,
792 BITS_PER_BYTE);
793
794 if (!IS_ALIGNED(cell->offset, nvmem->stride)) {
795 dev_err(&nvmem->dev,
796 "cell %s unaligned to nvmem stride %d\n",
797 cell->name, nvmem->stride);
798 rval = -EINVAL;
799 goto err_sanity;
800 }
801
802 nvmem_cell_add(cell);
803
804 return cell;
805
806err_sanity:
807 kfree(cell);
808
809err_mem:
810 __nvmem_device_put(nvmem);
811
812 return ERR_PTR(rval);
813}
814EXPORT_SYMBOL_GPL(of_nvmem_cell_get);
815#endif
816
817/**
818 * nvmem_cell_get() - Get nvmem cell of device form a given cell name
819 *
820 * @dev node: Device tree node that uses the nvmem cell
821 * @id: nvmem cell name to get.
822 *
823 * Return: Will be an ERR_PTR() on error or a valid pointer
824 * to a struct nvmem_cell. The nvmem_cell will be freed by the
825 * nvmem_cell_put().
826 */
827struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *cell_id)
828{
829 struct nvmem_cell *cell;
830
831 if (dev->of_node) { /* try dt first */
832 cell = of_nvmem_cell_get(dev->of_node, cell_id);
833 if (!IS_ERR(cell) || PTR_ERR(cell) == -EPROBE_DEFER)
834 return cell;
835 }
836
837 return nvmem_cell_get_from_list(cell_id);
838}
839EXPORT_SYMBOL_GPL(nvmem_cell_get);
840
841static void devm_nvmem_cell_release(struct device *dev, void *res)
842{
843 nvmem_cell_put(*(struct nvmem_cell **)res);
844}
845
846/**
847 * devm_nvmem_cell_get() - Get nvmem cell of device form a given id
848 *
849 * @dev node: Device tree node that uses the nvmem cell
850 * @id: nvmem id in nvmem-names property.
851 *
852 * Return: Will be an ERR_PTR() on error or a valid pointer
853 * to a struct nvmem_cell. The nvmem_cell will be freed by the
854 * automatically once the device is freed.
855 */
856struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id)
857{
858 struct nvmem_cell **ptr, *cell;
859
860 ptr = devres_alloc(devm_nvmem_cell_release, sizeof(*ptr), GFP_KERNEL);
861 if (!ptr)
862 return ERR_PTR(-ENOMEM);
863
864 cell = nvmem_cell_get(dev, id);
865 if (!IS_ERR(cell)) {
866 *ptr = cell;
867 devres_add(dev, ptr);
868 } else {
869 devres_free(ptr);
870 }
871
872 return cell;
873}
874EXPORT_SYMBOL_GPL(devm_nvmem_cell_get);
875
876static int devm_nvmem_cell_match(struct device *dev, void *res, void *data)
877{
878 struct nvmem_cell **c = res;
879
880 if (WARN_ON(!c || !*c))
881 return 0;
882
883 return *c == data;
884}
885
886/**
887 * devm_nvmem_cell_put() - Release previously allocated nvmem cell
888 * from devm_nvmem_cell_get.
889 *
890 * @cell: Previously allocated nvmem cell by devm_nvmem_cell_get()
891 */
892void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell)
893{
894 int ret;
895
896 ret = devres_release(dev, devm_nvmem_cell_release,
897 devm_nvmem_cell_match, cell);
898
899 WARN_ON(ret);
900}
901EXPORT_SYMBOL(devm_nvmem_cell_put);
902
903/**
904 * nvmem_cell_put() - Release previously allocated nvmem cell.
905 *
906 * @cell: Previously allocated nvmem cell by nvmem_cell_get()
907 */
908void nvmem_cell_put(struct nvmem_cell *cell)
909{
910 struct nvmem_device *nvmem = cell->nvmem;
911
912 __nvmem_device_put(nvmem);
913 nvmem_cell_drop(cell);
914}
915EXPORT_SYMBOL_GPL(nvmem_cell_put);
916
917static inline void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell,
918 void *buf)
919{
920 u8 *p, *b;
921 int i, bit_offset = cell->bit_offset;
922
923 p = b = buf;
924 if (bit_offset) {
925 /* First shift */
926 *b++ >>= bit_offset;
927
928 /* setup rest of the bytes if any */
929 for (i = 1; i < cell->bytes; i++) {
930 /* Get bits from next byte and shift them towards msb */
931 *p |= *b << (BITS_PER_BYTE - bit_offset);
932
933 p = b;
934 *b++ >>= bit_offset;
935 }
936
937 /* result fits in less bytes */
938 if (cell->bytes != DIV_ROUND_UP(cell->nbits, BITS_PER_BYTE))
939 *p-- = 0;
940 }
941 /* clear msb bits if any leftover in the last byte */
942 *p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0);
943}
944
945static int __nvmem_cell_read(struct nvmem_device *nvmem,
946 struct nvmem_cell *cell,
947 void *buf, size_t *len)
948{
949 int rc;
950
951 rc = regmap_raw_read(nvmem->regmap, cell->offset, buf, cell->bytes);
952
953 if (IS_ERR_VALUE(rc))
954 return rc;
955
956 /* shift bits in-place */
957 if (cell->bit_offset || cell->nbits)
958 nvmem_shift_read_buffer_in_place(cell, buf);
959
960 *len = cell->bytes;
961
962 return 0;
963}
964
965/**
966 * nvmem_cell_read() - Read a given nvmem cell
967 *
968 * @cell: nvmem cell to be read.
969 * @len: pointer to length of cell which will be populated on successful read.
970 *
971 * Return: ERR_PTR() on error or a valid pointer to a char * buffer on success.
972 * The buffer should be freed by the consumer with a kfree().
973 */
974void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
975{
976 struct nvmem_device *nvmem = cell->nvmem;
977 u8 *buf;
978 int rc;
979
980 if (!nvmem || !nvmem->regmap)
981 return ERR_PTR(-EINVAL);
982
983 buf = kzalloc(cell->bytes, GFP_KERNEL);
984 if (!buf)
985 return ERR_PTR(-ENOMEM);
986
987 rc = __nvmem_cell_read(nvmem, cell, buf, len);
988 if (IS_ERR_VALUE(rc)) {
989 kfree(buf);
990 return ERR_PTR(rc);
991 }
992
993 return buf;
994}
995EXPORT_SYMBOL_GPL(nvmem_cell_read);
996
997static inline void *nvmem_cell_prepare_write_buffer(struct nvmem_cell *cell,
998 u8 *_buf, int len)
999{
1000 struct nvmem_device *nvmem = cell->nvmem;
1001 int i, rc, nbits, bit_offset = cell->bit_offset;
1002 u8 v, *p, *buf, *b, pbyte, pbits;
1003
1004 nbits = cell->nbits;
1005 buf = kzalloc(cell->bytes, GFP_KERNEL);
1006 if (!buf)
1007 return ERR_PTR(-ENOMEM);
1008
1009 memcpy(buf, _buf, len);
1010 p = b = buf;
1011
1012 if (bit_offset) {
1013 pbyte = *b;
1014 *b <<= bit_offset;
1015
1016 /* setup the first byte with lsb bits from nvmem */
1017 rc = regmap_raw_read(nvmem->regmap, cell->offset, &v, 1);
1018 *b++ |= GENMASK(bit_offset - 1, 0) & v;
1019
1020 /* setup rest of the byte if any */
1021 for (i = 1; i < cell->bytes; i++) {
1022 /* Get last byte bits and shift them towards lsb */
1023 pbits = pbyte >> (BITS_PER_BYTE - 1 - bit_offset);
1024 pbyte = *b;
1025 p = b;
1026 *b <<= bit_offset;
1027 *b++ |= pbits;
1028 }
1029 }
1030
1031 /* if it's not end on byte boundary */
1032 if ((nbits + bit_offset) % BITS_PER_BYTE) {
1033 /* setup the last byte with msb bits from nvmem */
1034 rc = regmap_raw_read(nvmem->regmap,
1035 cell->offset + cell->bytes - 1, &v, 1);
1036 *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v;
1037
1038 }
1039
1040 return buf;
1041}
1042
1043/**
1044 * nvmem_cell_write() - Write to a given nvmem cell
1045 *
1046 * @cell: nvmem cell to be written.
1047 * @buf: Buffer to be written.
1048 * @len: length of buffer to be written to nvmem cell.
1049 *
1050 * Return: length of bytes written or negative on failure.
1051 */
1052int nvmem_cell_write(struct nvmem_cell *cell, void *buf, size_t len)
1053{
1054 struct nvmem_device *nvmem = cell->nvmem;
1055 int rc;
1056
1057 if (!nvmem || !nvmem->regmap || nvmem->read_only ||
1058 (cell->bit_offset == 0 && len != cell->bytes))
1059 return -EINVAL;
1060
1061 if (cell->bit_offset || cell->nbits) {
1062 buf = nvmem_cell_prepare_write_buffer(cell, buf, len);
1063 if (IS_ERR(buf))
1064 return PTR_ERR(buf);
1065 }
1066
1067 rc = regmap_raw_write(nvmem->regmap, cell->offset, buf, cell->bytes);
1068
1069 /* free the tmp buffer */
1070 if (cell->bit_offset || cell->nbits)
1071 kfree(buf);
1072
1073 if (IS_ERR_VALUE(rc))
1074 return rc;
1075
1076 return len;
1077}
1078EXPORT_SYMBOL_GPL(nvmem_cell_write);
1079
1080/**
1081 * nvmem_device_cell_read() - Read a given nvmem device and cell
1082 *
1083 * @nvmem: nvmem device to read from.
1084 * @info: nvmem cell info to be read.
1085 * @buf: buffer pointer which will be populated on successful read.
1086 *
1087 * Return: length of successful bytes read on success and negative
1088 * error code on error.
1089 */
1090ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
1091 struct nvmem_cell_info *info, void *buf)
1092{
1093 struct nvmem_cell cell;
1094 int rc;
1095 ssize_t len;
1096
1097 if (!nvmem || !nvmem->regmap)
1098 return -EINVAL;
1099
1100 rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1101 if (IS_ERR_VALUE(rc))
1102 return rc;
1103
1104 rc = __nvmem_cell_read(nvmem, &cell, buf, &len);
1105 if (IS_ERR_VALUE(rc))
1106 return rc;
1107
1108 return len;
1109}
1110EXPORT_SYMBOL_GPL(nvmem_device_cell_read);
1111
1112/**
1113 * nvmem_device_cell_write() - Write cell to a given nvmem device
1114 *
1115 * @nvmem: nvmem device to be written to.
1116 * @info: nvmem cell info to be written
1117 * @buf: buffer to be written to cell.
1118 *
1119 * Return: length of bytes written or negative error code on failure.
1120 * */
1121int nvmem_device_cell_write(struct nvmem_device *nvmem,
1122 struct nvmem_cell_info *info, void *buf)
1123{
1124 struct nvmem_cell cell;
1125 int rc;
1126
1127 if (!nvmem || !nvmem->regmap)
1128 return -EINVAL;
1129
1130 rc = nvmem_cell_info_to_nvmem_cell(nvmem, info, &cell);
1131 if (IS_ERR_VALUE(rc))
1132 return rc;
1133
1134 return nvmem_cell_write(&cell, buf, cell.bytes);
1135}
1136EXPORT_SYMBOL_GPL(nvmem_device_cell_write);
1137
1138/**
1139 * nvmem_device_read() - Read from a given nvmem device
1140 *
1141 * @nvmem: nvmem device to read from.
1142 * @offset: offset in nvmem device.
1143 * @bytes: number of bytes to read.
1144 * @buf: buffer pointer which will be populated on successful read.
1145 *
1146 * Return: length of successful bytes read on success and negative
1147 * error code on error.
1148 */
1149int nvmem_device_read(struct nvmem_device *nvmem,
1150 unsigned int offset,
1151 size_t bytes, void *buf)
1152{
1153 int rc;
1154
1155 if (!nvmem || !nvmem->regmap)
1156 return -EINVAL;
1157
1158 rc = regmap_raw_read(nvmem->regmap, offset, buf, bytes);
1159
1160 if (IS_ERR_VALUE(rc))
1161 return rc;
1162
1163 return bytes;
1164}
1165EXPORT_SYMBOL_GPL(nvmem_device_read);
1166
1167/**
1168 * nvmem_device_write() - Write cell to a given nvmem device
1169 *
1170 * @nvmem: nvmem device to be written to.
1171 * @offset: offset in nvmem device.
1172 * @bytes: number of bytes to write.
1173 * @buf: buffer to be written.
1174 *
1175 * Return: length of bytes written or negative error code on failure.
1176 * */
1177int nvmem_device_write(struct nvmem_device *nvmem,
1178 unsigned int offset,
1179 size_t bytes, void *buf)
1180{
1181 int rc;
1182
1183 if (!nvmem || !nvmem->regmap)
1184 return -EINVAL;
1185
1186 rc = regmap_raw_write(nvmem->regmap, offset, buf, bytes);
1187
1188 if (IS_ERR_VALUE(rc))
1189 return rc;
1190
1191
1192 return bytes;
1193}
1194EXPORT_SYMBOL_GPL(nvmem_device_write);
1195
1196static int __init nvmem_init(void)
1197{
1198 return bus_register(&nvmem_bus_type);
1199}
1200
1201static void __exit nvmem_exit(void)
1202{
1203 bus_unregister(&nvmem_bus_type);
1204}
1205
1206subsys_initcall(nvmem_init);
1207module_exit(nvmem_exit);
1208
1209MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
1210MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com");
1211MODULE_DESCRIPTION("nvmem Driver Core");
1212MODULE_LICENSE("GPL v2");