[linux-2.6-block.git] / drivers / uwb / reset.c

/*
 * Ultra Wide Band
 * UWB basic command support and radio reset
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 *
 * FIXME:
 *
 *  - docs
 *
 *  - Now we are serializing (using the uwb_dev->mutex) the command
 *    execution; it should be parallelized as much as possible some
 *    day.
 */
#include <linux/kernel.h>
#include <linux/err.h>

#include "uwb-internal.h"

/**
 * Command result codes (WUSB1.0[T8-69])
 */
static
const char *__strerror[] = {
	"success",
	"failure",
	"hardware failure",
	"no more slots",
	"beacon is too large",
	"invalid parameter",
	"unsupported power level",
	"time out (wa) or invalid ie data (whci)",
	"beacon size exceeded",
	"cancelled",
	"invalid state",
	"invalid size",
	"ack not recieved",
	"no more asie notification",
};


/** Return a string matching the given error code */
const char *uwb_rc_strerror(unsigned code)
{
	if (code == 255)
		return "time out";
	if (code >= ARRAY_SIZE(__strerror))
		return "unknown error";
	return __strerror[code];
}

int uwb_rc_cmd_async(struct uwb_rc *rc, const char *cmd_name,
		     struct uwb_rccb *cmd, size_t cmd_size,
		     u8 expected_type, u16 expected_event,
		     uwb_rc_cmd_cb_f cb, void *arg)
{
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_rc_neh *neh;
	int needtofree = 0;
	int result;

	uwb_dev_lock(&rc->uwb_dev);	/* Protect against rc->priv being removed */
	if (rc->priv == NULL) {
		uwb_dev_unlock(&rc->uwb_dev);
		return -ESHUTDOWN;
	}

	if (rc->filter_cmd) {
		needtofree = rc->filter_cmd(rc, &cmd, &cmd_size);
		if (needtofree < 0 && needtofree != -ENOANO) {
			dev_err(dev, "%s: filter error: %d\n",
				cmd_name, needtofree);
			uwb_dev_unlock(&rc->uwb_dev);
			return needtofree;
		}
	}

	neh = uwb_rc_neh_add(rc, cmd, expected_type, expected_event, cb, arg);
	if (IS_ERR(neh)) {
		result = PTR_ERR(neh);
		goto out;
	}

	result = rc->cmd(rc, cmd, cmd_size);
	uwb_dev_unlock(&rc->uwb_dev);
	if (result < 0)
		uwb_rc_neh_rm(rc, neh);
	else
		uwb_rc_neh_arm(rc, neh);
	uwb_rc_neh_put(neh);
out:
	if (needtofree == 1)
		kfree(cmd);
	return result < 0 ? result : 0;
}
EXPORT_SYMBOL_GPL(uwb_rc_cmd_async);

struct uwb_rc_cmd_done_params {
	struct completion completion;
	struct uwb_rceb *reply;
	ssize_t reply_size;
};

static void uwb_rc_cmd_done(struct uwb_rc *rc, void *arg,
			    struct uwb_rceb *reply, ssize_t reply_size)
{
	struct uwb_rc_cmd_done_params *p = (struct uwb_rc_cmd_done_params *)arg;

	if (reply_size > 0) {
		if (p->reply)
			reply_size = min(p->reply_size, reply_size);
		else
			p->reply = kmalloc(reply_size, GFP_ATOMIC);

		if (p->reply)
			memcpy(p->reply, reply, reply_size);
		else
			reply_size = -ENOMEM;
	}
	p->reply_size = reply_size;
	complete(&p->completion);
}


/**
 * Generic function for issuing commands to the Radio Control Interface
 *
 * @rc:       UWB Radio Control descriptor
 * @cmd_name: Name of the command being issued (for error messages)
 * @cmd:      Pointer to rccb structure containing the command;
 *            normally you embed this structure as the first member of
 *            the full command structure.
 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 * @reply:    Pointer to where to store the reply
 * @reply_size: @reply's size
 * @expected_type: Expected type in the return event
 * @expected_event: Expected event code in the return event
 * @preply:   Here a pointer to where the event data is received will
 *            be stored. Once done with the data, free with kfree().
 *
 * This function is generic; it works for commands that return a fixed
 * and known size or for commands that return a variable amount of data.
 *
 * If a buffer is provided, that is used, although it could be chopped
 * to the maximum size of the buffer. If the buffer is NULL, then one
 * be allocated in *preply with the whole contents of the reply.
 *
 * @rc needs to be referenced
 */
static
ssize_t __uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name,
		     struct uwb_rccb *cmd, size_t cmd_size,
		     struct uwb_rceb *reply, size_t reply_size,
		     u8 expected_type, u16 expected_event,
		     struct uwb_rceb **preply)
{
	ssize_t result = 0;
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_rc_cmd_done_params params;

	init_completion(&params.completion);
	params.reply = reply;
	params.reply_size = reply_size;

	result = uwb_rc_cmd_async(rc, cmd_name, cmd, cmd_size,
				  expected_type, expected_event,
				  uwb_rc_cmd_done, &params);
	if (result)
		return result;

	wait_for_completion(&params.completion);

	if (preply)
		*preply = params.reply;

	if (params.reply_size < 0)
		dev_err(dev, "%s: confirmation event 0x%02x/%04x/%02x "
			"reception failed: %d\n", cmd_name,
			expected_type, expected_event, cmd->bCommandContext,
			(int)params.reply_size);
	return params.reply_size;
}


/**
 * Generic function for issuing commands to the Radio Control Interface
 *
 * @rc:       UWB Radio Control descriptor
 * @cmd_name: Name of the command being issued (for error messages)
 * @cmd:      Pointer to rccb structure containing the command;
 *            normally you embed this structure as the first member of
 *            the full command structure.
 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 * @reply:    Pointer to the beginning of the confirmation event
 *            buffer. Normally bigger than an 'struct hwarc_rceb'.
 *            You need to fill out reply->bEventType and reply->wEvent (in
 *            cpu order) as the function will use them to verify the
 *            confirmation event.
 * @reply_size: Size of the reply buffer
 *
 * The function checks that the length returned in the reply is at
 * least as big as @reply_size; if not, it will be deemed an error and
 * -EIO returned.
 *
 * @rc needs to be referenced
 */
ssize_t uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name,
		   struct uwb_rccb *cmd, size_t cmd_size,
		   struct uwb_rceb *reply, size_t reply_size)
{
	struct device *dev = &rc->uwb_dev.dev;
	ssize_t result;

	result = __uwb_rc_cmd(rc, cmd_name,
			      cmd, cmd_size, reply, reply_size,
			      reply->bEventType, reply->wEvent, NULL);

	if (result > 0 && result < reply_size) {
		dev_err(dev, "%s: not enough data returned for decoding reply "
			"(%zu bytes received vs at least %zu needed)\n",
			cmd_name, result, reply_size);
		result = -EIO;
	}
	return result;
}
EXPORT_SYMBOL_GPL(uwb_rc_cmd);


/**
 * Generic function for issuing commands to the Radio Control
 * Interface that return an unknown amount of data
 *
 * @rc:       UWB Radio Control descriptor
 * @cmd_name: Name of the command being issued (for error messages)
 * @cmd:      Pointer to rccb structure containing the command;
 *            normally you embed this structure as the first member of
 *            the full command structure.
 * @cmd_size: Size of the whole command buffer pointed to by @cmd.
 * @expected_type: Expected type in the return event
 * @expected_event: Expected event code in the return event
 * @preply:   Here a pointer to where the event data is received will
 *            be stored. Once done with the data, free with kfree().
 *
 * The function checks that the length returned in the reply is at
 * least as big as a 'struct uwb_rceb *'; if not, it will be deemed an
 * error and -EIO returned.
 *
 * @rc needs to be referenced
 */
ssize_t uwb_rc_vcmd(struct uwb_rc *rc, const char *cmd_name,
		    struct uwb_rccb *cmd, size_t cmd_size,
		    u8 expected_type, u16 expected_event,
		    struct uwb_rceb **preply)
{
	return __uwb_rc_cmd(rc, cmd_name, cmd, cmd_size, NULL, 0,
			    expected_type, expected_event, preply);
}
EXPORT_SYMBOL_GPL(uwb_rc_vcmd);


/**
 * Reset a UWB Host Controller (and all radio settings)
 *
 * @rc:      Host Controller descriptor
 * @returns: 0 if ok, < 0 errno code on error
 *
 * We put the command on kmalloc'ed memory as some arches cannot do
 * USB from the stack. The reply event is copied from an stage buffer,
 * so it can be in the stack. See WUSB1.0[8.6.2.4] for more details.
 */
int uwb_rc_reset(struct uwb_rc *rc)
{
	int result = -ENOMEM;
	struct uwb_rc_evt_confirm reply;
	struct uwb_rccb *cmd;
	size_t cmd_size = sizeof(*cmd);

	mutex_lock(&rc->uwb_dev.mutex);
	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		goto error_kzalloc;
	cmd->bCommandType = UWB_RC_CET_GENERAL;
	cmd->wCommand = cpu_to_le16(UWB_RC_CMD_RESET);
	reply.rceb.bEventType = UWB_RC_CET_GENERAL;
	reply.rceb.wEvent = UWB_RC_CMD_RESET;
	result = uwb_rc_cmd(rc, "RESET", cmd, cmd_size,
			    &reply.rceb, sizeof(reply));
	if (result < 0)
		goto error_cmd;
	if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
		dev_err(&rc->uwb_dev.dev,
			"RESET: command execution failed: %s (%d)\n",
			uwb_rc_strerror(reply.bResultCode), reply.bResultCode);
		result = -EIO;
	}
error_cmd:
	kfree(cmd);
error_kzalloc:
	mutex_unlock(&rc->uwb_dev.mutex);
	return result;
}

int uwbd_msg_handle_reset(struct uwb_event *evt)
{
	struct uwb_rc *rc = evt->rc;
	int ret;

	dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
	ret = rc->reset(rc);
	if (ret) {
		dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
		goto error;
	}
	return 0;
error:
	/* Nothing can be done except try the reset again. */
	uwb_rc_reset_all(rc);
	return ret;
}

/**
 * uwb_rc_reset_all - request a reset of the radio controller and PALs
 * @rc: the radio controller of the hardware device to be reset.
 *
 * The full hardware reset of the radio controller and all the PALs
 * will be scheduled.
 */
void uwb_rc_reset_all(struct uwb_rc *rc)
{
	struct uwb_event *evt;

	evt = kzalloc(sizeof(struct uwb_event), GFP_ATOMIC);
	if (unlikely(evt == NULL))
		return;

	evt->rc = __uwb_rc_get(rc);	/* will be put by uwbd's uwbd_event_handle() */
	evt->ts_jiffies = jiffies;
	evt->type = UWB_EVT_TYPE_MSG;
	evt->message = UWB_EVT_MSG_RESET;

	uwbd_event_queue(evt);
}
EXPORT_SYMBOL_GPL(uwb_rc_reset_all);

void uwb_rc_pre_reset(struct uwb_rc *rc)
{
	rc->stop(rc);
	uwbd_flush(rc);

	uwb_radio_reset_state(rc);
	uwb_rsv_remove_all(rc);
}
EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);

void uwb_rc_post_reset(struct uwb_rc *rc)
{
	int ret;

	ret = rc->start(rc);
	if (ret)
		goto error;
	ret = uwb_rc_mac_addr_set(rc, &rc->uwb_dev.mac_addr);
	if (ret)
		goto error;
	ret = uwb_rc_dev_addr_set(rc, &rc->uwb_dev.dev_addr);
	if (ret)
		goto error;
	return;
error:
	/* Nothing can be done except try the reset again. */
	uwb_rc_reset_all(rc);
}
EXPORT_SYMBOL_GPL(uwb_rc_post_reset);
Commit	Line	Data
0612edfd IPG	1	/*
	2	* Ultra Wide Band
	3	* UWB basic command support and radio reset
	4	*
	5	* Copyright (C) 2005-2006 Intel Corporation
	6	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License version
	10	* 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	* 02110-1301, USA.
	21	*
	22	*
	23	* FIXME:
	24	*
	25	* - docs
	26	*
	27	* - Now we are serializing (using the uwb_dev->mutex) the command
	28	* execution; it should be parallelized as much as possible some
	29	* day.
	30	*/
	31	#include <linux/kernel.h>
	32	#include <linux/err.h>
	33
	34	#include "uwb-internal.h"
0612edfd IPG	35
	36	/**
	37	* Command result codes (WUSB1.0[T8-69])
	38	*/
	39	static
	40	const char *__strerror[] = {
	41	"success",
	42	"failure",
	43	"hardware failure",
	44	"no more slots",
	45	"beacon is too large",
	46	"invalid parameter",
	47	"unsupported power level",
	48	"time out (wa) or invalid ie data (whci)",
	49	"beacon size exceeded",
	50	"cancelled",
	51	"invalid state",
	52	"invalid size",
	53	"ack not recieved",
	54	"no more asie notification",
	55	};
	56
	57
	58	/** Return a string matching the given error code */
	59	const char *uwb_rc_strerror(unsigned code)
	60	{
	61	if (code == 255)
	62	return "time out";
	63	if (code >= ARRAY_SIZE(__strerror))
	64	return "unknown error";
	65	return __strerror[code];
	66	}
	67
	68	int uwb_rc_cmd_async(struct uwb_rc rc, const char cmd_name,
	69	struct uwb_rccb *cmd, size_t cmd_size,
	70	u8 expected_type, u16 expected_event,
	71	uwb_rc_cmd_cb_f cb, void *arg)
	72	{
	73	struct device *dev = &rc->uwb_dev.dev;
	74	struct uwb_rc_neh *neh;
	75	int needtofree = 0;
	76	int result;
	77
	78	uwb_dev_lock(&rc->uwb_dev); /* Protect against rc->priv being removed */
	79	if (rc->priv == NULL) {
	80	uwb_dev_unlock(&rc->uwb_dev);
	81	return -ESHUTDOWN;
	82	}
	83
	84	if (rc->filter_cmd) {
	85	needtofree = rc->filter_cmd(rc, &cmd, &cmd_size);
	86	if (needtofree < 0 && needtofree != -ENOANO) {
	87	dev_err(dev, "%s: filter error: %d\n",
	88	cmd_name, needtofree);
	89	uwb_dev_unlock(&rc->uwb_dev);
	90	return needtofree;
	91	}
	92	}
	93
	94	neh = uwb_rc_neh_add(rc, cmd, expected_type, expected_event, cb, arg);
	95	if (IS_ERR(neh)) {
	96	result = PTR_ERR(neh);
	97	goto out;
	98	}
99
100	result = rc->cmd(rc, cmd, cmd_size);
101	uwb_dev_unlock(&rc->uwb_dev);
102	if (result < 0)
103	uwb_rc_neh_rm(rc, neh);
104	else
105	uwb_rc_neh_arm(rc, neh);
106	uwb_rc_neh_put(neh);
107	out:
108	if (needtofree == 1)
109	kfree(cmd);
110	return result < 0 ? result : 0;
111	}
112	EXPORT_SYMBOL_GPL(uwb_rc_cmd_async);
113
114	struct uwb_rc_cmd_done_params {
115	struct completion completion;
116	struct uwb_rceb *reply;
117	ssize_t reply_size;
118	};
119
120	static void uwb_rc_cmd_done(struct uwb_rc rc, void arg,
121	struct uwb_rceb *reply, ssize_t reply_size)
122	{
123	struct uwb_rc_cmd_done_params p = (struct uwb_rc_cmd_done_params )arg;
124
125	if (reply_size > 0) {
126	if (p->reply)
127	reply_size = min(p->reply_size, reply_size);
128	else
129	p->reply = kmalloc(reply_size, GFP_ATOMIC);
130
131	if (p->reply)
132	memcpy(p->reply, reply, reply_size);
133	else
134	reply_size = -ENOMEM;
135	}
136	p->reply_size = reply_size;
137	complete(&p->completion);
138	}
139
140
141	/**
142	* Generic function for issuing commands to the Radio Control Interface
143	*
144	* @rc: UWB Radio Control descriptor
145	* @cmd_name: Name of the command being issued (for error messages)
146	* @cmd: Pointer to rccb structure containing the command;
147	* normally you embed this structure as the first member of
148	* the full command structure.
149	* @cmd_size: Size of the whole command buffer pointed to by @cmd.
150	* @reply: Pointer to where to store the reply
151	* @reply_size: @reply's size
152	* @expected_type: Expected type in the return event
153	* @expected_event: Expected event code in the return event
154	* @preply: Here a pointer to where the event data is received will
155	* be stored. Once done with the data, free with kfree().
156	*
157	* This function is generic; it works for commands that return a fixed
158	* and known size or for commands that return a variable amount of data.
159	*
160	* If a buffer is provided, that is used, although it could be chopped
161	* to the maximum size of the buffer. If the buffer is NULL, then one
162	* be allocated in *preply with the whole contents of the reply.
163	*
164	* @rc needs to be referenced
165	*/
166	static
167	ssize_t __uwb_rc_cmd(struct uwb_rc rc, const char cmd_name,
168	struct uwb_rccb *cmd, size_t cmd_size,
169	struct uwb_rceb *reply, size_t reply_size,
170	u8 expected_type, u16 expected_event,
171	struct uwb_rceb **preply)
172	{
173	ssize_t result = 0;
174	struct device *dev = &rc->uwb_dev.dev;
175	struct uwb_rc_cmd_done_params params;
176
177	init_completion(&params.completion);
178	params.reply = reply;
179	params.reply_size = reply_size;
180
181	result = uwb_rc_cmd_async(rc, cmd_name, cmd, cmd_size,
182	expected_type, expected_event,
183	uwb_rc_cmd_done, &params);
184	if (result)
185	return result;
186
187	wait_for_completion(&params.completion);
188
189	if (preply)
190	*preply = params.reply;
191
192	if (params.reply_size < 0)
193	dev_err(dev, "%s: confirmation event 0x%02x/%04x/%02x "
194	"reception failed: %d\n", cmd_name,
195	expected_type, expected_event, cmd->bCommandContext,
196	(int)params.reply_size);
197	return params.reply_size;
198	}
199
200
201	/**
202	* Generic function for issuing commands to the Radio Control Interface
203	*
204	* @rc: UWB Radio Control descriptor
205	* @cmd_name: Name of the command being issued (for error messages)
206	* @cmd: Pointer to rccb structure containing the command;
207	* normally you embed this structure as the first member of
208	* the full command structure.
209	* @cmd_size: Size of the whole command buffer pointed to by @cmd.
210	* @reply: Pointer to the beginning of the confirmation event
211	* buffer. Normally bigger than an 'struct hwarc_rceb'.
212	* You need to fill out reply->bEventType and reply->wEvent (in
213	* cpu order) as the function will use them to verify the
214	* confirmation event.
215	* @reply_size: Size of the reply buffer
216	*
217	* The function checks that the length returned in the reply is at
218	* least as big as @reply_size; if not, it will be deemed an error and
219	* -EIO returned.
220	*
221	* @rc needs to be referenced
222	*/
223	ssize_t uwb_rc_cmd(struct uwb_rc rc, const char cmd_name,
224	struct uwb_rccb *cmd, size_t cmd_size,
225	struct uwb_rceb *reply, size_t reply_size)
226	{
227	struct device *dev = &rc->uwb_dev.dev;
228	ssize_t result;
229
230	result = __uwb_rc_cmd(rc, cmd_name,
231	cmd, cmd_size, reply, reply_size,
232	reply->bEventType, reply->wEvent, NULL);
233
234	if (result > 0 && result < reply_size) {
235	dev_err(dev, "%s: not enough data returned for decoding reply "
236	"(%zu bytes received vs at least %zu needed)\n",
237	cmd_name, result, reply_size);
238	result = -EIO;
239	}
240	return result;
241	}
242	EXPORT_SYMBOL_GPL(uwb_rc_cmd);
243
244
245	/**
246	* Generic function for issuing commands to the Radio Control
247	* Interface that return an unknown amount of data
248	*
249	* @rc: UWB Radio Control descriptor
250	* @cmd_name: Name of the command being issued (for error messages)
251	* @cmd: Pointer to rccb structure containing the command;
252	* normally you embed this structure as the first member of
253	* the full command structure.
254	* @cmd_size: Size of the whole command buffer pointed to by @cmd.
255	* @expected_type: Expected type in the return event
256	* @expected_event: Expected event code in the return event
257	* @preply: Here a pointer to where the event data is received will
258	* be stored. Once done with the data, free with kfree().
259	*
260	* The function checks that the length returned in the reply is at
261	* least as big as a 'struct uwb_rceb *'; if not, it will be deemed an
262	* error and -EIO returned.
263	*
264	* @rc needs to be referenced
265	*/
266	ssize_t uwb_rc_vcmd(struct uwb_rc rc, const char cmd_name,
267	struct uwb_rccb *cmd, size_t cmd_size,
268	u8 expected_type, u16 expected_event,
269	struct uwb_rceb **preply)
270	{
271	return __uwb_rc_cmd(rc, cmd_name, cmd, cmd_size, NULL, 0,
272	expected_type, expected_event, preply);
273	}
274	EXPORT_SYMBOL_GPL(uwb_rc_vcmd);
275
276
277	/**
278	* Reset a UWB Host Controller (and all radio settings)
279	*
280	* @rc: Host Controller descriptor
281	* @returns: 0 if ok, < 0 errno code on error
282	*
283	* We put the command on kmalloc'ed memory as some arches cannot do
284	* USB from the stack. The reply event is copied from an stage buffer,
285	* so it can be in the stack. See WUSB1.0[8.6.2.4] for more details.
286	*/
287	int uwb_rc_reset(struct uwb_rc *rc)
288	{
289	int result = -ENOMEM;
290	struct uwb_rc_evt_confirm reply;
291	struct uwb_rccb *cmd;
292	size_t cmd_size = sizeof(*cmd);
293
294	mutex_lock(&rc->uwb_dev.mutex);
295	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
296	if (cmd == NULL)
297	goto error_kzalloc;
298	cmd->bCommandType = UWB_RC_CET_GENERAL;
299	cmd->wCommand = cpu_to_le16(UWB_RC_CMD_RESET);
300	reply.rceb.bEventType = UWB_RC_CET_GENERAL;
301	reply.rceb.wEvent = UWB_RC_CMD_RESET;
302	result = uwb_rc_cmd(rc, "RESET", cmd, cmd_size,
303	&reply.rceb, sizeof(reply));
304	if (result < 0)
305	goto error_cmd;
306	if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
307	dev_err(&rc->uwb_dev.dev,
308	"RESET: command execution failed: %s (%d)\n",
309	uwb_rc_strerror(reply.bResultCode), reply.bResultCode);
310	result = -EIO;
311	}
312	error_cmd:
313	kfree(cmd);
314	error_kzalloc:
315	mutex_unlock(&rc->uwb_dev.mutex);
316	return result;
317	}
318
319	int uwbd_msg_handle_reset(struct uwb_event *evt)
320	{
321	struct uwb_rc *rc = evt->rc;
322	int ret;
323
0612edfd IPG	324	dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
0612edfd IPG	325	ret = rc->reset(rc);
307ba6dd	326	if (ret) {
0612edfd	327	dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
307ba6dd DV	328	goto error;
	329	}
	330	return 0;
	331	error:
	332	/* Nothing can be done except try the reset again. */
	333	uwb_rc_reset_all(rc);
0612edfd IPG	334	return ret;
	335	}
	336
	337	/**
	338	* uwb_rc_reset_all - request a reset of the radio controller and PALs
	339	* @rc: the radio controller of the hardware device to be reset.
	340	*
	341	* The full hardware reset of the radio controller and all the PALs
	342	* will be scheduled.
	343	*/
	344	void uwb_rc_reset_all(struct uwb_rc *rc)
	345	{
	346	struct uwb_event *evt;
	347
	348	evt = kzalloc(sizeof(struct uwb_event), GFP_ATOMIC);
	349	if (unlikely(evt == NULL))
	350	return;
	351
	352	evt->rc = __uwb_rc_get(rc); /* will be put by uwbd's uwbd_event_handle() */
	353	evt->ts_jiffies = jiffies;
	354	evt->type = UWB_EVT_TYPE_MSG;
	355	evt->message = UWB_EVT_MSG_RESET;
	356
	357	uwbd_event_queue(evt);
	358	}
	359	EXPORT_SYMBOL_GPL(uwb_rc_reset_all);
307ba6dd DV	360
	361	void uwb_rc_pre_reset(struct uwb_rc *rc)
	362	{
	363	rc->stop(rc);
	364	uwbd_flush(rc);
	365
6fae35f9	366	uwb_radio_reset_state(rc);
307ba6dd DV	367	uwb_rsv_remove_all(rc);
	368	}
	369	EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);
	370
	371	void uwb_rc_post_reset(struct uwb_rc *rc)
	372	{
	373	int ret;
	374
	375	ret = rc->start(rc);
	376	if (ret)
	377	goto error;
	378	ret = uwb_rc_mac_addr_set(rc, &rc->uwb_dev.mac_addr);
	379	if (ret)
	380	goto error;
	381	ret = uwb_rc_dev_addr_set(rc, &rc->uwb_dev.dev_addr);
	382	if (ret)
	383	goto error;
	384	return;
	385	error:
	386	/* Nothing can be done except try the reset again. */
	387	uwb_rc_reset_all(rc);
	388	}
	389	EXPORT_SYMBOL_GPL(uwb_rc_post_reset);