fsl_esdhc_imx.c 43 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2007, 2010-2011 Freescale Semiconductor, Inc
  4. * Copyright 2019 NXP Semiconductors
  5. * Andy Fleming
  6. * Yangbo Lu <yangbo.lu@nxp.com>
  7. *
  8. * Based vaguely on the pxa mmc code:
  9. * (C) Copyright 2003
  10. * Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net
  11. */
  12. #include <config.h>
  13. #include <common.h>
  14. #include <command.h>
  15. #include <clk.h>
  16. #include <cpu_func.h>
  17. #include <errno.h>
  18. #include <hwconfig.h>
  19. #include <log.h>
  20. #include <mmc.h>
  21. #include <part.h>
  22. #include <asm/cache.h>
  23. #include <dm/device_compat.h>
  24. #include <linux/bitops.h>
  25. #include <linux/delay.h>
  26. #include <linux/err.h>
  27. #include <power/regulator.h>
  28. #include <malloc.h>
  29. #include <fsl_esdhc_imx.h>
  30. #include <fdt_support.h>
  31. #include <asm/io.h>
  32. #include <dm.h>
  33. #include <asm-generic/gpio.h>
  34. #include <dm/pinctrl.h>
  35. #include <dt-structs.h>
  36. #include <mapmem.h>
  37. #include <dm/ofnode.h>
  38. #include <linux/iopoll.h>
  39. #if !CONFIG_IS_ENABLED(BLK)
  40. #include "mmc_private.h"
  41. #endif
  42. DECLARE_GLOBAL_DATA_PTR;
  43. #define SDHCI_IRQ_EN_BITS (IRQSTATEN_CC | IRQSTATEN_TC | \
  44. IRQSTATEN_CINT | \
  45. IRQSTATEN_CTOE | IRQSTATEN_CCE | IRQSTATEN_CEBE | \
  46. IRQSTATEN_CIE | IRQSTATEN_DTOE | IRQSTATEN_DCE | \
  47. IRQSTATEN_DEBE | IRQSTATEN_BRR | IRQSTATEN_BWR | \
  48. IRQSTATEN_DINT)
  49. #define MAX_TUNING_LOOP 40
  50. #define ESDHC_DRIVER_STAGE_VALUE 0xffffffff
  51. struct fsl_esdhc {
  52. uint dsaddr; /* SDMA system address register */
  53. uint blkattr; /* Block attributes register */
  54. uint cmdarg; /* Command argument register */
  55. uint xfertyp; /* Transfer type register */
  56. uint cmdrsp0; /* Command response 0 register */
  57. uint cmdrsp1; /* Command response 1 register */
  58. uint cmdrsp2; /* Command response 2 register */
  59. uint cmdrsp3; /* Command response 3 register */
  60. uint datport; /* Buffer data port register */
  61. uint prsstat; /* Present state register */
  62. uint proctl; /* Protocol control register */
  63. uint sysctl; /* System Control Register */
  64. uint irqstat; /* Interrupt status register */
  65. uint irqstaten; /* Interrupt status enable register */
  66. uint irqsigen; /* Interrupt signal enable register */
  67. uint autoc12err; /* Auto CMD error status register */
  68. uint hostcapblt; /* Host controller capabilities register */
  69. uint wml; /* Watermark level register */
  70. uint mixctrl; /* For USDHC */
  71. char reserved1[4]; /* reserved */
  72. uint fevt; /* Force event register */
  73. uint admaes; /* ADMA error status register */
  74. uint adsaddr; /* ADMA system address register */
  75. char reserved2[4];
  76. uint dllctrl;
  77. uint dllstat;
  78. uint clktunectrlstatus;
  79. char reserved3[4];
  80. uint strobe_dllctrl;
  81. uint strobe_dllstat;
  82. char reserved4[72];
  83. uint vendorspec;
  84. uint mmcboot;
  85. uint vendorspec2;
  86. uint tuning_ctrl; /* on i.MX6/7/8/RT */
  87. char reserved5[44];
  88. uint hostver; /* Host controller version register */
  89. char reserved6[4]; /* reserved */
  90. uint dmaerraddr; /* DMA error address register */
  91. char reserved7[4]; /* reserved */
  92. uint dmaerrattr; /* DMA error attribute register */
  93. char reserved8[4]; /* reserved */
  94. uint hostcapblt2; /* Host controller capabilities register 2 */
  95. char reserved9[8]; /* reserved */
  96. uint tcr; /* Tuning control register */
  97. char reserved10[28]; /* reserved */
  98. uint sddirctl; /* SD direction control register */
  99. char reserved11[712];/* reserved */
  100. uint scr; /* eSDHC control register */
  101. };
  102. struct fsl_esdhc_plat {
  103. #if CONFIG_IS_ENABLED(OF_PLATDATA)
  104. /* Put this first since driver model will copy the data here */
  105. struct dtd_fsl_esdhc dtplat;
  106. #endif
  107. struct mmc_config cfg;
  108. struct mmc mmc;
  109. };
  110. struct esdhc_soc_data {
  111. u32 flags;
  112. };
  113. /**
  114. * struct fsl_esdhc_priv
  115. *
  116. * @esdhc_regs: registers of the sdhc controller
  117. * @sdhc_clk: Current clk of the sdhc controller
  118. * @bus_width: bus width, 1bit, 4bit or 8bit
  119. * @cfg: mmc config
  120. * @mmc: mmc
  121. * Following is used when Driver Model is enabled for MMC
  122. * @dev: pointer for the device
  123. * @non_removable: 0: removable; 1: non-removable
  124. * @broken_cd: 0: use GPIO for card detect; 1: Do not use GPIO for card detect
  125. * @wp_enable: 1: enable checking wp; 0: no check
  126. * @vs18_enable: 1: use 1.8V voltage; 0: use 3.3V
  127. * @flags: ESDHC_FLAG_xx in include/fsl_esdhc_imx.h
  128. * @caps: controller capabilities
  129. * @tuning_step: tuning step setting in tuning_ctrl register
  130. * @start_tuning_tap: the start point for tuning in tuning_ctrl register
  131. * @strobe_dll_delay_target: settings in strobe_dllctrl
  132. * @signal_voltage: indicating the current voltage
  133. * @cd_gpio: gpio for card detection
  134. * @wp_gpio: gpio for write protection
  135. */
  136. struct fsl_esdhc_priv {
  137. struct fsl_esdhc *esdhc_regs;
  138. unsigned int sdhc_clk;
  139. struct clk per_clk;
  140. unsigned int clock;
  141. unsigned int mode;
  142. unsigned int bus_width;
  143. #if !CONFIG_IS_ENABLED(BLK)
  144. struct mmc *mmc;
  145. #endif
  146. struct udevice *dev;
  147. int non_removable;
  148. int broken_cd;
  149. int wp_enable;
  150. int vs18_enable;
  151. u32 flags;
  152. u32 caps;
  153. u32 tuning_step;
  154. u32 tuning_start_tap;
  155. u32 strobe_dll_delay_target;
  156. u32 signal_voltage;
  157. #if CONFIG_IS_ENABLED(DM_REGULATOR)
  158. struct udevice *vqmmc_dev;
  159. struct udevice *vmmc_dev;
  160. #endif
  161. #if CONFIG_IS_ENABLED(DM_GPIO)
  162. struct gpio_desc cd_gpio;
  163. struct gpio_desc wp_gpio;
  164. #endif
  165. };
  166. /* Return the XFERTYP flags for a given command and data packet */
  167. static uint esdhc_xfertyp(struct mmc_cmd *cmd, struct mmc_data *data)
  168. {
  169. uint xfertyp = 0;
  170. if (data) {
  171. xfertyp |= XFERTYP_DPSEL;
  172. #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
  173. xfertyp |= XFERTYP_DMAEN;
  174. #endif
  175. if (data->blocks > 1) {
  176. xfertyp |= XFERTYP_MSBSEL;
  177. xfertyp |= XFERTYP_BCEN;
  178. #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
  179. xfertyp |= XFERTYP_AC12EN;
  180. #endif
  181. }
  182. if (data->flags & MMC_DATA_READ)
  183. xfertyp |= XFERTYP_DTDSEL;
  184. }
  185. if (cmd->resp_type & MMC_RSP_CRC)
  186. xfertyp |= XFERTYP_CCCEN;
  187. if (cmd->resp_type & MMC_RSP_OPCODE)
  188. xfertyp |= XFERTYP_CICEN;
  189. if (cmd->resp_type & MMC_RSP_136)
  190. xfertyp |= XFERTYP_RSPTYP_136;
  191. else if (cmd->resp_type & MMC_RSP_BUSY)
  192. xfertyp |= XFERTYP_RSPTYP_48_BUSY;
  193. else if (cmd->resp_type & MMC_RSP_PRESENT)
  194. xfertyp |= XFERTYP_RSPTYP_48;
  195. if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
  196. xfertyp |= XFERTYP_CMDTYP_ABORT;
  197. return XFERTYP_CMD(cmd->cmdidx) | xfertyp;
  198. }
  199. #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
  200. /*
  201. * PIO Read/Write Mode reduce the performace as DMA is not used in this mode.
  202. */
  203. static void esdhc_pio_read_write(struct fsl_esdhc_priv *priv,
  204. struct mmc_data *data)
  205. {
  206. struct fsl_esdhc *regs = priv->esdhc_regs;
  207. uint blocks;
  208. char *buffer;
  209. uint databuf;
  210. uint size;
  211. uint irqstat;
  212. ulong start;
  213. if (data->flags & MMC_DATA_READ) {
  214. blocks = data->blocks;
  215. buffer = data->dest;
  216. while (blocks) {
  217. start = get_timer(0);
  218. size = data->blocksize;
  219. irqstat = esdhc_read32(&regs->irqstat);
  220. while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BREN)) {
  221. if (get_timer(start) > PIO_TIMEOUT) {
  222. printf("\nData Read Failed in PIO Mode.");
  223. return;
  224. }
  225. }
  226. while (size && (!(irqstat & IRQSTAT_TC))) {
  227. udelay(100); /* Wait before last byte transfer complete */
  228. irqstat = esdhc_read32(&regs->irqstat);
  229. databuf = in_le32(&regs->datport);
  230. *((uint *)buffer) = databuf;
  231. buffer += 4;
  232. size -= 4;
  233. }
  234. blocks--;
  235. }
  236. } else {
  237. blocks = data->blocks;
  238. buffer = (char *)data->src;
  239. while (blocks) {
  240. start = get_timer(0);
  241. size = data->blocksize;
  242. irqstat = esdhc_read32(&regs->irqstat);
  243. while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_BWEN)) {
  244. if (get_timer(start) > PIO_TIMEOUT) {
  245. printf("\nData Write Failed in PIO Mode.");
  246. return;
  247. }
  248. }
  249. while (size && (!(irqstat & IRQSTAT_TC))) {
  250. udelay(100); /* Wait before last byte transfer complete */
  251. databuf = *((uint *)buffer);
  252. buffer += 4;
  253. size -= 4;
  254. irqstat = esdhc_read32(&regs->irqstat);
  255. out_le32(&regs->datport, databuf);
  256. }
  257. blocks--;
  258. }
  259. }
  260. }
  261. #endif
  262. static int esdhc_setup_data(struct fsl_esdhc_priv *priv, struct mmc *mmc,
  263. struct mmc_data *data)
  264. {
  265. int timeout;
  266. struct fsl_esdhc *regs = priv->esdhc_regs;
  267. #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
  268. dma_addr_t addr;
  269. #endif
  270. uint wml_value;
  271. wml_value = data->blocksize/4;
  272. if (data->flags & MMC_DATA_READ) {
  273. if (wml_value > WML_RD_WML_MAX)
  274. wml_value = WML_RD_WML_MAX_VAL;
  275. esdhc_clrsetbits32(&regs->wml, WML_RD_WML_MASK, wml_value);
  276. #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
  277. #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
  278. addr = virt_to_phys((void *)(data->dest));
  279. if (upper_32_bits(addr))
  280. printf("Error found for upper 32 bits\n");
  281. else
  282. esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
  283. #else
  284. esdhc_write32(&regs->dsaddr, (u32)data->dest);
  285. #endif
  286. #endif
  287. } else {
  288. #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
  289. flush_dcache_range((ulong)data->src,
  290. (ulong)data->src+data->blocks
  291. *data->blocksize);
  292. #endif
  293. if (wml_value > WML_WR_WML_MAX)
  294. wml_value = WML_WR_WML_MAX_VAL;
  295. if (priv->wp_enable) {
  296. if ((esdhc_read32(&regs->prsstat) &
  297. PRSSTAT_WPSPL) == 0) {
  298. printf("\nThe SD card is locked. Can not write to a locked card.\n\n");
  299. return -ETIMEDOUT;
  300. }
  301. } else {
  302. #if CONFIG_IS_ENABLED(DM_GPIO)
  303. if (dm_gpio_is_valid(&priv->wp_gpio) &&
  304. dm_gpio_get_value(&priv->wp_gpio)) {
  305. printf("\nThe SD card is locked. Can not write to a locked card.\n\n");
  306. return -ETIMEDOUT;
  307. }
  308. #endif
  309. }
  310. esdhc_clrsetbits32(&regs->wml, WML_WR_WML_MASK,
  311. wml_value << 16);
  312. #ifndef CONFIG_SYS_FSL_ESDHC_USE_PIO
  313. #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
  314. addr = virt_to_phys((void *)(data->src));
  315. if (upper_32_bits(addr))
  316. printf("Error found for upper 32 bits\n");
  317. else
  318. esdhc_write32(&regs->dsaddr, lower_32_bits(addr));
  319. #else
  320. esdhc_write32(&regs->dsaddr, (u32)data->src);
  321. #endif
  322. #endif
  323. }
  324. esdhc_write32(&regs->blkattr, data->blocks << 16 | data->blocksize);
  325. /* Calculate the timeout period for data transactions */
  326. /*
  327. * 1)Timeout period = (2^(timeout+13)) SD Clock cycles
  328. * 2)Timeout period should be minimum 0.250sec as per SD Card spec
  329. * So, Number of SD Clock cycles for 0.25sec should be minimum
  330. * (SD Clock/sec * 0.25 sec) SD Clock cycles
  331. * = (mmc->clock * 1/4) SD Clock cycles
  332. * As 1) >= 2)
  333. * => (2^(timeout+13)) >= mmc->clock * 1/4
  334. * Taking log2 both the sides
  335. * => timeout + 13 >= log2(mmc->clock/4)
  336. * Rounding up to next power of 2
  337. * => timeout + 13 = log2(mmc->clock/4) + 1
  338. * => timeout + 13 = fls(mmc->clock/4)
  339. *
  340. * However, the MMC spec "It is strongly recommended for hosts to
  341. * implement more than 500ms timeout value even if the card
  342. * indicates the 250ms maximum busy length." Even the previous
  343. * value of 300ms is known to be insufficient for some cards.
  344. * So, we use
  345. * => timeout + 13 = fls(mmc->clock/2)
  346. */
  347. timeout = fls(mmc->clock/2);
  348. timeout -= 13;
  349. if (timeout > 14)
  350. timeout = 14;
  351. if (timeout < 0)
  352. timeout = 0;
  353. #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC_A001
  354. if ((timeout == 4) || (timeout == 8) || (timeout == 12))
  355. timeout++;
  356. #endif
  357. #ifdef ESDHCI_QUIRK_BROKEN_TIMEOUT_VALUE
  358. timeout = 0xE;
  359. #endif
  360. esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, timeout << 16);
  361. return 0;
  362. }
  363. static void check_and_invalidate_dcache_range
  364. (struct mmc_cmd *cmd,
  365. struct mmc_data *data) {
  366. unsigned start = 0;
  367. unsigned end = 0;
  368. unsigned size = roundup(ARCH_DMA_MINALIGN,
  369. data->blocks*data->blocksize);
  370. #if defined(CONFIG_S32V234) || defined(CONFIG_IMX8) || defined(CONFIG_IMX8M)
  371. dma_addr_t addr;
  372. addr = virt_to_phys((void *)(data->dest));
  373. if (upper_32_bits(addr))
  374. printf("Error found for upper 32 bits\n");
  375. else
  376. start = lower_32_bits(addr);
  377. #else
  378. start = (unsigned)data->dest;
  379. #endif
  380. end = start + size;
  381. invalidate_dcache_range(start, end);
  382. }
  383. #ifdef CONFIG_MCF5441x
  384. /*
  385. * Swaps 32-bit words to little-endian byte order.
  386. */
  387. static inline void sd_swap_dma_buff(struct mmc_data *data)
  388. {
  389. int i, size = data->blocksize >> 2;
  390. u32 *buffer = (u32 *)data->dest;
  391. u32 sw;
  392. while (data->blocks--) {
  393. for (i = 0; i < size; i++) {
  394. sw = __sw32(*buffer);
  395. *buffer++ = sw;
  396. }
  397. }
  398. }
  399. #endif
  400. /*
  401. * Sends a command out on the bus. Takes the mmc pointer,
  402. * a command pointer, and an optional data pointer.
  403. */
  404. static int esdhc_send_cmd_common(struct fsl_esdhc_priv *priv, struct mmc *mmc,
  405. struct mmc_cmd *cmd, struct mmc_data *data)
  406. {
  407. int err = 0;
  408. uint xfertyp;
  409. uint irqstat;
  410. u32 flags = IRQSTAT_CC | IRQSTAT_CTOE;
  411. struct fsl_esdhc *regs = priv->esdhc_regs;
  412. unsigned long start;
  413. #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC111
  414. if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
  415. return 0;
  416. #endif
  417. esdhc_write32(&regs->irqstat, -1);
  418. sync();
  419. /* Wait for the bus to be idle */
  420. while ((esdhc_read32(&regs->prsstat) & PRSSTAT_CICHB) ||
  421. (esdhc_read32(&regs->prsstat) & PRSSTAT_CIDHB))
  422. ;
  423. while (esdhc_read32(&regs->prsstat) & PRSSTAT_DLA)
  424. ;
  425. /* Set up for a data transfer if we have one */
  426. if (data) {
  427. err = esdhc_setup_data(priv, mmc, data);
  428. if(err)
  429. return err;
  430. if (data->flags & MMC_DATA_READ)
  431. check_and_invalidate_dcache_range(cmd, data);
  432. }
  433. /* Figure out the transfer arguments */
  434. xfertyp = esdhc_xfertyp(cmd, data);
  435. /* Mask all irqs */
  436. esdhc_write32(&regs->irqsigen, 0);
  437. /* Send the command */
  438. esdhc_write32(&regs->cmdarg, cmd->cmdarg);
  439. #if defined(CONFIG_FSL_USDHC)
  440. esdhc_write32(&regs->mixctrl,
  441. (esdhc_read32(&regs->mixctrl) & 0xFFFFFF80) | (xfertyp & 0x7F)
  442. | (mmc->ddr_mode ? XFERTYP_DDREN : 0));
  443. esdhc_write32(&regs->xfertyp, xfertyp & 0xFFFF0000);
  444. #else
  445. esdhc_write32(&regs->xfertyp, xfertyp);
  446. #endif
  447. if ((cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK) ||
  448. (cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK_HS200))
  449. flags = IRQSTAT_BRR;
  450. /* Wait for the command to complete */
  451. start = get_timer(0);
  452. while (!(esdhc_read32(&regs->irqstat) & flags)) {
  453. if (get_timer(start) > 1000) {
  454. err = -ETIMEDOUT;
  455. goto out;
  456. }
  457. }
  458. irqstat = esdhc_read32(&regs->irqstat);
  459. if (irqstat & CMD_ERR) {
  460. err = -ECOMM;
  461. goto out;
  462. }
  463. if (irqstat & IRQSTAT_CTOE) {
  464. err = -ETIMEDOUT;
  465. goto out;
  466. }
  467. /* Switch voltage to 1.8V if CMD11 succeeded */
  468. if (cmd->cmdidx == SD_CMD_SWITCH_UHS18V) {
  469. esdhc_setbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
  470. printf("Run CMD11 1.8V switch\n");
  471. /* Sleep for 5 ms - max time for card to switch to 1.8V */
  472. udelay(5000);
  473. }
  474. /* Workaround for ESDHC errata ENGcm03648 */
  475. if (!data && (cmd->resp_type & MMC_RSP_BUSY)) {
  476. int timeout = 50000;
  477. /* Poll on DATA0 line for cmd with busy signal for 5000 ms */
  478. while (timeout > 0 && !(esdhc_read32(&regs->prsstat) &
  479. PRSSTAT_DAT0)) {
  480. udelay(100);
  481. timeout--;
  482. }
  483. if (timeout <= 0) {
  484. printf("Timeout waiting for DAT0 to go high!\n");
  485. err = -ETIMEDOUT;
  486. goto out;
  487. }
  488. }
  489. /* Copy the response to the response buffer */
  490. if (cmd->resp_type & MMC_RSP_136) {
  491. u32 cmdrsp3, cmdrsp2, cmdrsp1, cmdrsp0;
  492. cmdrsp3 = esdhc_read32(&regs->cmdrsp3);
  493. cmdrsp2 = esdhc_read32(&regs->cmdrsp2);
  494. cmdrsp1 = esdhc_read32(&regs->cmdrsp1);
  495. cmdrsp0 = esdhc_read32(&regs->cmdrsp0);
  496. cmd->response[0] = (cmdrsp3 << 8) | (cmdrsp2 >> 24);
  497. cmd->response[1] = (cmdrsp2 << 8) | (cmdrsp1 >> 24);
  498. cmd->response[2] = (cmdrsp1 << 8) | (cmdrsp0 >> 24);
  499. cmd->response[3] = (cmdrsp0 << 8);
  500. } else
  501. cmd->response[0] = esdhc_read32(&regs->cmdrsp0);
  502. /* Wait until all of the blocks are transferred */
  503. if (data) {
  504. #ifdef CONFIG_SYS_FSL_ESDHC_USE_PIO
  505. esdhc_pio_read_write(priv, data);
  506. #else
  507. flags = DATA_COMPLETE;
  508. if ((cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK) ||
  509. (cmd->cmdidx == MMC_CMD_SEND_TUNING_BLOCK_HS200)) {
  510. flags = IRQSTAT_BRR;
  511. }
  512. do {
  513. irqstat = esdhc_read32(&regs->irqstat);
  514. if (irqstat & IRQSTAT_DTOE) {
  515. err = -ETIMEDOUT;
  516. goto out;
  517. }
  518. if (irqstat & DATA_ERR) {
  519. err = -ECOMM;
  520. goto out;
  521. }
  522. } while ((irqstat & flags) != flags);
  523. /*
  524. * Need invalidate the dcache here again to avoid any
  525. * cache-fill during the DMA operations such as the
  526. * speculative pre-fetching etc.
  527. */
  528. if (data->flags & MMC_DATA_READ) {
  529. check_and_invalidate_dcache_range(cmd, data);
  530. #ifdef CONFIG_MCF5441x
  531. sd_swap_dma_buff(data);
  532. #endif
  533. }
  534. #endif
  535. }
  536. out:
  537. /* Reset CMD and DATA portions on error */
  538. if (err) {
  539. esdhc_write32(&regs->sysctl, esdhc_read32(&regs->sysctl) |
  540. SYSCTL_RSTC);
  541. while (esdhc_read32(&regs->sysctl) & SYSCTL_RSTC)
  542. ;
  543. if (data) {
  544. esdhc_write32(&regs->sysctl,
  545. esdhc_read32(&regs->sysctl) |
  546. SYSCTL_RSTD);
  547. while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTD))
  548. ;
  549. }
  550. /* If this was CMD11, then notify that power cycle is needed */
  551. if (cmd->cmdidx == SD_CMD_SWITCH_UHS18V)
  552. printf("CMD11 to switch to 1.8V mode failed, card requires power cycle.\n");
  553. }
  554. esdhc_write32(&regs->irqstat, -1);
  555. return err;
  556. }
  557. static void set_sysctl(struct fsl_esdhc_priv *priv, struct mmc *mmc, uint clock)
  558. {
  559. struct fsl_esdhc *regs = priv->esdhc_regs;
  560. int div = 1;
  561. u32 tmp;
  562. int ret;
  563. #ifdef ARCH_MXC
  564. #ifdef CONFIG_MX53
  565. /* For i.MX53 eSDHCv3, SYSCTL.SDCLKFS may not be set to 0. */
  566. int pre_div = (regs == (struct fsl_esdhc *)MMC_SDHC3_BASE_ADDR) ? 2 : 1;
  567. #else
  568. int pre_div = 1;
  569. #endif
  570. #else
  571. int pre_div = 2;
  572. #endif
  573. int ddr_pre_div = mmc->ddr_mode ? 2 : 1;
  574. int sdhc_clk = priv->sdhc_clk;
  575. uint clk;
  576. while (sdhc_clk / (16 * pre_div * ddr_pre_div) > clock && pre_div < 256)
  577. pre_div *= 2;
  578. while (sdhc_clk / (div * pre_div * ddr_pre_div) > clock && div < 16)
  579. div++;
  580. pre_div >>= 1;
  581. div -= 1;
  582. clk = (pre_div << 8) | (div << 4);
  583. #ifdef CONFIG_FSL_USDHC
  584. esdhc_clrbits32(&regs->vendorspec, VENDORSPEC_CKEN);
  585. #else
  586. esdhc_clrbits32(&regs->sysctl, SYSCTL_CKEN);
  587. #endif
  588. esdhc_clrsetbits32(&regs->sysctl, SYSCTL_CLOCK_MASK, clk);
  589. ret = readx_poll_timeout(esdhc_read32, &regs->prsstat, tmp, tmp & PRSSTAT_SDSTB, 100);
  590. if (ret)
  591. pr_warn("fsl_esdhc_imx: Internal clock never stabilised.\n");
  592. #ifdef CONFIG_FSL_USDHC
  593. esdhc_setbits32(&regs->vendorspec, VENDORSPEC_PEREN | VENDORSPEC_CKEN);
  594. #else
  595. esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_CKEN);
  596. #endif
  597. priv->clock = clock;
  598. }
  599. #ifdef MMC_SUPPORTS_TUNING
  600. static int esdhc_change_pinstate(struct udevice *dev)
  601. {
  602. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  603. int ret;
  604. switch (priv->mode) {
  605. case UHS_SDR50:
  606. case UHS_DDR50:
  607. ret = pinctrl_select_state(dev, "state_100mhz");
  608. break;
  609. case UHS_SDR104:
  610. case MMC_HS_200:
  611. case MMC_HS_400:
  612. case MMC_HS_400_ES:
  613. ret = pinctrl_select_state(dev, "state_200mhz");
  614. break;
  615. default:
  616. ret = pinctrl_select_state(dev, "default");
  617. break;
  618. }
  619. if (ret)
  620. printf("%s %d error\n", __func__, priv->mode);
  621. return ret;
  622. }
  623. static void esdhc_reset_tuning(struct mmc *mmc)
  624. {
  625. struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
  626. struct fsl_esdhc *regs = priv->esdhc_regs;
  627. if (priv->flags & ESDHC_FLAG_USDHC) {
  628. if (priv->flags & ESDHC_FLAG_STD_TUNING) {
  629. esdhc_clrbits32(&regs->autoc12err,
  630. MIX_CTRL_SMPCLK_SEL |
  631. MIX_CTRL_EXE_TUNE);
  632. }
  633. }
  634. }
  635. static void esdhc_set_strobe_dll(struct mmc *mmc)
  636. {
  637. struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
  638. struct fsl_esdhc *regs = priv->esdhc_regs;
  639. u32 val;
  640. if (priv->clock > ESDHC_STROBE_DLL_CLK_FREQ) {
  641. esdhc_write32(&regs->strobe_dllctrl, ESDHC_STROBE_DLL_CTRL_RESET);
  642. /*
  643. * enable strobe dll ctrl and adjust the delay target
  644. * for the uSDHC loopback read clock
  645. */
  646. val = ESDHC_STROBE_DLL_CTRL_ENABLE |
  647. (priv->strobe_dll_delay_target <<
  648. ESDHC_STROBE_DLL_CTRL_SLV_DLY_TARGET_SHIFT);
  649. esdhc_write32(&regs->strobe_dllctrl, val);
  650. /* wait 1us to make sure strobe dll status register stable */
  651. mdelay(1);
  652. val = esdhc_read32(&regs->strobe_dllstat);
  653. if (!(val & ESDHC_STROBE_DLL_STS_REF_LOCK))
  654. pr_warn("HS400 strobe DLL status REF not lock!\n");
  655. if (!(val & ESDHC_STROBE_DLL_STS_SLV_LOCK))
  656. pr_warn("HS400 strobe DLL status SLV not lock!\n");
  657. }
  658. }
  659. static int esdhc_set_timing(struct mmc *mmc)
  660. {
  661. struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
  662. struct fsl_esdhc *regs = priv->esdhc_regs;
  663. u32 mixctrl;
  664. mixctrl = esdhc_read32(&regs->mixctrl);
  665. mixctrl &= ~(MIX_CTRL_DDREN | MIX_CTRL_HS400_EN);
  666. switch (mmc->selected_mode) {
  667. case MMC_LEGACY:
  668. esdhc_reset_tuning(mmc);
  669. esdhc_write32(&regs->mixctrl, mixctrl);
  670. break;
  671. case MMC_HS_400:
  672. case MMC_HS_400_ES:
  673. mixctrl |= MIX_CTRL_DDREN | MIX_CTRL_HS400_EN;
  674. esdhc_write32(&regs->mixctrl, mixctrl);
  675. esdhc_set_strobe_dll(mmc);
  676. break;
  677. case MMC_HS:
  678. case MMC_HS_52:
  679. case MMC_HS_200:
  680. case SD_HS:
  681. case UHS_SDR12:
  682. case UHS_SDR25:
  683. case UHS_SDR50:
  684. case UHS_SDR104:
  685. esdhc_write32(&regs->mixctrl, mixctrl);
  686. break;
  687. case UHS_DDR50:
  688. case MMC_DDR_52:
  689. mixctrl |= MIX_CTRL_DDREN;
  690. esdhc_write32(&regs->mixctrl, mixctrl);
  691. break;
  692. default:
  693. printf("Not supported %d\n", mmc->selected_mode);
  694. return -EINVAL;
  695. }
  696. priv->mode = mmc->selected_mode;
  697. return esdhc_change_pinstate(mmc->dev);
  698. }
  699. static int esdhc_set_voltage(struct mmc *mmc)
  700. {
  701. struct fsl_esdhc_priv *priv = dev_get_priv(mmc->dev);
  702. struct fsl_esdhc *regs = priv->esdhc_regs;
  703. int ret;
  704. priv->signal_voltage = mmc->signal_voltage;
  705. switch (mmc->signal_voltage) {
  706. case MMC_SIGNAL_VOLTAGE_330:
  707. if (priv->vs18_enable)
  708. return -ENOTSUPP;
  709. #if CONFIG_IS_ENABLED(DM_REGULATOR)
  710. if (!IS_ERR_OR_NULL(priv->vqmmc_dev)) {
  711. ret = regulator_set_value(priv->vqmmc_dev, 3300000);
  712. if (ret) {
  713. printf("Setting to 3.3V error");
  714. return -EIO;
  715. }
  716. /* Wait for 5ms */
  717. mdelay(5);
  718. }
  719. #endif
  720. esdhc_clrbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
  721. if (!(esdhc_read32(&regs->vendorspec) &
  722. ESDHC_VENDORSPEC_VSELECT))
  723. return 0;
  724. return -EAGAIN;
  725. case MMC_SIGNAL_VOLTAGE_180:
  726. #if CONFIG_IS_ENABLED(DM_REGULATOR)
  727. if (!IS_ERR_OR_NULL(priv->vqmmc_dev)) {
  728. ret = regulator_set_value(priv->vqmmc_dev, 1800000);
  729. if (ret) {
  730. printf("Setting to 1.8V error");
  731. return -EIO;
  732. }
  733. }
  734. #endif
  735. esdhc_setbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
  736. if (esdhc_read32(&regs->vendorspec) & ESDHC_VENDORSPEC_VSELECT)
  737. return 0;
  738. return -EAGAIN;
  739. case MMC_SIGNAL_VOLTAGE_120:
  740. return -ENOTSUPP;
  741. default:
  742. return 0;
  743. }
  744. }
  745. static void esdhc_stop_tuning(struct mmc *mmc)
  746. {
  747. struct mmc_cmd cmd;
  748. cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
  749. cmd.cmdarg = 0;
  750. cmd.resp_type = MMC_RSP_R1b;
  751. dm_mmc_send_cmd(mmc->dev, &cmd, NULL);
  752. }
  753. static int fsl_esdhc_execute_tuning(struct udevice *dev, uint32_t opcode)
  754. {
  755. struct fsl_esdhc_plat *plat = dev_get_plat(dev);
  756. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  757. struct fsl_esdhc *regs = priv->esdhc_regs;
  758. struct mmc *mmc = &plat->mmc;
  759. u32 irqstaten = esdhc_read32(&regs->irqstaten);
  760. u32 irqsigen = esdhc_read32(&regs->irqsigen);
  761. int i, ret = -ETIMEDOUT;
  762. u32 val, mixctrl;
  763. /* clock tuning is not needed for upto 52MHz */
  764. if (mmc->clock <= 52000000)
  765. return 0;
  766. /* This is readw/writew SDHCI_HOST_CONTROL2 when tuning */
  767. if (priv->flags & ESDHC_FLAG_STD_TUNING) {
  768. val = esdhc_read32(&regs->autoc12err);
  769. mixctrl = esdhc_read32(&regs->mixctrl);
  770. val &= ~MIX_CTRL_SMPCLK_SEL;
  771. mixctrl &= ~(MIX_CTRL_FBCLK_SEL | MIX_CTRL_AUTO_TUNE_EN);
  772. val |= MIX_CTRL_EXE_TUNE;
  773. mixctrl |= MIX_CTRL_FBCLK_SEL | MIX_CTRL_AUTO_TUNE_EN;
  774. esdhc_write32(&regs->autoc12err, val);
  775. esdhc_write32(&regs->mixctrl, mixctrl);
  776. }
  777. /* sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE); */
  778. mixctrl = esdhc_read32(&regs->mixctrl);
  779. mixctrl = MIX_CTRL_DTDSEL_READ | (mixctrl & ~MIX_CTRL_SDHCI_MASK);
  780. esdhc_write32(&regs->mixctrl, mixctrl);
  781. esdhc_write32(&regs->irqstaten, IRQSTATEN_BRR);
  782. esdhc_write32(&regs->irqsigen, IRQSTATEN_BRR);
  783. /*
  784. * Issue opcode repeatedly till Execute Tuning is set to 0 or the number
  785. * of loops reaches 40 times.
  786. */
  787. for (i = 0; i < MAX_TUNING_LOOP; i++) {
  788. u32 ctrl;
  789. if (opcode == MMC_CMD_SEND_TUNING_BLOCK_HS200) {
  790. if (mmc->bus_width == 8)
  791. esdhc_write32(&regs->blkattr, 0x7080);
  792. else if (mmc->bus_width == 4)
  793. esdhc_write32(&regs->blkattr, 0x7040);
  794. } else {
  795. esdhc_write32(&regs->blkattr, 0x7040);
  796. }
  797. /* sdhci_writew(host, SDHCI_TRNS_READ, SDHCI_TRANSFER_MODE) */
  798. val = esdhc_read32(&regs->mixctrl);
  799. val = MIX_CTRL_DTDSEL_READ | (val & ~MIX_CTRL_SDHCI_MASK);
  800. esdhc_write32(&regs->mixctrl, val);
  801. /* We are using STD tuning, no need to check return value */
  802. mmc_send_tuning(mmc, opcode, NULL);
  803. ctrl = esdhc_read32(&regs->autoc12err);
  804. if ((!(ctrl & MIX_CTRL_EXE_TUNE)) &&
  805. (ctrl & MIX_CTRL_SMPCLK_SEL)) {
  806. ret = 0;
  807. break;
  808. }
  809. }
  810. esdhc_write32(&regs->irqstaten, irqstaten);
  811. esdhc_write32(&regs->irqsigen, irqsigen);
  812. esdhc_stop_tuning(mmc);
  813. return ret;
  814. }
  815. #endif
  816. static int esdhc_set_ios_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
  817. {
  818. struct fsl_esdhc *regs = priv->esdhc_regs;
  819. int ret __maybe_unused;
  820. u32 clock;
  821. /* Set the clock speed */
  822. clock = mmc->clock;
  823. if (clock < mmc->cfg->f_min)
  824. clock = mmc->cfg->f_min;
  825. if (priv->clock != clock)
  826. set_sysctl(priv, mmc, clock);
  827. #ifdef MMC_SUPPORTS_TUNING
  828. if (mmc->clk_disable) {
  829. #ifdef CONFIG_FSL_USDHC
  830. esdhc_clrbits32(&regs->vendorspec, VENDORSPEC_CKEN);
  831. #else
  832. esdhc_clrbits32(&regs->sysctl, SYSCTL_CKEN);
  833. #endif
  834. } else {
  835. #ifdef CONFIG_FSL_USDHC
  836. esdhc_setbits32(&regs->vendorspec, VENDORSPEC_PEREN |
  837. VENDORSPEC_CKEN);
  838. #else
  839. esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_CKEN);
  840. #endif
  841. }
  842. if (priv->mode != mmc->selected_mode) {
  843. ret = esdhc_set_timing(mmc);
  844. if (ret) {
  845. printf("esdhc_set_timing error %d\n", ret);
  846. return ret;
  847. }
  848. }
  849. if (priv->signal_voltage != mmc->signal_voltage) {
  850. ret = esdhc_set_voltage(mmc);
  851. if (ret) {
  852. if (ret != -ENOTSUPP)
  853. printf("esdhc_set_voltage error %d\n", ret);
  854. return ret;
  855. }
  856. }
  857. #endif
  858. /* Set the bus width */
  859. esdhc_clrbits32(&regs->proctl, PROCTL_DTW_4 | PROCTL_DTW_8);
  860. if (mmc->bus_width == 4)
  861. esdhc_setbits32(&regs->proctl, PROCTL_DTW_4);
  862. else if (mmc->bus_width == 8)
  863. esdhc_setbits32(&regs->proctl, PROCTL_DTW_8);
  864. return 0;
  865. }
  866. static int esdhc_init_common(struct fsl_esdhc_priv *priv, struct mmc *mmc)
  867. {
  868. struct fsl_esdhc *regs = priv->esdhc_regs;
  869. ulong start;
  870. /* Reset the entire host controller */
  871. esdhc_setbits32(&regs->sysctl, SYSCTL_RSTA);
  872. /* Wait until the controller is available */
  873. start = get_timer(0);
  874. while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTA)) {
  875. if (get_timer(start) > 1000)
  876. return -ETIMEDOUT;
  877. }
  878. #if defined(CONFIG_FSL_USDHC)
  879. /* RSTA doesn't reset MMC_BOOT register, so manually reset it */
  880. esdhc_write32(&regs->mmcboot, 0x0);
  881. /* Reset MIX_CTRL and CLK_TUNE_CTRL_STATUS regs to 0 */
  882. esdhc_write32(&regs->mixctrl, 0x0);
  883. esdhc_write32(&regs->clktunectrlstatus, 0x0);
  884. /* Put VEND_SPEC to default value */
  885. if (priv->vs18_enable)
  886. esdhc_write32(&regs->vendorspec, (VENDORSPEC_INIT |
  887. ESDHC_VENDORSPEC_VSELECT));
  888. else
  889. esdhc_write32(&regs->vendorspec, VENDORSPEC_INIT);
  890. /* Disable DLL_CTRL delay line */
  891. esdhc_write32(&regs->dllctrl, 0x0);
  892. #endif
  893. #ifndef ARCH_MXC
  894. /* Enable cache snooping */
  895. esdhc_write32(&regs->scr, 0x00000040);
  896. #endif
  897. #ifndef CONFIG_FSL_USDHC
  898. esdhc_setbits32(&regs->sysctl, SYSCTL_HCKEN | SYSCTL_IPGEN);
  899. #else
  900. esdhc_setbits32(&regs->vendorspec, VENDORSPEC_HCKEN | VENDORSPEC_IPGEN);
  901. #endif
  902. /* Set the initial clock speed */
  903. mmc_set_clock(mmc, 400000, MMC_CLK_ENABLE);
  904. /* Disable the BRR and BWR bits in IRQSTAT */
  905. esdhc_clrbits32(&regs->irqstaten, IRQSTATEN_BRR | IRQSTATEN_BWR);
  906. #ifdef CONFIG_MCF5441x
  907. esdhc_write32(&regs->proctl, PROCTL_INIT | PROCTL_D3CD);
  908. #else
  909. /* Put the PROCTL reg back to the default */
  910. esdhc_write32(&regs->proctl, PROCTL_INIT);
  911. #endif
  912. /* Set timout to the maximum value */
  913. esdhc_clrsetbits32(&regs->sysctl, SYSCTL_TIMEOUT_MASK, 14 << 16);
  914. return 0;
  915. }
  916. static int esdhc_getcd_common(struct fsl_esdhc_priv *priv)
  917. {
  918. struct fsl_esdhc *regs = priv->esdhc_regs;
  919. int timeout = 1000;
  920. #ifdef CONFIG_ESDHC_DETECT_QUIRK
  921. if (CONFIG_ESDHC_DETECT_QUIRK)
  922. return 1;
  923. #endif
  924. #if CONFIG_IS_ENABLED(DM_MMC)
  925. if (priv->non_removable)
  926. return 1;
  927. if (priv->broken_cd)
  928. return 1;
  929. #if CONFIG_IS_ENABLED(DM_GPIO)
  930. if (dm_gpio_is_valid(&priv->cd_gpio))
  931. return dm_gpio_get_value(&priv->cd_gpio);
  932. #endif
  933. #endif
  934. while (!(esdhc_read32(&regs->prsstat) & PRSSTAT_CINS) && --timeout)
  935. udelay(1000);
  936. return timeout > 0;
  937. }
  938. static int esdhc_reset(struct fsl_esdhc *regs)
  939. {
  940. ulong start;
  941. /* reset the controller */
  942. esdhc_setbits32(&regs->sysctl, SYSCTL_RSTA);
  943. /* hardware clears the bit when it is done */
  944. start = get_timer(0);
  945. while ((esdhc_read32(&regs->sysctl) & SYSCTL_RSTA)) {
  946. if (get_timer(start) > 100) {
  947. printf("MMC/SD: Reset never completed.\n");
  948. return -ETIMEDOUT;
  949. }
  950. }
  951. return 0;
  952. }
  953. #if !CONFIG_IS_ENABLED(DM_MMC)
  954. static int esdhc_getcd(struct mmc *mmc)
  955. {
  956. struct fsl_esdhc_priv *priv = mmc->priv;
  957. return esdhc_getcd_common(priv);
  958. }
  959. static int esdhc_init(struct mmc *mmc)
  960. {
  961. struct fsl_esdhc_priv *priv = mmc->priv;
  962. return esdhc_init_common(priv, mmc);
  963. }
  964. static int esdhc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
  965. struct mmc_data *data)
  966. {
  967. struct fsl_esdhc_priv *priv = mmc->priv;
  968. return esdhc_send_cmd_common(priv, mmc, cmd, data);
  969. }
  970. static int esdhc_set_ios(struct mmc *mmc)
  971. {
  972. struct fsl_esdhc_priv *priv = mmc->priv;
  973. return esdhc_set_ios_common(priv, mmc);
  974. }
  975. static const struct mmc_ops esdhc_ops = {
  976. .getcd = esdhc_getcd,
  977. .init = esdhc_init,
  978. .send_cmd = esdhc_send_cmd,
  979. .set_ios = esdhc_set_ios,
  980. };
  981. #endif
  982. static int fsl_esdhc_init(struct fsl_esdhc_priv *priv,
  983. struct fsl_esdhc_plat *plat)
  984. {
  985. struct mmc_config *cfg;
  986. struct fsl_esdhc *regs;
  987. u32 caps, voltage_caps;
  988. int ret;
  989. if (!priv)
  990. return -EINVAL;
  991. regs = priv->esdhc_regs;
  992. /* First reset the eSDHC controller */
  993. ret = esdhc_reset(regs);
  994. if (ret)
  995. return ret;
  996. #ifdef CONFIG_MCF5441x
  997. /* ColdFire, using SDHC_DATA[3] for card detection */
  998. esdhc_write32(&regs->proctl, PROCTL_INIT | PROCTL_D3CD);
  999. #endif
  1000. #ifndef CONFIG_FSL_USDHC
  1001. esdhc_setbits32(&regs->sysctl, SYSCTL_PEREN | SYSCTL_HCKEN
  1002. | SYSCTL_IPGEN | SYSCTL_CKEN);
  1003. /* Clearing tuning bits in case ROM has set it already */
  1004. esdhc_write32(&regs->mixctrl, 0);
  1005. esdhc_write32(&regs->autoc12err, 0);
  1006. esdhc_write32(&regs->clktunectrlstatus, 0);
  1007. #else
  1008. esdhc_setbits32(&regs->vendorspec, VENDORSPEC_PEREN |
  1009. VENDORSPEC_HCKEN | VENDORSPEC_IPGEN | VENDORSPEC_CKEN);
  1010. #endif
  1011. if (priv->vs18_enable)
  1012. esdhc_setbits32(&regs->vendorspec, ESDHC_VENDORSPEC_VSELECT);
  1013. esdhc_write32(&regs->irqstaten, SDHCI_IRQ_EN_BITS);
  1014. cfg = &plat->cfg;
  1015. #ifndef CONFIG_DM_MMC
  1016. memset(cfg, '\0', sizeof(*cfg));
  1017. #endif
  1018. voltage_caps = 0;
  1019. caps = esdhc_read32(&regs->hostcapblt);
  1020. #ifdef CONFIG_MCF5441x
  1021. /*
  1022. * MCF5441x RM declares in more points that sdhc clock speed must
  1023. * never exceed 25 Mhz. From this, the HS bit needs to be disabled
  1024. * from host capabilities.
  1025. */
  1026. caps &= ~ESDHC_HOSTCAPBLT_HSS;
  1027. #endif
  1028. #ifdef CONFIG_SYS_FSL_ERRATUM_ESDHC135
  1029. caps = caps & ~(ESDHC_HOSTCAPBLT_SRS |
  1030. ESDHC_HOSTCAPBLT_VS18 | ESDHC_HOSTCAPBLT_VS30);
  1031. #endif
  1032. /* T4240 host controller capabilities register should have VS33 bit */
  1033. #ifdef CONFIG_SYS_FSL_MMC_HAS_CAPBLT_VS33
  1034. caps = caps | ESDHC_HOSTCAPBLT_VS33;
  1035. #endif
  1036. if (caps & ESDHC_HOSTCAPBLT_VS18)
  1037. voltage_caps |= MMC_VDD_165_195;
  1038. if (caps & ESDHC_HOSTCAPBLT_VS30)
  1039. voltage_caps |= MMC_VDD_29_30 | MMC_VDD_30_31;
  1040. if (caps & ESDHC_HOSTCAPBLT_VS33)
  1041. voltage_caps |= MMC_VDD_32_33 | MMC_VDD_33_34;
  1042. cfg->name = "FSL_SDHC";
  1043. #if !CONFIG_IS_ENABLED(DM_MMC)
  1044. cfg->ops = &esdhc_ops;
  1045. #endif
  1046. #ifdef CONFIG_SYS_SD_VOLTAGE
  1047. cfg->voltages = CONFIG_SYS_SD_VOLTAGE;
  1048. #else
  1049. cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
  1050. #endif
  1051. if ((cfg->voltages & voltage_caps) == 0) {
  1052. printf("voltage not supported by controller\n");
  1053. return -1;
  1054. }
  1055. if (priv->bus_width == 8)
  1056. cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
  1057. else if (priv->bus_width == 4)
  1058. cfg->host_caps = MMC_MODE_4BIT;
  1059. cfg->host_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
  1060. #ifdef CONFIG_SYS_FSL_ESDHC_HAS_DDR_MODE
  1061. cfg->host_caps |= MMC_MODE_DDR_52MHz;
  1062. #endif
  1063. if (priv->bus_width > 0) {
  1064. if (priv->bus_width < 8)
  1065. cfg->host_caps &= ~MMC_MODE_8BIT;
  1066. if (priv->bus_width < 4)
  1067. cfg->host_caps &= ~MMC_MODE_4BIT;
  1068. }
  1069. if (caps & ESDHC_HOSTCAPBLT_HSS)
  1070. cfg->host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
  1071. #ifdef CONFIG_ESDHC_DETECT_8_BIT_QUIRK
  1072. if (CONFIG_ESDHC_DETECT_8_BIT_QUIRK)
  1073. cfg->host_caps &= ~MMC_MODE_8BIT;
  1074. #endif
  1075. cfg->host_caps |= priv->caps;
  1076. cfg->f_min = 400000;
  1077. cfg->f_max = min(priv->sdhc_clk, (u32)200000000);
  1078. cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
  1079. esdhc_write32(&regs->dllctrl, 0);
  1080. if (priv->flags & ESDHC_FLAG_USDHC) {
  1081. if (priv->flags & ESDHC_FLAG_STD_TUNING) {
  1082. u32 val = esdhc_read32(&regs->tuning_ctrl);
  1083. val |= ESDHC_STD_TUNING_EN;
  1084. val &= ~ESDHC_TUNING_START_TAP_MASK;
  1085. val |= priv->tuning_start_tap;
  1086. val &= ~ESDHC_TUNING_STEP_MASK;
  1087. val |= (priv->tuning_step) << ESDHC_TUNING_STEP_SHIFT;
  1088. /* Disable the CMD CRC check for tuning, if not, need to
  1089. * add some delay after every tuning command, because
  1090. * hardware standard tuning logic will directly go to next
  1091. * step once it detect the CMD CRC error, will not wait for
  1092. * the card side to finally send out the tuning data, trigger
  1093. * the buffer read ready interrupt immediately. If usdhc send
  1094. * the next tuning command some eMMC card will stuck, can't
  1095. * response, block the tuning procedure or the first command
  1096. * after the whole tuning procedure always can't get any response.
  1097. */
  1098. val |= ESDHC_TUNING_CMD_CRC_CHECK_DISABLE;
  1099. esdhc_write32(&regs->tuning_ctrl, val);
  1100. }
  1101. }
  1102. return 0;
  1103. }
  1104. #if !CONFIG_IS_ENABLED(DM_MMC)
  1105. static int fsl_esdhc_cfg_to_priv(struct fsl_esdhc_cfg *cfg,
  1106. struct fsl_esdhc_priv *priv)
  1107. {
  1108. if (!cfg || !priv)
  1109. return -EINVAL;
  1110. priv->esdhc_regs = (struct fsl_esdhc *)(unsigned long)(cfg->esdhc_base);
  1111. priv->bus_width = cfg->max_bus_width;
  1112. priv->sdhc_clk = cfg->sdhc_clk;
  1113. priv->wp_enable = cfg->wp_enable;
  1114. priv->vs18_enable = cfg->vs18_enable;
  1115. return 0;
  1116. };
  1117. int fsl_esdhc_initialize(struct bd_info *bis, struct fsl_esdhc_cfg *cfg)
  1118. {
  1119. struct fsl_esdhc_plat *plat;
  1120. struct fsl_esdhc_priv *priv;
  1121. struct mmc *mmc;
  1122. int ret;
  1123. if (!cfg)
  1124. return -EINVAL;
  1125. priv = calloc(sizeof(struct fsl_esdhc_priv), 1);
  1126. if (!priv)
  1127. return -ENOMEM;
  1128. plat = calloc(sizeof(struct fsl_esdhc_plat), 1);
  1129. if (!plat) {
  1130. free(priv);
  1131. return -ENOMEM;
  1132. }
  1133. ret = fsl_esdhc_cfg_to_priv(cfg, priv);
  1134. if (ret) {
  1135. debug("%s xlate failure\n", __func__);
  1136. free(plat);
  1137. free(priv);
  1138. return ret;
  1139. }
  1140. ret = fsl_esdhc_init(priv, plat);
  1141. if (ret) {
  1142. debug("%s init failure\n", __func__);
  1143. free(plat);
  1144. free(priv);
  1145. return ret;
  1146. }
  1147. mmc = mmc_create(&plat->cfg, priv);
  1148. if (!mmc)
  1149. return -EIO;
  1150. priv->mmc = mmc;
  1151. return 0;
  1152. }
  1153. int fsl_esdhc_mmc_init(struct bd_info *bis)
  1154. {
  1155. struct fsl_esdhc_cfg *cfg;
  1156. cfg = calloc(sizeof(struct fsl_esdhc_cfg), 1);
  1157. cfg->esdhc_base = CONFIG_SYS_FSL_ESDHC_ADDR;
  1158. cfg->sdhc_clk = gd->arch.sdhc_clk;
  1159. return fsl_esdhc_initialize(bis, cfg);
  1160. }
  1161. #endif
  1162. #ifdef CONFIG_OF_LIBFDT
  1163. __weak int esdhc_status_fixup(void *blob, const char *compat)
  1164. {
  1165. #ifdef CONFIG_FSL_ESDHC_PIN_MUX
  1166. if (!hwconfig("esdhc")) {
  1167. do_fixup_by_compat(blob, compat, "status", "disabled",
  1168. sizeof("disabled"), 1);
  1169. return 1;
  1170. }
  1171. #endif
  1172. return 0;
  1173. }
  1174. void fdt_fixup_esdhc(void *blob, struct bd_info *bd)
  1175. {
  1176. const char *compat = "fsl,esdhc";
  1177. if (esdhc_status_fixup(blob, compat))
  1178. return;
  1179. do_fixup_by_compat_u32(blob, compat, "clock-frequency",
  1180. gd->arch.sdhc_clk, 1);
  1181. }
  1182. #endif
  1183. #if CONFIG_IS_ENABLED(DM_MMC)
  1184. #include <asm/arch/clock.h>
  1185. __weak void init_clk_usdhc(u32 index)
  1186. {
  1187. }
  1188. static int fsl_esdhc_of_to_plat(struct udevice *dev)
  1189. {
  1190. #if !CONFIG_IS_ENABLED(OF_PLATDATA)
  1191. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1192. #if CONFIG_IS_ENABLED(DM_REGULATOR)
  1193. struct udevice *vqmmc_dev;
  1194. int ret;
  1195. #endif
  1196. const void *fdt = gd->fdt_blob;
  1197. int node = dev_of_offset(dev);
  1198. fdt_addr_t addr;
  1199. unsigned int val;
  1200. addr = dev_read_addr(dev);
  1201. if (addr == FDT_ADDR_T_NONE)
  1202. return -EINVAL;
  1203. priv->esdhc_regs = (struct fsl_esdhc *)addr;
  1204. priv->dev = dev;
  1205. priv->mode = -1;
  1206. val = dev_read_u32_default(dev, "bus-width", -1);
  1207. if (val == 8)
  1208. priv->bus_width = 8;
  1209. else if (val == 4)
  1210. priv->bus_width = 4;
  1211. else
  1212. priv->bus_width = 1;
  1213. val = fdtdec_get_int(fdt, node, "fsl,tuning-step", 1);
  1214. priv->tuning_step = val;
  1215. val = fdtdec_get_int(fdt, node, "fsl,tuning-start-tap",
  1216. ESDHC_TUNING_START_TAP_DEFAULT);
  1217. priv->tuning_start_tap = val;
  1218. val = fdtdec_get_int(fdt, node, "fsl,strobe-dll-delay-target",
  1219. ESDHC_STROBE_DLL_CTRL_SLV_DLY_TARGET_DEFAULT);
  1220. priv->strobe_dll_delay_target = val;
  1221. if (dev_read_bool(dev, "broken-cd"))
  1222. priv->broken_cd = 1;
  1223. if (dev_read_bool(dev, "non-removable")) {
  1224. priv->non_removable = 1;
  1225. } else {
  1226. priv->non_removable = 0;
  1227. #if CONFIG_IS_ENABLED(DM_GPIO)
  1228. gpio_request_by_name(dev, "cd-gpios", 0, &priv->cd_gpio,
  1229. GPIOD_IS_IN);
  1230. #endif
  1231. }
  1232. if (dev_read_prop(dev, "fsl,wp-controller", NULL)) {
  1233. priv->wp_enable = 1;
  1234. } else {
  1235. priv->wp_enable = 0;
  1236. #if CONFIG_IS_ENABLED(DM_GPIO)
  1237. gpio_request_by_name(dev, "wp-gpios", 0, &priv->wp_gpio,
  1238. GPIOD_IS_IN);
  1239. #endif
  1240. }
  1241. priv->vs18_enable = 0;
  1242. #if CONFIG_IS_ENABLED(DM_REGULATOR)
  1243. /*
  1244. * If emmc I/O has a fixed voltage at 1.8V, this must be provided,
  1245. * otherwise, emmc will work abnormally.
  1246. */
  1247. ret = device_get_supply_regulator(dev, "vqmmc-supply", &vqmmc_dev);
  1248. if (ret) {
  1249. dev_dbg(dev, "no vqmmc-supply\n");
  1250. } else {
  1251. priv->vqmmc_dev = vqmmc_dev;
  1252. ret = regulator_set_enable(vqmmc_dev, true);
  1253. if (ret) {
  1254. dev_err(dev, "fail to enable vqmmc-supply\n");
  1255. return ret;
  1256. }
  1257. if (regulator_get_value(vqmmc_dev) == 1800000)
  1258. priv->vs18_enable = 1;
  1259. }
  1260. #endif
  1261. #endif
  1262. return 0;
  1263. }
  1264. static int fsl_esdhc_probe(struct udevice *dev)
  1265. {
  1266. struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
  1267. struct fsl_esdhc_plat *plat = dev_get_plat(dev);
  1268. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1269. struct esdhc_soc_data *data =
  1270. (struct esdhc_soc_data *)dev_get_driver_data(dev);
  1271. struct mmc *mmc;
  1272. #if !CONFIG_IS_ENABLED(BLK)
  1273. struct blk_desc *bdesc;
  1274. #endif
  1275. int ret;
  1276. #if CONFIG_IS_ENABLED(OF_PLATDATA)
  1277. struct dtd_fsl_esdhc *dtplat = &plat->dtplat;
  1278. unsigned int val;
  1279. priv->esdhc_regs = map_sysmem(dtplat->reg[0], dtplat->reg[1]);
  1280. val = plat->dtplat.bus_width;
  1281. if (val == 8)
  1282. priv->bus_width = 8;
  1283. else if (val == 4)
  1284. priv->bus_width = 4;
  1285. else
  1286. priv->bus_width = 1;
  1287. if (dtplat->non_removable)
  1288. priv->non_removable = 1;
  1289. else
  1290. priv->non_removable = 0;
  1291. if (CONFIG_IS_ENABLED(DM_GPIO) && !priv->non_removable) {
  1292. struct udevice *gpiodev;
  1293. ret = device_get_by_driver_info_idx(dtplat->cd_gpios->idx,
  1294. &gpiodev);
  1295. if (ret)
  1296. return ret;
  1297. ret = gpio_dev_request_index(gpiodev, gpiodev->name, "cd-gpios",
  1298. dtplat->cd_gpios->arg[0], GPIOD_IS_IN,
  1299. dtplat->cd_gpios->arg[1], &priv->cd_gpio);
  1300. if (ret)
  1301. return ret;
  1302. }
  1303. #endif
  1304. if (data)
  1305. priv->flags = data->flags;
  1306. /*
  1307. * TODO:
  1308. * Because lack of clk driver, if SDHC clk is not enabled,
  1309. * need to enable it first before this driver is invoked.
  1310. *
  1311. * we use MXC_ESDHC_CLK to get clk freq.
  1312. * If one would like to make this function work,
  1313. * the aliases should be provided in dts as this:
  1314. *
  1315. * aliases {
  1316. * mmc0 = &usdhc1;
  1317. * mmc1 = &usdhc2;
  1318. * mmc2 = &usdhc3;
  1319. * mmc3 = &usdhc4;
  1320. * };
  1321. * Then if your board only supports mmc2 and mmc3, but we can
  1322. * correctly get the seq as 2 and 3, then let mxc_get_clock
  1323. * work as expected.
  1324. */
  1325. init_clk_usdhc(dev_seq(dev));
  1326. #if CONFIG_IS_ENABLED(CLK)
  1327. /* Assigned clock already set clock */
  1328. ret = clk_get_by_name(dev, "per", &priv->per_clk);
  1329. if (ret) {
  1330. printf("Failed to get per_clk\n");
  1331. return ret;
  1332. }
  1333. ret = clk_enable(&priv->per_clk);
  1334. if (ret) {
  1335. printf("Failed to enable per_clk\n");
  1336. return ret;
  1337. }
  1338. priv->sdhc_clk = clk_get_rate(&priv->per_clk);
  1339. #else
  1340. priv->sdhc_clk = mxc_get_clock(MXC_ESDHC_CLK + dev_seq(dev));
  1341. if (priv->sdhc_clk <= 0) {
  1342. dev_err(dev, "Unable to get clk for %s\n", dev->name);
  1343. return -EINVAL;
  1344. }
  1345. #endif
  1346. ret = fsl_esdhc_init(priv, plat);
  1347. if (ret) {
  1348. dev_err(dev, "fsl_esdhc_init failure\n");
  1349. return ret;
  1350. }
  1351. #if !CONFIG_IS_ENABLED(OF_PLATDATA)
  1352. ret = mmc_of_parse(dev, &plat->cfg);
  1353. if (ret)
  1354. return ret;
  1355. #endif
  1356. mmc = &plat->mmc;
  1357. mmc->cfg = &plat->cfg;
  1358. mmc->dev = dev;
  1359. #if !CONFIG_IS_ENABLED(BLK)
  1360. mmc->priv = priv;
  1361. /* Setup dsr related values */
  1362. mmc->dsr_imp = 0;
  1363. mmc->dsr = ESDHC_DRIVER_STAGE_VALUE;
  1364. /* Setup the universal parts of the block interface just once */
  1365. bdesc = mmc_get_blk_desc(mmc);
  1366. bdesc->if_type = IF_TYPE_MMC;
  1367. bdesc->removable = 1;
  1368. bdesc->devnum = mmc_get_next_devnum();
  1369. bdesc->block_read = mmc_bread;
  1370. bdesc->block_write = mmc_bwrite;
  1371. bdesc->block_erase = mmc_berase;
  1372. /* setup initial part type */
  1373. bdesc->part_type = mmc->cfg->part_type;
  1374. mmc_list_add(mmc);
  1375. #endif
  1376. upriv->mmc = mmc;
  1377. return esdhc_init_common(priv, mmc);
  1378. }
  1379. #if CONFIG_IS_ENABLED(DM_MMC)
  1380. static int fsl_esdhc_get_cd(struct udevice *dev)
  1381. {
  1382. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1383. return esdhc_getcd_common(priv);
  1384. }
  1385. static int fsl_esdhc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
  1386. struct mmc_data *data)
  1387. {
  1388. struct fsl_esdhc_plat *plat = dev_get_plat(dev);
  1389. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1390. return esdhc_send_cmd_common(priv, &plat->mmc, cmd, data);
  1391. }
  1392. static int fsl_esdhc_set_ios(struct udevice *dev)
  1393. {
  1394. struct fsl_esdhc_plat *plat = dev_get_plat(dev);
  1395. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1396. return esdhc_set_ios_common(priv, &plat->mmc);
  1397. }
  1398. #if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
  1399. static int fsl_esdhc_set_enhanced_strobe(struct udevice *dev)
  1400. {
  1401. struct fsl_esdhc_priv *priv = dev_get_priv(dev);
  1402. struct fsl_esdhc *regs = priv->esdhc_regs;
  1403. u32 m;
  1404. m = esdhc_read32(&regs->mixctrl);
  1405. m |= MIX_CTRL_HS400_ES;
  1406. esdhc_write32(&regs->mixctrl, m);
  1407. return 0;
  1408. }
  1409. #endif
  1410. static const struct dm_mmc_ops fsl_esdhc_ops = {
  1411. .get_cd = fsl_esdhc_get_cd,
  1412. .send_cmd = fsl_esdhc_send_cmd,
  1413. .set_ios = fsl_esdhc_set_ios,
  1414. #ifdef MMC_SUPPORTS_TUNING
  1415. .execute_tuning = fsl_esdhc_execute_tuning,
  1416. #endif
  1417. #if CONFIG_IS_ENABLED(MMC_HS400_ES_SUPPORT)
  1418. .set_enhanced_strobe = fsl_esdhc_set_enhanced_strobe,
  1419. #endif
  1420. };
  1421. #endif
  1422. static struct esdhc_soc_data usdhc_imx7d_data = {
  1423. .flags = ESDHC_FLAG_USDHC | ESDHC_FLAG_STD_TUNING
  1424. | ESDHC_FLAG_HAVE_CAP1 | ESDHC_FLAG_HS200
  1425. | ESDHC_FLAG_HS400,
  1426. };
  1427. static struct esdhc_soc_data usdhc_imx8qm_data = {
  1428. .flags = ESDHC_FLAG_USDHC | ESDHC_FLAG_STD_TUNING |
  1429. ESDHC_FLAG_HAVE_CAP1 | ESDHC_FLAG_HS200 |
  1430. ESDHC_FLAG_HS400 | ESDHC_FLAG_HS400_ES,
  1431. };
  1432. static const struct udevice_id fsl_esdhc_ids[] = {
  1433. { .compatible = "fsl,imx53-esdhc", },
  1434. { .compatible = "fsl,imx6ul-usdhc", },
  1435. { .compatible = "fsl,imx6sx-usdhc", },
  1436. { .compatible = "fsl,imx6sl-usdhc", },
  1437. { .compatible = "fsl,imx6q-usdhc", },
  1438. { .compatible = "fsl,imx7d-usdhc", .data = (ulong)&usdhc_imx7d_data,},
  1439. { .compatible = "fsl,imx7ulp-usdhc", },
  1440. { .compatible = "fsl,imx8qm-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
  1441. { .compatible = "fsl,imx8mm-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
  1442. { .compatible = "fsl,imx8mn-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
  1443. { .compatible = "fsl,imx8mq-usdhc", .data = (ulong)&usdhc_imx8qm_data,},
  1444. { .compatible = "fsl,imxrt-usdhc", },
  1445. { .compatible = "fsl,esdhc", },
  1446. { /* sentinel */ }
  1447. };
  1448. #if CONFIG_IS_ENABLED(BLK)
  1449. static int fsl_esdhc_bind(struct udevice *dev)
  1450. {
  1451. struct fsl_esdhc_plat *plat = dev_get_plat(dev);
  1452. return mmc_bind(dev, &plat->mmc, &plat->cfg);
  1453. }
  1454. #endif
  1455. U_BOOT_DRIVER(fsl_esdhc) = {
  1456. .name = "fsl_esdhc",
  1457. .id = UCLASS_MMC,
  1458. .of_match = fsl_esdhc_ids,
  1459. .of_to_plat = fsl_esdhc_of_to_plat,
  1460. .ops = &fsl_esdhc_ops,
  1461. #if CONFIG_IS_ENABLED(BLK)
  1462. .bind = fsl_esdhc_bind,
  1463. #endif
  1464. .probe = fsl_esdhc_probe,
  1465. .plat_auto = sizeof(struct fsl_esdhc_plat),
  1466. .priv_auto = sizeof(struct fsl_esdhc_priv),
  1467. };
  1468. U_BOOT_DRIVER_ALIAS(fsl_esdhc, fsl_imx6q_usdhc)
  1469. #endif