Commit | Line | Data |
---|---|---|
ae0c2d72 SK |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Copyright (c) 2019, Linaro Limited | |
4 | */ | |
5 | #include "nvmem.h" | |
6 | ||
7 | static const char * const nvmem_type_str[] = { | |
8 | [NVMEM_TYPE_UNKNOWN] = "Unknown", | |
9 | [NVMEM_TYPE_EEPROM] = "EEPROM", | |
10 | [NVMEM_TYPE_OTP] = "OTP", | |
11 | [NVMEM_TYPE_BATTERY_BACKED] = "Battery backed", | |
12 | }; | |
13 | ||
14 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | |
15 | static struct lock_class_key eeprom_lock_key; | |
16 | #endif | |
17 | ||
18 | static ssize_t type_show(struct device *dev, | |
19 | struct device_attribute *attr, char *buf) | |
20 | { | |
21 | struct nvmem_device *nvmem = to_nvmem_device(dev); | |
22 | ||
23 | return sprintf(buf, "%s\n", nvmem_type_str[nvmem->type]); | |
24 | } | |
25 | ||
26 | static DEVICE_ATTR_RO(type); | |
27 | ||
28 | static struct attribute *nvmem_attrs[] = { | |
29 | &dev_attr_type.attr, | |
30 | NULL, | |
31 | }; | |
32 | ||
33 | static ssize_t bin_attr_nvmem_read(struct file *filp, struct kobject *kobj, | |
34 | struct bin_attribute *attr, | |
35 | char *buf, loff_t pos, size_t count) | |
36 | { | |
37 | struct device *dev; | |
38 | struct nvmem_device *nvmem; | |
39 | int rc; | |
40 | ||
41 | if (attr->private) | |
42 | dev = attr->private; | |
43 | else | |
44 | dev = container_of(kobj, struct device, kobj); | |
45 | nvmem = to_nvmem_device(dev); | |
46 | ||
47 | /* Stop the user from reading */ | |
48 | if (pos >= nvmem->size) | |
49 | return 0; | |
50 | ||
51 | if (count < nvmem->word_size) | |
52 | return -EINVAL; | |
53 | ||
54 | if (pos + count > nvmem->size) | |
55 | count = nvmem->size - pos; | |
56 | ||
57 | count = round_down(count, nvmem->word_size); | |
58 | ||
59 | rc = nvmem->reg_read(nvmem->priv, pos, buf, count); | |
60 | ||
61 | if (rc) | |
62 | return rc; | |
63 | ||
64 | return count; | |
65 | } | |
66 | ||
67 | static ssize_t bin_attr_nvmem_write(struct file *filp, struct kobject *kobj, | |
68 | struct bin_attribute *attr, | |
69 | char *buf, loff_t pos, size_t count) | |
70 | { | |
71 | struct device *dev; | |
72 | struct nvmem_device *nvmem; | |
73 | int rc; | |
74 | ||
75 | if (attr->private) | |
76 | dev = attr->private; | |
77 | else | |
78 | dev = container_of(kobj, struct device, kobj); | |
79 | nvmem = to_nvmem_device(dev); | |
80 | ||
81 | /* Stop the user from writing */ | |
82 | if (pos >= nvmem->size) | |
83 | return -EFBIG; | |
84 | ||
85 | if (count < nvmem->word_size) | |
86 | return -EINVAL; | |
87 | ||
88 | if (pos + count > nvmem->size) | |
89 | count = nvmem->size - pos; | |
90 | ||
91 | count = round_down(count, nvmem->word_size); | |
92 | ||
93 | rc = nvmem->reg_write(nvmem->priv, pos, buf, count); | |
94 | ||
95 | if (rc) | |
96 | return rc; | |
97 | ||
98 | return count; | |
99 | } | |
100 | ||
101 | /* default read/write permissions */ | |
102 | static struct bin_attribute bin_attr_rw_nvmem = { | |
103 | .attr = { | |
104 | .name = "nvmem", | |
105 | .mode = 0644, | |
106 | }, | |
107 | .read = bin_attr_nvmem_read, | |
108 | .write = bin_attr_nvmem_write, | |
109 | }; | |
110 | ||
111 | static struct bin_attribute *nvmem_bin_rw_attributes[] = { | |
112 | &bin_attr_rw_nvmem, | |
113 | NULL, | |
114 | }; | |
115 | ||
116 | static const struct attribute_group nvmem_bin_rw_group = { | |
117 | .bin_attrs = nvmem_bin_rw_attributes, | |
118 | .attrs = nvmem_attrs, | |
119 | }; | |
120 | ||
121 | static const struct attribute_group *nvmem_rw_dev_groups[] = { | |
122 | &nvmem_bin_rw_group, | |
123 | NULL, | |
124 | }; | |
125 | ||
126 | /* read only permission */ | |
127 | static struct bin_attribute bin_attr_ro_nvmem = { | |
128 | .attr = { | |
129 | .name = "nvmem", | |
130 | .mode = 0444, | |
131 | }, | |
132 | .read = bin_attr_nvmem_read, | |
133 | }; | |
134 | ||
135 | static struct bin_attribute *nvmem_bin_ro_attributes[] = { | |
136 | &bin_attr_ro_nvmem, | |
137 | NULL, | |
138 | }; | |
139 | ||
140 | static const struct attribute_group nvmem_bin_ro_group = { | |
141 | .bin_attrs = nvmem_bin_ro_attributes, | |
142 | .attrs = nvmem_attrs, | |
143 | }; | |
144 | ||
145 | static const struct attribute_group *nvmem_ro_dev_groups[] = { | |
146 | &nvmem_bin_ro_group, | |
147 | NULL, | |
148 | }; | |
149 | ||
150 | /* default read/write permissions, root only */ | |
151 | static struct bin_attribute bin_attr_rw_root_nvmem = { | |
152 | .attr = { | |
153 | .name = "nvmem", | |
154 | .mode = 0600, | |
155 | }, | |
156 | .read = bin_attr_nvmem_read, | |
157 | .write = bin_attr_nvmem_write, | |
158 | }; | |
159 | ||
160 | static struct bin_attribute *nvmem_bin_rw_root_attributes[] = { | |
161 | &bin_attr_rw_root_nvmem, | |
162 | NULL, | |
163 | }; | |
164 | ||
165 | static const struct attribute_group nvmem_bin_rw_root_group = { | |
166 | .bin_attrs = nvmem_bin_rw_root_attributes, | |
167 | .attrs = nvmem_attrs, | |
168 | }; | |
169 | ||
170 | static const struct attribute_group *nvmem_rw_root_dev_groups[] = { | |
171 | &nvmem_bin_rw_root_group, | |
172 | NULL, | |
173 | }; | |
174 | ||
175 | /* read only permission, root only */ | |
176 | static struct bin_attribute bin_attr_ro_root_nvmem = { | |
177 | .attr = { | |
178 | .name = "nvmem", | |
179 | .mode = 0400, | |
180 | }, | |
181 | .read = bin_attr_nvmem_read, | |
182 | }; | |
183 | ||
184 | static struct bin_attribute *nvmem_bin_ro_root_attributes[] = { | |
185 | &bin_attr_ro_root_nvmem, | |
186 | NULL, | |
187 | }; | |
188 | ||
189 | static const struct attribute_group nvmem_bin_ro_root_group = { | |
190 | .bin_attrs = nvmem_bin_ro_root_attributes, | |
191 | .attrs = nvmem_attrs, | |
192 | }; | |
193 | ||
194 | static const struct attribute_group *nvmem_ro_root_dev_groups[] = { | |
195 | &nvmem_bin_ro_root_group, | |
196 | NULL, | |
197 | }; | |
198 | ||
199 | const struct attribute_group **nvmem_sysfs_get_groups( | |
200 | struct nvmem_device *nvmem, | |
201 | const struct nvmem_config *config) | |
202 | { | |
203 | if (config->root_only) | |
204 | return nvmem->read_only ? | |
205 | nvmem_ro_root_dev_groups : | |
206 | nvmem_rw_root_dev_groups; | |
207 | ||
208 | return nvmem->read_only ? nvmem_ro_dev_groups : nvmem_rw_dev_groups; | |
209 | } | |
210 | ||
211 | /* | |
212 | * nvmem_setup_compat() - Create an additional binary entry in | |
213 | * drivers sys directory, to be backwards compatible with the older | |
214 | * drivers/misc/eeprom drivers. | |
215 | */ | |
216 | int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem, | |
217 | const struct nvmem_config *config) | |
218 | { | |
219 | int rval; | |
220 | ||
221 | if (!config->compat) | |
222 | return 0; | |
223 | ||
224 | if (!config->base_dev) | |
225 | return -EINVAL; | |
226 | ||
e70d8b28 JD |
227 | if (nvmem->read_only) { |
228 | if (config->root_only) | |
229 | nvmem->eeprom = bin_attr_ro_root_nvmem; | |
230 | else | |
231 | nvmem->eeprom = bin_attr_ro_nvmem; | |
232 | } else { | |
233 | if (config->root_only) | |
234 | nvmem->eeprom = bin_attr_rw_root_nvmem; | |
235 | else | |
236 | nvmem->eeprom = bin_attr_rw_nvmem; | |
237 | } | |
ae0c2d72 SK |
238 | nvmem->eeprom.attr.name = "eeprom"; |
239 | nvmem->eeprom.size = nvmem->size; | |
240 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | |
241 | nvmem->eeprom.attr.key = &eeprom_lock_key; | |
242 | #endif | |
243 | nvmem->eeprom.private = &nvmem->dev; | |
244 | nvmem->base_dev = config->base_dev; | |
245 | ||
246 | rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom); | |
247 | if (rval) { | |
248 | dev_err(&nvmem->dev, | |
249 | "Failed to create eeprom binary file %d\n", rval); | |
250 | return rval; | |
251 | } | |
252 | ||
253 | nvmem->flags |= FLAG_COMPAT; | |
254 | ||
255 | return 0; | |
256 | } | |
257 | ||
258 | void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem, | |
259 | const struct nvmem_config *config) | |
260 | { | |
261 | if (config->compat) | |
262 | device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom); | |
263 | } |