/*
* Remove a device
*/
static int __exit rk28_sdmmc0_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct rk28mci_host *host;
struct resource *res;
if (!mmc)
return -1;
//printk("%s..%s..%d ********************====xbw===*******************\n",__FUNCTION__,__FILE__,__LINE__);
host = mmc_priv(mmc);
rk28_sdmmc_disable(host);
mmc_remove_host(mmc);
free_irq(host->irq, host);
iounmap(host->baseaddr);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
release_mem_region(res->start, res->end - res->start + 1);
mmc_free_host(mmc);
platform_set_drvdata(pdev, NULL);
pr_debug("MCI Removed\n");
return 0;
}
/*
* Remove a device
*/
static int __exit at91_mci_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct at91mci_host *host;
struct resource *res;
if (!mmc)
return -1;
host = mmc_priv(mmc);
if (host->board->det_pin) {
device_init_wakeup(&pdev->dev, 0);
free_irq(host->board->det_pin, host);
cancel_delayed_work(&host->mmc->detect);
}
at91_mci_disable(host);
mmc_remove_host(mmc);
free_irq(host->irq, host);
clk_disable(host->mci_clk); /* Disable the peripheral clock */
clk_put(host->mci_clk);
iounmap(host->baseaddr);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
release_mem_region(res->start, res->end - res->start + 1);
mmc_free_host(mmc);
platform_set_drvdata(pdev, NULL);
pr_debug("MCI Removed\n");
return 0;
}
static int omap_hsmmc_remove(struct platform_device *pdev)
{
struct omap_hsmmc_host *host = platform_get_drvdata(pdev);
struct resource *res;
if (host) {
mmc_host_enable(host->mmc);
mmc_remove_host(host->mmc);
if (host->pdata->cleanup)
host->pdata->cleanup(&pdev->dev);
free_irq(host->irq, host);
if (mmc_slot(host).card_detect_irq)
free_irq(mmc_slot(host).card_detect_irq, host);
flush_scheduled_work();
mmc_host_disable(host->mmc);
clk_disable(host->iclk);
clk_put(host->fclk);
clk_put(host->iclk);
if (host->got_dbclk) {
clk_disable(host->dbclk);
clk_put(host->dbclk);
}
mmc_free_host(host->mmc);
iounmap(host->base);
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res)
release_mem_region(res->start, res->end - res->start + 1);
platform_set_drvdata(pdev, NULL);
return 0;
}
static int sh_mmcif_remove(struct platform_device *pdev)
{
struct sh_mmcif_host *host = platform_get_drvdata(pdev);
host->dying = true;
clk_prepare_enable(host->hclk);
pm_runtime_get_sync(&pdev->dev);
dev_pm_qos_hide_latency_limit(&pdev->dev);
mmc_remove_host(host->mmc);
sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
/*
* FIXME: cancel_delayed_work(_sync)() and free_irq() race with the
* mmc_remove_host() call above. But swapping order doesn't help either
* (a query on the linux-mmc mailing list didn't bring any replies).
*/
cancel_delayed_work_sync(&host->timeout_work);
clk_disable_unprepare(host->hclk);
mmc_free_host(host->mmc);
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
return 0;
}
static int mmci_driver_remove(struct vmm_device *dev)
{
struct mmc_host *mmc = dev->priv;
struct mmci_host *host = mmc_priv(mmc);
if (mmc && host) {
mmc_remove_host(mmc);
vmm_writel(0, &host->base->mask0);
vmm_writel(0, &host->base->mask1);
vmm_writel(0, &host->base->command);
vmm_writel(0, &host->base->datactrl);
if (!host->singleirq) {
vmm_host_irq_unregister(host->irq1, mmc);
}
vmm_host_irq_unregister(host->irq0, mmc);
vmm_devtree_regunmap_release(dev->node,
(virtual_addr_t)host->base, 0);
mmc_free_host(mmc);
dev->priv = NULL;
}
return VMM_OK;
}
static int imxmci_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
if (mmc) {
struct imxmci_host *host = mmc_priv(mmc);
tasklet_disable(&host->tasklet);
del_timer_sync(&host->timer);
mmc_remove_host(mmc);
free_irq(host->irq, host);
if(host->dma_allocated){
imx_dma_free(host->dma);
host->dma_allocated=0;
}
tasklet_kill(&host->tasklet);
release_resource(host->res);
mmc_free_host(mmc);
}
return 0;
}
static int sslsd_remove(struct platform_device *dev)
{
struct mmc_host *mmc = platform_get_drvdata(dev);
sslsd_host *host = mmc_priv(mmc);
//printk("sslsd: remove\n");
del_timer(&host->timer);
sdhc_exit(&host->hw);
platform_set_drvdata(dev, NULL);
mmc_remove_host(mmc);
free_irq(host->irq, host);
#if IO_MAP == 1
// release_resource(host->res);
iounmap((void *)(host->hw.r - 0x100));
#endif
#if SD_DMA
if (host->hw.fdma)
{
#if IO_MAP == 3
ebm_mfree(ebm_mem);
#endif
}
#endif
mmc_free_host(mmc);
sysfs_remove_group(&dev->dev.kobj, &sslsd_attr_group);
return 0;
}
static int s3c_hsmmc_remove(struct platform_device *dev)
{
struct mmc_host *mmc = platform_get_drvdata(dev);
struct s3c_hsmmc_host *host = mmc_priv(mmc);
int i;
mmc = host->mmc;
mmc_remove_host(mmc);
s3c_hsmmc_reset(host, S3C_HSMMC_RESET_ALL);
clk_disable(clk_get(&dev->dev, "hsmmc"));
for (i=0; i<NUM_OF_HSMMC_CLKSOURCES; i++) {
clk_disable(host->clk[i]);
clk_put(host->clk[i]);
}
free_irq(host->irq, host);
del_timer_sync(&host->timer);
tasklet_kill(&host->card_tasklet);
tasklet_kill(&host->finish_tasklet);
mmc_free_host(mmc);
return 0;
}
static int mmci_remove(struct amba_device *dev)
{
struct mmc_host *mmc = amba_get_drvdata(dev);
amba_set_drvdata(dev, NULL);
if (mmc) {
struct mmci_host *host = mmc_priv(mmc);
del_timer_sync(&host->timer);
mmc_remove_host(mmc);
writel(0, host->base + MMCIMASK0);
writel(0, host->base + MMCIMASK1);
writel(0, host->base + MMCICOMMAND);
writel(0, host->base + MMCIDATACTRL);
free_irq(dev->irq[0], host);
free_irq(dev->irq[1], host);
iounmap(host->base);
clk_disable(host->clk);
clk_put(host->clk);
mmc_free_host(mmc);
amba_release_regions(dev);
}
return 0;
}
static int __devexit pmpmci_remove(struct platform_device *pdev)
{
struct pmpmci_host *host = platform_get_drvdata(pdev);
struct sd_data_s *sd_data= host->platdata;
if (host) {
mmc_remove_host(host->mmc);
clk_disable(host->clk);
// if (host->platdata && host->platdata->cd_setup &&
// !(host->mmc->caps & MMC_CAP_NEEDS_POLL))
// host->platdata->cd_setup(host->mmc, 0);
//
sd_data->ops->deInit(&(sd_data->info));
tasklet_kill(&host->data_task);
tasklet_kill(&host->finish_task);
free_irq(host->irq, host);
iounmap((void *)host->iobase);
release_resource(host->ioarea);
kfree(host->ioarea);
mmc_free_host(host->mmc);
platform_set_drvdata(pdev, NULL);
}
return 0;
}
/*
* ubicom32sd_remove
*/
static int __devexit ubicom32sd_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
if (mmc) {
struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
gpio_free(ud->pdata->cards[0].pin_pwr);
gpio_free(ud->pdata->cards[0].pin_cd);
if (ud->pdata->cards[0].pin_wp != -1) {
gpio_free(ud->pdata->cards[0].pin_wp);
}
mmc_remove_host(mmc);
mmc_free_host(mmc);
}
/*
* Note that our data is allocated as part of the mmc structure
* so we don't need to free it.
*/
return 0;
}
static void sunximmc_shutdown(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct sunxi_mmc_host *smc_host = mmc_priv(mmc);
SMC_MSG("%s: ShutDown.\n", dev_name(&pdev->dev));
sunximmc_procfs_remove(smc_host);
mmc_remove_host(mmc);
}
static void s3cmci_shutdown(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct s3cmci_host *host = mmc_priv(mmc);
if (host->irq_cd >= 0)
free_irq(host->irq_cd, host);
mmc_remove_host(mmc);
clk_disable(host->clk);
}
static int omap_mmc_remove(struct platform_device *pdev)
{
struct mmc_omap_host *host = platform_get_drvdata(pdev);
struct resource *res;
u16 vdd = 0;
/*
* TODO:
* The timer could kick in and turn off the clocks.
* if mmc_remove_host touches the mmc module regs, this can
* crash. So need to verify if mmc_remove_host indeed touches
* the module regs.
*/
mmc_clk_try_enable(host);
if (!(OMAP_HSMMC_READ(host->base, HCTL) & SDVSDET)) {
/*
* Set the vdd back to 3V,
* applicable for dual volt support.
*/
vdd = fls(host->mmc->ocr_avail) - 1;
if (omap_mmc_switch_opcond(host, vdd) != 0)
host->mmc->ios.vdd = vdd;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res)
release_mem_region(res->start, res->end - res->start + 1);
platform_set_drvdata(pdev, NULL);
if (host) {
mmc_remove_host(host->mmc);
if (host->pdata->cleanup)
host->pdata->cleanup(&pdev->dev);
free_irq(host->irq, host);
if (mmc_slot(host).card_detect_irq)
free_irq(mmc_slot(host).card_detect_irq, host);
flush_scheduled_work();
mmc_clk_try_disable(host);
clk_put(host->fclk);
clk_put(host->iclk);
if (host->dbclk_enabled) {
clk_disable(host->dbclk);
clk_put(host->dbclk);
}
mmc_free_host(host->mmc);
iounmap(host->base);
}
return 0;
}
static int ocsdc_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
if (mmc) {
mmc_remove_host(mmc);
mmc_free_host(mmc);
}
// printk("ocsdc_remove\n");
return 0;
}
static int msmsdcc_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = mmc_get_drvdata(pdev);
struct mmc_platform_data *plat;
struct msmsdcc_host *host;
if (!mmc)
return -ENXIO;
host = mmc_priv(mmc);
DBG(host, "Removing SDCC2 device = %d\n", pdev->id);
plat = host->plat;
if (!plat->status_irq)
sysfs_remove_group(&pdev->dev.kobj, &dev_attr_grp);
tasklet_kill(&host->dma_tlet);
mmc_remove_host(mmc);
if (plat->status_irq)
free_irq(plat->status_irq, host);
if (plat->sdiowakeup_irq) {
set_irq_wake(host->plat->sdiowakeup_irq, 0);
free_irq(plat->sdiowakeup_irq, host);
}
free_irq(host->irqres->start, host);
free_irq(host->irqres->end, host);
writel(0, host->base + MMCIMASK0);
writel(0, host->base + MMCIMASK1);
writel(MCI_CLEAR_STATIC_MASK, host->base + MMCICLEAR);
writel(0, host->base + MMCIDATACTRL);
writel(0, host->base + MMCICOMMAND);
clk_put(host->clk);
clk_put(host->pclk);
dma_free_coherent(NULL, sizeof(struct msmsdcc_nc_dmadata),
host->dma.nc, host->dma.nc_busaddr);
iounmap(host->base);
mmc_free_host(mmc);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&host->early_suspend);
#endif
return 0;
}
static int sdhci_sprd_remove(struct platform_device *pdev)
{
struct sdhci_host *host = platform_get_drvdata(pdev);
struct sdhci_sprd_host *sprd_host = TO_SPRD_HOST(host);
struct mmc_host *mmc = host->mmc;
mmc_remove_host(mmc);
clk_disable_unprepare(sprd_host->clk_sdio);
clk_disable_unprepare(sprd_host->clk_enable);
mmc_free_host(mmc);
return 0;
}
static int __devexit ak98_sdio_remove(struct platform_device *dev)
{
struct mmc_host *mmc = platform_get_drvdata(dev);
platform_set_drvdata(dev, NULL);
if (mmc) {
struct ak98_mci_host *host = mmc_priv(mmc);
#if 0
del_timer_sync(&host->timer);
#endif
ak98sdio_cpufreq_deregister(host);
mmc_remove_host(mmc);
writel(0, host->base + AK98MCIMASK);
writel(0, host->base + AK98MCICOMMAND);
writel(0, host->base + AK98MCIDATACTRL);
#if 0
if (gpio_is_valid(host->gpio_cd))
free_irq(host->irq_cd, host);
free_irq(host->irq_mci, host);
if (host->gpio_wp != -ENOSYS)
gpio_free(host->gpio_wp);
if (host->gpio_cd != -ENOSYS)
gpio_free(host->gpio_cd);
#else
if (host->irq_cd > 0)
{
free_irq(host->irq_cd, host);
}
free_irq(host->irq_mci, host);
#endif
iounmap(host->base);
clk_disable(host->clk);
clk_put(host->clk);
mmc_free_host(mmc);
}
return 0;
}
static void mmc_omap_remove_slot(struct mmc_omap_slot *slot)
{
struct mmc_host *mmc = slot->mmc;
if (slot->pdata->name != NULL)
device_remove_file(&mmc->class_dev, &dev_attr_slot_name);
if (slot->pdata->get_cover_state != NULL)
device_remove_file(&mmc->class_dev, &dev_attr_cover_switch);
tasklet_kill(&slot->cover_tasklet);
del_timer_sync(&slot->cover_timer);
flush_scheduled_work();
mmc_remove_host(mmc);
mmc_free_host(mmc);
}
static int s3cmci_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct s3cmci_host *host = mmc_priv(mmc);
mmc_remove_host(mmc);
clk_disable(host->clk);
clk_put(host->clk);
free_irq(host->irq_cd, host);
free_irq(host->irq, host);
iounmap(host->base);
release_mem_region(host->mem->start, RESSIZE(host->mem));
mmc_free_host(mmc);
return 0;
}
static int wbsd_remove(struct device* dev)
{
struct mmc_host* mmc = dev_get_drvdata(dev);
struct wbsd_host* host;
if (!mmc)
return 0;
host = mmc_priv(mmc);
/*
* Unregister host with MMC layer.
*/
mmc_remove_host(mmc);
/*
* Power down the SD/MMC function.
*/
wbsd_unlock_config(host);
wbsd_write_config(host, WBSD_CONF_DEVICE, DEVICE_SD);
wbsd_write_config(host, WBSD_CONF_ENABLE, 0);
wbsd_lock_config(host);
/*
* Free resources.
*/
if (host->dma_buffer)
kfree(host->dma_buffer);
if (host->dma >= 0)
free_dma(host->dma);
free_irq(host->irq, host);
tasklet_kill(&host->card_tasklet);
tasklet_kill(&host->fifo_tasklet);
tasklet_kill(&host->crc_tasklet);
tasklet_kill(&host->timeout_tasklet);
tasklet_kill(&host->finish_tasklet);
tasklet_kill(&host->block_tasklet);
wbsd_release_regions(host);
mmc_free_host(mmc);
return 0;
}
static int mxs_mmc_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct mxs_mmc_host *host = mmc_priv(mmc);
struct mxs_ssp *ssp = &host->ssp;
mmc_remove_host(mmc);
if (ssp->dmach)
dma_release_channel(ssp->dmach);
clk_disable_unprepare(ssp->clk);
mmc_free_host(mmc);
return 0;
}
static void ushc_disconnect(struct usb_interface *intf)
{
struct ushc_data *ushc = usb_get_intfdata(intf);
spin_lock_irq(&ushc->lock);
set_bit(DISCONNECTED, &ushc->flags);
spin_unlock_irq(&ushc->lock);
usb_kill_urb(ushc->int_urb);
usb_kill_urb(ushc->cbw_urb);
usb_kill_urb(ushc->data_urb);
usb_kill_urb(ushc->csw_urb);
mmc_remove_host(ushc->mmc);
ushc_clean_up(ushc);
}
static int __exit at91_mci_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = platform_get_drvdata(pdev);
struct at91mci_host *host;
struct resource *res;
if (!mmc)
return -1;
host = mmc_priv(mmc);
if (host->buffer)
dma_free_coherent(&pdev->dev, MCI_BUFSIZE,
host->buffer, host->physical_address);
if (gpio_is_valid(host->board->det_pin)) {
if (device_can_wakeup(&pdev->dev))
free_irq(gpio_to_irq(host->board->det_pin), host);
device_init_wakeup(&pdev->dev, 0);
gpio_free(host->board->det_pin);
}
at91_mci_disable(host);
del_timer_sync(&host->timer);
mmc_remove_host(mmc);
free_irq(host->irq, host);
clk_disable(host->mci_clk);
clk_put(host->mci_clk);
if (gpio_is_valid(host->board->vcc_pin))
gpio_free(host->board->vcc_pin);
if (gpio_is_valid(host->board->wp_pin))
gpio_free(host->board->wp_pin);
iounmap(host->baseaddr);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
release_mem_region(res->start, resource_size(res));
mmc_free_host(mmc);
platform_set_drvdata(pdev, NULL);
pr_debug("MCI Removed\n");
return 0;
}
static void sdio_card_reset_worker(struct work_struct *work)
{
struct mmc_host *target = reset_host;
/* The actual reset operation must be run outside of driver thread.
* This is because mmc_remove_host() will cause the device to be
* instantly destroyed, and the driver then needs to end its thread,
* leading to a deadlock.
*
* We run it in a totally independent workqueue.
*/
pr_err("Resetting card...\n");
mmc_remove_host(target);
/* 20ms delay is based on experiment with sdhci controller */
mdelay(20);
mmc_add_host(target);
}
static int __devexit sh_mmcif_remove(struct platform_device *pdev)
{
struct sh_mmcif_host *host = platform_get_drvdata(pdev);
struct sh_mmcif_plat_data *pd = pdev->dev.platform_data;
int irq[2];
host->dying = true;
clk_enable(host->hclk);
pm_runtime_get_sync(&pdev->dev);
dev_pm_qos_hide_latency_limit(&pdev->dev);
if (pd && pd->use_cd_gpio)
mmc_gpio_free_cd(host->mmc);
mmc_remove_host(host->mmc);
sh_mmcif_writel(host->addr, MMCIF_CE_INT_MASK, MASK_ALL);
/*
* FIXME: cancel_delayed_work(_sync)() and free_irq() race with the
* mmc_remove_host() call above. But swapping order doesn't help either
* (a query on the linux-mmc mailing list didn't bring any replies).
*/
cancel_delayed_work_sync(&host->timeout_work);
if (host->addr)
iounmap(host->addr);
irq[0] = platform_get_irq(pdev, 0);
irq[1] = platform_get_irq(pdev, 1);
free_irq(irq[0], host);
free_irq(irq[1], host);
platform_set_drvdata(pdev, NULL);
clk_disable(host->hclk);
mmc_free_host(host->mmc);
pm_runtime_put_sync(&pdev->dev);
pm_runtime_disable(&pdev->dev);
return 0;
}
static int __devexit mmci_remove(struct amba_device *dev)
{
struct mmc_host *mmc = amba_get_drvdata(dev);
amba_set_drvdata(dev, NULL);
if (mmc) {
struct mmci_host *host = mmc_priv(mmc);
del_timer_sync(&host->timer);
mmc_remove_host(mmc);
writel(0, host->base + MMCIMASK0);
writel(0, host->base + MMCIMASK1);
writel(0, host->base + MMCICOMMAND);
writel(0, host->base + MMCIDATACTRL);
free_irq(dev->irq[0], host);
free_irq(dev->irq[1], host);
if (host->gpio_wp != -ENOSYS)
gpio_free(host->gpio_wp);
if (host->gpio_cd != -ENOSYS)
gpio_free(host->gpio_cd);
iounmap(host->base);
clk_disable(host->clk);
clk_put(host->clk);
if (regulator_is_enabled(host->vcc))
regulator_disable(host->vcc);
regulator_put(host->vcc);
mmc_free_host(mmc);
amba_release_regions(dev);
}
return 0;
}
static int goldfish_mmc_remove(struct platform_device *pdev)
{
struct goldfish_mmc_host *host = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
BUG_ON(host == NULL);
mmc_remove_host(host->mmc);
free_irq(host->irq, host);
#if defined(CONFIG_ARM)
dma_free_writecombine(&pdev->dev, BUFFER_SIZE, host->virt_base, host->phys_base);
#elif defined(CONFIG_X86) || defined(CONFIG_MIPS)
dma_free_coherent(NULL, BUFFER_SIZE, host->virt_base, host->phys_base);
#else
#error NOT SUPPORTED
#endif
mmc_free_host(host->mmc);
return 0;
}
static int bcm2835_sdhost_remove(struct platform_device *pdev)
{
struct bcm2835_host *host = platform_get_drvdata(pdev);
pr_debug("bcm2835_sdhost_remove\n");
mmc_remove_host(host->mmc);
bcm2835_sdhost_set_power(host, false);
free_irq(host->irq, host);
del_timer_sync(&host->timer);
tasklet_kill(&host->finish_tasklet);
mmc_free_host(host->mmc);
platform_set_drvdata(pdev, NULL);
pr_debug("bcm2835_sdhost_remove - OK\n");
return 0;
}
static int moxart_remove(struct platform_device *pdev)
{
struct mmc_host *mmc = dev_get_drvdata(&pdev->dev);
struct moxart_host *host = mmc_priv(mmc);
dev_set_drvdata(&pdev->dev, NULL);
if (mmc) {
if (!IS_ERR(host->dma_chan_tx))
dma_release_channel(host->dma_chan_tx);
if (!IS_ERR(host->dma_chan_rx))
dma_release_channel(host->dma_chan_rx);
mmc_remove_host(mmc);
mmc_free_host(mmc);
writel(0, host->base + REG_INTERRUPT_MASK);
writel(0, host->base + REG_POWER_CONTROL);
writel(readl(host->base + REG_CLOCK_CONTROL) | CLK_OFF,
host->base + REG_CLOCK_CONTROL);
}
return 0;
}
