Correct .gbs.conf settings
[platform/adaptation/renesas_rcar/renesas_kernel.git] / drivers / uwb / reset.c
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 #include <linux/slab.h>
34 #include <linux/delay.h>
35 #include <linux/export.h>
36
37 #include "uwb-internal.h"
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",
56         "ack not received",
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                 uwb_dev_unlock(&rc->uwb_dev);
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
328         dev_info(&rc->uwb_dev.dev, "resetting radio controller\n");
329         ret = rc->reset(rc);
330         if (ret < 0) {
331                 dev_err(&rc->uwb_dev.dev, "failed to reset hardware: %d\n", ret);
332                 goto error;
333         }
334         return 0;
335 error:
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);
339         uwb_rc_reset_all(rc);
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);
366
367 void uwb_rc_pre_reset(struct uwb_rc *rc)
368 {
369         rc->stop(rc);
370         uwbd_flush(rc);
371
372         uwb_radio_reset_state(rc);
373         uwb_rsv_remove_all(rc);
374 }
375 EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);
376
377 int uwb_rc_post_reset(struct uwb_rc *rc)
378 {
379         int ret;
380
381         ret = rc->start(rc);
382         if (ret)
383                 goto out;
384         ret = uwb_rc_mac_addr_set(rc, &rc->uwb_dev.mac_addr);
385         if (ret)
386                 goto out;
387         ret = uwb_rc_dev_addr_set(rc, &rc->uwb_dev.dev_addr);
388         if (ret)
389                 goto out;
390 out:
391         return ret;
392 }
393 EXPORT_SYMBOL_GPL(uwb_rc_post_reset);