/* this is for power init */
void gpu_power_init(void)
{
#ifdef CONFIG_PM_RUNTIME
pm_suspend_ignore_children(&gpsPVRLDMDev->dev, true);
pm_runtime_enable(&gpsPVRLDMDev->dev);
#endif
}
/** This funtion is invoked when mali device needs to be activated.
*/
void _mali_osk_pmm_dev_activate(void)
{
#if MALI_LICENSE_IS_GPL
#ifdef CONFIG_PM_RUNTIME
#if MALI_PMM_RUNTIME_JOB_CONTROL_ON
int err = 0;
if(is_runtime == 0)
{
pm_suspend_ignore_children(&(mali_gpu_device.dev), true);
pm_runtime_enable(&(mali_gpu_device.dev));
pm_runtime_get_sync(&(mali_gpu_device.dev));
is_runtime = 1;
}
else
{
err = pm_runtime_get_sync(&(mali_gpu_device.dev));
}
if(err)
{
MALI_DEBUG_PRINT(4, ("OSPMM: Error in _mali_osk_pmm_dev_activate\n" ));
}
#endif /* MALI_PMM_RUNTIME_JOB_CONTROL_ON */
#endif /* CONFIG_PM_RUNTIME */
#endif /* MALI_LICENSE_IS_GPL */
}
mali_error kbase_device_runtime_init(struct kbase_device *kbdev)
{
pm_suspend_ignore_children(kbdev->osdev.dev, true);
pm_runtime_enable(kbdev->osdev.dev);
kbase_device_runtime_init_workqueue(kbdev->osdev.dev);
mutex_init(&runtime_pm_lock);
return MALI_ERROR_NONE;
}
static void sprd_sdio_card_remove(struct mmc_card *card) {
struct mmc_host *host = card->host;
if (mmc_card_sdio(card)) {
if(host->caps & MMC_CAP_POWER_OFF_CARD) {
pm_suspend_ignore_children(mmc_classdev(host), true); // avoid mmc_attach_sdio->pm_runtime_set_active returning with error -16
pm_runtime_idle(mmc_classdev(host)); // make platform devices runtime suspendable
}
}
}
static void sprd_sdio_card_remove(struct mmc_card *card) {
struct mmc_host *host = card->host;
if (mmc_card_sdio(card)) {
if(host->caps & MMC_CAP_POWER_OFF_CARD) {
pm_suspend_ignore_children(mmc_classdev(host), true);
pm_runtime_idle(mmc_classdev(host));
}
}
}
mali_error kbase_device_runtime_init(struct kbase_device *kbdev)
{
pm_suspend_ignore_children(kbdev->osdev.dev, true);
pm_runtime_enable(kbdev->osdev.dev);
#ifdef CONFIG_MALI_T6XX_DEBUG_SYS
if (kbase_platform_create_sysfs_file(kbdev->osdev.dev))
return MALI_ERROR_FUNCTION_FAILED;
#endif /* CONFIG_MALI_T6XX_DEBUG_SYS */
return MALI_ERROR_NONE;
}
static int sprd_sdio_card_probe(struct mmc_card *card) {
struct mmc_host *host = card->host;
if (mmc_card_sdio(card)) {
if(host->caps & MMC_CAP_POWER_OFF_CARD) {
pm_runtime_no_callbacks(&card->dev);
pm_suspend_ignore_children(mmc_classdev(host), false);
return 0;
}
}
return -EINVAL;
}
static int sprd_sdio_card_probe(struct mmc_card *card) {
struct mmc_host *host = card->host;
if (mmc_card_sdio(card)) {
if(host->caps & MMC_CAP_POWER_OFF_CARD) {
pm_runtime_no_callbacks(&card->dev); // avoid default sdio bus runtime calling
pm_suspend_ignore_children(mmc_classdev(host), false); // paired with remove function
}
return 0;
}
return -EINVAL;
}
static int rcar_vin_probe(struct platform_device *pdev)
{
const struct of_device_id *match;
struct rvin_dev *vin;
struct resource *mem;
int irq, ret;
vin = devm_kzalloc(&pdev->dev, sizeof(*vin), GFP_KERNEL);
if (!vin)
return -ENOMEM;
match = of_match_device(of_match_ptr(rvin_of_id_table), &pdev->dev);
if (!match)
return -ENODEV;
vin->dev = &pdev->dev;
vin->chip = (enum chip_id)match->data;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (mem == NULL)
return -EINVAL;
vin->base = devm_ioremap_resource(vin->dev, mem);
if (IS_ERR(vin->base))
return PTR_ERR(vin->base);
irq = platform_get_irq(pdev, 0);
if (irq < 0)
return irq;
ret = rvin_dma_probe(vin, irq);
if (ret)
return ret;
ret = rvin_digital_graph_init(vin);
if (ret < 0)
goto error;
pm_suspend_ignore_children(&pdev->dev, true);
pm_runtime_enable(&pdev->dev);
platform_set_drvdata(pdev, vin);
return 0;
error:
rvin_dma_remove(vin);
return ret;
}
static int rcar_vin_probe(struct platform_device *pdev)
{
struct rvin_dev *vin;
struct resource *mem;
int irq, ret;
vin = devm_kzalloc(&pdev->dev, sizeof(*vin), GFP_KERNEL);
if (!vin)
return -ENOMEM;
vin->dev = &pdev->dev;
ret = rvin_parse_dt(vin);
if (ret)
return ret;
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (mem == NULL)
return -EINVAL;
vin->base = devm_ioremap_resource(vin->dev, mem);
if (IS_ERR(vin->base))
return PTR_ERR(vin->base);
irq = platform_get_irq(pdev, 0);
if (irq <= 0)
return ret;
ret = rvin_dma_probe(vin, irq);
if (ret)
return ret;
ret = rvin_graph_init(vin);
if (ret < 0)
goto error;
pm_suspend_ignore_children(&pdev->dev, true);
pm_runtime_enable(&pdev->dev);
platform_set_drvdata(pdev, vin);
return 0;
error:
rvin_dma_remove(vin);
return ret;
}
int hid_sensor_setup_trigger(struct iio_dev *indio_dev, const char *name,
struct hid_sensor_common *attrb)
{
int ret;
struct iio_trigger *trig;
trig = iio_trigger_alloc("%s-dev%d", name, indio_dev->id);
if (trig == NULL) {
dev_err(&indio_dev->dev, "Trigger Allocate Failed\n");
ret = -ENOMEM;
goto error_ret;
}
trig->dev.parent = indio_dev->dev.parent;
iio_trigger_set_drvdata(trig, attrb);
trig->ops = &hid_sensor_trigger_ops;
ret = iio_trigger_register(trig);
if (ret) {
dev_err(&indio_dev->dev, "Trigger Register Failed\n");
goto error_free_trig;
}
attrb->trigger = trig;
indio_dev->trig = iio_trigger_get(trig);
ret = pm_runtime_set_active(&indio_dev->dev);
if (ret)
goto error_unreg_trigger;
iio_device_set_drvdata(indio_dev, attrb);
pm_suspend_ignore_children(&attrb->pdev->dev, true);
pm_runtime_enable(&attrb->pdev->dev);
/* Default to 3 seconds, but can be changed from sysfs */
pm_runtime_set_autosuspend_delay(&attrb->pdev->dev,
3000);
pm_runtime_use_autosuspend(&attrb->pdev->dev);
return ret;
error_unreg_trigger:
iio_trigger_unregister(trig);
error_free_trig:
iio_trigger_free(trig);
error_ret:
return ret;
}
static int sh_mobile_i2c_probe(struct platform_device *dev)
{
struct sh_mobile_i2c_data *pd;
struct i2c_adapter *adap;
struct resource *res;
char clk_name[8];
int size;
int ret;
pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL);
if (pd == NULL) {
dev_err(&dev->dev, "cannot allocate private data\n");
return -ENOMEM;
}
snprintf(clk_name, sizeof(clk_name), "i2c%d", dev->id);
pd->clk = clk_get(&dev->dev, clk_name);
if (IS_ERR(pd->clk)) {
dev_err(&dev->dev, "cannot get clock \"%s\"\n", clk_name);
ret = PTR_ERR(pd->clk);
goto err;
}
ret = sh_mobile_i2c_hook_irqs(dev, 1);
if (ret) {
dev_err(&dev->dev, "cannot request IRQ\n");
goto err_clk;
}
pd->dev = &dev->dev;
platform_set_drvdata(dev, pd);
res = platform_get_resource(dev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&dev->dev, "cannot find IO resource\n");
ret = -ENOENT;
goto err_irq;
}
size = resource_size(res);
pd->reg = ioremap(res->start, size);
if (pd->reg == NULL) {
dev_err(&dev->dev, "cannot map IO\n");
ret = -ENXIO;
goto err_irq;
}
/* The IIC blocks on SH-Mobile ARM processors
* come with two new bits in ICIC.
*/
if (size > 0x17)
pd->flags |= IIC_FLAG_HAS_ICIC67;
/* Enable Runtime PM for this device.
*
* Also tell the Runtime PM core to ignore children
* for this device since it is valid for us to suspend
* this I2C master driver even though the slave devices
* on the I2C bus may not be suspended.
*
* The state of the I2C hardware bus is unaffected by
* the Runtime PM state.
*/
pm_suspend_ignore_children(&dev->dev, true);
pm_runtime_enable(&dev->dev);
/* setup the private data */
adap = &pd->adap;
i2c_set_adapdata(adap, pd);
adap->owner = THIS_MODULE;
adap->algo = &sh_mobile_i2c_algorithm;
adap->dev.parent = &dev->dev;
adap->retries = 5;
adap->nr = dev->id;
strlcpy(adap->name, dev->name, sizeof(adap->name));
spin_lock_init(&pd->lock);
init_waitqueue_head(&pd->wait);
ret = i2c_add_numbered_adapter(adap);
if (ret < 0) {
dev_err(&dev->dev, "cannot add numbered adapter\n");
goto err_all;
}
return 0;
err_all:
iounmap(pd->reg);
err_irq:
sh_mobile_i2c_hook_irqs(dev, 0);
err_clk:
clk_put(pd->clk);
err:
kfree(pd);
return ret;
}
static mali_error gpu_device_runtime_init(struct kbase_device *kbdev)
{
pm_suspend_ignore_children(kbdev->dev, true);
return 0;
}
static int sdhci_acpi_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
acpi_handle handle = ACPI_HANDLE(dev);
struct acpi_device *device;
struct sdhci_acpi_host *c;
struct sdhci_host *host;
struct resource *iomem;
resource_size_t len;
const char *hid;
int err;
if (acpi_bus_get_device(handle, &device))
return -ENODEV;
if (acpi_bus_get_status(device) || !device->status.present)
return -ENODEV;
hid = acpi_device_hid(device);
iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!iomem)
return -ENOMEM;
len = resource_size(iomem);
if (len < 0x100)
dev_err(dev, "Invalid iomem size!\n");
if (!devm_request_mem_region(dev, iomem->start, len, dev_name(dev)))
return -ENOMEM;
host = sdhci_alloc_host(dev, sizeof(struct sdhci_acpi_host));
if (IS_ERR(host))
return PTR_ERR(host);
c = sdhci_priv(host);
c->host = host;
c->slot = sdhci_acpi_get_slot(handle, hid);
c->pdev = pdev;
c->use_runtime_pm = sdhci_acpi_flag(c, SDHCI_ACPI_RUNTIME_PM);
platform_set_drvdata(pdev, c);
host->hw_name = "ACPI";
host->ops = &sdhci_acpi_ops_dflt;
host->irq = platform_get_irq(pdev, 0);
host->ioaddr = devm_ioremap_nocache(dev, iomem->start,
resource_size(iomem));
if (host->ioaddr == NULL) {
err = -ENOMEM;
goto err_free;
}
if (!dev->dma_mask) {
u64 dma_mask;
if (sdhci_readl(host, SDHCI_CAPABILITIES) & SDHCI_CAN_64BIT) {
/* 64-bit DMA is not supported at present */
dma_mask = DMA_BIT_MASK(32);
} else {
dma_mask = DMA_BIT_MASK(32);
}
err = dma_coerce_mask_and_coherent(dev, dma_mask);
if (err)
goto err_free;
}
if (c->slot) {
if (c->slot->chip) {
host->ops = c->slot->chip->ops;
host->quirks |= c->slot->chip->quirks;
host->quirks2 |= c->slot->chip->quirks2;
host->mmc->caps |= c->slot->chip->caps;
host->mmc->caps2 |= c->slot->chip->caps2;
host->mmc->pm_caps |= c->slot->chip->pm_caps;
}
host->quirks |= c->slot->quirks;
host->quirks2 |= c->slot->quirks2;
host->mmc->caps |= c->slot->caps;
host->mmc->caps2 |= c->slot->caps2;
host->mmc->pm_caps |= c->slot->pm_caps;
}
host->mmc->caps2 |= MMC_CAP2_NO_PRESCAN_POWERUP;
err = sdhci_add_host(host);
if (err)
goto err_free;
if (sdhci_acpi_flag(c, SDHCI_ACPI_SD_CD)) {
if (sdhci_acpi_add_own_cd(dev, host->mmc))
c->use_runtime_pm = false;
}
if (c->use_runtime_pm) {
pm_runtime_set_active(dev);
pm_suspend_ignore_children(dev, 1);
pm_runtime_set_autosuspend_delay(dev, 50);
pm_runtime_use_autosuspend(dev);
pm_runtime_enable(dev);
}
return 0;
err_free:
sdhci_free_host(c->host);
return err;
}
static int __devinit sdhci_sprd_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct sdhci_host *host;
struct resource *res;
int ret, irq;
#ifdef CONFIG_MMC_CARD_HOTPLUG
int sd_detect_gpio;
int detect_irq;
#endif
struct sprd_host_data *host_data;
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(dev, "no irq specified\n");
return irq;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(dev, "no memory specified\n");
return -ENOENT;
}
if(pdev->id == 0)
{
sd_buffer_pre_alloc();
}
host = sdhci_alloc_host(dev, sizeof(struct sprd_host_data));
if (IS_ERR(host)) {
dev_err(dev, "sdhci_alloc_host() failed\n");
return PTR_ERR(host);
}
host_data = sdhci_priv(host);
host_data->platdata = dev_get_platdata(dev);
host_data->clk_enable = 0;
BUG_ON(NULL == host_data->platdata);
printk("sdio probe %s, vdd %s (%d), clk %s parent %s\n",
host_data->platdata->hw_name,
host_data->platdata->vdd_name, host_data->platdata->volt_level,
host_data->platdata->clk_name, host_data->platdata->clk_parent);
platform_set_drvdata(pdev, host);
host->vmmc = NULL;
host->vmmc_ext = NULL;
host->ioaddr = (void __iomem *)res->start;
printk("sdio: host->ioaddr:0x%x\n", (u32)host->ioaddr);
host->hw_name = (host_data->platdata->hw_name)?
host_data->platdata->hw_name:pdev->name;
host->ops = &sdhci_sprd_ops;
host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |\
SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |\
SDHCI_QUIRK_BROKEN_CARD_DETECTION|\
SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
host->irq = irq;
#ifdef CONFIG_MMC_CARD_HOTPLUG
sd_detect_gpio = host_data->platdata->detect_gpio;
if(sd_detect_gpio > 0){
pr_info("%s, sd_detect_gpio:%d\n", __func__, sd_detect_gpio);
if (0 == pdev->id){
ret = gpio_request(sd_detect_gpio, "sdio0_detect");
}else{
ret = gpio_request(sd_detect_gpio, "sdio1_detect");
}
if (ret) {
dev_err(dev, "cannot request gpio\n");
return -1;
}
ret = gpio_direction_input(sd_detect_gpio);
if (ret) {
dev_err(dev, "gpio can not change to input\n");
return -1;
}
detect_irq = gpio_to_irq(sd_detect_gpio);
if (detect_irq < 0){
dev_err(dev, "cannot alloc detect irq\n");
return -1;
}
host_data->detect_irq = detect_irq;
}else if (host_data->platdata->register_status_notify) {
host_data->platdata->register_status_notify(sdhci_status_notify_cb, host);
} else if (!host_data->platdata->status) {
printk("%s: No card detect facilities available\n",
mmc_hostname(host->mmc));
}else{
printk("%s, sd_detect_gpio == 0 \n", __func__ );
}
#endif
if(host_data->platdata->vdd_name) {
host->vmmc = regulator_get(NULL, host_data->platdata->vdd_name);
BUG_ON(IS_ERR(host->vmmc));
if(!is_sd_slot(host))
regulator_enable(host->vmmc);
}
if(host_data->platdata->vdd_ext_name) {
host->vmmc_ext = regulator_get(NULL, host_data->platdata->vdd_ext_name);
BUG_ON(IS_ERR(host->vmmc_ext));
regulator_enable(host->vmmc_ext);
}
host->clk = NULL;
sdhci_module_init(host);
switch(pdev->id) {
case 0:
host->mmc->pm_flags |= MMC_PM_ONLY_USED_SDIO0_SHARK;
host->caps = sdhci_readl(host, SDHCI_CAPABILITIES) & (~(SDHCI_CAN_VDD_330 | SDHCI_CAN_VDD_180));
host->quirks |= SDHCI_QUIRK_MISSING_CAPS;
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
break;
case 1:
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY|MMC_PM_KEEP_POWER |MMC_PM_DISABLE_TIMEOUT_IRQ;
host->mmc->pm_caps |= MMC_PM_KEEP_POWER |MMC_PM_DISABLE_TIMEOUT_IRQ;
#ifdef CONFIG_SDIO_CARD
host->mmc->caps |= MMC_CAP_4_BIT_DATA |MMC_CAP_NONREMOVABLE | MMC_CAP_POWER_OFF_CARD;
#else
host->mmc->caps |= MMC_CAP_4_BIT_DATA |MMC_CAP_NONREMOVABLE;
#endif
break;
case 2:
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY | MMC_PM_KEEP_POWER;
host->mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD;
break;
case 3:
host->caps = sdhci_readl(host, SDHCI_CAPABILITIES) & (~(SDHCI_CAN_VDD_330 | SDHCI_CAN_VDD_300));
host->quirks |= SDHCI_QUIRK_MISSING_CAPS;
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY | MMC_PM_KEEP_POWER;
host->mmc->caps |= MMC_CAP_NONREMOVABLE | MMC_CAP_8_BIT_DATA | MMC_CAP_HW_RESET;
break;
default:
BUG();
break;
}
#ifdef CONFIG_PM_RUNTIME
switch(pdev->id) {
case 1:
case 2:
#ifdef CONFIG_SDIO_CARD
pm_runtime_set_active(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 100);
pm_runtime_use_autosuspend(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_no_callbacks(mmc_classdev(host->mmc));
pm_suspend_ignore_children(mmc_classdev(host->mmc), true);
pm_runtime_set_active(mmc_classdev(host->mmc));
pm_runtime_enable(mmc_classdev(host->mmc));
#endif
break;
case 3:
case 0:
pm_suspend_ignore_children(&pdev->dev, true);
pm_runtime_set_active(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 100);
pm_runtime_use_autosuspend(&pdev->dev);
pm_runtime_enable(&pdev->dev);
default:
break;
}
#endif
ret = sdhci_add_host(host);
if (ret) {
dev_err(dev, "sdhci_add_host() failed\n");
goto err_add_host;
}
#ifdef CONFIG_MMC_BUS_SCAN
if (pdev->id == 1)
sdhci_host_g = host;
#endif
return 0;
err_add_host:
#ifdef CONFIG_PM_RUNTIME
pm_runtime_disable(&(pdev)->dev);
pm_runtime_set_suspended(&(pdev)->dev);
#endif
if (host_data->clk_enable) {
clk_disable(host->clk);
host_data->clk_enable = 0;
}
sdhci_free_host(host);
return ret;
}
static int __devinit spi_pci_probe(struct pci_dev *pdev,
const struct pci_device_id *ent)
{
struct dw_spi_pci *dwpci;
struct dw_spi *dws;
int pci_bar = 0;
int ret;
printk(KERN_INFO "DW: found PCI SPI controller(ID: %04x:%04x)\n",
pdev->vendor, pdev->device);
ret = pci_enable_device(pdev);
if (ret)
return ret;
dwpci = kzalloc(sizeof(struct dw_spi_pci), GFP_KERNEL);
if (!dwpci) {
ret = -ENOMEM;
goto err_disable;
}
dwpci->pdev = pdev;
dws = &dwpci->dws;
/* Get basic io resource and map it */
dws->paddr = pci_resource_start(pdev, pci_bar);
dws->iolen = pci_resource_len(pdev, pci_bar);
ret = pci_request_region(pdev, pci_bar, dev_name(&pdev->dev));
if (ret)
goto err_kfree;
dws->regs = ioremap_nocache((unsigned long)dws->paddr,
pci_resource_len(pdev, pci_bar));
if (!dws->regs) {
ret = -ENOMEM;
goto err_release_reg;
}
dws->parent_dev = &pdev->dev;
dws->bus_num = ent->driver_data;
dws->num_cs = 4;
dws->irq = pdev->irq;
/*
* Specific handling for Intel MID paltforms, like dma setup,
* clock rate, FIFO depth.
*/
ret = dw_spi_mid_init(dws, ent->driver_data);
if (ret)
goto err_unmap;
ret = dw_spi_add_host(dws);
if (ret)
goto err_unmap;
/* PCI hook and SPI hook use the same drv data */
pci_set_drvdata(pdev, dwpci);
pm_suspend_ignore_children(&pdev->dev, true);
pm_runtime_put_noidle(&pdev->dev);
pm_runtime_allow(&pdev->dev);
return 0;
err_unmap:
iounmap(dws->regs);
err_release_reg:
pci_release_region(pdev, pci_bar);
err_kfree:
kfree(dwpci);
err_disable:
pci_disable_device(pdev);
return ret;
}
static int sdhci_sprd_probe(struct platform_device *pdev)
{
struct sdhci_host *host;
struct sdhci_sprd_host *sprd_host;
struct clk *clk;
int ret = 0;
host = sdhci_pltfm_init(pdev, &sdhci_sprd_pdata, sizeof(*sprd_host));
if (IS_ERR(host))
return PTR_ERR(host);
host->dma_mask = DMA_BIT_MASK(64);
pdev->dev.dma_mask = &host->dma_mask;
host->mmc_host_ops.request = sdhci_sprd_request;
host->mmc->caps = MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED |
MMC_CAP_ERASE | MMC_CAP_CMD23;
ret = mmc_of_parse(host->mmc);
if (ret)
goto pltfm_free;
sprd_host = TO_SPRD_HOST(host);
clk = devm_clk_get(&pdev->dev, "sdio");
if (IS_ERR(clk)) {
ret = PTR_ERR(clk);
goto pltfm_free;
}
sprd_host->clk_sdio = clk;
sprd_host->base_rate = clk_get_rate(sprd_host->clk_sdio);
if (!sprd_host->base_rate)
sprd_host->base_rate = SDHCI_SPRD_CLK_DEF_RATE;
clk = devm_clk_get(&pdev->dev, "enable");
if (IS_ERR(clk)) {
ret = PTR_ERR(clk);
goto pltfm_free;
}
sprd_host->clk_enable = clk;
ret = clk_prepare_enable(sprd_host->clk_sdio);
if (ret)
goto pltfm_free;
clk_prepare_enable(sprd_host->clk_enable);
if (ret)
goto clk_disable;
sdhci_sprd_init_config(host);
host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
sprd_host->version = ((host->version & SDHCI_VENDOR_VER_MASK) >>
SDHCI_VENDOR_VER_SHIFT);
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);
pm_suspend_ignore_children(&pdev->dev, 1);
sdhci_enable_v4_mode(host);
ret = sdhci_setup_host(host);
if (ret)
goto pm_runtime_disable;
sprd_host->flags = host->flags;
ret = __sdhci_add_host(host);
if (ret)
goto err_cleanup_host;
pm_runtime_mark_last_busy(&pdev->dev);
pm_runtime_put_autosuspend(&pdev->dev);
return 0;
err_cleanup_host:
sdhci_cleanup_host(host);
pm_runtime_disable:
pm_runtime_disable(&pdev->dev);
pm_runtime_set_suspended(&pdev->dev);
clk_disable_unprepare(sprd_host->clk_enable);
clk_disable:
clk_disable_unprepare(sprd_host->clk_sdio);
pltfm_free:
sdhci_pltfm_free(pdev);
return ret;
}
static int __devinit sdhci_pxav3_probe(struct platform_device *pdev)
{
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
struct device *dev = &pdev->dev;
struct sdhci_host *host = NULL;
struct sdhci_pxa *pxa = NULL;
const struct of_device_id *match;
int ret;
struct clk *clk;
int qos_class = PM_QOS_CPUIDLE_BLOCK;
pxa = kzalloc(sizeof(struct sdhci_pxa), GFP_KERNEL);
if (!pxa)
return -ENOMEM;
host = sdhci_pltfm_init(pdev, NULL);
if (IS_ERR(host)) {
kfree(pxa);
return PTR_ERR(host);
}
pltfm_host = sdhci_priv(host);
pltfm_host->priv = pxa;
clk = clk_get(dev, "PXA-SDHCLK");
if (IS_ERR(clk)) {
dev_err(dev, "failed to get io clock\n");
ret = PTR_ERR(clk);
goto err_clk_get;
}
pltfm_host->clk = clk;
clk_prepare_enable(clk);
host->quirks = SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK
| SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
| SDHCI_QUIRK_32BIT_ADMA_SIZE
| SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN;
match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
if (match)
pdata = pxav3_get_mmc_pdata(dev);
if (pdata) {
pdata->qos_idle.name = mmc_hostname(host->mmc);
pm_qos_add_request(&pdata->qos_idle, qos_class,
PM_QOS_CPUIDLE_BLOCK_DEFAULT_VALUE);
/* If slot design supports 8 bit data, indicate this to MMC. */
if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
host->mmc->caps |= MMC_CAP_8_BIT_DATA;
if (pdata->flags & PXA_FLAG_ENABLE_CLOCK_GATING)
host->mmc->caps2 |= MMC_CAP2_BUS_AUTO_CLK_GATE;
if (pdata->flags & PXA_FLAG_DISABLE_PROBE_CDSCAN)
host->mmc->caps2 |= MMC_CAP2_DISABLE_PROBE_CDSCAN;
if (pdata->quirks)
host->quirks |= pdata->quirks;
if (pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
if (pdata->host_caps2)
host->mmc->caps2 |= pdata->host_caps2;
if (pdata->pm_caps)
host->mmc->pm_caps |= pdata->pm_caps;
if (pdata->cd_type != PXA_SDHCI_CD_HOST)
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
if (pdata->cd_type == PXA_SDHCI_CD_GPIO &&
gpio_is_valid(pdata->ext_cd_gpio)) {
ret = mmc_gpio_request_cd(host->mmc, pdata->ext_cd_gpio);
if (ret) {
dev_err(mmc_dev(host->mmc),
"failed to allocate card detect gpio\n");
goto err_cd_req;
}
} else if (pdata->cd_type == PXA_SDHCI_CD_PERMANENT) {
/* on-chip device */
host->mmc->caps |= MMC_CAP_NONREMOVABLE;
} else if (pdata->cd_type == PXA_SDHCI_CD_NONE)
host->mmc->caps |= MMC_CAP_NEEDS_POLL;
}
host->quirks2 = SDHCI_QUIRK2_NO_CURRENT_LIMIT
| SDHCI_QUIRK2_PRESET_VALUE_BROKEN
| SDHCI_QUIRK2_TIMEOUT_DIVIDE_4;
host->ops = &pxav3_sdhci_ops;
if (pdata && pdata->flags & PXA_FLAG_EN_PM_RUNTIME) {
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev,
PXAV3_RPM_DELAY_MS);
pm_runtime_use_autosuspend(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
}
#ifdef _MMC_SAFE_ACCESS_
mmc_is_available = 1;
#endif
ret = sdhci_add_host(host);
if (ret) {
dev_err(&pdev->dev, "failed to add host\n");
if (pdata && pdata->flags & PXA_FLAG_EN_PM_RUNTIME) {
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
}
goto err_add_host;
}
/* remove the caps that supported by the controller but not available
* for certain platforms.
*/
if (pdata && pdata->host_caps_disable)
host->mmc->caps &= ~(pdata->host_caps_disable);
platform_set_drvdata(pdev, host);
if (pdata && pdata->flags & PXA_FLAG_WAKEUP_HOST) {
device_init_wakeup(&pdev->dev, 1);
host->mmc->pm_flags |= MMC_PM_WAKE_SDIO_IRQ;
}
else
device_init_wakeup(&pdev->dev, 0);
#ifdef CONFIG_SD8XXX_RFKILL
if (pdata && pdata->pmmc)
*pdata->pmmc = host->mmc;
#endif
return 0;
err_add_host:
clk_disable_unprepare(clk);
clk_put(clk);
if (pdata)
pm_qos_remove_request(&pdata->qos_idle);
err_cd_req:
mmc_gpio_free_cd(host->mmc);
err_clk_get:
sdhci_pltfm_free(pdev);
kfree(pxa);
return ret;
}
static int __devinit if_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct usb_host_interface *data_desc;
struct usb_link_device *usb_ld =
(struct usb_link_device *)id->driver_info;
struct link_device *ld = &usb_ld->ld;
struct usb_interface *data_intf;
struct usb_device *usbdev = interface_to_usbdev(intf);
struct device *dev, *ehci_dev, *root_hub;
struct if_usb_devdata *pipe;
struct urb *urb;
int i;
int j;
int dev_id;
int err;
/* To detect usb device order probed */
dev_id = intf->cur_altsetting->desc.bInterfaceNumber;
if (dev_id >= IF_USB_DEVNUM_MAX) {
dev_err(&intf->dev, "Device id %d cannot support\n",
dev_id);
return -EINVAL;
}
if (!usb_ld) {
dev_err(&intf->dev,
"if_usb device doesn't be allocated\n");
err = ENOMEM;
goto out;
}
mif_info("probe dev_id=%d usb_device_id(0x%p), usb_ld (0x%p)\n",
dev_id, id, usb_ld);
usb_ld->usbdev = usbdev;
usb_get_dev(usbdev);
for (i = 0; i < IF_USB_DEVNUM_MAX; i++) {
data_intf = usb_ifnum_to_if(usbdev, i);
/* remap endpoint of RAW to no.1 for LTE modem */
if (i == 0)
pipe = &usb_ld->devdata[1];
else if (i == 1)
pipe = &usb_ld->devdata[0];
else
pipe = &usb_ld->devdata[i];
pipe->disconnected = 0;
pipe->data_intf = data_intf;
data_desc = data_intf->cur_altsetting;
/* Endpoints */
if (usb_pipein(data_desc->endpoint[0].desc.bEndpointAddress)) {
pipe->rx_pipe = usb_rcvbulkpipe(usbdev,
data_desc->endpoint[0].desc.bEndpointAddress);
pipe->tx_pipe = usb_sndbulkpipe(usbdev,
data_desc->endpoint[1].desc.bEndpointAddress);
pipe->rx_buf_size = 1024*4;
} else {
pipe->rx_pipe = usb_rcvbulkpipe(usbdev,
data_desc->endpoint[1].desc.bEndpointAddress);
pipe->tx_pipe = usb_sndbulkpipe(usbdev,
data_desc->endpoint[0].desc.bEndpointAddress);
pipe->rx_buf_size = 1024*4;
}
if (i == 0) {
dev_info(&usbdev->dev, "USB IF USB device found\n");
} else {
err = usb_driver_claim_interface(&if_usb_driver,
data_intf, usb_ld);
if (err < 0) {
mif_err("failed to cliam usb interface\n");
goto out;
}
}
usb_set_intfdata(data_intf, usb_ld);
usb_ld->dev_count++;
pm_suspend_ignore_children(&data_intf->dev, true);
for (j = 0; j < URB_COUNT; j++) {
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb) {
mif_err("alloc urb fail\n");
err = -ENOMEM;
goto out2;
}
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
urb->transfer_buffer = usb_alloc_coherent(usbdev,
pipe->rx_buf_size, GFP_KERNEL,
&urb->transfer_dma);
if (!urb->transfer_buffer) {
mif_err(
"Failed to allocate transfer buffer\n");
usb_free_urb(urb);
err = -ENOMEM;
goto out2;
}
usb_fill_bulk_urb(urb, usbdev, pipe->rx_pipe,
urb->transfer_buffer, pipe->rx_buf_size,
usb_rx_complete, pipe);
usb_anchor_urb(urb, &pipe->urbs);
}
}
/* temporary call reset_resume */
atomic_set(&usb_ld->suspend_count, 1);
if_usb_reset_resume(data_intf);
atomic_set(&usb_ld->suspend_count, 0);
SET_HOST_ACTIVE(usb_ld->pdata, 1);
usb_ld->host_wake_timeout_flag = 0;
if (gpio_get_value(usb_ld->pdata->gpio_phone_active)) {
struct link_pm_data *pm_data = usb_ld->link_pm_data;
int delay = pm_data->autosuspend_delay_ms ?:
DEFAULT_AUTOSUSPEND_DELAY_MS;
pm_runtime_set_autosuspend_delay(&usbdev->dev, delay);
dev = &usbdev->dev;
if (dev->parent) {
dev_dbg(&usbdev->dev, "if_usb Runtime PM Start!!\n");
usb_enable_autosuspend(usb_ld->usbdev);
/* s5p-ehci runtime pm allow - usb phy suspend mode */
root_hub = &usbdev->bus->root_hub->dev;
ehci_dev = root_hub->parent;
mif_debug("ehci device = %s, %s\n",
dev_driver_string(ehci_dev),
dev_name(ehci_dev));
pm_runtime_allow(ehci_dev);
if (!pm_data->autosuspend)
pm_runtime_forbid(dev);
if (has_hub(usb_ld))
link_pm_preactive(pm_data);
pm_data->root_hub = root_hub;
}
usb_ld->flow_suspend = 0;
/* Queue work if skbs were pending before a disconnect/probe */
if (ld->sk_fmt_tx_q.qlen || ld->sk_raw_tx_q.qlen)
queue_delayed_work(ld->tx_wq, &ld->tx_delayed_work, 0);
usb_ld->if_usb_connected = 1;
/*USB3503*/
mif_debug("hub active complete\n");
usb_change_modem_state(usb_ld, STATE_ONLINE);
} else {
static mali_error gpu_device_runtime_init(struct kbase_device *kbdev)
{
pm_suspend_ignore_children(kbdev->osdev.dev, true);
return MALI_ERROR_NONE;
}
static int sdhci_pxav3_probe(struct platform_device *pdev)
{
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
struct device *dev = &pdev->dev;
struct device_node *np = pdev->dev.of_node;
struct sdhci_host *host = NULL;
struct sdhci_pxa *pxa = NULL;
const struct of_device_id *match;
int ret;
host = sdhci_pltfm_init(pdev, &sdhci_pxav3_pdata, sizeof(*pxa));
if (IS_ERR(host))
return PTR_ERR(host);
pltfm_host = sdhci_priv(host);
pxa = sdhci_pltfm_priv(pltfm_host);
pxa->clk_io = devm_clk_get(dev, "io");
if (IS_ERR(pxa->clk_io))
pxa->clk_io = devm_clk_get(dev, NULL);
if (IS_ERR(pxa->clk_io)) {
dev_err(dev, "failed to get io clock\n");
ret = PTR_ERR(pxa->clk_io);
goto err_clk_get;
}
pltfm_host->clk = pxa->clk_io;
clk_prepare_enable(pxa->clk_io);
pxa->clk_core = devm_clk_get(dev, "core");
if (!IS_ERR(pxa->clk_core))
clk_prepare_enable(pxa->clk_core);
/* enable 1/8V DDR capable */
host->mmc->caps |= MMC_CAP_1_8V_DDR;
if (of_device_is_compatible(np, "marvell,armada-380-sdhci")) {
ret = armada_38x_quirks(pdev, host);
if (ret < 0)
goto err_mbus_win;
ret = mv_conf_mbus_windows(pdev, mv_mbus_dram_info());
if (ret < 0)
goto err_mbus_win;
}
match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
if (match) {
ret = mmc_of_parse(host->mmc);
if (ret)
goto err_of_parse;
sdhci_get_of_property(pdev);
pdata = pxav3_get_mmc_pdata(dev);
pdev->dev.platform_data = pdata;
} else if (pdata) {
/* on-chip device */
if (pdata->flags & PXA_FLAG_CARD_PERMANENT)
host->mmc->caps |= MMC_CAP_NONREMOVABLE;
/* If slot design supports 8 bit data, indicate this to MMC. */
if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
host->mmc->caps |= MMC_CAP_8_BIT_DATA;
if (pdata->quirks)
host->quirks |= pdata->quirks;
if (pdata->quirks2)
host->quirks2 |= pdata->quirks2;
if (pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
if (pdata->host_caps2)
host->mmc->caps2 |= pdata->host_caps2;
if (pdata->pm_caps)
host->mmc->pm_caps |= pdata->pm_caps;
if (gpio_is_valid(pdata->ext_cd_gpio)) {
ret = mmc_gpio_request_cd(host->mmc, pdata->ext_cd_gpio,
0);
if (ret) {
dev_err(mmc_dev(host->mmc),
"failed to allocate card detect gpio\n");
goto err_cd_req;
}
}
}
pm_runtime_get_noresume(&pdev->dev);
pm_runtime_set_active(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, PXAV3_RPM_DELAY_MS);
pm_runtime_use_autosuspend(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
ret = sdhci_add_host(host);
if (ret) {
dev_err(&pdev->dev, "failed to add host\n");
goto err_add_host;
}
platform_set_drvdata(pdev, host);
if (host->mmc->pm_caps & MMC_PM_WAKE_SDIO_IRQ)
device_init_wakeup(&pdev->dev, 1);
pm_runtime_put_autosuspend(&pdev->dev);
return 0;
err_add_host:
pm_runtime_disable(&pdev->dev);
pm_runtime_put_noidle(&pdev->dev);
err_of_parse:
err_cd_req:
err_mbus_win:
clk_disable_unprepare(pxa->clk_io);
clk_disable_unprepare(pxa->clk_core);
err_clk_get:
sdhci_pltfm_free(pdev);
return ret;
}
static void mmc_host_suspend_ignore_children(struct device *dev, bool enable)
{
pm_suspend_ignore_children(dev, enable);
}
static int __devinit sdhci_sprd_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct sdhci_host *host;
struct resource *res;
int ret, irq;
#ifdef CONFIG_MMC_CARD_HOTPLUG
int sd_detect_gpio;
int *sd_detect;
int detect_irq;
#endif
struct sprd_host_data *host_data;
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(dev, "no irq specified\n");
return irq;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
dev_err(dev, "no memory specified\n");
return -ENOENT;
}
host = sdhci_alloc_host(dev, sizeof(struct sprd_host_data));
if (IS_ERR(host)) {
dev_err(dev, "sdhci_alloc_host() failed\n");
return PTR_ERR(host);
}
host_data = sdhci_priv(host);
host_data->clk_enable = 1;
platform_set_drvdata(pdev, host);
host->vmmc = NULL;
host->ioaddr = (void __iomem *)res->start;
pr_debug("sdio: host->ioaddr:0x%x\n", (unsigned int)host->ioaddr);
if (0 == pdev->id){
host->hw_name = "Spread SDIO host0";
}else if(1 == pdev->id){
host->hw_name = "Spread SDIO host1";
}
else if(2 == pdev->id){
host->hw_name = "Spread SDIO host2";
}
else if(3 == pdev->id){
host->hw_name = "Spread EMMC host0";
host->mmc->caps |= MMC_CAP_8_BIT_DATA /*| MMC_CAP_1_8V_DDR*/;
}
host->ops = &sdhci_sprd_ops;
/*
* SC8810G don't have timeout value and cann't find card
*insert, write protection...
* too sad
*/
host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |\
SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |\
SDHCI_QUIRK_BROKEN_CARD_DETECTION|\
SDHCI_QUIRK_INVERTED_WRITE_PROTECT;
host->irq = irq;
#ifdef CONFIG_MMC_CARD_HOTPLUG
gpio_detect = 777;
sd_detect = dev_get_platdata(dev);
if(sd_detect && (*sd_detect > 0)){
sd_detect_gpio = *sd_detect;
pr_info("%s, sd_detect_gpio:%d\n", __func__, sd_detect_gpio);
if (0 == pdev->id){
ret = gpio_request(sd_detect_gpio, "sdio0_detect");
}else{
ret = gpio_request(sd_detect_gpio, "sdio1_detect");
}
gpio_export( sd_detect_gpio, 1);
if (ret) {
dev_err(dev, "cannot request gpio\n");
return -1;
}
ret = gpio_direction_input(sd_detect_gpio);
if (ret) {
dev_err(dev, "gpio can not change to input\n");
return -1;
}
detect_irq = gpio_to_irq(sd_detect_gpio);
if (detect_irq < 0){
dev_err(dev, "cannot alloc detect irq\n");
return -1;
}
gpio_detect = sd_detect_gpio;
host_data->detect_irq = detect_irq;
}else{
printk("%s, sd_detect_gpio == 0 \n", __func__ );
}
#endif
if (sd_detection_cmd_dev == NULL)
{
sd_detection_cmd_dev = device_create(sec_class, NULL, 0, NULL, "sdcard");
if (IS_ERR(sd_detection_cmd_dev))
pr_err("Fail to create sysfs dev\n");
if (device_create_file(sd_detection_cmd_dev,&dev_attr_status) < 0)
pr_err("Fail to create sysfs file\n");
}
host->clk = NULL;
sdhci_module_init(host);
host->mmc->caps |= MMC_CAP_HW_RESET;
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
host->mmc->pm_caps |= (MMC_PM_KEEP_POWER | MMC_PM_WAKE_SDIO_IRQ);
#ifdef CONFIG_MACH_KYLEW
if(pdev->id == 1){
host->mmc->pm_caps |= MMC_CAP_NONREMOVABLE;
pm_runtime_disable(&(pdev)->dev); /* temprarily disable runtime case because of error arising when turn on*/
} else if(pdev->id == 0) {
host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
pm_runtime_disable(&(pdev)->dev);
}
#elif defined (CONFIG_ARCH_SC7710)
if(pdev->id == 1){
host->mmc->pm_caps |= MMC_CAP_NONREMOVABLE;
// pm_runtime_disable(&(pdev)->dev);
} else if(pdev->id == 2) {
host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
// pm_runtime_disable(&(pdev)->dev);
}
#elif defined (CONFIG_MACH_SP7702)
if(pdev->id == 1){
host->mmc->pm_flags |= MMC_PM_KEEP_POWER;
pm_runtime_disable(&(pdev)->dev);
}
#else
if(pdev->id == 1){
host->mmc->pm_caps |= MMC_CAP_NONREMOVABLE;
}
switch(pdev->id) {
case 1://eMMC
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY ;//| MMC_PM_KEEP_POWER;
host->mmc->caps |= MMC_CAP_NONREMOVABLE | MMC_CAP_1_8V_DDR;
break;
case 0://SD
host->mmc->pm_flags |= MMC_PM_IGNORE_PM_NOTIFY;
break;
default:
break;
}
#endif
ret = sdhci_add_host(host);
if (ret) {
dev_err(dev, "sdhci_add_host() failed\n");
goto err_add_host;
}
#if defined(CONFIG_MACH_KYLEW) || defined(CONFIG_MACH_SP7702)|| defined(CONFIG_MACH_MINT)
sdhci_sprd_fix_controller_1p8v(host);
#endif
#ifdef CONFIG_MMC_BUS_SCAN
if (pdev->id == 1)
sdhci_host_g = host;
#endif
#ifdef CONFIG_PM_RUNTIME
switch(pdev->id) {
case 1:
case 0:
pm_suspend_ignore_children(&pdev->dev, true);
pm_runtime_set_active(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 500);
pm_runtime_use_autosuspend(&pdev->dev);
pm_runtime_enable(&pdev->dev);
default:
break;
}
#endif
return 0;
err_add_host:
#ifdef CONFIG_PM_RUNTIME
pm_runtime_disable(&(pdev)->dev);
pm_runtime_set_suspended(&(pdev)->dev);
#endif
if (host_data->clk_enable) {
clk_disable(host->clk);
host_data->clk_enable = 0;
}
sdhci_free_host(host);
return ret;
}
static int sdhci_pxav3_probe(struct platform_device *pdev)
{
struct sdhci_pltfm_host *pltfm_host;
struct sdhci_pxa_platdata *pdata = pdev->dev.platform_data;
struct device *dev = &pdev->dev;
struct sdhci_host *host = NULL;
struct sdhci_pxa *pxa = NULL;
const struct of_device_id *match;
int ret;
struct clk *clk;
pxa = kzalloc(sizeof(struct sdhci_pxa), GFP_KERNEL);
if (!pxa)
return -ENOMEM;
host = sdhci_pltfm_init(pdev, &sdhci_pxav3_pdata);
if (IS_ERR(host)) {
kfree(pxa);
return PTR_ERR(host);
}
pltfm_host = sdhci_priv(host);
pltfm_host->priv = pxa;
clk = clk_get(dev, NULL);
if (IS_ERR(clk)) {
dev_err(dev, "failed to get io clock\n");
ret = PTR_ERR(clk);
goto err_clk_get;
}
pltfm_host->clk = clk;
clk_prepare_enable(clk);
/* enable 1/8V DDR capable */
host->mmc->caps |= MMC_CAP_1_8V_DDR;
match = of_match_device(of_match_ptr(sdhci_pxav3_of_match), &pdev->dev);
if (match) {
mmc_of_parse(host->mmc);
sdhci_get_of_property(pdev);
pdata = pxav3_get_mmc_pdata(dev);
} else if (pdata) {
/* on-chip device */
if (pdata->flags & PXA_FLAG_CARD_PERMANENT)
host->mmc->caps |= MMC_CAP_NONREMOVABLE;
/* If slot design supports 8 bit data, indicate this to MMC. */
if (pdata->flags & PXA_FLAG_SD_8_BIT_CAPABLE_SLOT)
host->mmc->caps |= MMC_CAP_8_BIT_DATA;
if (pdata->quirks)
host->quirks |= pdata->quirks;
if (pdata->quirks2)
host->quirks2 |= pdata->quirks2;
if (pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
if (pdata->host_caps2)
host->mmc->caps2 |= pdata->host_caps2;
if (pdata->pm_caps)
host->mmc->pm_caps |= pdata->pm_caps;
if (gpio_is_valid(pdata->ext_cd_gpio)) {
ret = mmc_gpio_request_cd(host->mmc, pdata->ext_cd_gpio);
if (ret) {
dev_err(mmc_dev(host->mmc),
"failed to allocate card detect gpio\n");
goto err_cd_req;
}
}
}
pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, PXAV3_RPM_DELAY_MS);
pm_runtime_use_autosuspend(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
pm_runtime_get_noresume(&pdev->dev);
ret = sdhci_add_host(host);
if (ret) {
dev_err(&pdev->dev, "failed to add host\n");
pm_runtime_forbid(&pdev->dev);
pm_runtime_disable(&pdev->dev);
goto err_add_host;
}
platform_set_drvdata(pdev, host);
if (host->mmc->pm_caps & MMC_PM_KEEP_POWER) {
device_init_wakeup(&pdev->dev, 1);
host->mmc->pm_flags |= MMC_PM_WAKE_SDIO_IRQ;
} else {
device_init_wakeup(&pdev->dev, 0);
}
pm_runtime_put_autosuspend(&pdev->dev);
return 0;
err_add_host:
clk_disable_unprepare(clk);
clk_put(clk);
err_cd_req:
err_clk_get:
sdhci_pltfm_free(pdev);
kfree(pxa);
return ret;
}
static int sdhci_acpi_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
acpi_handle handle = ACPI_HANDLE(dev);
struct acpi_device *device;
struct sdhci_acpi_host *c;
struct sdhci_host *host;
struct resource *iomem;
resource_size_t len;
const char *hid;
const char *uid;
int err;
if (acpi_bus_get_device(handle, &device))
return -ENODEV;
if (acpi_bus_get_status(device) || !device->status.present)
return -ENODEV;
hid = acpi_device_hid(device);
uid = device->pnp.unique_id;
iomem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!iomem)
return -ENOMEM;
len = resource_size(iomem);
if (len < 0x100)
dev_err(dev, "Invalid iomem size!\n");
if (!devm_request_mem_region(dev, iomem->start, len, dev_name(dev)))
return -ENOMEM;
host = sdhci_alloc_host(dev, sizeof(struct sdhci_acpi_host));
if (IS_ERR(host))
return PTR_ERR(host);
c = sdhci_priv(host);
c->host = host;
c->slot = sdhci_acpi_get_slot(hid, uid);
c->pdev = pdev;
c->use_runtime_pm = sdhci_acpi_flag(c, SDHCI_ACPI_RUNTIME_PM);
platform_set_drvdata(pdev, c);
host->hw_name = "ACPI";
host->ops = &sdhci_acpi_ops_dflt;
host->irq = platform_get_irq(pdev, 0);
host->ioaddr = devm_ioremap_nocache(dev, iomem->start,
resource_size(iomem));
if (host->ioaddr == NULL) {
err = -ENOMEM;
goto err_free;
}
if (c->slot) {
if (c->slot->probe_slot) {
err = c->slot->probe_slot(pdev, hid, uid);
if (err)
goto err_free;
}
if (c->slot->chip) {
host->ops = c->slot->chip->ops;
host->quirks |= c->slot->chip->quirks;
host->quirks2 |= c->slot->chip->quirks2;
host->mmc->caps |= c->slot->chip->caps;
host->mmc->caps2 |= c->slot->chip->caps2;
host->mmc->pm_caps |= c->slot->chip->pm_caps;
}
host->quirks |= c->slot->quirks;
host->quirks2 |= c->slot->quirks2;
host->mmc->caps |= c->slot->caps;
host->mmc->caps2 |= c->slot->caps2;
host->mmc->pm_caps |= c->slot->pm_caps;
}
host->mmc->caps2 |= MMC_CAP2_NO_PRESCAN_POWERUP;
if (sdhci_acpi_flag(c, SDHCI_ACPI_SD_CD)) {
bool v = sdhci_acpi_flag(c, SDHCI_ACPI_SD_CD_OVERRIDE_LEVEL);
if (mmc_gpiod_request_cd(host->mmc, NULL, 0, v, 0, NULL)) {
dev_warn(dev, "failed to setup card detect gpio\n");
c->use_runtime_pm = false;
}
}
err = sdhci_add_host(host);
if (err)
goto err_free;
if (c->use_runtime_pm) {
pm_runtime_set_active(dev);
pm_suspend_ignore_children(dev, 1);
pm_runtime_set_autosuspend_delay(dev, 50);
pm_runtime_use_autosuspend(dev);
pm_runtime_enable(dev);
}
return 0;
err_free:
sdhci_free_host(c->host);
return err;
}
static int sdhci_s3c_probe(struct platform_device *pdev)
{
struct s3c_sdhci_platdata *pdata;
struct sdhci_s3c_drv_data *drv_data;
struct device *dev = &pdev->dev;
struct sdhci_host *host;
struct sdhci_s3c *sc;
struct resource *res;
int ret, irq, ptr, clks;
if (!pdev->dev.platform_data && !pdev->dev.of_node) {
dev_err(dev, "no device data specified\n");
return -ENOENT;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(dev, "no irq specified\n");
return irq;
}
host = sdhci_alloc_host(dev, sizeof(struct sdhci_s3c));
if (IS_ERR(host)) {
dev_err(dev, "sdhci_alloc_host() failed\n");
return PTR_ERR(host);
}
sc = sdhci_priv(host);
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
ret = -ENOMEM;
goto err_pdata_io_clk;
}
if (pdev->dev.of_node) {
ret = sdhci_s3c_parse_dt(&pdev->dev, host, pdata);
if (ret)
goto err_pdata_io_clk;
} else {
memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
sc->ext_cd_gpio = -1; /* invalid gpio number */
}
drv_data = sdhci_s3c_get_driver_data(pdev);
sc->host = host;
sc->pdev = pdev;
sc->pdata = pdata;
platform_set_drvdata(pdev, host);
sc->clk_io = devm_clk_get(dev, "hsmmc");
if (IS_ERR(sc->clk_io)) {
dev_err(dev, "failed to get io clock\n");
ret = PTR_ERR(sc->clk_io);
goto err_pdata_io_clk;
}
/* enable the local io clock and keep it running for the moment. */
clk_prepare_enable(sc->clk_io);
for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
struct clk *clk;
char name[14];
snprintf(name, 14, "mmc_busclk.%d", ptr);
clk = devm_clk_get(dev, name);
if (IS_ERR(clk))
continue;
clks++;
sc->clk_bus[ptr] = clk;
/*
* save current clock index to know which clock bus
* is used later in overriding functions.
*/
sc->cur_clk = ptr;
dev_info(dev, "clock source %d: %s (%ld Hz)\n",
ptr, name, clk_get_rate(clk));
}
if (clks == 0) {
dev_err(dev, "failed to find any bus clocks\n");
ret = -ENOENT;
goto err_no_busclks;
}
#ifndef CONFIG_PM_RUNTIME
clk_prepare_enable(sc->clk_bus[sc->cur_clk]);
#endif
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
host->ioaddr = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(host->ioaddr)) {
ret = PTR_ERR(host->ioaddr);
goto err_req_regs;
}
/* Ensure we have minimal gpio selected CMD/CLK/Detect */
if (pdata->cfg_gpio)
pdata->cfg_gpio(pdev, pdata->max_width);
host->hw_name = "samsung-hsmmc";
host->ops = &sdhci_s3c_ops;
host->quirks = 0;
host->irq = irq;
/* Setup quirks for the controller */
host->quirks |= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC;
host->quirks |= SDHCI_QUIRK_NO_HISPD_BIT;
if (drv_data)
host->quirks |= drv_data->sdhci_quirks;
#ifndef CONFIG_MMC_SDHCI_S3C_DMA
/* we currently see overruns on errors, so disable the SDMA
* support as well. */
host->quirks |= SDHCI_QUIRK_BROKEN_DMA;
#endif /* CONFIG_MMC_SDHCI_S3C_DMA */
/* It seems we do not get an DATA transfer complete on non-busy
* transfers, not sure if this is a problem with this specific
* SDHCI block, or a missing configuration that needs to be set. */
host->quirks |= SDHCI_QUIRK_NO_BUSY_IRQ;
/* This host supports the Auto CMD12 */
host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12;
/* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC;
if (pdata->cd_type == S3C_SDHCI_CD_NONE ||
pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT)
host->mmc->caps = MMC_CAP_NONREMOVABLE;
switch (pdata->max_width) {
case 8:
host->mmc->caps |= MMC_CAP_8_BIT_DATA;
case 4:
host->mmc->caps |= MMC_CAP_4_BIT_DATA;
break;
}
if (pdata->pm_caps)
host->mmc->pm_caps |= pdata->pm_caps;
host->quirks |= (SDHCI_QUIRK_32BIT_DMA_ADDR |
SDHCI_QUIRK_32BIT_DMA_SIZE);
/* HSMMC on Samsung SoCs uses SDCLK as timeout clock */
host->quirks |= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK;
/*
* If controller does not have internal clock divider,
* we can use overriding functions instead of default.
*/
if (host->quirks & SDHCI_QUIRK_NONSTANDARD_CLOCK) {
pax_open_kernel();
*(void **)&sdhci_s3c_ops.set_clock = sdhci_cmu_set_clock;
*(void **)&sdhci_s3c_ops.get_min_clock = sdhci_cmu_get_min_clock;
*(void **)&sdhci_s3c_ops.get_max_clock = sdhci_cmu_get_max_clock;
pax_close_kernel();
}
/* It supports additional host capabilities if needed */
if (pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
if (pdata->host_caps2)
host->mmc->caps2 |= pdata->host_caps2;
pm_runtime_enable(&pdev->dev);
pm_runtime_set_autosuspend_delay(&pdev->dev, 50);
pm_runtime_use_autosuspend(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
ret = sdhci_add_host(host);
if (ret) {
dev_err(dev, "sdhci_add_host() failed\n");
pm_runtime_forbid(&pdev->dev);
pm_runtime_get_noresume(&pdev->dev);
goto err_req_regs;
}
/* The following two methods of card detection might call
sdhci_s3c_notify_change() immediately, so they can be called
only after sdhci_add_host(). Setup errors are ignored. */
if (pdata->cd_type == S3C_SDHCI_CD_EXTERNAL && pdata->ext_cd_init)
pdata->ext_cd_init(&sdhci_s3c_notify_change);
if (pdata->cd_type == S3C_SDHCI_CD_GPIO &&
gpio_is_valid(pdata->ext_cd_gpio))
sdhci_s3c_setup_card_detect_gpio(sc);
#ifdef CONFIG_PM_RUNTIME
if (pdata->cd_type != S3C_SDHCI_CD_INTERNAL)
clk_disable_unprepare(sc->clk_io);
#endif
return 0;
err_req_regs:
#ifndef CONFIG_PM_RUNTIME
clk_disable_unprepare(sc->clk_bus[sc->cur_clk]);
#endif
err_no_busclks:
clk_disable_unprepare(sc->clk_io);
err_pdata_io_clk:
sdhci_free_host(host);
return ret;
}
static mali_error pm_callback_runtime_init(struct kbase_device *kbdev)
{
pm_suspend_ignore_children(kbdev->dev, true);
pm_runtime_enable(kbdev->dev);
return MALI_ERROR_NONE;
}
static int smdhsic_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
int devid = -1;
int err;
const struct usb_cdc_union_desc *union_header = NULL;
const struct usb_host_interface *data_desc;
struct usb_interface *data_intf;
struct usb_device *usbdev;
struct str_intf_priv *intfpriv = NULL;
struct usb_driver *driver;
struct str_smdipc *smdipc;
struct str_hsic *hsic;
u8 *data;
int len;
pr_info("%s: Enter\n", __func__);
usbdev = interface_to_usbdev(intf);
g_usbdev.usbdev = usbdev;
driver = get_usb_driver(intf);
data = intf->altsetting->extra;
len = intf->altsetting->extralen;
if (!len) {
if (intf->cur_altsetting->endpoint->extralen &&
intf->cur_altsetting->endpoint->extra) {
pr_debug(
"%s: Seeking extra descriptors on endpoint\n",
__func__);
len = intf->cur_altsetting->endpoint->extralen;
data = intf->cur_altsetting->endpoint->extra;
} else {
pr_err(
"%s: Zero length descriptor reference\n",
__func__);
return -EINVAL;
}
}
if (!len) {
pr_err("%s: Zero length descriptor reference\n",
__func__);
return -EINVAL;
}
while (len > 0) {
if (data[1] == USB_DT_CS_INTERFACE) {
switch (data[2]) {
case USB_CDC_UNION_TYPE:
if (union_header)
break;
union_header =
(struct usb_cdc_union_desc *)data;
break;
default:
break;
}
}
data += data[0];
len -= data[0];
}
if (!union_header) {
pr_err("%s:USB CDC is not union type\n", __func__);
return -EINVAL;
}
data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);
if (!data_intf) {
pr_err("%s:data_inferface is NULL\n", __func__);
return -ENODEV;
}
data_desc = data_intf->altsetting;
if (!data_desc) {
pr_err("%s:data_desc is NULL\n", __func__);
return -ENODEV;
}
switch (id->driver_info) {
case XMM6260_PSI_DOWN:
pr_warn("%s:XMM6260_PSI_DOWN\n", __func__);
intfpriv = smd_create_dev(data_intf, usbdev,
data_desc, DOWN_DEV_ID);
break;
case XMM6260_BIN_DOWN:
intfpriv = smd_create_dev(data_intf, usbdev,
data_desc, DOWN_DEV_ID);
break;
case XMM6260_CHANNEL:
devid = intf->altsetting->desc.bInterfaceNumber / 2;
intfpriv = smd_create_dev(data_intf, usbdev, data_desc, devid);
break;
default:
pr_err("%s: Undefined driver_info: %lu\n",
__func__, id->driver_info);
break;
}
if (!intfpriv) {
pr_err("%s:smd_create_dev() failed\n", __func__);
return -EINVAL;
}
err = usb_driver_claim_interface(driver, data_intf, intfpriv);
if (err < 0) {
pr_err("%s:usb_driver_claim() failed\n", __func__);
return err;
}
/* to start runtime pm with AP initiated L2 */
if (usb_runtime_pm_ap_initiated_L2) {
usbdev->autosuspend_delay = msecs_to_jiffies(200);
if (devid == FMT_DEV_ID) {
smdipc = (struct str_smdipc *)intfpriv->data;
hsic = &smdipc->hsic;
g_usbdev.hsic = hsic;
g_usbdev.hsic->dpm_suspending = false;
g_usbdev.suspended = 0;
INIT_DELAYED_WORK(&hsic->pm_runtime_work,
smdhsic_pm_runtime_start);
schedule_delayed_work(&hsic->pm_runtime_work,
msecs_to_jiffies(10000));
}
} else
usbdev->autosuspend_delay = 0;
intfpriv->devid |= ID_BIND;
usb_set_intfdata(intf, intfpriv);
pm_suspend_ignore_children(&usbdev->dev, true);
return 0;
}
/*
****************************************************************************
* - Device operation such as;
* probe, init/exit, remove
****************************************************************************
*/
static int __devinit lm3561_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct lm3561_platform_data *pdata = client->dev.platform_data;
struct lm3561_drv_data *data;
int result;
dev_dbg(&client->dev, "%s\n", __func__);
if (!pdata) {
dev_err(&client->dev,
"%s(): failed during init",
__func__);
return -EINVAL;
}
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
dev_err(&client->dev,
"%s(): failed during i2c_check_functionality",
__func__);
return -EIO;
}
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (!data) {
dev_err(&client->dev, "%s(): failed during kzalloc", __func__);
return -ENOMEM;
}
dev_set_drvdata(&client->dev, data);
data->client = client;
data->led_nums = 1;
data->torch_current_shift = 0;
data->flash_current_shift = 0;
if (pdata->current_limit >= 1500000) {
data->reg_flash_duration_limit =
LM3561_FLASH_DURATION_CL_1500MA;
} else if (pdata->current_limit >= 1000000) {
data->reg_flash_duration_limit =
LM3561_FLASH_DURATION_CL_1000MA;
} else {
/* current_limit > 1500000uA || current_limit < 1000000uA */
dev_err(&data->client->dev,
"%s(): current_limit(%luuA) is invalid\n",
__func__, pdata->current_limit);
result = -EINVAL;
goto err_init;
}
mutex_init(&data->lock);
pm_runtime_enable(&client->dev);
pm_suspend_ignore_children(&client->dev, true);
result = pm_runtime_get_sync(&client->dev);
if (result < 0)
goto err_setup;
result = lm3561_chip_init(data, pdata);
if (result) {
dev_err(&client->dev, "%s:chip init error\n", __func__);
goto err_chip_init;
}
result = lm3561_create_sysfs_interfaces(&client->dev);
if (result) {
dev_err(&data->client->dev,
"%s(): create sysfs failed",
__func__);
goto err_chip_init;
}
pm_runtime_set_autosuspend_delay(&client->dev, autosuspend_delay_ms);
pm_runtime_use_autosuspend(&client->dev);
pm_runtime_mark_last_busy(&data->client->dev);
pm_runtime_put_autosuspend(&data->client->dev);
dev_info(&data->client->dev, "%s: loaded\n", __func__);
return 0;
err_chip_init:
pm_runtime_suspend(&client->dev);
err_setup:
pm_runtime_disable(&client->dev);
if (pdata->platform_init)
pdata->platform_init(&client->dev, 0);
err_init:
dev_set_drvdata(&client->dev, NULL);
kfree(data);
dev_err(&client->dev,
"%s: failed with code %d.\n", __func__, result);
return result;
}
int usbsvn_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
const struct usb_cdc_union_desc *union_header = NULL;
const struct usb_host_interface *data_desc;
static struct usbsvn *svn;
struct usb_interface *data_intf;
struct usb_device *usbdev = interface_to_usbdev(intf);
u8 *data = intf->altsetting->extra;
int len = intf->altsetting->extralen;
int dev_id;
int err;
if (!share_svn) {
printk(KERN_ERR "%s: netdev not registed\n", __func__);
return -EINVAL;
}
svn = share_svn;
if (!len) {
if (intf->cur_altsetting->endpoint->extralen &&
intf->cur_altsetting->endpoint->extra) {
dev_dbg(&intf->dev,
"Seeking extra descriptors on endpoint\n");
len = intf->cur_altsetting->endpoint->extralen;
data = intf->cur_altsetting->endpoint->extra;
} else {
dev_err(&intf->dev,
"Zero length descriptor references\n");
return -EINVAL;
}
}
while (len > 0) {
/* bDescriptorType */
if (data[1] == USB_DT_CS_INTERFACE) {
/* bDescriptorSubType */
switch (data[2]) {
case USB_CDC_UNION_TYPE:
if (union_header)
break;
union_header =
(struct usb_cdc_union_desc *)data;
break;
default:
break;
}
}
data += data[0];
len -= data[0];
}
if (!union_header) {
dev_err(&intf->dev, "USB CDC isn't union type\n");
return -EINVAL;
}
data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);
if (!data_intf)
return -ENODEV;
data_desc = data_intf->altsetting;
/* To detect usb device order probed */
dev_id = intf->altsetting->desc.bInterfaceNumber / 2;
if (dev_id >= USBSVN_DEVNUM_MAX) {
dev_err(&intf->dev, "Device id %d cannot support\n", dev_id);
return -EINVAL;
}
printk(KERN_ERR "%s: probe dev_id=%d\n", __func__, dev_id);
if (dev_id > 0)
goto skip_netdev;
svn->usbdev = usbdev;
svn->driver_info = (unsigned long)id->driver_info;
/* FIXME: Does need this indeed? */
usbdev->autosuspend_delay = msecs_to_jiffies(200); /* 200ms */
if (!svn->driver_info) {
schedule_delayed_work(&svn->pm_runtime_work,
msecs_to_jiffies(10000));
}
svn->usbsvn_connected = 1;
svn->flow_suspend = 0;
skip_netdev:
if (!svn->driver_info) {
svn = share_svn;
if (!svn) {
dev_err(&intf->dev,
"svnet device doesn't be allocated\n");
err = ENOMEM;
goto out;
}
}
usb_get_dev(usbdev);
svn->devdata[dev_id].data_intf = data_intf;
/* Endpoints */
if (usb_pipein(data_desc->endpoint[0].desc.bEndpointAddress)) {
svn->devdata[dev_id].rx_pipe = usb_rcvbulkpipe(usbdev,
data_desc->endpoint[0].desc.bEndpointAddress);
svn->devdata[dev_id].tx_pipe = usb_sndbulkpipe(usbdev,
data_desc->endpoint[1].desc.bEndpointAddress);
} else {
svn->devdata[dev_id].rx_pipe = usb_rcvbulkpipe(usbdev,
data_desc->endpoint[1].desc.bEndpointAddress);
svn->devdata[dev_id].tx_pipe = usb_sndbulkpipe(usbdev,
data_desc->endpoint[0].desc.bEndpointAddress);
}
err = usb_driver_claim_interface(&usbsvn_driver, data_intf, svn);
if (err < 0)
goto out;
usb_set_intfdata(intf, svn);
svn->dev_count++;
if (dev_id == 0)
dev_info(&usbdev->dev, "USB CDC SVNET device found\n");
pm_suspend_ignore_children(&intf->dev, true);
svn->devdata[dev_id].disconnected = 0;
return 0;
out:
usb_set_intfdata(intf, NULL);
return err;
}