/**
* intel_sst_remove - PCI remove function
*
* @pci: PCI device structure
*
* This function is called by OS when a device is unloaded
* This frees the interrupt etc
*/
static void __devexit intel_sst_remove(struct pci_dev *pci)
{
pm_runtime_get_noresume(&pci->dev);
pm_runtime_forbid(&pci->dev);
pci_dev_put(sst_drv_ctx->pci);
mutex_lock(&sst_drv_ctx->sst_lock);
sst_drv_ctx->sst_state = SST_UN_INIT;
mutex_unlock(&sst_drv_ctx->sst_lock);
misc_deregister(&lpe_ctrl);
free_irq(pci->irq, sst_drv_ctx);
iounmap(sst_drv_ctx->dram);
iounmap(sst_drv_ctx->iram);
iounmap(sst_drv_ctx->mailbox);
iounmap(sst_drv_ctx->shim);
sst_drv_ctx->pmic_state = SND_MAD_UN_INIT;
if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID) {
misc_deregister(&lpe_dev);
kfree(sst_drv_ctx->mmap_mem);
} else
kfree(sst_drv_ctx->fw_cntx);
flush_scheduled_work();
destroy_workqueue(sst_drv_ctx->process_reply_wq);
destroy_workqueue(sst_drv_ctx->process_msg_wq);
destroy_workqueue(sst_drv_ctx->post_msg_wq);
destroy_workqueue(sst_drv_ctx->mad_wq);
kfree(pci_get_drvdata(pci));
sst_drv_ctx = NULL;
pci_release_regions(pci);
pci_disable_device(pci);
pci_set_drvdata(pci, NULL);
}
void wil_pm_runtime_forbid(struct wil6210_priv *wil)
{
struct device *dev = wil_to_dev(wil);
pm_runtime_forbid(dev);
pm_runtime_get_noresume(dev);
}
int smdhsic_reset_resume(struct usb_interface *intf)
{
unsigned int devid;
struct str_intf_priv *intfpriv;
struct device *dev = &g_usbdev.usbdev->dev;
pr_debug("%s: Called\n", __func__);
if (!g_usbdev.suspended)
return 0;
intfpriv = usb_get_intfdata(intf);
devid = GET_DEVID(intfpriv->devid);
if (!usb_runtime_pm_ap_initiated_L2 &&
atomic_read(&dev->power.usage_count) == 1)
pm_runtime_get_noresume(dev);
smdhsic_resume(intf);
if (devid == CMD_DEV_ID) {
g_usbdev.hsic->dpm_suspending = false;
pr_debug("%s : dpm suspending set to false\n", __func__);
}
return 0;
}
static void xhci_ush_pci_remove(struct pci_dev *dev)
{
struct xhci_hcd *xhci;
xhci = hcd_to_xhci(pci_get_drvdata(dev));
if (xhci->shared_hcd) {
usb_remove_hcd(xhci->shared_hcd);
usb_put_hcd(xhci->shared_hcd);
}
if (!pci_dev_run_wake(dev))
pm_runtime_get_noresume(&dev->dev);
pm_runtime_forbid(&dev->dev);
usb_hcd_pci_remove(dev);
/* Free the aux irq */
hsic_aux_irq_free();
hsic_wakeup_irq_free();
gpio_free(hsic.aux_gpio);
gpio_free(hsic.wakeup_gpio);
hsic.port_disconnect = 1;
hsic_enable = 0;
wake_lock_destroy(&(hsic.resume_wake_lock));
wake_lock_destroy(&hsic.s3_wake_lock);
usb_unregister_notify(&hsic.hsic_pm_nb);
unregister_pm_notifier(&hsic.hsic_s3_entry_nb);
kfree(xhci);
}
static int cyttsp4_btn_release(struct cyttsp4_device *ttsp)
{
struct device *dev = &ttsp->dev;
struct cyttsp4_btn_data *bd = dev_get_drvdata(dev);
dev_dbg(dev, "%s\n", __func__);
#ifdef CONFIG_HAS_EARLYSUSPEND
/*
* This check is to prevent pm_runtime usage_count drop below zero
* because of removing the module while in suspended state
*/
if (bd->is_suspended)
pm_runtime_get_noresume(dev);
unregister_early_suspend(&bd->es);
#endif
if (bd->input_device_registered) {
input_unregister_device(bd->input);
} else {
input_free_device(bd->input);
cyttsp4_unsubscribe_attention(ttsp, CY_ATTEN_STARTUP,
cyttsp4_setup_input_attention, 0);
}
pm_runtime_suspend(dev);
pm_runtime_disable(dev);
dev_set_drvdata(dev, NULL);
kfree(bd);
return 0;
}
/*
* These are the device model conversion veneers; they convert the
* device model structures to our more specific structures.
*/
static int amba_probe(struct device *dev)
{
struct amba_device *pcdev = to_amba_device(dev);
struct amba_driver *pcdrv = to_amba_driver(dev->driver);
const struct amba_id *id = amba_lookup(pcdrv->id_table, pcdev);
int ret;
do {
ret = amba_get_enable_pclk(pcdev);
if (ret)
break;
pm_runtime_get_noresume(dev);
pm_runtime_set_active(dev);
pm_runtime_enable(dev);
ret = pcdrv->probe(pcdev, id);
if (ret == 0)
break;
pm_runtime_disable(dev);
pm_runtime_set_suspended(dev);
pm_runtime_put_noidle(dev);
amba_put_disable_pclk(pcdev);
} while (0);
return ret;
}
static int dw_mci_rockchip_probe(struct platform_device *pdev)
{
const struct dw_mci_drv_data *drv_data;
const struct of_device_id *match;
int ret;
if (!pdev->dev.of_node)
return -ENODEV;
match = of_match_node(dw_mci_rockchip_match, pdev->dev.of_node);
drv_data = match->data;
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 50);
pm_runtime_use_autosuspend(&pdev->dev);
ret = dw_mci_pltfm_register(pdev, drv_data);
if (ret) {
pm_runtime_disable(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
return ret;
}
pm_runtime_put_autosuspend(&pdev->dev);
return 0;
}
/*
* __device_release_driver() must be called with @dev lock held.
* When called for a USB interface, @dev->parent lock must be held as well.
*/
static void __device_release_driver(struct device *dev)
{
struct device_driver *drv;
drv = dev->driver;
if (drv) {
pm_runtime_get_noresume(dev);
pm_runtime_barrier(dev);
driver_sysfs_remove(dev);
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_UNBIND_DRIVER,
dev);
if (dev->bus && dev->bus->remove)
dev->bus->remove(dev);
else if (drv->remove)
drv->remove(dev);
devres_release_all(dev);
dev->driver = NULL;
klist_remove(&dev->p->knode_driver);
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_UNBOUND_DRIVER,
dev);
pm_runtime_put_sync(dev);
}
}
/**
* device_attach - try to attach device to a driver.
* @dev: device.
*
* Walk the list of drivers that the bus has and call
* driver_probe_device() for each pair. If a compatible
* pair is found, break out and return.
*
* Returns 1 if the device was bound to a driver;
* 0 if no matching driver was found;
* -ENODEV if the device is not registered.
*
* When called for a USB interface, @dev->parent lock must be held.
*/
int device_attach(struct device *dev)
{
int ret = 0;
device_lock(dev);
if (dev->driver) {
if (klist_node_attached(&dev->p->knode_driver)) {
ret = 1;
goto out_unlock;
}
ret = device_bind_driver(dev);
if (ret == 0)
ret = 1;
else {
dev->driver = NULL;
ret = 0;
}
} else {
pm_runtime_get_noresume(dev);
ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
pm_runtime_put_sync(dev);
}
out_unlock:
device_unlock(dev);
return ret;
}
static void xhci_ush_pci_remove(struct pci_dev *dev)
{
struct xhci_hcd *xhci;
xhci = hcd_to_xhci(pci_get_drvdata(dev));
if (xhci->shared_hcd) {
usb_remove_hcd(xhci->shared_hcd);
usb_put_hcd(xhci->shared_hcd);
}
if (!pci_dev_run_wake(dev))
pm_runtime_get_noresume(&dev->dev);
pm_runtime_forbid(&dev->dev);
usb_hcd_pci_remove(dev);
/* Free the aux irq */
hsic_aux_irq_free();
hsic_wakeup_irq_free();
gpio_free(hsic.aux_gpio);
gpio_free(hsic.wakeup_gpio);
hsic.hsic_stopped = 1;
hsic_enable = 0;
kfree(xhci);
}
static int hsic_send(struct link_device *ld, struct io_device *iod,
struct sk_buff *skb)
{
int ret, rpm_state;
struct usb_link_device *usb_ld = to_usb_link_device(ld);
struct link_pm_data *pm_data = usb_ld->link_pm_data;
if (!usb_ld->if_usb_connected)
goto link_disconnect;
/* delay for net channel, limited by xmm6260 capacity */
if (iod->send_delay && (iod->io_typ == IODEV_NET) \
&& (1400 == skb->len))
udelay(iod->send_delay);
rpm_state = hsic_pm_runtime_get_active_async(pm_data);
if (rpm_state == -ENODEV)
goto link_disconnect;
pm_runtime_get_noresume(&usb_ld->usbdev->dev);
ret = hsic_tx_skb(&usb_ld->devdata[iod->id], skb);
usb_mark_last_busy(usb_ld->usbdev);
pm_runtime_put(&usb_ld->usbdev->dev);
return ret;
link_disconnect:
if (iod->io_typ != IODEV_NET)
report_modem_state(ld, MODEM_EVENT_DISCONN);
return -EINVAL;
}
static void __devexit intel_mid_i2s_remove(struct pci_dev *pdev)
{
struct intel_mid_i2s_hdl *drv_data;
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_forbid(&pdev->dev);
drv_data = pci_get_drvdata(pdev);
if (!drv_data) {
dev_err(&pdev->dev, "no drv_data in pci device to remove!\n");
goto leave;
}
if (test_bit(I2S_PORT_OPENED, &drv_data->flags)) {
dev_warn(&pdev->dev, "Not closed before removing pci_dev!\n");
intel_mid_i2s_close(drv_data);
}
pci_set_drvdata(pdev, NULL);
/* Stop DMA is already done during close() */
pci_dev_put(drv_data->dmac1);
/* Disable the SSP at the peripheral and SOC level */
write_SSCR0(0, drv_data->ioaddr);
free_irq(drv_data->irq, drv_data);
iounmap(drv_data->ioaddr);
pci_release_region(pdev, MRST_SSP_BAR);
pci_release_region(pdev, MRST_LPE_BAR);
pci_disable_device(pdev);
kfree(drv_data);
leave:
return;
}
/*
* We need to register our own PCI probe function (instead of the USB core's
* function) in order to create a second roothub under xHCI.
*/
static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
int retval;
struct xhci_hcd *xhci;
struct hc_driver *driver;
struct usb_hcd *hcd;
driver = (struct hc_driver *)id->driver_data;
/* Prevent runtime suspending between USB-2 and USB-3 initialization */
pm_runtime_get_noresume(&dev->dev);
/* Register the USB 2.0 roothub.
* FIXME: USB core must know to register the USB 2.0 roothub first.
* This is sort of silly, because we could just set the HCD driver flags
* to say USB 2.0, but I'm not sure what the implications would be in
* the other parts of the HCD code.
*/
retval = usb_hcd_pci_probe(dev, id);
if (retval)
goto put_runtime_pm;
/* USB 2.0 roothub is stored in the PCI device now. */
hcd = dev_get_drvdata(&dev->dev);
xhci = hcd_to_xhci(hcd);
xhci->shared_hcd = usb_create_shared_hcd(driver, &dev->dev,
pci_name(dev), hcd);
if (!xhci->shared_hcd) {
retval = -ENOMEM;
goto dealloc_usb2_hcd;
}
retval = usb_add_hcd(xhci->shared_hcd, dev->irq,
IRQF_SHARED);
if (retval)
goto put_usb3_hcd;
/* Roothub already marked as USB 3.0 speed */
if (!(xhci->quirks & XHCI_BROKEN_STREAMS) &&
HCC_MAX_PSA(xhci->hcc_params) >= 4)
xhci->shared_hcd->can_do_streams = 1;
if (xhci->quirks & XHCI_PME_STUCK_QUIRK)
xhci_pme_acpi_rtd3_enable(dev);
/* USB-2 and USB-3 roothubs initialized, allow runtime pm suspend */
pm_runtime_put_noidle(&dev->dev);
return 0;
put_usb3_hcd:
usb_put_hcd(xhci->shared_hcd);
dealloc_usb2_hcd:
usb_hcd_pci_remove(dev);
put_runtime_pm:
pm_runtime_put_noidle(&dev->dev);
return retval;
}
static void wl1271_remove(struct sdio_func *func)
{
struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);
/* Undo decrement done above in wl1271_probe */
pm_runtime_get_noresume(&func->dev);
platform_device_unregister(glue->core);
}
/**
* ufshcd_pci_remove - de-allocate PCI/SCSI host and host memory space
* data structure memory
* @pdev - pointer to PCI handle
*/
static void ufshcd_pci_remove(struct pci_dev *pdev)
{
struct ufs_hba *hba = pci_get_drvdata(pdev);
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
ufshcd_remove(hba);
pci_set_drvdata(pdev, NULL);
}
/**
* exynos_drd_switch_start_host - helper function for starting/stoping the host
* controller driver.
*
* @otg: Pointer to the usb_otg structure.
* @on: start / stop the host controller driver.
*
* Returns 0 on success otherwise negative errno.
*/
static int exynos_drd_switch_start_host(struct usb_otg *otg, int on)
{
struct exynos_drd_switch *drd_switch = container_of(otg,
struct exynos_drd_switch, otg);
struct usb_hcd *hcd;
struct device *xhci_dev;
int ret = 0;
if (!otg->host)
return -EINVAL;
dev_dbg(otg->phy->dev, "Turn %s host %s\n",
on ? "on" : "off", otg->host->bus_name);
hcd = bus_to_hcd(otg->host);
xhci_dev = hcd->self.controller;
if (on) {
#if !defined(CONFIG_USB_HOST_NOTIFY)
wake_lock(&drd_switch->wakelock);
#endif
/*
* Clear runtime_error flag. The flag could be
* set when user space accessed the host while DRD
* was in B-Dev mode.
*/
pm_runtime_disable(xhci_dev);
if (pm_runtime_status_suspended(xhci_dev))
pm_runtime_set_suspended(xhci_dev);
else
pm_runtime_set_active(xhci_dev);
pm_runtime_enable(xhci_dev);
ret = pm_runtime_get_sync(xhci_dev);
if (ret < 0 && ret != -EINPROGRESS) {
pm_runtime_put_noidle(xhci_dev);
goto err;
}
exynos_drd_switch_ases_vbus_ctrl(drd_switch, 1);
} else {
exynos_drd_switch_ases_vbus_ctrl(drd_switch, 0);
ret = pm_runtime_put_sync(xhci_dev);
if (ret == -EAGAIN)
pm_runtime_get_noresume(xhci_dev);
#if !defined(CONFIG_USB_HOST_NOTIFY)
else
wake_unlock(&drd_switch->wakelock);
#endif
}
err:
/* ret can be 1 after pm_runtime_get_sync */
return (ret < 0) ? ret : 0;
}
static void serial_hsu_pci_port_remove(struct pci_dev *pdev)
{
struct uart_hsu_port *up = pci_get_drvdata(pdev);
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
serial_hsu_port_free(up);
pci_set_drvdata(pdev, NULL);
pci_disable_device(pdev);
}
static int replicator_probe(struct platform_device *pdev)
{
int ret;
struct device *dev = &pdev->dev;
struct coresight_platform_data *pdata = NULL;
struct replicator_drvdata *drvdata;
struct coresight_desc desc = { 0 };
struct device_node *np = pdev->dev.of_node;
if (np) {
pdata = of_get_coresight_platform_data(dev, np);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
pdev->dev.platform_data = pdata;
}
drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
drvdata->dev = &pdev->dev;
drvdata->atclk = devm_clk_get(&pdev->dev, "atclk"); /* optional */
if (!IS_ERR(drvdata->atclk)) {
ret = clk_prepare_enable(drvdata->atclk);
if (ret)
return ret;
}
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
platform_set_drvdata(pdev, drvdata);
desc.type = CORESIGHT_DEV_TYPE_LINK;
desc.subtype.link_subtype = CORESIGHT_DEV_SUBTYPE_LINK_SPLIT;
desc.ops = &replicator_cs_ops;
desc.pdata = pdev->dev.platform_data;
desc.dev = &pdev->dev;
drvdata->csdev = coresight_register(&desc);
if (IS_ERR(drvdata->csdev)) {
ret = PTR_ERR(drvdata->csdev);
goto out_disable_pm;
}
pm_runtime_put(&pdev->dev);
return 0;
out_disable_pm:
if (!IS_ERR(drvdata->atclk))
clk_disable_unprepare(drvdata->atclk);
pm_runtime_put_noidle(&pdev->dev);
pm_runtime_disable(&pdev->dev);
return ret;
}
static void __devexit wl1271_remove(struct sdio_func *func)
{
struct wl1271 *wl = sdio_get_drvdata(func);
/* Undo decrement done above in wl1271_probe */
pm_runtime_get_noresume(&func->dev);
wl1271_unregister_hw(wl);
free_irq(wl->irq, wl);
wl1271_free_hw(wl);
}
int i915_rpm_deinit(struct drm_device *drm_dev)
{
struct device *dev = drm_dev->dev;
pm_runtime_forbid(dev);
pm_runtime_set_suspended(dev);
pm_runtime_get_noresume(dev);
if (dev->power.runtime_error)
DRM_ERROR("rpm init: error = %d\n", dev->power.runtime_error);
i915_rpm_procfs_deinit(drm_dev);
return 0;
}
static int cyttsp5_spi_read_default_nosize(struct cyttsp5_adapter *adap,
void *buf, int max)
{
struct cyttsp5_spi *ts = dev_get_drvdata(adap->dev);
int rc;
pm_runtime_get_noresume(adap->dev);
mutex_lock(&ts->lock);
rc = cyttsp5_spi_read_default_nosize_(adap, buf, max);
mutex_unlock(&ts->lock);
pm_runtime_put_noidle(adap->dev);
return rc;
}
static int smsc375x_remove(struct i2c_client *client)
{
struct smsc375x_chip *chip = i2c_get_clientdata(client);
free_irq(client->irq, chip);
usb_put_phy(chip->otg);
extcon_dev_unregister(chip->edev);
kfree(chip->edev);
pm_runtime_get_noresume(&chip->client->dev);
kfree(chip);
return 0;
}
/**
* usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
* @intf: the usb_interface whose counter should be incremented
*
* This routine increments @intf's usage counter but does not carry out an
* autoresume.
*
* This routine can run in atomic context.
*/
void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
{
struct usb_device *udev = interface_to_usbdev(intf);
usb_mark_last_busy(udev);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32))
atomic_inc(&intf->pm_usage_cnt);
#else
intf->pm_usage_cnt++;
#endif
pm_runtime_get_noresume(&intf->dev);
}
static int msm_hsl_console_setup(struct console *co, char *options)
{
struct uart_port *port;
unsigned int vid;
int baud = 0, flow, bits, parity;
int ret;
pr_info("%s: ir\n", __func__);
if (unlikely(co->index >= UART_NR || co->index < 0))
return -ENXIO;
port = get_port_from_line(co->index);
vid = UART_TO_MSM(port)->ver_id;
pr_info("%s ():port->line %d, ir\n", __func__, port->line);
if (unlikely(!port->membase))
return -ENXIO;
port->cons = co;
pm_runtime_get_noresume(port->dev);
#ifndef CONFIG_PM_RUNTIME
msm_hsl_init_clock(port);
#endif
pm_runtime_resume(port->dev);
if (options)
uart_parse_options(options, &baud, &parity, &bits, &flow);
bits = 8;
parity = 'n';
flow = 'n';
msm_hsl_write(port, UARTDM_MR2_BITS_PER_CHAR_8 | STOP_BIT_ONE,
regmap[vid][UARTDM_MR2]);
if (baud < 300 || baud > 115200)
baud = 115200;
msm_hsl_set_baud_rate(port, baud);
pr_info("%s: cir port[%d] set baud=%d\n", __func__, port->line, baud);
ret = uart_set_options(port, co, baud, parity, bits, flow);
msm_hsl_reset(port);
msm_hsl_write(port, CR_PROTECTION_EN, regmap[vid][UARTDM_CR]);
msm_hsl_write(port, UARTDM_CR_TX_EN_BMSK, regmap[vid][UARTDM_CR]);
printk(KERN_INFO "msm_serial_hsl: console setup on port #%d\n",
port->line);
pr_info("%s ():port->line %d, ok, ir\n", __func__, port->line);
return ret;
}
static void __devexit sdhci_pltfm_runtime_pm_forbid(struct device *device)
{
struct sdio_dev *dev =
platform_get_drvdata(to_platform_device(device));
if (!sdhci_pltfm_rpm_enabled(dev))
return;
pm_runtime_forbid(device);
pm_runtime_get_noresume(device);
pm_runtime_disable(device);
}
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;
}
static void __devexit wl1271_remove(struct sdio_func *func)
{
struct wl1271 *wl = sdio_get_drvdata(func);
/* Undo decrement done above in wl1271_probe */
pm_runtime_get_noresume(&func->dev);
wl1271_unregister_hw(wl);
device_init_wakeup(wl1271_sdio_wl_to_dev(wl), 0);
disable_irq_wake(wl->irq);
free_irq(wl->irq, wl);
wl1271_free_hw(wl);
}
/* Can run in atomic context */
mali_bool _mali_osk_pm_dev_ref_add_no_power_on(void)
{
#ifdef CONFIG_PM_RUNTIME
u32 ref;
MALI_DEBUG_ASSERT_POINTER(mali_platform_device);
pm_runtime_get_noresume(&(mali_platform_device->dev));
ref = _mali_osk_atomic_read(&mali_pm_ref_count);
MALI_DEBUG_PRINT(4, ("Mali OSK PM: No-power ref taken (%u)\n", _mali_osk_atomic_read(&mali_pm_ref_count)));
return ref > 0 ? MALI_TRUE : MALI_FALSE;
#else
return MALI_TRUE;
#endif
}
static void wl1271_remove(struct sdio_func *func)
{
struct wl12xx_sdio_glue *glue = sdio_get_drvdata(func);
struct wlcore_platdev_data *pdev_data = glue->core->dev.platform_data;
struct wl12xx_platform_data *pdata = pdev_data->pdata;
/* Undo decrement done above in wl1271_probe */
pm_runtime_get_noresume(&func->dev);
platform_device_unregister(glue->core);
del_platform_data(pdata);
kfree(glue);
}
static int cyttsp5_spi_write_read_specific(struct cyttsp5_adapter *adap,
u8 write_len, u8 *write_buf, u8 *read_buf)
{
struct cyttsp5_spi *ts = dev_get_drvdata(adap->dev);
int rc;
pm_runtime_get_noresume(adap->dev);
mutex_lock(&ts->lock);
rc = cyttsp5_spi_write_read_specific_(adap, write_len, write_buf,
read_buf);
mutex_unlock(&ts->lock);
pm_runtime_put_noidle(adap->dev);
return rc;
}
