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