2 * drivers/firmware/qemu_fw_cfg.c
4 * Copyright 2015 Carnegie Mellon University
6 * Expose entries from QEMU's firmware configuration (fw_cfg) device in
7 * sysfs (read-only, under "/sys/firmware/qemu_fw_cfg/...").
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:
13 * [qemu_fw_cfg.]ioport=<size>@<base>[:<ctrl_off>:<data_off>[:<dma_off>]]
15 * [qemu_fw_cfg.]mmio=<size>@<base>[:<ctrl_off>:<data_off>[:<dma_off>]]
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 * <dma_off> := (optional) offset of dma register
25 * qemu_fw_cfg.ioport=12@0x510:0:1:4 (the default on x86)
27 * qemu_fw_cfg.mmio=16@0x9020000:8:0:16 (the default on arm)
30 #include <linux/module.h>
31 #include <linux/mod_devicetable.h>
32 #include <linux/platform_device.h>
33 #include <linux/acpi.h>
34 #include <linux/slab.h>
36 #include <linux/ioport.h>
37 #include <uapi/linux/qemu_fw_cfg.h>
38 #include <linux/delay.h>
39 #include <linux/crash_dump.h>
40 #include <linux/crash_core.h>
42 MODULE_AUTHOR("Gabriel L. Somlo <somlo@cmu.edu>");
43 MODULE_DESCRIPTION("QEMU fw_cfg sysfs support");
44 MODULE_LICENSE("GPL");
46 /* fw_cfg revision attribute, in /sys/firmware/qemu_fw_cfg top-level dir. */
47 static u32 fw_cfg_rev
;
49 /* fw_cfg device i/o register addresses */
50 static bool fw_cfg_is_mmio
;
51 static phys_addr_t fw_cfg_p_base
;
52 static resource_size_t fw_cfg_p_size
;
53 static void __iomem
*fw_cfg_dev_base
;
54 static void __iomem
*fw_cfg_reg_ctrl
;
55 static void __iomem
*fw_cfg_reg_data
;
56 static void __iomem
*fw_cfg_reg_dma
;
58 /* atomic access to fw_cfg device (potentially slow i/o, so using mutex) */
59 static DEFINE_MUTEX(fw_cfg_dev_lock
);
61 /* pick appropriate endianness for selector key */
62 static void fw_cfg_sel_endianness(u16 key
)
65 iowrite16be(key
, fw_cfg_reg_ctrl
);
67 iowrite16(key
, fw_cfg_reg_ctrl
);
70 #ifdef CONFIG_CRASH_CORE
71 static inline bool fw_cfg_dma_enabled(void)
73 return (fw_cfg_rev
& FW_CFG_VERSION_DMA
) && fw_cfg_reg_dma
;
76 /* qemu fw_cfg device is sync today, but spec says it may become async */
77 static void fw_cfg_wait_for_control(struct fw_cfg_dma_access
*d
)
80 u32 ctrl
= be32_to_cpu(READ_ONCE(d
->control
));
82 /* do not reorder the read to d->control */
84 if ((ctrl
& ~FW_CFG_DMA_CTL_ERROR
) == 0)
91 static ssize_t
fw_cfg_dma_transfer(void *address
, u32 length
, u32 control
)
94 struct fw_cfg_dma_access
*d
= NULL
;
97 d
= kmalloc(sizeof(*d
), GFP_KERNEL
);
103 /* fw_cfg device does not need IOMMU protection, so use physical addresses */
104 *d
= (struct fw_cfg_dma_access
) {
105 .address
= cpu_to_be64(address
? virt_to_phys(address
) : 0),
106 .length
= cpu_to_be32(length
),
107 .control
= cpu_to_be32(control
)
110 dma
= virt_to_phys(d
);
112 iowrite32be((u64
)dma
>> 32, fw_cfg_reg_dma
);
113 /* force memory to sync before notifying device via MMIO */
115 iowrite32be(dma
, fw_cfg_reg_dma
+ 4);
117 fw_cfg_wait_for_control(d
);
119 if (be32_to_cpu(READ_ONCE(d
->control
)) & FW_CFG_DMA_CTL_ERROR
) {
130 /* read chunk of given fw_cfg blob (caller responsible for sanity-check) */
131 static ssize_t
fw_cfg_read_blob(u16 key
,
132 void *buf
, loff_t pos
, size_t count
)
137 /* If we have ACPI, ensure mutual exclusion against any potential
138 * device access by the firmware, e.g. via AML methods:
140 status
= acpi_acquire_global_lock(ACPI_WAIT_FOREVER
, &glk
);
141 if (ACPI_FAILURE(status
) && status
!= AE_NOT_CONFIGURED
) {
142 /* Should never get here */
143 WARN(1, "fw_cfg_read_blob: Failed to lock ACPI!\n");
144 memset(buf
, 0, count
);
148 mutex_lock(&fw_cfg_dev_lock
);
149 fw_cfg_sel_endianness(key
);
151 ioread8(fw_cfg_reg_data
);
152 ioread8_rep(fw_cfg_reg_data
, buf
, count
);
153 mutex_unlock(&fw_cfg_dev_lock
);
155 acpi_release_global_lock(glk
);
159 #ifdef CONFIG_CRASH_CORE
160 /* write chunk of given fw_cfg blob (caller responsible for sanity-check) */
161 static ssize_t
fw_cfg_write_blob(u16 key
,
162 void *buf
, loff_t pos
, size_t count
)
168 /* If we have ACPI, ensure mutual exclusion against any potential
169 * device access by the firmware, e.g. via AML methods:
171 status
= acpi_acquire_global_lock(ACPI_WAIT_FOREVER
, &glk
);
172 if (ACPI_FAILURE(status
) && status
!= AE_NOT_CONFIGURED
) {
173 /* Should never get here */
174 WARN(1, "%s: Failed to lock ACPI!\n", __func__
);
178 mutex_lock(&fw_cfg_dev_lock
);
180 ret
= fw_cfg_dma_transfer(buf
, count
, key
<< 16
181 | FW_CFG_DMA_CTL_SELECT
182 | FW_CFG_DMA_CTL_WRITE
);
184 fw_cfg_sel_endianness(key
);
185 ret
= fw_cfg_dma_transfer(NULL
, pos
, FW_CFG_DMA_CTL_SKIP
);
188 ret
= fw_cfg_dma_transfer(buf
, count
, FW_CFG_DMA_CTL_WRITE
);
192 mutex_unlock(&fw_cfg_dev_lock
);
194 acpi_release_global_lock(glk
);
198 #endif /* CONFIG_CRASH_CORE */
200 /* clean up fw_cfg device i/o */
201 static void fw_cfg_io_cleanup(void)
203 if (fw_cfg_is_mmio
) {
204 iounmap(fw_cfg_dev_base
);
205 release_mem_region(fw_cfg_p_base
, fw_cfg_p_size
);
207 ioport_unmap(fw_cfg_dev_base
);
208 release_region(fw_cfg_p_base
, fw_cfg_p_size
);
212 /* arch-specific ctrl & data register offsets are not available in ACPI, DT */
213 #if !(defined(FW_CFG_CTRL_OFF) && defined(FW_CFG_DATA_OFF))
214 # if (defined(CONFIG_ARM) || defined(CONFIG_ARM64))
215 # define FW_CFG_CTRL_OFF 0x08
216 # define FW_CFG_DATA_OFF 0x00
217 # define FW_CFG_DMA_OFF 0x10
218 # elif defined(CONFIG_PARISC) /* parisc */
219 # define FW_CFG_CTRL_OFF 0x00
220 # define FW_CFG_DATA_OFF 0x04
221 # elif (defined(CONFIG_PPC_PMAC) || defined(CONFIG_SPARC32)) /* ppc/mac,sun4m */
222 # define FW_CFG_CTRL_OFF 0x00
223 # define FW_CFG_DATA_OFF 0x02
224 # elif (defined(CONFIG_X86) || defined(CONFIG_SPARC64)) /* x86, sun4u */
225 # define FW_CFG_CTRL_OFF 0x00
226 # define FW_CFG_DATA_OFF 0x01
227 # define FW_CFG_DMA_OFF 0x04
229 # error "QEMU FW_CFG not available on this architecture!"
233 /* initialize fw_cfg device i/o from platform data */
234 static int fw_cfg_do_platform_probe(struct platform_device
*pdev
)
236 char sig
[FW_CFG_SIG_SIZE
];
237 struct resource
*range
, *ctrl
, *data
, *dma
;
239 /* acquire i/o range details */
240 fw_cfg_is_mmio
= false;
241 range
= platform_get_resource(pdev
, IORESOURCE_IO
, 0);
243 fw_cfg_is_mmio
= true;
244 range
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
248 fw_cfg_p_base
= range
->start
;
249 fw_cfg_p_size
= resource_size(range
);
251 if (fw_cfg_is_mmio
) {
252 if (!request_mem_region(fw_cfg_p_base
,
253 fw_cfg_p_size
, "fw_cfg_mem"))
255 fw_cfg_dev_base
= ioremap(fw_cfg_p_base
, fw_cfg_p_size
);
256 if (!fw_cfg_dev_base
) {
257 release_mem_region(fw_cfg_p_base
, fw_cfg_p_size
);
261 if (!request_region(fw_cfg_p_base
,
262 fw_cfg_p_size
, "fw_cfg_io"))
264 fw_cfg_dev_base
= ioport_map(fw_cfg_p_base
, fw_cfg_p_size
);
265 if (!fw_cfg_dev_base
) {
266 release_region(fw_cfg_p_base
, fw_cfg_p_size
);
271 /* were custom register offsets provided (e.g. on the command line)? */
272 ctrl
= platform_get_resource_byname(pdev
, IORESOURCE_REG
, "ctrl");
273 data
= platform_get_resource_byname(pdev
, IORESOURCE_REG
, "data");
274 dma
= platform_get_resource_byname(pdev
, IORESOURCE_REG
, "dma");
276 fw_cfg_reg_ctrl
= fw_cfg_dev_base
+ ctrl
->start
;
277 fw_cfg_reg_data
= fw_cfg_dev_base
+ data
->start
;
279 /* use architecture-specific offsets */
280 fw_cfg_reg_ctrl
= fw_cfg_dev_base
+ FW_CFG_CTRL_OFF
;
281 fw_cfg_reg_data
= fw_cfg_dev_base
+ FW_CFG_DATA_OFF
;
285 fw_cfg_reg_dma
= fw_cfg_dev_base
+ dma
->start
;
286 #ifdef FW_CFG_DMA_OFF
288 fw_cfg_reg_dma
= fw_cfg_dev_base
+ FW_CFG_DMA_OFF
;
291 /* verify fw_cfg device signature */
292 if (fw_cfg_read_blob(FW_CFG_SIGNATURE
, sig
,
293 0, FW_CFG_SIG_SIZE
) < 0 ||
294 memcmp(sig
, "QEMU", FW_CFG_SIG_SIZE
) != 0) {
302 static ssize_t
fw_cfg_showrev(struct kobject
*k
, struct kobj_attribute
*a
,
305 return sprintf(buf
, "%u\n", fw_cfg_rev
);
308 static const struct kobj_attribute fw_cfg_rev_attr
= {
309 .attr
= { .name
= "rev", .mode
= S_IRUSR
},
310 .show
= fw_cfg_showrev
,
313 /* fw_cfg_sysfs_entry type */
314 struct fw_cfg_sysfs_entry
{
318 char name
[FW_CFG_MAX_FILE_PATH
];
319 struct list_head list
;
322 #ifdef CONFIG_CRASH_CORE
323 static ssize_t
fw_cfg_write_vmcoreinfo(const struct fw_cfg_file
*f
)
325 static struct fw_cfg_vmcoreinfo
*data
;
328 data
= kmalloc(sizeof(struct fw_cfg_vmcoreinfo
), GFP_KERNEL
);
332 *data
= (struct fw_cfg_vmcoreinfo
) {
333 .guest_format
= cpu_to_le16(FW_CFG_VMCOREINFO_FORMAT_ELF
),
334 .size
= cpu_to_le32(VMCOREINFO_NOTE_SIZE
),
335 .paddr
= cpu_to_le64(paddr_vmcoreinfo_note())
337 /* spare ourself reading host format support for now since we
338 * don't know what else to format - host may ignore ours
340 ret
= fw_cfg_write_blob(be16_to_cpu(f
->select
), data
,
341 0, sizeof(struct fw_cfg_vmcoreinfo
));
346 #endif /* CONFIG_CRASH_CORE */
348 /* get fw_cfg_sysfs_entry from kobject member */
349 static inline struct fw_cfg_sysfs_entry
*to_entry(struct kobject
*kobj
)
351 return container_of(kobj
, struct fw_cfg_sysfs_entry
, kobj
);
354 /* fw_cfg_sysfs_attribute type */
355 struct fw_cfg_sysfs_attribute
{
356 struct attribute attr
;
357 ssize_t (*show
)(struct fw_cfg_sysfs_entry
*entry
, char *buf
);
360 /* get fw_cfg_sysfs_attribute from attribute member */
361 static inline struct fw_cfg_sysfs_attribute
*to_attr(struct attribute
*attr
)
363 return container_of(attr
, struct fw_cfg_sysfs_attribute
, attr
);
366 /* global cache of fw_cfg_sysfs_entry objects */
367 static LIST_HEAD(fw_cfg_entry_cache
);
369 /* kobjects removed lazily by kernel, mutual exclusion needed */
370 static DEFINE_SPINLOCK(fw_cfg_cache_lock
);
372 static inline void fw_cfg_sysfs_cache_enlist(struct fw_cfg_sysfs_entry
*entry
)
374 spin_lock(&fw_cfg_cache_lock
);
375 list_add_tail(&entry
->list
, &fw_cfg_entry_cache
);
376 spin_unlock(&fw_cfg_cache_lock
);
379 static inline void fw_cfg_sysfs_cache_delist(struct fw_cfg_sysfs_entry
*entry
)
381 spin_lock(&fw_cfg_cache_lock
);
382 list_del(&entry
->list
);
383 spin_unlock(&fw_cfg_cache_lock
);
386 static void fw_cfg_sysfs_cache_cleanup(void)
388 struct fw_cfg_sysfs_entry
*entry
, *next
;
390 list_for_each_entry_safe(entry
, next
, &fw_cfg_entry_cache
, list
) {
391 /* will end up invoking fw_cfg_sysfs_cache_delist()
392 * via each object's release() method (i.e. destructor)
394 kobject_put(&entry
->kobj
);
398 /* default_attrs: per-entry attributes and show methods */
400 #define FW_CFG_SYSFS_ATTR(_attr) \
401 struct fw_cfg_sysfs_attribute fw_cfg_sysfs_attr_##_attr = { \
402 .attr = { .name = __stringify(_attr), .mode = S_IRUSR }, \
403 .show = fw_cfg_sysfs_show_##_attr, \
406 static ssize_t
fw_cfg_sysfs_show_size(struct fw_cfg_sysfs_entry
*e
, char *buf
)
408 return sprintf(buf
, "%u\n", e
->size
);
411 static ssize_t
fw_cfg_sysfs_show_key(struct fw_cfg_sysfs_entry
*e
, char *buf
)
413 return sprintf(buf
, "%u\n", e
->select
);
416 static ssize_t
fw_cfg_sysfs_show_name(struct fw_cfg_sysfs_entry
*e
, char *buf
)
418 return sprintf(buf
, "%s\n", e
->name
);
421 static FW_CFG_SYSFS_ATTR(size
);
422 static FW_CFG_SYSFS_ATTR(key
);
423 static FW_CFG_SYSFS_ATTR(name
);
425 static struct attribute
*fw_cfg_sysfs_entry_attrs
[] = {
426 &fw_cfg_sysfs_attr_size
.attr
,
427 &fw_cfg_sysfs_attr_key
.attr
,
428 &fw_cfg_sysfs_attr_name
.attr
,
432 /* sysfs_ops: find fw_cfg_[entry, attribute] and call appropriate show method */
433 static ssize_t
fw_cfg_sysfs_attr_show(struct kobject
*kobj
, struct attribute
*a
,
436 struct fw_cfg_sysfs_entry
*entry
= to_entry(kobj
);
437 struct fw_cfg_sysfs_attribute
*attr
= to_attr(a
);
439 return attr
->show(entry
, buf
);
442 static const struct sysfs_ops fw_cfg_sysfs_attr_ops
= {
443 .show
= fw_cfg_sysfs_attr_show
,
446 /* release: destructor, to be called via kobject_put() */
447 static void fw_cfg_sysfs_release_entry(struct kobject
*kobj
)
449 struct fw_cfg_sysfs_entry
*entry
= to_entry(kobj
);
451 fw_cfg_sysfs_cache_delist(entry
);
455 /* kobj_type: ties together all properties required to register an entry */
456 static struct kobj_type fw_cfg_sysfs_entry_ktype
= {
457 .default_attrs
= fw_cfg_sysfs_entry_attrs
,
458 .sysfs_ops
= &fw_cfg_sysfs_attr_ops
,
459 .release
= fw_cfg_sysfs_release_entry
,
462 /* raw-read method and attribute */
463 static ssize_t
fw_cfg_sysfs_read_raw(struct file
*filp
, struct kobject
*kobj
,
464 struct bin_attribute
*bin_attr
,
465 char *buf
, loff_t pos
, size_t count
)
467 struct fw_cfg_sysfs_entry
*entry
= to_entry(kobj
);
469 if (pos
> entry
->size
)
472 if (count
> entry
->size
- pos
)
473 count
= entry
->size
- pos
;
475 return fw_cfg_read_blob(entry
->select
, buf
, pos
, count
);
478 static struct bin_attribute fw_cfg_sysfs_attr_raw
= {
479 .attr
= { .name
= "raw", .mode
= S_IRUSR
},
480 .read
= fw_cfg_sysfs_read_raw
,
484 * Create a kset subdirectory matching each '/' delimited dirname token
485 * in 'name', starting with sysfs kset/folder 'dir'; At the end, create
486 * a symlink directed at the given 'target'.
487 * NOTE: We do this on a best-effort basis, since 'name' is not guaranteed
488 * to be a well-behaved path name. Whenever a symlink vs. kset directory
489 * name collision occurs, the kernel will issue big scary warnings while
490 * refusing to add the offending link or directory. We follow up with our
491 * own, slightly less scary error messages explaining the situation :)
493 static int fw_cfg_build_symlink(struct kset
*dir
,
494 struct kobject
*target
, const char *name
)
499 char *name_copy
, *p
, *tok
;
501 if (!dir
|| !target
|| !name
|| !*name
)
504 /* clone a copy of name for parsing */
505 name_copy
= p
= kstrdup(name
, GFP_KERNEL
);
509 /* create folders for each dirname token, then symlink for basename */
510 while ((tok
= strsep(&p
, "/")) && *tok
) {
512 /* last (basename) token? If so, add symlink here */
514 ret
= sysfs_create_link(&dir
->kobj
, target
, tok
);
518 /* does the current dir contain an item named after tok ? */
519 ko
= kset_find_obj(dir
, tok
);
521 /* drop reference added by kset_find_obj */
524 /* ko MUST be a kset - we're about to use it as one ! */
525 if (ko
->ktype
!= dir
->kobj
.ktype
) {
530 /* descend into already existing subdirectory */
533 /* create new subdirectory kset */
534 subdir
= kzalloc(sizeof(struct kset
), GFP_KERNEL
);
539 subdir
->kobj
.kset
= dir
;
540 subdir
->kobj
.ktype
= dir
->kobj
.ktype
;
541 ret
= kobject_set_name(&subdir
->kobj
, "%s", tok
);
546 ret
= kset_register(subdir
);
552 /* descend into newly created subdirectory */
557 /* we're done with cloned copy of name */
562 /* recursively unregister fw_cfg/by_name/ kset directory tree */
563 static void fw_cfg_kset_unregister_recursive(struct kset
*kset
)
565 struct kobject
*k
, *next
;
567 list_for_each_entry_safe(k
, next
, &kset
->list
, entry
)
568 /* all set members are ksets too, but check just in case... */
569 if (k
->ktype
== kset
->kobj
.ktype
)
570 fw_cfg_kset_unregister_recursive(to_kset(k
));
572 /* symlinks are cleanly and automatically removed with the directory */
573 kset_unregister(kset
);
576 /* kobjects & kset representing top-level, by_key, and by_name folders */
577 static struct kobject
*fw_cfg_top_ko
;
578 static struct kobject
*fw_cfg_sel_ko
;
579 static struct kset
*fw_cfg_fname_kset
;
581 /* register an individual fw_cfg file */
582 static int fw_cfg_register_file(const struct fw_cfg_file
*f
)
585 struct fw_cfg_sysfs_entry
*entry
;
587 #ifdef CONFIG_CRASH_CORE
588 if (fw_cfg_dma_enabled() &&
589 strcmp(f
->name
, FW_CFG_VMCOREINFO_FILENAME
) == 0 &&
590 !is_kdump_kernel()) {
591 if (fw_cfg_write_vmcoreinfo(f
) < 0)
592 pr_warn("fw_cfg: failed to write vmcoreinfo");
596 /* allocate new entry */
597 entry
= kzalloc(sizeof(*entry
), GFP_KERNEL
);
601 /* set file entry information */
602 entry
->size
= be32_to_cpu(f
->size
);
603 entry
->select
= be16_to_cpu(f
->select
);
604 memcpy(entry
->name
, f
->name
, FW_CFG_MAX_FILE_PATH
);
606 /* register entry under "/sys/firmware/qemu_fw_cfg/by_key/" */
607 err
= kobject_init_and_add(&entry
->kobj
, &fw_cfg_sysfs_entry_ktype
,
608 fw_cfg_sel_ko
, "%d", entry
->select
);
610 kobject_put(&entry
->kobj
);
614 /* add raw binary content access */
615 err
= sysfs_create_bin_file(&entry
->kobj
, &fw_cfg_sysfs_attr_raw
);
619 /* try adding "/sys/firmware/qemu_fw_cfg/by_name/" symlink */
620 fw_cfg_build_symlink(fw_cfg_fname_kset
, &entry
->kobj
, entry
->name
);
622 /* success, add entry to global cache */
623 fw_cfg_sysfs_cache_enlist(entry
);
627 kobject_del(&entry
->kobj
);
632 /* iterate over all fw_cfg directory entries, registering each one */
633 static int fw_cfg_register_dir_entries(void)
638 struct fw_cfg_file
*dir
;
641 ret
= fw_cfg_read_blob(FW_CFG_FILE_DIR
, &files_count
,
642 0, sizeof(files_count
));
646 count
= be32_to_cpu(files_count
);
647 dir_size
= count
* sizeof(struct fw_cfg_file
);
649 dir
= kmalloc(dir_size
, GFP_KERNEL
);
653 ret
= fw_cfg_read_blob(FW_CFG_FILE_DIR
, dir
,
654 sizeof(files_count
), dir_size
);
658 for (i
= 0; i
< count
; i
++) {
659 ret
= fw_cfg_register_file(&dir
[i
]);
669 /* unregister top-level or by_key folder */
670 static inline void fw_cfg_kobj_cleanup(struct kobject
*kobj
)
676 static int fw_cfg_sysfs_probe(struct platform_device
*pdev
)
681 /* NOTE: If we supported multiple fw_cfg devices, we'd first create
682 * a subdirectory named after e.g. pdev->id, then hang per-device
683 * by_key (and by_name) subdirectories underneath it. However, only
684 * one fw_cfg device exist system-wide, so if one was already found
685 * earlier, we might as well stop here.
690 /* create by_key and by_name subdirs of /sys/firmware/qemu_fw_cfg/ */
692 fw_cfg_sel_ko
= kobject_create_and_add("by_key", fw_cfg_top_ko
);
695 fw_cfg_fname_kset
= kset_create_and_add("by_name", NULL
, fw_cfg_top_ko
);
696 if (!fw_cfg_fname_kset
)
699 /* initialize fw_cfg device i/o from platform data */
700 err
= fw_cfg_do_platform_probe(pdev
);
704 /* get revision number, add matching top-level attribute */
705 err
= fw_cfg_read_blob(FW_CFG_ID
, &rev
, 0, sizeof(rev
));
709 fw_cfg_rev
= le32_to_cpu(rev
);
710 err
= sysfs_create_file(fw_cfg_top_ko
, &fw_cfg_rev_attr
.attr
);
714 /* process fw_cfg file directory entry, registering each file */
715 err
= fw_cfg_register_dir_entries();
720 pr_debug("fw_cfg: loaded.\n");
724 fw_cfg_sysfs_cache_cleanup();
725 sysfs_remove_file(fw_cfg_top_ko
, &fw_cfg_rev_attr
.attr
);
729 fw_cfg_kset_unregister_recursive(fw_cfg_fname_kset
);
731 fw_cfg_kobj_cleanup(fw_cfg_sel_ko
);
736 static int fw_cfg_sysfs_remove(struct platform_device
*pdev
)
738 pr_debug("fw_cfg: unloading.\n");
739 fw_cfg_sysfs_cache_cleanup();
740 sysfs_remove_file(fw_cfg_top_ko
, &fw_cfg_rev_attr
.attr
);
742 fw_cfg_kset_unregister_recursive(fw_cfg_fname_kset
);
743 fw_cfg_kobj_cleanup(fw_cfg_sel_ko
);
747 static const struct of_device_id fw_cfg_sysfs_mmio_match
[] = {
748 { .compatible
= "qemu,fw-cfg-mmio", },
751 MODULE_DEVICE_TABLE(of
, fw_cfg_sysfs_mmio_match
);
754 static const struct acpi_device_id fw_cfg_sysfs_acpi_match
[] = {
755 { FW_CFG_ACPI_DEVICE_ID
, },
758 MODULE_DEVICE_TABLE(acpi
, fw_cfg_sysfs_acpi_match
);
761 static struct platform_driver fw_cfg_sysfs_driver
= {
762 .probe
= fw_cfg_sysfs_probe
,
763 .remove
= fw_cfg_sysfs_remove
,
766 .of_match_table
= fw_cfg_sysfs_mmio_match
,
767 .acpi_match_table
= ACPI_PTR(fw_cfg_sysfs_acpi_match
),
771 #ifdef CONFIG_FW_CFG_SYSFS_CMDLINE
773 static struct platform_device
*fw_cfg_cmdline_dev
;
775 /* this probably belongs in e.g. include/linux/types.h,
776 * but right now we are the only ones doing it...
778 #ifdef CONFIG_PHYS_ADDR_T_64BIT
779 #define __PHYS_ADDR_PREFIX "ll"
781 #define __PHYS_ADDR_PREFIX ""
784 /* use special scanf/printf modifier for phys_addr_t, resource_size_t */
785 #define PH_ADDR_SCAN_FMT "@%" __PHYS_ADDR_PREFIX "i%n" \
786 ":%" __PHYS_ADDR_PREFIX "i" \
787 ":%" __PHYS_ADDR_PREFIX "i%n" \
788 ":%" __PHYS_ADDR_PREFIX "i%n"
790 #define PH_ADDR_PR_1_FMT "0x%" __PHYS_ADDR_PREFIX "x@" \
791 "0x%" __PHYS_ADDR_PREFIX "x"
793 #define PH_ADDR_PR_3_FMT PH_ADDR_PR_1_FMT \
794 ":%" __PHYS_ADDR_PREFIX "u" \
795 ":%" __PHYS_ADDR_PREFIX "u"
797 #define PH_ADDR_PR_4_FMT PH_ADDR_PR_3_FMT \
798 ":%" __PHYS_ADDR_PREFIX "u"
800 static int fw_cfg_cmdline_set(const char *arg
, const struct kernel_param
*kp
)
802 struct resource res
[4] = {};
805 resource_size_t size
, ctrl_off
, data_off
, dma_off
;
806 int processed
, consumed
= 0;
808 /* only one fw_cfg device can exist system-wide, so if one
809 * was processed on the command line already, we might as
812 if (fw_cfg_cmdline_dev
) {
813 /* avoid leaking previously registered device */
814 platform_device_unregister(fw_cfg_cmdline_dev
);
818 /* consume "<size>" portion of command line argument */
819 size
= memparse(arg
, &str
);
821 /* get "@<base>[:<ctrl_off>:<data_off>[:<dma_off>]]" chunks */
822 processed
= sscanf(str
, PH_ADDR_SCAN_FMT
,
824 &ctrl_off
, &data_off
, &consumed
,
825 &dma_off
, &consumed
);
827 /* sscanf() must process precisely 1, 3 or 4 chunks:
828 * <base> is mandatory, optionally followed by <ctrl_off>
829 * and <data_off>, and <dma_off>;
830 * there must be no extra characters after the last chunk,
831 * so str[consumed] must be '\0'.
834 (processed
!= 1 && processed
!= 3 && processed
!= 4))
838 res
[0].end
= base
+ size
- 1;
839 res
[0].flags
= !strcmp(kp
->name
, "mmio") ? IORESOURCE_MEM
:
842 /* insert register offsets, if provided */
844 res
[1].name
= "ctrl";
845 res
[1].start
= ctrl_off
;
846 res
[1].flags
= IORESOURCE_REG
;
847 res
[2].name
= "data";
848 res
[2].start
= data_off
;
849 res
[2].flags
= IORESOURCE_REG
;
853 res
[3].start
= dma_off
;
854 res
[3].flags
= IORESOURCE_REG
;
857 /* "processed" happens to nicely match the number of resources
858 * we need to pass in to this platform device.
860 fw_cfg_cmdline_dev
= platform_device_register_simple("fw_cfg",
861 PLATFORM_DEVID_NONE
, res
, processed
);
863 return PTR_ERR_OR_ZERO(fw_cfg_cmdline_dev
);
866 static int fw_cfg_cmdline_get(char *buf
, const struct kernel_param
*kp
)
868 /* stay silent if device was not configured via the command
869 * line, or if the parameter name (ioport/mmio) doesn't match
872 if (!fw_cfg_cmdline_dev
||
873 (!strcmp(kp
->name
, "mmio") ^
874 (fw_cfg_cmdline_dev
->resource
[0].flags
== IORESOURCE_MEM
)))
877 switch (fw_cfg_cmdline_dev
->num_resources
) {
879 return snprintf(buf
, PAGE_SIZE
, PH_ADDR_PR_1_FMT
,
880 resource_size(&fw_cfg_cmdline_dev
->resource
[0]),
881 fw_cfg_cmdline_dev
->resource
[0].start
);
883 return snprintf(buf
, PAGE_SIZE
, PH_ADDR_PR_3_FMT
,
884 resource_size(&fw_cfg_cmdline_dev
->resource
[0]),
885 fw_cfg_cmdline_dev
->resource
[0].start
,
886 fw_cfg_cmdline_dev
->resource
[1].start
,
887 fw_cfg_cmdline_dev
->resource
[2].start
);
889 return snprintf(buf
, PAGE_SIZE
, PH_ADDR_PR_4_FMT
,
890 resource_size(&fw_cfg_cmdline_dev
->resource
[0]),
891 fw_cfg_cmdline_dev
->resource
[0].start
,
892 fw_cfg_cmdline_dev
->resource
[1].start
,
893 fw_cfg_cmdline_dev
->resource
[2].start
,
894 fw_cfg_cmdline_dev
->resource
[3].start
);
897 /* Should never get here */
898 WARN(1, "Unexpected number of resources: %d\n",
899 fw_cfg_cmdline_dev
->num_resources
);
903 static const struct kernel_param_ops fw_cfg_cmdline_param_ops
= {
904 .set
= fw_cfg_cmdline_set
,
905 .get
= fw_cfg_cmdline_get
,
908 device_param_cb(ioport
, &fw_cfg_cmdline_param_ops
, NULL
, S_IRUSR
);
909 device_param_cb(mmio
, &fw_cfg_cmdline_param_ops
, NULL
, S_IRUSR
);
911 #endif /* CONFIG_FW_CFG_SYSFS_CMDLINE */
913 static int __init
fw_cfg_sysfs_init(void)
917 /* create /sys/firmware/qemu_fw_cfg/ top level directory */
918 fw_cfg_top_ko
= kobject_create_and_add("qemu_fw_cfg", firmware_kobj
);
922 ret
= platform_driver_register(&fw_cfg_sysfs_driver
);
924 fw_cfg_kobj_cleanup(fw_cfg_top_ko
);
929 static void __exit
fw_cfg_sysfs_exit(void)
931 platform_driver_unregister(&fw_cfg_sysfs_driver
);
933 #ifdef CONFIG_FW_CFG_SYSFS_CMDLINE
934 platform_device_unregister(fw_cfg_cmdline_dev
);
937 /* clean up /sys/firmware/qemu_fw_cfg/ */
938 fw_cfg_kobj_cleanup(fw_cfg_top_ko
);
941 module_init(fw_cfg_sysfs_init
);
942 module_exit(fw_cfg_sysfs_exit
);