1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
41
42static
43const 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
62const 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
71int 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);
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);
111out:
112 if (needtofree == 1)
113 kfree(cmd);
114 return result < 0 ? result : 0;
115}
116EXPORT_SYMBOL_GPL(uwb_rc_cmd_async);
117
118struct uwb_rc_cmd_done_params {
119 struct completion completion;
120 struct uwb_rceb *reply;
121 ssize_t reply_size;
122};
123
124static 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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170static
171ssize_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(¶ms.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, ¶ms);
188 if (result)
189 return result;
190
191 wait_for_completion(¶ms.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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227ssize_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}
246EXPORT_SYMBOL_GPL(uwb_rc_cmd);
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270ssize_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}
278EXPORT_SYMBOL_GPL(uwb_rc_vcmd);
279
280
281
282
283
284
285
286
287
288
289
290
291int 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 }
316error_cmd:
317 kfree(cmd);
318error_kzalloc:
319 mutex_unlock(&rc->uwb_dev.mutex);
320 return result;
321}
322
323int 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;
335error:
336
337
338 msleep(1000);
339 uwb_rc_reset_all(rc);
340 return ret;
341}
342
343
344
345
346
347
348
349
350void 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);
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}
365EXPORT_SYMBOL_GPL(uwb_rc_reset_all);
366
367void 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}
375EXPORT_SYMBOL_GPL(uwb_rc_pre_reset);
376
377int 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;
390out:
391 return ret;
392}
393EXPORT_SYMBOL_GPL(uwb_rc_post_reset);
394