2 * Firmware loading and handling functions.
5 #include <linux/sched.h>
6 #include <linux/firmware.h>
7 #include <linux/module.h>
12 static void load_next_firmware_from_table(struct lbs_private *private);
14 static void lbs_fw_loaded(struct lbs_private *priv, int ret,
15 const struct firmware *helper, const struct firmware *mainfw)
19 lbs_deb_fw("firmware load complete, code %d\n", ret);
21 /* User must free helper/mainfw */
22 priv->fw_callback(priv, ret, helper, mainfw);
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);
30 static void do_load_firmware(struct lbs_private *priv, const char *name,
31 void (*cb)(const struct firmware *fw, void *context))
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);
39 lbs_deb_fw("request_firmware_nowait error %d\n", ret);
40 lbs_fw_loaded(priv, ret, NULL, NULL);
44 static void main_firmware_cb(const struct firmware *firmware, void *context)
46 struct lbs_private *priv = context;
49 /* Failed to find firmware: try next table entry */
50 load_next_firmware_from_table(priv);
55 lbs_fw_loaded(priv, 0, priv->helper_fw, firmware);
56 if (priv->helper_fw) {
57 release_firmware (priv->helper_fw);
58 priv->helper_fw = NULL;
60 release_firmware (firmware);
63 static void helper_firmware_cb(const struct firmware *firmware, void *context)
65 struct lbs_private *priv = context;
68 /* Failed to find firmware: try next table entry */
69 load_next_firmware_from_table(priv);
74 if (priv->fw_iter->fwname) {
75 priv->helper_fw = firmware;
76 do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
78 /* No main firmware needed for this helper --> success! */
79 lbs_fw_loaded(priv, 0, firmware, NULL);
83 static void load_next_firmware_from_table(struct lbs_private *priv)
85 const struct lbs_fw_table *iter;
88 iter = priv->fw_table;
90 iter = ++priv->fw_iter;
92 if (priv->helper_fw) {
93 release_firmware(priv->helper_fw);
94 priv->helper_fw = NULL;
99 /* End of table hit. */
100 lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
104 if (iter->model != priv->fw_model) {
109 priv->fw_iter = iter;
110 do_load_firmware(priv, iter->helper, helper_firmware_cb);
113 void lbs_wait_for_firmware_load(struct lbs_private *priv)
115 wait_event(priv->fw_waitq, priv->fw_callback == NULL);
119 * lbs_get_firmware_async - Retrieves firmware asynchronously. Can load
120 * either a helper firmware and a main firmware (2-stage), or just the helper.
122 * @priv: Pointer to lbs_private instance
123 * @dev: A pointer to &device structure
124 * @card_model: Bus-specific card model ID used to filter firmware table
126 * @fw_table: Table of firmware file names and device model numbers
127 * terminated by an entry with a NULL helper name
128 * @callback: User callback to invoke when firmware load succeeds or fails.
130 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
131 u32 card_model, const struct lbs_fw_table *fw_table,
136 spin_lock_irqsave(&priv->driver_lock, flags);
137 if (priv->fw_callback) {
138 lbs_deb_fw("firmware load already in progress\n");
139 spin_unlock_irqrestore(&priv->driver_lock, flags);
143 priv->fw_device = device;
144 priv->fw_callback = callback;
145 priv->fw_table = fw_table;
146 priv->fw_iter = NULL;
147 priv->fw_model = card_model;
148 spin_unlock_irqrestore(&priv->driver_lock, flags);
150 lbs_deb_fw("Starting async firmware load\n");
151 load_next_firmware_from_table(priv);
154 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
157 * lbs_get_firmware - Retrieves two-stage firmware
159 * @dev: A pointer to &device structure
160 * @card_model: Bus-specific card model ID used to filter firmware table
162 * @fw_table: Table of firmware file names and device model numbers
163 * terminated by an entry with a NULL helper name
164 * @helper: On success, the helper firmware; caller must free
165 * @mainfw: On success, the main firmware; caller must free
167 * Deprecated: use lbs_get_firmware_async() instead.
169 * returns: 0 on success, non-zero on failure
171 int lbs_get_firmware(struct device *dev, u32 card_model,
172 const struct lbs_fw_table *fw_table,
173 const struct firmware **helper,
174 const struct firmware **mainfw)
176 const struct lbs_fw_table *iter;
179 BUG_ON(helper == NULL);
180 BUG_ON(mainfw == NULL);
182 /* Search for firmware to use from the table. */
184 while (iter && iter->helper) {
185 if (iter->model != card_model)
188 if (*helper == NULL) {
189 ret = request_firmware(helper, iter->helper, dev);
193 /* If the device has one-stage firmware (ie cf8305) and
194 * we've got it then we don't need to bother with the
197 if (iter->fwname == NULL)
201 if (*mainfw == NULL) {
202 ret = request_firmware(mainfw, iter->fwname, dev);
204 /* Clear the helper to ensure we don't have
205 * mismatched firmware pairs.
207 release_firmware(*helper);
212 if (*helper && *mainfw)
220 release_firmware(*helper);
222 release_firmware(*mainfw);
227 EXPORT_SYMBOL_GPL(lbs_get_firmware);