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