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