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 #include <acpi/actypes.h> 27 28 #include "../base.h" 29 #include "pnpacpi.h" 30 31 static int num = 0; 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 (!('@' <= (c) || (c) <= 'Z')) \ 61 return 0 62 static int __init ispnpidacpi(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 dev_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 acpi_handle handle = dev->data; 85 struct acpi_buffer buffer; 86 int ret; 87 acpi_status status; 88 89 dev_dbg(&dev->dev, "set resources\n"); 90 ret = pnpacpi_build_resource_template(dev, &buffer); 91 if (ret) 92 return ret; 93 ret = pnpacpi_encode_resources(dev, &buffer); 94 if (ret) { 95 kfree(buffer.pointer); 96 return ret; 97 } 98 status = acpi_set_current_resources(handle, &buffer); 99 if (ACPI_FAILURE(status)) 100 ret = -EINVAL; 101 kfree(buffer.pointer); 102 return ret; 103 } 104 105 static int pnpacpi_disable_resources(struct pnp_dev *dev) 106 { 107 acpi_status status; 108 109 /* acpi_unregister_gsi(pnp_irq(dev, 0)); */ 110 status = acpi_evaluate_object((acpi_handle) dev->data, 111 "_DIS", NULL, NULL); 112 return ACPI_FAILURE(status) ? -ENODEV : 0; 113 } 114 115 #ifdef CONFIG_ACPI_SLEEP 116 static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state) 117 { 118 int power_state; 119 120 power_state = acpi_pm_device_sleep_state(&dev->dev, NULL); 121 if (power_state < 0) 122 power_state = (state.event == PM_EVENT_ON) ? 123 ACPI_STATE_D0 : ACPI_STATE_D3; 124 125 return acpi_bus_set_power((acpi_handle) dev->data, power_state); 126 } 127 128 static int pnpacpi_resume(struct pnp_dev *dev) 129 { 130 return acpi_bus_set_power((acpi_handle) dev->data, ACPI_STATE_D0); 131 } 132 #endif 133 134 static struct pnp_protocol pnpacpi_protocol = { 135 .name = "Plug and Play ACPI", 136 .get = pnpacpi_get_resources, 137 .set = pnpacpi_set_resources, 138 .disable = pnpacpi_disable_resources, 139 #ifdef CONFIG_ACPI_SLEEP 140 .suspend = pnpacpi_suspend, 141 .resume = pnpacpi_resume, 142 #endif 143 }; 144 145 static int __init pnpacpi_add_device(struct acpi_device *device) 146 { 147 acpi_handle temp = NULL; 148 acpi_status status; 149 struct pnp_dev *dev; 150 151 status = acpi_get_handle(device->handle, "_CRS", &temp); 152 if (ACPI_FAILURE(status) || !ispnpidacpi(acpi_device_hid(device)) || 153 is_exclusive_device(device)) 154 return 0; 155 156 dev = pnp_alloc_dev(&pnpacpi_protocol, num, acpi_device_hid(device)); 157 if (!dev) 158 return -ENOMEM; 159 160 dev->data = device->handle; 161 /* .enabled means the device can decode the resources */ 162 dev->active = device->status.enabled; 163 status = acpi_get_handle(device->handle, "_SRS", &temp); 164 if (ACPI_SUCCESS(status)) 165 dev->capabilities |= PNP_CONFIGURABLE; 166 dev->capabilities |= PNP_READ; 167 if (device->flags.dynamic_status && (dev->capabilities & PNP_CONFIGURABLE)) 168 dev->capabilities |= PNP_WRITE; 169 if (device->flags.removable) 170 dev->capabilities |= PNP_REMOVABLE; 171 status = acpi_get_handle(device->handle, "_DIS", &temp); 172 if (ACPI_SUCCESS(status)) 173 dev->capabilities |= PNP_DISABLE; 174 175 if (strlen(acpi_device_name(device))) 176 strncpy(dev->name, acpi_device_name(device), sizeof(dev->name)); 177 else 178 strncpy(dev->name, acpi_device_bid(device), sizeof(dev->name)); 179 180 if (dev->active) 181 pnpacpi_parse_allocated_resource(dev); 182 183 if (dev->capabilities & PNP_CONFIGURABLE) 184 pnpacpi_parse_resource_option_data(dev); 185 186 if (device->flags.compatible_ids) { 187 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list; 188 int i; 189 190 for (i = 0; i < cid_list->count; i++) { 191 if (!ispnpidacpi(cid_list->id[i].value)) 192 continue; 193 pnp_add_id(dev, cid_list->id[i].value); 194 } 195 } 196 197 /* clear out the damaged flags */ 198 if (!dev->active) 199 pnp_init_resources(dev); 200 pnp_add_device(dev); 201 num++; 202 203 return AE_OK; 204 } 205 206 static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle, 207 u32 lvl, void *context, 208 void **rv) 209 { 210 struct acpi_device *device; 211 212 if (!acpi_bus_get_device(handle, &device)) 213 pnpacpi_add_device(device); 214 else 215 return AE_CTRL_DEPTH; 216 return AE_OK; 217 } 218 219 static int __init acpi_pnp_match(struct device *dev, void *_pnp) 220 { 221 struct acpi_device *acpi = to_acpi_device(dev); 222 struct pnp_dev *pnp = _pnp; 223 224 /* true means it matched */ 225 return acpi->flags.hardware_id 226 && !acpi_get_physical_device(acpi->handle) 227 && compare_pnp_id(pnp->id, acpi->pnp.hardware_id); 228 } 229 230 static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle) 231 { 232 struct device *adev; 233 struct acpi_device *acpi; 234 235 adev = bus_find_device(&acpi_bus_type, NULL, 236 to_pnp_dev(dev), acpi_pnp_match); 237 if (!adev) 238 return -ENODEV; 239 240 acpi = to_acpi_device(adev); 241 *handle = acpi->handle; 242 put_device(adev); 243 return 0; 244 } 245 246 /* complete initialization of a PNPACPI device includes having 247 * pnpdev->dev.archdata.acpi_handle point to its ACPI sibling. 248 */ 249 static struct acpi_bus_type __initdata acpi_pnp_bus = { 250 .bus = &pnp_bus_type, 251 .find_device = acpi_pnp_find_device, 252 }; 253 254 int pnpacpi_disabled __initdata; 255 static int __init pnpacpi_init(void) 256 { 257 if (acpi_disabled || pnpacpi_disabled) { 258 pnp_info("PnP ACPI: disabled"); 259 return 0; 260 } 261 pnp_info("PnP ACPI init"); 262 pnp_register_protocol(&pnpacpi_protocol); 263 register_acpi_bus_type(&acpi_pnp_bus); 264 acpi_get_devices(NULL, pnpacpi_add_device_handler, NULL, NULL); 265 pnp_info("PnP ACPI: found %d devices", num); 266 unregister_acpi_bus_type(&acpi_pnp_bus); 267 pnp_platform_devices = 1; 268 return 0; 269 } 270 271 subsys_initcall(pnpacpi_init); 272 273 static int __init pnpacpi_setup(char *str) 274 { 275 if (str == NULL) 276 return 1; 277 if (!strncmp(str, "off", 3)) 278 pnpacpi_disabled = 1; 279 return 1; 280 } 281 282 __setup("pnpacpi=", pnpacpi_setup); 283