static ssize_t store_ehci_power(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct usb_hcd *hcd = dev_get_drvdata(dev);
struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);
int power_on;
int irq;
int retval;
if (sscanf(buf, "%d", &power_on) != 1)
return -EINVAL;
device_lock(dev);
if (!power_on && s5p_ehci->power_on) {
dev_info(dev, "EHCI turn off\n");
pm_runtime_forbid(dev);
s5p_ehci->power_on = 0;
usb_remove_hcd(hcd);
if (s5p_ehci->phy) {
/* Shutdown PHY only if it wasn't shutdown before */
if (!s5p_ehci->post_lpa_resume)
usb_phy_shutdown(s5p_ehci->phy);
} else if (s5p_ehci->pdata->phy_exit) {
s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
}
} else if (power_on) {
dev_info(dev, "EHCI turn on\n");
if (s5p_ehci->power_on) {
pm_runtime_forbid(dev);
usb_remove_hcd(hcd);
} else {
s5p_ehci_phy_init(pdev);
}
irq = platform_get_irq(pdev, 0);
retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
if (retval < 0) {
dev_err(dev, "Power On Fail\n");
goto exit;
}
/*
* EHCI root hubs are expected to handle remote wakeup.
* So, wakeup flag init defaults for root hubs.
*/
device_wakeup_enable(&hcd->self.root_hub->dev);
s5p_ehci->power_on = 1;
pm_runtime_allow(dev);
}
exit:
device_unlock(dev);
return count;
}
static ssize_t store_ohci_power(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct exynos4_ohci_platdata *pdata = pdev->dev.platform_data;
struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
struct usb_hcd *hcd = exynos_ohci->hcd;
int power_on;
int irq;
int retval;
if (sscanf(buf, "%d", &power_on) != 1)
return -EINVAL;
device_lock(dev);
if (!power_on && exynos_ohci->power_on) {
printk(KERN_DEBUG "%s: EHCI turns off\n", __func__);
pm_runtime_forbid(dev);
exynos_ohci->power_on = 0;
usb_remove_hcd(hcd);
if (pdata && pdata->phy_exit)
pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
} else if (power_on) {
printk(KERN_DEBUG "%s: EHCI turns on\n", __func__);
if (exynos_ohci->power_on) {
pm_runtime_forbid(dev);
usb_remove_hcd(hcd);
} else {
if (pdata && pdata->phy_init)
pdata->phy_init(pdev, S5P_USB_PHY_HOST);
}
irq = platform_get_irq(pdev, 0);
retval = usb_add_hcd(hcd, irq,
IRQF_DISABLED | IRQF_SHARED);
if (retval < 0) {
dev_err(dev, "Power On Fail\n");
goto exit;
}
/*
* OHCI root hubs are expected to handle remote wakeup.
* So, wakeup flag init defaults for root hubs.
*/
device_wakeup_enable(&hcd->self.root_hub->dev);
exynos_ohci->power_on = 1;
pm_runtime_allow(dev);
}
exit:
device_unlock(dev);
return count;
}
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 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;
}
static int __devexit s5p_ehci_remove(struct platform_device *pdev)
{
struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
struct usb_hcd *hcd = s5p_ehci->hcd;
#ifdef CONFIG_USB_SUSPEND
#ifdef CONFIG_MDM_HSIC_PM
pm_runtime_forbid(&pdev->dev);
#else
pm_runtime_put(hcd->self.controller);
pm_runtime_disable(&pdev->dev);
#endif
#endif
s5p_ehci->power_on = 0;
remove_ehci_sys_file(hcd_to_ehci(hcd));
usb_remove_hcd(hcd);
if (pdata && pdata->phy_exit)
pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
iounmap(hcd->regs);
clk_disable(s5p_ehci->clk);
clk_put(s5p_ehci->clk);
usb_put_hcd(hcd);
kfree(s5p_ehci);
return 0;
}
/**
* amdgpu_driver_unload_kms - Main unload function for KMS.
*
* @dev: drm dev pointer
*
* This is the main unload function for KMS (all asics).
* Returns 0 on success.
*/
void amdgpu_driver_unload_kms(struct drm_device *dev)
{
struct amdgpu_device *adev = dev->dev_private;
if (adev == NULL)
return;
if (adev->rmmio == NULL)
goto done_free;
if (amdgpu_sriov_vf(adev))
amdgpu_virt_request_full_gpu(adev, false);
if (amdgpu_device_is_px(dev)) {
pm_runtime_get_sync(dev->dev);
pm_runtime_forbid(dev->dev);
}
amdgpu_amdkfd_device_fini(adev);
amdgpu_acpi_fini(adev);
amdgpu_device_fini(adev);
done_free:
kfree(adev);
dev->dev_private = NULL;
}
/**
* 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);
}
/* Create a DIMM object under specifed memory controller device */
static int edac_create_dimm_object(struct mem_ctl_info *mci,
struct dimm_info *dimm,
int index)
{
int err;
dimm->mci = mci;
dimm->dev.type = &dimm_attr_type;
dimm->dev.bus = mci->bus;
device_initialize(&dimm->dev);
dimm->dev.parent = &mci->dev;
if (mci->csbased)
dev_set_name(&dimm->dev, "rank%d", index);
else
dev_set_name(&dimm->dev, "dimm%d", index);
dev_set_drvdata(&dimm->dev, dimm);
pm_runtime_forbid(&mci->dev);
err = device_add(&dimm->dev);
edac_dbg(0, "creating rank/dimm device %s\n", dev_name(&dimm->dev));
return err;
}
static void dwc_otg_remove(struct pci_dev *pdev)
{
struct dwc_otg2 *otg = the_transceiver;
int resource, len;
if (otg->gadget)
platform_device_unregister(otg->gadget);
if (otg->host)
platform_device_unregister(otg->host);
wake_lock_destroy(&wakelock);
pm_runtime_forbid(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
kfree(platform_par);
iounmap(otg->usb2_phy.io_priv);
usb_remove_phy(&otg->usb2_phy);
usb_remove_phy(&otg->usb3_phy);
kfree(otg);
otg = NULL;
resource = pci_resource_start(pdev, 0);
len = pci_resource_len(pdev, 0);
release_mem_region(resource, len);
pci_disable_device(pdev);
the_transceiver = NULL;
}
static void
serial_omap_pm(struct uart_port *port, unsigned int state,
unsigned int oldstate)
{
struct uart_omap_port *up = (struct uart_omap_port *)port;
unsigned char efr;
dev_dbg(up->port.dev, "serial_omap_pm+%d\n", up->port.line);
pm_runtime_get_sync(&up->pdev->dev);
serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
efr = serial_in(up, UART_EFR);
serial_out(up, UART_EFR, efr | UART_EFR_ECB);
serial_out(up, UART_LCR, 0);
serial_out(up, UART_IER, (state != 0) ? UART_IERX_SLEEP : 0);
serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
serial_out(up, UART_EFR, efr);
serial_out(up, UART_LCR, 0);
if (!device_may_wakeup(&up->pdev->dev)) {
if (!state)
pm_runtime_forbid(&up->pdev->dev);
else
pm_runtime_allow(&up->pdev->dev);
}
pm_runtime_put(&up->pdev->dev);
}
static void intel_lpss_pci_remove(struct pci_dev *pdev)
{
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
intel_lpss_remove(&pdev->dev);
}
static ssize_t store_autosuspend(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct miscdevice *miscdev = dev_get_drvdata(dev);
struct link_pm_data *pm_data = container_of(miscdev,
struct link_pm_data, miscdev);
struct usb_link_device *usb_ld = pm_data->usb_ld;
struct task_struct *task = get_current();
char taskname[TASK_COMM_LEN];
mif_info("autosuspend: %s: %s(%d)'\n",
buf, get_task_comm(taskname, task), task->pid);
if (!strncmp(buf, "on", 2)) {
pm_data->autosuspend = true;
if (usb_ld->usbdev)
pm_runtime_allow(&usb_ld->usbdev->dev);
} else if (!strncmp(buf, "off", 3)) {
pm_data->autosuspend = false;
if (usb_ld->usbdev)
pm_runtime_forbid(&usb_ld->usbdev->dev);
}
return count;
}
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);
}
/**
* amdgpu_driver_unload_kms - Main unload function for KMS.
*
* @dev: drm dev pointer
*
* This is the main unload function for KMS (all asics).
* Returns 0 on success.
*/
int amdgpu_driver_unload_kms(struct drm_device *dev)
{
struct amdgpu_device *adev = dev->dev_private;
if (adev == NULL)
return 0;
if (adev->rmmio == NULL)
goto done_free;
if (amdgpu_device_is_px(dev)) {
pm_runtime_get_sync(dev->dev);
pm_runtime_forbid(dev->dev);
}
amdgpu_amdkfd_device_fini(adev);
amdgpu_acpi_fini(adev);
amdgpu_device_fini(adev);
done_free:
kfree(adev);
dev->dev_private = NULL;
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 void if_usb_disconnect(struct usb_interface *intf)
{
struct usb_link_device *usb_ld = usb_get_intfdata(intf);
struct usb_device *usbdev = usb_ld->usbdev;
struct link_pm_data *pm_data = usb_ld->link_pm_data;
int dev_id = intf->altsetting->desc.bInterfaceNumber;
struct if_usb_devdata *pipe_data = &usb_ld->devdata[dev_id];
usb_set_intfdata(intf, NULL);
pipe_data->disconnected = 1;
smp_wmb();
wake_up(&usb_ld->l2_wait);
usb_ld->if_usb_connected = 0;
usb_ld->flow_suspend = 1;
dev_dbg(&usbdev->dev, "%s\n", __func__);
usb_ld->dev_count--;
usb_driver_release_interface(&if_usb_driver, pipe_data->data_intf);
usb_kill_anchored_urbs(&pipe_data->reading);
usb_free_urbs(usb_ld, pipe_data);
if (usb_ld->dev_count == 0) {
cancel_delayed_work_sync(&usb_ld->runtime_pm_work);
cancel_delayed_work_sync(&usb_ld->post_resume_work);
cancel_delayed_work_sync(&usb_ld->ld.tx_delayed_work);
usb_put_dev(usbdev);
usb_ld->usbdev = NULL;
pm_runtime_forbid(pm_data->root_hub);
}
}
void request_autopm_lock(int status)
{
struct diag_bridge *dev = __dev;
if (!dev || !dev->udev)
return;
pr_info("%s: set runtime pm lock : %d\n", __func__, status);
if (status) {
if (!atomic_read(&dev->pmlock_cnt)) {
atomic_inc(&dev->pmlock_cnt);
pr_info("get lock\n");
pm_runtime_get(&dev->udev->dev);
pm_runtime_forbid(&dev->udev->dev);
} else
atomic_inc(&dev->pmlock_cnt);
} else {
if (!atomic_read(&dev->pmlock_cnt))
pr_info("unbalanced release\n");
else if (atomic_dec_and_test(&dev->pmlock_cnt)) {
pr_info("release lock\n");
pm_runtime_allow(&dev->udev->dev);
pm_runtime_put(&dev->udev->dev);
}
}
}
static long link_pm_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
int value, err = 0;
struct task_struct *task = get_current();
struct link_pm_data *pm_data = file->private_data;
struct usb_link_device *usb_ld = pm_data->usb_ld;
char taskname[TASK_COMM_LEN];
mif_info("cmd: 0x%08x\n", cmd);
switch (cmd) {
case IOCTL_LINK_CONTROL_ACTIVE:
if (copy_from_user(&value, (const void __user *)arg,
sizeof(int)))
return -EFAULT;
gpio_set_value(pm_data->gpio_link_active, value);
break;
case IOCTL_LINK_GET_HOSTWAKE:
return !gpio_get_value(pm_data->gpio_link_hostwake);
case IOCTL_LINK_CONNECTED:
return usb_ld->if_usb_connected;
case IOCTL_LINK_PORT_ON: /* hub only */
/* ignore cp host wakeup irq, set the hub_init_lock when AP try
CP off and release hub_init_lock when CP boot done */
pm_data->hub_init_lock = 0;
if (pm_data->root_hub)
pm_runtime_get_sync(pm_data->root_hub);
if (pm_data->port_enable) {
err = pm_data->port_enable(2, 1);
if (err < 0) {
mif_err("hub on fail err=%d\n", err);
goto exit;
}
pm_data->hub_status = HUB_STATE_RESUMMING;
}
break;
case IOCTL_LINK_PORT_OFF: /* hub only */
err = link_pm_hub_standby(pm_data);
if (err < 0) {
mif_err("usb3503 active fail\n");
goto exit;
}
pm_data->hub_init_lock = 1;
pm_data->hub_handshake_done = 0;
break;
case IOCTL_LINK_BLOCK_AUTOSUSPEND: /* block autosuspend forever */
mif_info("blocked autosuspend by `%s(%d)'\n",
get_task_comm(taskname, task), task->pid);
pm_data->block_autosuspend = true;
if (usb_ld->usbdev)
pm_runtime_forbid(&usb_ld->usbdev->dev);
break;
default:
break;
}
exit:
return err;
}
/**
* 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);
}
static void pwm_lpss_remove_pci(struct pci_dev *pdev)
{
struct pwm_lpss_chip *lpwm = pci_get_drvdata(pdev);
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_sync(&pdev->dev);
pwm_lpss_remove(lpwm);
}
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 smsc_hub_disable(struct hsic_hub *hub)
{
struct smsc_hub_platform_data *pdata = hub->pdata;
pm_runtime_forbid(hub->dev);
device_for_each_child(hub->dev, NULL, sms_hub_remove_child);
gpio_direction_output(pdata->hub_reset, 0);
gpio_direction_output(pdata->xo_clk_gpio, 0);
return 0;
}
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);
}
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;
}
void i915_rpm_disable(struct drm_device *drm_dev)
{
struct device *dev = drm_dev->dev;
int cur_status = pm_runtime_enabled(dev);
if (cur_status) {
pm_runtime_forbid(dev);
pm_runtime_disable(dev);
}
return;
}
static void __devexit spi_pci_remove(struct pci_dev *pdev)
{
struct dw_spi_pci *dwpci = pci_get_drvdata(pdev);
pci_set_drvdata(pdev, NULL);
dw_spi_remove_host(&dwpci->dws);
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
iounmap(dwpci->dws.regs);
pci_release_region(pdev, 0);
kfree(dwpci);
pci_disable_device(pdev);
}
static int serial_hsu_plat_port_remove(struct platform_device *pdev)
{
struct uart_hsu_port *up = platform_get_drvdata(pdev);
struct resource *mem;
pm_runtime_forbid(&pdev->dev);
serial_hsu_port_free(up);
platform_set_drvdata(pdev, NULL);
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (mem)
release_mem_region(mem->start, resource_size(mem));
return 0;
}
static ssize_t store_ohci_power(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct s5p_ohci_platdata *pdata = pdev->dev.platform_data;
struct s5p_ohci_hcd *s5p_ohci = platform_get_drvdata(pdev);
struct usb_hcd *hcd = s5p_ohci->hcd;
int power_on;
int irq;
int retval;
if (sscanf(buf, "%d", &power_on) != 1)
return -EINVAL;
device_lock(dev);
if (!power_on && s5p_ohci->power_on) {
printk(KERN_DEBUG "%s: EHCI turns off\n", __func__);
pm_runtime_forbid(dev);
s5p_ohci->power_on = 0;
usb_remove_hcd(hcd);
if (pdata && pdata->phy_exit)
pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
} else if (power_on) {
printk(KERN_DEBUG "%s: EHCI turns on\n", __func__);
if (s5p_ohci->power_on) {
usb_remove_hcd(hcd);
}
if (pdata->phy_init)
pdata->phy_init(pdev, S5P_USB_PHY_HOST);
irq = platform_get_irq(pdev, 0);
retval = usb_add_hcd(hcd, irq,
IRQF_DISABLED | IRQF_SHARED);
if (retval < 0) {
dev_err(dev, "Power On Fail\n");
goto exit;
}
s5p_ohci->power_on = 1;
pm_runtime_allow(dev);
}
exit:
device_unlock(dev);
return count;
}
static int __devexit s5p_ehci_remove(struct platform_device *pdev)
{
struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
struct usb_hcd *hcd = s5p_ehci->hcd;
/* pm_runtime_disable called twice during pdev unregistering
* it causes disable_depth mismatching, so rpm for this device
* cannot works from disable_depth count
* replace it to runtime forbid.
*/
#ifdef CONFIG_USB_SUSPEND
#ifdef CONFIG_MDM_HSIC_PM
pm_runtime_forbid(&pdev->dev);
#else
pm_runtime_disable(&pdev->dev);
#endif
#endif
s5p_ehci->power_on = 0;
remove_ehci_sys_file(hcd_to_ehci(hcd));
usb_remove_hcd(hcd);
#ifdef CONFIG_EHCI_IRQ_DISTRIBUTION
if (num_possible_cpus() > 1) {
s5p_ehci_irq_no = 0;
s5p_ehci_irq_cpu = 0;
unregister_cpu_notifier(&s5p_ehci_cpu_notifier);
}
#endif
#if defined(CONFIG_LINK_DEVICE_HSIC) || defined(CONFIG_LINK_DEVICE_USB)
/*HSIC IPC control the ACTIVE_STATE*/
if (pdata && pdata->noti_host_states)
pdata->noti_host_states(pdev, S5P_HOST_OFF);
#endif
if (pdata && pdata->phy_exit)
pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
iounmap(hcd->regs);
clk_disable(s5p_ehci->clk);
clk_put(s5p_ehci->clk);
usb_put_hcd(hcd);
kfree(s5p_ehci);
return 0;
}
static void css2600_pci_remove(struct pci_dev *pdev)
{
struct css2600_device *isp = pci_get_drvdata(pdev);
css2600_isys_iomem_filter_remove(&pdev->dev);
css2600_bus_del_devices(pdev);
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
free_irq(pdev->irq, &pdev->dev);
pci_release_regions(pdev);
pci_disable_device(pdev);
release_firmware(isp->fw);
}