1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (c) 2023 Daniel Golle <daniel@makrotopia.org>
4 */
5
6/* UBI NVMEM provider */
7#include "ubi.h"
8#include <linux/nvmem-provider.h>
9
10/* List of all NVMEM devices */
11static LIST_HEAD(nvmem_devices);
12static DEFINE_MUTEX(devices_mutex);
13
14struct ubi_nvmem {
15 struct nvmem_device *nvmem;
16 int ubi_num;
17 int vol_id;
18 int usable_leb_size;
19 struct list_head list;
20};
21
22static int ubi_nvmem_reg_read(void *priv, unsigned int from,
23 void *val, size_t bytes)
24{
25 size_t to_read, bytes_left = bytes;
26 struct ubi_nvmem *unv = priv;
27 struct ubi_volume_desc *desc;
28 uint32_t offs;
29 uint32_t lnum;
30 int err = 0;
31
32 desc = ubi_open_volume(ubi_num: unv->ubi_num, vol_id: unv->vol_id, mode: UBI_READONLY);
33 if (IS_ERR(ptr: desc))
34 return PTR_ERR(ptr: desc);
35
36 offs = from % unv->usable_leb_size;
37 lnum = from / unv->usable_leb_size;
38 while (bytes_left) {
39 to_read = unv->usable_leb_size - offs;
40
41 if (to_read > bytes_left)
42 to_read = bytes_left;
43
44 err = ubi_read(desc, lnum, buf: val, offset: offs, len: to_read);
45 if (err)
46 break;
47
48 lnum += 1;
49 offs = 0;
50 bytes_left -= to_read;
51 val += to_read;
52 }
53 ubi_close_volume(desc);
54
55 if (err)
56 return err;
57
58 return 0;
59}
60
61static int ubi_nvmem_add(struct ubi_volume_info *vi)
62{
63 struct device_node *np = dev_of_node(dev: vi->dev);
64 struct nvmem_config config = {};
65 struct ubi_nvmem *unv;
66 int ret;
67
68 if (!np)
69 return 0;
70
71 if (!of_get_child_by_name(node: np, name: "nvmem-layout"))
72 return 0;
73
74 if (WARN_ON_ONCE(vi->usable_leb_size <= 0) ||
75 WARN_ON_ONCE(vi->size <= 0))
76 return -EINVAL;
77
78 unv = kzalloc(sizeof(struct ubi_nvmem), GFP_KERNEL);
79 if (!unv)
80 return -ENOMEM;
81
82 config.id = NVMEM_DEVID_NONE;
83 config.dev = vi->dev;
84 config.name = dev_name(dev: vi->dev);
85 config.owner = THIS_MODULE;
86 config.priv = unv;
87 config.reg_read = ubi_nvmem_reg_read;
88 config.size = vi->usable_leb_size * vi->size;
89 config.word_size = 1;
90 config.stride = 1;
91 config.read_only = true;
92 config.root_only = true;
93 config.ignore_wp = true;
94 config.of_node = np;
95
96 unv->ubi_num = vi->ubi_num;
97 unv->vol_id = vi->vol_id;
98 unv->usable_leb_size = vi->usable_leb_size;
99 unv->nvmem = nvmem_register(cfg: &config);
100 if (IS_ERR(ptr: unv->nvmem)) {
101 ret = dev_err_probe(dev: vi->dev, err: PTR_ERR(ptr: unv->nvmem),
102 fmt: "Failed to register NVMEM device\n");
103 kfree(objp: unv);
104 return ret;
105 }
106
107 mutex_lock(&devices_mutex);
108 list_add_tail(new: &unv->list, head: &nvmem_devices);
109 mutex_unlock(lock: &devices_mutex);
110
111 return 0;
112}
113
114static void ubi_nvmem_remove(struct ubi_volume_info *vi)
115{
116 struct ubi_nvmem *unv_c, *unv = NULL;
117
118 mutex_lock(&devices_mutex);
119 list_for_each_entry(unv_c, &nvmem_devices, list)
120 if (unv_c->ubi_num == vi->ubi_num && unv_c->vol_id == vi->vol_id) {
121 unv = unv_c;
122 break;
123 }
124
125 if (!unv) {
126 mutex_unlock(lock: &devices_mutex);
127 return;
128 }
129
130 list_del(entry: &unv->list);
131 mutex_unlock(lock: &devices_mutex);
132 nvmem_unregister(nvmem: unv->nvmem);
133 kfree(objp: unv);
134}
135
136/**
137 * nvmem_notify - UBI notification handler.
138 * @nb: registered notifier block
139 * @l: notification type
140 * @ns_ptr: pointer to the &struct ubi_notification object
141 */
142static int nvmem_notify(struct notifier_block *nb, unsigned long l,
143 void *ns_ptr)
144{
145 struct ubi_notification *nt = ns_ptr;
146
147 switch (l) {
148 case UBI_VOLUME_RESIZED:
149 ubi_nvmem_remove(vi: &nt->vi);
150 fallthrough;
151 case UBI_VOLUME_ADDED:
152 ubi_nvmem_add(vi: &nt->vi);
153 break;
154 case UBI_VOLUME_SHUTDOWN:
155 ubi_nvmem_remove(vi: &nt->vi);
156 break;
157 default:
158 break;
159 }
160 return NOTIFY_OK;
161}
162
163static struct notifier_block nvmem_notifier = {
164 .notifier_call = nvmem_notify,
165};
166
167static int __init ubi_nvmem_init(void)
168{
169 return ubi_register_volume_notifier(nb: &nvmem_notifier, ignore_existing: 0);
170}
171
172static void __exit ubi_nvmem_exit(void)
173{
174 struct ubi_nvmem *unv, *tmp;
175
176 mutex_lock(&devices_mutex);
177 list_for_each_entry_safe(unv, tmp, &nvmem_devices, list) {
178 nvmem_unregister(nvmem: unv->nvmem);
179 list_del(entry: &unv->list);
180 kfree(objp: unv);
181 }
182 mutex_unlock(lock: &devices_mutex);
183
184 ubi_unregister_volume_notifier(nb: &nvmem_notifier);
185}
186
187module_init(ubi_nvmem_init);
188module_exit(ubi_nvmem_exit);
189MODULE_DESCRIPTION("NVMEM layer over UBI volumes");
190MODULE_AUTHOR("Daniel Golle");
191MODULE_LICENSE("GPL");
192

source code of linux/drivers/mtd/ubi/nvmem.c