1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* 3 * (C) Copyright 2015 Miao Yan <yanmiaobest@gmail.com> 4 */ 5 6 #ifndef __FW_CFG__ 7 #define __FW_CFG__ 8 9 #include <linux/list.h> 10 11 /* 12 * List of firmware configuration item selectors. The official source of truth 13 * for these is the QEMU source itself; see 14 * https://github.com/qemu/qemu/blob/master/hw/nvram/fw_cfg.c 15 */ 16 enum { 17 FW_CFG_SIGNATURE = 0x00, 18 FW_CFG_ID = 0x01, 19 FW_CFG_UUID = 0x02, 20 FW_CFG_RAM_SIZE = 0x03, 21 FW_CFG_NOGRAPHIC = 0x04, 22 FW_CFG_NB_CPUS = 0x05, 23 FW_CFG_MACHINE_ID = 0x06, 24 FW_CFG_KERNEL_ADDR = 0x07, 25 FW_CFG_KERNEL_SIZE = 0x08, 26 FW_CFG_KERNEL_CMDLINE = 0x09, 27 FW_CFG_INITRD_ADDR = 0x0a, 28 FW_CFG_INITRD_SIZE = 0x0b, 29 FW_CFG_BOOT_DEVICE = 0x0c, 30 FW_CFG_NUMA = 0x0d, 31 FW_CFG_BOOT_MENU = 0x0e, 32 FW_CFG_MAX_CPUS = 0x0f, 33 FW_CFG_KERNEL_ENTRY = 0x10, 34 FW_CFG_KERNEL_DATA = 0x11, 35 FW_CFG_INITRD_DATA = 0x12, 36 FW_CFG_CMDLINE_ADDR = 0x13, 37 FW_CFG_CMDLINE_SIZE = 0x14, 38 FW_CFG_CMDLINE_DATA = 0x15, 39 FW_CFG_SETUP_ADDR = 0x16, 40 FW_CFG_SETUP_SIZE = 0x17, 41 FW_CFG_SETUP_DATA = 0x18, 42 FW_CFG_FILE_DIR = 0x19, 43 FW_CFG_FILE_FIRST = 0x20, 44 FW_CFG_WRITE_CHANNEL = 0x4000, 45 FW_CFG_ARCH_LOCAL = 0x8000, 46 FW_CFG_INVALID = 0xffff, 47 }; 48 49 enum { 50 BIOS_LINKER_LOADER_COMMAND_ALLOCATE = 0x1, 51 BIOS_LINKER_LOADER_COMMAND_ADD_POINTER = 0x2, 52 BIOS_LINKER_LOADER_COMMAND_ADD_CHECKSUM = 0x3, 53 }; 54 55 enum { 56 BIOS_LINKER_LOADER_ALLOC_ZONE_HIGH = 0x1, 57 BIOS_LINKER_LOADER_ALLOC_ZONE_FSEG = 0x2, 58 }; 59 60 #define FW_CFG_FILE_SLOTS 0x10 61 #define FW_CFG_MAX_ENTRY (FW_CFG_FILE_FIRST + FW_CFG_FILE_SLOTS) 62 #define FW_CFG_ENTRY_MASK ~(FW_CFG_WRITE_CHANNEL | FW_CFG_ARCH_LOCAL) 63 64 #define FW_CFG_MAX_FILE_PATH 56 65 #define BIOS_LINKER_LOADER_FILESZ FW_CFG_MAX_FILE_PATH 66 67 #define QEMU_FW_CFG_SIGNATURE (('Q' << 24) | ('E' << 16) | ('M' << 8) | 'U') 68 69 #define FW_CFG_DMA_ERROR (1 << 0) 70 #define FW_CFG_DMA_READ (1 << 1) 71 #define FW_CFG_DMA_SKIP (1 << 2) 72 #define FW_CFG_DMA_SELECT (1 << 3) 73 74 /* Bit set in FW_CFG_ID response to indicate DMA interface availability. */ 75 #define FW_CFG_DMA_ENABLED (1 << 1) 76 77 /* Structs read from FW_CFG_FILE_DIR. */ 78 struct fw_cfg_file { 79 __be32 size; 80 __be16 select; 81 __be16 reserved; 82 char name[FW_CFG_MAX_FILE_PATH]; 83 }; 84 85 struct fw_file { 86 struct fw_cfg_file cfg; /* firmware file information */ 87 unsigned long addr; /* firmware file in-memory address */ 88 struct list_head list; /* list node to link to fw_list */ 89 }; 90 91 struct fw_cfg_file_iter { 92 struct list_head *entry, *end; /* structures to iterate file list */ 93 }; 94 95 struct bios_linker_entry { 96 __le32 command; 97 union { 98 /* 99 * COMMAND_ALLOCATE - allocate a table from @alloc.file 100 * subject to @alloc.align alignment (must be power of 2) 101 * and @alloc.zone (can be HIGH or FSEG) requirements. 102 * 103 * Must appear exactly once for each file, and before 104 * this file is referenced by any other command. 105 */ 106 struct { 107 char file[BIOS_LINKER_LOADER_FILESZ]; 108 __le32 align; 109 uint8_t zone; 110 } alloc; 111 112 /* 113 * COMMAND_ADD_POINTER - patch the table (originating from 114 * @dest_file) at @pointer.offset, by adding a pointer to the 115 * table originating from @src_file. 1,2,4 or 8 byte unsigned 116 * addition is used depending on @pointer.size. 117 */ 118 struct { 119 char dest_file[BIOS_LINKER_LOADER_FILESZ]; 120 char src_file[BIOS_LINKER_LOADER_FILESZ]; 121 __le32 offset; 122 uint8_t size; 123 } pointer; 124 125 /* 126 * COMMAND_ADD_CHECKSUM - calculate checksum of the range 127 * specified by @cksum_start and @cksum_length fields, 128 * and then add the value at @cksum.offset. 129 * Checksum simply sums -X for each byte X in the range 130 * using 8-bit math. 131 */ 132 struct { 133 char file[BIOS_LINKER_LOADER_FILESZ]; 134 __le32 offset; 135 __le32 start; 136 __le32 length; 137 } cksum; 138 139 /* padding */ 140 char pad[124]; 141 }; 142 } __packed; 143 144 /* DMA transfer control data between UCLASS_QFW and QEMU. */ 145 struct qfw_dma { 146 __be32 control; 147 __be32 length; 148 __be64 address; 149 }; 150 151 /* uclass per-device configuration information */ 152 struct qfw_dev { 153 struct udevice *dev; /* Transport device */ 154 bool dma_present; /* DMA interface usable? */ 155 struct list_head fw_list; /* Cached firmware file list */ 156 }; 157 158 /* Ops used internally between UCLASS_QFW and its driver implementations. */ 159 struct dm_qfw_ops { 160 /** 161 * read_entry_io() - Read a firmware config entry using the regular 162 * IO interface for the platform (either PIO or MMIO) 163 * 164 * Supply %FW_CFG_INVALID as the entry to continue a previous read. In 165 * this case, no selector will be issued before reading. 166 * 167 * @dev: Device to use 168 * @entry: Firmware config entry number (e.g. %FW_CFG_SIGNATURE) 169 * @size: Number of bytes to read 170 * @address: Target location for read 171 */ 172 void (*read_entry_io)(struct udevice *dev, u16 entry, u32 size, 173 void *address); 174 175 /** 176 * read_entry_dma() - Read a firmware config entry using the DMA 177 * interface 178 * 179 * Supply FW_CFG_INVALID as the entry to continue a previous read. In 180 * this case, no selector will be issued before reading. 181 * 182 * This method assumes DMA availability has already been confirmed. 183 * 184 * @dev: Device to use 185 * @dma: DMA transfer control struct 186 */ 187 void (*read_entry_dma)(struct udevice *dev, struct qfw_dma *dma); 188 }; 189 190 #define dm_qfw_get_ops(dev) \ 191 ((struct dm_qfw_ops *)(dev)->driver->ops) 192 193 /** 194 * qfw_register() - Called by a qfw driver after successful probe. 195 * @dev: Device registering itself with the uclass. 196 * 197 * Used internally by driver implementations on successful probe. 198 * 199 * Return: 0 on success, negative otherwise. 200 */ 201 int qfw_register(struct udevice *dev); 202 203 struct udevice; 204 205 /** 206 * qfw_get_dev() - Get QEMU firmware config device. 207 * @devp: Pointer to be filled with address of the qfw device. 208 * 209 * Gets the active QEMU firmware config device, for use with qfw_read_entry() 210 * and others. 211 * 212 * Return: 0 on success, -ENODEV if the device is not available. 213 */ 214 int qfw_get_dev(struct udevice **devp); 215 216 /** 217 * qfw_read_entry() - Read a QEMU firmware config entry 218 * @dev: QFW device to use. 219 * @entry: Firmware config entry number (e.g. %FW_CFG_SIGNATURE). 220 * @size: Number of bytes to read. 221 * @address: Target location for read. 222 * 223 * Reads a QEMU firmware config entry using @dev. DMA will be used if the QEMU 224 * machine supports it, otherwise PIO/MMIO. 225 */ 226 void qfw_read_entry(struct udevice *dev, u16 entry, u32 size, void *address); 227 228 /** 229 * qfw_read_firmware_list() - Read and cache the QEMU firmware config file 230 * list. 231 * @dev: QFW device to use. 232 * 233 * Reads the QEMU firmware config file list, caching it against @dev for later 234 * use with qfw_find_file(). 235 * 236 * If the list has already been read, does nothing and returns 0 (success). 237 * 238 * Return: 0 on success, -ENOMEM if unable to allocate. 239 */ 240 int qfw_read_firmware_list(struct udevice *dev); 241 242 /** 243 * qfw_find_file() - Find a file by name in the QEMU firmware config file 244 * list. 245 * @dev: QFW device to use. 246 * @name: Name of file to locate (e.g. "etc/table-loader"). 247 * 248 * Finds a file by name in the QEMU firmware config file list cached against 249 * @dev. You must call qfw_read_firmware_list() successfully first for this to 250 * succeed. 251 * 252 * Return: Pointer to &struct fw_file if found, %NULL if not present. 253 */ 254 struct fw_file *qfw_find_file(struct udevice *dev, const char *name); 255 256 /** 257 * qfw_online_cpus() - Get number of CPUs in system from QEMU firmware config. 258 * @dev: QFW device to use. 259 * 260 * Asks QEMU to report how many CPUs it is emulating for the machine. 261 * 262 * Return: Number of CPUs in the system. 263 */ 264 int qfw_online_cpus(struct udevice *dev); 265 266 /** 267 * qfw_file_iter_init() - Start iterating cached firmware file list. 268 * @dev: QFW device to use. 269 * @iter: Iterator to be initialised. 270 * 271 * Starts iterating the cached firmware file list in @dev. You must call 272 * qfw_read_firmware_list() successfully first, otherwise you will always get 273 * an empty list. 274 * 275 * qfw_file_iter_init() returns the first &struct fw_file, but it may be 276 * invalid if the list is empty. Check that ``!qfw_file_iter_end(&iter)`` 277 * first. 278 * 279 * Return: The first &struct fw_file item in the firmware file list, if any. 280 * Only valid when qfw_file_iter_end() is not true after the call. 281 */ 282 struct fw_file *qfw_file_iter_init(struct udevice *dev, 283 struct fw_cfg_file_iter *iter); 284 285 /** 286 * qfw_file_iter_next() - Iterate cached firmware file list. 287 * @iter: Iterator to use. 288 * 289 * Continues iterating the cached firmware file list in @dev. You must call 290 * qfw_file_iter_init() first to initialise it. Check that 291 * ``!qfw_file_iter_end(&iter)`` before using the return value of this 292 * function. 293 * 294 * Return: The next &struct fw_file item in the firmware file list. Only valid 295 * when qfw_file_iter_end() is not true after the call. 296 */ 297 struct fw_file *qfw_file_iter_next(struct fw_cfg_file_iter *iter); 298 299 /** 300 * qfw_file_iter_end() - Check if iter is at end of list. 301 * @iter: Iterator to use. 302 * 303 * Checks whether or not the iterator is at its end position. If so, the 304 * qfw_file_iter_init() or qfw_file_iter_next() call that immediately preceded 305 * returned invalid data. 306 * 307 * Return: True if the iterator is at its end; false otherwise. 308 */ 309 bool qfw_file_iter_end(struct fw_cfg_file_iter *iter); 310 311 /** 312 * qemu_cpu_fixup() - Fix up the CPUs for QEMU. 313 * 314 * Return: 0 on success, -ENODEV if no CPUs, -ENOMEM if out of memory, other < 315 * 0 on on other error. 316 */ 317 int qemu_cpu_fixup(void); 318 319 #endif 320