1 /* 2 * drivers/firmware/qemu_fw_cfg.c 3 * 4 * Copyright 2015 Carnegie Mellon University 5 * 6 * Expose entries from QEMU's firmware configuration (fw_cfg) device in 7 * sysfs (read-only, under "/sys/firmware/qemu_fw_cfg/..."). 8 * 9 * The fw_cfg device may be instantiated via either an ACPI node (on x86 10 * and select subsets of aarch64), a Device Tree node (on arm), or using 11 * a kernel module (or command line) parameter with the following syntax: 12 * 13 * [fw_cfg.]ioport=<size>@<base>[:<ctrl_off>:<data_off>] 14 * or 15 * [fw_cfg.]mmio=<size>@<base>[:<ctrl_off>:<data_off>] 16 * 17 * where: 18 * <size> := size of ioport or mmio range 19 * <base> := physical base address of ioport or mmio range 20 * <ctrl_off> := (optional) offset of control register 21 * <data_off> := (optional) offset of data register 22 * 23 * e.g.: 24 * fw_cfg.ioport=2@0x510:0:1 (the default on x86) 25 * or 26 * fw_cfg.mmio=0xA@0x9020000:8:0 (the default on arm) 27 */ 28 29 #include <linux/module.h> 30 #include <linux/platform_device.h> 31 #include <linux/acpi.h> 32 #include <linux/slab.h> 33 #include <linux/io.h> 34 #include <linux/ioport.h> 35 36 MODULE_AUTHOR("Gabriel L. Somlo <somlo@cmu.edu>"); 37 MODULE_DESCRIPTION("QEMU fw_cfg sysfs support"); 38 MODULE_LICENSE("GPL"); 39 40 /* selector key values for "well-known" fw_cfg entries */ 41 #define FW_CFG_SIGNATURE 0x00 42 #define FW_CFG_ID 0x01 43 #define FW_CFG_FILE_DIR 0x19 44 45 /* size in bytes of fw_cfg signature */ 46 #define FW_CFG_SIG_SIZE 4 47 48 /* fw_cfg "file name" is up to 56 characters (including terminating nul) */ 49 #define FW_CFG_MAX_FILE_PATH 56 50 51 /* fw_cfg file directory entry type */ 52 struct fw_cfg_file { 53 u32 size; 54 u16 select; 55 u16 reserved; 56 char name[FW_CFG_MAX_FILE_PATH]; 57 }; 58 59 /* fw_cfg device i/o register addresses */ 60 static bool fw_cfg_is_mmio; 61 static phys_addr_t fw_cfg_p_base; 62 static resource_size_t fw_cfg_p_size; 63 static void __iomem *fw_cfg_dev_base; 64 static void __iomem *fw_cfg_reg_ctrl; 65 static void __iomem *fw_cfg_reg_data; 66 67 /* atomic access to fw_cfg device (potentially slow i/o, so using mutex) */ 68 static DEFINE_MUTEX(fw_cfg_dev_lock); 69 70 /* pick appropriate endianness for selector key */ 71 static inline u16 fw_cfg_sel_endianness(u16 key) 72 { 73 return fw_cfg_is_mmio ? cpu_to_be16(key) : cpu_to_le16(key); 74 } 75 76 /* read chunk of given fw_cfg blob (caller responsible for sanity-check) */ 77 static inline void fw_cfg_read_blob(u16 key, 78 void *buf, loff_t pos, size_t count) 79 { 80 u32 glk = -1U; 81 acpi_status status; 82 83 /* If we have ACPI, ensure mutual exclusion against any potential 84 * device access by the firmware, e.g. via AML methods: 85 */ 86 status = acpi_acquire_global_lock(ACPI_WAIT_FOREVER, &glk); 87 if (ACPI_FAILURE(status) && status != AE_NOT_CONFIGURED) { 88 /* Should never get here */ 89 WARN(1, "fw_cfg_read_blob: Failed to lock ACPI!\n"); 90 memset(buf, 0, count); 91 return; 92 } 93 94 mutex_lock(&fw_cfg_dev_lock); 95 iowrite16(fw_cfg_sel_endianness(key), fw_cfg_reg_ctrl); 96 while (pos-- > 0) 97 ioread8(fw_cfg_reg_data); 98 ioread8_rep(fw_cfg_reg_data, buf, count); 99 mutex_unlock(&fw_cfg_dev_lock); 100 101 acpi_release_global_lock(glk); 102 } 103 104 /* clean up fw_cfg device i/o */ 105 static void fw_cfg_io_cleanup(void) 106 { 107 if (fw_cfg_is_mmio) { 108 iounmap(fw_cfg_dev_base); 109 release_mem_region(fw_cfg_p_base, fw_cfg_p_size); 110 } else { 111 ioport_unmap(fw_cfg_dev_base); 112 release_region(fw_cfg_p_base, fw_cfg_p_size); 113 } 114 } 115 116 /* arch-specific ctrl & data register offsets are not available in ACPI, DT */ 117 #if !(defined(FW_CFG_CTRL_OFF) && defined(FW_CFG_DATA_OFF)) 118 # if (defined(CONFIG_ARM) || defined(CONFIG_ARM64)) 119 # define FW_CFG_CTRL_OFF 0x08 120 # define FW_CFG_DATA_OFF 0x00 121 # elif (defined(CONFIG_PPC_PMAC) || defined(CONFIG_SPARC32)) /* ppc/mac,sun4m */ 122 # define FW_CFG_CTRL_OFF 0x00 123 # define FW_CFG_DATA_OFF 0x02 124 # elif (defined(CONFIG_X86) || defined(CONFIG_SPARC64)) /* x86, sun4u */ 125 # define FW_CFG_CTRL_OFF 0x00 126 # define FW_CFG_DATA_OFF 0x01 127 # else 128 # error "QEMU FW_CFG not available on this architecture!" 129 # endif 130 #endif 131 132 /* initialize fw_cfg device i/o from platform data */ 133 static int fw_cfg_do_platform_probe(struct platform_device *pdev) 134 { 135 char sig[FW_CFG_SIG_SIZE]; 136 struct resource *range, *ctrl, *data; 137 138 /* acquire i/o range details */ 139 fw_cfg_is_mmio = false; 140 range = platform_get_resource(pdev, IORESOURCE_IO, 0); 141 if (!range) { 142 fw_cfg_is_mmio = true; 143 range = platform_get_resource(pdev, IORESOURCE_MEM, 0); 144 if (!range) 145 return -EINVAL; 146 } 147 fw_cfg_p_base = range->start; 148 fw_cfg_p_size = resource_size(range); 149 150 if (fw_cfg_is_mmio) { 151 if (!request_mem_region(fw_cfg_p_base, 152 fw_cfg_p_size, "fw_cfg_mem")) 153 return -EBUSY; 154 fw_cfg_dev_base = ioremap(fw_cfg_p_base, fw_cfg_p_size); 155 if (!fw_cfg_dev_base) { 156 release_mem_region(fw_cfg_p_base, fw_cfg_p_size); 157 return -EFAULT; 158 } 159 } else { 160 if (!request_region(fw_cfg_p_base, 161 fw_cfg_p_size, "fw_cfg_io")) 162 return -EBUSY; 163 fw_cfg_dev_base = ioport_map(fw_cfg_p_base, fw_cfg_p_size); 164 if (!fw_cfg_dev_base) { 165 release_region(fw_cfg_p_base, fw_cfg_p_size); 166 return -EFAULT; 167 } 168 } 169 170 /* were custom register offsets provided (e.g. on the command line)? */ 171 ctrl = platform_get_resource_byname(pdev, IORESOURCE_REG, "ctrl"); 172 data = platform_get_resource_byname(pdev, IORESOURCE_REG, "data"); 173 if (ctrl && data) { 174 fw_cfg_reg_ctrl = fw_cfg_dev_base + ctrl->start; 175 fw_cfg_reg_data = fw_cfg_dev_base + data->start; 176 } else { 177 /* use architecture-specific offsets */ 178 fw_cfg_reg_ctrl = fw_cfg_dev_base + FW_CFG_CTRL_OFF; 179 fw_cfg_reg_data = fw_cfg_dev_base + FW_CFG_DATA_OFF; 180 } 181 182 /* verify fw_cfg device signature */ 183 fw_cfg_read_blob(FW_CFG_SIGNATURE, sig, 0, FW_CFG_SIG_SIZE); 184 if (memcmp(sig, "QEMU", FW_CFG_SIG_SIZE) != 0) { 185 fw_cfg_io_cleanup(); 186 return -ENODEV; 187 } 188 189 return 0; 190 } 191 192 /* fw_cfg revision attribute, in /sys/firmware/qemu_fw_cfg top-level dir. */ 193 static u32 fw_cfg_rev; 194 195 static ssize_t fw_cfg_showrev(struct kobject *k, struct attribute *a, char *buf) 196 { 197 return sprintf(buf, "%u\n", fw_cfg_rev); 198 } 199 200 static const struct { 201 struct attribute attr; 202 ssize_t (*show)(struct kobject *k, struct attribute *a, char *buf); 203 } fw_cfg_rev_attr = { 204 .attr = { .name = "rev", .mode = S_IRUSR }, 205 .show = fw_cfg_showrev, 206 }; 207 208 /* fw_cfg_sysfs_entry type */ 209 struct fw_cfg_sysfs_entry { 210 struct kobject kobj; 211 struct fw_cfg_file f; 212 struct list_head list; 213 }; 214 215 /* get fw_cfg_sysfs_entry from kobject member */ 216 static inline struct fw_cfg_sysfs_entry *to_entry(struct kobject *kobj) 217 { 218 return container_of(kobj, struct fw_cfg_sysfs_entry, kobj); 219 } 220 221 /* fw_cfg_sysfs_attribute type */ 222 struct fw_cfg_sysfs_attribute { 223 struct attribute attr; 224 ssize_t (*show)(struct fw_cfg_sysfs_entry *entry, char *buf); 225 }; 226 227 /* get fw_cfg_sysfs_attribute from attribute member */ 228 static inline struct fw_cfg_sysfs_attribute *to_attr(struct attribute *attr) 229 { 230 return container_of(attr, struct fw_cfg_sysfs_attribute, attr); 231 } 232 233 /* global cache of fw_cfg_sysfs_entry objects */ 234 static LIST_HEAD(fw_cfg_entry_cache); 235 236 /* kobjects removed lazily by kernel, mutual exclusion needed */ 237 static DEFINE_SPINLOCK(fw_cfg_cache_lock); 238 239 static inline void fw_cfg_sysfs_cache_enlist(struct fw_cfg_sysfs_entry *entry) 240 { 241 spin_lock(&fw_cfg_cache_lock); 242 list_add_tail(&entry->list, &fw_cfg_entry_cache); 243 spin_unlock(&fw_cfg_cache_lock); 244 } 245 246 static inline void fw_cfg_sysfs_cache_delist(struct fw_cfg_sysfs_entry *entry) 247 { 248 spin_lock(&fw_cfg_cache_lock); 249 list_del(&entry->list); 250 spin_unlock(&fw_cfg_cache_lock); 251 } 252 253 static void fw_cfg_sysfs_cache_cleanup(void) 254 { 255 struct fw_cfg_sysfs_entry *entry, *next; 256 257 list_for_each_entry_safe(entry, next, &fw_cfg_entry_cache, list) { 258 /* will end up invoking fw_cfg_sysfs_cache_delist() 259 * via each object's release() method (i.e. destructor) 260 */ 261 kobject_put(&entry->kobj); 262 } 263 } 264 265 /* default_attrs: per-entry attributes and show methods */ 266 267 #define FW_CFG_SYSFS_ATTR(_attr) \ 268 struct fw_cfg_sysfs_attribute fw_cfg_sysfs_attr_##_attr = { \ 269 .attr = { .name = __stringify(_attr), .mode = S_IRUSR }, \ 270 .show = fw_cfg_sysfs_show_##_attr, \ 271 } 272 273 static ssize_t fw_cfg_sysfs_show_size(struct fw_cfg_sysfs_entry *e, char *buf) 274 { 275 return sprintf(buf, "%u\n", e->f.size); 276 } 277 278 static ssize_t fw_cfg_sysfs_show_key(struct fw_cfg_sysfs_entry *e, char *buf) 279 { 280 return sprintf(buf, "%u\n", e->f.select); 281 } 282 283 static ssize_t fw_cfg_sysfs_show_name(struct fw_cfg_sysfs_entry *e, char *buf) 284 { 285 return sprintf(buf, "%s\n", e->f.name); 286 } 287 288 static FW_CFG_SYSFS_ATTR(size); 289 static FW_CFG_SYSFS_ATTR(key); 290 static FW_CFG_SYSFS_ATTR(name); 291 292 static struct attribute *fw_cfg_sysfs_entry_attrs[] = { 293 &fw_cfg_sysfs_attr_size.attr, 294 &fw_cfg_sysfs_attr_key.attr, 295 &fw_cfg_sysfs_attr_name.attr, 296 NULL, 297 }; 298 299 /* sysfs_ops: find fw_cfg_[entry, attribute] and call appropriate show method */ 300 static ssize_t fw_cfg_sysfs_attr_show(struct kobject *kobj, struct attribute *a, 301 char *buf) 302 { 303 struct fw_cfg_sysfs_entry *entry = to_entry(kobj); 304 struct fw_cfg_sysfs_attribute *attr = to_attr(a); 305 306 return attr->show(entry, buf); 307 } 308 309 static const struct sysfs_ops fw_cfg_sysfs_attr_ops = { 310 .show = fw_cfg_sysfs_attr_show, 311 }; 312 313 /* release: destructor, to be called via kobject_put() */ 314 static void fw_cfg_sysfs_release_entry(struct kobject *kobj) 315 { 316 struct fw_cfg_sysfs_entry *entry = to_entry(kobj); 317 318 fw_cfg_sysfs_cache_delist(entry); 319 kfree(entry); 320 } 321 322 /* kobj_type: ties together all properties required to register an entry */ 323 static struct kobj_type fw_cfg_sysfs_entry_ktype = { 324 .default_attrs = fw_cfg_sysfs_entry_attrs, 325 .sysfs_ops = &fw_cfg_sysfs_attr_ops, 326 .release = fw_cfg_sysfs_release_entry, 327 }; 328 329 /* raw-read method and attribute */ 330 static ssize_t fw_cfg_sysfs_read_raw(struct file *filp, struct kobject *kobj, 331 struct bin_attribute *bin_attr, 332 char *buf, loff_t pos, size_t count) 333 { 334 struct fw_cfg_sysfs_entry *entry = to_entry(kobj); 335 336 if (pos > entry->f.size) 337 return -EINVAL; 338 339 if (count > entry->f.size - pos) 340 count = entry->f.size - pos; 341 342 fw_cfg_read_blob(entry->f.select, buf, pos, count); 343 return count; 344 } 345 346 static struct bin_attribute fw_cfg_sysfs_attr_raw = { 347 .attr = { .name = "raw", .mode = S_IRUSR }, 348 .read = fw_cfg_sysfs_read_raw, 349 }; 350 351 /* 352 * Create a kset subdirectory matching each '/' delimited dirname token 353 * in 'name', starting with sysfs kset/folder 'dir'; At the end, create 354 * a symlink directed at the given 'target'. 355 * NOTE: We do this on a best-effort basis, since 'name' is not guaranteed 356 * to be a well-behaved path name. Whenever a symlink vs. kset directory 357 * name collision occurs, the kernel will issue big scary warnings while 358 * refusing to add the offending link or directory. We follow up with our 359 * own, slightly less scary error messages explaining the situation :) 360 */ 361 static int fw_cfg_build_symlink(struct kset *dir, 362 struct kobject *target, const char *name) 363 { 364 int ret; 365 struct kset *subdir; 366 struct kobject *ko; 367 char *name_copy, *p, *tok; 368 369 if (!dir || !target || !name || !*name) 370 return -EINVAL; 371 372 /* clone a copy of name for parsing */ 373 name_copy = p = kstrdup(name, GFP_KERNEL); 374 if (!name_copy) 375 return -ENOMEM; 376 377 /* create folders for each dirname token, then symlink for basename */ 378 while ((tok = strsep(&p, "/")) && *tok) { 379 380 /* last (basename) token? If so, add symlink here */ 381 if (!p || !*p) { 382 ret = sysfs_create_link(&dir->kobj, target, tok); 383 break; 384 } 385 386 /* does the current dir contain an item named after tok ? */ 387 ko = kset_find_obj(dir, tok); 388 if (ko) { 389 /* drop reference added by kset_find_obj */ 390 kobject_put(ko); 391 392 /* ko MUST be a kset - we're about to use it as one ! */ 393 if (ko->ktype != dir->kobj.ktype) { 394 ret = -EINVAL; 395 break; 396 } 397 398 /* descend into already existing subdirectory */ 399 dir = to_kset(ko); 400 } else { 401 /* create new subdirectory kset */ 402 subdir = kzalloc(sizeof(struct kset), GFP_KERNEL); 403 if (!subdir) { 404 ret = -ENOMEM; 405 break; 406 } 407 subdir->kobj.kset = dir; 408 subdir->kobj.ktype = dir->kobj.ktype; 409 ret = kobject_set_name(&subdir->kobj, "%s", tok); 410 if (ret) { 411 kfree(subdir); 412 break; 413 } 414 ret = kset_register(subdir); 415 if (ret) { 416 kfree(subdir); 417 break; 418 } 419 420 /* descend into newly created subdirectory */ 421 dir = subdir; 422 } 423 } 424 425 /* we're done with cloned copy of name */ 426 kfree(name_copy); 427 return ret; 428 } 429 430 /* recursively unregister fw_cfg/by_name/ kset directory tree */ 431 static void fw_cfg_kset_unregister_recursive(struct kset *kset) 432 { 433 struct kobject *k, *next; 434 435 list_for_each_entry_safe(k, next, &kset->list, entry) 436 /* all set members are ksets too, but check just in case... */ 437 if (k->ktype == kset->kobj.ktype) 438 fw_cfg_kset_unregister_recursive(to_kset(k)); 439 440 /* symlinks are cleanly and automatically removed with the directory */ 441 kset_unregister(kset); 442 } 443 444 /* kobjects & kset representing top-level, by_key, and by_name folders */ 445 static struct kobject *fw_cfg_top_ko; 446 static struct kobject *fw_cfg_sel_ko; 447 static struct kset *fw_cfg_fname_kset; 448 449 /* register an individual fw_cfg file */ 450 static int fw_cfg_register_file(const struct fw_cfg_file *f) 451 { 452 int err; 453 struct fw_cfg_sysfs_entry *entry; 454 455 /* allocate new entry */ 456 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 457 if (!entry) 458 return -ENOMEM; 459 460 /* set file entry information */ 461 memcpy(&entry->f, f, sizeof(struct fw_cfg_file)); 462 463 /* register entry under "/sys/firmware/qemu_fw_cfg/by_key/" */ 464 err = kobject_init_and_add(&entry->kobj, &fw_cfg_sysfs_entry_ktype, 465 fw_cfg_sel_ko, "%d", entry->f.select); 466 if (err) 467 goto err_register; 468 469 /* add raw binary content access */ 470 err = sysfs_create_bin_file(&entry->kobj, &fw_cfg_sysfs_attr_raw); 471 if (err) 472 goto err_add_raw; 473 474 /* try adding "/sys/firmware/qemu_fw_cfg/by_name/" symlink */ 475 fw_cfg_build_symlink(fw_cfg_fname_kset, &entry->kobj, entry->f.name); 476 477 /* success, add entry to global cache */ 478 fw_cfg_sysfs_cache_enlist(entry); 479 return 0; 480 481 err_add_raw: 482 kobject_del(&entry->kobj); 483 err_register: 484 kfree(entry); 485 return err; 486 } 487 488 /* iterate over all fw_cfg directory entries, registering each one */ 489 static int fw_cfg_register_dir_entries(void) 490 { 491 int ret = 0; 492 u32 count, i; 493 struct fw_cfg_file *dir; 494 size_t dir_size; 495 496 fw_cfg_read_blob(FW_CFG_FILE_DIR, &count, 0, sizeof(count)); 497 count = be32_to_cpu(count); 498 dir_size = count * sizeof(struct fw_cfg_file); 499 500 dir = kmalloc(dir_size, GFP_KERNEL); 501 if (!dir) 502 return -ENOMEM; 503 504 fw_cfg_read_blob(FW_CFG_FILE_DIR, dir, sizeof(count), dir_size); 505 506 for (i = 0; i < count; i++) { 507 dir[i].size = be32_to_cpu(dir[i].size); 508 dir[i].select = be16_to_cpu(dir[i].select); 509 ret = fw_cfg_register_file(&dir[i]); 510 if (ret) 511 break; 512 } 513 514 kfree(dir); 515 return ret; 516 } 517 518 /* unregister top-level or by_key folder */ 519 static inline void fw_cfg_kobj_cleanup(struct kobject *kobj) 520 { 521 kobject_del(kobj); 522 kobject_put(kobj); 523 } 524 525 static int fw_cfg_sysfs_probe(struct platform_device *pdev) 526 { 527 int err; 528 529 /* NOTE: If we supported multiple fw_cfg devices, we'd first create 530 * a subdirectory named after e.g. pdev->id, then hang per-device 531 * by_key (and by_name) subdirectories underneath it. However, only 532 * one fw_cfg device exist system-wide, so if one was already found 533 * earlier, we might as well stop here. 534 */ 535 if (fw_cfg_sel_ko) 536 return -EBUSY; 537 538 /* create by_key and by_name subdirs of /sys/firmware/qemu_fw_cfg/ */ 539 err = -ENOMEM; 540 fw_cfg_sel_ko = kobject_create_and_add("by_key", fw_cfg_top_ko); 541 if (!fw_cfg_sel_ko) 542 goto err_sel; 543 fw_cfg_fname_kset = kset_create_and_add("by_name", NULL, fw_cfg_top_ko); 544 if (!fw_cfg_fname_kset) 545 goto err_name; 546 547 /* initialize fw_cfg device i/o from platform data */ 548 err = fw_cfg_do_platform_probe(pdev); 549 if (err) 550 goto err_probe; 551 552 /* get revision number, add matching top-level attribute */ 553 fw_cfg_read_blob(FW_CFG_ID, &fw_cfg_rev, 0, sizeof(fw_cfg_rev)); 554 fw_cfg_rev = le32_to_cpu(fw_cfg_rev); 555 err = sysfs_create_file(fw_cfg_top_ko, &fw_cfg_rev_attr.attr); 556 if (err) 557 goto err_rev; 558 559 /* process fw_cfg file directory entry, registering each file */ 560 err = fw_cfg_register_dir_entries(); 561 if (err) 562 goto err_dir; 563 564 /* success */ 565 pr_debug("fw_cfg: loaded.\n"); 566 return 0; 567 568 err_dir: 569 fw_cfg_sysfs_cache_cleanup(); 570 sysfs_remove_file(fw_cfg_top_ko, &fw_cfg_rev_attr.attr); 571 err_rev: 572 fw_cfg_io_cleanup(); 573 err_probe: 574 fw_cfg_kset_unregister_recursive(fw_cfg_fname_kset); 575 err_name: 576 fw_cfg_kobj_cleanup(fw_cfg_sel_ko); 577 err_sel: 578 return err; 579 } 580 581 static int fw_cfg_sysfs_remove(struct platform_device *pdev) 582 { 583 pr_debug("fw_cfg: unloading.\n"); 584 fw_cfg_sysfs_cache_cleanup(); 585 fw_cfg_kset_unregister_recursive(fw_cfg_fname_kset); 586 fw_cfg_kobj_cleanup(fw_cfg_sel_ko); 587 fw_cfg_io_cleanup(); 588 return 0; 589 } 590 591 static const struct of_device_id fw_cfg_sysfs_mmio_match[] = { 592 { .compatible = "qemu,fw-cfg-mmio", }, 593 {}, 594 }; 595 MODULE_DEVICE_TABLE(of, fw_cfg_sysfs_mmio_match); 596 597 #ifdef CONFIG_ACPI 598 static const struct acpi_device_id fw_cfg_sysfs_acpi_match[] = { 599 { "QEMU0002", }, 600 {}, 601 }; 602 MODULE_DEVICE_TABLE(acpi, fw_cfg_sysfs_acpi_match); 603 #endif 604 605 static struct platform_driver fw_cfg_sysfs_driver = { 606 .probe = fw_cfg_sysfs_probe, 607 .remove = fw_cfg_sysfs_remove, 608 .driver = { 609 .name = "fw_cfg", 610 .of_match_table = fw_cfg_sysfs_mmio_match, 611 .acpi_match_table = ACPI_PTR(fw_cfg_sysfs_acpi_match), 612 }, 613 }; 614 615 #ifdef CONFIG_FW_CFG_SYSFS_CMDLINE 616 617 static struct platform_device *fw_cfg_cmdline_dev; 618 619 /* this probably belongs in e.g. include/linux/types.h, 620 * but right now we are the only ones doing it... 621 */ 622 #ifdef CONFIG_PHYS_ADDR_T_64BIT 623 #define __PHYS_ADDR_PREFIX "ll" 624 #else 625 #define __PHYS_ADDR_PREFIX "" 626 #endif 627 628 /* use special scanf/printf modifier for phys_addr_t, resource_size_t */ 629 #define PH_ADDR_SCAN_FMT "@%" __PHYS_ADDR_PREFIX "i%n" \ 630 ":%" __PHYS_ADDR_PREFIX "i" \ 631 ":%" __PHYS_ADDR_PREFIX "i%n" 632 633 #define PH_ADDR_PR_1_FMT "0x%" __PHYS_ADDR_PREFIX "x@" \ 634 "0x%" __PHYS_ADDR_PREFIX "x" 635 636 #define PH_ADDR_PR_3_FMT PH_ADDR_PR_1_FMT \ 637 ":%" __PHYS_ADDR_PREFIX "u" \ 638 ":%" __PHYS_ADDR_PREFIX "u" 639 640 static int fw_cfg_cmdline_set(const char *arg, const struct kernel_param *kp) 641 { 642 struct resource res[3] = {}; 643 char *str; 644 phys_addr_t base; 645 resource_size_t size, ctrl_off, data_off; 646 int processed, consumed = 0; 647 648 /* only one fw_cfg device can exist system-wide, so if one 649 * was processed on the command line already, we might as 650 * well stop here. 651 */ 652 if (fw_cfg_cmdline_dev) { 653 /* avoid leaking previously registered device */ 654 platform_device_unregister(fw_cfg_cmdline_dev); 655 return -EINVAL; 656 } 657 658 /* consume "<size>" portion of command line argument */ 659 size = memparse(arg, &str); 660 661 /* get "@<base>[:<ctrl_off>:<data_off>]" chunks */ 662 processed = sscanf(str, PH_ADDR_SCAN_FMT, 663 &base, &consumed, 664 &ctrl_off, &data_off, &consumed); 665 666 /* sscanf() must process precisely 1 or 3 chunks: 667 * <base> is mandatory, optionally followed by <ctrl_off> 668 * and <data_off>; 669 * there must be no extra characters after the last chunk, 670 * so str[consumed] must be '\0'. 671 */ 672 if (str[consumed] || 673 (processed != 1 && processed != 3)) 674 return -EINVAL; 675 676 res[0].start = base; 677 res[0].end = base + size - 1; 678 res[0].flags = !strcmp(kp->name, "mmio") ? IORESOURCE_MEM : 679 IORESOURCE_IO; 680 681 /* insert register offsets, if provided */ 682 if (processed > 1) { 683 res[1].name = "ctrl"; 684 res[1].start = ctrl_off; 685 res[1].flags = IORESOURCE_REG; 686 res[2].name = "data"; 687 res[2].start = data_off; 688 res[2].flags = IORESOURCE_REG; 689 } 690 691 /* "processed" happens to nicely match the number of resources 692 * we need to pass in to this platform device. 693 */ 694 fw_cfg_cmdline_dev = platform_device_register_simple("fw_cfg", 695 PLATFORM_DEVID_NONE, res, processed); 696 if (IS_ERR(fw_cfg_cmdline_dev)) 697 return PTR_ERR(fw_cfg_cmdline_dev); 698 699 return 0; 700 } 701 702 static int fw_cfg_cmdline_get(char *buf, const struct kernel_param *kp) 703 { 704 /* stay silent if device was not configured via the command 705 * line, or if the parameter name (ioport/mmio) doesn't match 706 * the device setting 707 */ 708 if (!fw_cfg_cmdline_dev || 709 (!strcmp(kp->name, "mmio") ^ 710 (fw_cfg_cmdline_dev->resource[0].flags == IORESOURCE_MEM))) 711 return 0; 712 713 switch (fw_cfg_cmdline_dev->num_resources) { 714 case 1: 715 return snprintf(buf, PAGE_SIZE, PH_ADDR_PR_1_FMT, 716 resource_size(&fw_cfg_cmdline_dev->resource[0]), 717 fw_cfg_cmdline_dev->resource[0].start); 718 case 3: 719 return snprintf(buf, PAGE_SIZE, PH_ADDR_PR_3_FMT, 720 resource_size(&fw_cfg_cmdline_dev->resource[0]), 721 fw_cfg_cmdline_dev->resource[0].start, 722 fw_cfg_cmdline_dev->resource[1].start, 723 fw_cfg_cmdline_dev->resource[2].start); 724 } 725 726 /* Should never get here */ 727 WARN(1, "Unexpected number of resources: %d\n", 728 fw_cfg_cmdline_dev->num_resources); 729 return 0; 730 } 731 732 static const struct kernel_param_ops fw_cfg_cmdline_param_ops = { 733 .set = fw_cfg_cmdline_set, 734 .get = fw_cfg_cmdline_get, 735 }; 736 737 device_param_cb(ioport, &fw_cfg_cmdline_param_ops, NULL, S_IRUSR); 738 device_param_cb(mmio, &fw_cfg_cmdline_param_ops, NULL, S_IRUSR); 739 740 #endif /* CONFIG_FW_CFG_SYSFS_CMDLINE */ 741 742 static int __init fw_cfg_sysfs_init(void) 743 { 744 int ret; 745 746 /* create /sys/firmware/qemu_fw_cfg/ top level directory */ 747 fw_cfg_top_ko = kobject_create_and_add("qemu_fw_cfg", firmware_kobj); 748 if (!fw_cfg_top_ko) 749 return -ENOMEM; 750 751 ret = platform_driver_register(&fw_cfg_sysfs_driver); 752 if (ret) 753 fw_cfg_kobj_cleanup(fw_cfg_top_ko); 754 755 return ret; 756 } 757 758 static void __exit fw_cfg_sysfs_exit(void) 759 { 760 platform_driver_unregister(&fw_cfg_sysfs_driver); 761 762 #ifdef CONFIG_FW_CFG_SYSFS_CMDLINE 763 platform_device_unregister(fw_cfg_cmdline_dev); 764 #endif 765 766 /* clean up /sys/firmware/qemu_fw_cfg/ */ 767 fw_cfg_kobj_cleanup(fw_cfg_top_ko); 768 } 769 770 module_init(fw_cfg_sysfs_init); 771 module_exit(fw_cfg_sysfs_exit); 772