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