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