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/acpi.h> 23 #include <linux/pnp.h> 24 #include <linux/mod_devicetable.h> 25 #include <acpi/acpi_bus.h> 26 27 #include "../base.h" 28 #include "pnpacpi.h" 29 30 static int num = 0; 31 32 /* We need only to blacklist devices that have already an acpi driver that 33 * can't use pnp layer. We don't need to blacklist device that are directly 34 * used by the kernel (PCI root, ...), as it is harmless and there were 35 * already present in pnpbios. But there is an exception for devices that 36 * have irqs (PIC, Timer) because we call acpi_register_gsi. 37 * Finally, only devices that have a CRS method need to be in this list. 38 */ 39 static struct acpi_device_id excluded_id_list[] __initdata = { 40 {"PNP0C09", 0}, /* EC */ 41 {"PNP0C0F", 0}, /* Link device */ 42 {"PNP0000", 0}, /* PIC */ 43 {"PNP0100", 0}, /* Timer */ 44 {"", 0}, 45 }; 46 47 static inline int __init is_exclusive_device(struct acpi_device *dev) 48 { 49 return (!acpi_match_device_ids(dev, excluded_id_list)); 50 } 51 52 /* 53 * Compatible Device IDs 54 */ 55 #define TEST_HEX(c) \ 56 if (!(('0' <= (c) && (c) <= '9') || ('A' <= (c) && (c) <= 'F'))) \ 57 return 0 58 #define TEST_ALPHA(c) \ 59 if (!('@' <= (c) || (c) <= 'Z')) \ 60 return 0 61 static int __init ispnpidacpi(char *id) 62 { 63 TEST_ALPHA(id[0]); 64 TEST_ALPHA(id[1]); 65 TEST_ALPHA(id[2]); 66 TEST_HEX(id[3]); 67 TEST_HEX(id[4]); 68 TEST_HEX(id[5]); 69 TEST_HEX(id[6]); 70 if (id[7] != '\0') 71 return 0; 72 return 1; 73 } 74 75 static int pnpacpi_get_resources(struct pnp_dev *dev) 76 { 77 pnp_dbg(&dev->dev, "get resources\n"); 78 return pnpacpi_parse_allocated_resource(dev); 79 } 80 81 static int pnpacpi_set_resources(struct pnp_dev *dev) 82 { 83 acpi_handle handle = dev->data; 84 struct acpi_buffer buffer; 85 int ret; 86 87 pnp_dbg(&dev->dev, "set resources\n"); 88 ret = pnpacpi_build_resource_template(dev, &buffer); 89 if (ret) 90 return ret; 91 ret = pnpacpi_encode_resources(dev, &buffer); 92 if (ret) { 93 kfree(buffer.pointer); 94 return ret; 95 } 96 if (ACPI_FAILURE(acpi_set_current_resources(handle, &buffer))) 97 ret = -EINVAL; 98 else if (acpi_bus_power_manageable(handle)) 99 ret = acpi_bus_set_power(handle, ACPI_STATE_D0); 100 kfree(buffer.pointer); 101 return ret; 102 } 103 104 static int pnpacpi_disable_resources(struct pnp_dev *dev) 105 { 106 acpi_handle handle = dev->data; 107 int ret; 108 109 dev_dbg(&dev->dev, "disable resources\n"); 110 111 /* acpi_unregister_gsi(pnp_irq(dev, 0)); */ 112 ret = 0; 113 if (acpi_bus_power_manageable(handle)) { 114 ret = acpi_bus_set_power(handle, ACPI_STATE_D3); 115 if (ret) 116 return ret; 117 } 118 if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DIS", NULL, NULL))) 119 ret = -ENODEV; 120 return ret; 121 } 122 123 #ifdef CONFIG_ACPI_SLEEP 124 static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state) 125 { 126 int power_state; 127 128 power_state = acpi_pm_device_sleep_state(&dev->dev, NULL); 129 if (power_state < 0) 130 power_state = (state.event == PM_EVENT_ON) ? 131 ACPI_STATE_D0 : ACPI_STATE_D3; 132 133 return acpi_bus_set_power((acpi_handle) dev->data, power_state); 134 } 135 136 static int pnpacpi_resume(struct pnp_dev *dev) 137 { 138 return acpi_bus_set_power((acpi_handle) dev->data, ACPI_STATE_D0); 139 } 140 #endif 141 142 static struct pnp_protocol pnpacpi_protocol = { 143 .name = "Plug and Play ACPI", 144 .get = pnpacpi_get_resources, 145 .set = pnpacpi_set_resources, 146 .disable = pnpacpi_disable_resources, 147 #ifdef CONFIG_ACPI_SLEEP 148 .suspend = pnpacpi_suspend, 149 .resume = pnpacpi_resume, 150 #endif 151 }; 152 153 static int __init pnpacpi_add_device(struct acpi_device *device) 154 { 155 acpi_handle temp = NULL; 156 acpi_status status; 157 struct pnp_dev *dev; 158 159 /* 160 * If a PnPacpi device is not present , the device 161 * driver should not be loaded. 162 */ 163 status = acpi_get_handle(device->handle, "_CRS", &temp); 164 if (ACPI_FAILURE(status) || !ispnpidacpi(acpi_device_hid(device)) || 165 is_exclusive_device(device) || (!device->status.present)) 166 return 0; 167 168 dev = pnp_alloc_dev(&pnpacpi_protocol, num, acpi_device_hid(device)); 169 if (!dev) 170 return -ENOMEM; 171 172 dev->data = device->handle; 173 /* .enabled means the device can decode the resources */ 174 dev->active = device->status.enabled; 175 status = acpi_get_handle(device->handle, "_SRS", &temp); 176 if (ACPI_SUCCESS(status)) 177 dev->capabilities |= PNP_CONFIGURABLE; 178 dev->capabilities |= PNP_READ; 179 if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE)) 180 dev->capabilities |= PNP_WRITE; 181 if (device->flags.removable) 182 dev->capabilities |= PNP_REMOVABLE; 183 status = acpi_get_handle(device->handle, "_DIS", &temp); 184 if (ACPI_SUCCESS(status)) 185 dev->capabilities |= PNP_DISABLE; 186 187 if (strlen(acpi_device_name(device))) 188 strncpy(dev->name, acpi_device_name(device), sizeof(dev->name)); 189 else 190 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name)); 191 192 if (dev->active) 193 pnpacpi_parse_allocated_resource(dev); 194 195 if (dev->capabilities & PNP_CONFIGURABLE) 196 pnpacpi_parse_resource_option_data(dev); 197 198 if (device->flags.compatible_ids) { 199 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list; 200 int i; 201 202 for (i = 0; i < cid_list->count; i++) { 203 if (!ispnpidacpi(cid_list->id[i].value)) 204 continue; 205 pnp_add_id(dev, cid_list->id[i].value); 206 } 207 } 208 209 /* clear out the damaged flags */ 210 if (!dev->active) 211 pnp_init_resources(dev); 212 pnp_add_device(dev); 213 num++; 214 215 return AE_OK; 216 } 217 218 static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle, 219 u32 lvl, void *context, 220 void **rv) 221 { 222 struct acpi_device *device; 223 224 if (!acpi_bus_get_device(handle, &device)) 225 pnpacpi_add_device(device); 226 else 227 return AE_CTRL_DEPTH; 228 return AE_OK; 229 } 230 231 static int __init acpi_pnp_match(struct device *dev, void *_pnp) 232 { 233 struct acpi_device *acpi = to_acpi_device(dev); 234 struct pnp_dev *pnp = _pnp; 235 236 /* true means it matched */ 237 return acpi->flags.hardware_id 238 && !acpi_get_physical_device(acpi->handle) 239 && compare_pnp_id(pnp->id, acpi->pnp.hardware_id); 240 } 241 242 static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle) 243 { 244 struct device *adev; 245 struct acpi_device *acpi; 246 247 adev = bus_find_device(&acpi_bus_type, NULL, 248 to_pnp_dev(dev), acpi_pnp_match); 249 if (!adev) 250 return -ENODEV; 251 252 acpi = to_acpi_device(adev); 253 *handle = acpi->handle; 254 put_device(adev); 255 return 0; 256 } 257 258 /* complete initialization of a PNPACPI device includes having 259 * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling. 260 */ 261 static struct acpi_bus_type __initdata acpi_pnp_bus = { 262 .bus = &pnp_bus_type, 263 .find_device = acpi_pnp_find_device, 264 }; 265 266 int pnpacpi_disabled __initdata; 267 static int __init pnpacpi_init(void) 268 { 269 if (acpi_disabled || pnpacpi_disabled) { 270 printk(KERN_INFO "pnp: PnP ACPI: disabled\n"); 271 return 0; 272 } 273 printk(KERN_INFO "pnp: PnP ACPI init\n"); 274 pnp_register_protocol(&pnpacpi_protocol); 275 register_acpi_bus_type(&acpi_pnp_bus); 276 acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL); 277 printk(KERN_INFO "pnp: PnP ACPI: found %d devices\n", num); 278 unregister_acpi_bus_type(&acpi_pnp_bus); 279 pnp_platform_devices = 1; 280 return 0; 281 } 282 283 fs_initcall(pnpacpi_init); 284 285 static int __init pnpacpi_setup(char *str) 286 { 287 if (str == NULL) 288 return 1; 289 if (!strncmp(str, "off", 3)) 290 pnpacpi_disabled = 1; 291 return 1; 292 } 293 294 __setup("pnpacpi=", pnpacpi_setup); 295