1 /* linux/drivers/mmc/host/sdhci-s3c.c
3 * Copyright 2008 Openmoko Inc.
4 * Copyright 2008 Simtec Electronics
5 * Ben Dooks <ben@simtec.co.uk>
6 * http://armlinux.simtec.co.uk/
8 * SDHCI (HSMMC) support for Samsung SoC
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/delay.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/platform_device.h>
18 #include <linux/platform_data/mmc-sdhci-s3c.h>
19 #include <linux/slab.h>
20 #include <linux/clk.h>
22 #include <linux/gpio.h>
23 #include <linux/module.h>
25 #include <linux/of_gpio.h>
27 #include <linux/pm_runtime.h>
29 #include <linux/mmc/host.h>
31 #include "sdhci-s3c-regs.h"
34 #define MAX_BUS_CLK (4)
37 * struct sdhci_s3c - S3C SDHCI instance
38 * @host: The SDHCI host created
39 * @pdev: The platform device we where created from.
40 * @ioarea: The resource created when we claimed the IO area.
41 * @pdata: The platform data for this controller.
42 * @cur_clk: The index of the current bus clock.
43 * @clk_io: The clock for the internal bus interface.
44 * @clk_bus: The clocks that are available for the SD/MMC bus clock.
47 struct sdhci_host
*host
;
48 struct platform_device
*pdev
;
49 struct resource
*ioarea
;
50 struct s3c_sdhci_platdata
*pdata
;
56 struct clk
*clk_bus
[MAX_BUS_CLK
];
57 unsigned long clk_rates
[MAX_BUS_CLK
];
61 * struct sdhci_s3c_driver_data - S3C SDHCI platform specific driver data
62 * @sdhci_quirks: sdhci host specific quirks.
64 * Specifies platform specific configuration of sdhci controller.
65 * Note: A structure for driver specific platform data is used for future
66 * expansion of its usage.
68 struct sdhci_s3c_drv_data
{
69 unsigned int sdhci_quirks
;
72 static inline struct sdhci_s3c
*to_s3c(struct sdhci_host
*host
)
74 return sdhci_priv(host
);
78 * sdhci_s3c_get_max_clk - callback to get maximum clock frequency.
79 * @host: The SDHCI host instance.
81 * Callback to return the maximum clock rate acheivable by the controller.
83 static unsigned int sdhci_s3c_get_max_clk(struct sdhci_host
*host
)
85 struct sdhci_s3c
*ourhost
= to_s3c(host
);
86 unsigned long rate
, max
= 0;
89 for (src
= 0; src
< MAX_BUS_CLK
; src
++) {
90 rate
= ourhost
->clk_rates
[src
];
99 * sdhci_s3c_consider_clock - consider one the bus clocks for current setting
100 * @ourhost: Our SDHCI instance.
101 * @src: The source clock index.
102 * @wanted: The clock frequency wanted.
104 static unsigned int sdhci_s3c_consider_clock(struct sdhci_s3c
*ourhost
,
109 struct clk
*clksrc
= ourhost
->clk_bus
[src
];
116 * If controller uses a non-standard clock division, find the best clock
117 * speed possible with selected clock source and skip the division.
119 if (ourhost
->host
->quirks
& SDHCI_QUIRK_NONSTANDARD_CLOCK
) {
120 rate
= clk_round_rate(clksrc
, wanted
);
121 return wanted
- rate
;
124 rate
= ourhost
->clk_rates
[src
];
126 for (shift
= 0; shift
<= 8; ++shift
) {
127 if ((rate
>> shift
) <= wanted
)
132 dev_dbg(&ourhost
->pdev
->dev
,
133 "clk %d: rate %ld, min rate %lu > wanted %u\n",
134 src
, rate
, rate
/ 256, wanted
);
138 dev_dbg(&ourhost
->pdev
->dev
, "clk %d: rate %ld, want %d, got %ld\n",
139 src
, rate
, wanted
, rate
>> shift
);
141 return wanted
- (rate
>> shift
);
145 * sdhci_s3c_set_clock - callback on clock change
146 * @host: The SDHCI host being changed
147 * @clock: The clock rate being requested.
149 * When the card's clock is going to be changed, look at the new frequency
150 * and find the best clock source to go with it.
152 static void sdhci_s3c_set_clock(struct sdhci_host
*host
, unsigned int clock
)
154 struct sdhci_s3c
*ourhost
= to_s3c(host
);
155 unsigned int best
= UINT_MAX
;
161 /* don't bother if the clock is going off. */
165 for (src
= 0; src
< MAX_BUS_CLK
; src
++) {
166 delta
= sdhci_s3c_consider_clock(ourhost
, src
, clock
);
173 dev_dbg(&ourhost
->pdev
->dev
,
174 "selected source %d, clock %d, delta %d\n",
175 best_src
, clock
, best
);
177 /* select the new clock source */
178 if (ourhost
->cur_clk
!= best_src
) {
179 struct clk
*clk
= ourhost
->clk_bus
[best_src
];
181 clk_prepare_enable(clk
);
182 if (ourhost
->cur_clk
>= 0)
183 clk_disable_unprepare(
184 ourhost
->clk_bus
[ourhost
->cur_clk
]);
186 ourhost
->cur_clk
= best_src
;
187 host
->max_clk
= ourhost
->clk_rates
[best_src
];
190 /* turn clock off to card before changing clock source */
191 writew(0, host
->ioaddr
+ SDHCI_CLOCK_CONTROL
);
193 ctrl
= readl(host
->ioaddr
+ S3C_SDHCI_CONTROL2
);
194 ctrl
&= ~S3C_SDHCI_CTRL2_SELBASECLK_MASK
;
195 ctrl
|= best_src
<< S3C_SDHCI_CTRL2_SELBASECLK_SHIFT
;
196 writel(ctrl
, host
->ioaddr
+ S3C_SDHCI_CONTROL2
);
198 /* reprogram default hardware configuration */
199 writel(S3C64XX_SDHCI_CONTROL4_DRIVE_9mA
,
200 host
->ioaddr
+ S3C64XX_SDHCI_CONTROL4
);
202 ctrl
= readl(host
->ioaddr
+ S3C_SDHCI_CONTROL2
);
203 ctrl
|= (S3C64XX_SDHCI_CTRL2_ENSTAASYNCCLR
|
204 S3C64XX_SDHCI_CTRL2_ENCMDCNFMSK
|
205 S3C_SDHCI_CTRL2_ENFBCLKRX
|
206 S3C_SDHCI_CTRL2_DFCNT_NONE
|
207 S3C_SDHCI_CTRL2_ENCLKOUTHOLD
);
208 writel(ctrl
, host
->ioaddr
+ S3C_SDHCI_CONTROL2
);
210 /* reconfigure the controller for new clock rate */
211 ctrl
= (S3C_SDHCI_CTRL3_FCSEL1
| S3C_SDHCI_CTRL3_FCSEL0
);
212 if (clock
< 25 * 1000000)
213 ctrl
|= (S3C_SDHCI_CTRL3_FCSEL3
| S3C_SDHCI_CTRL3_FCSEL2
);
214 writel(ctrl
, host
->ioaddr
+ S3C_SDHCI_CONTROL3
);
218 * sdhci_s3c_get_min_clock - callback to get minimal supported clock value
219 * @host: The SDHCI host being queried
221 * To init mmc host properly a minimal clock value is needed. For high system
222 * bus clock's values the standard formula gives values out of allowed range.
223 * The clock still can be set to lower values, if clock source other then
224 * system bus is selected.
226 static unsigned int sdhci_s3c_get_min_clock(struct sdhci_host
*host
)
228 struct sdhci_s3c
*ourhost
= to_s3c(host
);
229 unsigned long rate
, min
= ULONG_MAX
;
232 for (src
= 0; src
< MAX_BUS_CLK
; src
++) {
233 rate
= ourhost
->clk_rates
[src
] / 256;
243 /* sdhci_cmu_get_max_clk - callback to get maximum clock frequency.*/
244 static unsigned int sdhci_cmu_get_max_clock(struct sdhci_host
*host
)
246 struct sdhci_s3c
*ourhost
= to_s3c(host
);
247 unsigned long rate
, max
= 0;
250 for (src
= 0; src
< MAX_BUS_CLK
; src
++) {
253 clk
= ourhost
->clk_bus
[src
];
257 rate
= clk_round_rate(clk
, ULONG_MAX
);
265 /* sdhci_cmu_get_min_clock - callback to get minimal supported clock value. */
266 static unsigned int sdhci_cmu_get_min_clock(struct sdhci_host
*host
)
268 struct sdhci_s3c
*ourhost
= to_s3c(host
);
269 unsigned long rate
, min
= ULONG_MAX
;
272 for (src
= 0; src
< MAX_BUS_CLK
; src
++) {
275 clk
= ourhost
->clk_bus
[src
];
279 rate
= clk_round_rate(clk
, 0);
287 /* sdhci_cmu_set_clock - callback on clock change.*/
288 static void sdhci_cmu_set_clock(struct sdhci_host
*host
, unsigned int clock
)
290 struct sdhci_s3c
*ourhost
= to_s3c(host
);
291 struct device
*dev
= &ourhost
->pdev
->dev
;
292 unsigned long timeout
;
295 /* If the clock is going off, set to 0 at clock control register */
297 sdhci_writew(host
, 0, SDHCI_CLOCK_CONTROL
);
302 sdhci_s3c_set_clock(host
, clock
);
304 clk_set_rate(ourhost
->clk_bus
[ourhost
->cur_clk
], clock
);
308 clk
= SDHCI_CLOCK_INT_EN
;
309 sdhci_writew(host
, clk
, SDHCI_CLOCK_CONTROL
);
313 while (!((clk
= sdhci_readw(host
, SDHCI_CLOCK_CONTROL
))
314 & SDHCI_CLOCK_INT_STABLE
)) {
316 dev_err(dev
, "%s: Internal clock never stabilised.\n",
317 mmc_hostname(host
->mmc
));
324 clk
|= SDHCI_CLOCK_CARD_EN
;
325 sdhci_writew(host
, clk
, SDHCI_CLOCK_CONTROL
);
329 * sdhci_s3c_set_bus_width - support 8bit buswidth
330 * @host: The SDHCI host being queried
331 * @width: MMC_BUS_WIDTH_ macro for the bus width being requested
333 * We have 8-bit width support but is not a v3 controller.
334 * So we add platform_bus_width() and support 8bit width.
336 static void sdhci_s3c_set_bus_width(struct sdhci_host
*host
, int width
)
340 ctrl
= sdhci_readb(host
, SDHCI_HOST_CONTROL
);
343 case MMC_BUS_WIDTH_8
:
344 ctrl
|= SDHCI_CTRL_8BITBUS
;
345 ctrl
&= ~SDHCI_CTRL_4BITBUS
;
347 case MMC_BUS_WIDTH_4
:
348 ctrl
|= SDHCI_CTRL_4BITBUS
;
349 ctrl
&= ~SDHCI_CTRL_8BITBUS
;
352 ctrl
&= ~SDHCI_CTRL_4BITBUS
;
353 ctrl
&= ~SDHCI_CTRL_8BITBUS
;
357 sdhci_writeb(host
, ctrl
, SDHCI_HOST_CONTROL
);
360 static struct sdhci_ops sdhci_s3c_ops
= {
361 .get_max_clock
= sdhci_s3c_get_max_clk
,
362 .set_clock
= sdhci_s3c_set_clock
,
363 .get_min_clock
= sdhci_s3c_get_min_clock
,
364 .set_bus_width
= sdhci_s3c_set_bus_width
,
365 .reset
= sdhci_reset
,
368 static void sdhci_s3c_notify_change(struct platform_device
*dev
, int state
)
370 struct sdhci_host
*host
= platform_get_drvdata(dev
);
371 #ifdef CONFIG_PM_RUNTIME
372 struct sdhci_s3c
*sc
= sdhci_priv(host
);
377 spin_lock_irqsave(&host
->lock
, flags
);
379 dev_dbg(&dev
->dev
, "card inserted.\n");
380 #ifdef CONFIG_PM_RUNTIME
381 clk_prepare_enable(sc
->clk_io
);
383 host
->flags
&= ~SDHCI_DEVICE_DEAD
;
384 host
->quirks
|= SDHCI_QUIRK_BROKEN_CARD_DETECTION
;
386 dev_dbg(&dev
->dev
, "card removed.\n");
387 host
->flags
|= SDHCI_DEVICE_DEAD
;
388 host
->quirks
&= ~SDHCI_QUIRK_BROKEN_CARD_DETECTION
;
389 #ifdef CONFIG_PM_RUNTIME
390 clk_disable_unprepare(sc
->clk_io
);
393 tasklet_schedule(&host
->card_tasklet
);
394 spin_unlock_irqrestore(&host
->lock
, flags
);
398 static irqreturn_t
sdhci_s3c_gpio_card_detect_thread(int irq
, void *dev_id
)
400 struct sdhci_s3c
*sc
= dev_id
;
401 int status
= gpio_get_value(sc
->ext_cd_gpio
);
402 if (sc
->pdata
->ext_cd_gpio_invert
)
404 sdhci_s3c_notify_change(sc
->pdev
, status
);
408 static void sdhci_s3c_setup_card_detect_gpio(struct sdhci_s3c
*sc
)
410 struct s3c_sdhci_platdata
*pdata
= sc
->pdata
;
411 struct device
*dev
= &sc
->pdev
->dev
;
413 if (devm_gpio_request(dev
, pdata
->ext_cd_gpio
, "SDHCI EXT CD") == 0) {
414 sc
->ext_cd_gpio
= pdata
->ext_cd_gpio
;
415 sc
->ext_cd_irq
= gpio_to_irq(pdata
->ext_cd_gpio
);
416 if (sc
->ext_cd_irq
&&
417 request_threaded_irq(sc
->ext_cd_irq
, NULL
,
418 sdhci_s3c_gpio_card_detect_thread
,
419 IRQF_TRIGGER_RISING
|
420 IRQF_TRIGGER_FALLING
|
422 dev_name(dev
), sc
) == 0) {
423 int status
= gpio_get_value(sc
->ext_cd_gpio
);
424 if (pdata
->ext_cd_gpio_invert
)
426 sdhci_s3c_notify_change(sc
->pdev
, status
);
428 dev_warn(dev
, "cannot request irq for card detect\n");
432 dev_err(dev
, "cannot request gpio for card detect\n");
437 static int sdhci_s3c_parse_dt(struct device
*dev
,
438 struct sdhci_host
*host
, struct s3c_sdhci_platdata
*pdata
)
440 struct device_node
*node
= dev
->of_node
;
441 struct sdhci_s3c
*ourhost
= to_s3c(host
);
445 /* if the bus-width property is not specified, assume width as 1 */
446 if (of_property_read_u32(node
, "bus-width", &max_width
))
448 pdata
->max_width
= max_width
;
450 /* get the card detection method */
451 if (of_get_property(node
, "broken-cd", NULL
)) {
452 pdata
->cd_type
= S3C_SDHCI_CD_NONE
;
456 if (of_get_property(node
, "non-removable", NULL
)) {
457 pdata
->cd_type
= S3C_SDHCI_CD_PERMANENT
;
461 gpio
= of_get_named_gpio(node
, "cd-gpios", 0);
462 if (gpio_is_valid(gpio
)) {
463 pdata
->cd_type
= S3C_SDHCI_CD_GPIO
;
464 pdata
->ext_cd_gpio
= gpio
;
465 ourhost
->ext_cd_gpio
= -1;
466 if (of_get_property(node
, "cd-inverted", NULL
))
467 pdata
->ext_cd_gpio_invert
= 1;
469 } else if (gpio
!= -ENOENT
) {
470 dev_err(dev
, "invalid card detect gpio specified\n");
474 /* assuming internal card detect that will be configured by pinctrl */
475 pdata
->cd_type
= S3C_SDHCI_CD_INTERNAL
;
479 static int sdhci_s3c_parse_dt(struct device
*dev
,
480 struct sdhci_host
*host
, struct s3c_sdhci_platdata
*pdata
)
486 static const struct of_device_id sdhci_s3c_dt_match
[];
488 static inline struct sdhci_s3c_drv_data
*sdhci_s3c_get_driver_data(
489 struct platform_device
*pdev
)
492 if (pdev
->dev
.of_node
) {
493 const struct of_device_id
*match
;
494 match
= of_match_node(sdhci_s3c_dt_match
, pdev
->dev
.of_node
);
495 return (struct sdhci_s3c_drv_data
*)match
->data
;
498 return (struct sdhci_s3c_drv_data
*)
499 platform_get_device_id(pdev
)->driver_data
;
502 static int sdhci_s3c_probe(struct platform_device
*pdev
)
504 struct s3c_sdhci_platdata
*pdata
;
505 struct sdhci_s3c_drv_data
*drv_data
;
506 struct device
*dev
= &pdev
->dev
;
507 struct sdhci_host
*host
;
508 struct sdhci_s3c
*sc
;
509 struct resource
*res
;
510 int ret
, irq
, ptr
, clks
;
512 if (!pdev
->dev
.platform_data
&& !pdev
->dev
.of_node
) {
513 dev_err(dev
, "no device data specified\n");
517 irq
= platform_get_irq(pdev
, 0);
519 dev_err(dev
, "no irq specified\n");
523 host
= sdhci_alloc_host(dev
, sizeof(struct sdhci_s3c
));
525 dev_err(dev
, "sdhci_alloc_host() failed\n");
526 return PTR_ERR(host
);
528 sc
= sdhci_priv(host
);
530 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
533 goto err_pdata_io_clk
;
536 if (pdev
->dev
.of_node
) {
537 ret
= sdhci_s3c_parse_dt(&pdev
->dev
, host
, pdata
);
539 goto err_pdata_io_clk
;
541 memcpy(pdata
, pdev
->dev
.platform_data
, sizeof(*pdata
));
542 sc
->ext_cd_gpio
= -1; /* invalid gpio number */
545 drv_data
= sdhci_s3c_get_driver_data(pdev
);
552 platform_set_drvdata(pdev
, host
);
554 sc
->clk_io
= devm_clk_get(dev
, "hsmmc");
555 if (IS_ERR(sc
->clk_io
)) {
556 dev_err(dev
, "failed to get io clock\n");
557 ret
= PTR_ERR(sc
->clk_io
);
558 goto err_pdata_io_clk
;
561 /* enable the local io clock and keep it running for the moment. */
562 clk_prepare_enable(sc
->clk_io
);
564 for (clks
= 0, ptr
= 0; ptr
< MAX_BUS_CLK
; ptr
++) {
567 snprintf(name
, 14, "mmc_busclk.%d", ptr
);
568 sc
->clk_bus
[ptr
] = devm_clk_get(dev
, name
);
569 if (IS_ERR(sc
->clk_bus
[ptr
]))
573 sc
->clk_rates
[ptr
] = clk_get_rate(sc
->clk_bus
[ptr
]);
575 dev_info(dev
, "clock source %d: %s (%ld Hz)\n",
576 ptr
, name
, sc
->clk_rates
[ptr
]);
580 dev_err(dev
, "failed to find any bus clocks\n");
585 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
586 host
->ioaddr
= devm_ioremap_resource(&pdev
->dev
, res
);
587 if (IS_ERR(host
->ioaddr
)) {
588 ret
= PTR_ERR(host
->ioaddr
);
592 /* Ensure we have minimal gpio selected CMD/CLK/Detect */
594 pdata
->cfg_gpio(pdev
, pdata
->max_width
);
596 host
->hw_name
= "samsung-hsmmc";
597 host
->ops
= &sdhci_s3c_ops
;
602 /* Setup quirks for the controller */
603 host
->quirks
|= SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC
;
604 host
->quirks
|= SDHCI_QUIRK_NO_HISPD_BIT
;
606 host
->quirks
|= drv_data
->sdhci_quirks
;
608 #ifndef CONFIG_MMC_SDHCI_S3C_DMA
610 /* we currently see overruns on errors, so disable the SDMA
611 * support as well. */
612 host
->quirks
|= SDHCI_QUIRK_BROKEN_DMA
;
614 #endif /* CONFIG_MMC_SDHCI_S3C_DMA */
616 /* It seems we do not get an DATA transfer complete on non-busy
617 * transfers, not sure if this is a problem with this specific
618 * SDHCI block, or a missing configuration that needs to be set. */
619 host
->quirks
|= SDHCI_QUIRK_NO_BUSY_IRQ
;
621 /* This host supports the Auto CMD12 */
622 host
->quirks
|= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12
;
624 /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */
625 host
->quirks
|= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC
;
627 if (pdata
->cd_type
== S3C_SDHCI_CD_NONE
||
628 pdata
->cd_type
== S3C_SDHCI_CD_PERMANENT
)
629 host
->quirks
|= SDHCI_QUIRK_BROKEN_CARD_DETECTION
;
631 if (pdata
->cd_type
== S3C_SDHCI_CD_PERMANENT
)
632 host
->mmc
->caps
= MMC_CAP_NONREMOVABLE
;
634 switch (pdata
->max_width
) {
636 host
->mmc
->caps
|= MMC_CAP_8_BIT_DATA
;
638 host
->mmc
->caps
|= MMC_CAP_4_BIT_DATA
;
643 host
->mmc
->pm_caps
|= pdata
->pm_caps
;
645 host
->quirks
|= (SDHCI_QUIRK_32BIT_DMA_ADDR
|
646 SDHCI_QUIRK_32BIT_DMA_SIZE
);
648 /* HSMMC on Samsung SoCs uses SDCLK as timeout clock */
649 host
->quirks
|= SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK
;
652 * If controller does not have internal clock divider,
653 * we can use overriding functions instead of default.
655 if (host
->quirks
& SDHCI_QUIRK_NONSTANDARD_CLOCK
) {
656 sdhci_s3c_ops
.set_clock
= sdhci_cmu_set_clock
;
657 sdhci_s3c_ops
.get_min_clock
= sdhci_cmu_get_min_clock
;
658 sdhci_s3c_ops
.get_max_clock
= sdhci_cmu_get_max_clock
;
661 /* It supports additional host capabilities if needed */
662 if (pdata
->host_caps
)
663 host
->mmc
->caps
|= pdata
->host_caps
;
665 if (pdata
->host_caps2
)
666 host
->mmc
->caps2
|= pdata
->host_caps2
;
668 pm_runtime_enable(&pdev
->dev
);
669 pm_runtime_set_autosuspend_delay(&pdev
->dev
, 50);
670 pm_runtime_use_autosuspend(&pdev
->dev
);
671 pm_suspend_ignore_children(&pdev
->dev
, 1);
673 ret
= sdhci_add_host(host
);
675 dev_err(dev
, "sdhci_add_host() failed\n");
676 pm_runtime_forbid(&pdev
->dev
);
677 pm_runtime_get_noresume(&pdev
->dev
);
681 /* The following two methods of card detection might call
682 sdhci_s3c_notify_change() immediately, so they can be called
683 only after sdhci_add_host(). Setup errors are ignored. */
684 if (pdata
->cd_type
== S3C_SDHCI_CD_EXTERNAL
&& pdata
->ext_cd_init
)
685 pdata
->ext_cd_init(&sdhci_s3c_notify_change
);
686 if (pdata
->cd_type
== S3C_SDHCI_CD_GPIO
&&
687 gpio_is_valid(pdata
->ext_cd_gpio
))
688 sdhci_s3c_setup_card_detect_gpio(sc
);
690 #ifdef CONFIG_PM_RUNTIME
691 if (pdata
->cd_type
!= S3C_SDHCI_CD_INTERNAL
)
692 clk_disable_unprepare(sc
->clk_io
);
698 clk_disable_unprepare(sc
->clk_io
);
701 sdhci_free_host(host
);
706 static int sdhci_s3c_remove(struct platform_device
*pdev
)
708 struct sdhci_host
*host
= platform_get_drvdata(pdev
);
709 struct sdhci_s3c
*sc
= sdhci_priv(host
);
710 struct s3c_sdhci_platdata
*pdata
= sc
->pdata
;
712 if (pdata
->cd_type
== S3C_SDHCI_CD_EXTERNAL
&& pdata
->ext_cd_cleanup
)
713 pdata
->ext_cd_cleanup(&sdhci_s3c_notify_change
);
716 free_irq(sc
->ext_cd_irq
, sc
);
718 #ifdef CONFIG_PM_RUNTIME
719 if (pdata
->cd_type
!= S3C_SDHCI_CD_INTERNAL
)
720 clk_prepare_enable(sc
->clk_io
);
722 sdhci_remove_host(host
, 1);
724 pm_runtime_dont_use_autosuspend(&pdev
->dev
);
725 pm_runtime_disable(&pdev
->dev
);
727 clk_disable_unprepare(sc
->clk_io
);
729 sdhci_free_host(host
);
734 #ifdef CONFIG_PM_SLEEP
735 static int sdhci_s3c_suspend(struct device
*dev
)
737 struct sdhci_host
*host
= dev_get_drvdata(dev
);
739 return sdhci_suspend_host(host
);
742 static int sdhci_s3c_resume(struct device
*dev
)
744 struct sdhci_host
*host
= dev_get_drvdata(dev
);
746 return sdhci_resume_host(host
);
750 #ifdef CONFIG_PM_RUNTIME
751 static int sdhci_s3c_runtime_suspend(struct device
*dev
)
753 struct sdhci_host
*host
= dev_get_drvdata(dev
);
754 struct sdhci_s3c
*ourhost
= to_s3c(host
);
755 struct clk
*busclk
= ourhost
->clk_io
;
758 ret
= sdhci_runtime_suspend_host(host
);
760 if (ourhost
->cur_clk
>= 0)
761 clk_disable_unprepare(ourhost
->clk_bus
[ourhost
->cur_clk
]);
762 clk_disable_unprepare(busclk
);
766 static int sdhci_s3c_runtime_resume(struct device
*dev
)
768 struct sdhci_host
*host
= dev_get_drvdata(dev
);
769 struct sdhci_s3c
*ourhost
= to_s3c(host
);
770 struct clk
*busclk
= ourhost
->clk_io
;
773 clk_prepare_enable(busclk
);
774 if (ourhost
->cur_clk
>= 0)
775 clk_prepare_enable(ourhost
->clk_bus
[ourhost
->cur_clk
]);
776 ret
= sdhci_runtime_resume_host(host
);
782 static const struct dev_pm_ops sdhci_s3c_pmops
= {
783 SET_SYSTEM_SLEEP_PM_OPS(sdhci_s3c_suspend
, sdhci_s3c_resume
)
784 SET_RUNTIME_PM_OPS(sdhci_s3c_runtime_suspend
, sdhci_s3c_runtime_resume
,
788 #define SDHCI_S3C_PMOPS (&sdhci_s3c_pmops)
791 #define SDHCI_S3C_PMOPS NULL
794 #if defined(CONFIG_CPU_EXYNOS4210) || defined(CONFIG_SOC_EXYNOS4212)
795 static struct sdhci_s3c_drv_data exynos4_sdhci_drv_data
= {
796 .sdhci_quirks
= SDHCI_QUIRK_NONSTANDARD_CLOCK
,
798 #define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)&exynos4_sdhci_drv_data)
800 #define EXYNOS4_SDHCI_DRV_DATA ((kernel_ulong_t)NULL)
803 static struct platform_device_id sdhci_s3c_driver_ids
[] = {
806 .driver_data
= (kernel_ulong_t
)NULL
,
808 .name
= "exynos4-sdhci",
809 .driver_data
= EXYNOS4_SDHCI_DRV_DATA
,
813 MODULE_DEVICE_TABLE(platform
, sdhci_s3c_driver_ids
);
816 static const struct of_device_id sdhci_s3c_dt_match
[] = {
817 { .compatible
= "samsung,s3c6410-sdhci", },
818 { .compatible
= "samsung,exynos4210-sdhci",
819 .data
= (void *)EXYNOS4_SDHCI_DRV_DATA
},
822 MODULE_DEVICE_TABLE(of
, sdhci_s3c_dt_match
);
825 static struct platform_driver sdhci_s3c_driver
= {
826 .probe
= sdhci_s3c_probe
,
827 .remove
= sdhci_s3c_remove
,
828 .id_table
= sdhci_s3c_driver_ids
,
830 .owner
= THIS_MODULE
,
832 .of_match_table
= of_match_ptr(sdhci_s3c_dt_match
),
833 .pm
= SDHCI_S3C_PMOPS
,
837 module_platform_driver(sdhci_s3c_driver
);
839 MODULE_DESCRIPTION("Samsung SDHCI (HSMMC) glue");
840 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
841 MODULE_LICENSE("GPL v2");
842 MODULE_ALIAS("platform:s3c-sdhci");