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