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