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
 12static void load_next_firmware_from_table(struct lbs_private *private);
 13
 14static 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
 30static 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
 44static 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
 63static 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
 83static 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
 97next:
 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
113void 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 */
130int 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}
154EXPORT_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 */
171int 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}
227EXPORT_SYMBOL_GPL(lbs_get_firmware);