2 * card.c - contains functions for managing groups of PnP devices
4 * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
7 #include <linux/module.h>
8 #include <linux/slab.h>
13 static LIST_HEAD(pnp_card_drivers
);
15 static const struct pnp_card_device_id
*match_card(struct pnp_card_driver
*drv
,
16 struct pnp_card
*card
)
18 const struct pnp_card_device_id
*drv_id
= drv
->id_table
;
21 if (compare_pnp_id(card
->id
, drv_id
->id
)) {
28 if (i
== PNP_MAX_DEVICES
||
32 card_for_each_dev(card
, dev
) {
33 if (compare_pnp_id(dev
->id
,
34 drv_id
->devs
[i
].id
)) {
49 static void card_remove(struct pnp_dev
*dev
)
51 dev
->card_link
= NULL
;
54 static void card_remove_first(struct pnp_dev
*dev
)
56 struct pnp_card_driver
*drv
= to_pnp_card_driver(dev
->driver
);
58 if (!dev
->card
|| !drv
)
61 drv
->remove(dev
->card_link
);
62 drv
->link
.remove
= &card_remove
;
63 kfree(dev
->card_link
);
67 static int card_probe(struct pnp_card
*card
, struct pnp_card_driver
*drv
)
69 const struct pnp_card_device_id
*id
;
70 struct pnp_card_link
*clink
;
75 id
= match_card(drv
, card
);
79 clink
= pnp_alloc(sizeof(*clink
));
84 clink
->pm_state
= PMSG_ON
;
86 if (drv
->probe(clink
, id
) >= 0)
90 card_for_each_dev(card
, dev
) {
91 if (dev
->card_link
== clink
)
92 pnp_release_card_device(dev
);
99 * pnp_add_card_id - adds an EISA id to the specified card
100 * @id: pointer to a pnp_id structure
101 * @card: pointer to the desired card
103 int pnp_add_card_id(struct pnp_id
*id
, struct pnp_card
*card
)
109 while (ptr
&& ptr
->next
)
118 static void pnp_free_card_ids(struct pnp_card
*card
)
131 static void pnp_release_card(struct device
*dmdev
)
133 struct pnp_card
*card
= to_pnp_card(dmdev
);
135 pnp_free_card_ids(card
);
139 static ssize_t
pnp_show_card_name(struct device
*dmdev
,
140 struct device_attribute
*attr
, char *buf
)
143 struct pnp_card
*card
= to_pnp_card(dmdev
);
145 str
+= sprintf(str
, "%s\n", card
->name
);
149 static DEVICE_ATTR(name
, S_IRUGO
, pnp_show_card_name
, NULL
);
151 static ssize_t
pnp_show_card_ids(struct device
*dmdev
,
152 struct device_attribute
*attr
, char *buf
)
155 struct pnp_card
*card
= to_pnp_card(dmdev
);
156 struct pnp_id
*pos
= card
->id
;
159 str
+= sprintf(str
, "%s\n", pos
->id
);
165 static DEVICE_ATTR(card_id
, S_IRUGO
, pnp_show_card_ids
, NULL
);
167 static int pnp_interface_attach_card(struct pnp_card
*card
)
169 int rc
= device_create_file(&card
->dev
, &dev_attr_name
);
174 rc
= device_create_file(&card
->dev
, &dev_attr_card_id
);
181 device_remove_file(&card
->dev
, &dev_attr_name
);
186 * pnp_add_card - adds a PnP card to the PnP Layer
187 * @card: pointer to the card to add
189 int pnp_add_card(struct pnp_card
*card
)
192 struct list_head
*pos
, *temp
;
194 sprintf(card
->dev
.bus_id
, "%02x:%02x", card
->protocol
->number
,
196 card
->dev
.parent
= &card
->protocol
->dev
;
197 card
->dev
.bus
= NULL
;
198 card
->dev
.release
= &pnp_release_card
;
199 error
= device_register(&card
->dev
);
201 pnp_err("sysfs failure, card '%s' will be unavailable",
206 pnp_interface_attach_card(card
);
207 spin_lock(&pnp_lock
);
208 list_add_tail(&card
->global_list
, &pnp_cards
);
209 list_add_tail(&card
->protocol_list
, &card
->protocol
->cards
);
210 spin_unlock(&pnp_lock
);
212 /* we wait until now to add devices in order to ensure the drivers
213 * will be able to use all of the related devices on the card
214 * without waiting an unreasonable length of time */
215 list_for_each(pos
, &card
->devices
) {
216 struct pnp_dev
*dev
= card_to_pnp_dev(pos
);
217 __pnp_add_device(dev
);
220 /* match with card drivers */
221 list_for_each_safe(pos
, temp
, &pnp_card_drivers
) {
222 struct pnp_card_driver
*drv
=
223 list_entry(pos
, struct pnp_card_driver
,
225 card_probe(card
, drv
);
231 * pnp_remove_card - removes a PnP card from the PnP Layer
232 * @card: pointer to the card to remove
234 void pnp_remove_card(struct pnp_card
*card
)
236 struct list_head
*pos
, *temp
;
238 device_unregister(&card
->dev
);
239 spin_lock(&pnp_lock
);
240 list_del(&card
->global_list
);
241 list_del(&card
->protocol_list
);
242 spin_unlock(&pnp_lock
);
243 list_for_each_safe(pos
, temp
, &card
->devices
) {
244 struct pnp_dev
*dev
= card_to_pnp_dev(pos
);
245 pnp_remove_card_device(dev
);
250 * pnp_add_card_device - adds a device to the specified card
251 * @card: pointer to the card to add to
252 * @dev: pointer to the device to add
254 int pnp_add_card_device(struct pnp_card
*card
, struct pnp_dev
*dev
)
256 dev
->dev
.parent
= &card
->dev
;
257 dev
->card_link
= NULL
;
258 snprintf(dev
->dev
.bus_id
, BUS_ID_SIZE
, "%02x:%02x.%02x",
259 dev
->protocol
->number
, card
->number
, dev
->number
);
260 spin_lock(&pnp_lock
);
262 list_add_tail(&dev
->card_list
, &card
->devices
);
263 spin_unlock(&pnp_lock
);
268 * pnp_remove_card_device- removes a device from the specified card
269 * @dev: pointer to the device to remove
271 void pnp_remove_card_device(struct pnp_dev
*dev
)
273 spin_lock(&pnp_lock
);
275 list_del(&dev
->card_list
);
276 spin_unlock(&pnp_lock
);
277 __pnp_remove_device(dev
);
281 * pnp_request_card_device - Searches for a PnP device under the specified card
282 * @clink: pointer to the card link, cannot be NULL
283 * @id: pointer to a PnP ID structure that explains the rules for finding the device
284 * @from: Starting place to search from. If NULL it will start from the begining.
286 struct pnp_dev
*pnp_request_card_device(struct pnp_card_link
*clink
,
287 const char *id
, struct pnp_dev
*from
)
289 struct list_head
*pos
;
291 struct pnp_card_driver
*drv
;
292 struct pnp_card
*card
;
300 pos
= card
->devices
.next
;
302 if (from
->card
!= card
)
304 pos
= from
->card_list
.next
;
306 while (pos
!= &card
->devices
) {
307 dev
= card_to_pnp_dev(pos
);
308 if ((!dev
->card_link
) && compare_pnp_id(dev
->id
, id
))
316 dev
->card_link
= clink
;
317 dev
->dev
.driver
= &drv
->link
.driver
;
318 if (pnp_bus_type
.probe(&dev
->dev
))
320 if (device_bind_driver(&dev
->dev
))
326 dev
->dev
.driver
= NULL
;
327 dev
->card_link
= NULL
;
332 * pnp_release_card_device - call this when the driver no longer needs the device
333 * @dev: pointer to the PnP device stucture
335 void pnp_release_card_device(struct pnp_dev
*dev
)
337 struct pnp_card_driver
*drv
= dev
->card_link
->driver
;
339 drv
->link
.remove
= &card_remove
;
340 device_release_driver(&dev
->dev
);
341 drv
->link
.remove
= &card_remove_first
;
345 * suspend/resume callbacks
347 static int card_suspend(struct pnp_dev
*dev
, pm_message_t state
)
349 struct pnp_card_link
*link
= dev
->card_link
;
351 if (link
->pm_state
.event
== state
.event
)
353 link
->pm_state
= state
;
354 return link
->driver
->suspend(link
, state
);
357 static int card_resume(struct pnp_dev
*dev
)
359 struct pnp_card_link
*link
= dev
->card_link
;
361 if (link
->pm_state
.event
== PM_EVENT_ON
)
363 link
->pm_state
= PMSG_ON
;
364 link
->driver
->resume(link
);
369 * pnp_register_card_driver - registers a PnP card driver with the PnP Layer
370 * @drv: pointer to the driver to register
372 int pnp_register_card_driver(struct pnp_card_driver
*drv
)
375 struct list_head
*pos
, *temp
;
377 drv
->link
.name
= drv
->name
;
378 drv
->link
.id_table
= NULL
; /* this will disable auto matching */
379 drv
->link
.flags
= drv
->flags
;
380 drv
->link
.probe
= NULL
;
381 drv
->link
.remove
= &card_remove_first
;
382 drv
->link
.suspend
= drv
->suspend
? card_suspend
: NULL
;
383 drv
->link
.resume
= drv
->resume
? card_resume
: NULL
;
385 error
= pnp_register_driver(&drv
->link
);
389 spin_lock(&pnp_lock
);
390 list_add_tail(&drv
->global_list
, &pnp_card_drivers
);
391 spin_unlock(&pnp_lock
);
393 list_for_each_safe(pos
, temp
, &pnp_cards
) {
394 struct pnp_card
*card
=
395 list_entry(pos
, struct pnp_card
, global_list
);
396 card_probe(card
, drv
);
402 * pnp_unregister_card_driver - unregisters a PnP card driver from the PnP Layer
403 * @drv: pointer to the driver to unregister
405 void pnp_unregister_card_driver(struct pnp_card_driver
*drv
)
407 spin_lock(&pnp_lock
);
408 list_del(&drv
->global_list
);
409 spin_unlock(&pnp_lock
);
410 pnp_unregister_driver(&drv
->link
);
413 EXPORT_SYMBOL(pnp_request_card_device
);
414 EXPORT_SYMBOL(pnp_release_card_device
);
415 EXPORT_SYMBOL(pnp_register_card_driver
);
416 EXPORT_SYMBOL(pnp_unregister_card_driver
);