| /linux/Documentation/ABI/stable/ |
| H A D | sysfs-driver-firmware-zynqmp | 1 What: /sys/devices/platform/firmware\:zynqmp-firmware/ggs*
17 # cat /sys/devices/platform/firmware\:zynqmp-firmware/ggs0
18 # echo <value> > /sys/devices/platform/firmware\:zynqmp-firmware/ggs0
22 # cat /sys/devices/platform/firmware\:zynqmp-firmware/ggs0
23 # echo 0x1234ABCD > /sys/devices/platform/firmware\:zynqmp-firmware/ggs0
27 What: /sys/devices/platform/firmware\:zynqmp-firmware/pggs*
46 # cat /sys/devices/platform/firmware\:zynqmp-firmware/pggs0
47 # echo <value> > /sys/devices/platform/firmware\:zynqmp-firmware/pggs0
51 # cat /sys/devices/platform/firmware\:zynqmp-firmware/pggs0
52 # echo 0x1234ABCD > /sys/devices/platform/firmware\:zynqmp-firmware/pggs0
[all …]
|
| /linux/include/linux/ |
| H A D | firmware.h | 13 struct firmware { struct
89 bool firmware_request_builtin(struct firmware *fw, const char *name);
91 static inline bool firmware_request_builtin(struct firmware *fw, in firmware_request_builtin()
99 int request_firmware(const struct firmware **fw, const char *name,
104 void (*cont)(const struct firmware *fw, void *context));
105 int firmware_request_nowarn(const struct firmware **fw, const char *name,
107 int firmware_request_platform(const struct firmware **fw, const char *name,
112 void (*cont)(const struct firmware *fw, void *context));
113 int request_firmware_direct(const struct firmware **fw, const char *name,
115 int request_firmware_into_buf(const struct firmware **firmware_p,
[all …]
|
| /linux/Documentation/driver-api/firmware/ |
| H A D | firmware_cache.rst | 5 When Linux resumes from suspend some device drivers require firmware lookups to
7 firmware lookups are not possible, during this short period of time firmware
9 the root filesystem for firmware delays user experience with device
10 functionality. In order to support these requirements the firmware
11 infrastructure implements a firmware cache for device drivers for most API
14 The firmware cache makes using certain firmware API calls safe during a device
16 the firmware by themselves for dealing with firmware loss during system resume.
18 The firmware cache works by requesting for firmware prior to suspend and
19 caching it in memory. Upon resume device drivers using the firmware API will
20 have access to the firmware immediately, without having to wait for the root
[all …]
|
| H A D | request_firmware.rst | 5 You would typically load firmware and then load it into your device somehow.
6 The typical firmware work flow is reflected below::
12 Synchronous firmware requests
15 Synchronous firmware requests will wait until the firmware is found or until
43 Asynchronous firmware requests
46 Asynchronous firmware requests allow driver code to not have to wait
47 until the firmware or an error is returned. Function callbacks are
48 provided so that when the firmware or an error is found the driver is
60 Some devices have an optimization in place to enable the firmware to be
62 author must ensure the firmware is still available on resume from suspend,
[all …]
|
| H A D | fallback-mechanisms.rst | 6 filesystem lookup on the root filesystem or when the firmware simply cannot be
8 configuration options related to supporting the firmware fallback mechanism are:
10 * CONFIG_FW_LOADER_USER_HELPER: enables building the firmware fallback
15 enable the kobject uevent fallback mechanism on all firmware API calls
21 manually load the firmware. Read below for more details.
31 Justifying the firmware fallback mechanism
40 * Races upon resume from suspend. This is resolved by the firmware cache, but
41 the firmware cache is only supported if you use uevents, and its not
47 * The firmware provides very unique device specific data tailored for
68 In order to help device drivers upload firmware using a fallback mechanism
[all …]
|
| H A D | built-in-fw.rst | 2 Built-in firmware
5 Firmware can be built-in to the kernel, this means building the firmware
6 into vmlinux directly, to enable avoiding having to look for firmware from
7 the filesystem. Instead, firmware can be looked for inside the kernel
8 directly. You can enable built-in firmware using the kernel configuration
14 There are a few reasons why you might want to consider building your firmware
19 want to stuff the firmware into the boot initramfs.
22 able to make use of built-in firmware:
24 * Legalese - firmware is non-GPL compatible
25 * Some firmware may be optional
[all …]
|
| H A D | lookup-order.rst | 5 Different functionality is available to enable firmware to be found.
6 Below is chronological order of how firmware will be looked for once
7 a driver issues a firmware API call.
9 * The ''Built-in firmware'' is checked first, if the firmware is present we
11 * The ''Firmware cache'' is looked at next. If the firmware is found we
15 * The ''Platform firmware fallback'' is performed next, but only when
17 * If no firmware has been found and the fallback mechanism was enabled
19 is issued or the custom firmware loading is relied upon for firmware
|
| H A D | fw_upload.rst | 7 A device driver that registers with the firmware loader will expose
8 persistent sysfs nodes to enable users to initiate firmware updates for
12 documentation for firmware fallback. It also adds additional sysfs files
13 to provide status on the transfer of the firmware image to the device.
15 Register for firmware upload
18 A device driver registers for firmware upload by calling
20 identify the device under /sys/class/firmware. A user may initiate a
21 firmware upload by echoing a 1 to the *loading* sysfs file for the target
22 device. Next, the user writes the firmware image to the *data* sysfs
23 file. After writing the firmware data, the user echos 0 to the *loading*
[all …]
|
| /linux/Documentation/ABI/testing/ |
| H A D | sysfs-class-firmware | 1 What: /sys/class/firmware/.../data
5 Description: The data sysfs file is used for firmware-fallback and for
6 firmware uploads. Cat a firmware image to this sysfs file
7 after you echo 1 to the loading sysfs file. When the firmware
9 sequence will signal the completion of the firmware write and
10 signal the lower-level driver that the firmware data is
13 What: /sys/class/firmware/.../cancel
17 Description: Write-only. For firmware uploads, write a "1" to this file to
18 request that the transfer of firmware data to the lower-level
21 progress) or (ENODEV) if there is no firmware update in progress.
[all …]
|
| H A D | sysfs-firmware-efi-esrt | 1 What: /sys/firmware/efi/esrt/
5 (ESRT), a catalog of firmware for which can be updated with
10 What: /sys/firmware/efi/esrt/fw_resource_count
15 What: /sys/firmware/efi/esrt/fw_resource_count_max
20 really only useful to the system firmware itself.
22 What: /sys/firmware/efi/esrt/fw_resource_version
25 Description: The version of the ESRT structure provided by the firmware.
27 What: /sys/firmware/efi/esrt/entries/entry<N>/
32 example: /sys/firmware/efi/esrt/entries/entry0/
34 What: /sys/firmware/efi/esrt/entries/entry<N>/fw_type
[all …]
|
| H A D | sysfs-firmware-memmap | 1 What: /sys/firmware/memmap/
5 On all platforms, the firmware provides a memory map which the
10 However, on most architectures that firmware-provided memory
16 kexec needs the raw firmware-provided memory map to setup the
19 that reason, /sys/firmware/memmap is an interface that provides
22 The structure is as follows: Under /sys/firmware/memmap there
25 /sys/firmware/memmap/0
26 /sys/firmware/memmap/1
27 /sys/firmware/memmap/2
28 /sys/firmware/memmap/3
[all …]
|
| H A D | sysfs-firmware-gsmi | 1 What: /sys/firmware/gsmi
5 Some servers used internally at Google have firmware
13 these firmware callbacks. Currently, this functionality
19 /sys/firmware/gsmi/vars:
22 underlying implementation as /sys/firmware/efi/vars.
23 See `Documentation/ABI/*/sysfs-firmware-efi-vars`
27 /sys/firmware/gsmi/append_to_eventlog - write-only:
30 the firmware to be timestamped and appended to
32 interpreted by the firmware and may change from
36 firmware call.
[all …]
|
| /linux/Documentation/driver-api/nvdimm/ |
| H A D | firmware-activate.rst | 7 Some persistent memory devices run a firmware locally on the device /
9 and health monitoring. The process of updating that firmware typically
13 DSM specification [1], has added support for activating firmware at
17 to advertise and control their local runtime firmware activation
20 The libnvdimm bus object, ndbusX, implements an ndbusX/firmware/activate
21 attribute that shows the state of the firmware activation as one of 'idle',
25 No devices are set / armed to activate firmware
37 activation. In that scenario the potential for firmware activation to
40 The 'ndbusX/firmware/activate' property can be written with a value of
42 run firmware activation from within the equivalent of the hibernation
[all …]
|
| /linux/drivers/base/firmware_loader/ |
| H A D | Kconfig | 9 This enables the firmware loading facility in the kernel. The kernel
10 will first look for built-in firmware, if it has any. Next, it will
11 look for the requested firmware in a series of filesystem paths:
14 o /lib/firmware/updates/UTS_RELEASE
15 o /lib/firmware/updates
16 o /lib/firmware/UTS_RELEASE
17 o /lib/firmware
21 need firmware.
26 enable built-in firmware (CONFIG_EXTRA_FIRMWARE).
29 bool "Log filenames and checksums for loaded firmware"
[all …]
|
| /linux/sound/pci/asihpi/ |
| H A D | hpidspcd.c | 18 const struct firmware *firmware; member
26 const struct firmware *firmware; in hpi_dsp_code_open() local
35 err = request_firmware(&firmware, fw_name, &dev->dev); in hpi_dsp_code_open()
37 if (err || !firmware) { in hpi_dsp_code_open()
42 if (firmware->size < sizeof(header)) { in hpi_dsp_code_open()
46 memcpy(&header, firmware->data, sizeof(header)); in hpi_dsp_code_open()
50 || (header.size != firmware->size)) { in hpi_dsp_code_open()
53 header.size, firmware->size); in hpi_dsp_code_open()
79 dsp_code->pvt->firmware = firmware; in hpi_dsp_code_open()
86 release_firmware(firmware); in hpi_dsp_code_open()
[all …]
|
| /linux/drivers/bluetooth/ |
| H A D | ath3k.c | 203 const struct firmware *firmware) in ath3k_load_firmware() argument
208 int count = firmware->size; in ath3k_load_firmware()
219 0, 0, firmware->data, FW_HDR_SIZE, in ath3k_load_firmware()
235 memcpy(send_buf, firmware->data + sent, size); in ath3k_load_firmware()
272 const struct firmware *firmware) in ath3k_load_fwfile() argument
279 count = firmware->size; in ath3k_load_fwfile()
290 firmware->data, size, USB_CTRL_SET_TIMEOUT, in ath3k_load_fwfile()
308 memcpy(send_buf, firmware->data + sent, size); in ath3k_load_fwfile()
356 const struct firmware *firmware; in ath3k_load_patch() local
381 ret = request_firmware(&firmware, filename, &udev->dev); in ath3k_load_patch()
[all …]
|
| H A D | bcm203x.c | 154 const struct firmware *firmware; in bcm203x_probe() local
175 if (request_firmware(&firmware, "BCM2033-MD.hex", &udev->dev) < 0) { in bcm203x_probe()
181 BT_DBG("minidrv data %p size %zu", firmware->data, firmware->size); in bcm203x_probe()
183 size = max_t(uint, firmware->size, 4096); in bcm203x_probe()
188 release_firmware(firmware); in bcm203x_probe()
193 memcpy(data->buffer, firmware->data, firmware->size); in bcm203x_probe()
196 data->buffer, firmware->size, bcm203x_complete, data); in bcm203x_probe()
198 release_firmware(firmware); in bcm203x_probe()
200 if (request_firmware(&firmware, "BCM2033-FW.bin", &udev->dev) < 0) { in bcm203x_probe()
207 BT_DBG("firmware data %p size %zu", firmware->data, firmware->size); in bcm203x_probe()
[all …]
|
| /linux/drivers/media/usb/as102/ |
| H A D | as102_fw.c | 93 const struct firmware *firmware) { in as102_firmware_upload() argument
104 for (total_read_bytes = 0; total_read_bytes < firmware->size; ) { in as102_firmware_upload()
109 (u8 *) (firmware->data + total_read_bytes), in as102_firmware_upload()
120 if (total_read_bytes == firmware->size) { in as102_firmware_upload()
158 const struct firmware *firmware = NULL; in as102_fw_upload() local
180 errno = request_firmware(&firmware, fw1, &dev->dev); in as102_fw_upload()
188 errno = as102_firmware_upload(bus_adap, cmd_buf, firmware); in as102_fw_upload()
197 release_firmware(firmware); in as102_fw_upload()
198 firmware = NULL; in as102_fw_upload()
204 errno = request_firmware(&firmware, fw2, &dev->dev); in as102_fw_upload()
[all …]
|
| /linux/drivers/net/wireless/marvell/libertas/ |
| H A D | firmware.c | 16 const struct firmware *helper, const struct firmware *mainfw) in lbs_fw_loaded()
32 void (*cb)(const struct firmware *fw, void *context)) in do_load_firmware()
45 static void main_firmware_cb(const struct firmware *firmware, void *context) in main_firmware_cb() argument
49 if (!firmware) { in main_firmware_cb()
56 lbs_fw_loaded(priv, 0, priv->helper_fw, firmware); in main_firmware_cb()
61 release_firmware (firmware); in main_firmware_cb()
64 static void helper_firmware_cb(const struct firmware *firmware, void *context) in helper_firmware_cb() argument
68 if (!firmware) { in helper_firmware_cb()
76 priv->helper_fw = firmware; in helper_firmware_cb()
80 lbs_fw_loaded(priv, 0, firmware, NULL); in helper_firmware_cb()
[all …]
|
| /linux/Documentation/devicetree/bindings/soc/fsl/cpm_qe/qe/ |
| H A D | firmware.txt | 1 * Uploaded QE firmware
3 If a new firmware has been uploaded to the QE (usually by the
4 boot loader), then a 'firmware' child node should be added to the QE
5 node. This node provides information on the uploaded firmware that
9 - id: The string name of the firmware. This is taken from the 'id'
10 member of the qe_firmware structure of the uploaded firmware.
12 firmware they want is already present.
14 firmware binary. It is a 64-bit number represented
16 - virtual-traps: The virtual traps, taken from the firmware binary.
20 firmware {
|
| /linux/drivers/soc/fsl/qe/ |
| H A D | qe.c | 447 int qe_upload_firmware(const struct qe_firmware *firmware) in qe_upload_firmware() argument
456 if (!firmware) { in qe_upload_firmware()
461 hdr = &firmware->header; in qe_upload_firmware()
478 if ((firmware->count < 1) || (firmware->count > MAX_QE_RISC)) { in qe_upload_firmware()
484 calc_size = struct_size(firmware, microcode, firmware->count); in qe_upload_firmware()
486 for (i = 0; i < firmware->count; i++) in qe_upload_firmware()
493 be32_to_cpu(firmware->microcode[i].count); in qe_upload_firmware()
502 crc = be32_to_cpu(*(__be32 *)((void *)firmware + calc_size)); in qe_upload_firmware()
503 if (crc != crc32(0, firmware, calc_size)) { in qe_upload_firmware()
511 if (!firmware->split) in qe_upload_firmware()
[all …]
|
| /linux/Documentation/networking/devlink/ |
| H A D | devlink-flash.rst | 9 The ``devlink-flash`` API allows updating device firmware. It replaces the
15 Note that the file name is a path relative to the firmware loading path
16 (usually ``/lib/firmware/``). Drivers may send status updates to inform
41 are provided, it is expected that the device only update firmware binaries
50 Devices which require firmware to operate usually store it in non-volatile
51 memory on the board, e.g. flash. Some devices store only basic firmware on
53 ``devlink-info`` allows users to query firmware information (loaded
61 On-disk firmware files are usually stored in ``/lib/firmware/``.
68 automated firmware update facilities.
74 design, e.g. for looking up applicable firmware updates. This is why
[all …]
|
| /linux/drivers/pwm/ |
| H A D | pwm-raspberrypi-poe.c | 29 struct rpi_firmware *firmware; member
45 static int raspberrypi_pwm_set_property(struct rpi_firmware *firmware, in raspberrypi_pwm_set_property() argument
54 ret = rpi_firmware_property(firmware, RPI_FIRMWARE_SET_POE_HAT_VAL, in raspberrypi_pwm_set_property()
64 static int raspberrypi_pwm_get_property(struct rpi_firmware *firmware, in raspberrypi_pwm_get_property() argument
72 ret = rpi_firmware_property(firmware, RPI_FIRMWARE_GET_POE_HAT_VAL, in raspberrypi_pwm_get_property()
121 ret = raspberrypi_pwm_set_property(rpipwm->firmware, RPI_PWM_CUR_DUTY_REG, in raspberrypi_pwm_apply()
143 struct rpi_firmware *firmware; in raspberrypi_pwm_probe() local
154 firmware = devm_rpi_firmware_get(&pdev->dev, firmware_node); in raspberrypi_pwm_probe()
156 if (!firmware) in raspberrypi_pwm_probe()
166 rpipwm->firmware = firmware; in raspberrypi_pwm_probe()
[all …]
|
| /linux/Documentation/leds/ |
| H A D | leds-lp55xx.rst | 66 LP55xx common driver supports the firmware interface.
82 Start program which is loaded via the firmware interface
83 firmware:
93 echo 1 > /sys/class/firmware/lp5521/loading
94 echo "4000600040FF6000" > /sys/class/firmware/lp5521/data
95 echo 0 > /sys/class/firmware/lp5521/loading
103 echo 1 > /sys/class/firmware/lp55231/loading
104 echo "9d0740ff7e0040007e00a0010000" > /sys/class/firmware/lp55231/data
105 echo 0 > /sys/class/firmware/lp55231/loading
115 echo 1 > /sys/class/firmware/lp5521/loading
[all …]
|
| /linux/drivers/usb/misc/ |
| H A D | isight_firmware.c | 39 const struct firmware *firmware; in isight_firmware_load() local
47 if (request_firmware(&firmware, "isight.fw", &dev->dev) != 0) { in isight_firmware_load()
53 ptr = firmware->data; in isight_firmware_load()
65 while (ptr+4 <= firmware->data+firmware->size) { in isight_firmware_load()
79 if (ptr+llen > firmware->data+firmware->size) { in isight_firmware_load()
111 release_firmware(firmware); in isight_firmware_load()
|