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