This source file includes following definitions.
- lbs_fw_loaded
- do_load_firmware
- main_firmware_cb
- helper_firmware_cb
- load_next_firmware_from_table
- lbs_wait_for_firmware_load
- lbs_get_firmware_async
- lbs_get_firmware
1
2
3
4
5
6 #include <linux/sched.h>
7 #include <linux/firmware.h>
8 #include <linux/module.h>
9
10 #include "dev.h"
11 #include "decl.h"
12
13 static void load_next_firmware_from_table(struct lbs_private *private);
14
15 static void lbs_fw_loaded(struct lbs_private *priv, int ret,
16 const struct firmware *helper, const struct firmware *mainfw)
17 {
18 unsigned long flags;
19
20 lbs_deb_fw("firmware load complete, code %d\n", ret);
21
22
23 priv->fw_callback(priv, ret, helper, mainfw);
24
25 spin_lock_irqsave(&priv->driver_lock, flags);
26 priv->fw_callback = NULL;
27 wake_up(&priv->fw_waitq);
28 spin_unlock_irqrestore(&priv->driver_lock, flags);
29 }
30
31 static void do_load_firmware(struct lbs_private *priv, const char *name,
32 void (*cb)(const struct firmware *fw, void *context))
33 {
34 int ret;
35
36 lbs_deb_fw("Requesting %s\n", name);
37 ret = request_firmware_nowait(THIS_MODULE, true, name,
38 priv->fw_device, GFP_KERNEL, priv, cb);
39 if (ret) {
40 lbs_deb_fw("request_firmware_nowait error %d\n", ret);
41 lbs_fw_loaded(priv, ret, NULL, NULL);
42 }
43 }
44
45 static void main_firmware_cb(const struct firmware *firmware, void *context)
46 {
47 struct lbs_private *priv = context;
48
49 if (!firmware) {
50
51 load_next_firmware_from_table(priv);
52 return;
53 }
54
55
56 lbs_fw_loaded(priv, 0, priv->helper_fw, firmware);
57 if (priv->helper_fw) {
58 release_firmware (priv->helper_fw);
59 priv->helper_fw = NULL;
60 }
61 release_firmware (firmware);
62 }
63
64 static void helper_firmware_cb(const struct firmware *firmware, void *context)
65 {
66 struct lbs_private *priv = context;
67
68 if (!firmware) {
69
70 load_next_firmware_from_table(priv);
71 return;
72 }
73
74
75 if (priv->fw_iter->fwname) {
76 priv->helper_fw = firmware;
77 do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
78 } else {
79
80 lbs_fw_loaded(priv, 0, firmware, NULL);
81 }
82 }
83
84 static void load_next_firmware_from_table(struct lbs_private *priv)
85 {
86 const struct lbs_fw_table *iter;
87
88 if (!priv->fw_iter)
89 iter = priv->fw_table;
90 else
91 iter = ++priv->fw_iter;
92
93 if (priv->helper_fw) {
94 release_firmware(priv->helper_fw);
95 priv->helper_fw = NULL;
96 }
97
98 next:
99 if (!iter->helper) {
100
101 lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
102 return;
103 }
104
105 if (iter->model != priv->fw_model) {
106 iter++;
107 goto next;
108 }
109
110 priv->fw_iter = iter;
111 do_load_firmware(priv, iter->helper, helper_firmware_cb);
112 }
113
114 void lbs_wait_for_firmware_load(struct lbs_private *priv)
115 {
116 wait_event(priv->fw_waitq, priv->fw_callback == NULL);
117 }
118
119
120
121
122
123
124
125
126
127
128
129
130
131 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
132 u32 card_model, const struct lbs_fw_table *fw_table,
133 lbs_fw_cb callback)
134 {
135 unsigned long flags;
136
137 spin_lock_irqsave(&priv->driver_lock, flags);
138 if (priv->fw_callback) {
139 lbs_deb_fw("firmware load already in progress\n");
140 spin_unlock_irqrestore(&priv->driver_lock, flags);
141 return -EBUSY;
142 }
143
144 priv->fw_device = device;
145 priv->fw_callback = callback;
146 priv->fw_table = fw_table;
147 priv->fw_iter = NULL;
148 priv->fw_model = card_model;
149 spin_unlock_irqrestore(&priv->driver_lock, flags);
150
151 lbs_deb_fw("Starting async firmware load\n");
152 load_next_firmware_from_table(priv);
153 return 0;
154 }
155 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172 int lbs_get_firmware(struct device *dev, u32 card_model,
173 const struct lbs_fw_table *fw_table,
174 const struct firmware **helper,
175 const struct firmware **mainfw)
176 {
177 const struct lbs_fw_table *iter;
178 int ret;
179
180 BUG_ON(helper == NULL);
181 BUG_ON(mainfw == NULL);
182
183
184 iter = fw_table;
185 while (iter && iter->helper) {
186 if (iter->model != card_model)
187 goto next;
188
189 if (*helper == NULL) {
190 ret = request_firmware(helper, iter->helper, dev);
191 if (ret)
192 goto next;
193
194
195
196
197
198 if (iter->fwname == NULL)
199 return 0;
200 }
201
202 if (*mainfw == NULL) {
203 ret = request_firmware(mainfw, iter->fwname, dev);
204 if (ret) {
205
206
207
208 release_firmware(*helper);
209 *helper = NULL;
210 }
211 }
212
213 if (*helper && *mainfw)
214 return 0;
215
216 next:
217 iter++;
218 }
219
220
221 release_firmware(*helper);
222 *helper = NULL;
223 release_firmware(*mainfw);
224 *mainfw = NULL;
225
226 return -ENOENT;
227 }
228 EXPORT_SYMBOL_GPL(lbs_get_firmware);