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