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