1 /* 2 * File: pci-acpi.c 3 * Purpose: Provide PCI support in ACPI 4 * 5 * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com> 6 * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com> 7 * Copyright (C) 2004 Intel Corp. 8 */ 9 10 #include <linux/delay.h> 11 #include <linux/init.h> 12 #include <linux/pci.h> 13 #include <linux/module.h> 14 #include <acpi/acpi.h> 15 #include <acpi/acnamesp.h> 16 #include <acpi/acresrc.h> 17 #include <acpi/acpi_bus.h> 18 19 #include <linux/pci-acpi.h> 20 #include "pci.h" 21 22 struct acpi_osc_data { 23 acpi_handle handle; 24 u32 support_set; 25 u32 control_set; 26 int is_queried; 27 u32 query_result; 28 struct list_head sibiling; 29 }; 30 static LIST_HEAD(acpi_osc_data_list); 31 32 struct acpi_osc_args { 33 u32 capbuf[3]; 34 u32 query_result; 35 }; 36 37 static struct acpi_osc_data *acpi_get_osc_data(acpi_handle handle) 38 { 39 struct acpi_osc_data *data; 40 41 list_for_each_entry(data, &acpi_osc_data_list, sibiling) { 42 if (data->handle == handle) 43 return data; 44 } 45 data = kzalloc(sizeof(*data), GFP_KERNEL); 46 if (!data) 47 return NULL; 48 INIT_LIST_HEAD(&data->sibiling); 49 data->handle = handle; 50 list_add_tail(&data->sibiling, &acpi_osc_data_list); 51 return data; 52 } 53 54 static u8 OSC_UUID[16] = {0x5B, 0x4D, 0xDB, 0x33, 0xF7, 0x1F, 0x1C, 0x40, 55 0x96, 0x57, 0x74, 0x41, 0xC0, 0x3D, 0xD7, 0x66}; 56 57 static acpi_status acpi_run_osc(acpi_handle handle, 58 struct acpi_osc_args *osc_args) 59 { 60 acpi_status status; 61 struct acpi_object_list input; 62 union acpi_object in_params[4]; 63 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; 64 union acpi_object *out_obj; 65 u32 osc_dw0, flags = osc_args->capbuf[OSC_QUERY_TYPE]; 66 67 /* Setting up input parameters */ 68 input.count = 4; 69 input.pointer = in_params; 70 in_params[0].type = ACPI_TYPE_BUFFER; 71 in_params[0].buffer.length = 16; 72 in_params[0].buffer.pointer = OSC_UUID; 73 in_params[1].type = ACPI_TYPE_INTEGER; 74 in_params[1].integer.value = 1; 75 in_params[2].type = ACPI_TYPE_INTEGER; 76 in_params[2].integer.value = 3; 77 in_params[3].type = ACPI_TYPE_BUFFER; 78 in_params[3].buffer.length = 12; 79 in_params[3].buffer.pointer = (u8 *)osc_args->capbuf; 80 81 status = acpi_evaluate_object(handle, "_OSC", &input, &output); 82 if (ACPI_FAILURE(status)) 83 return status; 84 85 out_obj = output.pointer; 86 if (out_obj->type != ACPI_TYPE_BUFFER) { 87 printk(KERN_DEBUG "Evaluate _OSC returns wrong type\n"); 88 status = AE_TYPE; 89 goto out_kfree; 90 } 91 osc_dw0 = *((u32 *)out_obj->buffer.pointer); 92 if (osc_dw0) { 93 if (osc_dw0 & OSC_REQUEST_ERROR) 94 printk(KERN_DEBUG "_OSC request fails\n"); 95 if (osc_dw0 & OSC_INVALID_UUID_ERROR) 96 printk(KERN_DEBUG "_OSC invalid UUID\n"); 97 if (osc_dw0 & OSC_INVALID_REVISION_ERROR) 98 printk(KERN_DEBUG "_OSC invalid revision\n"); 99 if (osc_dw0 & OSC_CAPABILITIES_MASK_ERROR) { 100 if (flags & OSC_QUERY_ENABLE) 101 goto out_success; 102 printk(KERN_DEBUG "_OSC FW not grant req. control\n"); 103 status = AE_SUPPORT; 104 goto out_kfree; 105 } 106 status = AE_ERROR; 107 goto out_kfree; 108 } 109 out_success: 110 if (flags & OSC_QUERY_ENABLE) 111 osc_args->query_result = 112 *((u32 *)(out_obj->buffer.pointer + 8)); 113 status = AE_OK; 114 115 out_kfree: 116 kfree(output.pointer); 117 return status; 118 } 119 120 static acpi_status acpi_query_osc(acpi_handle handle, 121 u32 level, void *context, void **retval) 122 { 123 acpi_status status; 124 struct acpi_osc_data *osc_data; 125 u32 flags = (unsigned long)context, support_set; 126 acpi_handle tmp; 127 struct acpi_osc_args osc_args; 128 129 status = acpi_get_handle(handle, "_OSC", &tmp); 130 if (ACPI_FAILURE(status)) 131 return status; 132 133 osc_data = acpi_get_osc_data(handle); 134 if (!osc_data) { 135 printk(KERN_ERR "acpi osc data array is full\n"); 136 return AE_ERROR; 137 } 138 139 /* do _OSC query for all possible controls */ 140 support_set = osc_data->support_set | (flags & OSC_SUPPORT_MASKS); 141 osc_args.capbuf[OSC_QUERY_TYPE] = OSC_QUERY_ENABLE; 142 osc_args.capbuf[OSC_SUPPORT_TYPE] = support_set; 143 osc_args.capbuf[OSC_CONTROL_TYPE] = OSC_CONTROL_MASKS; 144 145 status = acpi_run_osc(handle, &osc_args); 146 if (ACPI_SUCCESS(status)) { 147 osc_data->support_set = support_set; 148 osc_data->query_result = osc_args.query_result; 149 osc_data->is_queried = 1; 150 } 151 152 return status; 153 } 154 155 /** 156 * __pci_osc_support_set - register OS support to Firmware 157 * @flags: OS support bits 158 * @hid: hardware ID 159 * 160 * Update OS support fields and doing a _OSC Query to obtain an update 161 * from Firmware on supported control bits. 162 **/ 163 acpi_status __pci_osc_support_set(u32 flags, const char *hid) 164 { 165 if (!(flags & OSC_SUPPORT_MASKS)) 166 return AE_TYPE; 167 168 acpi_get_devices(hid, acpi_query_osc, 169 (void *)(unsigned long)flags, NULL); 170 return AE_OK; 171 } 172 173 /** 174 * pci_osc_control_set - commit requested control to Firmware 175 * @handle: acpi_handle for the target ACPI object 176 * @flags: driver's requested control bits 177 * 178 * Attempt to take control from Firmware on requested control bits. 179 **/ 180 acpi_status pci_osc_control_set(acpi_handle handle, u32 flags) 181 { 182 acpi_status status; 183 u32 ctrlset, control_set; 184 acpi_handle tmp; 185 struct acpi_osc_data *osc_data; 186 struct acpi_osc_args osc_args; 187 188 status = acpi_get_handle(handle, "_OSC", &tmp); 189 if (ACPI_FAILURE(status)) 190 return status; 191 192 osc_data = acpi_get_osc_data(handle); 193 if (!osc_data) { 194 printk(KERN_ERR "acpi osc data array is full\n"); 195 return AE_ERROR; 196 } 197 198 ctrlset = (flags & OSC_CONTROL_MASKS); 199 if (!ctrlset) 200 return AE_TYPE; 201 202 if (osc_data->is_queried && 203 ((osc_data->query_result & ctrlset) != ctrlset)) 204 return AE_SUPPORT; 205 206 control_set = osc_data->control_set | ctrlset; 207 osc_args.capbuf[OSC_QUERY_TYPE] = 0; 208 osc_args.capbuf[OSC_SUPPORT_TYPE] = osc_data->support_set; 209 osc_args.capbuf[OSC_CONTROL_TYPE] = control_set; 210 status = acpi_run_osc(handle, &osc_args); 211 if (ACPI_SUCCESS(status)) 212 osc_data->control_set = control_set; 213 214 return status; 215 } 216 EXPORT_SYMBOL(pci_osc_control_set); 217 218 /* 219 * _SxD returns the D-state with the highest power 220 * (lowest D-state number) supported in the S-state "x". 221 * 222 * If the devices does not have a _PRW 223 * (Power Resources for Wake) supporting system wakeup from "x" 224 * then the OS is free to choose a lower power (higher number 225 * D-state) than the return value from _SxD. 226 * 227 * But if _PRW is enabled at S-state "x", the OS 228 * must not choose a power lower than _SxD -- 229 * unless the device has an _SxW method specifying 230 * the lowest power (highest D-state number) the device 231 * may enter while still able to wake the system. 232 * 233 * ie. depending on global OS policy: 234 * 235 * if (_PRW at S-state x) 236 * choose from highest power _SxD to lowest power _SxW 237 * else // no _PRW at S-state x 238 * choose highest power _SxD or any lower power 239 */ 240 241 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev) 242 { 243 int acpi_state; 244 245 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL); 246 if (acpi_state < 0) 247 return PCI_POWER_ERROR; 248 249 switch (acpi_state) { 250 case ACPI_STATE_D0: 251 return PCI_D0; 252 case ACPI_STATE_D1: 253 return PCI_D1; 254 case ACPI_STATE_D2: 255 return PCI_D2; 256 case ACPI_STATE_D3: 257 return PCI_D3hot; 258 } 259 return PCI_POWER_ERROR; 260 } 261 262 static bool acpi_pci_power_manageable(struct pci_dev *dev) 263 { 264 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 265 266 return handle ? acpi_bus_power_manageable(handle) : false; 267 } 268 269 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 270 { 271 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 272 acpi_handle tmp; 273 static const u8 state_conv[] = { 274 [PCI_D0] = ACPI_STATE_D0, 275 [PCI_D1] = ACPI_STATE_D1, 276 [PCI_D2] = ACPI_STATE_D2, 277 [PCI_D3hot] = ACPI_STATE_D3, 278 [PCI_D3cold] = ACPI_STATE_D3 279 }; 280 int error = -EINVAL; 281 282 /* If the ACPI device has _EJ0, ignore the device */ 283 if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp))) 284 return -ENODEV; 285 286 switch (state) { 287 case PCI_D0: 288 case PCI_D1: 289 case PCI_D2: 290 case PCI_D3hot: 291 case PCI_D3cold: 292 error = acpi_bus_set_power(handle, state_conv[state]); 293 } 294 295 if (!error) 296 dev_printk(KERN_INFO, &dev->dev, 297 "power state changed by ACPI to D%d\n", state); 298 299 return error; 300 } 301 302 static bool acpi_pci_can_wakeup(struct pci_dev *dev) 303 { 304 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 305 306 return handle ? acpi_bus_can_wakeup(handle) : false; 307 } 308 309 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable) 310 { 311 int error = acpi_pm_device_sleep_wake(&dev->dev, enable); 312 313 if (!error) 314 dev_printk(KERN_INFO, &dev->dev, 315 "wake-up capability %s by ACPI\n", 316 enable ? "enabled" : "disabled"); 317 return error; 318 } 319 320 static struct pci_platform_pm_ops acpi_pci_platform_pm = { 321 .is_manageable = acpi_pci_power_manageable, 322 .set_state = acpi_pci_set_power_state, 323 .choose_state = acpi_pci_choose_state, 324 .can_wakeup = acpi_pci_can_wakeup, 325 .sleep_wake = acpi_pci_sleep_wake, 326 }; 327 328 /* ACPI bus type */ 329 static int acpi_pci_find_device(struct device *dev, acpi_handle *handle) 330 { 331 struct pci_dev * pci_dev; 332 acpi_integer addr; 333 334 pci_dev = to_pci_dev(dev); 335 /* Please ref to ACPI spec for the syntax of _ADR */ 336 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 337 *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr); 338 if (!*handle) 339 return -ENODEV; 340 return 0; 341 } 342 343 static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle) 344 { 345 int num; 346 unsigned int seg, bus; 347 348 /* 349 * The string should be the same as root bridge's name 350 * Please look at 'pci_scan_bus_parented' 351 */ 352 num = sscanf(dev->bus_id, "pci%04x:%02x", &seg, &bus); 353 if (num != 2) 354 return -ENODEV; 355 *handle = acpi_get_pci_rootbridge_handle(seg, bus); 356 if (!*handle) 357 return -ENODEV; 358 return 0; 359 } 360 361 static struct acpi_bus_type acpi_pci_bus = { 362 .bus = &pci_bus_type, 363 .find_device = acpi_pci_find_device, 364 .find_bridge = acpi_pci_find_root_bridge, 365 }; 366 367 static int __init acpi_pci_init(void) 368 { 369 int ret; 370 371 if (acpi_gbl_FADT.boot_flags & BAF_MSI_NOT_SUPPORTED) { 372 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n"); 373 pci_no_msi(); 374 } 375 ret = register_acpi_bus_type(&acpi_pci_bus); 376 if (ret) 377 return 0; 378 pci_set_platform_pm(&acpi_pci_platform_pm); 379 return 0; 380 } 381 arch_initcall(acpi_pci_init); 382