static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c *sc)
{
struct s3c_sdhci_platdata *pdata = sc->pdata;
struct device *dev = &sc->pdev->dev;
if (sc->ext_cd_gpio > 0) {
sc->ext_cd_irq = gpio_to_irq(pdata->ext_cd_gpio);
if (sc->ext_cd_irq &&
request_threaded_irq(sc->ext_cd_irq, NULL,
sdhci_s3c_gpio_card_detect_thread,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
dev_name(dev), sc) == 0) {
int status = gpio_get_value(sc->ext_cd_gpio);
if (pdata->ext_cd_gpio_invert)
status = !status;
if (status)
mmc_host_sd_set_present(sc->host->mmc);
else
mmc_host_sd_clear_present(sc->host->mmc);
/* T-Flash EINT for CD SHOULD be wakeup source */
irq_set_irq_wake(sc->ext_cd_irq, 1);
sdhci_s3c_notify_change(sc->pdev, status);
} else {
dev_warn(dev, "cannot request irq for card detect\n");
sc->ext_cd_irq = 0;
}
}
}
static irqreturn_t sdhci_s3c_gpio_card_detect_thread(int irq, void *dev_id)
{
struct sdhci_s3c *sc = dev_id;
int status = gpio_get_value(sc->ext_cd_gpio);
if (sc->pdata->ext_cd_gpio_invert)
status = !status;
if (sc->host->mmc) {
if (status)
mmc_host_sd_set_present(sc->host->mmc);
else
mmc_host_sd_clear_present(sc->host->mmc);
pr_debug("SDcard present state=%d.\n",
mmc_host_sd_present(sc->host->mmc));
}
sdhci_s3c_notify_change(sc->pdev, status);
return IRQ_HANDLED;
}
static int __devinit sdhci_s3c_probe(struct platform_device *pdev)
{
struct s3c_sdhci_platdata *pdata = pdev->dev.platform_data;
struct device *dev = &pdev->dev;
struct sdhci_host *host;
struct sdhci_s3c *sc;
struct resource *res;
int ret, irq, ptr, clks;
if (!pdata) {
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;
}
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 sdhci_s3c));
if (IS_ERR(host)) {
dev_err(dev, "sdhci_alloc_host() failed\n");
return PTR_ERR(host);
}
sc = sdhci_priv(host);
sc->host = host;
sc->pdev = pdev;
sc->pdata = pdata;
sc->ext_cd_gpio = -1;
platform_set_drvdata(pdev, host);
sc->clk_io = 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_io_clk;
}
/* enable the local io clock and keep it running for the moment. */
clk_enable(sc->clk_io);
for (clks = 0, ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
struct clk *clk;
char *name = pdata->clocks[ptr];
if (name == NULL)
continue;
clk = clk_get(dev, name);
if (IS_ERR(clk)) {
dev_err(dev, "failed to get clock %s\n", name);
continue;
}
clks++;
sc->clk_bus[ptr] = clk;
clk_enable(clk);
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;
}
sc->ioarea = request_mem_region(res->start, resource_size(res),
mmc_hostname(host->mmc));
if (!sc->ioarea) {
dev_err(dev, "failed to reserve register area\n");
ret = -ENXIO;
goto err_req_regs;
}
host->ioaddr = ioremap_nocache(res->start, resource_size(res));
if (!host->ioaddr) {
dev_err(dev, "failed to map registers\n");
ret = -ENXIO;
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;
#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;
if (pdata->cd_type == S3C_SDHCI_CD_NONE)
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
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 SD controller's WP pin donsn't connected with SD card and there is an
* allocated GPIO for getting WP data form SD card, use this quirk and send
* the GPIO number in pdata->wp_gpio. */
if (pdata->has_wp_gpio && gpio_is_valid(pdata->wp_gpio)) {
sdhci_s3c_ops.get_ro = sdhci_s3c_get_ro;
host->quirks |= SDHCI_QUIRK_NO_WP_BIT;
sdhci_s3c_cfg_wp(pdata->wp_gpio);
}
host->quirks |= SDHCI_QUIRK_NO_HISPD_BIT;
#ifdef CONFIG_ARCH_S5PV310
host->quirks |= SDHCI_QUIRK_NONSTANDARD_CLOCK;
host->quirks |= SDHCI_QUIRK_BROKEN_CLOCK_DIVIDER;
#endif
mmc_host_sd_set_present(host->mmc);
if(pdata->host_caps)
host->mmc->caps |= pdata->host_caps;
/* if vmmc_name is in pdata */
if (pdata->vmmc_name)
host->vmmc_name = pdata->vmmc_name;
ret = sdhci_add_host(host);
if (ret) {
dev_err(dev, "sdhci_add_host() failed\n");
goto err_add_host;
}
if (pdata->cd_type == S3C_SDHCI_CD_PERMANENT) {
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
host->mmc->caps |= MMC_CAP_NONREMOVABLE;
}
/* pdata->ext_cd_init might call sdhci_s3c_notify_change immediately,
so it can be called only after sdhci_add_host() */
if (pdata->cd_type == S3C_SDHCI_CD_EXTERNAL && pdata->ext_cd_init) {
pdata->ext_cd_init(&sdhci_s3c_notify_change);
#ifndef CONFIG_MACH_P4W_REV00 /* original */
if (pdata->ext_pdev)
pdata->ext_pdev(pdev);
#endif
}
if (pdata->cd_type == S3C_SDHCI_CD_GPIO &&
gpio_is_valid(pdata->ext_cd_gpio)) {
host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION;
gpio_request(pdata->ext_cd_gpio, "SDHCI EXT CD");
sc->ext_cd_gpio = pdata->ext_cd_gpio;
sc->ext_cd_irq = gpio_to_irq(pdata->ext_cd_gpio);
sc->regulator_workq = create_singlethread_workqueue("ktflash_requlatord");
if (!sc->regulator_workq) {
pr_info("%s : ERROR: workqueue for Tflash's regulator.\n"
"Regulator for Tflash will be always ON\n",
__func__);
}
INIT_DELAYED_WORK(&sc->regul_work, sdhci_s3c_requlator_work);
if (sc->ext_cd_irq &&
request_irq(sc->ext_cd_irq, sdhci_s3c_gpio_card_detect_isr,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
dev_name(&pdev->dev), sc)) {
dev_err(&pdev->dev, "cannot request irq for card detect\n");
sc->ext_cd_irq = 0;
} else {
int status = gpio_get_value(sc->ext_cd_gpio);
/* T-Flash EINT for CD SHOULD be wakeup source */
set_irq_wake(sc->ext_cd_irq, 1);
/* disable pull-up/down for detection gpio */
s3c_gpio_setpull(sc->ext_cd_gpio, S3C_GPIO_PULL_NONE);
if (pdata->ext_cd_gpio_invert)
status = !status;
if (status)
mmc_host_sd_set_present(host->mmc);
else
mmc_host_sd_clear_present(host->mmc);
sdhci_s3c_notify_change(sc->pdev, status);
}
if (tflash_detection_cmd_dev == NULL && sc->ext_cd_gpio) {
tflash_detection_cmd_dev = device_create(sec_class, NULL, 0, NULL, "tctest");
if (IS_ERR(tflash_detection_cmd_dev))
pr_err("%s : Failed to create device(ts)!\n", __func__);
if (device_create_file(tflash_detection_cmd_dev, &dev_attr_tftest) < 0)
pr_err("%s : Failed to create device file(%s)!\n", __func__, dev_attr_tftest.attr.name);
dev_set_drvdata(tflash_detection_cmd_dev, sc);
}
}
return 0;
err_add_host:
release_resource(sc->ioarea);
kfree(sc->ioarea);
err_req_regs:
for (ptr = 0; ptr < MAX_BUS_CLK; ptr++) {
clk_disable(sc->clk_bus[ptr]);
clk_put(sc->clk_bus[ptr]);
}
err_no_busclks:
clk_disable(sc->clk_io);
clk_put(sc->clk_io);
err_io_clk:
sdhci_free_host(host);
return ret;
}