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);