Branch data 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 : 84 : static int serio_connect_driver(struct serio *serio, struct serio_driver *drv)
43 : : {
44 : 84 : int retval;
45 : :
46 : 84 : mutex_lock(&serio->drv_mutex);
47 : 84 : retval = drv->connect(serio, drv);
48 : 84 : mutex_unlock(&serio->drv_mutex);
49 : :
50 : 84 : 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 : 112 : static int serio_match_port(const struct serio_device_id *ids, struct serio *serio)
74 : : {
75 [ + + - + ]: 196 : while (ids->type || ids->proto) {
76 [ + - + + ]: 168 : if ((ids->type == SERIO_ANY || ids->type == serio->id.type) &&
77 [ - + - - ]: 84 : (ids->proto == SERIO_ANY || ids->proto == serio->id.proto) &&
78 [ - + - - ]: 84 : (ids->extra == SERIO_ANY || ids->extra == serio->id.extra) &&
79 [ - + - - ]: 84 : (ids->id == SERIO_ANY || ids->id == serio->id.id))
80 : : return 1;
81 : 84 : 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 : 0 : 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 : 0 : 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 : 224 : static struct serio_event *serio_get_event(void)
151 : : {
152 : 224 : struct serio_event *event = NULL;
153 : 224 : unsigned long flags;
154 : :
155 : 224 : spin_lock_irqsave(&serio_event_lock, flags);
156 : :
157 [ + + ]: 224 : if (!list_empty(&serio_event_list)) {
158 : 112 : event = list_first_entry(&serio_event_list,
159 : : struct serio_event, node);
160 : 112 : list_del_init(&event->node);
161 : : }
162 : :
163 : 224 : spin_unlock_irqrestore(&serio_event_lock, flags);
164 : 224 : return event;
165 : : }
166 : :
167 : 112 : static void serio_free_event(struct serio_event *event)
168 : : {
169 : 112 : module_put(event->owner);
170 : 112 : kfree(event);
171 : 112 : }
172 : :
173 : 112 : static void serio_remove_duplicate_events(void *object,
174 : : enum serio_event_type type)
175 : : {
176 : 112 : struct serio_event *e, *next;
177 : 112 : unsigned long flags;
178 : :
179 : 112 : spin_lock_irqsave(&serio_event_lock, flags);
180 : :
181 [ - + ]: 112 : list_for_each_entry_safe(e, next, &serio_event_list, node) {
182 [ # # ]: 0 : 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 : 0 : serio_free_event(e);
193 : : }
194 : : }
195 : :
196 : 112 : spin_unlock_irqrestore(&serio_event_lock, flags);
197 : 112 : }
198 : :
199 : 112 : static void serio_handle_event(struct work_struct *work)
200 : : {
201 : 112 : struct serio_event *event;
202 : :
203 : 112 : mutex_lock(&serio_mutex);
204 : :
205 [ + + ]: 224 : while ((event = serio_get_event())) {
206 : :
207 [ + - - - : 112 : switch (event->type) {
+ - ]
208 : :
209 : 56 : case SERIO_REGISTER_PORT:
210 : 56 : serio_add_port(event->object);
211 : 56 : break;
212 : :
213 : 0 : case SERIO_RECONNECT_PORT:
214 : 0 : serio_reconnect_port(event->object);
215 : 0 : break;
216 : :
217 : 0 : case SERIO_RESCAN_PORT:
218 : 0 : serio_disconnect_port(event->object);
219 : 0 : serio_find_driver(event->object);
220 : 0 : break;
221 : :
222 : 0 : case SERIO_RECONNECT_SUBTREE:
223 : 0 : serio_reconnect_subtree(event->object);
224 : 0 : break;
225 : :
226 : 56 : case SERIO_ATTACH_DRIVER:
227 : 56 : serio_attach_driver(event->object);
228 : 56 : break;
229 : : }
230 : :
231 : 112 : serio_remove_duplicate_events(event->object, event->type);
232 : 112 : serio_free_event(event);
233 : : }
234 : :
235 : 112 : mutex_unlock(&serio_mutex);
236 : 112 : }
237 : :
238 : : static DECLARE_WORK(serio_event_work, serio_handle_event);
239 : :
240 : 112 : static int serio_queue_event(void *object, struct module *owner,
241 : : enum serio_event_type event_type)
242 : : {
243 : 112 : unsigned long flags;
244 : 112 : struct serio_event *event;
245 : 112 : int retval = 0;
246 : :
247 : 112 : 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 [ - + ]: 112 : list_for_each_entry_reverse(event, &serio_event_list, node) {
257 [ # # ]: 0 : if (event->object == object) {
258 [ # # ]: 0 : if (event->type == event_type)
259 : 0 : goto out;
260 : : break;
261 : : }
262 : : }
263 : :
264 : 112 : event = kmalloc(sizeof(struct serio_event), GFP_ATOMIC);
265 [ - + ]: 112 : 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 [ - + ]: 112 : if (!try_module_get(owner)) {
272 : 0 : pr_warn("Can't get module reference, dropping event %d\n",
273 : : event_type);
274 : 0 : kfree(event);
275 : 0 : retval = -EINVAL;
276 : 0 : goto out;
277 : : }
278 : :
279 : 112 : event->type = event_type;
280 : 112 : event->object = object;
281 : 112 : event->owner = owner;
282 : :
283 : 112 : list_add_tail(&event->node, &serio_event_list);
284 : 112 : queue_work(system_long_wq, &serio_event_work);
285 : :
286 : 112 : out:
287 : 112 : spin_unlock_irqrestore(&serio_event_lock, flags);
288 : 112 : 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 : 0 : struct serio_event *event, *next;
298 : 0 : 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 : 0 : 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 : 0 : struct serio_event *event;
321 : 0 : struct serio *serio, *child = NULL;
322 : 0 : 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 : 0 : struct device_driver *drv;
386 : 0 : 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 : 0 : 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 : 56 : static void serio_init_port(struct serio *serio)
498 : : {
499 : 56 : static atomic_t serio_no = ATOMIC_INIT(-1);
500 : :
501 : 56 : __module_get(THIS_MODULE);
502 : :
503 : 56 : INIT_LIST_HEAD(&serio->node);
504 : 56 : INIT_LIST_HEAD(&serio->child_node);
505 : 56 : INIT_LIST_HEAD(&serio->children);
506 : 56 : spin_lock_init(&serio->lock);
507 : 56 : mutex_init(&serio->drv_mutex);
508 : 56 : device_initialize(&serio->dev);
509 : 56 : dev_set_name(&serio->dev, "serio%lu",
510 : : (unsigned long)atomic_inc_return(&serio_no));
511 : 56 : serio->dev.bus = &serio_bus;
512 : 56 : serio->dev.release = serio_release_port;
513 : 56 : serio->dev.groups = serio_device_attr_groups;
514 [ - + ]: 56 : if (serio->parent) {
515 : 0 : serio->dev.parent = &serio->parent->dev;
516 : 0 : serio->depth = serio->parent->depth + 1;
517 : : } else
518 : 56 : serio->depth = 0;
519 : 56 : lockdep_set_subclass(&serio->lock, serio->depth);
520 : 56 : }
521 : :
522 : : /*
523 : : * Complete serio port registration.
524 : : * Driver core will attempt to find appropriate driver for the port.
525 : : */
526 : 56 : static void serio_add_port(struct serio *serio)
527 : : {
528 : 56 : struct serio *parent = serio->parent;
529 : 56 : int error;
530 : :
531 [ - + ]: 56 : 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 [ + - ]: 56 : list_add_tail(&serio->node, &serio_list);
538 : :
539 [ + - ]: 56 : if (serio->start)
540 : 56 : serio->start(serio);
541 : :
542 : 56 : error = device_add(&serio->dev);
543 [ - + ]: 56 : 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 : 56 : }
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 : 0 : 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 : 0 : int error;
606 : :
607 : 0 : 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 : 56 : void __serio_register_port(struct serio *serio, struct module *owner)
696 : : {
697 : 56 : serio_init_port(serio);
698 : 56 : serio_queue_event(serio, owner, SERIO_REGISTER_PORT);
699 : 56 : }
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 : 0 : 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 : 0 : 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 : 84 : static int serio_driver_probe(struct device *dev)
774 : : {
775 : 84 : struct serio *serio = to_serio_port(dev);
776 : 84 : struct serio_driver *drv = to_serio_driver(dev->driver);
777 : :
778 : 84 : return serio_connect_driver(serio, drv);
779 : : }
780 : :
781 : 0 : static int 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 : return 0;
787 : : }
788 : :
789 : 0 : static void serio_cleanup(struct serio *serio)
790 : : {
791 : 0 : mutex_lock(&serio->drv_mutex);
792 [ # # # # ]: 0 : if (serio->drv && serio->drv->cleanup)
793 : 0 : serio->drv->cleanup(serio);
794 : 0 : mutex_unlock(&serio->drv_mutex);
795 : 0 : }
796 : :
797 : 0 : static void serio_shutdown(struct device *dev)
798 : : {
799 : 0 : struct serio *serio = to_serio_port(dev);
800 : :
801 : 0 : serio_cleanup(serio);
802 : 0 : }
803 : :
804 : 56 : static void serio_attach_driver(struct serio_driver *drv)
805 : : {
806 : 56 : int error;
807 : :
808 : 56 : error = driver_attach(&drv->driver);
809 [ - + ]: 56 : if (error)
810 : 0 : pr_warn("driver_attach() failed for %s with error %d\n",
811 : : drv->driver.name, error);
812 : 56 : }
813 : :
814 : 56 : int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name)
815 : : {
816 : 56 : bool manual_bind = drv->manual_bind;
817 : 56 : int error;
818 : :
819 : 56 : drv->driver.bus = &serio_bus;
820 : 56 : drv->driver.owner = owner;
821 : 56 : drv->driver.mod_name = mod_name;
822 : :
823 : : /*
824 : : * Temporarily disable automatic binding because probing
825 : : * takes long time and we are better off doing it in kseriod
826 : : */
827 : 56 : drv->manual_bind = true;
828 : :
829 : 56 : error = driver_register(&drv->driver);
830 [ - + ]: 56 : if (error) {
831 : 0 : pr_err("driver_register() failed for %s, error: %d\n",
832 : : drv->driver.name, error);
833 : 0 : return error;
834 : : }
835 : :
836 : : /*
837 : : * Restore original bind mode and let kseriod bind the
838 : : * driver to free ports
839 : : */
840 [ + - ]: 56 : if (!manual_bind) {
841 : 56 : drv->manual_bind = false;
842 : 56 : error = serio_queue_event(drv, NULL, SERIO_ATTACH_DRIVER);
843 [ - + ]: 56 : if (error) {
844 : 0 : driver_unregister(&drv->driver);
845 : 0 : return error;
846 : : }
847 : : }
848 : :
849 : : return 0;
850 : : }
851 : : EXPORT_SYMBOL(__serio_register_driver);
852 : :
853 : 0 : void serio_unregister_driver(struct serio_driver *drv)
854 : : {
855 : 0 : struct serio *serio;
856 : :
857 : 0 : mutex_lock(&serio_mutex);
858 : :
859 : 0 : drv->manual_bind = true; /* so serio_find_driver ignores it */
860 : 0 : serio_remove_pending_events(drv);
861 : :
862 : 0 : start_over:
863 [ # # ]: 0 : list_for_each_entry(serio, &serio_list, node) {
864 [ # # ]: 0 : if (serio->drv == drv) {
865 : 0 : serio_disconnect_port(serio);
866 : 0 : serio_find_driver(serio);
867 : : /* we could've deleted some ports, restart */
868 : 0 : goto start_over;
869 : : }
870 : : }
871 : :
872 : 0 : driver_unregister(&drv->driver);
873 : 0 : mutex_unlock(&serio_mutex);
874 : 0 : }
875 : : EXPORT_SYMBOL(serio_unregister_driver);
876 : :
877 : 112 : static void serio_set_drv(struct serio *serio, struct serio_driver *drv)
878 : : {
879 : 112 : serio_pause_rx(serio);
880 : 112 : serio->drv = drv;
881 : 112 : serio_continue_rx(serio);
882 : : }
883 : :
884 : 224 : static int serio_bus_match(struct device *dev, struct device_driver *drv)
885 : : {
886 : 224 : struct serio *serio = to_serio_port(dev);
887 : 224 : struct serio_driver *serio_drv = to_serio_driver(drv);
888 : :
889 [ + - + + ]: 224 : if (serio->manual_bind || serio_drv->manual_bind)
890 : : return 0;
891 : :
892 : 112 : return serio_match_port(serio_drv->id_table, serio);
893 : : }
894 : :
895 : : #define SERIO_ADD_UEVENT_VAR(fmt, val...) \
896 : : do { \
897 : : int err = add_uevent_var(env, fmt, val); \
898 : : if (err) \
899 : : return err; \
900 : : } while (0)
901 : :
902 : 336 : static int serio_uevent(struct device *dev, struct kobj_uevent_env *env)
903 : : {
904 : 336 : struct serio *serio;
905 : :
906 [ + - ]: 336 : if (!dev)
907 : : return -ENODEV;
908 : :
909 : 336 : serio = to_serio_port(dev);
910 : :
911 [ + - ]: 336 : SERIO_ADD_UEVENT_VAR("SERIO_TYPE=%02x", serio->id.type);
912 [ + - ]: 336 : SERIO_ADD_UEVENT_VAR("SERIO_PROTO=%02x", serio->id.proto);
913 [ + - ]: 336 : SERIO_ADD_UEVENT_VAR("SERIO_ID=%02x", serio->id.id);
914 [ + - ]: 336 : SERIO_ADD_UEVENT_VAR("SERIO_EXTRA=%02x", serio->id.extra);
915 : :
916 [ + - ]: 336 : SERIO_ADD_UEVENT_VAR("MODALIAS=serio:ty%02Xpr%02Xid%02Xex%02X",
917 : : serio->id.type, serio->id.proto, serio->id.id, serio->id.extra);
918 : :
919 [ + - ]: 336 : if (serio->firmware_id[0])
920 [ - + ]: 336 : SERIO_ADD_UEVENT_VAR("SERIO_FIRMWARE_ID=%s",
921 : : serio->firmware_id);
922 : :
923 : : return 0;
924 : : }
925 : : #undef SERIO_ADD_UEVENT_VAR
926 : :
927 : : #ifdef CONFIG_PM
928 : 0 : static int serio_suspend(struct device *dev)
929 : : {
930 : 0 : struct serio *serio = to_serio_port(dev);
931 : :
932 : 0 : serio_cleanup(serio);
933 : :
934 : 0 : return 0;
935 : : }
936 : :
937 : 0 : static int serio_resume(struct device *dev)
938 : : {
939 : 0 : struct serio *serio = to_serio_port(dev);
940 : 0 : int error = -ENOENT;
941 : :
942 : 0 : mutex_lock(&serio->drv_mutex);
943 [ # # # # ]: 0 : if (serio->drv && serio->drv->fast_reconnect) {
944 : 0 : error = serio->drv->fast_reconnect(serio);
945 [ # # ]: 0 : if (error && error != -ENOENT)
946 : 0 : dev_warn(dev, "fast reconnect failed with error %d\n",
947 : : error);
948 : : }
949 : 0 : mutex_unlock(&serio->drv_mutex);
950 : :
951 [ # # ]: 0 : if (error) {
952 : : /*
953 : : * Driver reconnect can take a while, so better let
954 : : * kseriod deal with it.
955 : : */
956 : 0 : serio_queue_event(serio, NULL, SERIO_RECONNECT_PORT);
957 : : }
958 : :
959 : 0 : return 0;
960 : : }
961 : :
962 : : static const struct dev_pm_ops serio_pm_ops = {
963 : : .suspend = serio_suspend,
964 : : .resume = serio_resume,
965 : : .poweroff = serio_suspend,
966 : : .restore = serio_resume,
967 : : };
968 : : #endif /* CONFIG_PM */
969 : :
970 : : /* called from serio_driver->connect/disconnect methods under serio_mutex */
971 : 84 : int serio_open(struct serio *serio, struct serio_driver *drv)
972 : : {
973 : 84 : serio_set_drv(serio, drv);
974 : :
975 [ - + - - ]: 84 : if (serio->open && serio->open(serio)) {
976 : 0 : serio_set_drv(serio, NULL);
977 : 0 : return -1;
978 : : }
979 : : return 0;
980 : : }
981 : : EXPORT_SYMBOL(serio_open);
982 : :
983 : : /* called from serio_driver->connect/disconnect methods under serio_mutex */
984 : 28 : void serio_close(struct serio *serio)
985 : : {
986 [ + - ]: 28 : if (serio->close)
987 : 28 : serio->close(serio);
988 : :
989 : 28 : serio_set_drv(serio, NULL);
990 : 28 : }
991 : : EXPORT_SYMBOL(serio_close);
992 : :
993 : 3724 : irqreturn_t serio_interrupt(struct serio *serio,
994 : : unsigned char data, unsigned int dfl)
995 : : {
996 : 3724 : unsigned long flags;
997 : 3724 : irqreturn_t ret = IRQ_NONE;
998 : :
999 : 3724 : spin_lock_irqsave(&serio->lock, flags);
1000 : :
1001 [ + - ]: 3724 : if (likely(serio->drv)) {
1002 : 3724 : ret = serio->drv->interrupt(serio, data, dfl);
1003 [ # # # # ]: 0 : } else if (!dfl && device_is_registered(&serio->dev)) {
1004 : 0 : serio_rescan(serio);
1005 : 0 : ret = IRQ_HANDLED;
1006 : : }
1007 : :
1008 : 3724 : spin_unlock_irqrestore(&serio->lock, flags);
1009 : :
1010 : 3724 : return ret;
1011 : : }
1012 : : EXPORT_SYMBOL(serio_interrupt);
1013 : :
1014 : : struct bus_type serio_bus = {
1015 : : .name = "serio",
1016 : : .drv_groups = serio_driver_groups,
1017 : : .match = serio_bus_match,
1018 : : .uevent = serio_uevent,
1019 : : .probe = serio_driver_probe,
1020 : : .remove = serio_driver_remove,
1021 : : .shutdown = serio_shutdown,
1022 : : #ifdef CONFIG_PM
1023 : : .pm = &serio_pm_ops,
1024 : : #endif
1025 : : };
1026 : : EXPORT_SYMBOL(serio_bus);
1027 : :
1028 : 28 : static int __init serio_init(void)
1029 : : {
1030 : 28 : int error;
1031 : :
1032 : 28 : error = bus_register(&serio_bus);
1033 [ - + ]: 28 : if (error) {
1034 : 0 : pr_err("Failed to register serio bus, error: %d\n", error);
1035 : 0 : return error;
1036 : : }
1037 : :
1038 : : return 0;
1039 : : }
1040 : :
1041 : 0 : static void __exit serio_exit(void)
1042 : : {
1043 : 0 : bus_unregister(&serio_bus);
1044 : :
1045 : : /*
1046 : : * There should not be any outstanding events but work may
1047 : : * still be scheduled so simply cancel it.
1048 : : */
1049 : 0 : cancel_work_sync(&serio_event_work);
1050 : 0 : }
1051 : :
1052 : : subsys_initcall(serio_init);
1053 : : module_exit(serio_exit);
|
