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[0]; 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 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 */ 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 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 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 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 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 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 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 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 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 301 static int 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 return 0; 309 } 310 311 static struct coreboot_driver vpd_driver = { 312 .probe = vpd_probe, 313 .remove = vpd_remove, 314 .drv = { 315 .name = "vpd", 316 }, 317 .tag = CB_TAG_VPD, 318 }; 319 module_coreboot_driver(vpd_driver); 320 321 MODULE_AUTHOR("Google, Inc."); 322 MODULE_LICENSE("GPL"); 323