2 * driver.c - device id matching, driver model, etc.
4 * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
7 #include <linux/string.h>
8 #include <linux/list.h>
9 #include <linux/module.h>
10 #include <linux/ctype.h>
11 #include <linux/slab.h>
12 #include <linux/pnp.h>
15 static int compare_func(const char *ida
, const char *idb
)
19 /* we only need to compare the last 4 chars */
20 for (i
= 3; i
< 7; i
++) {
22 idb
[i
] != 'X' && toupper(ida
[i
]) != toupper(idb
[i
]))
28 int compare_pnp_id(struct pnp_id
*pos
, const char *id
)
30 if (!pos
|| !id
|| (strlen(id
) != 7))
32 if (memcmp(id
, "ANYDEVS", 7) == 0)
35 if (memcmp(pos
->id
, id
, 3) == 0)
36 if (compare_func(pos
->id
, id
) == 1)
43 static const struct pnp_device_id
*match_device(struct pnp_driver
*drv
,
46 const struct pnp_device_id
*drv_id
= drv
->id_table
;
52 if (compare_pnp_id(dev
->id
, drv_id
->id
))
59 int pnp_device_attach(struct pnp_dev
*pnp_dev
)
62 if (pnp_dev
->status
!= PNP_READY
) {
63 spin_unlock(&pnp_lock
);
66 pnp_dev
->status
= PNP_ATTACHED
;
67 spin_unlock(&pnp_lock
);
71 void pnp_device_detach(struct pnp_dev
*pnp_dev
)
74 if (pnp_dev
->status
== PNP_ATTACHED
)
75 pnp_dev
->status
= PNP_READY
;
76 spin_unlock(&pnp_lock
);
77 pnp_disable_dev(pnp_dev
);
80 static int pnp_device_probe(struct device
*dev
)
83 struct pnp_driver
*pnp_drv
;
84 struct pnp_dev
*pnp_dev
;
85 const struct pnp_device_id
*dev_id
= NULL
;
86 pnp_dev
= to_pnp_dev(dev
);
87 pnp_drv
= to_pnp_driver(dev
->driver
);
89 error
= pnp_device_attach(pnp_dev
);
93 if (pnp_dev
->active
== 0) {
94 if (!(pnp_drv
->flags
& PNP_DRIVER_RES_DO_NOT_CHANGE
)) {
95 error
= pnp_activate_dev(pnp_dev
);
99 } else if ((pnp_drv
->flags
& PNP_DRIVER_RES_DISABLE
)
100 == PNP_DRIVER_RES_DISABLE
) {
101 error
= pnp_disable_dev(pnp_dev
);
106 if (pnp_drv
->probe
) {
107 dev_id
= match_device(pnp_drv
, pnp_dev
);
109 error
= pnp_drv
->probe(pnp_dev
, dev_id
);
112 pnp_dev
->driver
= pnp_drv
;
120 pnp_device_detach(pnp_dev
);
124 static int pnp_device_remove(struct device
*dev
)
126 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
127 struct pnp_driver
*drv
= pnp_dev
->driver
;
131 drv
->remove(pnp_dev
);
132 pnp_dev
->driver
= NULL
;
134 pnp_device_detach(pnp_dev
);
138 static void pnp_device_shutdown(struct device
*dev
)
140 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
141 struct pnp_driver
*drv
= pnp_dev
->driver
;
143 if (drv
&& drv
->shutdown
)
144 drv
->shutdown(pnp_dev
);
147 static int pnp_bus_match(struct device
*dev
, struct device_driver
*drv
)
149 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
150 struct pnp_driver
*pnp_drv
= to_pnp_driver(drv
);
152 if (match_device(pnp_drv
, pnp_dev
) == NULL
)
157 static int __pnp_bus_suspend(struct device
*dev
, pm_message_t state
)
159 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
160 struct pnp_driver
*pnp_drv
= pnp_dev
->driver
;
166 if (pnp_drv
->driver
.pm
&& pnp_drv
->driver
.pm
->suspend
) {
167 error
= pnp_drv
->driver
.pm
->suspend(dev
);
168 suspend_report_result(pnp_drv
->driver
.pm
->suspend
, error
);
173 if (pnp_drv
->suspend
) {
174 error
= pnp_drv
->suspend(pnp_dev
, state
);
179 if (pnp_can_disable(pnp_dev
)) {
180 error
= pnp_stop_dev(pnp_dev
);
185 if (pnp_dev
->protocol
->suspend
)
186 pnp_dev
->protocol
->suspend(pnp_dev
, state
);
190 static int pnp_bus_suspend(struct device
*dev
)
192 return __pnp_bus_suspend(dev
, PMSG_SUSPEND
);
195 static int pnp_bus_freeze(struct device
*dev
)
197 return __pnp_bus_suspend(dev
, PMSG_FREEZE
);
200 static int pnp_bus_resume(struct device
*dev
)
202 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
203 struct pnp_driver
*pnp_drv
= pnp_dev
->driver
;
209 if (pnp_dev
->protocol
->resume
) {
210 error
= pnp_dev
->protocol
->resume(pnp_dev
);
215 if (pnp_can_write(pnp_dev
)) {
216 error
= pnp_start_dev(pnp_dev
);
221 if (pnp_drv
->driver
.pm
&& pnp_drv
->driver
.pm
->resume
) {
222 error
= pnp_drv
->driver
.pm
->resume(dev
);
227 if (pnp_drv
->resume
) {
228 error
= pnp_drv
->resume(pnp_dev
);
236 static const struct dev_pm_ops pnp_bus_dev_pm_ops
= {
237 .suspend
= pnp_bus_suspend
,
238 .freeze
= pnp_bus_freeze
,
239 .resume
= pnp_bus_resume
,
242 struct bus_type pnp_bus_type
= {
244 .match
= pnp_bus_match
,
245 .probe
= pnp_device_probe
,
246 .remove
= pnp_device_remove
,
247 .shutdown
= pnp_device_shutdown
,
248 .pm
= &pnp_bus_dev_pm_ops
,
249 .dev_attrs
= pnp_interface_attrs
,
252 int pnp_register_driver(struct pnp_driver
*drv
)
254 drv
->driver
.name
= drv
->name
;
255 drv
->driver
.bus
= &pnp_bus_type
;
257 return driver_register(&drv
->driver
);
260 void pnp_unregister_driver(struct pnp_driver
*drv
)
262 driver_unregister(&drv
->driver
);
266 * pnp_add_id - adds an EISA id to the specified device
267 * @dev: pointer to the desired device
268 * @id: pointer to an EISA id string
270 struct pnp_id
*pnp_add_id(struct pnp_dev
*dev
, const char *id
)
272 struct pnp_id
*dev_id
, *ptr
;
274 dev_id
= kzalloc(sizeof(struct pnp_id
), GFP_KERNEL
);
278 dev_id
->id
[0] = id
[0];
279 dev_id
->id
[1] = id
[1];
280 dev_id
->id
[2] = id
[2];
281 dev_id
->id
[3] = tolower(id
[3]);
282 dev_id
->id
[4] = tolower(id
[4]);
283 dev_id
->id
[5] = tolower(id
[5]);
284 dev_id
->id
[6] = tolower(id
[6]);
285 dev_id
->id
[7] = '\0';
289 while (ptr
&& ptr
->next
)
299 EXPORT_SYMBOL(pnp_register_driver
);
300 EXPORT_SYMBOL(pnp_unregister_driver
);
301 EXPORT_SYMBOL(pnp_device_attach
);
302 EXPORT_SYMBOL(pnp_device_detach
);