static int xhci_msm_pm_resume(struct device *dev) { dev_dbg(dev, "xhci-msm PM resume\n"); if (pm_runtime_suspended(dev)) return 0; if (phy) return usb_phy_set_suspend(phy, 0); return 0; }
static int __maybe_unused zynq_gpio_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct zynq_gpio *gpio = platform_get_drvdata(pdev); if (!device_may_wakeup(dev)) { if (!pm_runtime_suspended(dev)) return clk_enable(gpio->clk); } return 0; }
static void exnos_usb_switch_worker(struct work_struct *work) { struct exynos_usb_switch *usb_switch = container_of(work, struct exynos_usb_switch, switch_work); int cnt = 0; mutex_lock(&usb_switch->mutex); /* If already device detached or host_detected, */ if (!is_device_detect(usb_switch) || is_host_detect(usb_switch)) goto done; if (!usb_switch->ehci_dev || !usb_switch->ohci_dev) goto detect; while (!pm_runtime_suspended(usb_switch->ehci_dev) || !pm_runtime_suspended(usb_switch->ohci_dev)) { mutex_unlock(&usb_switch->mutex); msleep(SWITCH_WAIT_TIME); mutex_lock(&usb_switch->mutex); /* If already device detached or host_detected, */ if (!is_device_detect(usb_switch) || is_host_detect(usb_switch)) goto done; if (cnt++ > WAIT_TIMES) { printk(KERN_ERR "%s:device not attached by host\n", __func__); goto done; } } if (cnt > 1) printk(KERN_INFO "Device wait host power during %d\n", (cnt-1)); detect: /* Check Device, VBUS PIN high active */ exynos_change_usb_mode(usb_switch, USB_DEVICE_ATTACHED); done: mutex_unlock(&usb_switch->mutex); }
static int escore_system_suspend(struct device *dev) { struct escore_priv *escore = &escore_priv; int ret = 0; pr_info("%s(): @@@@@@ Entry #####\n", __func__); dev_dbg(dev, "%s()\n", __func__); if (escore->dev != dev) { dev_dbg(dev, "%s() Invalid device\n", __func__); return 0; } /* if (!es_ready_to_suspend(escore)) { dev_dbg(dev, "%s() - Not ready for suspend\n", __func__); return -EBUSY; } if (escore->disable_codec_irq) { ret = escore->disable_codec_irq(escore); if (ret < 0) { dev_err(dev, "%s(): Disable irq failed\n", __func__); return -EBUSY; } pr_info("%s(): @@@@@@ disable_codec_irq #####\n", __func__); }*/ if (!pm_runtime_suspended(dev)) { dev_dbg(dev, "%s() system suspend\n", __func__); mutex_lock(&escore->access_lock); ret = escore_runtime_suspend(dev); /* * If runtime-PM still thinks it's active, then make sure its * status is in sync with HW status. * If runtime suspend is not executed yet, RPM status is * RPM_ACTIVE. System suspend changes chip status to suspend * and hence RPM status needs to be updated manually to match * actual chip status. This can be done by disabling RPM, * changing RPM status and enabling RPM again. */ if (!ret) { pm_runtime_disable(dev); pm_runtime_set_suspended(dev); pm_runtime_enable(dev); } mutex_unlock(&escore->access_lock); } dev_dbg(dev, "%s() complete %d\n", __func__, ret); pr_info("%s(): @@@@@@ Exit #####\n", __func__); return ret; }
static int omap_usb3_remove(struct platform_device *pdev) { struct omap_usb *phy = platform_get_drvdata(pdev); clk_unprepare(phy->wkupclk); clk_unprepare(phy->optclk); usb_remove_phy(&phy->phy); if (!pm_runtime_suspended(&pdev->dev)) pm_runtime_put(&pdev->dev); pm_runtime_disable(&pdev->dev); return 0; }
static ssize_t apds990x_prox_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t ret; struct apds990x_chip *chip = dev_get_drvdata(dev); if (pm_runtime_suspended(dev) || !chip->prox_en) return -EIO; mutex_lock(&chip->mutex); ret = sprintf(buf, "%d\n", chip->prox_data); mutex_unlock(&chip->mutex); return ret; }
static int xgpiops_suspend(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct xgpiops *gpio = platform_get_drvdata(pdev); if (!device_may_wakeup(dev)) { if (!pm_runtime_suspended(dev)) clk_disable(gpio->clk); return 0; } return 0; }
static int lm3561_resume_sleep(struct device *dev) { int rc; struct lm3561_platform_data *pdata = dev->platform_data; if (!pm_runtime_suspended(dev)) { pm_runtime_put(dev); rc = lm3561_resume(dev); } else rc = pdata->power ? pdata->power(dev, true) : 0; dev_dbg(dev, "%s: resumed (%d)\n", __func__, rc); return rc; }
static int __maybe_unused sirf_resume(struct device *dev) { struct sirf_data *data = dev_get_drvdata(dev); int ret = 0; if (data->wakeup) enable_irq(data->irq); if (!pm_runtime_suspended(dev)) ret = sirf_runtime_resume(dev); return ret; }
/* Called always with mutex locked */ static int apds990x_refresh_athres(struct apds990x_chip *chip) { int ret; /* If the chip is not in use, don't try to access it */ if (pm_runtime_suspended(&chip->client->dev)) return 0; ret = apds990x_write_word(chip, APDS990X_AILTL, apds990x_lux_to_threshold(chip, chip->lux_thres_lo)); ret |= apds990x_write_word(chip, APDS990X_AIHTL, apds990x_lux_to_threshold(chip, chip->lux_thres_hi)); return ret; }
static int atmel_hlcdc_dc_drm_resume(struct device *dev) { struct drm_device *drm_dev = dev_get_drvdata(dev); struct drm_crtc *crtc; if (pm_runtime_suspended(dev)) return 0; drm_modeset_lock_all(drm_dev); list_for_each_entry(crtc, &drm_dev->mode_config.crtc_list, head) atmel_hlcdc_crtc_resume(crtc); drm_modeset_unlock_all(drm_dev); return 0; }
/** * exynos_drd_switch_is_host_off - check host's PM status. * * @otg: Pointer to the usb_otg structure. * * Before peripheral can start two conditions must be met: * 1. Host's completely resumed after system sleep. * 2. Host is runtime suspended. */ static bool exynos_drd_switch_is_host_off(struct usb_otg *otg) { struct usb_hcd *hcd; struct device *dev; if (!otg->host) /* REVISIT: what should we return here? */ return true; hcd = bus_to_hcd(otg->host); dev = hcd->self.controller; return pm_runtime_suspended(dev); }
static ssize_t bh1770_prox_result_show(struct device *dev, struct device_attribute *attr, char *buf) { struct bh1770_chip *chip = dev_get_drvdata(dev); ssize_t ret; mutex_lock(&chip->mutex); if (chip->prox_enable_count && !pm_runtime_suspended(dev)) ret = sprintf(buf, "%d\n", chip->prox_data); else ret = -EIO; mutex_unlock(&chip->mutex); return ret; }
/* * Following two functions converts raw lux values from HW to normalized * values. Purpose is to compensate differences between different sensor * versions and variants so that result means about the same between * versions. Chip->mutex is kept when this is called. */ static int bh1770_prox_set_threshold(struct bh1770_chip *chip) { u8 tmp = 0; /* sysfs may call this when the chip is powered off */ if (pm_runtime_suspended(&chip->client->dev)) return 0; tmp = bh1770_psadjusted_to_raw(chip, chip->prox_threshold); chip->prox_threshold_hw = tmp; return i2c_smbus_write_byte_data(chip->client, BH1770_PS_TH_LED1, tmp); }
/* chip->mutex is always kept here */ static int bh1770_lux_rate(struct bh1770_chip *chip, int rate_index) { /* sysfs may call this when the chip is powered off */ if (pm_runtime_suspended(&chip->client->dev)) return 0; /* Proper proximity response needs fastest lux rate (100ms) */ if (chip->prox_enable_count) rate_index = 0; return i2c_smbus_write_byte_data(chip->client, BH1770_ALS_MEAS_RATE, rate_index); }
static int exynos_xhci_suspend(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct exynos_xhci_hcd *exynos_xhci; struct usb_hcd *hcd; struct xhci_hcd *xhci; int retval = 0; #ifdef CONFIG_PM_RUNTIME dev_dbg(dev, "%s: usage_count = %d\n", __func__, atomic_read(&dev->power.usage_count)); #endif exynos_xhci = dev_get_drvdata(dev); if (!exynos_xhci) return -EINVAL; hcd = exynos_xhci->hcd; if (!hcd) return -EINVAL; /* Prevent any more root-hub status calls from the timer * The HCD might still restart the timer (if a port status change * interrupt occurs), but usb_hcd_poll_rh_status() won't invoke * the hub_status_data() callback. */ hcd->rh_pollable = 0; hcd->shared_hcd->rh_pollable = 0; xhci = hcd_to_xhci(hcd); if (hcd->state != HC_STATE_SUSPENDED || xhci->shared_hcd->state != HC_STATE_SUSPENDED) dev_err(dev, "%s: HC state is not suspended!\n", __func__); #ifdef CONFIG_USB_SUSPEND if (pm_runtime_suspended(dev)) { dev_dbg(dev, "xhci is runtime suspended\n"); return 0; } #endif retval = xhci_suspend(xhci, 0); if (retval < 0) dev_err(dev, "%s: cannot stop xHC\n", __func__); pm_runtime_put_sync(dev->parent); exynos_drd_put(pdev); return retval; }
static int ak89xx_resume(struct device *dev) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct inv_ak89xx_state_s *st = iio_priv(indio_dev); int rc; dev_dbg(dev, "%s\n", __func__); if (!pm_runtime_suspended(dev)) { rc = ak89xx_power_supply(st, 1); } else { dev_info(dev, "%s: was runtime-suspended.\n", __func__); rc = 0; } return rc ? -EAGAIN : 0; }
int hdmi_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl) { struct hdmi_device *hdev = sd_to_hdmi_dev(sd); struct device *dev = hdev->dev; if (!pm_runtime_suspended(hdev->dev) && !hdev->hpd_user_checked) ctrl->value = hdmi_hpd_status(hdev); else ctrl->value = atomic_read(&hdev->hpd_state); dev_dbg(dev, "HDMI cable is %s\n", ctrl->value ? "connected" : "disconnected"); return 0; }
/* 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 void st_tty_close(struct tty_struct *tty) { unsigned char i = ST_MAX_CHANNELS; unsigned long flags = 0; struct st_data_s *st_gdata = tty->disc_data; pr_info("%s ", __func__); /* TODO: * if a protocol has been registered & line discipline * un-installed for some reason - what should be done ? */ spin_lock_irqsave(&st_gdata->lock, flags); for (i = 0; i < ST_MAX_CHANNELS; i++) { if (st_gdata->is_registered[i] == true) pr_err("%d not un-registered", i); st_gdata->list[i] = NULL; st_gdata->is_registered[i] = false; } st_gdata->protos_registered = 0; spin_unlock_irqrestore(&st_gdata->lock, flags); /* * signal to UIM via KIM that - * N_TI_WL ldisc is un-installed */ st_kim_complete(st_gdata->kim_data); st_gdata->tty = NULL; /* Flush any pending characters in the driver and discipline. */ tty_ldisc_flush(tty); tty_driver_flush_buffer(tty); spin_lock_irqsave(&st_gdata->lock, flags); /* empty out txq and tx_waitq */ skb_queue_purge(&st_gdata->txq); skb_queue_purge(&st_gdata->tx_waitq); /* reset the TTY Rx states of ST */ st_gdata->rx_count = 0; st_gdata->rx_state = ST_W4_PACKET_TYPE; kfree_skb(st_gdata->rx_skb); st_gdata->rx_skb = NULL; spin_unlock_irqrestore(&st_gdata->lock, flags); pm_runtime_put_noidle(st_gdata->tty_dev); if (!pm_runtime_suspended(st_gdata->tty_dev)) __pm_runtime_idle(st_gdata->tty_dev, 0); pr_debug("%s: done ", __func__); }
static int lis3lv02d_i2c_resume(struct device *dev) { struct i2c_client *client = container_of(dev, struct i2c_client, dev); struct lis3lv02d *lis3 = i2c_get_clientdata(client); /* * pm_runtime documentation says that devices should always * be powered on at resume. Pm_runtime turns them off after system * wide resume is complete. */ if (!lis3->pdata || !lis3->pdata->wakeup_flags || pm_runtime_suspended(dev)) lis3lv02d_poweron(lis3); return 0; }
static int rockchip_spi_suspend(struct device *dev) { int ret = 0; struct spi_master *master = dev_get_drvdata(dev); struct rockchip_spi *rs = spi_master_get_devdata(master); ret = spi_master_suspend(rs->master); if (ret) return ret; if (!pm_runtime_suspended(dev)) { clk_disable_unprepare(rs->spiclk); clk_disable_unprepare(rs->apb_pclk); } return ret; }
static bool samsung_usb2phy_is_active(struct usb_phy *phy) { struct samsung_usbphy *sphy = phy_to_sphy(phy); unsigned long flags; bool ret; spin_lock_irqsave(&sphy->lock, flags); if (!sphy->usage_count || pm_runtime_suspended(sphy->dev)) ret = false; else ret = true; spin_unlock_irqrestore(&sphy->lock, flags); return ret; }
static int scsi_bus_suspend_common(struct device *dev, pm_message_t msg) { int err = 0; if (scsi_is_sdev_device(dev)) { if (pm_runtime_suspended(dev)) { if (msg.event == PM_EVENT_SUSPEND || msg.event == PM_EVENT_HIBERNATE) return 0; pm_runtime_resume(dev); } err = scsi_dev_type_suspend(dev, msg); } return err; }
static void usbhs_resume_work(struct work_struct *work) { dev_dbg(usbhs_wake->dev, "USB IO PAD Wakeup event triggered\n"); if (usbhs_wake->wakeup_ehci) { usbhs_wake->wakeup_ehci = 0; omap_hwmod_disable_ioring_wakeup(usbhs_wake->oh_ehci); } if (usbhs_wake->wakeup_ohci) { usbhs_wake->wakeup_ohci = 0; omap_hwmod_disable_ioring_wakeup(usbhs_wake->oh_ohci); } if (pm_runtime_suspended(usbhs_wake->dev)) pm_runtime_get_sync(usbhs_wake->dev); }
/** * cdns_i2c_clk_notifier_cb - Clock rate change callback * @nb: Pointer to notifier block * @event: Notification reason * @data: Pointer to notification data object * * This function is called when the cdns_i2c input clock frequency changes. * The callback checks whether a valid bus frequency can be generated after the * change. If so, the change is acknowledged, otherwise the change is aborted. * New dividers are written to the HW in the pre- or post change notification * depending on the scaling direction. * * Return: NOTIFY_STOP if the rate change should be aborted, NOTIFY_OK * to acknowedge the change, NOTIFY_DONE if the notification is * considered irrelevant. */ static int cdns_i2c_clk_notifier_cb(struct notifier_block *nb, unsigned long event, void *data) { struct clk_notifier_data *ndata = data; struct cdns_i2c *id = to_cdns_i2c(nb); if (pm_runtime_suspended(id->dev)) return NOTIFY_OK; switch (event) { case PRE_RATE_CHANGE: { unsigned long input_clk = ndata->new_rate; unsigned long fscl = id->i2c_clk; unsigned int div_a, div_b; int ret; ret = cdns_i2c_calc_divs(&fscl, input_clk, &div_a, &div_b); if (ret) { dev_warn(id->adap.dev.parent, "clock rate change rejected\n"); return NOTIFY_STOP; } /* scale up */ if (ndata->new_rate > ndata->old_rate) cdns_i2c_setclk(ndata->new_rate, id); return NOTIFY_OK; } case POST_RATE_CHANGE: id->input_clk = ndata->new_rate; /* scale down */ if (ndata->new_rate < ndata->old_rate) cdns_i2c_setclk(ndata->new_rate, id); return NOTIFY_OK; case ABORT_RATE_CHANGE: /* scale up */ if (ndata->new_rate > ndata->old_rate) cdns_i2c_setclk(ndata->old_rate, id); return NOTIFY_OK; default: return NOTIFY_DONE; } }
static int bdisp_resume(struct device *dev) { struct bdisp_dev *bdisp = dev_get_drvdata(dev); unsigned long flags; int opened; spin_lock_irqsave(&bdisp->slock, flags); opened = test_bit(ST_M2M_OPEN, &bdisp->state); spin_unlock_irqrestore(&bdisp->slock, flags); if (!opened) return 0; if (!pm_runtime_suspended(dev)) return bdisp_runtime_resume(dev); return 0; }
/** * inv_ak89xx_remove() - remove function. */ static int inv_ak89xx_remove(struct i2c_client *client) { struct iio_dev *indio_dev = i2c_get_clientdata(client); struct inv_ak89xx_state_s *st = iio_priv(indio_dev); cancel_delayed_work_sync(&st->work); iio_device_unregister(indio_dev); inv_ak89xx_remove_trigger(indio_dev); iio_buffer_unregister(indio_dev); inv_ak89xx_unconfigure_ring(indio_dev); if (!pm_runtime_suspended(&client->dev)) ak89xx_power_supply(st, 0); pm_runtime_disable(&client->dev); iio_free_device(indio_dev); dev_info(&client->adapter->dev, "inv-ak89xx-iio module removed.\n"); return 0; }
int lis3lv02d_remove_fs(struct lis3lv02d *lis3) { sysfs_remove_group(&lis3->pdev->dev.kobj, &lis3lv02d_attribute_group); platform_device_unregister(lis3->pdev); if (lis3->pm_dev) { /* Barrier after the sysfs remove */ pm_runtime_barrier(lis3->pm_dev); /* SYSFS may have left chip running. Turn off if necessary */ if (!pm_runtime_suspended(lis3->pm_dev)) lis3lv02d_poweroff(&lis3_dev); pm_runtime_disable(lis3->pm_dev); pm_runtime_set_suspended(lis3->pm_dev); } kfree(lis3->reg_cache); return 0; }
static int scsi_bus_resume_common(struct device *dev, int (*cb)(struct device *, const struct dev_pm_ops *)) { async_func_t fn; if (!scsi_is_sdev_device(dev)) fn = NULL; else if (cb == do_scsi_resume) fn = async_sdev_resume; else if (cb == do_scsi_thaw) fn = async_sdev_thaw; else if (cb == do_scsi_restore) fn = async_sdev_restore; else fn = NULL; /* * Forcibly set runtime PM status of request queue to "active" to * make sure we can again get requests from the queue (see also * blk_pm_peek_request()). * * The resume hook will correct runtime PM status of the disk. */ if (scsi_is_sdev_device(dev) && pm_runtime_suspended(dev)) blk_set_runtime_active(to_scsi_device(dev)->request_queue); if (fn) { async_schedule_domain(fn, dev, &scsi_sd_pm_domain); /* * If a user has disabled async probing a likely reason * is due to a storage enclosure that does not inject * staggered spin-ups. For safety, make resume * synchronous as well in that case. */ if (strncmp(scsi_scan_type, "async", 5) != 0) async_synchronize_full_domain(&scsi_sd_pm_domain); } else { pm_runtime_disable(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); } return 0; }