USB: <linux/usb_ch9.h> becomes <linux/usb/ch9.h>
[linux-2.6] / drivers / pnp / card.c
1 /*
2  * card.c - contains functions for managing groups of PnP devices
3  *
4  * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
5  *
6  */
7
8 #include <linux/module.h>
9 #include <linux/slab.h>
10 #include <linux/pnp.h>
11 #include "base.h"
12
13 LIST_HEAD(pnp_cards);
14 static LIST_HEAD(pnp_card_drivers);
15
16
17 static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv, struct pnp_card * card)
18 {
19         const struct pnp_card_device_id * drv_id = drv->id_table;
20         while (*drv_id->id){
21                 if (compare_pnp_id(card->id,drv_id->id)) {
22                         int i = 0;
23                         for (;;) {
24                                 int found;
25                                 struct pnp_dev *dev;
26                                 if (i == PNP_MAX_DEVICES || ! *drv_id->devs[i].id)
27                                         return drv_id;
28                                 found = 0;
29                                 card_for_each_dev(card, dev) {
30                                         if (compare_pnp_id(dev->id, drv_id->devs[i].id)) {
31                                                 found = 1;
32                                                 break;
33                                         }
34                                 }
35                                 if (! found)
36                                         break;
37                                 i++;
38                         }
39                 }
40                 drv_id++;
41         }
42         return NULL;
43 }
44
45 static void card_remove(struct pnp_dev * dev)
46 {
47         dev->card_link = NULL;
48 }
49
50 static void card_remove_first(struct pnp_dev * dev)
51 {
52         struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver);
53         if (!dev->card || !drv)
54                 return;
55         if (drv->remove)
56                 drv->remove(dev->card_link);
57         drv->link.remove = &card_remove;
58         kfree(dev->card_link);
59         card_remove(dev);
60 }
61
62 static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
63 {
64         const struct pnp_card_device_id *id;
65         struct pnp_card_link *clink;
66         struct pnp_dev *dev;
67
68         if (!drv->probe)
69                 return 0;
70         id = match_card(drv,card);
71         if (!id)
72                 return 0;
73
74         clink = pnp_alloc(sizeof(*clink));
75         if (!clink)
76                 return 0;
77         clink->card = card;
78         clink->driver = drv;
79         clink->pm_state = PMSG_ON;
80
81         if (drv->probe(clink, id) >= 0)
82                 return 1;
83
84         /* Recovery */
85         card_for_each_dev(card, dev) {
86                 if (dev->card_link == clink)
87                         pnp_release_card_device(dev);
88         }
89         kfree(clink);
90         return 0;
91 }
92
93 /**
94  * pnp_add_card_id - adds an EISA id to the specified card
95  * @id: pointer to a pnp_id structure
96  * @card: pointer to the desired card
97  *
98  */
99
100 int pnp_add_card_id(struct pnp_id *id, struct pnp_card * card)
101 {
102         struct pnp_id * ptr;
103         if (!id)
104                 return -EINVAL;
105         if (!card)
106                 return -EINVAL;
107         id->next = NULL;
108         ptr = card->id;
109         while (ptr && ptr->next)
110                 ptr = ptr->next;
111         if (ptr)
112                 ptr->next = id;
113         else
114                 card->id = id;
115         return 0;
116 }
117
118 static void pnp_free_card_ids(struct pnp_card * card)
119 {
120         struct pnp_id * id;
121         struct pnp_id *next;
122         if (!card)
123                 return;
124         id = card->id;
125         while (id) {
126                 next = id->next;
127                 kfree(id);
128                 id = next;
129         }
130 }
131
132 static void pnp_release_card(struct device *dmdev)
133 {
134         struct pnp_card * card = to_pnp_card(dmdev);
135         pnp_free_card_ids(card);
136         kfree(card);
137 }
138
139
140 static ssize_t pnp_show_card_name(struct device *dmdev, struct device_attribute *attr, char *buf)
141 {
142         char *str = buf;
143         struct pnp_card *card = to_pnp_card(dmdev);
144         str += sprintf(str,"%s\n", card->name);
145         return (str - buf);
146 }
147
148 static DEVICE_ATTR(name,S_IRUGO,pnp_show_card_name,NULL);
149
150 static ssize_t pnp_show_card_ids(struct device *dmdev, struct device_attribute *attr, char *buf)
151 {
152         char *str = buf;
153         struct pnp_card *card = to_pnp_card(dmdev);
154         struct pnp_id * pos = card->id;
155
156         while (pos) {
157                 str += sprintf(str,"%s\n", pos->id);
158                 pos = pos->next;
159         }
160         return (str - buf);
161 }
162
163 static DEVICE_ATTR(card_id,S_IRUGO,pnp_show_card_ids,NULL);
164
165 static int pnp_interface_attach_card(struct pnp_card *card)
166 {
167         int rc = device_create_file(&card->dev,&dev_attr_name);
168         if (rc) return rc;
169
170         rc = device_create_file(&card->dev,&dev_attr_card_id);
171         if (rc) goto err_name;
172
173         return 0;
174
175 err_name:
176         device_remove_file(&card->dev,&dev_attr_name);
177         return rc;
178 }
179
180 /**
181  * pnp_add_card - adds a PnP card to the PnP Layer
182  * @card: pointer to the card to add
183  */
184
185 int pnp_add_card(struct pnp_card * card)
186 {
187         int error;
188         struct list_head * pos, * temp;
189         if (!card || !card->protocol)
190                 return -EINVAL;
191
192         sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number, card->number);
193         card->dev.parent = &card->protocol->dev;
194         card->dev.bus = NULL;
195         card->dev.release = &pnp_release_card;
196         error = device_register(&card->dev);
197
198         if (error == 0) {
199                 pnp_interface_attach_card(card);
200                 spin_lock(&pnp_lock);
201                 list_add_tail(&card->global_list, &pnp_cards);
202                 list_add_tail(&card->protocol_list, &card->protocol->cards);
203                 spin_unlock(&pnp_lock);
204
205                 /* we wait until now to add devices in order to ensure the drivers
206                  * will be able to use all of the related devices on the card
207                  * without waiting any unresonable length of time */
208                 list_for_each(pos,&card->devices){
209                         struct pnp_dev *dev = card_to_pnp_dev(pos);
210                         __pnp_add_device(dev);
211                 }
212
213                 /* match with card drivers */
214                 list_for_each_safe(pos,temp,&pnp_card_drivers){
215                         struct pnp_card_driver * drv = list_entry(pos, struct pnp_card_driver, global_list);
216                         card_probe(card,drv);
217                 }
218         } else
219                 pnp_err("sysfs failure, card '%s' will be unavailable", card->dev.bus_id);
220         return error;
221 }
222
223 /**
224  * pnp_remove_card - removes a PnP card from the PnP Layer
225  * @card: pointer to the card to remove
226  */
227
228 void pnp_remove_card(struct pnp_card * card)
229 {
230         struct list_head *pos, *temp;
231         if (!card)
232                 return;
233         device_unregister(&card->dev);
234         spin_lock(&pnp_lock);
235         list_del(&card->global_list);
236         list_del(&card->protocol_list);
237         spin_unlock(&pnp_lock);
238         list_for_each_safe(pos,temp,&card->devices){
239                 struct pnp_dev *dev = card_to_pnp_dev(pos);
240                 pnp_remove_card_device(dev);
241         }
242 }
243
244 /**
245  * pnp_add_card_device - adds a device to the specified card
246  * @card: pointer to the card to add to
247  * @dev: pointer to the device to add
248  */
249
250 int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev)
251 {
252         if (!card || !dev || !dev->protocol)
253                 return -EINVAL;
254         dev->dev.parent = &card->dev;
255         dev->card_link = NULL;
256         snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x", dev->protocol->number,
257                  card->number,dev->number);
258         spin_lock(&pnp_lock);
259         dev->card = card;
260         list_add_tail(&dev->card_list, &card->devices);
261         spin_unlock(&pnp_lock);
262         return 0;
263 }
264
265 /**
266  * pnp_remove_card_device- removes a device from the specified card
267  * @dev: pointer to the device to remove
268  */
269
270 void pnp_remove_card_device(struct pnp_dev * dev)
271 {
272         spin_lock(&pnp_lock);
273         dev->card = NULL;
274         list_del(&dev->card_list);
275         spin_unlock(&pnp_lock);
276         __pnp_remove_device(dev);
277 }
278
279 /**
280  * pnp_request_card_device - Searches for a PnP device under the specified card
281  * @clink: pointer to the card link, cannot be NULL
282  * @id: pointer to a PnP ID structure that explains the rules for finding the device
283  * @from: Starting place to search from. If NULL it will start from the begining.
284  */
285
286 struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from)
287 {
288         struct list_head * pos;
289         struct pnp_dev * dev;
290         struct pnp_card_driver * drv;
291         struct pnp_card * card;
292         if (!clink || !id)
293                 goto done;
294         card = clink->card;
295         drv = clink->driver;
296         if (!from) {
297                 pos = card->devices.next;
298         } else {
299                 if (from->card != card)
300                         goto done;
301                 pos = from->card_list.next;
302         }
303         while (pos != &card->devices) {
304                 dev = card_to_pnp_dev(pos);
305                 if ((!dev->card_link) && compare_pnp_id(dev->id,id))
306                         goto found;
307                 pos = pos->next;
308         }
309
310 done:
311         return NULL;
312
313 found:
314         down_write(&dev->dev.bus->subsys.rwsem);
315         dev->card_link = clink;
316         dev->dev.driver = &drv->link.driver;
317         if (pnp_bus_type.probe(&dev->dev))
318                 goto err_out;
319         if (device_bind_driver(&dev->dev))
320                 goto err_out;
321
322         up_write(&dev->dev.bus->subsys.rwsem);
323
324         return dev;
325
326 err_out:
327         dev->dev.driver = NULL;
328         dev->card_link = NULL;
329         up_write(&dev->dev.bus->subsys.rwsem);
330         return NULL;
331 }
332
333 /**
334  * pnp_release_card_device - call this when the driver no longer needs the device
335  * @dev: pointer to the PnP device stucture
336  */
337
338 void pnp_release_card_device(struct pnp_dev * dev)
339 {
340         struct pnp_card_driver * drv = dev->card_link->driver;
341         if (!drv)
342                 return;
343         down_write(&dev->dev.bus->subsys.rwsem);
344         drv->link.remove = &card_remove;
345         device_release_driver(&dev->dev);
346         drv->link.remove = &card_remove_first;
347         up_write(&dev->dev.bus->subsys.rwsem);
348 }
349
350 /*
351  * suspend/resume callbacks
352  */
353 static int card_suspend(struct pnp_dev *dev, pm_message_t state)
354 {
355         struct pnp_card_link *link = dev->card_link;
356         if (link->pm_state.event == state.event)
357                 return 0;
358         link->pm_state = state;
359         return link->driver->suspend(link, state);
360 }
361
362 static int card_resume(struct pnp_dev *dev)
363 {
364         struct pnp_card_link *link = dev->card_link;
365         if (link->pm_state.event == PM_EVENT_ON)
366                 return 0;
367         link->pm_state = PMSG_ON;
368         link->driver->resume(link);
369         return 0;
370 }
371
372 /**
373  * pnp_register_card_driver - registers a PnP card driver with the PnP Layer
374  * @drv: pointer to the driver to register
375  */
376
377 int pnp_register_card_driver(struct pnp_card_driver * drv)
378 {
379         int error;
380         struct list_head *pos, *temp;
381
382         drv->link.name = drv->name;
383         drv->link.id_table = NULL;      /* this will disable auto matching */
384         drv->link.flags = drv->flags;
385         drv->link.probe = NULL;
386         drv->link.remove = &card_remove_first;
387         drv->link.suspend = drv->suspend ? card_suspend : NULL;
388         drv->link.resume = drv->resume ? card_resume : NULL;
389
390         error = pnp_register_driver(&drv->link);
391         if (error < 0)
392                 return error;
393
394         spin_lock(&pnp_lock);
395         list_add_tail(&drv->global_list, &pnp_card_drivers);
396         spin_unlock(&pnp_lock);
397
398         list_for_each_safe(pos,temp,&pnp_cards){
399                 struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
400                 card_probe(card,drv);
401         }
402         return 0;
403 }
404
405 /**
406  * pnp_unregister_card_driver - unregisters a PnP card driver from the PnP Layer
407  * @drv: pointer to the driver to unregister
408  */
409
410 void pnp_unregister_card_driver(struct pnp_card_driver * drv)
411 {
412         spin_lock(&pnp_lock);
413         list_del(&drv->global_list);
414         spin_unlock(&pnp_lock);
415         pnp_unregister_driver(&drv->link);
416 }
417
418 #if 0
419 EXPORT_SYMBOL(pnp_add_card);
420 EXPORT_SYMBOL(pnp_remove_card);
421 EXPORT_SYMBOL(pnp_add_card_device);
422 EXPORT_SYMBOL(pnp_remove_card_device);
423 EXPORT_SYMBOL(pnp_add_card_id);
424 #endif  /*  0  */
425 EXPORT_SYMBOL(pnp_request_card_device);
426 EXPORT_SYMBOL(pnp_release_card_device);
427 EXPORT_SYMBOL(pnp_register_card_driver);
428 EXPORT_SYMBOL(pnp_unregister_card_driver);