www.infradead.org Git - linux.git/blob

1 // SPDX-License-Identifier: GPL-2.0-or-later

2 /*

3 * drivers/acpi/power.c - ACPI Power Resources management.

4 *

6 * Author: Andy Grover <andrew.grover@intel.com>

7 * Author: Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>

8 * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

9 */

11 /*

12 * ACPI power-managed devices may be controlled in two ways:

13 * 1. via "Device Specific (D-State) Control"

14 * 2. via "Power Resource Control".

15 * The code below deals with ACPI Power Resources control.

16 *

17 * An ACPI "power resource object" represents a software controllable power

18 * plane, clock plane, or other resource depended on by a device.

19 *

20 * A device may rely on multiple power resources, and a power resource

21 * may be shared by multiple devices.

22 */

24 #define pr_fmt(fmt) "ACPI: PM: " fmt

26 #include <linux/dmi.h>

27 #include <linux/kernel.h>

28 #include <linux/module.h>

29 #include <linux/init.h>

30 #include <linux/types.h>

31 #include <linux/slab.h>

32 #include <linux/string_choices.h>

33 #include <linux/pm_runtime.h>

34 #include <linux/sysfs.h>

35 #include <linux/acpi.h>

36 #include "sleep.h"

37 #include "internal.h"

39 #define ACPI_POWER_CLASS "power_resource"

40 #define ACPI_POWER_DEVICE_NAME "Power Resource"

41 #define ACPI_POWER_RESOURCE_STATE_OFF 0x00

42 #define ACPI_POWER_RESOURCE_STATE_ON 0x01

43 #define ACPI_POWER_RESOURCE_STATE_UNKNOWN 0xFF

45 struct acpi_power_dependent_device {

46 struct device *dev;

47 struct list_head node;

48 };

50 struct acpi_power_resource {

51 struct acpi_device device;

52 struct list_head list_node;

53 u32 system_level;

54 u32 order;

55 unsigned int ref_count;

56 u8 state;

57 struct mutex resource_lock;

58 struct list_head dependents;

59 };

61 struct acpi_power_resource_entry {

62 struct list_head node;

63 struct acpi_power_resource *resource;

64 };

66 static bool unused_power_resources_quirk;

68 static LIST_HEAD(acpi_power_resource_list);

69 static DEFINE_MUTEX(power_resource_list_lock);

71 /* --------------------------------------------------------------------------

72 Power Resource Management

73 -------------------------------------------------------------------------- */

75 static inline const char *resource_dev_name(struct acpi_power_resource *pr)

76 {

77 return dev_name(&pr->device.dev);

78 }

80 static inline

81 struct acpi_power_resource *to_power_resource(struct acpi_device *device)

82 {

83 return container_of(device, struct acpi_power_resource, device);

84 }

86 static struct acpi_power_resource *acpi_power_get_context(acpi_handle handle)

87 {

88 struct acpi_device *device = acpi_fetch_acpi_dev(handle);

90 if (!device)

91 return NULL;

93 return to_power_resource(device);

94 }

96 static int acpi_power_resources_list_add(acpi_handle handle,

97 struct list_head *list)

98 {

99 struct acpi_power_resource *resource = acpi_power_get_context(handle);

100 struct acpi_power_resource_entry *entry;

101

102 if (!resource || !list)

103 return -EINVAL;

104

105 entry = kzalloc(sizeof(*entry), GFP_KERNEL);

106 if (!entry)

107 return -ENOMEM;

108

109 entry->resource = resource;

110 if (!list_empty(list)) {

111 struct acpi_power_resource_entry *e;

112

113 list_for_each_entry(e, list, node)

114 if (e->resource->order > resource->order) {

115 list_add_tail(&entry->node, &e->node);

116 return 0;

117 }

118 }

119 list_add_tail(&entry->node, list);

120 return 0;

121 }

122

123 void acpi_power_resources_list_free(struct list_head *list)

124 {

125 struct acpi_power_resource_entry *entry, *e;

126

127 list_for_each_entry_safe(entry, e, list, node) {

128 list_del(&entry->node);

129 kfree(entry);

130 }

131 }

132

133 static bool acpi_power_resource_is_dup(union acpi_object *package,

134 unsigned int start, unsigned int i)

135 {

136 acpi_handle rhandle, dup;

137 unsigned int j;

138

139 /* The caller is expected to check the package element types */

140 rhandle = package->package.elements[i].reference.handle;

141 for (j = start; j < i; j++) {

142 dup = package->package.elements[j].reference.handle;

143 if (dup == rhandle)

144 return true;

145 }

146

147 return false;

148 }

149

150 int acpi_extract_power_resources(union acpi_object *package, unsigned int start,

151 struct list_head *list)

152 {

153 unsigned int i;

154 int err = 0;

155

156 for (i = start; i < package->package.count; i++) {

157 union acpi_object *element = &package->package.elements[i];

158 struct acpi_device *rdev;

159 acpi_handle rhandle;

160

161 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) {

162 err = -ENODATA;

163 break;

164 }

165 rhandle = element->reference.handle;

166 if (!rhandle) {

167 err = -ENODEV;

168 break;

169 }

170

171 /* Some ACPI tables contain duplicate power resource references */

172 if (acpi_power_resource_is_dup(package, start, i))

173 continue;

174

175 rdev = acpi_add_power_resource(rhandle);

176 if (!rdev) {

177 err = -ENODEV;

178 break;

179 }

180 err = acpi_power_resources_list_add(rhandle, list);

181 if (err)

182 break;

183 }

184 if (err)

185 acpi_power_resources_list_free(list);

186

187 return err;

188 }

189

190 static int __get_state(acpi_handle handle, u8 *state)

191 {

192 acpi_status status = AE_OK;

193 unsigned long long sta = 0;

194 u8 cur_state;

195

196 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);

197 if (ACPI_FAILURE(status))

198 return -ENODEV;

199

200 cur_state = sta & ACPI_POWER_RESOURCE_STATE_ON;

201

202 acpi_handle_debug(handle, "Power resource is %s\n",

203 str_on_off(cur_state));

204

205 *state = cur_state;

206 return 0;

207 }

208

209 static int acpi_power_get_state(struct acpi_power_resource *resource, u8 *state)

210 {

211 if (resource->state == ACPI_POWER_RESOURCE_STATE_UNKNOWN) {

212 int ret;

213

214 ret = __get_state(resource->device.handle, &resource->state);

215 if (ret)

216 return ret;

217 }

218

219 *state = resource->state;

220 return 0;

221 }

222

223 static int acpi_power_get_list_state(struct list_head *list, u8 *state)

224 {

225 struct acpi_power_resource_entry *entry;

226 u8 cur_state = ACPI_POWER_RESOURCE_STATE_OFF;

227

228 if (!list || !state)

229 return -EINVAL;

230

231 /* The state of the list is 'on' IFF all resources are 'on'. */

232 list_for_each_entry(entry, list, node) {

233 struct acpi_power_resource *resource = entry->resource;

234 int result;

235

236 mutex_lock(&resource->resource_lock);

237 result = acpi_power_get_state(resource, &cur_state);

238 mutex_unlock(&resource->resource_lock);

239 if (result)

240 return result;

241

242 if (cur_state != ACPI_POWER_RESOURCE_STATE_ON)

243 break;

244 }

245

246 pr_debug("Power resource list is %s\n", str_on_off(cur_state));

247

248 *state = cur_state;

249 return 0;

250 }

251

252 static int

253 acpi_power_resource_add_dependent(struct acpi_power_resource *resource,

254 struct device *dev)

255 {

256 struct acpi_power_dependent_device *dep;

257 int ret = 0;

258

259 mutex_lock(&resource->resource_lock);

260 list_for_each_entry(dep, &resource->dependents, node) {

261 /* Only add it once */

262 if (dep->dev == dev)

263 goto unlock;

264 }

265

266 dep = kzalloc(sizeof(*dep), GFP_KERNEL);

267 if (!dep) {

268 ret = -ENOMEM;

269 goto unlock;

270 }

271

272 dep->dev = dev;

273 list_add_tail(&dep->node, &resource->dependents);

274 dev_dbg(dev, "added power dependency to [%s]\n",

275 resource_dev_name(resource));

276

277 unlock:

278 mutex_unlock(&resource->resource_lock);

279 return ret;

280 }

281

282 static void

283 acpi_power_resource_remove_dependent(struct acpi_power_resource *resource,

284 struct device *dev)

285 {

286 struct acpi_power_dependent_device *dep;

287

288 mutex_lock(&resource->resource_lock);

289 list_for_each_entry(dep, &resource->dependents, node) {

290 if (dep->dev == dev) {

291 list_del(&dep->node);

292 kfree(dep);

293 dev_dbg(dev, "removed power dependency to [%s]\n",

294 resource_dev_name(resource));

295 break;

296 }

297 }

298 mutex_unlock(&resource->resource_lock);

299 }

300

301 /**

302 * acpi_device_power_add_dependent - Add dependent device of this ACPI device

303 * @adev: ACPI device pointer

304 * @dev: Dependent device

305 *

306 * If @adev has non-empty _PR0 the @dev is added as dependent device to all

307 * power resources returned by it. This means that whenever these power

308 * resources are turned _ON the dependent devices get runtime resumed. This

309 * is needed for devices such as PCI to allow its driver to re-initialize

310 * it after it went to D0uninitialized.

311 *

312 * If @adev does not have _PR0 this does nothing.

313 *

314 * Returns %0 in case of success and negative errno otherwise.

315 */

316 int acpi_device_power_add_dependent(struct acpi_device *adev,

317 struct device *dev)

318 {

319 struct acpi_power_resource_entry *entry;

320 struct list_head *resources;

321 int ret;

322

323 if (!adev->flags.power_manageable)

324 return 0;

325

326 resources = &adev->power.states[ACPI_STATE_D0].resources;

327 list_for_each_entry(entry, resources, node) {

328 ret = acpi_power_resource_add_dependent(entry->resource, dev);

329 if (ret)

330 goto err;

331 }

332

333 return 0;

334

335 err:

336 list_for_each_entry(entry, resources, node)

337 acpi_power_resource_remove_dependent(entry->resource, dev);

338

339 return ret;

340 }

341

342 /**

343 * acpi_device_power_remove_dependent - Remove dependent device

344 * @adev: ACPI device pointer

345 * @dev: Dependent device

346 *

347 * Does the opposite of acpi_device_power_add_dependent() and removes the

348 * dependent device if it is found. Can be called to @adev that does not

349 * have _PR0 as well.

350 */

351 void acpi_device_power_remove_dependent(struct acpi_device *adev,

352 struct device *dev)

353 {

354 struct acpi_power_resource_entry *entry;

355 struct list_head *resources;

356

357 if (!adev->flags.power_manageable)

358 return;

359

360 resources = &adev->power.states[ACPI_STATE_D0].resources;

361 list_for_each_entry_reverse(entry, resources, node)

362 acpi_power_resource_remove_dependent(entry->resource, dev);

363 }

364

365 static int __acpi_power_on(struct acpi_power_resource *resource)

366 {

367 acpi_handle handle = resource->device.handle;

368 struct acpi_power_dependent_device *dep;

369 acpi_status status = AE_OK;

370

371 status = acpi_evaluate_object(handle, "_ON", NULL, NULL);

372 if (ACPI_FAILURE(status)) {

373 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;

374 return -ENODEV;

375 }

376

377 resource->state = ACPI_POWER_RESOURCE_STATE_ON;

378

379 acpi_handle_debug(handle, "Power resource turned on\n");

380

381 /*

382 * If there are other dependents on this power resource we need to

383 * resume them now so that their drivers can re-initialize the

384 * hardware properly after it went back to D0.

385 */

386 if (list_empty(&resource->dependents) ||

387 list_is_singular(&resource->dependents))

388 return 0;

389

390 list_for_each_entry(dep, &resource->dependents, node) {

391 dev_dbg(dep->dev, "runtime resuming because [%s] turned on\n",

392 resource_dev_name(resource));

393 pm_request_resume(dep->dev);

394 }

395

396 return 0;

397 }

398

399 static int acpi_power_on_unlocked(struct acpi_power_resource *resource)

400 {

401 int result = 0;

402

403 if (resource->ref_count++) {

404 acpi_handle_debug(resource->device.handle,

405 "Power resource already on\n");

406 } else {

407 result = __acpi_power_on(resource);

408 if (result)

409 resource->ref_count--;

410 }

411 return result;

412 }

413

414 static int acpi_power_on(struct acpi_power_resource *resource)

415 {

416 int result;

417

418 mutex_lock(&resource->resource_lock);

419 result = acpi_power_on_unlocked(resource);

420 mutex_unlock(&resource->resource_lock);

421 return result;

422 }

423

424 static int __acpi_power_off(struct acpi_power_resource *resource)

425 {

426 acpi_handle handle = resource->device.handle;

427 acpi_status status;

428

429 status = acpi_evaluate_object(handle, "_OFF", NULL, NULL);

430 if (ACPI_FAILURE(status)) {

431 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;

432 return -ENODEV;

433 }

434

435 resource->state = ACPI_POWER_RESOURCE_STATE_OFF;

436

437 acpi_handle_debug(handle, "Power resource turned off\n");

438

439 return 0;

440 }

441

442 static int acpi_power_off_unlocked(struct acpi_power_resource *resource)

443 {

444 int result = 0;

445

446 if (!resource->ref_count) {

447 acpi_handle_debug(resource->device.handle,

448 "Power resource already off\n");

449 return 0;

450 }

451

452 if (--resource->ref_count) {

453 acpi_handle_debug(resource->device.handle,

454 "Power resource still in use\n");

455 } else {

456 result = __acpi_power_off(resource);

457 if (result)

458 resource->ref_count++;

459 }

460 return result;

461 }

462

463 static int acpi_power_off(struct acpi_power_resource *resource)

464 {

465 int result;

466

467 mutex_lock(&resource->resource_lock);

468 result = acpi_power_off_unlocked(resource);

469 mutex_unlock(&resource->resource_lock);

470 return result;

471 }

472

473 static int acpi_power_off_list(struct list_head *list)

474 {

475 struct acpi_power_resource_entry *entry;

476 int result = 0;

477

478 list_for_each_entry_reverse(entry, list, node) {

479 result = acpi_power_off(entry->resource);

480 if (result)

481 goto err;

482 }

483 return 0;

484

485 err:

486 list_for_each_entry_continue(entry, list, node)

487 acpi_power_on(entry->resource);

488

489 return result;

490 }

491

492 static int acpi_power_on_list(struct list_head *list)

493 {

494 struct acpi_power_resource_entry *entry;

495 int result = 0;

496

497 list_for_each_entry(entry, list, node) {

498 result = acpi_power_on(entry->resource);

499 if (result)

500 goto err;

501 }

502 return 0;

503

504 err:

505 list_for_each_entry_continue_reverse(entry, list, node)

506 acpi_power_off(entry->resource);

507

508 return result;

509 }

510

511 static struct attribute *attrs[] = {

512 NULL,

513 };

514

515 static const struct attribute_group attr_groups[] = {

516 [ACPI_STATE_D0] = {

517 .name = "power_resources_D0",

518 .attrs = attrs,

519 },

520 [ACPI_STATE_D1] = {

521 .name = "power_resources_D1",

522 .attrs = attrs,

523 },

524 [ACPI_STATE_D2] = {

525 .name = "power_resources_D2",

526 .attrs = attrs,

527 },

528 [ACPI_STATE_D3_HOT] = {

529 .name = "power_resources_D3hot",

530 .attrs = attrs,

531 },

532 };

533

534 static const struct attribute_group wakeup_attr_group = {

535 .name = "power_resources_wakeup",

536 .attrs = attrs,

537 };

538

539 static void acpi_power_hide_list(struct acpi_device *adev,

540 struct list_head *resources,

541 const struct attribute_group *attr_group)

542 {

543 struct acpi_power_resource_entry *entry;

544

545 if (list_empty(resources))

546 return;

547

548 list_for_each_entry_reverse(entry, resources, node) {

549 struct acpi_device *res_dev = &entry->resource->device;

550

551 sysfs_remove_link_from_group(&adev->dev.kobj,

552 attr_group->name,

553 dev_name(&res_dev->dev));

554 }

555 sysfs_remove_group(&adev->dev.kobj, attr_group);

556 }

557

558 static void acpi_power_expose_list(struct acpi_device *adev,

559 struct list_head *resources,

560 const struct attribute_group *attr_group)

561 {

562 struct acpi_power_resource_entry *entry;

563 int ret;

564

565 if (list_empty(resources))

566 return;

567

568 ret = sysfs_create_group(&adev->dev.kobj, attr_group);

569 if (ret)

570 return;

571

572 list_for_each_entry(entry, resources, node) {

573 struct acpi_device *res_dev = &entry->resource->device;

574

575 ret = sysfs_add_link_to_group(&adev->dev.kobj,

576 attr_group->name,

577 &res_dev->dev.kobj,

578 dev_name(&res_dev->dev));

579 if (ret) {

580 acpi_power_hide_list(adev, resources, attr_group);

581 break;

582 }

583 }

584 }

585

586 static void acpi_power_expose_hide(struct acpi_device *adev,

587 struct list_head *resources,

588 const struct attribute_group *attr_group,

589 bool expose)

590 {

591 if (expose)

592 acpi_power_expose_list(adev, resources, attr_group);

593 else

594 acpi_power_hide_list(adev, resources, attr_group);

595 }

596

597 void acpi_power_add_remove_device(struct acpi_device *adev, bool add)

598 {

599 int state;

600

601 if (adev->wakeup.flags.valid)

602 acpi_power_expose_hide(adev, &adev->wakeup.resources,

603 &wakeup_attr_group, add);

604

605 if (!adev->power.flags.power_resources)

606 return;

607

608 for (state = ACPI_STATE_D0; state <= ACPI_STATE_D3_HOT; state++)

609 acpi_power_expose_hide(adev,

610 &adev->power.states[state].resources,

611 &attr_groups[state], add);

612 }

613

614 int acpi_power_wakeup_list_init(struct list_head *list, int *system_level_p)

615 {

616 struct acpi_power_resource_entry *entry;

617 int system_level = 5;

618

619 list_for_each_entry(entry, list, node) {

620 struct acpi_power_resource *resource = entry->resource;

621 u8 state;

622

623 mutex_lock(&resource->resource_lock);

624

625 /*

626 * Make sure that the power resource state and its reference

627 * counter value are consistent with each other.

628 */

629 if (!resource->ref_count &&

630 !acpi_power_get_state(resource, &state) &&

631 state == ACPI_POWER_RESOURCE_STATE_ON)

632 __acpi_power_off(resource);

633

634 if (system_level > resource->system_level)

635 system_level = resource->system_level;

636

637 mutex_unlock(&resource->resource_lock);

638 }

639 *system_level_p = system_level;

640 return 0;

641 }

642

643 /* --------------------------------------------------------------------------

644 Device Power Management

645 -------------------------------------------------------------------------- */

646

647 /**

648 * acpi_device_sleep_wake - execute _DSW (Device Sleep Wake) or (deprecated in

649 * ACPI 3.0) _PSW (Power State Wake)

650 * @dev: Device to handle.

651 * @enable: 0 - disable, 1 - enable the wake capabilities of the device.

652 * @sleep_state: Target sleep state of the system.

653 * @dev_state: Target power state of the device.

654 *

655 * Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power

656 * State Wake) for the device, if present. On failure reset the device's

657 * wakeup.flags.valid flag.

658 *

659 * RETURN VALUE:

660 * 0 if either _DSW or _PSW has been successfully executed

661 * 0 if neither _DSW nor _PSW has been found

662 * -ENODEV if the execution of either _DSW or _PSW has failed

663 */

664 int acpi_device_sleep_wake(struct acpi_device *dev,

665 int enable, int sleep_state, int dev_state)

666 {

667 union acpi_object in_arg[3];

668 struct acpi_object_list arg_list = { 3, in_arg };

669 acpi_status status = AE_OK;

670

671 /*

672 * Try to execute _DSW first.

673 *

674 * Three arguments are needed for the _DSW object:

675 * Argument 0: enable/disable the wake capabilities

676 * Argument 1: target system state

677 * Argument 2: target device state

678 * When _DSW object is called to disable the wake capabilities, maybe

679 * the first argument is filled. The values of the other two arguments

680 * are meaningless.

681 */

682 in_arg[0].type = ACPI_TYPE_INTEGER;

683 in_arg[0].integer.value = enable;

684 in_arg[1].type = ACPI_TYPE_INTEGER;

685 in_arg[1].integer.value = sleep_state;

686 in_arg[2].type = ACPI_TYPE_INTEGER;

687 in_arg[2].integer.value = dev_state;

688 status = acpi_evaluate_object(dev->handle, "_DSW", &arg_list, NULL);

689 if (ACPI_SUCCESS(status)) {

690 return 0;

691 } else if (status != AE_NOT_FOUND) {

692 acpi_handle_info(dev->handle, "_DSW execution failed\n");

693 dev->wakeup.flags.valid = 0;

694 return -ENODEV;

695 }

696

697 /* Execute _PSW */

698 status = acpi_execute_simple_method(dev->handle, "_PSW", enable);

699 if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {

700 acpi_handle_info(dev->handle, "_PSW execution failed\n");

701 dev->wakeup.flags.valid = 0;

702 return -ENODEV;

703 }

704

705 return 0;

706 }

707

708 /*

709 * Prepare a wakeup device, two steps (Ref ACPI 2.0:P229):

710 * 1. Power on the power resources required for the wakeup device

711 * 2. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power

712 * State Wake) for the device, if present

713 */

714 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state)

715 {

716 int err = 0;

717

718 if (!dev || !dev->wakeup.flags.valid)

719 return -EINVAL;

720

721 mutex_lock(&acpi_device_lock);

722

723 dev_dbg(&dev->dev, "Enabling wakeup power (count %d)\n",

724 dev->wakeup.prepare_count);

725

726 if (dev->wakeup.prepare_count++)

727 goto out;

728

729 err = acpi_power_on_list(&dev->wakeup.resources);

730 if (err) {

731 dev_err(&dev->dev, "Cannot turn on wakeup power resources\n");

732 dev->wakeup.flags.valid = 0;

733 goto out;

734 }

735

736 /*

737 * Passing 3 as the third argument below means the device may be

738 * put into arbitrary power state afterward.

739 */

740 err = acpi_device_sleep_wake(dev, 1, sleep_state, 3);

741 if (err) {

742 acpi_power_off_list(&dev->wakeup.resources);

743 dev->wakeup.prepare_count = 0;

744 goto out;

745 }

746

747 dev_dbg(&dev->dev, "Wakeup power enabled\n");

748

749 out:

750 mutex_unlock(&acpi_device_lock);

751 return err;

752 }

753

754 /*

755 * Shutdown a wakeup device, counterpart of above method

756 * 1. Execute _DSW (Device Sleep Wake) or (deprecated in ACPI 3.0) _PSW (Power

757 * State Wake) for the device, if present

758 * 2. Shutdown down the power resources

759 */

760 int acpi_disable_wakeup_device_power(struct acpi_device *dev)

761 {

762 struct acpi_power_resource_entry *entry;

763 int err = 0;

764

765 if (!dev || !dev->wakeup.flags.valid)

766 return -EINVAL;

767

768 mutex_lock(&acpi_device_lock);

769

770 dev_dbg(&dev->dev, "Disabling wakeup power (count %d)\n",

771 dev->wakeup.prepare_count);

772

773 /* Do nothing if wakeup power has not been enabled for this device. */

774 if (dev->wakeup.prepare_count <= 0)

775 goto out;

776

777 if (--dev->wakeup.prepare_count > 0)

778 goto out;

779

780 err = acpi_device_sleep_wake(dev, 0, 0, 0);

781 if (err)

782 goto out;

783

784 /*

785 * All of the power resources in the list need to be turned off even if

786 * there are errors.

787 */

788 list_for_each_entry(entry, &dev->wakeup.resources, node) {

789 int ret;

790

791 ret = acpi_power_off(entry->resource);

792 if (ret && !err)

793 err = ret;

794 }

795 if (err) {

796 dev_err(&dev->dev, "Cannot turn off wakeup power resources\n");

797 dev->wakeup.flags.valid = 0;

798 goto out;

799 }

800

801 dev_dbg(&dev->dev, "Wakeup power disabled\n");

802

803 out:

804 mutex_unlock(&acpi_device_lock);

805 return err;

806 }

807

808 int acpi_power_get_inferred_state(struct acpi_device *device, int *state)

809 {

810 u8 list_state = ACPI_POWER_RESOURCE_STATE_OFF;

811 int result = 0;

812 int i = 0;

813

814 if (!device || !state)

815 return -EINVAL;

816

817 /*

818 * We know a device's inferred power state when all the resources

819 * required for a given D-state are 'on'.

820 */

821 for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {

822 struct list_head *list = &device->power.states[i].resources;

823

824 if (list_empty(list))

825 continue;

826

827 result = acpi_power_get_list_state(list, &list_state);

828 if (result)

829 return result;

830

831 if (list_state == ACPI_POWER_RESOURCE_STATE_ON) {

832 *state = i;

833 return 0;

834 }

835 }

836

837 *state = device->power.states[ACPI_STATE_D3_COLD].flags.valid ?

838 ACPI_STATE_D3_COLD : ACPI_STATE_D3_HOT;

839 return 0;

840 }

841

842 int acpi_power_on_resources(struct acpi_device *device, int state)

843 {

844 if (!device || state < ACPI_STATE_D0 || state > ACPI_STATE_D3_HOT)

845 return -EINVAL;

846

847 return acpi_power_on_list(&device->power.states[state].resources);

848 }

849

850 int acpi_power_transition(struct acpi_device *device, int state)

851 {

852 int result = 0;

853

854 if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))

855 return -EINVAL;

856

857 if (device->power.state == state || !device->flags.power_manageable)

858 return 0;

859

860 if ((device->power.state < ACPI_STATE_D0)

861 || (device->power.state > ACPI_STATE_D3_COLD))

862 return -ENODEV;

863

864 /*

865 * First we reference all power resources required in the target list

866 * (e.g. so the device doesn't lose power while transitioning). Then,

867 * we dereference all power resources used in the current list.

868 */

869 if (state < ACPI_STATE_D3_COLD)

870 result = acpi_power_on_list(

871 &device->power.states[state].resources);

872

873 if (!result && device->power.state < ACPI_STATE_D3_COLD)

874 acpi_power_off_list(

875 &device->power.states[device->power.state].resources);

876

877 /* We shouldn't change the state unless the above operations succeed. */

878 device->power.state = result ? ACPI_STATE_UNKNOWN : state;

879

880 return result;

881 }

882

883 static void acpi_release_power_resource(struct device *dev)

884 {

885 struct acpi_device *device = to_acpi_device(dev);

886 struct acpi_power_resource *resource;

887

888 resource = container_of(device, struct acpi_power_resource, device);

889

890 mutex_lock(&power_resource_list_lock);

891 list_del(&resource->list_node);

892 mutex_unlock(&power_resource_list_lock);

893

894 acpi_free_pnp_ids(&device->pnp);

895 kfree(resource);

896 }

897

898 static ssize_t resource_in_use_show(struct device *dev,

899 struct device_attribute *attr,

900 char *buf)

901 {

902 struct acpi_power_resource *resource;

903

904 resource = to_power_resource(to_acpi_device(dev));

905 return sprintf(buf, "%u\n", !!resource->ref_count);

906 }

907 static DEVICE_ATTR_RO(resource_in_use);

908

909 static void acpi_power_sysfs_remove(struct acpi_device *device)

910 {

911 device_remove_file(&device->dev, &dev_attr_resource_in_use);

912 }

913

914 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource)

915 {

916 mutex_lock(&power_resource_list_lock);

917

918 if (!list_empty(&acpi_power_resource_list)) {

919 struct acpi_power_resource *r;

920

921 list_for_each_entry(r, &acpi_power_resource_list, list_node)

922 if (r->order > resource->order) {

923 list_add_tail(&resource->list_node, &r->list_node);

924 goto out;

925 }

926 }

927 list_add_tail(&resource->list_node, &acpi_power_resource_list);

928

929 out:

930 mutex_unlock(&power_resource_list_lock);

931 }

932

933 struct acpi_device *acpi_add_power_resource(acpi_handle handle)

934 {

935 struct acpi_device *device = acpi_fetch_acpi_dev(handle);

936 struct acpi_power_resource *resource;

937 union acpi_object acpi_object;

938 struct acpi_buffer buffer = { sizeof(acpi_object), &acpi_object };

939 acpi_status status;

940 u8 state_dummy;

941 int result;

942

943 if (device)

944 return device;

945

946 resource = kzalloc(sizeof(*resource), GFP_KERNEL);

947 if (!resource)

948 return NULL;

949

950 device = &resource->device;

951 acpi_init_device_object(device, handle, ACPI_BUS_TYPE_POWER,

952 acpi_release_power_resource);

953 mutex_init(&resource->resource_lock);

954 INIT_LIST_HEAD(&resource->list_node);

955 INIT_LIST_HEAD(&resource->dependents);

956 strscpy(acpi_device_name(device), ACPI_POWER_DEVICE_NAME);

957 strscpy(acpi_device_class(device), ACPI_POWER_CLASS);

958 device->power.state = ACPI_STATE_UNKNOWN;

959 device->flags.match_driver = true;

960

961 /* Evaluate the object to get the system level and resource order. */

962 status = acpi_evaluate_object(handle, NULL, NULL, &buffer);

963 if (ACPI_FAILURE(status))

964 goto err;

965

966 resource->system_level = acpi_object.power_resource.system_level;

967 resource->order = acpi_object.power_resource.resource_order;

968 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;

969

970 /* Get the initial state or just flip it on if that fails. */

971 if (acpi_power_get_state(resource, &state_dummy))

972 __acpi_power_on(resource);

973

974 acpi_handle_info(handle, "New power resource\n");

975

976 result = acpi_tie_acpi_dev(device);

977 if (result)

978 goto err;

979

980 result = acpi_device_add(device);

981 if (result)

982 goto err;

983

984 if (!device_create_file(&device->dev, &dev_attr_resource_in_use))

985 device->remove = acpi_power_sysfs_remove;

986

987 acpi_power_add_resource_to_list(resource);

988 acpi_device_add_finalize(device);

989 return device;

990

991 err:

992 acpi_release_power_resource(&device->dev);

993 return NULL;

994 }

995

996 #ifdef CONFIG_ACPI_SLEEP

997 void acpi_resume_power_resources(void)

998 {

999 struct acpi_power_resource *resource;

1000

1001 mutex_lock(&power_resource_list_lock);

1002

1003 list_for_each_entry(resource, &acpi_power_resource_list, list_node) {

1004 int result;

1005 u8 state;

1006

1007 mutex_lock(&resource->resource_lock);

1008

1009 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;

1010 result = acpi_power_get_state(resource, &state);

1011 if (result) {

1012 mutex_unlock(&resource->resource_lock);

1013 continue;

1014 }

1015

1016 if (state == ACPI_POWER_RESOURCE_STATE_OFF

1017 && resource->ref_count) {

1018 acpi_handle_debug(resource->device.handle, "Turning ON\n");

1019 __acpi_power_on(resource);

1020 }

1021

1022 mutex_unlock(&resource->resource_lock);

1023 }

1024

1025 mutex_unlock(&power_resource_list_lock);

1026 }

1027 #endif

1028

1029 static const struct dmi_system_id dmi_leave_unused_power_resources_on[] = {

1030 {

1031 /*

1032 * The Toshiba Click Mini has a CPR3 power-resource which must

1033 * be on for the touchscreen to work, but which is not in any

1034 * _PR? lists. The other 2 affected power-resources are no-ops.

1035 */

1036 .matches = {

1037 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),

1038 DMI_MATCH(DMI_PRODUCT_NAME, "SATELLITE Click Mini L9W-B"),

1039 },

1040 },

1041 {}

1042 };

1043

1044 /**

1045 * acpi_turn_off_unused_power_resources - Turn off power resources not in use.

1046 */

1047 void acpi_turn_off_unused_power_resources(void)

1048 {

1049 struct acpi_power_resource *resource;

1050

1051 if (unused_power_resources_quirk)

1052 return;

1053

1054 mutex_lock(&power_resource_list_lock);

1055

1056 list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) {

1057 mutex_lock(&resource->resource_lock);

1058

1059 if (!resource->ref_count &&

1060 resource->state == ACPI_POWER_RESOURCE_STATE_ON) {

1061 acpi_handle_debug(resource->device.handle, "Turning OFF\n");

1062 __acpi_power_off(resource);

1063 }

1064

1065 mutex_unlock(&resource->resource_lock);

1066 }

1067

1068 mutex_unlock(&power_resource_list_lock);

1069 }

1070

1071 void __init acpi_power_resources_init(void)

1072 {

1073 unused_power_resources_quirk =

1074 dmi_check_system(dmi_leave_unused_power_resources_on);

1075 }