Branch data Line data Source code
1 : : /*
2 : : * The Serio abstraction module
3 : : *
4 : : * Copyright (c) 1999-2004 Vojtech Pavlik
5 : : * Copyright (c) 2004 Dmitry Torokhov
6 : : * Copyright (c) 2003 Daniele Bellucci
7 : : */
8 : :
9 : : /*
10 : : * This program is free software; you can redistribute it and/or modify
11 : : * it under the terms of the GNU General Public License as published by
12 : : * the Free Software Foundation; either version 2 of the License, or
13 : : * (at your option) any later version.
14 : : *
15 : : * This program is distributed in the hope that it will be useful,
16 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 : : * GNU General Public License for more details.
19 : : *
20 : : * You should have received a copy of the GNU General Public License
21 : : * along with this program; if not, write to the Free Software
22 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 : : *
24 : : * Should you need to contact me, the author, you can do so either by
25 : : * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26 : : * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
27 : : */
28 : :
29 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30 : :
31 : : #include <linux/stddef.h>
32 : : #include <linux/module.h>
33 : : #include <linux/serio.h>
34 : : #include <linux/errno.h>
35 : : #include <linux/sched.h>
36 : : #include <linux/slab.h>
37 : : #include <linux/workqueue.h>
38 : : #include <linux/mutex.h>
39 : :
40 : : MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
41 : : MODULE_DESCRIPTION("Serio abstraction core");
42 : : MODULE_LICENSE("GPL");
43 : :
44 : : /*
45 : : * serio_mutex protects entire serio subsystem and is taken every time
46 : : * serio port or driver registered or unregistered.
47 : : */
48 : : static DEFINE_MUTEX(serio_mutex);
49 : :
50 : : static LIST_HEAD(serio_list);
51 : :
52 : : static struct bus_type serio_bus;
53 : :
54 : : static void serio_add_port(struct serio *serio);
55 : : static int serio_reconnect_port(struct serio *serio);
56 : : static void serio_disconnect_port(struct serio *serio);
57 : : static void serio_reconnect_subtree(struct serio *serio);
58 : : static void serio_attach_driver(struct serio_driver *drv);
59 : :
60 : 0 : static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
61 : : {
62 : : int retval;
63 : :
64 : 0 : mutex_lock(&serio->drv_mutex);
65 : 0 : retval = drv->connect(serio, drv);
66 : 0 : mutex_unlock(&serio->drv_mutex);
67 : :
68 : 0 : return retval;
69 : : }
70 : :
71 : 0 : static int serio_reconnect_driver(struct serio *serio)
72 : : {
73 : : int retval = -1;
74 : :
75 : 0 : mutex_lock(&serio->drv_mutex);
76 [ # # ][ # # ]: 0 : if (serio->drv && serio->drv->reconnect)
77 : 0 : retval = serio->drv->reconnect(serio);
78 : 0 : mutex_unlock(&serio->drv_mutex);
79 : :
80 : 0 : return retval;
81 : : }
82 : :
83 : 0 : static void serio_disconnect_driver(struct serio *serio)
84 : : {
85 : 0 : mutex_lock(&serio->drv_mutex);
86 [ # # ]: 0 : if (serio->drv)
87 : 0 : serio->drv->disconnect(serio);
88 : 0 : mutex_unlock(&serio->drv_mutex);
89 : 0 : }
90 : :
91 : 0 : static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
92 : : {
93 [ # # ][ # # ]: 0 : while (ids->type || ids->proto) {
94 [ # # ][ # # ]: 0 : if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
[ # # ]
95 [ # # ][ # # ]: 0 : (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
96 [ # # ][ # # ]: 0 : (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
97 [ # # ]: 0 : (ids->id == SERIO_ANY || ids->id == serio->id.id))
98 : : return 1;
99 : 0 : ids++;
100 : : }
101 : : return 0;
102 : : }
103 : :
104 : : /*
105 : : * Basic serio -> driver core mappings
106 : : */
107 : :
108 : 0 : static int serio_bind_driver(struct serio *serio, struct serio_driver *drv)
109 : : {
110 : : int error;
111 : :
112 [ # # ]: 0 : if (serio_match_port(drv->id_table, serio)) {
113 : :
114 : 0 : serio->dev.driver = &drv->driver;
115 [ # # ]: 0 : if (serio_connect_driver(serio, drv)) {
116 : 0 : serio->dev.driver = NULL;
117 : 0 : return -ENODEV;
118 : : }
119 : :
120 : 0 : error = device_bind_driver(&serio->dev);
121 [ # # ]: 0 : if (error) {
122 : 0 : dev_warn(&serio->dev,
123 : : "device_bind_driver() failed for %s (%s) and %s, error: %d\n",
124 : 0 : serio->phys, serio->name,
125 : : drv->description, error);
126 : 0 : serio_disconnect_driver(serio);
127 : 0 : serio->dev.driver = NULL;
128 : 0 : return error;
129 : : }
130 : : }
131 : : return 0;
132 : : }
133 : :
134 : 0 : static void serio_find_driver(struct serio *serio)
135 : : {
136 : : int error;
137 : :
138 : 0 : error = device_attach(&serio->dev);
139 [ # # ]: 0 : if (error < 0)
140 : 0 : dev_warn(&serio->dev,
141 : : "device_attach() failed for %s (%s), error: %d\n",
142 : 0 : serio->phys, serio->name, error);
143 : 0 : }
144 : :
145 : :
146 : : /*
147 : : * Serio event processing.
148 : : */
149 : :
150 : : enum serio_event_type {
151 : : SERIO_RESCAN_PORT,
152 : : SERIO_RECONNECT_PORT,
153 : : SERIO_RECONNECT_SUBTREE,
154 : : SERIO_REGISTER_PORT,
155 : : SERIO_ATTACH_DRIVER,
156 : : };
157 : :
158 : : struct serio_event {
159 : : enum serio_event_type type;
160 : : void *object;
161 : : struct module *owner;
162 : : struct list_head node;
163 : : };
164 : :
165 : : static DEFINE_SPINLOCK(serio_event_lock); /* protects serio_event_list */
166 : : static LIST_HEAD(serio_event_list);
167 : :
168 : 0 : static struct serio_event *serio_get_event(void)
169 : : {
170 : : struct serio_event *event = NULL;
171 : : unsigned long flags;
172 : :
173 : 0 : spin_lock_irqsave(&serio_event_lock, flags);
174 : :
175 [ # # ]: 0 : if (!list_empty(&serio_event_list)) {
176 : 0 : event = list_first_entry(&serio_event_list,
177 : : struct serio_event, node);
178 : 0 : list_del_init(&event->node);
179 : : }
180 : :
181 : : spin_unlock_irqrestore(&serio_event_lock, flags);
182 : 0 : return event;
183 : : }
184 : :
185 : : static void serio_free_event(struct serio_event *event)
186 : : {
187 : 0 : module_put(event->owner);
188 : 0 : kfree(event);
189 : : }
190 : :
191 : 0 : static void serio_remove_duplicate_events(void *object,
192 : : enum serio_event_type type)
193 : : {
194 : : struct serio_event *e, *next;
195 : : unsigned long flags;
196 : :
197 : 0 : spin_lock_irqsave(&serio_event_lock, flags);
198 : :
199 [ # # ]: 0 : list_for_each_entry_safe(e, next, &serio_event_list, node) {
200 [ # # ]: 0 : if (object == e->object) {
201 : : /*
202 : : * If this event is of different type we should not
203 : : * look further - we only suppress duplicate events
204 : : * that were sent back-to-back.
205 : : */
206 [ # # ]: 0 : if (type != e->type)
207 : : break;
208 : :
209 : : list_del_init(&e->node);
210 : : serio_free_event(e);
211 : : }
212 : : }
213 : :
214 : : spin_unlock_irqrestore(&serio_event_lock, flags);
215 : 0 : }
216 : :
217 : 0 : static void serio_handle_event(struct work_struct *work)
218 : : {
219 : : struct serio_event *event;
220 : :
221 : 0 : mutex_lock(&serio_mutex);
222 : :
223 [ # # ]: 0 : while ((event = serio_get_event())) {
224 : :
225 [ # # # # : 0 : switch (event->type) {
# # ]
226 : :
227 : : case SERIO_REGISTER_PORT:
228 : 0 : serio_add_port(event->object);
229 : 0 : break;
230 : :
231 : : case SERIO_RECONNECT_PORT:
232 : 0 : serio_reconnect_port(event->object);
233 : 0 : break;
234 : :
235 : : case SERIO_RESCAN_PORT:
236 : 0 : serio_disconnect_port(event->object);
237 : 0 : serio_find_driver(event->object);
238 : 0 : break;
239 : :
240 : : case SERIO_RECONNECT_SUBTREE:
241 : 0 : serio_reconnect_subtree(event->object);
242 : 0 : break;
243 : :
244 : : case SERIO_ATTACH_DRIVER:
245 : 0 : serio_attach_driver(event->object);
246 : 0 : break;
247 : : }
248 : :
249 : 0 : serio_remove_duplicate_events(event->object, event->type);
250 : : serio_free_event(event);
251 : : }
252 : :
253 : 0 : mutex_unlock(&serio_mutex);
254 : 0 : }
255 : :
256 : : static DECLARE_WORK(serio_event_work, serio_handle_event);
257 : :
258 : 0 : static int serio_queue_event(void *object, struct module *owner,
259 : : enum serio_event_type event_type)
260 : : {
261 : : unsigned long flags;
262 : : struct serio_event *event;
263 : : int retval = 0;
264 : :
265 : 0 : spin_lock_irqsave(&serio_event_lock, flags);
266 : :
267 : : /*
268 : : * Scan event list for the other events for the same serio port,
269 : : * starting with the most recent one. If event is the same we
270 : : * do not need add new one. If event is of different type we
271 : : * need to add this event and should not look further because
272 : : * we need to preseve sequence of distinct events.
273 : : */
274 [ # # ]: 0 : list_for_each_entry_reverse(event, &serio_event_list, node) {
275 [ # # ]: 0 : if (event->object == object) {
276 [ # # ]: 0 : if (event->type == event_type)
277 : : goto out;
278 : : break;
279 : : }
280 : : }
281 : :
282 : : event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
283 [ # # ]: 0 : if (!event) {
284 : 0 : pr_err("Not enough memory to queue event %d\n", event_type);
285 : : retval = -ENOMEM;
286 : 0 : goto out;
287 : : }
288 : :
289 [ # # ]: 0 : if (!try_module_get(owner)) {
290 : 0 : pr_warning("Can't get module reference, dropping event %d\n",
291 : : event_type);
292 : 0 : kfree(event);
293 : : retval = -EINVAL;
294 : 0 : goto out;
295 : : }
296 : :
297 : 0 : event->type = event_type;
298 : 0 : event->object = object;
299 : 0 : event->owner = owner;
300 : :
301 : 0 : list_add_tail(&event->node, &serio_event_list);
302 : 0 : queue_work(system_long_wq, &serio_event_work);
303 : :
304 : : out:
305 : : spin_unlock_irqrestore(&serio_event_lock, flags);
306 : 0 : return retval;
307 : : }
308 : :
309 : : /*
310 : : * Remove all events that have been submitted for a given
311 : : * object, be it serio port or driver.
312 : : */
313 : 0 : static void serio_remove_pending_events(void *object)
314 : : {
315 : : struct serio_event *event, *next;
316 : : unsigned long flags;
317 : :
318 : 0 : spin_lock_irqsave(&serio_event_lock, flags);
319 : :
320 [ # # ]: 0 : list_for_each_entry_safe(event, next, &serio_event_list, node) {
321 [ # # ]: 0 : if (event->object == object) {
322 : : list_del_init(&event->node);
323 : : serio_free_event(event);
324 : : }
325 : : }
326 : :
327 : : spin_unlock_irqrestore(&serio_event_lock, flags);
328 : 0 : }
329 : :
330 : : /*
331 : : * Locate child serio port (if any) that has not been fully registered yet.
332 : : *
333 : : * Children are registered by driver's connect() handler so there can't be a
334 : : * grandchild pending registration together with a child.
335 : : */
336 : 0 : static struct serio *serio_get_pending_child(struct serio *parent)
337 : : {
338 : : struct serio_event *event;
339 : : struct serio *serio, *child = NULL;
340 : : unsigned long flags;
341 : :
342 : 0 : spin_lock_irqsave(&serio_event_lock, flags);
343 : :
344 [ # # ]: 0 : list_for_each_entry(event, &serio_event_list, node) {
345 [ # # ]: 0 : if (event->type == SERIO_REGISTER_PORT) {
346 : 0 : serio = event->object;
347 [ # # ]: 0 : if (serio->parent == parent) {
348 : : child = serio;
349 : : break;
350 : : }
351 : : }
352 : : }
353 : :
354 : : spin_unlock_irqrestore(&serio_event_lock, flags);
355 : 0 : return child;
356 : : }
357 : :
358 : : /*
359 : : * Serio port operations
360 : : */
361 : :
362 : 0 : static ssize_t serio_show_description(struct device *dev, struct device_attribute *attr, char *buf)
363 : : {
364 : : struct serio *serio = to_serio_port(dev);
365 : 0 : return sprintf(buf, "%s\n", serio->name);
366 : : }
367 : :
368 : 0 : static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
369 : : {
370 : : struct serio *serio = to_serio_port(dev);
371 : :
372 : 0 : return sprintf(buf, "serio:ty%02Xpr%02Xid%02Xex%02X\n",
373 : 0 : serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
374 : : }
375 : :
376 : 0 : static ssize_t type_show(struct device *dev, struct device_attribute *attr, char *buf)
377 : : {
378 : : struct serio *serio = to_serio_port(dev);
379 : 0 : return sprintf(buf, "%02x\n", serio->id.type);
380 : : }
381 : :
382 : 0 : static ssize_t proto_show(struct device *dev, struct device_attribute *attr, char *buf)
383 : : {
384 : : struct serio *serio = to_serio_port(dev);
385 : 0 : return sprintf(buf, "%02x\n", serio->id.proto);
386 : : }
387 : :
388 : 0 : static ssize_t id_show(struct device *dev, struct device_attribute *attr, char *buf)
389 : : {
390 : : struct serio *serio = to_serio_port(dev);
391 : 0 : return sprintf(buf, "%02x\n", serio->id.id);
392 : : }
393 : :
394 : 0 : static ssize_t extra_show(struct device *dev, struct device_attribute *attr, char *buf)
395 : : {
396 : : struct serio *serio = to_serio_port(dev);
397 : 0 : return sprintf(buf, "%02x\n", serio->id.extra);
398 : : }
399 : :
400 : 0 : static ssize_t drvctl_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
401 : : {
402 : 0 : struct serio *serio = to_serio_port(dev);
403 : : struct device_driver *drv;
404 : : int error;
405 : :
406 : 0 : error = mutex_lock_interruptible(&serio_mutex);
407 [ # # ]: 0 : if (error)
408 : : return error;
409 : :
410 [ # # ]: 0 : if (!strncmp(buf, "none", count)) {
411 : 0 : serio_disconnect_port(serio);
412 [ # # ]: 0 : } else if (!strncmp(buf, "reconnect", count)) {
413 : 0 : serio_reconnect_subtree(serio);
414 [ # # ]: 0 : } else if (!strncmp(buf, "rescan", count)) {
415 : 0 : serio_disconnect_port(serio);
416 : 0 : serio_find_driver(serio);
417 : 0 : serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
418 [ # # ]: 0 : } else if ((drv = driver_find(buf, &serio_bus)) != NULL) {
419 : 0 : serio_disconnect_port(serio);
420 : 0 : error = serio_bind_driver(serio, to_serio_driver(drv));
421 : 0 : serio_remove_duplicate_events(serio, SERIO_RESCAN_PORT);
422 : : } else {
423 : : error = -EINVAL;
424 : : }
425 : :
426 : 0 : mutex_unlock(&serio_mutex);
427 : :
428 [ # # ]: 0 : return error ? error : count;
429 : : }
430 : :
431 : 0 : static ssize_t serio_show_bind_mode(struct device *dev, struct device_attribute *attr, char *buf)
432 : : {
433 : : struct serio *serio = to_serio_port(dev);
434 [ # # ]: 0 : return sprintf(buf, "%s\n", serio->manual_bind ? "manual" : "auto");
435 : : }
436 : :
437 : 0 : static ssize_t serio_set_bind_mode(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
438 : : {
439 : : struct serio *serio = to_serio_port(dev);
440 : : int retval;
441 : :
442 : 0 : retval = count;
443 [ # # ]: 0 : if (!strncmp(buf, "manual", count)) {
444 : 0 : serio->manual_bind = true;
445 [ # # ]: 0 : } else if (!strncmp(buf, "auto", count)) {
446 : 0 : serio->manual_bind = false;
447 : : } else {
448 : : retval = -EINVAL;
449 : : }
450 : :
451 : 0 : return retval;
452 : : }
453 : :
454 : : static DEVICE_ATTR_RO(type);
455 : : static DEVICE_ATTR_RO(proto);
456 : : static DEVICE_ATTR_RO(id);
457 : : static DEVICE_ATTR_RO(extra);
458 : :
459 : : static struct attribute *serio_device_id_attrs[] = {
460 : : &dev_attr_type.attr,
461 : : &dev_attr_proto.attr,
462 : : &dev_attr_id.attr,
463 : : &dev_attr_extra.attr,
464 : : NULL
465 : : };
466 : :
467 : : static struct attribute_group serio_id_attr_group = {
468 : : .name = "id",
469 : : .attrs = serio_device_id_attrs,
470 : : };
471 : :
472 : : static DEVICE_ATTR_RO(modalias);
473 : : static DEVICE_ATTR_WO(drvctl);
474 : : static DEVICE_ATTR(description, S_IRUGO, serio_show_description, NULL);
475 : : static DEVICE_ATTR(bind_mode, S_IWUSR | S_IRUGO, serio_show_bind_mode, serio_set_bind_mode);
476 : :
477 : : static struct attribute *serio_device_attrs[] = {
478 : : &dev_attr_modalias.attr,
479 : : &dev_attr_description.attr,
480 : : &dev_attr_drvctl.attr,
481 : : &dev_attr_bind_mode.attr,
482 : : NULL
483 : : };
484 : :
485 : : static struct attribute_group serio_device_attr_group = {
486 : : .attrs = serio_device_attrs,
487 : : };
488 : :
489 : : static const struct attribute_group *serio_device_attr_groups[] = {
490 : : &serio_id_attr_group,
491 : : &serio_device_attr_group,
492 : : NULL
493 : : };
494 : :
495 : 0 : static void serio_release_port(struct device *dev)
496 : : {
497 : 0 : struct serio *serio = to_serio_port(dev);
498 : :
499 : 0 : kfree(serio);
500 : 0 : module_put(THIS_MODULE);
501 : 0 : }
502 : :
503 : : /*
504 : : * Prepare serio port for registration.
505 : : */
506 : 0 : static void serio_init_port(struct serio *serio)
507 : : {
508 : : static atomic_t serio_no = ATOMIC_INIT(0);
509 : :
510 : 0 : __module_get(THIS_MODULE);
511 : :
512 : 0 : INIT_LIST_HEAD(&serio->node);
513 : 0 : INIT_LIST_HEAD(&serio->child_node);
514 : 0 : INIT_LIST_HEAD(&serio->children);
515 : 0 : spin_lock_init(&serio->lock);
516 : 0 : mutex_init(&serio->drv_mutex);
517 : 0 : device_initialize(&serio->dev);
518 : 0 : dev_set_name(&serio->dev, "serio%ld",
519 : : (long)atomic_inc_return(&serio_no) - 1);
520 : 0 : serio->dev.bus = &serio_bus;
521 : 0 : serio->dev.release = serio_release_port;
522 : 0 : serio->dev.groups = serio_device_attr_groups;
523 [ # # ]: 0 : if (serio->parent) {
524 : 0 : serio->dev.parent = &serio->parent->dev;
525 : 0 : serio->depth = serio->parent->depth + 1;
526 : : } else
527 : 0 : serio->depth = 0;
528 : : lockdep_set_subclass(&serio->lock, serio->depth);
529 : 0 : }
530 : :
531 : : /*
532 : : * Complete serio port registration.
533 : : * Driver core will attempt to find appropriate driver for the port.
534 : : */
535 : 0 : static void serio_add_port(struct serio *serio)
536 : : {
537 : 0 : struct serio *parent = serio->parent;
538 : : int error;
539 : :
540 [ # # ]: 0 : if (parent) {
541 : : serio_pause_rx(parent);
542 : 0 : list_add_tail(&serio->child_node, &parent->children);
543 : : serio_continue_rx(parent);
544 : : }
545 : :
546 : 0 : list_add_tail(&serio->node, &serio_list);
547 : :
548 [ # # ]: 0 : if (serio->start)
549 : 0 : serio->start(serio);
550 : :
551 : 0 : error = device_add(&serio->dev);
552 [ # # ]: 0 : if (error)
553 : 0 : dev_err(&serio->dev,
554 : : "device_add() failed for %s (%s), error: %d\n",
555 : 0 : serio->phys, serio->name, error);
556 : 0 : }
557 : :
558 : : /*
559 : : * serio_destroy_port() completes unregistration process and removes
560 : : * port from the system
561 : : */
562 : 0 : static void serio_destroy_port(struct serio *serio)
563 : : {
564 : : struct serio *child;
565 : :
566 [ # # ]: 0 : while ((child = serio_get_pending_child(serio)) != NULL) {
567 : 0 : serio_remove_pending_events(child);
568 : 0 : put_device(&child->dev);
569 : : }
570 : :
571 [ # # ]: 0 : if (serio->stop)
572 : 0 : serio->stop(serio);
573 : :
574 [ # # ]: 0 : if (serio->parent) {
575 : : serio_pause_rx(serio->parent);
576 : 0 : list_del_init(&serio->child_node);
577 : 0 : serio_continue_rx(serio->parent);
578 : 0 : serio->parent = NULL;
579 : : }
580 : :
581 [ # # ]: 0 : if (device_is_registered(&serio->dev))
582 : 0 : device_del(&serio->dev);
583 : :
584 : 0 : list_del_init(&serio->node);
585 : 0 : serio_remove_pending_events(serio);
586 : 0 : put_device(&serio->dev);
587 : 0 : }
588 : :
589 : : /*
590 : : * Reconnect serio port (re-initialize attached device).
591 : : * If reconnect fails (old device is no longer attached or
592 : : * there was no device to begin with) we do full rescan in
593 : : * hope of finding a driver for the port.
594 : : */
595 : 0 : static int serio_reconnect_port(struct serio *serio)
596 : : {
597 : 0 : int error = serio_reconnect_driver(serio);
598 : :
599 [ # # ]: 0 : if (error) {
600 : 0 : serio_disconnect_port(serio);
601 : 0 : serio_find_driver(serio);
602 : : }
603 : :
604 : 0 : return error;
605 : : }
606 : :
607 : : /*
608 : : * Reconnect serio port and all its children (re-initialize attached
609 : : * devices).
610 : : */
611 : 0 : static void serio_reconnect_subtree(struct serio *root)
612 : : {
613 : : struct serio *s = root;
614 : : int error;
615 : :
616 : : do {
617 : 0 : error = serio_reconnect_port(s);
618 [ # # ]: 0 : if (!error) {
619 : : /*
620 : : * Reconnect was successful, move on to do the
621 : : * first child.
622 : : */
623 [ # # ]: 0 : if (!list_empty(&s->children)) {
624 : 0 : s = list_first_entry(&s->children,
625 : : struct serio, child_node);
626 : 0 : continue;
627 : : }
628 : : }
629 : :
630 : : /*
631 : : * Either it was a leaf node or reconnect failed and it
632 : : * became a leaf node. Continue reconnecting starting with
633 : : * the next sibling of the parent node.
634 : : */
635 [ # # ]: 0 : while (s != root) {
636 : 0 : struct serio *parent = s->parent;
637 : :
638 [ # # ]: 0 : if (!list_is_last(&s->child_node, &parent->children)) {
639 : 0 : s = list_entry(s->child_node.next,
640 : : struct serio, child_node);
641 : 0 : break;
642 : : }
643 : :
644 : : s = parent;
645 : : }
646 [ # # ]: 0 : } while (s != root);
647 : 0 : }
648 : :
649 : : /*
650 : : * serio_disconnect_port() unbinds a port from its driver. As a side effect
651 : : * all children ports are unbound and destroyed.
652 : : */
653 : 0 : static void serio_disconnect_port(struct serio *serio)
654 : : {
655 : : struct serio *s = serio;
656 : :
657 : : /*
658 : : * Children ports should be disconnected and destroyed
659 : : * first; we travel the tree in depth-first order.
660 : : */
661 [ # # ]: 0 : while (!list_empty(&serio->children)) {
662 : :
663 : : /* Locate a leaf */
664 [ # # ]: 0 : while (!list_empty(&s->children))
665 : 0 : s = list_first_entry(&s->children,
666 : : struct serio, child_node);
667 : :
668 : : /*
669 : : * Prune this leaf node unless it is the one we
670 : : * started with.
671 : : */
672 [ # # ]: 0 : if (s != serio) {
673 : 0 : struct serio *parent = s->parent;
674 : :
675 : 0 : device_release_driver(&s->dev);
676 : 0 : serio_destroy_port(s);
677 : :
678 : : s = parent;
679 : : }
680 : : }
681 : :
682 : : /*
683 : : * OK, no children left, now disconnect this port.
684 : : */
685 : 0 : device_release_driver(&serio->dev);
686 : 0 : }
687 : :
688 : 0 : void serio_rescan(struct serio *serio)
689 : : {
690 : 0 : serio_queue_event(serio, NULL, SERIO_RESCAN_PORT);
691 : 0 : }
692 : : EXPORT_SYMBOL(serio_rescan);
693 : :
694 : 0 : void serio_reconnect(struct serio *serio)
695 : : {
696 : 0 : serio_queue_event(serio, NULL, SERIO_RECONNECT_SUBTREE);
697 : 0 : }
698 : : EXPORT_SYMBOL(serio_reconnect);
699 : :
700 : : /*
701 : : * Submits register request to kseriod for subsequent execution.
702 : : * Note that port registration is always asynchronous.
703 : : */
704 : 0 : void __serio_register_port(struct serio *serio, struct module *owner)
705 : : {
706 : 0 : serio_init_port(serio);
707 : 0 : serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
708 : 0 : }
709 : : EXPORT_SYMBOL(__serio_register_port);
710 : :
711 : : /*
712 : : * Synchronously unregisters serio port.
713 : : */
714 : 0 : void serio_unregister_port(struct serio *serio)
715 : : {
716 : 0 : mutex_lock(&serio_mutex);
717 : 0 : serio_disconnect_port(serio);
718 : 0 : serio_destroy_port(serio);
719 : 0 : mutex_unlock(&serio_mutex);
720 : 0 : }
721 : : EXPORT_SYMBOL(serio_unregister_port);
722 : :
723 : : /*
724 : : * Safely unregisters children ports if they are present.
725 : : */
726 : 0 : void serio_unregister_child_port(struct serio *serio)
727 : : {
728 : : struct serio *s, *next;
729 : :
730 : 0 : mutex_lock(&serio_mutex);
731 [ # # ]: 0 : list_for_each_entry_safe(s, next, &serio->children, child_node) {
732 : 0 : serio_disconnect_port(s);
733 : 0 : serio_destroy_port(s);
734 : : }
735 : 0 : mutex_unlock(&serio_mutex);
736 : 0 : }
737 : : EXPORT_SYMBOL(serio_unregister_child_port);
738 : :
739 : :
740 : : /*
741 : : * Serio driver operations
742 : : */
743 : :
744 : 0 : static ssize_t description_show(struct device_driver *drv, char *buf)
745 : : {
746 : : struct serio_driver *driver = to_serio_driver(drv);
747 [ # # ]: 0 : return sprintf(buf, "%s\n", driver->description ? driver->description : "(none)");
748 : : }
749 : : static DRIVER_ATTR_RO(description);
750 : :
751 : 0 : static ssize_t bind_mode_show(struct device_driver *drv, char *buf)
752 : : {
753 : : struct serio_driver *serio_drv = to_serio_driver(drv);
754 [ # # ]: 0 : return sprintf(buf, "%s\n", serio_drv->manual_bind ? "manual" : "auto");
755 : : }
756 : :
757 : 0 : static ssize_t bind_mode_store(struct device_driver *drv, const char *buf, size_t count)
758 : : {
759 : : struct serio_driver *serio_drv = to_serio_driver(drv);
760 : : int retval;
761 : :
762 : 0 : retval = count;
763 [ # # ]: 0 : if (!strncmp(buf, "manual", count)) {
764 : 0 : serio_drv->manual_bind = true;
765 [ # # ]: 0 : } else if (!strncmp(buf, "auto", count)) {
766 : 0 : serio_drv->manual_bind = false;
767 : : } else {
768 : : retval = -EINVAL;
769 : : }
770 : :
771 : 0 : return retval;
772 : : }
773 : : static DRIVER_ATTR_RW(bind_mode);
774 : :
775 : : static struct attribute *serio_driver_attrs[] = {
776 : : &driver_attr_description.attr,
777 : : &driver_attr_bind_mode.attr,
778 : : NULL,
779 : : };
780 : : ATTRIBUTE_GROUPS(serio_driver);
781 : :
782 : 0 : static int serio_driver_probe(struct device *dev)
783 : : {
784 : 0 : struct serio *serio = to_serio_port(dev);
785 : 0 : struct serio_driver *drv = to_serio_driver(dev->driver);
786 : :
787 : 0 : return serio_connect_driver(serio, drv);
788 : : }
789 : :
790 : 0 : static int serio_driver_remove(struct device *dev)
791 : : {
792 : 0 : struct serio *serio = to_serio_port(dev);
793 : :
794 : 0 : serio_disconnect_driver(serio);
795 : 0 : return 0;
796 : : }
797 : :
798 : 0 : static void serio_cleanup(struct serio *serio)
799 : : {
800 : 0 : mutex_lock(&serio->drv_mutex);
801 [ # # ][ # # ]: 0 : if (serio->drv && serio->drv->cleanup)
802 : 0 : serio->drv->cleanup(serio);
803 : 0 : mutex_unlock(&serio->drv_mutex);
804 : 0 : }
805 : :
806 : 0 : static void serio_shutdown(struct device *dev)
807 : : {
808 : 0 : struct serio *serio = to_serio_port(dev);
809 : :
810 : 0 : serio_cleanup(serio);
811 : 0 : }
812 : :
813 : 0 : static void serio_attach_driver(struct serio_driver *drv)
814 : : {
815 : : int error;
816 : :
817 : 0 : error = driver_attach(&drv->driver);
818 [ # # ]: 0 : if (error)
819 : 0 : pr_warning("driver_attach() failed for %s with error %d\n",
820 : : drv->driver.name, error);
821 : 0 : }
822 : :
823 : 0 : int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
824 : : {
825 : 0 : bool manual_bind = drv->manual_bind;
826 : : int error;
827 : :
828 : 0 : drv->driver.bus = &serio_bus;
829 : 0 : drv->driver.owner = owner;
830 : 0 : drv->driver.mod_name = mod_name;
831 : :
832 : : /*
833 : : * Temporarily disable automatic binding because probing
834 : : * takes long time and we are better off doing it in kseriod
835 : : */
836 : 0 : drv->manual_bind = true;
837 : :
838 : 0 : error = driver_register(&drv->driver);
839 [ # # ]: 0 : if (error) {
840 : 0 : pr_err("driver_register() failed for %s, error: %d\n",
841 : : drv->driver.name, error);
842 : 0 : return error;
843 : : }
844 : :
845 : : /*
846 : : * Restore original bind mode and let kseriod bind the
847 : : * driver to free ports
848 : : */
849 [ # # ]: 0 : if (!manual_bind) {
850 : 0 : drv->manual_bind = false;
851 : 0 : error = serio_queue_event(drv, NULL, SERIO_ATTACH_DRIVER);
852 [ # # ]: 0 : if (error) {
853 : 0 : driver_unregister(&drv->driver);
854 : 0 : return error;
855 : : }
856 : : }
857 : :
858 : : return 0;
859 : : }
860 : : EXPORT_SYMBOL(__serio_register_driver);
861 : :
862 : 0 : void serio_unregister_driver(struct serio_driver *drv)
863 : : {
864 : : struct serio *serio;
865 : :
866 : 0 : mutex_lock(&serio_mutex);
867 : :
868 : 0 : drv->manual_bind = true; /* so serio_find_driver ignores it */
869 : 0 : serio_remove_pending_events(drv);
870 : :
871 : : start_over:
872 [ # # ]: 0 : list_for_each_entry(serio, &serio_list, node) {
873 [ # # ]: 0 : if (serio->drv == drv) {
874 : 0 : serio_disconnect_port(serio);
875 : 0 : serio_find_driver(serio);
876 : : /* we could've deleted some ports, restart */
877 : 0 : goto start_over;
878 : : }
879 : : }
880 : :
881 : 0 : driver_unregister(&drv->driver);
882 : 0 : mutex_unlock(&serio_mutex);
883 : 0 : }
884 : : EXPORT_SYMBOL(serio_unregister_driver);
885 : :
886 : 0 : static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
887 : : {
888 : : serio_pause_rx(serio);
889 : 0 : serio->drv = drv;
890 : : serio_continue_rx(serio);
891 : 0 : }
892 : :
893 : 0 : static int serio_bus_match(struct device *dev, struct device_driver *drv)
894 : : {
895 : 0 : struct serio *serio = to_serio_port(dev);
896 : : struct serio_driver *serio_drv = to_serio_driver(drv);
897 : :
898 [ # # ][ # # ]: 0 : if (serio->manual_bind || serio_drv->manual_bind)
899 : : return 0;
900 : :
901 : 0 : return serio_match_port(serio_drv->id_table, serio);
902 : : }
903 : :
904 : : #define SERIO_ADD_UEVENT_VAR(fmt, val...) \
905 : : do { \
906 : : int err = add_uevent_var(env, fmt, val); \
907 : : if (err) \
908 : : return err; \
909 : : } while (0)
910 : :
911 : 0 : static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
912 : : {
913 : : struct serio *serio;
914 : :
915 [ # # ]: 0 : if (!dev)
916 : : return -ENODEV;
917 : :
918 : : serio = to_serio_port(dev);
919 : :
920 [ # # ]: 0 : SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
921 [ # # ]: 0 : SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
922 [ # # ]: 0 : SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
923 [ # # ]: 0 : SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
924 [ # # ]: 0 : SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
925 : : serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
926 : :
927 : : return 0;
928 : : }
929 : : #undef SERIO_ADD_UEVENT_VAR
930 : :
931 : : #ifdef CONFIG_PM
932 : 0 : static int serio_suspend(struct device *dev)
933 : : {
934 : 0 : struct serio *serio = to_serio_port(dev);
935 : :
936 : 0 : serio_cleanup(serio);
937 : :
938 : 0 : return 0;
939 : : }
940 : :
941 : 0 : static int serio_resume(struct device *dev)
942 : : {
943 : 0 : struct serio *serio = to_serio_port(dev);
944 : :
945 : : /*
946 : : * Driver reconnect can take a while, so better let kseriod
947 : : * deal with it.
948 : : */
949 : 0 : serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
950 : :
951 : 0 : return 0;
952 : : }
953 : :
954 : : static const struct dev_pm_ops serio_pm_ops = {
955 : : .suspend = serio_suspend,
956 : : .resume = serio_resume,
957 : : .poweroff = serio_suspend,
958 : : .restore = serio_resume,
959 : : };
960 : : #endif /* CONFIG_PM */
961 : :
962 : : /* called from serio_driver->connect/disconnect methods under serio_mutex */
963 : 0 : int serio_open(struct serio *serio, struct serio_driver *drv)
964 : : {
965 : 0 : serio_set_drv(serio, drv);
966 : :
967 [ # # ][ # # ]: 0 : if (serio->open && serio->open(serio)) {
968 : 0 : serio_set_drv(serio, NULL);
969 : 0 : return -1;
970 : : }
971 : : return 0;
972 : : }
973 : : EXPORT_SYMBOL(serio_open);
974 : :
975 : : /* called from serio_driver->connect/disconnect methods under serio_mutex */
976 : 0 : void serio_close(struct serio *serio)
977 : : {
978 [ # # ]: 0 : if (serio->close)
979 : 0 : serio->close(serio);
980 : :
981 : 0 : serio_set_drv(serio, NULL);
982 : 0 : }
983 : : EXPORT_SYMBOL(serio_close);
984 : :
985 : 0 : irqreturn_t serio_interrupt(struct serio *serio,
986 : : unsigned char data, unsigned int dfl)
987 : : {
988 : : unsigned long flags;
989 : : irqreturn_t ret = IRQ_NONE;
990 : :
991 : 0 : spin_lock_irqsave(&serio->lock, flags);
992 : :
993 [ # # ]: 0 : if (likely(serio->drv)) {
994 : 0 : ret = serio->drv->interrupt(serio, data, dfl);
995 [ # # ][ # # ]: 0 : } else if (!dfl && device_is_registered(&serio->dev)) {
996 : : serio_rescan(serio);
997 : : ret = IRQ_HANDLED;
998 : : }
999 : :
1000 : : spin_unlock_irqrestore(&serio->lock, flags);
1001 : :
1002 : 0 : return ret;
1003 : : }
1004 : : EXPORT_SYMBOL(serio_interrupt);
1005 : :
1006 : : static struct bus_type serio_bus = {
1007 : : .name = "serio",
1008 : : .drv_groups = serio_driver_groups,
1009 : : .match = serio_bus_match,
1010 : : .uevent = serio_uevent,
1011 : : .probe = serio_driver_probe,
1012 : : .remove = serio_driver_remove,
1013 : : .shutdown = serio_shutdown,
1014 : : #ifdef CONFIG_PM
1015 : : .pm = &serio_pm_ops,
1016 : : #endif
1017 : : };
1018 : :
1019 : 0 : static int __init serio_init(void)
1020 : : {
1021 : : int error;
1022 : :
1023 : 0 : error = bus_register(&serio_bus);
1024 [ # # ]: 0 : if (error) {
1025 : 0 : pr_err("Failed to register serio bus, error: %d\n", error);
1026 : 0 : return error;
1027 : : }
1028 : :
1029 : : return 0;
1030 : : }
1031 : :
1032 : 0 : static void __exit serio_exit(void)
1033 : : {
1034 : 0 : bus_unregister(&serio_bus);
1035 : :
1036 : : /*
1037 : : * There should not be any outstanding events but work may
1038 : : * still be scheduled so simply cancel it.
1039 : : */
1040 : 0 : cancel_work_sync(&serio_event_work);
1041 : 0 : }
1042 : :
1043 : : subsys_initcall(serio_init);
1044 : : module_exit(serio_exit);
|
