1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_FIRMWARE_H
3 #define _LINUX_FIRMWARE_H
5 #include <linux/types.h>
6 #include <linux/compiler.h>
9 #define FW_ACTION_NOHOTPLUG 0
10 #define FW_ACTION_HOTPLUG 1
16 /* firmware loader private fields */
29 /* We have to play tricks here much like stringify() to get the
30 __COUNTER__ macro to be expanded as we want it */
31 #define __fw_concat1(x, y) x##y
32 #define __fw_concat(x, y) __fw_concat1(x, y)
34 #define DECLARE_BUILTIN_FIRMWARE(name, blob) \
35 DECLARE_BUILTIN_FIRMWARE_SIZE(name, &(blob), sizeof(blob))
37 #define DECLARE_BUILTIN_FIRMWARE_SIZE(name, blob, size) \
38 static const struct builtin_fw __fw_concat(__builtin_fw,__COUNTER__) \
39 __used __section(".builtin_fw") = { name, blob, size }
41 #if defined(CONFIG_FW_LOADER) || (defined(CONFIG_FW_LOADER_MODULE) && defined(MODULE))
42 int request_firmware(const struct firmware **fw, const char *name,
43 struct device *device);
44 int firmware_request_nowarn(const struct firmware **fw, const char *name,
45 struct device *device);
46 int firmware_request_platform(const struct firmware **fw, const char *name,
47 struct device *device);
48 int request_firmware_nowait(
49 struct module *module, bool uevent,
50 const char *name, struct device *device, gfp_t gfp, void *context,
51 void (*cont)(const struct firmware *fw, void *context));
52 int request_firmware_direct(const struct firmware **fw, const char *name,
53 struct device *device);
54 int request_firmware_into_buf(const struct firmware **firmware_p,
55 const char *name, struct device *device, void *buf, size_t size);
56 int request_partial_firmware_into_buf(const struct firmware **firmware_p,
57 const char *name, struct device *device,
58 void *buf, size_t size, size_t offset);
60 void release_firmware(const struct firmware *fw);
62 static inline int request_firmware(const struct firmware **fw,
64 struct device *device)
69 static inline int firmware_request_nowarn(const struct firmware **fw,
71 struct device *device)
76 static inline int firmware_request_platform(const struct firmware **fw,
78 struct device *device)
83 static inline int request_firmware_nowait(
84 struct module *module, bool uevent,
85 const char *name, struct device *device, gfp_t gfp, void *context,
86 void (*cont)(const struct firmware *fw, void *context))
91 static inline void release_firmware(const struct firmware *fw)
95 static inline int request_firmware_direct(const struct firmware **fw,
97 struct device *device)
102 static inline int request_firmware_into_buf(const struct firmware **firmware_p,
103 const char *name, struct device *device, void *buf, size_t size)
108 static inline int request_partial_firmware_into_buf
109 (const struct firmware **firmware_p,
111 struct device *device,
112 void *buf, size_t size, size_t offset)
119 int firmware_request_cache(struct device *device, const char *name);
121 #ifndef _LINUX_LIBRE_FIRMWARE_H
122 #define _LINUX_LIBRE_FIRMWARE_H
124 #include <linux/device.h>
126 #define NONFREE_FIRMWARE "/*(DEBLOBBED)*/"
129 is_nonfree_firmware(const char *name)
131 return strstr(name, NONFREE_FIRMWARE) != 0;
135 report_missing_free_firmware(const char *name, const char *what)
137 printk(KERN_ERR "%s: Missing Free %s (non-Free firmware loading is disabled)\n", name,
138 what ? what : "firmware");
142 firmware_reject_nowarn(const struct firmware **fw,
143 const char *name, struct device *device)
145 const struct firmware *xfw = NULL;
146 int retval, retval0 = -ENOENT;
147 retval = firmware_request_nowarn(&xfw, NONFREE_FIRMWARE, device);
149 release_firmware(xfw);
155 reject_firmware(const struct firmware **fw,
156 const char *name, struct device *device)
159 retval0 = report_missing_free_firmware(dev_name(device), NULL);
160 retval = firmware_reject_nowarn(fw, name, device);
167 maybe_reject_firmware(const struct firmware **fw,
168 const char *name, struct device *device)
170 if (is_nonfree_firmware(name))
171 return reject_firmware(fw, name, device);
173 return request_firmware(fw, name, device);
176 reject_firmware_direct(const struct firmware **fw,
177 const char *name, struct device *device)
179 const struct firmware *xfw = NULL;
181 retval0 = report_missing_free_firmware(dev_name(device), NULL);
182 retval = request_firmware_direct(&xfw, NONFREE_FIRMWARE, device);
184 release_firmware(xfw);
190 reject_firmware_nowait(struct module *module, int uevent,
191 const char *name, struct device *device,
192 gfp_t gfp, void *context,
193 void (*cont)(const struct firmware *fw,
196 report_missing_free_firmware(dev_name(device), NULL);
197 /* We assume NONFREE_FIRMWARE will not be found; how could it? */
198 return request_firmware_nowait(module, uevent, NONFREE_FIRMWARE,
199 device, gfp, context, cont);
202 maybe_reject_firmware_nowait(struct module *module, int uevent,
203 const char *name, struct device *device,
204 gfp_t gfp, void *context,
205 void (*cont)(const struct firmware *fw,
208 if (is_nonfree_firmware(name))
209 return reject_firmware_nowait(module, uevent, name,
210 device, gfp, context, cont);
212 return request_firmware_nowait(module, uevent, name,
213 device, gfp, context, cont);
216 reject_firmware_into_buf(const struct firmware **firmware_p, const char *name,
217 struct device *device, void *buf, size_t size)
219 const struct firmware *xfw = NULL;
221 retval0 = report_missing_free_firmware(dev_name(device), NULL);
222 retval = request_firmware_into_buf(&xfw, NONFREE_FIRMWARE, device, buf, size);
224 release_firmware(xfw);
230 maybe_reject_firmware_into_buf(const struct firmware **firmware_p, const char *name,
231 struct device *device, void *buf, size_t size)
233 if (is_nonfree_firmware(name))
234 return reject_firmware_into_buf(firmware_p, name, device, buf, size);
236 return request_firmware_into_buf(firmware_p, name, device, buf, size);
239 reject_partial_firmware_into_buf(const struct firmware **firmware_p, const char *name,
240 struct device *device, void *buf, size_t size, size_t offset)
242 const struct firmware *xfw = NULL;
244 retval0 = report_missing_free_firmware(dev_name(device), NULL);
245 retval = request_partial_firmware_into_buf(&xfw, NONFREE_FIRMWARE, device, buf, size, offset);
247 release_firmware(xfw);
253 maybe_reject_partial_firmware_into_buf(const struct firmware **firmware_p, const char *name,
254 struct device *device, void *buf, size_t size, size_t offset)
256 if (is_nonfree_firmware(name))
257 return reject_partial_firmware_into_buf(firmware_p, name, device, buf, size, offset);
259 return request_partial_firmware_into_buf(firmware_p, name, device, buf, size, offset);
262 #endif /* _LINUX_LIBRE_FIRMWARE_H */