/** * acpi_subsys_complete - Finalize device's resume during system resume. * @dev: Device to handle. */ void acpi_subsys_complete(struct device *dev) { /* * If the device had been runtime-suspended before the system went into * the sleep state it is going out of and it has never been resumed till * now, resume it in case the firmware powered it up. */ if (dev->power.direct_complete) pm_request_resume(dev); }
static int usb_port_runtime_resume(struct device *dev) { struct usb_port *port_dev = to_usb_port(dev); struct usb_device *hdev = to_usb_device(dev->parent->parent); struct usb_interface *intf = to_usb_interface(dev->parent); struct usb_hub *hub = usb_hub_to_struct_hub(hdev); struct usb_device *udev = port_dev->child; struct usb_port *peer = port_dev->peer; int port1 = port_dev->portnum; int retval; if (!hub) return -EINVAL; if (hub->in_reset) { set_bit(port1, hub->power_bits); return 0; } /* * Power on our usb3 peer before this usb2 port to prevent a usb3 * device from degrading to its usb2 connection */ if (!port_dev->is_superspeed && peer) pm_runtime_get_sync(&peer->dev); usb_autopm_get_interface(intf); retval = usb_hub_set_port_power(hdev, hub, port1, true); msleep(hub_power_on_good_delay(hub)); if (udev && !retval) { /* * Attempt to wait for usb hub port to be reconnected in order * to make the resume procedure successful. The device may have * disconnected while the port was powered off, so ignore the * return status. */ retval = hub_port_debounce_be_connected(hub, port1); if (retval < 0) dev_dbg(&port_dev->dev, "can't get reconnection after setting port power on, status %d\n", retval); retval = 0; /* Force the child awake to revalidate after the power loss. */ if (!test_and_set_bit(port1, hub->child_usage_bits)) { pm_runtime_get_noresume(&port_dev->dev); pm_request_resume(&udev->dev); } } usb_autopm_put_interface(intf); return retval; }
/** * pci_acpi_wake_dev - PCI device wakeup notification work function. * @context: Device wakeup context. */ static void pci_acpi_wake_dev(struct acpi_device_wakeup_context *context) { struct pci_dev *pci_dev; pci_dev = to_pci_dev(context->dev); if (pci_dev->pme_poll) pci_dev->pme_poll = false; if (pci_dev->current_state == PCI_D3cold) { pci_wakeup_event(pci_dev); pm_request_resume(&pci_dev->dev); return; } /* Clear PME Status if set. */ if (pci_dev->pme_support) pci_check_pme_status(pci_dev); pci_wakeup_event(pci_dev); pm_request_resume(&pci_dev->dev); pci_pme_wakeup_bus(pci_dev->subordinate); }
/* Resume the device when all power resources in _PR0 are on */ static void acpi_power_on_device(struct acpi_power_managed_device *device) { struct acpi_device *acpi_dev; acpi_handle handle = device->handle; int state; if (acpi_bus_get_device(handle, &acpi_dev)) return; if(acpi_power_get_inferred_state(acpi_dev, &state)) return; if (state == ACPI_STATE_D0 && pm_runtime_suspended(device->dev)) pm_request_resume(device->dev); }
static enum MHI_STATUS process_wake_transition( struct mhi_device_ctxt *mhi_dev_ctxt, enum STATE_TRANSITION cur_work_item) { enum MHI_STATUS ret_val = MHI_STATUS_SUCCESS; int r = 0; mhi_log(MHI_MSG_INFO, "Entered\n"); __pm_stay_awake(&mhi_dev_ctxt->w_lock); if (atomic_read(&mhi_dev_ctxt->flags.pending_ssr)) { mhi_log(MHI_MSG_CRITICAL, "Pending SSR, Ignoring.\n"); goto exit; } if (mhi_dev_ctxt->flags.mhi_initialized) { r = pm_request_resume(&mhi_dev_ctxt->dev_info->plat_dev->dev); mhi_log(MHI_MSG_VERBOSE, "MHI is initialized, transitioning to M0, ret %d\n", r); } if (!mhi_dev_ctxt->flags.mhi_initialized) { mhi_log(MHI_MSG_INFO, "MHI is not initialized transitioning to base.\n"); ret_val = init_mhi_base_state(mhi_dev_ctxt); if (MHI_STATUS_SUCCESS != ret_val) mhi_log(MHI_MSG_CRITICAL, "Failed to transition to base state %d.\n", ret_val); } exit: __pm_relax(&mhi_dev_ctxt->w_lock); mhi_log(MHI_MSG_INFO, "Exited.\n"); return ret_val; }
static int mmc_host_request_resume(struct device *dev) { return pm_request_resume(dev); }