1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * driver.c - device id matching, driver model, etc. 4 * 5 * Copyright 2002 Adam Belay <ambx1@neo.rr.com> 6 */ 7 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> 14 #include "base.h" 15 16 static int compare_func(const char *ida, const char *idb) 17 { 18 int i; 19 20 /* we only need to compare the last 4 chars */ 21 for (i = 3; i < 7; i++) { 22 if (ida[i] != 'X' && 23 idb[i] != 'X' && toupper(ida[i]) != toupper(idb[i])) 24 return 0; 25 } 26 return 1; 27 } 28 29 int compare_pnp_id(struct pnp_id *pos, const char *id) 30 { 31 if (!pos || !id || (strlen(id) != 7)) 32 return 0; 33 if (memcmp(id, "ANYDEVS", 7) == 0) 34 return 1; 35 while (pos) { 36 if (memcmp(pos->id, id, 3) == 0) 37 if (compare_func(pos->id, id) == 1) 38 return 1; 39 pos = pos->next; 40 } 41 return 0; 42 } 43 44 static const struct pnp_device_id *match_device(const struct pnp_driver *drv, 45 struct pnp_dev *dev) 46 { 47 const struct pnp_device_id *drv_id = drv->id_table; 48 49 if (!drv_id) 50 return NULL; 51 52 while (*drv_id->id) { 53 if (compare_pnp_id(dev->id, drv_id->id)) 54 return drv_id; 55 drv_id++; 56 } 57 return NULL; 58 } 59 60 int pnp_device_attach(struct pnp_dev *pnp_dev) 61 { 62 mutex_lock(&pnp_lock); 63 if (pnp_dev->status != PNP_READY) { 64 mutex_unlock(&pnp_lock); 65 return -EBUSY; 66 } 67 pnp_dev->status = PNP_ATTACHED; 68 mutex_unlock(&pnp_lock); 69 return 0; 70 } 71 EXPORT_SYMBOL(pnp_device_attach); 72 73 void pnp_device_detach(struct pnp_dev *pnp_dev) 74 { 75 mutex_lock(&pnp_lock); 76 if (pnp_dev->status == PNP_ATTACHED) 77 pnp_dev->status = PNP_READY; 78 mutex_unlock(&pnp_lock); 79 } 80 EXPORT_SYMBOL(pnp_device_detach); 81 82 static int pnp_device_probe(struct device *dev) 83 { 84 int error; 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); 90 91 error = pnp_device_attach(pnp_dev); 92 if (error < 0) 93 return error; 94 95 if (pnp_dev->active == 0) { 96 if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) { 97 error = pnp_activate_dev(pnp_dev); 98 if (error < 0) 99 return error; 100 } 101 } else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE) 102 == PNP_DRIVER_RES_DISABLE) { 103 error = pnp_disable_dev(pnp_dev); 104 if (error < 0) 105 return error; 106 } 107 error = 0; 108 if (pnp_drv->probe) { 109 dev_id = match_device(pnp_drv, pnp_dev); 110 if (dev_id != NULL) 111 error = pnp_drv->probe(pnp_dev, dev_id); 112 } 113 if (error >= 0) { 114 pnp_dev->driver = pnp_drv; 115 error = 0; 116 } else 117 goto fail; 118 119 return error; 120 121 fail: 122 pnp_device_detach(pnp_dev); 123 return error; 124 } 125 126 static void pnp_device_remove(struct device *dev) 127 { 128 struct pnp_dev *pnp_dev = to_pnp_dev(dev); 129 struct pnp_driver *drv = pnp_dev->driver; 130 131 if (drv) { 132 if (drv->remove) 133 drv->remove(pnp_dev); 134 pnp_dev->driver = NULL; 135 } 136 137 if (pnp_dev->active && 138 (!drv || !(drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE))) 139 pnp_disable_dev(pnp_dev); 140 141 pnp_device_detach(pnp_dev); 142 } 143 144 static void pnp_device_shutdown(struct device *dev) 145 { 146 struct pnp_dev *pnp_dev = to_pnp_dev(dev); 147 struct pnp_driver *drv = pnp_dev->driver; 148 149 if (drv && drv->shutdown) 150 drv->shutdown(pnp_dev); 151 } 152 153 static int pnp_uevent(const struct device *dev, struct kobj_uevent_env *env) 154 { 155 struct pnp_id *pos; 156 const struct pnp_dev *pnp_dev = to_pnp_dev(dev); 157 158 if (!dev) 159 return -ENODEV; 160 161 pos = pnp_dev->id; 162 while (pos) { 163 if (add_uevent_var(env, "MODALIAS=pnp:d%s", pos->id)) 164 return -ENOMEM; 165 pos = pos->next; 166 } 167 168 return 0; 169 } 170 171 static int pnp_bus_match(struct device *dev, const struct device_driver *drv) 172 { 173 struct pnp_dev *pnp_dev = to_pnp_dev(dev); 174 const struct pnp_driver *pnp_drv = to_pnp_driver(drv); 175 176 if (match_device(pnp_drv, pnp_dev) == NULL) 177 return 0; 178 return 1; 179 } 180 181 static int __pnp_bus_suspend(struct device *dev, pm_message_t state) 182 { 183 struct pnp_dev *pnp_dev = to_pnp_dev(dev); 184 struct pnp_driver *pnp_drv = pnp_dev->driver; 185 int error; 186 187 if (!pnp_drv) 188 return 0; 189 190 if (pnp_drv->driver.pm && pnp_drv->driver.pm->suspend) { 191 error = pnp_drv->driver.pm->suspend(dev); 192 suspend_report_result(dev, pnp_drv->driver.pm->suspend, error); 193 if (error) 194 return error; 195 } 196 197 if (pnp_drv->suspend) { 198 error = pnp_drv->suspend(pnp_dev, state); 199 if (error) 200 return error; 201 } 202 203 /* can_write is necessary to be able to re-start the device on resume */ 204 if (pnp_can_disable(pnp_dev) && pnp_can_write(pnp_dev)) { 205 error = pnp_stop_dev(pnp_dev); 206 if (error) 207 return error; 208 } 209 210 if (pnp_can_suspend(pnp_dev)) 211 pnp_dev->protocol->suspend(pnp_dev, state); 212 return 0; 213 } 214 215 static int pnp_bus_suspend(struct device *dev) 216 { 217 return __pnp_bus_suspend(dev, PMSG_SUSPEND); 218 } 219 220 static int pnp_bus_freeze(struct device *dev) 221 { 222 return __pnp_bus_suspend(dev, PMSG_FREEZE); 223 } 224 225 static int pnp_bus_poweroff(struct device *dev) 226 { 227 return __pnp_bus_suspend(dev, PMSG_HIBERNATE); 228 } 229 230 static int pnp_bus_resume(struct device *dev) 231 { 232 struct pnp_dev *pnp_dev = to_pnp_dev(dev); 233 struct pnp_driver *pnp_drv = pnp_dev->driver; 234 int error; 235 236 if (!pnp_drv) 237 return 0; 238 239 if (pnp_dev->protocol->resume) { 240 error = pnp_dev->protocol->resume(pnp_dev); 241 if (error) 242 return error; 243 } 244 245 if (pnp_can_write(pnp_dev)) { 246 error = pnp_start_dev(pnp_dev); 247 if (error) 248 return error; 249 } 250 251 if (pnp_drv->driver.pm && pnp_drv->driver.pm->resume) { 252 error = pnp_drv->driver.pm->resume(dev); 253 if (error) 254 return error; 255 } 256 257 if (pnp_drv->resume) { 258 error = pnp_drv->resume(pnp_dev); 259 if (error) 260 return error; 261 } 262 263 return 0; 264 } 265 266 static const struct dev_pm_ops pnp_bus_dev_pm_ops = { 267 /* Suspend callbacks */ 268 .suspend = pnp_bus_suspend, 269 .resume = pnp_bus_resume, 270 /* Hibernate callbacks */ 271 .freeze = pnp_bus_freeze, 272 .thaw = pnp_bus_resume, 273 .poweroff = pnp_bus_poweroff, 274 .restore = pnp_bus_resume, 275 }; 276 277 const struct bus_type pnp_bus_type = { 278 .name = "pnp", 279 .match = pnp_bus_match, 280 .uevent = pnp_uevent, 281 .probe = pnp_device_probe, 282 .remove = pnp_device_remove, 283 .shutdown = pnp_device_shutdown, 284 .pm = &pnp_bus_dev_pm_ops, 285 .dev_groups = pnp_dev_groups, 286 }; 287 288 bool dev_is_pnp(const struct device *dev) 289 { 290 return dev->bus == &pnp_bus_type; 291 } 292 EXPORT_SYMBOL_GPL(dev_is_pnp); 293 294 int pnp_register_driver(struct pnp_driver *drv) 295 { 296 drv->driver.name = drv->name; 297 drv->driver.bus = &pnp_bus_type; 298 299 return driver_register(&drv->driver); 300 } 301 EXPORT_SYMBOL(pnp_register_driver); 302 303 void pnp_unregister_driver(struct pnp_driver *drv) 304 { 305 driver_unregister(&drv->driver); 306 } 307 EXPORT_SYMBOL(pnp_unregister_driver); 308 309 /** 310 * pnp_add_id - adds an EISA id to the specified device 311 * @dev: pointer to the desired device 312 * @id: pointer to an EISA id string 313 */ 314 struct pnp_id *pnp_add_id(struct pnp_dev *dev, const char *id) 315 { 316 struct pnp_id *dev_id, *ptr; 317 318 dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL); 319 if (!dev_id) 320 return NULL; 321 322 dev_id->id[0] = id[0]; 323 dev_id->id[1] = id[1]; 324 dev_id->id[2] = id[2]; 325 dev_id->id[3] = tolower(id[3]); 326 dev_id->id[4] = tolower(id[4]); 327 dev_id->id[5] = tolower(id[5]); 328 dev_id->id[6] = tolower(id[6]); 329 dev_id->id[7] = '\0'; 330 331 dev_id->next = NULL; 332 ptr = dev->id; 333 while (ptr && ptr->next) 334 ptr = ptr->next; 335 if (ptr) 336 ptr->next = dev_id; 337 else 338 dev->id = dev_id; 339 340 return dev_id; 341 } 342