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