1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Firmware loading and handling functions.
4  */
5 
6 #include <linux/sched.h>
7 #include <linux/firmware.h>
8 #include <linux/module.h>
9 
10 #include "dev.h"
11 #include "decl.h"
12 
13 static void load_next_firmware_from_table(struct lbs_private *private);
14 
15 static void lbs_fw_loaded(struct lbs_private *priv, int ret,
16 	const struct firmware *helper, const struct firmware *mainfw)
17 {
18 	unsigned long flags;
19 
20 	lbs_deb_fw("firmware load complete, code %d\n", ret);
21 
22 	/* User must free helper/mainfw */
23 	priv->fw_callback(priv, ret, helper, mainfw);
24 
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);
29 }
30 
31 static void do_load_firmware(struct lbs_private *priv, const char *name,
32 	void (*cb)(const struct firmware *fw, void *context))
33 {
34 	int ret;
35 
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);
39 	if (ret) {
40 		lbs_deb_fw("request_firmware_nowait error %d\n", ret);
41 		lbs_fw_loaded(priv, ret, NULL, NULL);
42 	}
43 }
44 
45 static void main_firmware_cb(const struct firmware *firmware, void *context)
46 {
47 	struct lbs_private *priv = context;
48 
49 	if (!firmware) {
50 		/* Failed to find firmware: try next table entry */
51 		load_next_firmware_from_table(priv);
52 		return;
53 	}
54 
55 	/* Firmware found! */
56 	lbs_fw_loaded(priv, 0, priv->helper_fw, firmware);
57 	if (priv->helper_fw) {
58 		release_firmware (priv->helper_fw);
59 		priv->helper_fw = NULL;
60 	}
61 	release_firmware (firmware);
62 }
63 
64 static void helper_firmware_cb(const struct firmware *firmware, void *context)
65 {
66 	struct lbs_private *priv = context;
67 
68 	if (!firmware) {
69 		/* Failed to find firmware: try next table entry */
70 		load_next_firmware_from_table(priv);
71 		return;
72 	}
73 
74 	/* Firmware found! */
75 	if (priv->fw_iter->fwname) {
76 		priv->helper_fw = firmware;
77 		do_load_firmware(priv, priv->fw_iter->fwname, main_firmware_cb);
78 	} else {
79 		/* No main firmware needed for this helper --> success! */
80 		lbs_fw_loaded(priv, 0, firmware, NULL);
81 	}
82 }
83 
84 static void load_next_firmware_from_table(struct lbs_private *priv)
85 {
86 	const struct lbs_fw_table *iter;
87 
88 	if (!priv->fw_iter)
89 		iter = priv->fw_table;
90 	else
91 		iter = ++priv->fw_iter;
92 
93 	if (priv->helper_fw) {
94 		release_firmware(priv->helper_fw);
95 		priv->helper_fw = NULL;
96 	}
97 
98 next:
99 	if (!iter->helper) {
100 		/* End of table hit. */
101 		lbs_fw_loaded(priv, -ENOENT, NULL, NULL);
102 		return;
103 	}
104 
105 	if (iter->model != priv->fw_model) {
106 		iter++;
107 		goto next;
108 	}
109 
110 	priv->fw_iter = iter;
111 	do_load_firmware(priv, iter->helper, helper_firmware_cb);
112 }
113 
114 void lbs_wait_for_firmware_load(struct lbs_private *priv)
115 {
116 	wait_event(priv->fw_waitq, priv->fw_callback == NULL);
117 }
118 
119 /**
120  *  lbs_get_firmware_async - Retrieves firmware asynchronously. Can load
121  *  either a helper firmware and a main firmware (2-stage), or just the helper.
122  *
123  *  @priv:      Pointer to lbs_private instance
124  *  @device:   	A pointer to &device structure
125  *  @card_model: Bus-specific card model ID used to filter firmware table
126  *		elements
127  *  @fw_table:	Table of firmware file names and device model numbers
128  *		terminated by an entry with a NULL helper name
129  *  @callback:	User callback to invoke when firmware load succeeds or fails.
130  */
131 int lbs_get_firmware_async(struct lbs_private *priv, struct device *device,
132 			    u32 card_model, const struct lbs_fw_table *fw_table,
133 			    lbs_fw_cb callback)
134 {
135 	unsigned long flags;
136 
137 	spin_lock_irqsave(&priv->driver_lock, flags);
138 	if (priv->fw_callback) {
139 		lbs_deb_fw("firmware load already in progress\n");
140 		spin_unlock_irqrestore(&priv->driver_lock, flags);
141 		return -EBUSY;
142 	}
143 
144 	priv->fw_device = device;
145 	priv->fw_callback = callback;
146 	priv->fw_table = fw_table;
147 	priv->fw_iter = NULL;
148 	priv->fw_model = card_model;
149 	spin_unlock_irqrestore(&priv->driver_lock, flags);
150 
151 	lbs_deb_fw("Starting async firmware load\n");
152 	load_next_firmware_from_table(priv);
153 	return 0;
154 }
155 EXPORT_SYMBOL_GPL(lbs_get_firmware_async);
156 
157 /**
158  *  lbs_get_firmware - Retrieves two-stage firmware
159  *
160  *  @dev:     	A pointer to &device structure
161  *  @card_model: Bus-specific card model ID used to filter firmware table
162  *		elements
163  *  @fw_table:	Table of firmware file names and device model numbers
164  *		terminated by an entry with a NULL helper name
165  *  @helper:	On success, the helper firmware; caller must free
166  *  @mainfw:	On success, the main firmware; caller must free
167  *
168  * Deprecated: use lbs_get_firmware_async() instead.
169  *
170  *  returns:		0 on success, non-zero on failure
171  */
172 int lbs_get_firmware(struct device *dev, u32 card_model,
173 			const struct lbs_fw_table *fw_table,
174 			const struct firmware **helper,
175 			const struct firmware **mainfw)
176 {
177 	const struct lbs_fw_table *iter;
178 	int ret;
179 
180 	BUG_ON(helper == NULL);
181 	BUG_ON(mainfw == NULL);
182 
183 	/* Search for firmware to use from the table. */
184 	iter = fw_table;
185 	while (iter && iter->helper) {
186 		if (iter->model != card_model)
187 			goto next;
188 
189 		if (*helper == NULL) {
190 			ret = request_firmware(helper, iter->helper, dev);
191 			if (ret)
192 				goto next;
193 
194 			/* If the device has one-stage firmware (ie cf8305) and
195 			 * we've got it then we don't need to bother with the
196 			 * main firmware.
197 			 */
198 			if (iter->fwname == NULL)
199 				return 0;
200 		}
201 
202 		if (*mainfw == NULL) {
203 			ret = request_firmware(mainfw, iter->fwname, dev);
204 			if (ret) {
205 				/* Clear the helper to ensure we don't have
206 				 * mismatched firmware pairs.
207 				 */
208 				release_firmware(*helper);
209 				*helper = NULL;
210 			}
211 		}
212 
213 		if (*helper && *mainfw)
214 			return 0;
215 
216   next:
217 		iter++;
218 	}
219 
220 	/* Failed */
221 	release_firmware(*helper);
222 	*helper = NULL;
223 	release_firmware(*mainfw);
224 	*mainfw = NULL;
225 
226 	return -ENOENT;
227 }
228 EXPORT_SYMBOL_GPL(lbs_get_firmware);
229