xref: /linux/drivers/net/wireless/marvell/libertas/firmware.c (revision 0883c2c06fb5bcf5b9e008270827e63c09a88c1e)
1 /*
2  * Firmware loading and handling functions.
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 
12 static void load_next_firmware_from_table(struct lbs_private *private);
13 
14 static 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 	/* User must free helper/mainfw */
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 
30 static 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 
44 static void main_firmware_cb(const struct firmware *firmware, void *context)
45 {
46 	struct lbs_private *priv = context;
47 
48 	if (!firmware) {
49 		/* Failed to find firmware: try next table entry */
50 		load_next_firmware_from_table(priv);
51 		return;
52 	}
53 
54 	/* Firmware found! */
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;
59 	}
60 	release_firmware (firmware);
61 }
62 
63 static void helper_firmware_cb(const struct firmware *firmware, void *context)
64 {
65 	struct lbs_private *priv = context;
66 
67 	if (!firmware) {
68 		/* Failed to find firmware: try next table entry */
69 		load_next_firmware_from_table(priv);
70 		return;
71 	}
72 
73 	/* Firmware found! */
74 	if (priv->fw_iter->fwname) {
75 		priv->helper_fw = firmware;
76 		do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
77 	} else {
78 		/* No main firmware needed for this helper --> success! */
79 		lbs_fw_loaded(priv, 0, firmware, NULL);
80 	}
81 }
82 
83 static void load_next_firmware_from_table(struct lbs_private *priv)
84 {
85 	const struct lbs_fw_table *iter;
86 
87 	if (!priv->fw_iter)
88 		iter = priv->fw_table;
89 	else
90 		iter = ++priv->fw_iter;
91 
92 	if (priv->helper_fw) {
93 		release_firmware(priv->helper_fw);
94 		priv->helper_fw = NULL;
95 	}
96 
97 next:
98 	if (!iter->helper) {
99 		/* End of table hit. */
100 		lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
101 		return;
102 	}
103 
104 	if (iter->model != priv->fw_model) {
105 		iter++;
106 		goto next;
107 	}
108 
109 	priv->fw_iter = iter;
110 	do_load_firmware(priv, iter->helper, helper_firmware_cb);
111 }
112 
113 void lbs_wait_for_firmware_load(struct lbs_private *priv)
114 {
115 	wait_event(priv->fw_waitq, priv->fw_callback == NULL);
116 }
117 
118 /**
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.
121  *
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
125  *		elements
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.
129  */
130 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
131 			    u32 card_model, const struct lbs_fw_table *fw_table,
132 			    lbs_fw_cb callback)
133 {
134 	unsigned long flags;
135 
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);
140 		return -EBUSY;
141 	}
142 
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);
149 
150 	lbs_deb_fw("Starting async firmware load\n");
151 	load_next_firmware_from_table(priv);
152 	return 0;
153 }
154 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
155 
156 /**
157  *  lbs_get_firmware - Retrieves two-stage firmware
158  *
159  *  @dev:     	A pointer to &device structure
160  *  @card_model: Bus-specific card model ID used to filter firmware table
161  *		elements
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
166  *
167  * Deprecated: use lbs_get_firmware_async() instead.
168  *
169  *  returns:		0 on success, non-zero on failure
170  */
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)
175 {
176 	const struct lbs_fw_table *iter;
177 	int ret;
178 
179 	BUG_ON(helper == NULL);
180 	BUG_ON(mainfw == NULL);
181 
182 	/* Search for firmware to use from the table. */
183 	iter = fw_table;
184 	while (iter && iter->helper) {
185 		if (iter->model != card_model)
186 			goto next;
187 
188 		if (*helper == NULL) {
189 			ret = request_firmware(helper, iter->helper, dev);
190 			if (ret)
191 				goto next;
192 
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
195 			 * main firmware.
196 			 */
197 			if (iter->fwname == NULL)
198 				return 0;
199 		}
200 
201 		if (*mainfw == NULL) {
202 			ret = request_firmware(mainfw, iter->fwname, dev);
203 			if (ret) {
204 				/* Clear the helper to ensure we don't have
205 				 * mismatched firmware pairs.
206 				 */
207 				release_firmware(*helper);
208 				*helper = NULL;
209 			}
210 		}
211 
212 		if (*helper && *mainfw)
213 			return 0;
214 
215   next:
216 		iter++;
217 	}
218 
219 	/* Failed */
220 	release_firmware(*helper);
221 	*helper = NULL;
222 	release_firmware(*mainfw);
223 	*mainfw = NULL;
224 
225 	return -ENOENT;
226 }
227 EXPORT_SYMBOL_GPL(lbs_get_firmware);
228