1 // SPDX-License-Identifier: GPL-2.0
3 * driver.c - device id matching, driver model, etc.
5 * Copyright 2002 Adam Belay <ambx1@neo.rr.com>
8 #include <linux/string.h>
9 #include <linux/list.h>
10 #include <linux/module.h>
11 #include <linux/ctype.h>
12 #include <linux/slab.h>
13 #include <linux/pnp.h>
16 static int compare_func(const char *ida
, const char *idb
)
20 /* we only need to compare the last 4 chars */
21 for (i
= 3; i
< 7; i
++) {
23 idb
[i
] != 'X' && toupper(ida
[i
]) != toupper(idb
[i
]))
29 int compare_pnp_id(struct pnp_id
*pos
, const char *id
)
31 if (!pos
|| !id
|| (strlen(id
) != 7))
33 if (memcmp(id
, "ANYDEVS", 7) == 0)
36 if (memcmp(pos
->id
, id
, 3) == 0)
37 if (compare_func(pos
->id
, id
) == 1)
44 static const struct pnp_device_id
*match_device(struct pnp_driver
*drv
,
47 const struct pnp_device_id
*drv_id
= drv
->id_table
;
53 if (compare_pnp_id(dev
->id
, drv_id
->id
))
60 int pnp_device_attach(struct pnp_dev
*pnp_dev
)
62 mutex_lock(&pnp_lock
);
63 if (pnp_dev
->status
!= PNP_READY
) {
64 mutex_unlock(&pnp_lock
);
67 pnp_dev
->status
= PNP_ATTACHED
;
68 mutex_unlock(&pnp_lock
);
71 EXPORT_SYMBOL(pnp_device_attach
);
73 void pnp_device_detach(struct pnp_dev
*pnp_dev
)
75 mutex_lock(&pnp_lock
);
76 if (pnp_dev
->status
== PNP_ATTACHED
)
77 pnp_dev
->status
= PNP_READY
;
78 mutex_unlock(&pnp_lock
);
80 EXPORT_SYMBOL(pnp_device_detach
);
82 static int pnp_device_probe(struct device
*dev
)
85 struct pnp_driver
*pnp_drv
;
86 struct pnp_dev
*pnp_dev
;
87 const struct pnp_device_id
*dev_id
= NULL
;
88 pnp_dev
= to_pnp_dev(dev
);
89 pnp_drv
= to_pnp_driver(dev
->driver
);
91 error
= pnp_device_attach(pnp_dev
);
95 if (pnp_dev
->active
== 0) {
96 if (!(pnp_drv
->flags
& PNP_DRIVER_RES_DO_NOT_CHANGE
)) {
97 error
= pnp_activate_dev(pnp_dev
);
101 } else if ((pnp_drv
->flags
& PNP_DRIVER_RES_DISABLE
)
102 == PNP_DRIVER_RES_DISABLE
) {
103 error
= pnp_disable_dev(pnp_dev
);
108 if (pnp_drv
->probe
) {
109 dev_id
= match_device(pnp_drv
, pnp_dev
);
111 error
= pnp_drv
->probe(pnp_dev
, dev_id
);
114 pnp_dev
->driver
= pnp_drv
;
122 pnp_device_detach(pnp_dev
);
126 static void pnp_device_remove(struct device
*dev
)
128 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
129 struct pnp_driver
*drv
= pnp_dev
->driver
;
133 drv
->remove(pnp_dev
);
134 pnp_dev
->driver
= NULL
;
137 if (pnp_dev
->active
&&
138 (!drv
|| !(drv
->flags
& PNP_DRIVER_RES_DO_NOT_CHANGE
)))
139 pnp_disable_dev(pnp_dev
);
141 pnp_device_detach(pnp_dev
);
144 static void pnp_device_shutdown(struct device
*dev
)
146 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
147 struct pnp_driver
*drv
= pnp_dev
->driver
;
149 if (drv
&& drv
->shutdown
)
150 drv
->shutdown(pnp_dev
);
153 static int pnp_bus_match(struct device
*dev
, struct device_driver
*drv
)
155 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
156 struct pnp_driver
*pnp_drv
= to_pnp_driver(drv
);
158 if (match_device(pnp_drv
, pnp_dev
) == NULL
)
163 static int __pnp_bus_suspend(struct device
*dev
, pm_message_t state
)
165 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
166 struct pnp_driver
*pnp_drv
= pnp_dev
->driver
;
172 if (pnp_drv
->driver
.pm
&& pnp_drv
->driver
.pm
->suspend
) {
173 error
= pnp_drv
->driver
.pm
->suspend(dev
);
174 suspend_report_result(pnp_drv
->driver
.pm
->suspend
, error
);
179 if (pnp_drv
->suspend
) {
180 error
= pnp_drv
->suspend(pnp_dev
, state
);
185 if (pnp_can_disable(pnp_dev
)) {
186 error
= pnp_stop_dev(pnp_dev
);
191 if (pnp_can_suspend(pnp_dev
))
192 pnp_dev
->protocol
->suspend(pnp_dev
, state
);
196 static int pnp_bus_suspend(struct device
*dev
)
198 return __pnp_bus_suspend(dev
, PMSG_SUSPEND
);
201 static int pnp_bus_freeze(struct device
*dev
)
203 return __pnp_bus_suspend(dev
, PMSG_FREEZE
);
206 static int pnp_bus_poweroff(struct device
*dev
)
208 return __pnp_bus_suspend(dev
, PMSG_HIBERNATE
);
211 static int pnp_bus_resume(struct device
*dev
)
213 struct pnp_dev
*pnp_dev
= to_pnp_dev(dev
);
214 struct pnp_driver
*pnp_drv
= pnp_dev
->driver
;
220 if (pnp_dev
->protocol
->resume
) {
221 error
= pnp_dev
->protocol
->resume(pnp_dev
);
226 if (pnp_can_write(pnp_dev
)) {
227 error
= pnp_start_dev(pnp_dev
);
232 if (pnp_drv
->driver
.pm
&& pnp_drv
->driver
.pm
->resume
) {
233 error
= pnp_drv
->driver
.pm
->resume(dev
);
238 if (pnp_drv
->resume
) {
239 error
= pnp_drv
->resume(pnp_dev
);
247 static const struct dev_pm_ops pnp_bus_dev_pm_ops
= {
248 /* Suspend callbacks */
249 .suspend
= pnp_bus_suspend
,
250 .resume
= pnp_bus_resume
,
251 /* Hibernate callbacks */
252 .freeze
= pnp_bus_freeze
,
253 .thaw
= pnp_bus_resume
,
254 .poweroff
= pnp_bus_poweroff
,
255 .restore
= pnp_bus_resume
,
258 struct bus_type pnp_bus_type
= {
260 .match
= pnp_bus_match
,
261 .probe
= pnp_device_probe
,
262 .remove
= pnp_device_remove
,
263 .shutdown
= pnp_device_shutdown
,
264 .pm
= &pnp_bus_dev_pm_ops
,
265 .dev_groups
= pnp_dev_groups
,
268 int pnp_register_driver(struct pnp_driver
*drv
)
270 drv
->driver
.name
= drv
->name
;
271 drv
->driver
.bus
= &pnp_bus_type
;
273 return driver_register(&drv
->driver
);
275 EXPORT_SYMBOL(pnp_register_driver
);
277 void pnp_unregister_driver(struct pnp_driver
*drv
)
279 driver_unregister(&drv
->driver
);
281 EXPORT_SYMBOL(pnp_unregister_driver
);
284 * pnp_add_id - adds an EISA id to the specified device
285 * @dev: pointer to the desired device
286 * @id: pointer to an EISA id string
288 struct pnp_id
*pnp_add_id(struct pnp_dev
*dev
, const char *id
)
290 struct pnp_id
*dev_id
, *ptr
;
292 dev_id
= kzalloc(sizeof(struct pnp_id
), GFP_KERNEL
);
296 dev_id
->id
[0] = id
[0];
297 dev_id
->id
[1] = id
[1];
298 dev_id
->id
[2] = id
[2];
299 dev_id
->id
[3] = tolower(id
[3]);
300 dev_id
->id
[4] = tolower(id
[4]);
301 dev_id
->id
[5] = tolower(id
[5]);
302 dev_id
->id
[6] = tolower(id
[6]);
303 dev_id
->id
[7] = '\0';
307 while (ptr
&& ptr
->next
)