Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /********************************************************************* |
2 | * | |
3 | * sir_dongle.c: manager for serial dongle protocol drivers | |
4 | * | |
5 | * Copyright (c) 2002 Martin Diehl | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License as | |
9 | * published by the Free Software Foundation; either version 2 of | |
10 | * the License, or (at your option) any later version. | |
11 | * | |
12 | ********************************************************************/ | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/kernel.h> | |
1da177e4 | 16 | #include <linux/kmod.h> |
d4ccd08c | 17 | #include <linux/mutex.h> |
1da177e4 LT |
18 | |
19 | #include <net/irda/irda.h> | |
20 | ||
21 | #include "sir-dev.h" | |
22 | ||
23 | /************************************************************************** | |
24 | * | |
25 | * dongle registration and attachment | |
26 | * | |
27 | */ | |
28 | ||
29 | static LIST_HEAD(dongle_list); /* list of registered dongle drivers */ | |
d4ccd08c | 30 | static DEFINE_MUTEX(dongle_list_lock); /* protects the list */ |
1da177e4 LT |
31 | |
32 | int irda_register_dongle(struct dongle_driver *new) | |
33 | { | |
34 | struct list_head *entry; | |
35 | struct dongle_driver *drv; | |
36 | ||
37 | IRDA_DEBUG(0, "%s : registering dongle \"%s\" (%d).\n", | |
a97a6f10 | 38 | __func__, new->driver_name, new->type); |
1da177e4 | 39 | |
d4ccd08c | 40 | mutex_lock(&dongle_list_lock); |
1da177e4 LT |
41 | list_for_each(entry, &dongle_list) { |
42 | drv = list_entry(entry, struct dongle_driver, dongle_list); | |
43 | if (new->type == drv->type) { | |
d4ccd08c | 44 | mutex_unlock(&dongle_list_lock); |
1da177e4 LT |
45 | return -EEXIST; |
46 | } | |
47 | } | |
48 | list_add(&new->dongle_list, &dongle_list); | |
d4ccd08c | 49 | mutex_unlock(&dongle_list_lock); |
1da177e4 LT |
50 | return 0; |
51 | } | |
214ad784 | 52 | EXPORT_SYMBOL(irda_register_dongle); |
1da177e4 LT |
53 | |
54 | int irda_unregister_dongle(struct dongle_driver *drv) | |
55 | { | |
d4ccd08c | 56 | mutex_lock(&dongle_list_lock); |
1da177e4 | 57 | list_del(&drv->dongle_list); |
d4ccd08c | 58 | mutex_unlock(&dongle_list_lock); |
1da177e4 LT |
59 | return 0; |
60 | } | |
214ad784 | 61 | EXPORT_SYMBOL(irda_unregister_dongle); |
1da177e4 LT |
62 | |
63 | int sirdev_get_dongle(struct sir_dev *dev, IRDA_DONGLE type) | |
64 | { | |
65 | struct list_head *entry; | |
66 | const struct dongle_driver *drv = NULL; | |
67 | int err = -EINVAL; | |
68 | ||
1da177e4 | 69 | request_module("irda-dongle-%d", type); |
1da177e4 LT |
70 | |
71 | if (dev->dongle_drv != NULL) | |
72 | return -EBUSY; | |
73 | ||
74 | /* serialize access to the list of registered dongles */ | |
d4ccd08c | 75 | mutex_lock(&dongle_list_lock); |
1da177e4 LT |
76 | |
77 | list_for_each(entry, &dongle_list) { | |
78 | drv = list_entry(entry, struct dongle_driver, dongle_list); | |
79 | if (drv->type == type) | |
80 | break; | |
81 | else | |
82 | drv = NULL; | |
83 | } | |
84 | ||
85 | if (!drv) { | |
86 | err = -ENODEV; | |
87 | goto out_unlock; /* no such dongle */ | |
88 | } | |
89 | ||
90 | /* handling of SMP races with dongle module removal - three cases: | |
91 | * 1) dongle driver was already unregistered - then we haven't found the | |
92 | * requested dongle above and are already out here | |
93 | * 2) the module is already marked deleted but the driver is still | |
94 | * registered - then the try_module_get() below will fail | |
95 | * 3) the try_module_get() below succeeds before the module is marked | |
96 | * deleted - then sys_delete_module() fails and prevents the removal | |
97 | * because the module is in use. | |
98 | */ | |
99 | ||
100 | if (!try_module_get(drv->owner)) { | |
101 | err = -ESTALE; | |
102 | goto out_unlock; /* rmmod already pending */ | |
103 | } | |
104 | dev->dongle_drv = drv; | |
105 | ||
106 | if (!drv->open || (err=drv->open(dev))!=0) | |
107 | goto out_reject; /* failed to open driver */ | |
108 | ||
d4ccd08c | 109 | mutex_unlock(&dongle_list_lock); |
1da177e4 LT |
110 | return 0; |
111 | ||
112 | out_reject: | |
113 | dev->dongle_drv = NULL; | |
114 | module_put(drv->owner); | |
115 | out_unlock: | |
d4ccd08c | 116 | mutex_unlock(&dongle_list_lock); |
1da177e4 LT |
117 | return err; |
118 | } | |
119 | ||
120 | int sirdev_put_dongle(struct sir_dev *dev) | |
121 | { | |
122 | const struct dongle_driver *drv = dev->dongle_drv; | |
123 | ||
124 | if (drv) { | |
125 | if (drv->close) | |
126 | drv->close(dev); /* close this dongle instance */ | |
127 | ||
128 | dev->dongle_drv = NULL; /* unlink the dongle driver */ | |
129 | module_put(drv->owner);/* decrement driver's module refcount */ | |
130 | } | |
131 | ||
132 | return 0; | |
133 | } |