2 * Firmware loading and handling functions.
5 #include <linux/firmware.h>
6 #include <linux/firmware.h>
7 #include <linux/module.h>
8 #include <linux/sched.h>
13 static void load_next_firmware_from_table(struct lbs_private
*private);
15 static void lbs_fw_loaded(struct lbs_private
*priv
, int ret
,
16 const struct firmware
*helper
, const struct firmware
*mainfw
)
20 lbs_deb_fw("firmware load complete, code %d\n", ret
);
22 /* User must free helper/mainfw */
23 priv
->fw_callback(priv
, ret
, helper
, mainfw
);
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
);
31 static void do_load_firmware(struct lbs_private
*priv
, const char *name
,
32 void (*cb
)(const struct firmware
*fw
, void *context
))
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
);
40 lbs_deb_fw("request_firmware_nowait error %d\n", ret
);
41 lbs_fw_loaded(priv
, ret
, NULL
, NULL
);
45 static void main_firmware_cb(const struct firmware
*firmware
, void *context
)
47 struct lbs_private
*priv
= context
;
50 /* Failed to find firmware: try next table entry */
51 load_next_firmware_from_table(priv
);
56 lbs_fw_loaded(priv
, 0, priv
->helper_fw
, firmware
);
59 static void helper_firmware_cb(const struct firmware
*firmware
, void *context
)
61 struct lbs_private
*priv
= context
;
64 /* Failed to find firmware: try next table entry */
65 load_next_firmware_from_table(priv
);
70 if (priv
->fw_iter
->fwname
) {
71 priv
->helper_fw
= firmware
;
72 do_load_firmware(priv
, priv
->fw_iter
->fwname
, main_firmware_cb
);
74 /* No main firmware needed for this helper --> success! */
75 lbs_fw_loaded(priv
, 0, firmware
, NULL
);
79 static void load_next_firmware_from_table(struct lbs_private
*priv
)
81 const struct lbs_fw_table
*iter
;
84 iter
= priv
->fw_table
;
86 iter
= ++priv
->fw_iter
;
88 if (priv
->helper_fw
) {
89 release_firmware(priv
->helper_fw
);
90 priv
->helper_fw
= NULL
;
95 /* End of table hit. */
96 lbs_fw_loaded(priv
, -ENOENT
, NULL
, NULL
);
100 if (iter
->model
!= priv
->fw_model
) {
105 priv
->fw_iter
= iter
;
106 do_load_firmware(priv
, iter
->helper
, helper_firmware_cb
);
109 void lbs_wait_for_firmware_load(struct lbs_private
*priv
)
111 wait_event(priv
->fw_waitq
, priv
->fw_callback
== NULL
);
115 * lbs_get_firmware_async - Retrieves firmware asynchronously. Can load
116 * either a helper firmware and a main firmware (2-stage), or just the helper.
118 * @priv: Pointer to lbs_private instance
119 * @dev: A pointer to &device structure
120 * @card_model: Bus-specific card model ID used to filter firmware table
122 * @fw_table: Table of firmware file names and device model numbers
123 * terminated by an entry with a NULL helper name
124 * @callback: User callback to invoke when firmware load succeeds or fails.
126 int lbs_get_firmware_async(struct lbs_private
*priv
, struct device
*device
,
127 u32 card_model
, const struct lbs_fw_table
*fw_table
,
132 spin_lock_irqsave(&priv
->driver_lock
, flags
);
133 if (priv
->fw_callback
) {
134 lbs_deb_fw("firmware load already in progress\n");
135 spin_unlock_irqrestore(&priv
->driver_lock
, flags
);
139 priv
->fw_device
= device
;
140 priv
->fw_callback
= callback
;
141 priv
->fw_table
= fw_table
;
142 priv
->fw_iter
= NULL
;
143 priv
->fw_model
= card_model
;
144 spin_unlock_irqrestore(&priv
->driver_lock
, flags
);
146 lbs_deb_fw("Starting async firmware load\n");
147 load_next_firmware_from_table(priv
);
150 EXPORT_SYMBOL_GPL(lbs_get_firmware_async
);
153 * lbs_get_firmware - Retrieves two-stage firmware
155 * @dev: A pointer to &device structure
156 * @card_model: Bus-specific card model ID used to filter firmware table
158 * @fw_table: Table of firmware file names and device model numbers
159 * terminated by an entry with a NULL helper name
160 * @helper: On success, the helper firmware; caller must free
161 * @mainfw: On success, the main firmware; caller must free
163 * Deprecated: use lbs_get_firmware_async() instead.
165 * returns: 0 on success, non-zero on failure
167 int lbs_get_firmware(struct device
*dev
, u32 card_model
,
168 const struct lbs_fw_table
*fw_table
,
169 const struct firmware
**helper
,
170 const struct firmware
**mainfw
)
172 const struct lbs_fw_table
*iter
;
175 BUG_ON(helper
== NULL
);
176 BUG_ON(mainfw
== NULL
);
178 /* Search for firmware to use from the table. */
180 while (iter
&& iter
->helper
) {
181 if (iter
->model
!= card_model
)
184 if (*helper
== NULL
) {
185 ret
= request_firmware(helper
, iter
->helper
, dev
);
189 /* If the device has one-stage firmware (ie cf8305) and
190 * we've got it then we don't need to bother with the
193 if (iter
->fwname
== NULL
)
197 if (*mainfw
== NULL
) {
198 ret
= request_firmware(mainfw
, iter
->fwname
, dev
);
200 /* Clear the helper to ensure we don't have
201 * mismatched firmware pairs.
203 release_firmware(*helper
);
208 if (*helper
&& *mainfw
)
216 release_firmware(*helper
);
218 release_firmware(*mainfw
);
223 EXPORT_SYMBOL_GPL(lbs_get_firmware
);
This page took 0.036054 seconds and 6 git commands to generate.