1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
#ifndef _LINUX_FIRMWARE_H
#define _LINUX_FIRMWARE_H
#include <linux/types.h>
#include <linux/compiler.h>
#include <linux/gfp.h>
#define FW_ACTION_NOHOTPLUG 0
#define FW_ACTION_HOTPLUG 1
struct firmware {
size_t size;
const u8 *data;
struct page **pages;
/* firmware loader private fields */
void *priv;
};
struct module;
struct device;
struct builtin_fw {
char *name;
void *data;
unsigned long size;
};
/* We have to play tricks here much like stringify() to get the
__COUNTER__ macro to be expanded as we want it */
#define __fw_concat1(x, y) x##y
#define __fw_concat(x, y) __fw_concat1(x, y)
#define DECLARE_BUILTIN_FIRMWARE(name, blob) \
DECLARE_BUILTIN_FIRMWARE_SIZE(name, &(blob), sizeof(blob))
#define DECLARE_BUILTIN_FIRMWARE_SIZE(name, blob, size) \
static const struct builtin_fw __fw_concat(__builtin_fw,__COUNTER__) \
__used __section(.builtin_fw) = { name, blob, size }
#if defined(CONFIG_FW_LOADER) || (defined(CONFIG_FW_LOADER_MODULE) && defined(MODULE))
int request_firmware(const struct firmware **fw, const char *name,
struct device *device);
int request_firmware_nowait(
struct module *module, bool uevent,
const char *name, struct device *device, gfp_t gfp, void *context,
void (*cont)(const struct firmware *fw, void *context));
int request_firmware_direct(const struct firmware **fw, const char *name,
struct device *device);
int request_firmware_into_buf(const struct firmware **firmware_p,
const char *name, struct device *device, void *buf, size_t size);
void release_firmware(const struct firmware *fw);
#else
static inline int request_firmware(const struct firmware **fw,
const char *name,
struct device *device)
{
return -EINVAL;
}
static inline int request_firmware_nowait(
struct module *module, bool uevent,
const char *name, struct device *device, gfp_t gfp, void *context,
void (*cont)(const struct firmware *fw, void *context))
{
return -EINVAL;
}
static inline void release_firmware(const struct firmware *fw)
{
}
static inline int request_firmware_direct(const struct firmware **fw,
const char *name,
struct device *device)
{
return -EINVAL;
}
static inline int request_firmware_into_buf(const struct firmware **firmware_p,
const char *name, struct device *device, void *buf, size_t size)
{
return -EINVAL;
}
#endif
#ifndef _LINUX_LIBRE_FIRMWARE_H
#define _LINUX_LIBRE_FIRMWARE_H
#include <linux/device.h>
#define NONFREE_FIRMWARE "/*(DEBLOBBED)*/"
static inline int
is_nonfree_firmware(const char *name)
{
return strstr(name, NONFREE_FIRMWARE) != 0;
}
static inline int
report_missing_free_firmware(const char *name, const char *what)
{
printk(KERN_ERR "%s: Missing Free %s (non-Free firmware loading is disabled)\n", name,
what ? what : "firmware");
return -EINVAL;
}
static inline int
reject_firmware(const struct firmware **fw,
const char *name, struct device *device)
{
const struct firmware *xfw = NULL;
int retval;
report_missing_free_firmware(dev_name(device), NULL);
retval = request_firmware(&xfw, NONFREE_FIRMWARE, device);
if (!retval)
release_firmware(xfw);
return -EINVAL;
}
static inline int
maybe_reject_firmware(const struct firmware **fw,
const char *name, struct device *device)
{
if (is_nonfree_firmware(name))
return reject_firmware(fw, name, device);
else
return request_firmware(fw, name, device);
}
static inline int
reject_firmware_direct(const struct firmware **fw,
const char *name, struct device *device)
{
const struct firmware *xfw = NULL;
int retval;
report_missing_free_firmware(dev_name(device), NULL);
retval = request_firmware_direct(&xfw, NONFREE_FIRMWARE, device);
if (!retval)
release_firmware(xfw);
return -EINVAL;
}
static inline void
discard_rejected_firmware(const struct firmware *fw, void *context)
{
release_firmware(fw);
}
static inline int
reject_firmware_nowait(struct module *module, int uevent,
const char *name, struct device *device,
gfp_t gfp, void *context,
void (*cont)(const struct firmware *fw,
void *context))
{
int retval;
report_missing_free_firmware(dev_name(device), NULL);
retval = request_firmware_nowait(module, uevent, NONFREE_FIRMWARE,
device, gfp, NULL,
discard_rejected_firmware);
if (retval)
return retval;
return -EINVAL;
}
static inline int
maybe_reject_firmware_nowait(struct module *module, int uevent,
const char *name, struct device *device,
gfp_t gfp, void *context,
void (*cont)(const struct firmware *fw,
void *context))
{
if (is_nonfree_firmware(name))
return reject_firmware_nowait(module, uevent, name,
device, gfp, context, cont);
else
return request_firmware_nowait(module, uevent, name,
device, gfp, context, cont);
}
#endif /* _LINUX_LIBRE_FIRMWARE_H */
#endif
|
