1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Ultra Wide Band
4 * Neighborhood Management Daemon
5 *
6 * Copyright (C) 2005-2006 Intel Corporation
7 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 *
9 * This daemon takes care of maintaing information that describes the
10 * UWB neighborhood that the radios in this machine can see. It also
11 * keeps a tab of which devices are visible, makes sure each HC sits
12 * on a different channel to avoid interfering, etc.
13 *
14 * Different drivers (radio controller, device, any API in general)
15 * communicate with this daemon through an event queue. Daemon wakes
16 * up, takes a list of events and handles them one by one; handling
17 * function is extracted from a table based on the event's type and
18 * subtype. Events are freed only if the handling function says so.
19 *
20 * . Lock protecting the event list has to be an spinlock and locked
21 * with IRQSAVE because it might be called from an interrupt
22 * context (ie: when events arrive and the notification drops
23 * down from the ISR).
24 *
25 * . UWB radio controller drivers queue events to the daemon using
26 * uwbd_event_queue(). They just get the event, chew it to make it
27 * look like UWBD likes it and pass it in a buffer allocated with
28 * uwb_event_alloc().
29 *
30 * EVENTS
31 *
32 * Events have a type, a subtype, a length, some other stuff and the
33 * data blob, which depends on the event. The header is 'struct
34 * uwb_event'; for payloads, see 'struct uwbd_evt_*'.
35 *
36 * EVENT HANDLER TABLES
37 *
38 * To find a handling function for an event, the type is used to index
39 * a subtype-table in the type-table. The subtype-table is indexed
40 * with the subtype to get the function that handles the event. Start
41 * with the main type-table 'uwbd_evt_type_handler'.
42 *
43 * DEVICES
44 *
45 * Devices are created when a bunch of beacons have been received and
46 * it is stablished that the device has stable radio presence. CREATED
47 * only, not configured. Devices are ONLY configured when an
48 * Application-Specific IE Probe is receieved, in which the device
49 * declares which Protocol ID it groks. Then the device is CONFIGURED
50 * (and the driver->probe() stuff of the device model is invoked).
51 *
52 * Devices are considered disconnected when a certain number of
53 * beacons are not received in an amount of time.
54 *
55 * Handler functions are called normally uwbd_evt_handle_*().
56 */
57 #include <linux/kthread.h>
58 #include <linux/slab.h>
59 #include <linux/module.h>
60 #include <linux/freezer.h>
61
62 #include "uwb-internal.h"
63
64 /*
65 * UWBD Event handler function signature
66 *
67 * Return !0 if the event needs not to be freed (ie the handler
68 * takes/took care of it). 0 means the daemon code will free the
69 * event.
70 *
71 * @evt->rc is already referenced and guaranteed to exist. See
72 * uwb_evt_handle().
73 */
74 typedef int (*uwbd_evt_handler_f)(struct uwb_event *);
75
76 /**
77 * Properties of a UWBD event
78 *
79 * @handler: the function that will handle this event
80 * @name: text name of event
81 */
82 struct uwbd_event {
83 uwbd_evt_handler_f handler;
84 const char *name;
85 };
86
87 /* Table of handlers for and properties of the UWBD Radio Control Events */
88 static struct uwbd_event uwbd_urc_events[] = {
89 [UWB_RC_EVT_IE_RCV] = {
90 .handler = uwbd_evt_handle_rc_ie_rcv,
91 .name = "IE_RECEIVED"
92 },
93 [UWB_RC_EVT_BEACON] = {
94 .handler = uwbd_evt_handle_rc_beacon,
95 .name = "BEACON_RECEIVED"
96 },
97 [UWB_RC_EVT_BEACON_SIZE] = {
98 .handler = uwbd_evt_handle_rc_beacon_size,
99 .name = "BEACON_SIZE_CHANGE"
100 },
101 [UWB_RC_EVT_BPOIE_CHANGE] = {
102 .handler = uwbd_evt_handle_rc_bpoie_change,
103 .name = "BPOIE_CHANGE"
104 },
105 [UWB_RC_EVT_BP_SLOT_CHANGE] = {
106 .handler = uwbd_evt_handle_rc_bp_slot_change,
107 .name = "BP_SLOT_CHANGE"
108 },
109 [UWB_RC_EVT_DRP_AVAIL] = {
110 .handler = uwbd_evt_handle_rc_drp_avail,
111 .name = "DRP_AVAILABILITY_CHANGE"
112 },
113 [UWB_RC_EVT_DRP] = {
114 .handler = uwbd_evt_handle_rc_drp,
115 .name = "DRP"
116 },
117 [UWB_RC_EVT_DEV_ADDR_CONFLICT] = {
118 .handler = uwbd_evt_handle_rc_dev_addr_conflict,
119 .name = "DEV_ADDR_CONFLICT",
120 },
121 };
122
123
124
125 struct uwbd_evt_type_handler {
126 const char *name;
127 struct uwbd_event *uwbd_events;
128 size_t size;
129 };
130
131 /* Table of handlers for each UWBD Event type. */
132 static struct uwbd_evt_type_handler uwbd_urc_evt_type_handlers[] = {
133 [UWB_RC_CET_GENERAL] = {
134 .name = "URC",
135 .uwbd_events = uwbd_urc_events,
136 .size = ARRAY_SIZE(uwbd_urc_events),
137 },
138 };
139
140 static const struct uwbd_event uwbd_message_handlers[] = {
141 [UWB_EVT_MSG_RESET] = {
142 .handler = uwbd_msg_handle_reset,
143 .name = "reset",
144 },
145 };
146
147 /*
148 * Handle an URC event passed to the UWB Daemon
149 *
150 * @evt: the event to handle
151 * @returns: 0 if the event can be kfreed, !0 on the contrary
152 * (somebody else took ownership) [coincidentally, returning
153 * a <0 errno code will free it :)].
154 *
155 * Looks up the two indirection tables (one for the type, one for the
156 * subtype) to decide which function handles it and then calls the
157 * handler.
158 *
159 * The event structure passed to the event handler has the radio
160 * controller in @evt->rc referenced. The reference will be dropped
161 * once the handler returns, so if it needs it for longer (async),
162 * it'll need to take another one.
163 */
164 static
165 int uwbd_event_handle_urc(struct uwb_event *evt)
166 {
167 int result = -EINVAL;
168 struct uwbd_evt_type_handler *type_table;
169 uwbd_evt_handler_f handler;
170 u8 type, context;
171 u16 event;
172
173 type = evt->notif.rceb->bEventType;
174 event = le16_to_cpu(evt->notif.rceb->wEvent);
175 context = evt->notif.rceb->bEventContext;
176
177 if (type >= ARRAY_SIZE(uwbd_urc_evt_type_handlers))
178 goto out;
179 type_table = &uwbd_urc_evt_type_handlers[type];
180 if (type_table->uwbd_events == NULL)
181 goto out;
182 if (event >= type_table->size)
183 goto out;
184 handler = type_table->uwbd_events[event].handler;
185 if (handler == NULL)
186 goto out;
187
188 result = (*handler)(evt);
189 out:
190 if (result < 0)
191 dev_err(&evt->rc->uwb_dev.dev,
192 "UWBD: event 0x%02x/%04x/%02x, handling failed: %d\n",
193 type, event, context, result);
194 return result;
195 }
196
197 static void uwbd_event_handle_message(struct uwb_event *evt)
198 {
199 struct uwb_rc *rc;
200 int result;
201
202 rc = evt->rc;
203
204 if (evt->message < 0 || evt->message >= ARRAY_SIZE(uwbd_message_handlers)) {
205 dev_err(&rc->uwb_dev.dev, "UWBD: invalid message type %d\n", evt->message);
206 return;
207 }
208
209 result = uwbd_message_handlers[evt->message].handler(evt);
210 if (result < 0)
211 dev_err(&rc->uwb_dev.dev, "UWBD: '%s' message failed: %d\n",
212 uwbd_message_handlers[evt->message].name, result);
213 }
214
215 static void uwbd_event_handle(struct uwb_event *evt)
216 {
217 struct uwb_rc *rc;
218 int should_keep;
219
220 rc = evt->rc;
221
222 if (rc->ready) {
223 switch (evt->type) {
224 case UWB_EVT_TYPE_NOTIF:
225 should_keep = uwbd_event_handle_urc(evt);
226 if (should_keep <= 0)
227 kfree(evt->notif.rceb);
228 break;
229 case UWB_EVT_TYPE_MSG:
230 uwbd_event_handle_message(evt);
231 break;
232 default:
233 dev_err(&rc->uwb_dev.dev, "UWBD: invalid event type %d\n", evt->type);
234 break;
235 }
236 }
237
238 __uwb_rc_put(rc); /* for the __uwb_rc_get() in uwb_rc_notif_cb() */
239 }
240
241 /**
242 * UWB Daemon
243 *
244 * Listens to all UWB notifications and takes care to track the state
245 * of the UWB neighbourhood for the kernel. When we do a run, we
246 * spinlock, move the list to a private copy and release the
247 * lock. Hold it as little as possible. Not a conflict: it is
248 * guaranteed we own the events in the private list.
249 *
250 * FIXME: should change so we don't have a 1HZ timer all the time, but
251 * only if there are devices.
252 */
253 static int uwbd(void *param)
254 {
255 struct uwb_rc *rc = param;
256 unsigned long flags;
257 struct uwb_event *evt;
258 int should_stop = 0;
259
260 while (1) {
261 wait_event_interruptible_timeout(
262 rc->uwbd.wq,
263 !list_empty(&rc->uwbd.event_list)
264 || (should_stop = kthread_should_stop()),
265 HZ);
266 if (should_stop)
267 break;
268
269 spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
270 if (!list_empty(&rc->uwbd.event_list)) {
271 evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node);
272 list_del(&evt->list_node);
273 } else
274 evt = NULL;
275 spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
276
277 if (evt) {
278 uwbd_event_handle(evt);
279 kfree(evt);
280 }
281
282 uwb_beca_purge(rc); /* Purge devices that left */
283 }
284 return 0;
285 }
286
287
288 /** Start the UWB daemon */
289 void uwbd_start(struct uwb_rc *rc)
290 {
291 struct task_struct *task = kthread_run(uwbd, rc, "uwbd");
292 if (IS_ERR(task)) {
293 rc->uwbd.task = NULL;
294 printk(KERN_ERR "UWB: Cannot start management daemon; "
295 "UWB won't work\n");
296 } else {
297 rc->uwbd.task = task;
298 rc->uwbd.pid = rc->uwbd.task->pid;
299 }
300 }
301
302 /* Stop the UWB daemon and free any unprocessed events */
303 void uwbd_stop(struct uwb_rc *rc)
304 {
305 if (rc->uwbd.task)
306 kthread_stop(rc->uwbd.task);
307 uwbd_flush(rc);
308 }
309
310 /*
311 * Queue an event for the management daemon
312 *
313 * When some lower layer receives an event, it uses this function to
314 * push it forward to the UWB daemon.
315 *
316 * Once you pass the event, you don't own it any more, but the daemon
317 * does. It will uwb_event_free() it when done, so make sure you
318 * uwb_event_alloc()ed it or bad things will happen.
319 *
320 * If the daemon is not running, we just free the event.
321 */
322 void uwbd_event_queue(struct uwb_event *evt)
323 {
324 struct uwb_rc *rc = evt->rc;
325 unsigned long flags;
326
327 spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
328 if (rc->uwbd.pid != 0) {
329 list_add(&evt->list_node, &rc->uwbd.event_list);
330 wake_up_all(&rc->uwbd.wq);
331 } else {
332 __uwb_rc_put(evt->rc);
333 if (evt->type == UWB_EVT_TYPE_NOTIF)
334 kfree(evt->notif.rceb);
335 kfree(evt);
336 }
337 spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
338 return;
339 }
340
341 void uwbd_flush(struct uwb_rc *rc)
342 {
343 struct uwb_event *evt, *nxt;
344
345 spin_lock_irq(&rc->uwbd.event_list_lock);
346 list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) {
347 if (evt->rc == rc) {
348 __uwb_rc_put(rc);
349 list_del(&evt->list_node);
350 if (evt->type == UWB_EVT_TYPE_NOTIF)
351 kfree(evt->notif.rceb);
352 kfree(evt);
353 }
354 }
355 spin_unlock_irq(&rc->uwbd.event_list_lock);
356 }