[linux.git] / drivers / uwb / reset.c

/*
 * Ultra Wide Band
 * UWB basic command support and radio reset
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <[email protected]>
 *
 * 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 <linux/slab.h>
#include <linux/delay.h>
#include <linux/export.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 received",
	"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);
		uwb_dev_unlock(&rc->uwb_dev);
		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 < 0) {
		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. Wait a bit
	   to avoid reset loops during probe() or remove(). */
	msleep(1000);
	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);

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

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