1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * vpd.c
4  *
5  * Driver for exporting VPD content to sysfs.
6  *
7  * Copyright 2017 Google Inc.
8  */
9 
10 #include <linux/ctype.h>
11 #include <linux/init.h>
12 #include <linux/io.h>
13 #include <linux/kernel.h>
14 #include <linux/kobject.h>
15 #include <linux/list.h>
16 #include <linux/module.h>
17 #include <linux/of_address.h>
18 #include <linux/platform_device.h>
19 #include <linux/slab.h>
20 #include <linux/sysfs.h>
21 
22 #include "coreboot_table.h"
23 #include "vpd_decode.h"
24 
25 #define CB_TAG_VPD      0x2c
26 #define VPD_CBMEM_MAGIC 0x43524f53
27 
28 static struct kobject *vpd_kobj;
29 
30 struct vpd_cbmem {
31 	u32 magic;
32 	u32 version;
33 	u32 ro_size;
34 	u32 rw_size;
35 	u8  blob[];
36 };
37 
38 struct vpd_section {
39 	bool enabled;
40 	const char *name;
41 	char *raw_name;                /* the string name_raw */
42 	struct kobject *kobj;          /* vpd/name directory */
43 	char *baseaddr;
44 	struct bin_attribute bin_attr; /* vpd/name_raw bin_attribute */
45 	struct list_head attribs;      /* key/value in vpd_attrib_info list */
46 };
47 
48 struct vpd_attrib_info {
49 	char *key;
50 	const char *value;
51 	struct bin_attribute bin_attr;
52 	struct list_head list;
53 };
54 
55 static struct vpd_section ro_vpd;
56 static struct vpd_section rw_vpd;
57 
vpd_attrib_read(struct file * filp,struct kobject * kobp,struct bin_attribute * bin_attr,char * buf,loff_t pos,size_t count)58 static ssize_t vpd_attrib_read(struct file *filp, struct kobject *kobp,
59 			       struct bin_attribute *bin_attr, char *buf,
60 			       loff_t pos, size_t count)
61 {
62 	struct vpd_attrib_info *info = bin_attr->private;
63 
64 	return memory_read_from_buffer(buf, count, &pos, info->value,
65 				       info->bin_attr.size);
66 }
67 
68 /*
69  * vpd_section_check_key_name()
70  *
71  * The VPD specification supports only [a-zA-Z0-9_]+ characters in key names but
72  * old firmware versions may have entries like "S/N" which are problematic when
73  * exporting them as sysfs attributes. These keys present in old firmwares are
74  * ignored.
75  *
76  * Returns VPD_OK for a valid key name, VPD_FAIL otherwise.
77  *
78  * @key: The key name to check
79  * @key_len: key name length
80  */
vpd_section_check_key_name(const u8 * key,s32 key_len)81 static int vpd_section_check_key_name(const u8 *key, s32 key_len)
82 {
83 	int c;
84 
85 	while (key_len-- > 0) {
86 		c = *key++;
87 
88 		if (!isalnum(c) && c != '_')
89 			return VPD_FAIL;
90 	}
91 
92 	return VPD_OK;
93 }
94 
vpd_section_attrib_add(const u8 * key,u32 key_len,const u8 * value,u32 value_len,void * arg)95 static int vpd_section_attrib_add(const u8 *key, u32 key_len,
96 				  const u8 *value, u32 value_len,
97 				  void *arg)
98 {
99 	int ret;
100 	struct vpd_section *sec = arg;
101 	struct vpd_attrib_info *info;
102 
103 	/*
104 	 * Return VPD_OK immediately to decode next entry if the current key
105 	 * name contains invalid characters.
106 	 */
107 	if (vpd_section_check_key_name(key, key_len) != VPD_OK)
108 		return VPD_OK;
109 
110 	info = kzalloc(sizeof(*info), GFP_KERNEL);
111 	if (!info)
112 		return -ENOMEM;
113 
114 	info->key = kstrndup(key, key_len, GFP_KERNEL);
115 	if (!info->key) {
116 		ret = -ENOMEM;
117 		goto free_info;
118 	}
119 
120 	sysfs_bin_attr_init(&info->bin_attr);
121 	info->bin_attr.attr.name = info->key;
122 	info->bin_attr.attr.mode = 0444;
123 	info->bin_attr.size = value_len;
124 	info->bin_attr.read = vpd_attrib_read;
125 	info->bin_attr.private = info;
126 
127 	info->value = value;
128 
129 	INIT_LIST_HEAD(&info->list);
130 
131 	ret = sysfs_create_bin_file(sec->kobj, &info->bin_attr);
132 	if (ret)
133 		goto free_info_key;
134 
135 	list_add_tail(&info->list, &sec->attribs);
136 	return 0;
137 
138 free_info_key:
139 	kfree(info->key);
140 free_info:
141 	kfree(info);
142 
143 	return ret;
144 }
145 
vpd_section_attrib_destroy(struct vpd_section * sec)146 static void vpd_section_attrib_destroy(struct vpd_section *sec)
147 {
148 	struct vpd_attrib_info *info;
149 	struct vpd_attrib_info *temp;
150 
151 	list_for_each_entry_safe(info, temp, &sec->attribs, list) {
152 		sysfs_remove_bin_file(sec->kobj, &info->bin_attr);
153 		kfree(info->key);
154 		kfree(info);
155 	}
156 }
157 
vpd_section_read(struct file * filp,struct kobject * kobp,struct bin_attribute * bin_attr,char * buf,loff_t pos,size_t count)158 static ssize_t vpd_section_read(struct file *filp, struct kobject *kobp,
159 				struct bin_attribute *bin_attr, char *buf,
160 				loff_t pos, size_t count)
161 {
162 	struct vpd_section *sec = bin_attr->private;
163 
164 	return memory_read_from_buffer(buf, count, &pos, sec->baseaddr,
165 				       sec->bin_attr.size);
166 }
167 
vpd_section_create_attribs(struct vpd_section * sec)168 static int vpd_section_create_attribs(struct vpd_section *sec)
169 {
170 	s32 consumed;
171 	int ret;
172 
173 	consumed = 0;
174 	do {
175 		ret = vpd_decode_string(sec->bin_attr.size, sec->baseaddr,
176 					&consumed, vpd_section_attrib_add, sec);
177 	} while (ret == VPD_OK);
178 
179 	return 0;
180 }
181 
vpd_section_init(const char * name,struct vpd_section * sec,phys_addr_t physaddr,size_t size)182 static int vpd_section_init(const char *name, struct vpd_section *sec,
183 			    phys_addr_t physaddr, size_t size)
184 {
185 	int err;
186 
187 	sec->baseaddr = memremap(physaddr, size, MEMREMAP_WB);
188 	if (!sec->baseaddr)
189 		return -ENOMEM;
190 
191 	sec->name = name;
192 
193 	/* We want to export the raw partition with name ${name}_raw */
194 	sec->raw_name = kasprintf(GFP_KERNEL, "%s_raw", name);
195 	if (!sec->raw_name) {
196 		err = -ENOMEM;
197 		goto err_memunmap;
198 	}
199 
200 	sysfs_bin_attr_init(&sec->bin_attr);
201 	sec->bin_attr.attr.name = sec->raw_name;
202 	sec->bin_attr.attr.mode = 0444;
203 	sec->bin_attr.size = size;
204 	sec->bin_attr.read = vpd_section_read;
205 	sec->bin_attr.private = sec;
206 
207 	err = sysfs_create_bin_file(vpd_kobj, &sec->bin_attr);
208 	if (err)
209 		goto err_free_raw_name;
210 
211 	sec->kobj = kobject_create_and_add(name, vpd_kobj);
212 	if (!sec->kobj) {
213 		err = -EINVAL;
214 		goto err_sysfs_remove;
215 	}
216 
217 	INIT_LIST_HEAD(&sec->attribs);
218 	vpd_section_create_attribs(sec);
219 
220 	sec->enabled = true;
221 
222 	return 0;
223 
224 err_sysfs_remove:
225 	sysfs_remove_bin_file(vpd_kobj, &sec->bin_attr);
226 err_free_raw_name:
227 	kfree(sec->raw_name);
228 err_memunmap:
229 	memunmap(sec->baseaddr);
230 	return err;
231 }
232 
vpd_section_destroy(struct vpd_section * sec)233 static int vpd_section_destroy(struct vpd_section *sec)
234 {
235 	if (sec->enabled) {
236 		vpd_section_attrib_destroy(sec);
237 		kobject_put(sec->kobj);
238 		sysfs_remove_bin_file(vpd_kobj, &sec->bin_attr);
239 		kfree(sec->raw_name);
240 		memunmap(sec->baseaddr);
241 		sec->enabled = false;
242 	}
243 
244 	return 0;
245 }
246 
vpd_sections_init(phys_addr_t physaddr)247 static int vpd_sections_init(phys_addr_t physaddr)
248 {
249 	struct vpd_cbmem *temp;
250 	struct vpd_cbmem header;
251 	int ret = 0;
252 
253 	temp = memremap(physaddr, sizeof(struct vpd_cbmem), MEMREMAP_WB);
254 	if (!temp)
255 		return -ENOMEM;
256 
257 	memcpy(&header, temp, sizeof(struct vpd_cbmem));
258 	memunmap(temp);
259 
260 	if (header.magic != VPD_CBMEM_MAGIC)
261 		return -ENODEV;
262 
263 	if (header.ro_size) {
264 		ret = vpd_section_init("ro", &ro_vpd,
265 				       physaddr + sizeof(struct vpd_cbmem),
266 				       header.ro_size);
267 		if (ret)
268 			return ret;
269 	}
270 
271 	if (header.rw_size) {
272 		ret = vpd_section_init("rw", &rw_vpd,
273 				       physaddr + sizeof(struct vpd_cbmem) +
274 				       header.ro_size, header.rw_size);
275 		if (ret) {
276 			vpd_section_destroy(&ro_vpd);
277 			return ret;
278 		}
279 	}
280 
281 	return 0;
282 }
283 
vpd_probe(struct coreboot_device * dev)284 static int vpd_probe(struct coreboot_device *dev)
285 {
286 	int ret;
287 
288 	vpd_kobj = kobject_create_and_add("vpd", firmware_kobj);
289 	if (!vpd_kobj)
290 		return -ENOMEM;
291 
292 	ret = vpd_sections_init(dev->cbmem_ref.cbmem_addr);
293 	if (ret) {
294 		kobject_put(vpd_kobj);
295 		return ret;
296 	}
297 
298 	return 0;
299 }
300 
vpd_remove(struct coreboot_device * dev)301 static void vpd_remove(struct coreboot_device *dev)
302 {
303 	vpd_section_destroy(&ro_vpd);
304 	vpd_section_destroy(&rw_vpd);
305 
306 	kobject_put(vpd_kobj);
307 }
308 
309 static struct coreboot_driver vpd_driver = {
310 	.probe = vpd_probe,
311 	.remove = vpd_remove,
312 	.drv = {
313 		.name = "vpd",
314 	},
315 	.tag = CB_TAG_VPD,
316 };
317 module_coreboot_driver(vpd_driver);
318 
319 MODULE_AUTHOR("Google, Inc.");
320 MODULE_LICENSE("GPL");
321