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