3 * Texas Instruments, <www.ti.com>
4 * Sukumar Ghorai <s-ghorai@ti.com>
6 * See file CREDITS for list of people who contributed to this
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation's version 2 of
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
33 #if defined(CONFIG_OMAP54XX) || defined(CONFIG_OMAP44XX)
37 #include <asm/arch/mmc_host_def.h>
38 #ifdef CONFIG_OMAP54XX
39 #include <asm/arch/mux_dra7xx.h>
40 #include <asm/arch/dra7xx_iodelay.h>
42 #if !defined(CONFIG_SOC_KEYSTONE)
44 #include <asm/arch/sys_proto.h>
46 #ifdef CONFIG_MMC_OMAP36XX_PINS
47 #include <asm/arch/mux.h>
50 #include <dm/devres.h>
51 #include <linux/err.h>
52 #include <power/regulator.h>
55 DECLARE_GLOBAL_DATA_PTR
;
57 /* simplify defines to OMAP_HSMMC_USE_GPIO */
58 #if (defined(CONFIG_OMAP_GPIO) && !defined(CONFIG_SPL_BUILD)) || \
59 (defined(CONFIG_SPL_BUILD) && defined(CONFIG_SPL_GPIO_SUPPORT))
60 #define OMAP_HSMMC_USE_GPIO
62 #undef OMAP_HSMMC_USE_GPIO
65 /* common definitions for all OMAPs */
66 #define SYSCTL_SRC (1 << 25)
67 #define SYSCTL_SRD (1 << 26)
69 #ifdef CONFIG_IODELAY_RECALIBRATION
70 struct omap_hsmmc_pinctrl_state
{
71 struct pad_conf_entry
*padconf
;
73 struct iodelay_cfg_entry
*iodelay
;
78 struct omap_hsmmc_data
{
79 struct hsmmc
*base_addr
;
80 #if !CONFIG_IS_ENABLED(DM_MMC)
81 struct mmc_config cfg
;
86 #ifdef OMAP_HSMMC_USE_GPIO
87 #if CONFIG_IS_ENABLED(DM_MMC)
88 struct gpio_desc cd_gpio
; /* Change Detect GPIO */
89 struct gpio_desc wp_gpio
; /* Write Protect GPIO */
95 #if CONFIG_IS_ENABLED(DM_MMC)
99 #ifdef CONFIG_MMC_OMAP_HS_ADMA
100 struct omap_hsmmc_adma_desc
*adma_desc_table
;
104 struct udevice
*pbias_supply
;
106 #ifdef CONFIG_IODELAY_RECALIBRATION
107 struct omap_hsmmc_pinctrl_state
*default_pinctrl_state
;
108 struct omap_hsmmc_pinctrl_state
*hs_pinctrl_state
;
109 struct omap_hsmmc_pinctrl_state
*hs200_1_8v_pinctrl_state
;
110 struct omap_hsmmc_pinctrl_state
*ddr_1_8v_pinctrl_state
;
111 struct omap_hsmmc_pinctrl_state
*sdr12_pinctrl_state
;
112 struct omap_hsmmc_pinctrl_state
*sdr25_pinctrl_state
;
113 struct omap_hsmmc_pinctrl_state
*ddr50_pinctrl_state
;
114 struct omap_hsmmc_pinctrl_state
*sdr50_pinctrl_state
;
115 struct omap_hsmmc_pinctrl_state
*sdr104_pinctrl_state
;
119 struct omap_mmc_of_data
{
123 #ifdef CONFIG_MMC_OMAP_HS_ADMA
124 struct omap_hsmmc_adma_desc
{
131 #define ADMA_MAX_LEN 63488
133 /* Decriptor table defines */
134 #define ADMA_DESC_ATTR_VALID BIT(0)
135 #define ADMA_DESC_ATTR_END BIT(1)
136 #define ADMA_DESC_ATTR_INT BIT(2)
137 #define ADMA_DESC_ATTR_ACT1 BIT(4)
138 #define ADMA_DESC_ATTR_ACT2 BIT(5)
140 #define ADMA_DESC_TRANSFER_DATA ADMA_DESC_ATTR_ACT2
141 #define ADMA_DESC_LINK_DESC (ADMA_DESC_ATTR_ACT1 | ADMA_DESC_ATTR_ACT2)
144 /* If we fail after 1 second wait, something is really bad */
145 #define MAX_RETRY_MS 1000
146 #define MMC_TIMEOUT_MS 20
148 /* DMA transfers can take a long time if a lot a data is transferred.
149 * The timeout must take in account the amount of data. Let's assume
150 * that the time will never exceed 333 ms per MB (in other word we assume
151 * that the bandwidth is always above 3MB/s).
153 #define DMA_TIMEOUT_PER_MB 333
154 #define OMAP_HSMMC_SUPPORTS_DUAL_VOLT BIT(0)
155 #define OMAP_HSMMC_NO_1_8_V BIT(1)
156 #define OMAP_HSMMC_USE_ADMA BIT(2)
157 #define OMAP_HSMMC_REQUIRE_IODELAY BIT(3)
159 static int mmc_read_data(struct hsmmc
*mmc_base
, char *buf
, unsigned int size
);
160 static int mmc_write_data(struct hsmmc
*mmc_base
, const char *buf
,
162 static void omap_hsmmc_start_clock(struct hsmmc
*mmc_base
);
163 static void omap_hsmmc_stop_clock(struct hsmmc
*mmc_base
);
164 static void mmc_reset_controller_fsm(struct hsmmc
*mmc_base
, u32 bit
);
166 static inline struct omap_hsmmc_data
*omap_hsmmc_get_data(struct mmc
*mmc
)
168 #if CONFIG_IS_ENABLED(DM_MMC)
169 return dev_get_priv(mmc
->dev
);
171 return (struct omap_hsmmc_data
*)mmc
->priv
;
174 static inline struct mmc_config
*omap_hsmmc_get_cfg(struct mmc
*mmc
)
176 #if CONFIG_IS_ENABLED(DM_MMC)
177 struct omap_hsmmc_plat
*plat
= dev_get_platdata(mmc
->dev
);
180 return &((struct omap_hsmmc_data
*)mmc
->priv
)->cfg
;
184 #if defined(OMAP_HSMMC_USE_GPIO) && !CONFIG_IS_ENABLED(DM_MMC)
185 static int omap_mmc_setup_gpio_in(int gpio
, const char *label
)
189 #if !CONFIG_IS_ENABLED(DM_GPIO)
190 if (!gpio_is_valid(gpio
))
193 ret
= gpio_request(gpio
, label
);
197 ret
= gpio_direction_input(gpio
);
205 static unsigned char mmc_board_init(struct mmc
*mmc
)
207 #if defined(CONFIG_OMAP34XX)
208 struct mmc_config
*cfg
= omap_hsmmc_get_cfg(mmc
);
209 t2_t
*t2_base
= (t2_t
*)T2_BASE
;
210 struct prcm
*prcm_base
= (struct prcm
*)PRCM_BASE
;
212 #ifdef CONFIG_MMC_OMAP36XX_PINS
213 u32 wkup_ctrl
= readl(OMAP34XX_CTRL_WKUP_CTRL
);
216 pbias_lite
= readl(&t2_base
->pbias_lite
);
217 pbias_lite
&= ~(PBIASLITEPWRDNZ1
| PBIASLITEPWRDNZ0
);
218 #ifdef CONFIG_TARGET_OMAP3_CAIRO
219 /* for cairo board, we need to set up 1.8 Volt bias level on MMC1 */
220 pbias_lite
&= ~PBIASLITEVMODE0
;
222 #ifdef CONFIG_TARGET_OMAP3_LOGIC
223 /* For Logic PD board, 1.8V bias to go enable gpio127 for mmc_cd */
224 pbias_lite
&= ~PBIASLITEVMODE1
;
226 #ifdef CONFIG_MMC_OMAP36XX_PINS
227 if (get_cpu_family() == CPU_OMAP36XX
) {
228 /* Disable extended drain IO before changing PBIAS */
229 wkup_ctrl
&= ~OMAP34XX_CTRL_WKUP_CTRL_GPIO_IO_PWRDNZ
;
230 writel(wkup_ctrl
, OMAP34XX_CTRL_WKUP_CTRL
);
233 writel(pbias_lite
, &t2_base
->pbias_lite
);
235 writel(pbias_lite
| PBIASLITEPWRDNZ1
|
236 PBIASSPEEDCTRL0
| PBIASLITEPWRDNZ0
,
237 &t2_base
->pbias_lite
);
239 #ifdef CONFIG_MMC_OMAP36XX_PINS
240 if (get_cpu_family() == CPU_OMAP36XX
)
241 /* Enable extended drain IO after changing PBIAS */
243 OMAP34XX_CTRL_WKUP_CTRL_GPIO_IO_PWRDNZ
,
244 OMAP34XX_CTRL_WKUP_CTRL
);
246 writel(readl(&t2_base
->devconf0
) | MMCSDIO1ADPCLKISEL
,
249 writel(readl(&t2_base
->devconf1
) | MMCSDIO2ADPCLKISEL
,
252 /* Change from default of 52MHz to 26MHz if necessary */
253 if (!(cfg
->host_caps
& MMC_MODE_HS_52MHz
))
254 writel(readl(&t2_base
->ctl_prog_io1
) & ~CTLPROGIO1SPEEDCTRL
,
255 &t2_base
->ctl_prog_io1
);
257 writel(readl(&prcm_base
->fclken1_core
) |
258 EN_MMC1
| EN_MMC2
| EN_MMC3
,
259 &prcm_base
->fclken1_core
);
261 writel(readl(&prcm_base
->iclken1_core
) |
262 EN_MMC1
| EN_MMC2
| EN_MMC3
,
263 &prcm_base
->iclken1_core
);
266 #if (defined(CONFIG_OMAP54XX) || defined(CONFIG_OMAP44XX)) &&\
267 !CONFIG_IS_ENABLED(DM_REGULATOR)
268 /* PBIAS config needed for MMC1 only */
269 if (mmc_get_blk_desc(mmc
)->devnum
== 0)
270 vmmc_pbias_config(LDO_VOLT_3V3
);
276 void mmc_init_stream(struct hsmmc
*mmc_base
)
280 writel(readl(&mmc_base
->con
) | INIT_INITSTREAM
, &mmc_base
->con
);
282 writel(MMC_CMD0
, &mmc_base
->cmd
);
283 start
= get_timer(0);
284 while (!(readl(&mmc_base
->stat
) & CC_MASK
)) {
285 if (get_timer(0) - start
> MAX_RETRY_MS
) {
286 printf("%s: timedout waiting for cc!\n", __func__
);
290 writel(CC_MASK
, &mmc_base
->stat
)
292 writel(MMC_CMD0
, &mmc_base
->cmd
)
294 start
= get_timer(0);
295 while (!(readl(&mmc_base
->stat
) & CC_MASK
)) {
296 if (get_timer(0) - start
> MAX_RETRY_MS
) {
297 printf("%s: timedout waiting for cc2!\n", __func__
);
301 writel(readl(&mmc_base
->con
) & ~INIT_INITSTREAM
, &mmc_base
->con
);
304 #if CONFIG_IS_ENABLED(DM_MMC)
305 #ifdef CONFIG_IODELAY_RECALIBRATION
306 static void omap_hsmmc_io_recalibrate(struct mmc
*mmc
)
308 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
309 struct omap_hsmmc_pinctrl_state
*pinctrl_state
;
311 switch (priv
->mode
) {
313 pinctrl_state
= priv
->hs200_1_8v_pinctrl_state
;
316 pinctrl_state
= priv
->sdr104_pinctrl_state
;
319 pinctrl_state
= priv
->sdr50_pinctrl_state
;
322 pinctrl_state
= priv
->ddr50_pinctrl_state
;
325 pinctrl_state
= priv
->sdr25_pinctrl_state
;
328 pinctrl_state
= priv
->sdr12_pinctrl_state
;
333 pinctrl_state
= priv
->hs_pinctrl_state
;
336 pinctrl_state
= priv
->ddr_1_8v_pinctrl_state
;
338 pinctrl_state
= priv
->default_pinctrl_state
;
343 pinctrl_state
= priv
->default_pinctrl_state
;
345 if (priv
->controller_flags
& OMAP_HSMMC_REQUIRE_IODELAY
) {
346 if (pinctrl_state
->iodelay
)
347 late_recalibrate_iodelay(pinctrl_state
->padconf
,
348 pinctrl_state
->npads
,
349 pinctrl_state
->iodelay
,
350 pinctrl_state
->niodelays
);
352 do_set_mux32((*ctrl
)->control_padconf_core_base
,
353 pinctrl_state
->padconf
,
354 pinctrl_state
->npads
);
358 static void omap_hsmmc_set_timing(struct mmc
*mmc
)
361 struct hsmmc
*mmc_base
;
362 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
364 mmc_base
= priv
->base_addr
;
366 omap_hsmmc_stop_clock(mmc_base
);
367 val
= readl(&mmc_base
->ac12
);
368 val
&= ~AC12_UHSMC_MASK
;
369 priv
->mode
= mmc
->selected_mode
;
371 if (mmc_is_mode_ddr(priv
->mode
))
372 writel(readl(&mmc_base
->con
) | DDR
, &mmc_base
->con
);
374 writel(readl(&mmc_base
->con
) & ~DDR
, &mmc_base
->con
);
376 switch (priv
->mode
) {
379 val
|= AC12_UHSMC_SDR104
;
382 val
|= AC12_UHSMC_SDR50
;
386 val
|= AC12_UHSMC_DDR50
;
391 val
|= AC12_UHSMC_SDR25
;
396 val
|= AC12_UHSMC_SDR12
;
399 val
|= AC12_UHSMC_RES
;
402 writel(val
, &mmc_base
->ac12
);
404 #ifdef CONFIG_IODELAY_RECALIBRATION
405 omap_hsmmc_io_recalibrate(mmc
);
407 omap_hsmmc_start_clock(mmc_base
);
410 static void omap_hsmmc_conf_bus_power(struct mmc
*mmc
, uint signal_voltage
)
412 struct hsmmc
*mmc_base
;
413 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
416 mmc_base
= priv
->base_addr
;
418 hctl
= readl(&mmc_base
->hctl
) & ~SDVS_MASK
;
419 ac12
= readl(&mmc_base
->ac12
) & ~AC12_V1V8_SIGEN
;
421 switch (signal_voltage
) {
422 case MMC_SIGNAL_VOLTAGE_330
:
425 case MMC_SIGNAL_VOLTAGE_180
:
427 ac12
|= AC12_V1V8_SIGEN
;
431 writel(hctl
, &mmc_base
->hctl
);
432 writel(ac12
, &mmc_base
->ac12
);
435 static int omap_hsmmc_wait_dat0(struct udevice
*dev
, int state
, int timeout_us
)
437 int ret
= -ETIMEDOUT
;
440 bool target_dat0_high
= !!state
;
441 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
442 struct hsmmc
*mmc_base
= priv
->base_addr
;
444 con
= readl(&mmc_base
->con
);
445 writel(con
| CON_CLKEXTFREE
| CON_PADEN
, &mmc_base
->con
);
447 timeout_us
= DIV_ROUND_UP(timeout_us
, 10); /* check every 10 us. */
448 while (timeout_us
--) {
449 dat0_high
= !!(readl(&mmc_base
->pstate
) & PSTATE_DLEV_DAT0
);
450 if (dat0_high
== target_dat0_high
) {
456 writel(con
, &mmc_base
->con
);
461 #if CONFIG_IS_ENABLED(MMC_IO_VOLTAGE)
462 #if CONFIG_IS_ENABLED(DM_REGULATOR)
463 static int omap_hsmmc_set_io_regulator(struct mmc
*mmc
, int mV
)
468 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
470 if (!mmc
->vqmmc_supply
)
474 ret
= regulator_set_enable_if_allowed(priv
->pbias_supply
, false);
478 /* Turn off IO voltage */
479 ret
= regulator_set_enable_if_allowed(mmc
->vqmmc_supply
, false);
482 /* Program a new IO voltage value */
483 ret
= regulator_set_value(mmc
->vqmmc_supply
, uV
);
486 /* Turn on IO voltage */
487 ret
= regulator_set_enable_if_allowed(mmc
->vqmmc_supply
, true);
491 /* Program PBIAS voltage*/
492 ret
= regulator_set_value(priv
->pbias_supply
, uV
);
493 if (ret
&& ret
!= -ENOSYS
)
496 ret
= regulator_set_enable_if_allowed(priv
->pbias_supply
, true);
504 static int omap_hsmmc_set_signal_voltage(struct mmc
*mmc
)
506 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
507 struct hsmmc
*mmc_base
= priv
->base_addr
;
508 int mv
= mmc_voltage_to_mv(mmc
->signal_voltage
);
510 __maybe_unused u8 palmas_ldo_volt
;
516 if (mmc
->signal_voltage
== MMC_SIGNAL_VOLTAGE_330
) {
518 capa_mask
= VS33_3V3SUP
;
519 palmas_ldo_volt
= LDO_VOLT_3V3
;
520 } else if (mmc
->signal_voltage
== MMC_SIGNAL_VOLTAGE_180
) {
521 capa_mask
= VS18_1V8SUP
;
522 palmas_ldo_volt
= LDO_VOLT_1V8
;
527 val
= readl(&mmc_base
->capa
);
528 if (!(val
& capa_mask
))
531 priv
->signal_voltage
= mmc
->signal_voltage
;
533 omap_hsmmc_conf_bus_power(mmc
, mmc
->signal_voltage
);
535 #if CONFIG_IS_ENABLED(DM_REGULATOR)
536 return omap_hsmmc_set_io_regulator(mmc
, mv
);
537 #elif (defined(CONFIG_OMAP54XX) || defined(CONFIG_OMAP44XX)) && \
538 defined(CONFIG_PALMAS_POWER)
539 if (mmc_get_blk_desc(mmc
)->devnum
== 0)
540 vmmc_pbias_config(palmas_ldo_volt
);
548 static uint32_t omap_hsmmc_set_capabilities(struct mmc
*mmc
)
550 struct hsmmc
*mmc_base
;
551 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
554 mmc_base
= priv
->base_addr
;
555 val
= readl(&mmc_base
->capa
);
557 if (priv
->controller_flags
& OMAP_HSMMC_SUPPORTS_DUAL_VOLT
) {
558 val
|= (VS33_3V3SUP
| VS18_1V8SUP
);
559 } else if (priv
->controller_flags
& OMAP_HSMMC_NO_1_8_V
) {
567 writel(val
, &mmc_base
->capa
);
572 #ifdef MMC_SUPPORTS_TUNING
573 static void omap_hsmmc_disable_tuning(struct mmc
*mmc
)
575 struct hsmmc
*mmc_base
;
576 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
579 mmc_base
= priv
->base_addr
;
580 val
= readl(&mmc_base
->ac12
);
581 val
&= ~(AC12_SCLK_SEL
);
582 writel(val
, &mmc_base
->ac12
);
584 val
= readl(&mmc_base
->dll
);
585 val
&= ~(DLL_FORCE_VALUE
| DLL_SWT
);
586 writel(val
, &mmc_base
->dll
);
589 static void omap_hsmmc_set_dll(struct mmc
*mmc
, int count
)
592 struct hsmmc
*mmc_base
;
593 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
596 mmc_base
= priv
->base_addr
;
597 val
= readl(&mmc_base
->dll
);
598 val
|= DLL_FORCE_VALUE
;
599 val
&= ~(DLL_FORCE_SR_C_MASK
<< DLL_FORCE_SR_C_SHIFT
);
600 val
|= (count
<< DLL_FORCE_SR_C_SHIFT
);
601 writel(val
, &mmc_base
->dll
);
604 writel(val
, &mmc_base
->dll
);
605 for (i
= 0; i
< 1000; i
++) {
606 if (readl(&mmc_base
->dll
) & DLL_CALIB
)
610 writel(val
, &mmc_base
->dll
);
613 static int omap_hsmmc_execute_tuning(struct udevice
*dev
, uint opcode
)
615 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
616 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
617 struct mmc
*mmc
= upriv
->mmc
;
618 struct hsmmc
*mmc_base
;
620 u8 cur_match
, prev_match
= 0;
623 u32 start_window
= 0, max_window
= 0;
624 u32 length
= 0, max_len
= 0;
625 bool single_point_failure
= false;
626 struct udevice
*thermal_dev
;
630 mmc_base
= priv
->base_addr
;
631 val
= readl(&mmc_base
->capa2
);
633 /* clock tuning is not needed for upto 52MHz */
634 if (!((mmc
->selected_mode
== MMC_HS_200
) ||
635 (mmc
->selected_mode
== UHS_SDR104
) ||
636 ((mmc
->selected_mode
== UHS_SDR50
) && (val
& CAPA2_TSDR50
))))
639 ret
= uclass_first_device(UCLASS_THERMAL
, &thermal_dev
);
641 printf("Couldn't get thermal device for tuning\n");
644 ret
= thermal_get_temp(thermal_dev
, &temperature
);
646 printf("Couldn't get temperature for tuning\n");
649 val
= readl(&mmc_base
->dll
);
651 writel(val
, &mmc_base
->dll
);
654 * Stage 1: Search for a maximum pass window ignoring any
655 * any single point failures. If the tuning value ends up
656 * near it, move away from it in stage 2 below
658 while (phase_delay
<= MAX_PHASE_DELAY
) {
659 omap_hsmmc_set_dll(mmc
, phase_delay
);
661 cur_match
= !mmc_send_tuning(mmc
, opcode
, NULL
);
666 } else if (single_point_failure
) {
667 /* ignore single point failure */
669 single_point_failure
= false;
671 start_window
= phase_delay
;
675 single_point_failure
= prev_match
;
678 if (length
> max_len
) {
679 max_window
= start_window
;
683 prev_match
= cur_match
;
692 val
= readl(&mmc_base
->ac12
);
693 if (!(val
& AC12_SCLK_SEL
)) {
698 * Assign tuning value as a ratio of maximum pass window based
701 if (temperature
< -20000)
702 phase_delay
= min(max_window
+ 4 * max_len
- 24,
704 DIV_ROUND_UP(13 * max_len
, 16) * 4);
705 else if (temperature
< 20000)
706 phase_delay
= max_window
+ DIV_ROUND_UP(9 * max_len
, 16) * 4;
707 else if (temperature
< 40000)
708 phase_delay
= max_window
+ DIV_ROUND_UP(8 * max_len
, 16) * 4;
709 else if (temperature
< 70000)
710 phase_delay
= max_window
+ DIV_ROUND_UP(7 * max_len
, 16) * 4;
711 else if (temperature
< 90000)
712 phase_delay
= max_window
+ DIV_ROUND_UP(5 * max_len
, 16) * 4;
713 else if (temperature
< 120000)
714 phase_delay
= max_window
+ DIV_ROUND_UP(4 * max_len
, 16) * 4;
716 phase_delay
= max_window
+ DIV_ROUND_UP(3 * max_len
, 16) * 4;
719 * Stage 2: Search for a single point failure near the chosen tuning
720 * value in two steps. First in the +3 to +10 range and then in the
721 * +2 to -10 range. If found, move away from it in the appropriate
722 * direction by the appropriate amount depending on the temperature.
724 for (i
= 3; i
<= 10; i
++) {
725 omap_hsmmc_set_dll(mmc
, phase_delay
+ i
);
726 if (mmc_send_tuning(mmc
, opcode
, NULL
)) {
727 if (temperature
< 10000)
728 phase_delay
+= i
+ 6;
729 else if (temperature
< 20000)
730 phase_delay
+= i
- 12;
731 else if (temperature
< 70000)
732 phase_delay
+= i
- 8;
733 else if (temperature
< 90000)
734 phase_delay
+= i
- 6;
736 phase_delay
+= i
- 6;
738 goto single_failure_found
;
742 for (i
= 2; i
>= -10; i
--) {
743 omap_hsmmc_set_dll(mmc
, phase_delay
+ i
);
744 if (mmc_send_tuning(mmc
, opcode
, NULL
)) {
745 if (temperature
< 10000)
746 phase_delay
+= i
+ 12;
747 else if (temperature
< 20000)
748 phase_delay
+= i
+ 8;
749 else if (temperature
< 70000)
750 phase_delay
+= i
+ 8;
751 else if (temperature
< 90000)
752 phase_delay
+= i
+ 10;
754 phase_delay
+= i
+ 12;
756 goto single_failure_found
;
760 single_failure_found
:
762 omap_hsmmc_set_dll(mmc
, phase_delay
);
764 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
765 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRC
);
771 omap_hsmmc_disable_tuning(mmc
);
772 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
773 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRC
);
780 static void mmc_enable_irq(struct mmc
*mmc
, struct mmc_cmd
*cmd
)
782 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
783 struct hsmmc
*mmc_base
= priv
->base_addr
;
784 u32 irq_mask
= INT_EN_MASK
;
787 * TODO: Errata i802 indicates only DCRC interrupts can occur during
788 * tuning procedure and DCRC should be disabled. But see occurences
789 * of DEB, CIE, CEB, CCRC interupts during tuning procedure. These
790 * interrupts occur along with BRR, so the data is actually in the
791 * buffer. It has to be debugged why these interrutps occur
793 if (cmd
&& mmc_is_tuning_cmd(cmd
->cmdidx
))
794 irq_mask
&= ~(IE_DEB
| IE_DCRC
| IE_CIE
| IE_CEB
| IE_CCRC
);
796 writel(irq_mask
, &mmc_base
->ie
);
799 static int omap_hsmmc_init_setup(struct mmc
*mmc
)
801 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
802 struct hsmmc
*mmc_base
;
803 unsigned int reg_val
;
807 mmc_base
= priv
->base_addr
;
810 writel(readl(&mmc_base
->sysconfig
) | MMC_SOFTRESET
,
811 &mmc_base
->sysconfig
);
812 start
= get_timer(0);
813 while ((readl(&mmc_base
->sysstatus
) & RESETDONE
) == 0) {
814 if (get_timer(0) - start
> MAX_RETRY_MS
) {
815 printf("%s: timedout waiting for cc2!\n", __func__
);
819 writel(readl(&mmc_base
->sysctl
) | SOFTRESETALL
, &mmc_base
->sysctl
);
820 start
= get_timer(0);
821 while ((readl(&mmc_base
->sysctl
) & SOFTRESETALL
) != 0x0) {
822 if (get_timer(0) - start
> MAX_RETRY_MS
) {
823 printf("%s: timedout waiting for softresetall!\n",
828 #ifdef CONFIG_MMC_OMAP_HS_ADMA
829 reg_val
= readl(&mmc_base
->hl_hwinfo
);
830 if (reg_val
& MADMA_EN
)
831 priv
->controller_flags
|= OMAP_HSMMC_USE_ADMA
;
834 #if CONFIG_IS_ENABLED(DM_MMC)
835 reg_val
= omap_hsmmc_set_capabilities(mmc
);
836 omap_hsmmc_conf_bus_power(mmc
, (reg_val
& VS33_3V3SUP
) ?
837 MMC_SIGNAL_VOLTAGE_330
: MMC_SIGNAL_VOLTAGE_180
);
839 writel(DTW_1_BITMODE
| SDBP_PWROFF
| SDVS_3V0
, &mmc_base
->hctl
);
840 writel(readl(&mmc_base
->capa
) | VS33_3V3SUP
| VS18_1V8SUP
,
844 reg_val
= readl(&mmc_base
->con
) & RESERVED_MASK
;
846 writel(CTPL_MMC_SD
| reg_val
| WPP_ACTIVEHIGH
| CDP_ACTIVEHIGH
|
847 MIT_CTO
| DW8_1_4BITMODE
| MODE_FUNC
| STR_BLOCK
|
848 HR_NOHOSTRESP
| INIT_NOINIT
| NOOPENDRAIN
, &mmc_base
->con
);
851 mmc_reg_out(&mmc_base
->sysctl
, (ICE_MASK
| DTO_MASK
| CEN_MASK
),
852 (ICE_STOP
| DTO_15THDTO
));
853 mmc_reg_out(&mmc_base
->sysctl
, ICE_MASK
| CLKD_MASK
,
854 (dsor
<< CLKD_OFFSET
) | ICE_OSCILLATE
);
855 start
= get_timer(0);
856 while ((readl(&mmc_base
->sysctl
) & ICS_MASK
) == ICS_NOTREADY
) {
857 if (get_timer(0) - start
> MAX_RETRY_MS
) {
858 printf("%s: timedout waiting for ics!\n", __func__
);
862 writel(readl(&mmc_base
->sysctl
) | CEN_ENABLE
, &mmc_base
->sysctl
);
864 writel(readl(&mmc_base
->hctl
) | SDBP_PWRON
, &mmc_base
->hctl
);
866 mmc_enable_irq(mmc
, NULL
);
868 #if !CONFIG_IS_ENABLED(DM_MMC)
869 mmc_init_stream(mmc_base
);
876 * MMC controller internal finite state machine reset
878 * Used to reset command or data internal state machines, using respectively
879 * SRC or SRD bit of SYSCTL register
881 static void mmc_reset_controller_fsm(struct hsmmc
*mmc_base
, u32 bit
)
885 mmc_reg_out(&mmc_base
->sysctl
, bit
, bit
);
888 * CMD(DAT) lines reset procedures are slightly different
889 * for OMAP3 and OMAP4(AM335x,OMAP5,DRA7xx).
890 * According to OMAP3 TRM:
891 * Set SRC(SRD) bit in MMCHS_SYSCTL register to 0x1 and wait until it
893 * According to OMAP4(AM335x,OMAP5,DRA7xx) TRMs, CMD(DATA) lines reset
894 * procedure steps must be as follows:
895 * 1. Initiate CMD(DAT) line reset by writing 0x1 to SRC(SRD) bit in
896 * MMCHS_SYSCTL register (SD_SYSCTL for AM335x).
897 * 2. Poll the SRC(SRD) bit until it is set to 0x1.
898 * 3. Wait until the SRC (SRD) bit returns to 0x0
899 * (reset procedure is completed).
901 #if defined(CONFIG_OMAP44XX) || defined(CONFIG_OMAP54XX) || \
902 defined(CONFIG_AM33XX) || defined(CONFIG_AM43XX)
903 if (!(readl(&mmc_base
->sysctl
) & bit
)) {
904 start
= get_timer(0);
905 while (!(readl(&mmc_base
->sysctl
) & bit
)) {
906 if (get_timer(0) - start
> MMC_TIMEOUT_MS
)
911 start
= get_timer(0);
912 while ((readl(&mmc_base
->sysctl
) & bit
) != 0) {
913 if (get_timer(0) - start
> MAX_RETRY_MS
) {
914 printf("%s: timedout waiting for sysctl %x to clear\n",
921 #ifdef CONFIG_MMC_OMAP_HS_ADMA
922 static void omap_hsmmc_adma_desc(struct mmc
*mmc
, char *buf
, u16 len
, bool end
)
924 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
925 struct omap_hsmmc_adma_desc
*desc
;
928 desc
= &priv
->adma_desc_table
[priv
->desc_slot
];
930 attr
= ADMA_DESC_ATTR_VALID
| ADMA_DESC_TRANSFER_DATA
;
934 attr
|= ADMA_DESC_ATTR_END
;
937 desc
->addr
= (u32
)buf
;
942 static void omap_hsmmc_prepare_adma_table(struct mmc
*mmc
,
943 struct mmc_data
*data
)
945 uint total_len
= data
->blocksize
* data
->blocks
;
946 uint desc_count
= DIV_ROUND_UP(total_len
, ADMA_MAX_LEN
);
947 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
952 priv
->adma_desc_table
= (struct omap_hsmmc_adma_desc
*)
953 memalign(ARCH_DMA_MINALIGN
, desc_count
*
954 sizeof(struct omap_hsmmc_adma_desc
));
956 if (data
->flags
& MMC_DATA_READ
)
959 buf
= (char *)data
->src
;
962 omap_hsmmc_adma_desc(mmc
, buf
, ADMA_MAX_LEN
, false);
964 total_len
-= ADMA_MAX_LEN
;
967 omap_hsmmc_adma_desc(mmc
, buf
, total_len
, true);
969 flush_dcache_range((long)priv
->adma_desc_table
,
970 (long)priv
->adma_desc_table
+
972 sizeof(struct omap_hsmmc_adma_desc
),
976 static void omap_hsmmc_prepare_data(struct mmc
*mmc
, struct mmc_data
*data
)
978 struct hsmmc
*mmc_base
;
979 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
983 mmc_base
= priv
->base_addr
;
984 omap_hsmmc_prepare_adma_table(mmc
, data
);
986 if (data
->flags
& MMC_DATA_READ
)
989 buf
= (char *)data
->src
;
991 val
= readl(&mmc_base
->hctl
);
993 writel(val
, &mmc_base
->hctl
);
995 val
= readl(&mmc_base
->con
);
997 writel(val
, &mmc_base
->con
);
999 writel((u32
)priv
->adma_desc_table
, &mmc_base
->admasal
);
1001 flush_dcache_range((u32
)buf
,
1003 ROUND(data
->blocksize
* data
->blocks
,
1004 ARCH_DMA_MINALIGN
));
1007 static void omap_hsmmc_dma_cleanup(struct mmc
*mmc
)
1009 struct hsmmc
*mmc_base
;
1010 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1013 mmc_base
= priv
->base_addr
;
1015 val
= readl(&mmc_base
->con
);
1017 writel(val
, &mmc_base
->con
);
1019 val
= readl(&mmc_base
->hctl
);
1021 writel(val
, &mmc_base
->hctl
);
1023 kfree(priv
->adma_desc_table
);
1026 #define omap_hsmmc_adma_desc
1027 #define omap_hsmmc_prepare_adma_table
1028 #define omap_hsmmc_prepare_data
1029 #define omap_hsmmc_dma_cleanup
1032 #if !CONFIG_IS_ENABLED(DM_MMC)
1033 static int omap_hsmmc_send_cmd(struct mmc
*mmc
, struct mmc_cmd
*cmd
,
1034 struct mmc_data
*data
)
1036 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1038 static int omap_hsmmc_send_cmd(struct udevice
*dev
, struct mmc_cmd
*cmd
,
1039 struct mmc_data
*data
)
1041 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
1042 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
1043 struct mmc
*mmc
= upriv
->mmc
;
1045 struct hsmmc
*mmc_base
;
1046 unsigned int flags
, mmc_stat
;
1048 priv
->last_cmd
= cmd
->cmdidx
;
1050 mmc_base
= priv
->base_addr
;
1052 if (cmd
->cmdidx
== MMC_CMD_STOP_TRANSMISSION
)
1055 start
= get_timer(0);
1056 while ((readl(&mmc_base
->pstate
) & (DATI_MASK
| CMDI_MASK
)) != 0) {
1057 if (get_timer(0) - start
> MAX_RETRY_MS
) {
1058 printf("%s: timedout waiting on cmd inhibit to clear\n",
1060 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
1061 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRC
);
1065 writel(0xFFFFFFFF, &mmc_base
->stat
);
1066 if (readl(&mmc_base
->stat
)) {
1067 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
1068 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRC
);
1073 * CMDIDX[13:8] : Command index
1074 * DATAPRNT[5] : Data Present Select
1075 * ENCMDIDX[4] : Command Index Check Enable
1076 * ENCMDCRC[3] : Command CRC Check Enable
1081 * 11 = Length 48 Check busy after response
1083 /* Delay added before checking the status of frq change
1084 * retry not supported by mmc.c(core file)
1086 if (cmd
->cmdidx
== SD_CMD_APP_SEND_SCR
)
1087 udelay(50000); /* wait 50 ms */
1089 if (!(cmd
->resp_type
& MMC_RSP_PRESENT
))
1091 else if (cmd
->resp_type
& MMC_RSP_136
)
1092 flags
= RSP_TYPE_LGHT136
| CICE_NOCHECK
;
1093 else if (cmd
->resp_type
& MMC_RSP_BUSY
)
1094 flags
= RSP_TYPE_LGHT48B
;
1096 flags
= RSP_TYPE_LGHT48
;
1098 /* enable default flags */
1099 flags
= flags
| (CMD_TYPE_NORMAL
| CICE_NOCHECK
| CCCE_NOCHECK
|
1101 flags
&= ~(ACEN_ENABLE
| BCE_ENABLE
| DE_ENABLE
);
1103 if (cmd
->resp_type
& MMC_RSP_CRC
)
1104 flags
|= CCCE_CHECK
;
1105 if (cmd
->resp_type
& MMC_RSP_OPCODE
)
1106 flags
|= CICE_CHECK
;
1109 if ((cmd
->cmdidx
== MMC_CMD_READ_MULTIPLE_BLOCK
) ||
1110 (cmd
->cmdidx
== MMC_CMD_WRITE_MULTIPLE_BLOCK
)) {
1111 flags
|= (MSBS_MULTIBLK
| BCE_ENABLE
| ACEN_ENABLE
);
1112 data
->blocksize
= 512;
1113 writel(data
->blocksize
| (data
->blocks
<< 16),
1116 writel(data
->blocksize
| NBLK_STPCNT
, &mmc_base
->blk
);
1118 if (data
->flags
& MMC_DATA_READ
)
1119 flags
|= (DP_DATA
| DDIR_READ
);
1121 flags
|= (DP_DATA
| DDIR_WRITE
);
1123 #ifdef CONFIG_MMC_OMAP_HS_ADMA
1124 if ((priv
->controller_flags
& OMAP_HSMMC_USE_ADMA
) &&
1125 !mmc_is_tuning_cmd(cmd
->cmdidx
)) {
1126 omap_hsmmc_prepare_data(mmc
, data
);
1132 mmc_enable_irq(mmc
, cmd
);
1134 writel(cmd
->cmdarg
, &mmc_base
->arg
);
1135 udelay(20); /* To fix "No status update" error on eMMC */
1136 writel((cmd
->cmdidx
<< 24) | flags
, &mmc_base
->cmd
);
1138 start
= get_timer(0);
1140 mmc_stat
= readl(&mmc_base
->stat
);
1141 if (get_timer(start
) > MAX_RETRY_MS
) {
1142 printf("%s : timeout: No status update\n", __func__
);
1145 } while (!mmc_stat
);
1147 if ((mmc_stat
& IE_CTO
) != 0) {
1148 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRC
);
1150 } else if ((mmc_stat
& ERRI_MASK
) != 0)
1153 if (mmc_stat
& CC_MASK
) {
1154 writel(CC_MASK
, &mmc_base
->stat
);
1155 if (cmd
->resp_type
& MMC_RSP_PRESENT
) {
1156 if (cmd
->resp_type
& MMC_RSP_136
) {
1157 /* response type 2 */
1158 cmd
->response
[3] = readl(&mmc_base
->rsp10
);
1159 cmd
->response
[2] = readl(&mmc_base
->rsp32
);
1160 cmd
->response
[1] = readl(&mmc_base
->rsp54
);
1161 cmd
->response
[0] = readl(&mmc_base
->rsp76
);
1163 /* response types 1, 1b, 3, 4, 5, 6 */
1164 cmd
->response
[0] = readl(&mmc_base
->rsp10
);
1168 #ifdef CONFIG_MMC_OMAP_HS_ADMA
1169 if ((priv
->controller_flags
& OMAP_HSMMC_USE_ADMA
) && data
&&
1170 !mmc_is_tuning_cmd(cmd
->cmdidx
)) {
1173 if (mmc_stat
& IE_ADMAE
) {
1174 omap_hsmmc_dma_cleanup(mmc
);
1178 sz_mb
= DIV_ROUND_UP(data
->blocksize
* data
->blocks
, 1 << 20);
1179 timeout
= sz_mb
* DMA_TIMEOUT_PER_MB
;
1180 if (timeout
< MAX_RETRY_MS
)
1181 timeout
= MAX_RETRY_MS
;
1183 start
= get_timer(0);
1185 mmc_stat
= readl(&mmc_base
->stat
);
1186 if (mmc_stat
& TC_MASK
) {
1187 writel(readl(&mmc_base
->stat
) | TC_MASK
,
1191 if (get_timer(start
) > timeout
) {
1192 printf("%s : DMA timeout: No status update\n",
1198 omap_hsmmc_dma_cleanup(mmc
);
1203 if (data
&& (data
->flags
& MMC_DATA_READ
)) {
1204 mmc_read_data(mmc_base
, data
->dest
,
1205 data
->blocksize
* data
->blocks
);
1206 } else if (data
&& (data
->flags
& MMC_DATA_WRITE
)) {
1207 mmc_write_data(mmc_base
, data
->src
,
1208 data
->blocksize
* data
->blocks
);
1213 static int mmc_read_data(struct hsmmc
*mmc_base
, char *buf
, unsigned int size
)
1215 unsigned int *output_buf
= (unsigned int *)buf
;
1216 unsigned int mmc_stat
;
1222 count
= (size
> MMCSD_SECTOR_SIZE
) ? MMCSD_SECTOR_SIZE
: size
;
1226 ulong start
= get_timer(0);
1228 mmc_stat
= readl(&mmc_base
->stat
);
1229 if (get_timer(0) - start
> MAX_RETRY_MS
) {
1230 printf("%s: timedout waiting for status!\n",
1234 } while (mmc_stat
== 0);
1236 if ((mmc_stat
& (IE_DTO
| IE_DCRC
| IE_DEB
)) != 0)
1237 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
1239 if ((mmc_stat
& ERRI_MASK
) != 0)
1242 if (mmc_stat
& BRR_MASK
) {
1245 writel(readl(&mmc_base
->stat
) | BRR_MASK
,
1247 for (k
= 0; k
< count
; k
++) {
1248 *output_buf
= readl(&mmc_base
->data
);
1254 if (mmc_stat
& BWR_MASK
)
1255 writel(readl(&mmc_base
->stat
) | BWR_MASK
,
1258 if (mmc_stat
& TC_MASK
) {
1259 writel(readl(&mmc_base
->stat
) | TC_MASK
,
1267 #if CONFIG_IS_ENABLED(MMC_WRITE)
1268 static int mmc_write_data(struct hsmmc
*mmc_base
, const char *buf
,
1271 unsigned int *input_buf
= (unsigned int *)buf
;
1272 unsigned int mmc_stat
;
1276 * Start Polled Write
1278 count
= (size
> MMCSD_SECTOR_SIZE
) ? MMCSD_SECTOR_SIZE
: size
;
1282 ulong start
= get_timer(0);
1284 mmc_stat
= readl(&mmc_base
->stat
);
1285 if (get_timer(0) - start
> MAX_RETRY_MS
) {
1286 printf("%s: timedout waiting for status!\n",
1290 } while (mmc_stat
== 0);
1292 if ((mmc_stat
& (IE_DTO
| IE_DCRC
| IE_DEB
)) != 0)
1293 mmc_reset_controller_fsm(mmc_base
, SYSCTL_SRD
);
1295 if ((mmc_stat
& ERRI_MASK
) != 0)
1298 if (mmc_stat
& BWR_MASK
) {
1301 writel(readl(&mmc_base
->stat
) | BWR_MASK
,
1303 for (k
= 0; k
< count
; k
++) {
1304 writel(*input_buf
, &mmc_base
->data
);
1310 if (mmc_stat
& BRR_MASK
)
1311 writel(readl(&mmc_base
->stat
) | BRR_MASK
,
1314 if (mmc_stat
& TC_MASK
) {
1315 writel(readl(&mmc_base
->stat
) | TC_MASK
,
1323 static int mmc_write_data(struct hsmmc
*mmc_base
, const char *buf
,
1329 static void omap_hsmmc_stop_clock(struct hsmmc
*mmc_base
)
1331 writel(readl(&mmc_base
->sysctl
) & ~CEN_ENABLE
, &mmc_base
->sysctl
);
1334 static void omap_hsmmc_start_clock(struct hsmmc
*mmc_base
)
1336 writel(readl(&mmc_base
->sysctl
) | CEN_ENABLE
, &mmc_base
->sysctl
);
1339 static void omap_hsmmc_set_clock(struct mmc
*mmc
)
1341 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1342 struct hsmmc
*mmc_base
;
1343 unsigned int dsor
= 0;
1346 mmc_base
= priv
->base_addr
;
1347 omap_hsmmc_stop_clock(mmc_base
);
1349 /* TODO: Is setting DTO required here? */
1350 mmc_reg_out(&mmc_base
->sysctl
, (ICE_MASK
| DTO_MASK
),
1351 (ICE_STOP
| DTO_15THDTO
));
1353 if (mmc
->clock
!= 0) {
1354 dsor
= DIV_ROUND_UP(MMC_CLOCK_REFERENCE
* 1000000, mmc
->clock
);
1355 if (dsor
> CLKD_MAX
)
1361 mmc_reg_out(&mmc_base
->sysctl
, ICE_MASK
| CLKD_MASK
,
1362 (dsor
<< CLKD_OFFSET
) | ICE_OSCILLATE
);
1364 start
= get_timer(0);
1365 while ((readl(&mmc_base
->sysctl
) & ICS_MASK
) == ICS_NOTREADY
) {
1366 if (get_timer(0) - start
> MAX_RETRY_MS
) {
1367 printf("%s: timedout waiting for ics!\n", __func__
);
1372 priv
->clock
= MMC_CLOCK_REFERENCE
* 1000000 / dsor
;
1373 mmc
->clock
= priv
->clock
;
1374 omap_hsmmc_start_clock(mmc_base
);
1377 static void omap_hsmmc_set_bus_width(struct mmc
*mmc
)
1379 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1380 struct hsmmc
*mmc_base
;
1382 mmc_base
= priv
->base_addr
;
1383 /* configue bus width */
1384 switch (mmc
->bus_width
) {
1386 writel(readl(&mmc_base
->con
) | DTW_8_BITMODE
,
1391 writel(readl(&mmc_base
->con
) & ~DTW_8_BITMODE
,
1393 writel(readl(&mmc_base
->hctl
) | DTW_4_BITMODE
,
1399 writel(readl(&mmc_base
->con
) & ~DTW_8_BITMODE
,
1401 writel(readl(&mmc_base
->hctl
) & ~DTW_4_BITMODE
,
1406 priv
->bus_width
= mmc
->bus_width
;
1409 #if !CONFIG_IS_ENABLED(DM_MMC)
1410 static int omap_hsmmc_set_ios(struct mmc
*mmc
)
1412 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1414 static int omap_hsmmc_set_ios(struct udevice
*dev
)
1416 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
1417 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
1418 struct mmc
*mmc
= upriv
->mmc
;
1420 struct hsmmc
*mmc_base
= priv
->base_addr
;
1423 if (priv
->bus_width
!= mmc
->bus_width
)
1424 omap_hsmmc_set_bus_width(mmc
);
1426 if (priv
->clock
!= mmc
->clock
)
1427 omap_hsmmc_set_clock(mmc
);
1429 if (mmc
->clk_disable
)
1430 omap_hsmmc_stop_clock(mmc_base
);
1432 omap_hsmmc_start_clock(mmc_base
);
1434 #if CONFIG_IS_ENABLED(DM_MMC)
1435 if (priv
->mode
!= mmc
->selected_mode
)
1436 omap_hsmmc_set_timing(mmc
);
1438 #if CONFIG_IS_ENABLED(MMC_IO_VOLTAGE)
1439 if (priv
->signal_voltage
!= mmc
->signal_voltage
)
1440 ret
= omap_hsmmc_set_signal_voltage(mmc
);
1446 #ifdef OMAP_HSMMC_USE_GPIO
1447 #if CONFIG_IS_ENABLED(DM_MMC)
1448 static int omap_hsmmc_getcd(struct udevice
*dev
)
1451 #if CONFIG_IS_ENABLED(DM_GPIO)
1452 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
1453 value
= dm_gpio_get_value(&priv
->cd_gpio
);
1455 /* if no CD return as 1 */
1462 static int omap_hsmmc_getwp(struct udevice
*dev
)
1465 #if CONFIG_IS_ENABLED(DM_GPIO)
1466 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
1467 value
= dm_gpio_get_value(&priv
->wp_gpio
);
1469 /* if no WP return as 0 */
1475 static int omap_hsmmc_getcd(struct mmc
*mmc
)
1477 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1480 /* if no CD return as 1 */
1481 cd_gpio
= priv
->cd_gpio
;
1485 /* NOTE: assumes card detect signal is active-low */
1486 return !gpio_get_value(cd_gpio
);
1489 static int omap_hsmmc_getwp(struct mmc
*mmc
)
1491 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1494 /* if no WP return as 0 */
1495 wp_gpio
= priv
->wp_gpio
;
1499 /* NOTE: assumes write protect signal is active-high */
1500 return gpio_get_value(wp_gpio
);
1505 #if CONFIG_IS_ENABLED(DM_MMC)
1506 static const struct dm_mmc_ops omap_hsmmc_ops
= {
1507 .send_cmd
= omap_hsmmc_send_cmd
,
1508 .set_ios
= omap_hsmmc_set_ios
,
1509 #ifdef OMAP_HSMMC_USE_GPIO
1510 .get_cd
= omap_hsmmc_getcd
,
1511 .get_wp
= omap_hsmmc_getwp
,
1513 #ifdef MMC_SUPPORTS_TUNING
1514 .execute_tuning
= omap_hsmmc_execute_tuning
,
1516 .wait_dat0
= omap_hsmmc_wait_dat0
,
1519 static const struct mmc_ops omap_hsmmc_ops
= {
1520 .send_cmd
= omap_hsmmc_send_cmd
,
1521 .set_ios
= omap_hsmmc_set_ios
,
1522 .init
= omap_hsmmc_init_setup
,
1523 #ifdef OMAP_HSMMC_USE_GPIO
1524 .getcd
= omap_hsmmc_getcd
,
1525 .getwp
= omap_hsmmc_getwp
,
1530 #if !CONFIG_IS_ENABLED(DM_MMC)
1531 int omap_mmc_init(int dev_index
, uint host_caps_mask
, uint f_max
, int cd_gpio
,
1535 struct omap_hsmmc_data
*priv
;
1536 struct mmc_config
*cfg
;
1539 priv
= calloc(1, sizeof(*priv
));
1543 host_caps_val
= MMC_MODE_4BIT
| MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
1545 switch (dev_index
) {
1547 priv
->base_addr
= (struct hsmmc
*)OMAP_HSMMC1_BASE
;
1549 #ifdef OMAP_HSMMC2_BASE
1551 priv
->base_addr
= (struct hsmmc
*)OMAP_HSMMC2_BASE
;
1552 #if (defined(CONFIG_OMAP44XX) || defined(CONFIG_OMAP54XX) || \
1553 defined(CONFIG_DRA7XX) || defined(CONFIG_AM33XX) || \
1554 defined(CONFIG_AM43XX) || defined(CONFIG_SOC_KEYSTONE)) && \
1555 defined(CONFIG_HSMMC2_8BIT)
1556 /* Enable 8-bit interface for eMMC on OMAP4/5 or DRA7XX */
1557 host_caps_val
|= MMC_MODE_8BIT
;
1561 #ifdef OMAP_HSMMC3_BASE
1563 priv
->base_addr
= (struct hsmmc
*)OMAP_HSMMC3_BASE
;
1564 #if defined(CONFIG_DRA7XX) && defined(CONFIG_HSMMC3_8BIT)
1565 /* Enable 8-bit interface for eMMC on DRA7XX */
1566 host_caps_val
|= MMC_MODE_8BIT
;
1571 priv
->base_addr
= (struct hsmmc
*)OMAP_HSMMC1_BASE
;
1574 #ifdef OMAP_HSMMC_USE_GPIO
1575 /* on error gpio values are set to -1, which is what we want */
1576 priv
->cd_gpio
= omap_mmc_setup_gpio_in(cd_gpio
, "mmc_cd");
1577 priv
->wp_gpio
= omap_mmc_setup_gpio_in(wp_gpio
, "mmc_wp");
1582 cfg
->name
= "OMAP SD/MMC";
1583 cfg
->ops
= &omap_hsmmc_ops
;
1585 cfg
->voltages
= MMC_VDD_32_33
| MMC_VDD_33_34
| MMC_VDD_165_195
;
1586 cfg
->host_caps
= host_caps_val
& ~host_caps_mask
;
1588 cfg
->f_min
= 400000;
1593 if (cfg
->host_caps
& MMC_MODE_HS
) {
1594 if (cfg
->host_caps
& MMC_MODE_HS_52MHz
)
1595 cfg
->f_max
= 52000000;
1597 cfg
->f_max
= 26000000;
1599 cfg
->f_max
= 20000000;
1602 cfg
->b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
1604 #if defined(CONFIG_OMAP34XX)
1606 * Silicon revs 2.1 and older do not support multiblock transfers.
1608 if ((get_cpu_family() == CPU_OMAP34XX
) && (get_cpu_rev() <= CPU_3XX_ES21
))
1612 mmc
= mmc_create(cfg
, priv
);
1620 #ifdef CONFIG_IODELAY_RECALIBRATION
1621 static struct pad_conf_entry
*
1622 omap_hsmmc_get_pad_conf_entry(const fdt32_t
*pinctrl
, int count
)
1625 struct pad_conf_entry
*padconf
;
1627 padconf
= (struct pad_conf_entry
*)malloc(sizeof(*padconf
) * count
);
1629 debug("failed to allocate memory\n");
1633 while (index
< count
) {
1634 padconf
[index
].offset
= fdt32_to_cpu(pinctrl
[2 * index
]);
1635 padconf
[index
].val
= fdt32_to_cpu(pinctrl
[2 * index
+ 1]);
1642 static struct iodelay_cfg_entry
*
1643 omap_hsmmc_get_iodelay_cfg_entry(const fdt32_t
*pinctrl
, int count
)
1646 struct iodelay_cfg_entry
*iodelay
;
1648 iodelay
= (struct iodelay_cfg_entry
*)malloc(sizeof(*iodelay
) * count
);
1650 debug("failed to allocate memory\n");
1654 while (index
< count
) {
1655 iodelay
[index
].offset
= fdt32_to_cpu(pinctrl
[3 * index
]);
1656 iodelay
[index
].a_delay
= fdt32_to_cpu(pinctrl
[3 * index
+ 1]);
1657 iodelay
[index
].g_delay
= fdt32_to_cpu(pinctrl
[3 * index
+ 2]);
1664 static const fdt32_t
*omap_hsmmc_get_pinctrl_entry(u32 phandle
,
1665 const char *name
, int *len
)
1667 const void *fdt
= gd
->fdt_blob
;
1669 const fdt32_t
*pinctrl
;
1671 offset
= fdt_node_offset_by_phandle(fdt
, phandle
);
1673 debug("failed to get pinctrl node %s.\n",
1674 fdt_strerror(offset
));
1678 pinctrl
= fdt_getprop(fdt
, offset
, name
, len
);
1680 debug("failed to get property %s\n", name
);
1687 static uint32_t omap_hsmmc_get_pad_conf_phandle(struct mmc
*mmc
,
1690 const void *fdt
= gd
->fdt_blob
;
1691 const __be32
*phandle
;
1692 int node
= dev_of_offset(mmc
->dev
);
1694 phandle
= fdt_getprop(fdt
, node
, prop_name
, NULL
);
1696 debug("failed to get property %s\n", prop_name
);
1700 return fdt32_to_cpu(*phandle
);
1703 static uint32_t omap_hsmmc_get_iodelay_phandle(struct mmc
*mmc
,
1706 const void *fdt
= gd
->fdt_blob
;
1707 const __be32
*phandle
;
1710 int node
= dev_of_offset(mmc
->dev
);
1712 phandle
= fdt_getprop(fdt
, node
, prop_name
, &len
);
1714 debug("failed to get property %s\n", prop_name
);
1718 /* No manual mode iodelay values if count < 2 */
1719 count
= len
/ sizeof(*phandle
);
1723 return fdt32_to_cpu(*(phandle
+ 1));
1726 static struct pad_conf_entry
*
1727 omap_hsmmc_get_pad_conf(struct mmc
*mmc
, char *prop_name
, int *npads
)
1731 struct pad_conf_entry
*padconf
;
1733 const fdt32_t
*pinctrl
;
1735 phandle
= omap_hsmmc_get_pad_conf_phandle(mmc
, prop_name
);
1737 return ERR_PTR(-EINVAL
);
1739 pinctrl
= omap_hsmmc_get_pinctrl_entry(phandle
, "pinctrl-single,pins",
1742 return ERR_PTR(-EINVAL
);
1744 count
= (len
/ sizeof(*pinctrl
)) / 2;
1745 padconf
= omap_hsmmc_get_pad_conf_entry(pinctrl
, count
);
1747 return ERR_PTR(-EINVAL
);
1754 static struct iodelay_cfg_entry
*
1755 omap_hsmmc_get_iodelay(struct mmc
*mmc
, char *prop_name
, int *niodelay
)
1759 struct iodelay_cfg_entry
*iodelay
;
1761 const fdt32_t
*pinctrl
;
1763 phandle
= omap_hsmmc_get_iodelay_phandle(mmc
, prop_name
);
1764 /* Not all modes have manual mode iodelay values. So its not fatal */
1768 pinctrl
= omap_hsmmc_get_pinctrl_entry(phandle
, "pinctrl-pin-array",
1771 return ERR_PTR(-EINVAL
);
1773 count
= (len
/ sizeof(*pinctrl
)) / 3;
1774 iodelay
= omap_hsmmc_get_iodelay_cfg_entry(pinctrl
, count
);
1776 return ERR_PTR(-EINVAL
);
1783 static struct omap_hsmmc_pinctrl_state
*
1784 omap_hsmmc_get_pinctrl_by_mode(struct mmc
*mmc
, char *mode
)
1789 const void *fdt
= gd
->fdt_blob
;
1790 int node
= dev_of_offset(mmc
->dev
);
1792 struct omap_hsmmc_pinctrl_state
*pinctrl_state
;
1794 pinctrl_state
= (struct omap_hsmmc_pinctrl_state
*)
1795 malloc(sizeof(*pinctrl_state
));
1796 if (!pinctrl_state
) {
1797 debug("failed to allocate memory\n");
1801 index
= fdt_stringlist_search(fdt
, node
, "pinctrl-names", mode
);
1803 debug("fail to find %s mode %s\n", mode
, fdt_strerror(index
));
1804 goto err_pinctrl_state
;
1807 sprintf(prop_name
, "pinctrl-%d", index
);
1809 pinctrl_state
->padconf
= omap_hsmmc_get_pad_conf(mmc
, prop_name
,
1811 if (IS_ERR(pinctrl_state
->padconf
))
1812 goto err_pinctrl_state
;
1813 pinctrl_state
->npads
= npads
;
1815 pinctrl_state
->iodelay
= omap_hsmmc_get_iodelay(mmc
, prop_name
,
1817 if (IS_ERR(pinctrl_state
->iodelay
))
1819 pinctrl_state
->niodelays
= niodelays
;
1821 return pinctrl_state
;
1824 kfree(pinctrl_state
->padconf
);
1827 kfree(pinctrl_state
);
1831 #define OMAP_HSMMC_SETUP_PINCTRL(capmask, mode, optional) \
1833 struct omap_hsmmc_pinctrl_state *s = NULL; \
1835 if (!(cfg->host_caps & capmask)) \
1838 if (priv->hw_rev) { \
1839 sprintf(str, "%s-%s", #mode, priv->hw_rev); \
1840 s = omap_hsmmc_get_pinctrl_by_mode(mmc, str); \
1844 s = omap_hsmmc_get_pinctrl_by_mode(mmc, #mode); \
1846 if (!s && !optional) { \
1847 debug("%s: no pinctrl for %s\n", \
1848 mmc->dev->name, #mode); \
1849 cfg->host_caps &= ~(capmask); \
1851 priv->mode##_pinctrl_state = s; \
1855 static int omap_hsmmc_get_pinctrl_state(struct mmc
*mmc
)
1857 struct omap_hsmmc_data
*priv
= omap_hsmmc_get_data(mmc
);
1858 struct mmc_config
*cfg
= omap_hsmmc_get_cfg(mmc
);
1859 struct omap_hsmmc_pinctrl_state
*default_pinctrl
;
1861 if (!(priv
->controller_flags
& OMAP_HSMMC_REQUIRE_IODELAY
))
1864 default_pinctrl
= omap_hsmmc_get_pinctrl_by_mode(mmc
, "default");
1865 if (!default_pinctrl
) {
1866 printf("no pinctrl state for default mode\n");
1870 priv
->default_pinctrl_state
= default_pinctrl
;
1872 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(UHS_SDR104
), sdr104
, false);
1873 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(UHS_SDR50
), sdr50
, false);
1874 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(UHS_DDR50
), ddr50
, false);
1875 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(UHS_SDR25
), sdr25
, false);
1876 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(UHS_SDR12
), sdr12
, false);
1878 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(MMC_HS_200
), hs200_1_8v
, false);
1879 OMAP_HSMMC_SETUP_PINCTRL(MMC_CAP(MMC_DDR_52
), ddr_1_8v
, false);
1880 OMAP_HSMMC_SETUP_PINCTRL(MMC_MODE_HS
, hs
, true);
1886 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
1887 #ifdef CONFIG_OMAP54XX
1888 __weak
const struct mmc_platform_fixups
*platform_fixups_mmc(uint32_t addr
)
1894 static int omap_hsmmc_ofdata_to_platdata(struct udevice
*dev
)
1896 struct omap_hsmmc_plat
*plat
= dev_get_platdata(dev
);
1897 struct omap_mmc_of_data
*of_data
= (void *)dev_get_driver_data(dev
);
1899 struct mmc_config
*cfg
= &plat
->cfg
;
1900 #ifdef CONFIG_OMAP54XX
1901 const struct mmc_platform_fixups
*fixups
;
1903 const void *fdt
= gd
->fdt_blob
;
1904 int node
= dev_of_offset(dev
);
1907 plat
->base_addr
= map_physmem(devfdt_get_addr(dev
),
1908 sizeof(struct hsmmc
*),
1911 ret
= mmc_of_parse(dev
, cfg
);
1916 cfg
->f_max
= 52000000;
1917 cfg
->host_caps
|= MMC_MODE_HS_52MHz
| MMC_MODE_HS
;
1918 cfg
->f_min
= 400000;
1919 cfg
->voltages
= MMC_VDD_32_33
| MMC_VDD_33_34
| MMC_VDD_165_195
;
1920 cfg
->b_max
= CONFIG_SYS_MMC_MAX_BLK_COUNT
;
1921 if (fdtdec_get_bool(fdt
, node
, "ti,dual-volt"))
1922 plat
->controller_flags
|= OMAP_HSMMC_SUPPORTS_DUAL_VOLT
;
1923 if (fdtdec_get_bool(fdt
, node
, "no-1-8-v"))
1924 plat
->controller_flags
|= OMAP_HSMMC_NO_1_8_V
;
1926 plat
->controller_flags
|= of_data
->controller_flags
;
1928 #ifdef CONFIG_OMAP54XX
1929 fixups
= platform_fixups_mmc(devfdt_get_addr(dev
));
1931 plat
->hw_rev
= fixups
->hw_rev
;
1932 cfg
->host_caps
&= ~fixups
->unsupported_caps
;
1933 cfg
->f_max
= fixups
->max_freq
;
1943 static int omap_hsmmc_bind(struct udevice
*dev
)
1945 struct omap_hsmmc_plat
*plat
= dev_get_platdata(dev
);
1946 plat
->mmc
= calloc(1, sizeof(struct mmc
));
1947 return mmc_bind(dev
, plat
->mmc
, &plat
->cfg
);
1950 static int omap_hsmmc_probe(struct udevice
*dev
)
1952 struct omap_hsmmc_plat
*plat
= dev_get_platdata(dev
);
1953 struct mmc_uclass_priv
*upriv
= dev_get_uclass_priv(dev
);
1954 struct omap_hsmmc_data
*priv
= dev_get_priv(dev
);
1955 struct mmc_config
*cfg
= &plat
->cfg
;
1957 #ifdef CONFIG_IODELAY_RECALIBRATION
1961 cfg
->name
= "OMAP SD/MMC";
1962 priv
->base_addr
= plat
->base_addr
;
1963 priv
->controller_flags
= plat
->controller_flags
;
1964 priv
->hw_rev
= plat
->hw_rev
;
1969 mmc
= mmc_create(cfg
, priv
);
1973 #if CONFIG_IS_ENABLED(DM_REGULATOR)
1974 device_get_supply_regulator(dev
, "pbias-supply",
1975 &priv
->pbias_supply
);
1977 #if defined(OMAP_HSMMC_USE_GPIO)
1978 #if CONFIG_IS_ENABLED(OF_CONTROL) && CONFIG_IS_ENABLED(DM_GPIO)
1979 gpio_request_by_name(dev
, "cd-gpios", 0, &priv
->cd_gpio
, GPIOD_IS_IN
);
1980 gpio_request_by_name(dev
, "wp-gpios", 0, &priv
->wp_gpio
, GPIOD_IS_IN
);
1987 #ifdef CONFIG_IODELAY_RECALIBRATION
1988 ret
= omap_hsmmc_get_pinctrl_state(mmc
);
1990 * disable high speed modes for the platforms that require IO delay
1991 * and for which we don't have this information
1994 (priv
->controller_flags
& OMAP_HSMMC_REQUIRE_IODELAY
)) {
1995 priv
->controller_flags
&= ~OMAP_HSMMC_REQUIRE_IODELAY
;
1996 cfg
->host_caps
&= ~(MMC_CAP(MMC_HS_200
) | MMC_CAP(MMC_DDR_52
) |
2001 return omap_hsmmc_init_setup(mmc
);
2004 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
2006 static const struct omap_mmc_of_data dra7_mmc_of_data
= {
2007 .controller_flags
= OMAP_HSMMC_REQUIRE_IODELAY
,
2010 static const struct udevice_id omap_hsmmc_ids
[] = {
2011 { .compatible
= "ti,omap3-hsmmc" },
2012 { .compatible
= "ti,omap4-hsmmc" },
2013 { .compatible
= "ti,am33xx-hsmmc" },
2014 { .compatible
= "ti,dra7-hsmmc", .data
= (ulong
)&dra7_mmc_of_data
},
2019 U_BOOT_DRIVER(omap_hsmmc
) = {
2020 .name
= "omap_hsmmc",
2022 #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
2023 .of_match
= omap_hsmmc_ids
,
2024 .ofdata_to_platdata
= omap_hsmmc_ofdata_to_platdata
,
2025 .platdata_auto_alloc_size
= sizeof(struct omap_hsmmc_plat
),
2028 .bind
= omap_hsmmc_bind
,
2030 .ops
= &omap_hsmmc_ops
,
2031 .probe
= omap_hsmmc_probe
,
2032 .priv_auto_alloc_size
= sizeof(struct omap_hsmmc_data
),
2033 #if !CONFIG_IS_ENABLED(OF_CONTROL)
2034 .flags
= DM_FLAG_PRE_RELOC
,