3 * UWB basic command support and radio reset
5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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
27 * - Now we are serializing (using the uwb_dev->mutex) the command
28 * execution; it should be parallelized as much as possible some
31 #include <linux/kernel.h>
32 #include <linux/err.h>
34 #include "uwb-internal.h"
36 #include <linux/uwb/debug.h>
39 * Command result codes (WUSB1.0[T8-69])
42 const char *__strerror[] = {
47 "beacon is too large",
49 "unsupported power level",
50 "time out (wa) or invalid ie data (whci)",
51 "beacon size exceeded",
56 "no more asie notification",
60 /** Return a string matching the given error code */
61 const char *uwb_rc_strerror(unsigned code)
65 if (code >= ARRAY_SIZE(__strerror))
66 return "unknown error";
67 return __strerror[code];
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)
75 struct device *dev = &rc->uwb_dev.dev;
76 struct uwb_rc_neh *neh;
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);
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);
96 neh = uwb_rc_neh_add(rc, cmd, expected_type, expected_event, cb, arg);
98 result = PTR_ERR(neh);
102 result = rc->cmd(rc, cmd, cmd_size);
103 uwb_dev_unlock(&rc->uwb_dev);
105 uwb_rc_neh_rm(rc, neh);
107 uwb_rc_neh_arm(rc, neh);
112 return result < 0 ? result : 0;
114 EXPORT_SYMBOL_GPL(uwb_rc_cmd_async);
116 struct uwb_rc_cmd_done_params {
117 struct completion completion;
118 struct uwb_rceb *reply;
122 static void uwb_rc_cmd_done(struct uwb_rc *rc, void *arg,
123 struct uwb_rceb *reply, ssize_t reply_size)
125 struct uwb_rc_cmd_done_params *p = (struct uwb_rc_cmd_done_params *)arg;
127 if (reply_size > 0) {
129 reply_size = min(p->reply_size, reply_size);
131 p->reply = kmalloc(reply_size, GFP_ATOMIC);
134 memcpy(p->reply, reply, reply_size);
136 reply_size = -ENOMEM;
138 p->reply_size = reply_size;
139 complete(&p->completion);
144 * Generic function for issuing commands to the Radio Control Interface
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().
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.
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.
166 * @rc needs to be referenced
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)
176 struct device *dev = &rc->uwb_dev.dev;
177 struct uwb_rc_cmd_done_params params;
179 init_completion(¶ms.completion);
180 params.reply = reply;
181 params.reply_size = reply_size;
183 result = uwb_rc_cmd_async(rc, cmd_name, cmd, cmd_size,
184 expected_type, expected_event,
185 uwb_rc_cmd_done, ¶ms);
189 wait_for_completion(¶ms.completion);
192 *preply = params.reply;
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;
204 * Generic function for issuing commands to the Radio Control Interface
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
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
223 * @rc needs to be referenced
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)
229 struct device *dev = &rc->uwb_dev.dev;
232 result = __uwb_rc_cmd(rc, cmd_name,
233 cmd, cmd_size, reply, reply_size,
234 reply->bEventType, reply->wEvent, NULL);
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);
244 EXPORT_SYMBOL_GPL(uwb_rc_cmd);
248 * Generic function for issuing commands to the Radio Control
249 * Interface that return an unknown amount of data
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().
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.
266 * @rc needs to be referenced
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)
273 return __uwb_rc_cmd(rc, cmd_name, cmd, cmd_size, NULL, 0,
274 expected_type, expected_event, preply);
276 EXPORT_SYMBOL_GPL(uwb_rc_vcmd);
280 * Reset a UWB Host Controller (and all radio settings)
282 * @rc: Host Controller descriptor
283 * @returns: 0 if ok, < 0 errno code on error
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.
289 int uwb_rc_reset(struct uwb_rc *rc)
291 int result = -ENOMEM;
292 struct uwb_rc_evt_confirm reply;
293 struct uwb_rccb *cmd;
294 size_t cmd_size = sizeof(*cmd);
296 mutex_lock(&rc->uwb_dev.mutex);
297 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
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));
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);
317 mutex_unlock(&rc->uwb_dev.mutex);
321 int uwbd_msg_handle_reset(struct uwb_event *evt)
323 struct uwb_rc *rc = evt->rc;
326 /* Need to prevent the RC hardware module going away while in
327 the rc->reset() call. */
328 if (!try_module_get(rc->owner))
331 dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
334 dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
336 module_put(rc->owner);
341 * uwb_rc_reset_all - request a reset of the radio controller and PALs
342 * @rc: the radio controller of the hardware device to be reset.
344 * The full hardware reset of the radio controller and all the PALs
347 void uwb_rc_reset_all(struct uwb_rc *rc)
349 struct uwb_event *evt;
351 evt = kzalloc(sizeof(struct uwb_event), GFP_ATOMIC);
352 if (unlikely(evt == NULL))
355 evt->rc = __uwb_rc_get(rc); /* will be put by uwbd's uwbd_event_handle() */
356 evt->ts_jiffies = jiffies;
357 evt->type = UWB_EVT_TYPE_MSG;
358 evt->message = UWB_EVT_MSG_RESET;
360 uwbd_event_queue(evt);
362 EXPORT_SYMBOL_GPL(uwb_rc_reset_all);