1 /* 2 * pnpacpi -- PnP ACPI driver 3 * 4 * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr> 5 * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2, or (at your option) any 10 * later version. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/export.h> 23 #include <linux/acpi.h> 24 #include <linux/pnp.h> 25 #include <linux/slab.h> 26 #include <linux/mod_devicetable.h> 27 28 #include "../base.h" 29 #include "pnpacpi.h" 30 31 static int num; 32 33 /* We need only to blacklist devices that have already an acpi driver that 34 * can't use pnp layer. We don't need to blacklist device that are directly 35 * used by the kernel (PCI root, ...), as it is harmless and there were 36 * already present in pnpbios. But there is an exception for devices that 37 * have irqs (PIC, Timer) because we call acpi_register_gsi. 38 * Finally, only devices that have a CRS method need to be in this list. 39 */ 40 static struct acpi_device_id excluded_id_list[] __initdata = { 41 {"PNP0C09", 0}, /* EC */ 42 {"PNP0C0F", 0}, /* Link device */ 43 {"PNP0000", 0}, /* PIC */ 44 {"PNP0100", 0}, /* Timer */ 45 {"", 0}, 46 }; 47 48 static inline int __init is_exclusive_device(struct acpi_device *dev) 49 { 50 return (!acpi_match_device_ids(dev, excluded_id_list)); 51 } 52 53 /* 54 * Compatible Device IDs 55 */ 56 #define TEST_HEX(c) \ 57 if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \ 58 return 0 59 #define TEST_ALPHA(c) \ 60 if (!('A' <= (c) && (c) <= 'Z')) \ 61 return 0 62 static int __init ispnpidacpi(const char *id) 63 { 64 TEST_ALPHA(id[0]); 65 TEST_ALPHA(id[1]); 66 TEST_ALPHA(id[2]); 67 TEST_HEX(id[3]); 68 TEST_HEX(id[4]); 69 TEST_HEX(id[5]); 70 TEST_HEX(id[6]); 71 if (id[7] != '\0') 72 return 0; 73 return 1; 74 } 75 76 static int pnpacpi_get_resources(struct pnp_dev *dev) 77 { 78 pnp_dbg(&dev->dev, "get resources\n"); 79 return pnpacpi_parse_allocated_resource(dev); 80 } 81 82 static int pnpacpi_set_resources(struct pnp_dev *dev) 83 { 84 struct acpi_device *acpi_dev; 85 acpi_handle handle; 86 int ret = 0; 87 88 pnp_dbg(&dev->dev, "set resources\n"); 89 90 handle = ACPI_HANDLE(&dev->dev); 91 if (!handle || acpi_bus_get_device(handle, &acpi_dev)) { 92 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__); 93 return -ENODEV; 94 } 95 96 if (WARN_ON_ONCE(acpi_dev != dev->data)) 97 dev->data = acpi_dev; 98 99 if (acpi_has_method(handle, METHOD_NAME__SRS)) { 100 struct acpi_buffer buffer; 101 102 ret = pnpacpi_build_resource_template(dev, &buffer); 103 if (ret) 104 return ret; 105 106 ret = pnpacpi_encode_resources(dev, &buffer); 107 if (!ret) { 108 acpi_status status; 109 110 status = acpi_set_current_resources(handle, &buffer); 111 if (ACPI_FAILURE(status)) 112 ret = -EIO; 113 } 114 kfree(buffer.pointer); 115 } 116 if (!ret && acpi_bus_power_manageable(handle)) 117 ret = acpi_bus_set_power(handle, ACPI_STATE_D0); 118 119 return ret; 120 } 121 122 static int pnpacpi_disable_resources(struct pnp_dev *dev) 123 { 124 struct acpi_device *acpi_dev; 125 acpi_handle handle; 126 acpi_status status; 127 128 dev_dbg(&dev->dev, "disable resources\n"); 129 130 handle = ACPI_HANDLE(&dev->dev); 131 if (!handle || acpi_bus_get_device(handle, &acpi_dev)) { 132 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__); 133 return 0; 134 } 135 136 /* acpi_unregister_gsi(pnp_irq(dev, 0)); */ 137 if (acpi_bus_power_manageable(handle)) 138 acpi_bus_set_power(handle, ACPI_STATE_D3_COLD); 139 140 /* continue even if acpi_bus_set_power() fails */ 141 status = acpi_evaluate_object(handle, "_DIS", NULL, NULL); 142 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) 143 return -ENODEV; 144 145 return 0; 146 } 147 148 #ifdef CONFIG_ACPI_SLEEP 149 static bool pnpacpi_can_wakeup(struct pnp_dev *dev) 150 { 151 struct acpi_device *acpi_dev; 152 acpi_handle handle; 153 154 handle = ACPI_HANDLE(&dev->dev); 155 if (!handle || acpi_bus_get_device(handle, &acpi_dev)) { 156 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__); 157 return false; 158 } 159 160 return acpi_bus_can_wakeup(handle); 161 } 162 163 static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state) 164 { 165 struct acpi_device *acpi_dev; 166 acpi_handle handle; 167 int error = 0; 168 169 handle = ACPI_HANDLE(&dev->dev); 170 if (!handle || acpi_bus_get_device(handle, &acpi_dev)) { 171 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__); 172 return 0; 173 } 174 175 if (device_can_wakeup(&dev->dev)) { 176 error = acpi_pm_device_sleep_wake(&dev->dev, 177 device_may_wakeup(&dev->dev)); 178 if (error) 179 return error; 180 } 181 182 if (acpi_bus_power_manageable(handle)) { 183 int power_state = acpi_pm_device_sleep_state(&dev->dev, NULL, 184 ACPI_STATE_D3_COLD); 185 if (power_state < 0) 186 power_state = (state.event == PM_EVENT_ON) ? 187 ACPI_STATE_D0 : ACPI_STATE_D3_COLD; 188 189 /* 190 * acpi_bus_set_power() often fails (keyboard port can't be 191 * powered-down?), and in any case, our return value is ignored 192 * by pnp_bus_suspend(). Hence we don't revert the wakeup 193 * setting if the set_power fails. 194 */ 195 error = acpi_bus_set_power(handle, power_state); 196 } 197 198 return error; 199 } 200 201 static int pnpacpi_resume(struct pnp_dev *dev) 202 { 203 struct acpi_device *acpi_dev; 204 acpi_handle handle = ACPI_HANDLE(&dev->dev); 205 int error = 0; 206 207 if (!handle || acpi_bus_get_device(handle, &acpi_dev)) { 208 dev_dbg(&dev->dev, "ACPI device not found in %s!\n", __func__); 209 return -ENODEV; 210 } 211 212 if (device_may_wakeup(&dev->dev)) 213 acpi_pm_device_sleep_wake(&dev->dev, false); 214 215 if (acpi_bus_power_manageable(handle)) 216 error = acpi_bus_set_power(handle, ACPI_STATE_D0); 217 218 return error; 219 } 220 #endif 221 222 struct pnp_protocol pnpacpi_protocol = { 223 .name = "Plug and Play ACPI", 224 .get = pnpacpi_get_resources, 225 .set = pnpacpi_set_resources, 226 .disable = pnpacpi_disable_resources, 227 #ifdef CONFIG_ACPI_SLEEP 228 .can_wakeup = pnpacpi_can_wakeup, 229 .suspend = pnpacpi_suspend, 230 .resume = pnpacpi_resume, 231 #endif 232 }; 233 EXPORT_SYMBOL(pnpacpi_protocol); 234 235 static char *__init pnpacpi_get_id(struct acpi_device *device) 236 { 237 struct acpi_hardware_id *id; 238 239 list_for_each_entry(id, &device->pnp.ids, list) { 240 if (ispnpidacpi(id->id)) 241 return id->id; 242 } 243 244 return NULL; 245 } 246 247 static int __init pnpacpi_add_device(struct acpi_device *device) 248 { 249 struct pnp_dev *dev; 250 char *pnpid; 251 struct acpi_hardware_id *id; 252 int error; 253 254 /* Skip devices that are already bound */ 255 if (device->physical_node_count) 256 return 0; 257 258 /* 259 * If a PnPacpi device is not present , the device 260 * driver should not be loaded. 261 */ 262 if (!acpi_has_method(device->handle, "_CRS")) 263 return 0; 264 265 pnpid = pnpacpi_get_id(device); 266 if (!pnpid) 267 return 0; 268 269 if (is_exclusive_device(device) || !device->status.present) 270 return 0; 271 272 dev = pnp_alloc_dev(&pnpacpi_protocol, num, pnpid); 273 if (!dev) 274 return -ENOMEM; 275 276 dev->data = device; 277 /* .enabled means the device can decode the resources */ 278 dev->active = device->status.enabled; 279 if (acpi_has_method(device->handle, "_SRS")) 280 dev->capabilities |= PNP_CONFIGURABLE; 281 dev->capabilities |= PNP_READ; 282 if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE)) 283 dev->capabilities |= PNP_WRITE; 284 if (device->flags.removable) 285 dev->capabilities |= PNP_REMOVABLE; 286 if (acpi_has_method(device->handle, "_DIS")) 287 dev->capabilities |= PNP_DISABLE; 288 289 if (strlen(acpi_device_name(device))) 290 strncpy(dev->name, acpi_device_name(device), sizeof(dev->name)); 291 else 292 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name)); 293 294 if (dev->active) 295 pnpacpi_parse_allocated_resource(dev); 296 297 if (dev->capabilities & PNP_CONFIGURABLE) 298 pnpacpi_parse_resource_option_data(dev); 299 300 list_for_each_entry(id, &device->pnp.ids, list) { 301 if (!strcmp(id->id, pnpid)) 302 continue; 303 if (!ispnpidacpi(id->id)) 304 continue; 305 pnp_add_id(dev, id->id); 306 } 307 308 /* clear out the damaged flags */ 309 if (!dev->active) 310 pnp_init_resources(dev); 311 312 error = pnp_add_device(dev); 313 if (error) { 314 put_device(&dev->dev); 315 return error; 316 } 317 318 num++; 319 320 return 0; 321 } 322 323 static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle, 324 u32 lvl, void *context, 325 void **rv) 326 { 327 struct acpi_device *device; 328 329 if (!acpi_bus_get_device(handle, &device)) 330 pnpacpi_add_device(device); 331 else 332 return AE_CTRL_DEPTH; 333 return AE_OK; 334 } 335 336 static int __init acpi_pnp_match(struct device *dev, void *_pnp) 337 { 338 struct acpi_device *acpi = to_acpi_device(dev); 339 struct pnp_dev *pnp = _pnp; 340 341 /* true means it matched */ 342 return !acpi->physical_node_count 343 && compare_pnp_id(pnp->id, acpi_device_hid(acpi)); 344 } 345 346 static struct acpi_device * __init acpi_pnp_find_companion(struct device *dev) 347 { 348 dev = bus_find_device(&acpi_bus_type, NULL, to_pnp_dev(dev), 349 acpi_pnp_match); 350 if (!dev) 351 return NULL; 352 353 put_device(dev); 354 return to_acpi_device(dev); 355 } 356 357 /* complete initialization of a PNPACPI device includes having 358 * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling. 359 */ 360 static bool acpi_pnp_bus_match(struct device *dev) 361 { 362 return dev->bus == &pnp_bus_type; 363 } 364 365 static struct acpi_bus_type __initdata acpi_pnp_bus = { 366 .name = "PNP", 367 .match = acpi_pnp_bus_match, 368 .find_companion = acpi_pnp_find_companion, 369 }; 370 371 int pnpacpi_disabled __initdata; 372 static int __init pnpacpi_init(void) 373 { 374 if (acpi_disabled || pnpacpi_disabled) { 375 printk(KERN_INFO "pnp: PnP ACPI: disabled\n"); 376 return 0; 377 } 378 printk(KERN_INFO "pnp: PnP ACPI init\n"); 379 pnp_register_protocol(&pnpacpi_protocol); 380 register_acpi_bus_type(&acpi_pnp_bus); 381 acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL); 382 printk(KERN_INFO "pnp: PnP ACPI: found %d devices\n", num); 383 unregister_acpi_bus_type(&acpi_pnp_bus); 384 pnp_platform_devices = 1; 385 return 0; 386 } 387 388 fs_initcall(pnpacpi_init); 389 390 static int __init pnpacpi_setup(char *str) 391 { 392 if (str == NULL) 393 return 1; 394 if (!strncmp(str, "off", 3)) 395 pnpacpi_disabled = 1; 396 return 1; 397 } 398 399 __setup("pnpacpi=", pnpacpi_setup); 400