Merge acpi-2.6.12 to-akpm
[linux-2.6] / drivers / w1 / w1_family.c
1 /*
2  *      w1_family.c
3  *
4  * Copyright (c) 2004 Evgeniy Polyakov <johnpol@2ka.mipt.ru>
5  *
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21
22 #include <linux/spinlock.h>
23 #include <linux/list.h>
24 #include <linux/delay.h>
25
26 #include "w1_family.h"
27
28 DEFINE_SPINLOCK(w1_flock);
29 static LIST_HEAD(w1_families);
30 extern void w1_reconnect_slaves(struct w1_family *f);
31
32 static int w1_check_family(struct w1_family *f)
33 {
34         if (!f->fops->rname || !f->fops->rbin)
35                 return -EINVAL;
36
37         return 0;
38 }
39
40 int w1_register_family(struct w1_family *newf)
41 {
42         struct list_head *ent, *n;
43         struct w1_family *f;
44         int ret = 0;
45
46         if (w1_check_family(newf))
47                 return -EINVAL;
48
49         spin_lock(&w1_flock);
50         list_for_each_safe(ent, n, &w1_families) {
51                 f = list_entry(ent, struct w1_family, family_entry);
52
53                 if (f->fid == newf->fid) {
54                         ret = -EEXIST;
55                         break;
56                 }
57         }
58
59         if (!ret) {
60                 atomic_set(&newf->refcnt, 0);
61                 newf->need_exit = 0;
62                 list_add_tail(&newf->family_entry, &w1_families);
63         }
64         spin_unlock(&w1_flock);
65
66         w1_reconnect_slaves(newf);
67
68         return ret;
69 }
70
71 void w1_unregister_family(struct w1_family *fent)
72 {
73         struct list_head *ent, *n;
74         struct w1_family *f;
75
76         spin_lock(&w1_flock);
77         list_for_each_safe(ent, n, &w1_families) {
78                 f = list_entry(ent, struct w1_family, family_entry);
79
80                 if (f->fid == fent->fid) {
81                         list_del(&fent->family_entry);
82                         break;
83                 }
84         }
85
86         fent->need_exit = 1;
87
88         spin_unlock(&w1_flock);
89
90         while (atomic_read(&fent->refcnt)) {
91                 printk(KERN_INFO "Waiting for family %u to become free: refcnt=%d.\n",
92                                 fent->fid, atomic_read(&fent->refcnt));
93
94                 if (msleep_interruptible(1000))
95                         flush_signals(current);
96         }
97 }
98
99 /*
100  * Should be called under w1_flock held.
101  */
102 struct w1_family * w1_family_registered(u8 fid)
103 {
104         struct list_head *ent, *n;
105         struct w1_family *f = NULL;
106         int ret = 0;
107
108         list_for_each_safe(ent, n, &w1_families) {
109                 f = list_entry(ent, struct w1_family, family_entry);
110
111                 if (f->fid == fid) {
112                         ret = 1;
113                         break;
114                 }
115         }
116
117         return (ret) ? f : NULL;
118 }
119
120 void w1_family_put(struct w1_family *f)
121 {
122         spin_lock(&w1_flock);
123         __w1_family_put(f);
124         spin_unlock(&w1_flock);
125 }
126
127 void __w1_family_put(struct w1_family *f)
128 {
129         if (atomic_dec_and_test(&f->refcnt))
130                 f->need_exit = 1;
131 }
132
133 void w1_family_get(struct w1_family *f)
134 {
135         spin_lock(&w1_flock);
136         __w1_family_get(f);
137         spin_unlock(&w1_flock);
138
139 }
140
141 void __w1_family_get(struct w1_family *f)
142 {
143         smp_mb__before_atomic_inc();
144         atomic_inc(&f->refcnt);
145         smp_mb__after_atomic_inc();
146 }
147
148 EXPORT_SYMBOL(w1_family_get);
149 EXPORT_SYMBOL(w1_family_put);
150 EXPORT_SYMBOL(w1_family_registered);
151 EXPORT_SYMBOL(w1_unregister_family);
152 EXPORT_SYMBOL(w1_register_family);