tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'pm+acpi-3.11-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull ACPI and power management fixes from Rafael Wysocki:

- ACPI-based memory hotplug stopped working after a recent change,
because it's not possible to associate sufficiently many "physical"
devices with one ACPI device object due to an artificial limit. Fix
from Rafael J Wysocki removes that limit and makes memory hotplug
work again.

- A change made in 3.9 uncovered a bug in the ACPI processor driver
preventing NUMA nodes from being put offline due to an ordering
issue. Fix from Yasuaki Ishimatsu changes the ordering to make
things work again.

- One of the recent ACPI video commits (that hasn't been reverted so
far) uncovered a bug in the code handling quirky BIOSes that caused
some Asus machines to boot with backlight completely off which made
it quite difficult to use them afterward. Fix from Felipe Contreras
improves the quirk to cover this particular case correctly.

- A cpufreq user space interface change made in 3.10 inadvertently
renamed the ignore_nice_load sysfs attribute to ignore_nice which
resulted in some confusion. Fix from Viresh Kumar changes the name
back to ignore_nice_load.

- An initialization ordering change made in 3.9 broke cpufreq on
loongson2 boards. Fix from Aaro Koskinen restores the correct
initialization ordering there.

- Fix breakage resulting from a mistake made in 3.9 and causing the
detection of some graphics adapters (that were detected correctly
before) to fail. There are two objects representing the same PCIe
port in the affected systems' ACPI tables and both appear as
"enabled" and we are expected to guess which one to use. We used to
choose the right one before by pure luck, but when we tried to
address another similar corner case, the luck went away. This time
we try to make our guessing a bit more educated which is reported to
work on those systems.

- The /proc/acpi/wakeup interface code is missing some locking which
may lead to breakage if that file is written or read during hotplug
of wakeup devices. That should be rare but still possible, so it's
better to start using the appropriate locking there.

* tag 'pm+acpi-3.11-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
ACPI: Try harder to resolve _ADR collisions for bridges
cpufreq: rename ignore_nice as ignore_nice_load
cpufreq: loongson2: fix regression related to clock management
ACPI / processor: move try_offline_node() after acpi_unmap_lsapic()
ACPI: Drop physical_node_id_bitmap from struct acpi_device
ACPI / PM: Walk physical_node_list under physical_node_lock
ACPI / video: improve quirk check in acpi_video_bqc_quirk()

Linus Torvalds 14e94194 fdafa7cf

+162 -76
+2 -1
drivers/acpi/acpi_processor.c
··· 451 451 /* Clean up. */ 452 452 per_cpu(processor_device_array, pr->id) = NULL; 453 453 per_cpu(processors, pr->id) = NULL; 454 - try_offline_node(cpu_to_node(pr->id)); 455 454 456 455 /* Remove the CPU. */ 457 456 get_online_cpus(); 458 457 arch_unregister_cpu(pr->id); 459 458 acpi_unmap_lsapic(pr->id); 460 459 put_online_cpus(); 460 + 461 + try_offline_node(cpu_to_node(pr->id)); 461 462 462 463 out: 463 464 free_cpumask_var(pr->throttling.shared_cpu_map);
+101 -32
drivers/acpi/glue.c
··· 31 31 static DECLARE_RWSEM(bus_type_sem); 32 32 33 33 #define PHYSICAL_NODE_STRING "physical_node" 34 + #define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10) 34 35 35 36 int register_acpi_bus_type(struct acpi_bus_type *type) 36 37 { ··· 79 78 return ret; 80 79 } 81 80 82 - static acpi_status do_acpi_find_child(acpi_handle handle, u32 lvl_not_used, 83 - void *addr_p, void **ret_p) 81 + static acpi_status acpi_dev_present(acpi_handle handle, u32 lvl_not_used, 82 + void *not_used, void **ret_p) 84 83 { 85 - unsigned long long addr, sta; 86 - acpi_status status; 84 + struct acpi_device *adev = NULL; 87 85 88 - status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr); 89 - if (ACPI_SUCCESS(status) && addr == *((u64 *)addr_p)) { 86 + acpi_bus_get_device(handle, &adev); 87 + if (adev) { 90 88 *ret_p = handle; 91 - status = acpi_bus_get_status_handle(handle, &sta); 92 - if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_ENABLED)) 93 - return AE_CTRL_TERMINATE; 89 + return AE_CTRL_TERMINATE; 94 90 } 95 91 return AE_OK; 96 92 } 97 93 98 - acpi_handle acpi_get_child(acpi_handle parent, u64 address) 94 + static bool acpi_extra_checks_passed(acpi_handle handle, bool is_bridge) 99 95 { 100 - void *ret = NULL; 96 + unsigned long long sta; 97 + acpi_status status; 101 98 102 - if (!parent) 103 - return NULL; 99 + status = acpi_bus_get_status_handle(handle, &sta); 100 + if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED)) 101 + return false; 104 102 105 - acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, NULL, 106 - do_acpi_find_child, &address, &ret); 107 - return (acpi_handle)ret; 103 + if (is_bridge) { 104 + void *test = NULL; 105 + 106 + /* Check if this object has at least one child device. */ 107 + acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 108 + acpi_dev_present, NULL, NULL, &test); 109 + return !!test; 110 + } 111 + return true; 108 112 } 109 - EXPORT_SYMBOL(acpi_get_child); 113 + 114 + struct find_child_context { 115 + u64 addr; 116 + bool is_bridge; 117 + acpi_handle ret; 118 + bool ret_checked; 119 + }; 120 + 121 + static acpi_status do_find_child(acpi_handle handle, u32 lvl_not_used, 122 + void *data, void **not_used) 123 + { 124 + struct find_child_context *context = data; 125 + unsigned long long addr; 126 + acpi_status status; 127 + 128 + status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr); 129 + if (ACPI_FAILURE(status) || addr != context->addr) 130 + return AE_OK; 131 + 132 + if (!context->ret) { 133 + /* This is the first matching object. Save its handle. */ 134 + context->ret = handle; 135 + return AE_OK; 136 + } 137 + /* 138 + * There is more than one matching object with the same _ADR value. 139 + * That really is unexpected, so we are kind of beyond the scope of the 140 + * spec here. We have to choose which one to return, though. 141 + * 142 + * First, check if the previously found object is good enough and return 143 + * its handle if so. Second, check the same for the object that we've 144 + * just found. 145 + */ 146 + if (!context->ret_checked) { 147 + if (acpi_extra_checks_passed(context->ret, context->is_bridge)) 148 + return AE_CTRL_TERMINATE; 149 + else 150 + context->ret_checked = true; 151 + } 152 + if (acpi_extra_checks_passed(handle, context->is_bridge)) { 153 + context->ret = handle; 154 + return AE_CTRL_TERMINATE; 155 + } 156 + return AE_OK; 157 + } 158 + 159 + acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge) 160 + { 161 + if (parent) { 162 + struct find_child_context context = { 163 + .addr = addr, 164 + .is_bridge = is_bridge, 165 + }; 166 + 167 + acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, do_find_child, 168 + NULL, &context, NULL); 169 + return context.ret; 170 + } 171 + return NULL; 172 + } 173 + EXPORT_SYMBOL_GPL(acpi_find_child); 110 174 111 175 int acpi_bind_one(struct device *dev, acpi_handle handle) 112 176 { 113 177 struct acpi_device *acpi_dev; 114 178 acpi_status status; 115 179 struct acpi_device_physical_node *physical_node, *pn; 116 - char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2]; 180 + char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 181 + struct list_head *physnode_list; 182 + unsigned int node_id; 117 183 int retval = -EINVAL; 118 184 119 185 if (ACPI_HANDLE(dev)) { ··· 207 139 208 140 mutex_lock(&acpi_dev->physical_node_lock); 209 141 210 - /* Sanity check. */ 211 - list_for_each_entry(pn, &acpi_dev->physical_node_list, node) 142 + /* 143 + * Keep the list sorted by node_id so that the IDs of removed nodes can 144 + * be recycled easily. 145 + */ 146 + physnode_list = &acpi_dev->physical_node_list; 147 + node_id = 0; 148 + list_for_each_entry(pn, &acpi_dev->physical_node_list, node) { 149 + /* Sanity check. */ 212 150 if (pn->dev == dev) { 213 151 dev_warn(dev, "Already associated with ACPI node\n"); 214 152 goto err_free; 215 153 } 216 - 217 - /* allocate physical node id according to physical_node_id_bitmap */ 218 - physical_node->node_id = 219 - find_first_zero_bit(acpi_dev->physical_node_id_bitmap, 220 - ACPI_MAX_PHYSICAL_NODE); 221 - if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) { 222 - retval = -ENOSPC; 223 - goto err_free; 154 + if (pn->node_id == node_id) { 155 + physnode_list = &pn->node; 156 + node_id++; 157 + } 224 158 } 225 159 226 - set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap); 160 + physical_node->node_id = node_id; 227 161 physical_node->dev = dev; 228 - list_add_tail(&physical_node->node, &acpi_dev->physical_node_list); 162 + list_add(&physical_node->node, physnode_list); 229 163 acpi_dev->physical_node_count++; 230 164 231 165 mutex_unlock(&acpi_dev->physical_node_lock); ··· 278 208 279 209 mutex_lock(&acpi_dev->physical_node_lock); 280 210 list_for_each_safe(node, next, &acpi_dev->physical_node_list) { 281 - char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2]; 211 + char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 282 212 283 213 entry = list_entry(node, struct acpi_device_physical_node, 284 214 node); ··· 286 216 continue; 287 217 288 218 list_del(node); 289 - clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap); 290 219 291 220 acpi_dev->physical_node_count--; 292 221
+8
drivers/acpi/proc.c
··· 311 311 dev->pnp.bus_id, 312 312 (u32) dev->wakeup.sleep_state); 313 313 314 + mutex_lock(&dev->physical_node_lock); 315 + 314 316 if (!dev->physical_node_count) { 315 317 seq_printf(seq, "%c%-8s\n", 316 318 dev->wakeup.flags.run_wake ? '*' : ' ', ··· 340 338 put_device(ldev); 341 339 } 342 340 } 341 + 342 + mutex_unlock(&dev->physical_node_lock); 343 343 } 344 344 mutex_unlock(&acpi_device_lock); 345 345 return 0; ··· 351 347 { 352 348 struct acpi_device_physical_node *entry; 353 349 350 + mutex_lock(&adev->physical_node_lock); 351 + 354 352 list_for_each_entry(entry, 355 353 &adev->physical_node_list, node) 356 354 if (entry->dev && device_can_wakeup(entry->dev)) { 357 355 bool enable = !device_may_wakeup(entry->dev); 358 356 device_set_wakeup_enable(entry->dev, enable); 359 357 } 358 + 359 + mutex_unlock(&adev->physical_node_lock); 360 360 } 361 361 362 362 static ssize_t
+1 -1
drivers/acpi/video.c
··· 689 689 * Some systems always report current brightness level as maximum 690 690 * through _BQC, we need to test another value for them. 691 691 */ 692 - test_level = current_level == max_level ? br->levels[2] : max_level; 692 + test_level = current_level == max_level ? br->levels[3] : max_level; 693 693 694 694 result = acpi_video_device_lcd_set_level(device, test_level); 695 695 if (result)
+10 -10
drivers/cpufreq/cpufreq_conservative.c
··· 221 221 return count; 222 222 } 223 223 224 - static ssize_t store_ignore_nice(struct dbs_data *dbs_data, const char *buf, 225 - size_t count) 224 + static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, 225 + const char *buf, size_t count) 226 226 { 227 227 struct cs_dbs_tuners *cs_tuners = dbs_data->tuners; 228 228 unsigned int input, j; ··· 235 235 if (input > 1) 236 236 input = 1; 237 237 238 - if (input == cs_tuners->ignore_nice) /* nothing to do */ 238 + if (input == cs_tuners->ignore_nice_load) /* nothing to do */ 239 239 return count; 240 240 241 - cs_tuners->ignore_nice = input; 241 + cs_tuners->ignore_nice_load = input; 242 242 243 243 /* we need to re-evaluate prev_cpu_idle */ 244 244 for_each_online_cpu(j) { ··· 246 246 dbs_info = &per_cpu(cs_cpu_dbs_info, j); 247 247 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, 248 248 &dbs_info->cdbs.prev_cpu_wall, 0); 249 - if (cs_tuners->ignore_nice) 249 + if (cs_tuners->ignore_nice_load) 250 250 dbs_info->cdbs.prev_cpu_nice = 251 251 kcpustat_cpu(j).cpustat[CPUTIME_NICE]; 252 252 } ··· 279 279 show_store_one(cs, sampling_down_factor); 280 280 show_store_one(cs, up_threshold); 281 281 show_store_one(cs, down_threshold); 282 - show_store_one(cs, ignore_nice); 282 + show_store_one(cs, ignore_nice_load); 283 283 show_store_one(cs, freq_step); 284 284 declare_show_sampling_rate_min(cs); 285 285 ··· 287 287 gov_sys_pol_attr_rw(sampling_down_factor); 288 288 gov_sys_pol_attr_rw(up_threshold); 289 289 gov_sys_pol_attr_rw(down_threshold); 290 - gov_sys_pol_attr_rw(ignore_nice); 290 + gov_sys_pol_attr_rw(ignore_nice_load); 291 291 gov_sys_pol_attr_rw(freq_step); 292 292 gov_sys_pol_attr_ro(sampling_rate_min); 293 293 ··· 297 297 &sampling_down_factor_gov_sys.attr, 298 298 &up_threshold_gov_sys.attr, 299 299 &down_threshold_gov_sys.attr, 300 - &ignore_nice_gov_sys.attr, 300 + &ignore_nice_load_gov_sys.attr, 301 301 &freq_step_gov_sys.attr, 302 302 NULL 303 303 }; ··· 313 313 &sampling_down_factor_gov_pol.attr, 314 314 &up_threshold_gov_pol.attr, 315 315 &down_threshold_gov_pol.attr, 316 - &ignore_nice_gov_pol.attr, 316 + &ignore_nice_load_gov_pol.attr, 317 317 &freq_step_gov_pol.attr, 318 318 NULL 319 319 }; ··· 338 338 tuners->up_threshold = DEF_FREQUENCY_UP_THRESHOLD; 339 339 tuners->down_threshold = DEF_FREQUENCY_DOWN_THRESHOLD; 340 340 tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; 341 - tuners->ignore_nice = 0; 341 + tuners->ignore_nice_load = 0; 342 342 tuners->freq_step = DEF_FREQUENCY_STEP; 343 343 344 344 dbs_data->tuners = tuners;
+4 -4
drivers/cpufreq/cpufreq_governor.c
··· 47 47 unsigned int j; 48 48 49 49 if (dbs_data->cdata->governor == GOV_ONDEMAND) 50 - ignore_nice = od_tuners->ignore_nice; 50 + ignore_nice = od_tuners->ignore_nice_load; 51 51 else 52 - ignore_nice = cs_tuners->ignore_nice; 52 + ignore_nice = cs_tuners->ignore_nice_load; 53 53 54 54 policy = cdbs->cur_policy; 55 55 ··· 298 298 cs_tuners = dbs_data->tuners; 299 299 cs_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu); 300 300 sampling_rate = cs_tuners->sampling_rate; 301 - ignore_nice = cs_tuners->ignore_nice; 301 + ignore_nice = cs_tuners->ignore_nice_load; 302 302 } else { 303 303 od_tuners = dbs_data->tuners; 304 304 od_dbs_info = dbs_data->cdata->get_cpu_dbs_info_s(cpu); 305 305 sampling_rate = od_tuners->sampling_rate; 306 - ignore_nice = od_tuners->ignore_nice; 306 + ignore_nice = od_tuners->ignore_nice_load; 307 307 od_ops = dbs_data->cdata->gov_ops; 308 308 io_busy = od_tuners->io_is_busy; 309 309 }
+2 -2
drivers/cpufreq/cpufreq_governor.h
··· 165 165 166 166 /* Per policy Governers sysfs tunables */ 167 167 struct od_dbs_tuners { 168 - unsigned int ignore_nice; 168 + unsigned int ignore_nice_load; 169 169 unsigned int sampling_rate; 170 170 unsigned int sampling_down_factor; 171 171 unsigned int up_threshold; ··· 175 175 }; 176 176 177 177 struct cs_dbs_tuners { 178 - unsigned int ignore_nice; 178 + unsigned int ignore_nice_load; 179 179 unsigned int sampling_rate; 180 180 unsigned int sampling_down_factor; 181 181 unsigned int up_threshold;
+10 -10
drivers/cpufreq/cpufreq_ondemand.c
··· 403 403 return count; 404 404 } 405 405 406 - static ssize_t store_ignore_nice(struct dbs_data *dbs_data, const char *buf, 407 - size_t count) 406 + static ssize_t store_ignore_nice_load(struct dbs_data *dbs_data, 407 + const char *buf, size_t count) 408 408 { 409 409 struct od_dbs_tuners *od_tuners = dbs_data->tuners; 410 410 unsigned int input; ··· 419 419 if (input > 1) 420 420 input = 1; 421 421 422 - if (input == od_tuners->ignore_nice) { /* nothing to do */ 422 + if (input == od_tuners->ignore_nice_load) { /* nothing to do */ 423 423 return count; 424 424 } 425 - od_tuners->ignore_nice = input; 425 + od_tuners->ignore_nice_load = input; 426 426 427 427 /* we need to re-evaluate prev_cpu_idle */ 428 428 for_each_online_cpu(j) { ··· 430 430 dbs_info = &per_cpu(od_cpu_dbs_info, j); 431 431 dbs_info->cdbs.prev_cpu_idle = get_cpu_idle_time(j, 432 432 &dbs_info->cdbs.prev_cpu_wall, od_tuners->io_is_busy); 433 - if (od_tuners->ignore_nice) 433 + if (od_tuners->ignore_nice_load) 434 434 dbs_info->cdbs.prev_cpu_nice = 435 435 kcpustat_cpu(j).cpustat[CPUTIME_NICE]; 436 436 ··· 461 461 show_store_one(od, io_is_busy); 462 462 show_store_one(od, up_threshold); 463 463 show_store_one(od, sampling_down_factor); 464 - show_store_one(od, ignore_nice); 464 + show_store_one(od, ignore_nice_load); 465 465 show_store_one(od, powersave_bias); 466 466 declare_show_sampling_rate_min(od); 467 467 ··· 469 469 gov_sys_pol_attr_rw(io_is_busy); 470 470 gov_sys_pol_attr_rw(up_threshold); 471 471 gov_sys_pol_attr_rw(sampling_down_factor); 472 - gov_sys_pol_attr_rw(ignore_nice); 472 + gov_sys_pol_attr_rw(ignore_nice_load); 473 473 gov_sys_pol_attr_rw(powersave_bias); 474 474 gov_sys_pol_attr_ro(sampling_rate_min); 475 475 ··· 478 478 &sampling_rate_gov_sys.attr, 479 479 &up_threshold_gov_sys.attr, 480 480 &sampling_down_factor_gov_sys.attr, 481 - &ignore_nice_gov_sys.attr, 481 + &ignore_nice_load_gov_sys.attr, 482 482 &powersave_bias_gov_sys.attr, 483 483 &io_is_busy_gov_sys.attr, 484 484 NULL ··· 494 494 &sampling_rate_gov_pol.attr, 495 495 &up_threshold_gov_pol.attr, 496 496 &sampling_down_factor_gov_pol.attr, 497 - &ignore_nice_gov_pol.attr, 497 + &ignore_nice_load_gov_pol.attr, 498 498 &powersave_bias_gov_pol.attr, 499 499 &io_is_busy_gov_pol.attr, 500 500 NULL ··· 544 544 } 545 545 546 546 tuners->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR; 547 - tuners->ignore_nice = 0; 547 + tuners->ignore_nice_load = 0; 548 548 tuners->powersave_bias = default_powersave_bias; 549 549 tuners->io_is_busy = should_io_be_busy(); 550 550
+6 -5
drivers/cpufreq/loongson2_cpufreq.c
··· 118 118 clk_put(cpuclk); 119 119 return -EINVAL; 120 120 } 121 - ret = clk_set_rate(cpuclk, rate); 122 - if (ret) { 123 - clk_put(cpuclk); 124 - return ret; 125 - } 126 121 127 122 /* clock table init */ 128 123 for (i = 2; 129 124 (loongson2_clockmod_table[i].frequency != CPUFREQ_TABLE_END); 130 125 i++) 131 126 loongson2_clockmod_table[i].frequency = (rate * i) / 8; 127 + 128 + ret = clk_set_rate(cpuclk, rate); 129 + if (ret) { 130 + clk_put(cpuclk); 131 + return ret; 132 + } 132 133 133 134 policy->cur = loongson2_cpufreq_get(policy->cpu); 134 135
+11 -4
drivers/pci/pci-acpi.c
··· 317 317 /* ACPI bus type */ 318 318 static int acpi_pci_find_device(struct device *dev, acpi_handle *handle) 319 319 { 320 - struct pci_dev * pci_dev; 321 - u64 addr; 320 + struct pci_dev *pci_dev = to_pci_dev(dev); 321 + bool is_bridge; 322 + u64 addr; 322 323 323 - pci_dev = to_pci_dev(dev); 324 + /* 325 + * pci_is_bridge() is not suitable here, because pci_dev->subordinate 326 + * is set only after acpi_pci_find_device() has been called for the 327 + * given device. 328 + */ 329 + is_bridge = pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE 330 + || pci_dev->hdr_type == PCI_HEADER_TYPE_CARDBUS; 324 331 /* Please ref to ACPI spec for the syntax of _ADR */ 325 332 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 326 - *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr); 333 + *handle = acpi_find_child(ACPI_HANDLE(dev->parent), addr, is_bridge); 327 334 if (!*handle) 328 335 return -ENODEV; 329 336 return 0;
+7 -7
include/acpi/acpi_bus.h
··· 274 274 }; 275 275 276 276 struct acpi_device_physical_node { 277 - u8 node_id; 277 + unsigned int node_id; 278 278 struct list_head node; 279 279 struct device *dev; 280 280 bool put_online:1; 281 281 }; 282 - 283 - /* set maximum of physical nodes to 32 for expansibility */ 284 - #define ACPI_MAX_PHYSICAL_NODE 32 285 282 286 283 /* Device */ 287 284 struct acpi_device { ··· 299 302 struct acpi_driver *driver; 300 303 void *driver_data; 301 304 struct device dev; 302 - u8 physical_node_count; 305 + unsigned int physical_node_count; 303 306 struct list_head physical_node_list; 304 307 struct mutex physical_node_lock; 305 - DECLARE_BITMAP(physical_node_id_bitmap, ACPI_MAX_PHYSICAL_NODE); 306 308 struct list_head power_dependent; 307 309 void (*remove)(struct acpi_device *); 308 310 }; ··· 441 445 }; 442 446 443 447 /* helper */ 444 - acpi_handle acpi_get_child(acpi_handle, u64); 448 + acpi_handle acpi_find_child(acpi_handle, u64, bool); 449 + static inline acpi_handle acpi_get_child(acpi_handle handle, u64 addr) 450 + { 451 + return acpi_find_child(handle, addr, false); 452 + } 445 453 int acpi_is_root_bridge(acpi_handle); 446 454 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle); 447 455 #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)ACPI_HANDLE(dev))