mmc.c 60 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/drivers/mmc/core/mmc.c
  4. *
  5. * Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  6. * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
  7. * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
  8. */
  9. #include <linux/err.h>
  10. #include <linux/of.h>
  11. #include <linux/slab.h>
  12. #include <linux/stat.h>
  13. #include <linux/pm_runtime.h>
  14. #include <linux/mmc/host.h>
  15. #include <linux/mmc/card.h>
  16. #include <linux/mmc/mmc.h>
  17. #include "core.h"
  18. #include "card.h"
  19. #include "host.h"
  20. #include "bus.h"
  21. #include "mmc_ops.h"
  22. #include "quirks.h"
  23. #include "sd_ops.h"
  24. #include "pwrseq.h"
  25. #define DEFAULT_CMD6_TIMEOUT_MS 500
  26. #define MIN_CACHE_EN_TIMEOUT_MS 1600
  27. static const unsigned int tran_exp[] = {
  28. 10000, 100000, 1000000, 10000000,
  29. 0, 0, 0, 0
  30. };
  31. static const unsigned char tran_mant[] = {
  32. 0, 10, 12, 13, 15, 20, 25, 30,
  33. 35, 40, 45, 50, 55, 60, 70, 80,
  34. };
  35. static const unsigned int taac_exp[] = {
  36. 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
  37. };
  38. static const unsigned int taac_mant[] = {
  39. 0, 10, 12, 13, 15, 20, 25, 30,
  40. 35, 40, 45, 50, 55, 60, 70, 80,
  41. };
  42. #define UNSTUFF_BITS(resp,start,size) \
  43. ({ \
  44. const int __size = size; \
  45. const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  46. const int __off = 3 - ((start) / 32); \
  47. const int __shft = (start) & 31; \
  48. u32 __res; \
  49. \
  50. __res = resp[__off] >> __shft; \
  51. if (__size + __shft > 32) \
  52. __res |= resp[__off-1] << ((32 - __shft) % 32); \
  53. __res & __mask; \
  54. })
  55. /*
  56. * Given the decoded CSD structure, decode the raw CID to our CID structure.
  57. */
  58. static int mmc_decode_cid(struct mmc_card *card)
  59. {
  60. u32 *resp = card->raw_cid;
  61. /*
  62. * The selection of the format here is based upon published
  63. * specs from sandisk and from what people have reported.
  64. */
  65. switch (card->csd.mmca_vsn) {
  66. case 0: /* MMC v1.0 - v1.2 */
  67. case 1: /* MMC v1.4 */
  68. card->cid.manfid = UNSTUFF_BITS(resp, 104, 24);
  69. card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
  70. card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
  71. card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
  72. card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
  73. card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
  74. card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
  75. card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8);
  76. card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4);
  77. card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4);
  78. card->cid.serial = UNSTUFF_BITS(resp, 16, 24);
  79. card->cid.month = UNSTUFF_BITS(resp, 12, 4);
  80. card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
  81. break;
  82. case 2: /* MMC v2.0 - v2.2 */
  83. case 3: /* MMC v3.1 - v3.3 */
  84. case 4: /* MMC v4 */
  85. card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
  86. card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
  87. card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
  88. card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
  89. card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
  90. card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
  91. card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
  92. card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
  93. card->cid.prv = UNSTUFF_BITS(resp, 48, 8);
  94. card->cid.serial = UNSTUFF_BITS(resp, 16, 32);
  95. card->cid.month = UNSTUFF_BITS(resp, 12, 4);
  96. card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
  97. break;
  98. default:
  99. pr_err("%s: card has unknown MMCA version %d\n",
  100. mmc_hostname(card->host), card->csd.mmca_vsn);
  101. return -EINVAL;
  102. }
  103. return 0;
  104. }
  105. static void mmc_set_erase_size(struct mmc_card *card)
  106. {
  107. if (card->ext_csd.erase_group_def & 1)
  108. card->erase_size = card->ext_csd.hc_erase_size;
  109. else
  110. card->erase_size = card->csd.erase_size;
  111. mmc_init_erase(card);
  112. }
  113. /*
  114. * Given a 128-bit response, decode to our card CSD structure.
  115. */
  116. static int mmc_decode_csd(struct mmc_card *card)
  117. {
  118. struct mmc_csd *csd = &card->csd;
  119. unsigned int e, m, a, b;
  120. u32 *resp = card->raw_csd;
  121. /*
  122. * We only understand CSD structure v1.1 and v1.2.
  123. * v1.2 has extra information in bits 15, 11 and 10.
  124. * We also support eMMC v4.4 & v4.41.
  125. */
  126. csd->structure = UNSTUFF_BITS(resp, 126, 2);
  127. if (csd->structure == 0) {
  128. pr_err("%s: unrecognised CSD structure version %d\n",
  129. mmc_hostname(card->host), csd->structure);
  130. return -EINVAL;
  131. }
  132. csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4);
  133. m = UNSTUFF_BITS(resp, 115, 4);
  134. e = UNSTUFF_BITS(resp, 112, 3);
  135. csd->taac_ns = (taac_exp[e] * taac_mant[m] + 9) / 10;
  136. csd->taac_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
  137. m = UNSTUFF_BITS(resp, 99, 4);
  138. e = UNSTUFF_BITS(resp, 96, 3);
  139. csd->max_dtr = tran_exp[e] * tran_mant[m];
  140. csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
  141. e = UNSTUFF_BITS(resp, 47, 3);
  142. m = UNSTUFF_BITS(resp, 62, 12);
  143. csd->capacity = (1 + m) << (e + 2);
  144. csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
  145. csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
  146. csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
  147. csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
  148. csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
  149. csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
  150. csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
  151. csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
  152. if (csd->write_blkbits >= 9) {
  153. a = UNSTUFF_BITS(resp, 42, 5);
  154. b = UNSTUFF_BITS(resp, 37, 5);
  155. csd->erase_size = (a + 1) * (b + 1);
  156. csd->erase_size <<= csd->write_blkbits - 9;
  157. }
  158. return 0;
  159. }
  160. static void mmc_select_card_type(struct mmc_card *card)
  161. {
  162. struct mmc_host *host = card->host;
  163. u8 card_type = card->ext_csd.raw_card_type;
  164. u32 caps = host->caps, caps2 = host->caps2;
  165. unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
  166. unsigned int avail_type = 0;
  167. if (caps & MMC_CAP_MMC_HIGHSPEED &&
  168. card_type & EXT_CSD_CARD_TYPE_HS_26) {
  169. hs_max_dtr = MMC_HIGH_26_MAX_DTR;
  170. avail_type |= EXT_CSD_CARD_TYPE_HS_26;
  171. }
  172. if (caps & MMC_CAP_MMC_HIGHSPEED &&
  173. card_type & EXT_CSD_CARD_TYPE_HS_52) {
  174. hs_max_dtr = MMC_HIGH_52_MAX_DTR;
  175. avail_type |= EXT_CSD_CARD_TYPE_HS_52;
  176. }
  177. if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&
  178. card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
  179. hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
  180. avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
  181. }
  182. if (caps & MMC_CAP_1_2V_DDR &&
  183. card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
  184. hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
  185. avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
  186. }
  187. if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
  188. card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
  189. hs200_max_dtr = MMC_HS200_MAX_DTR;
  190. avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
  191. }
  192. if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
  193. card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
  194. hs200_max_dtr = MMC_HS200_MAX_DTR;
  195. avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
  196. }
  197. if (caps2 & MMC_CAP2_HS400_1_8V &&
  198. card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
  199. hs200_max_dtr = MMC_HS200_MAX_DTR;
  200. avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
  201. }
  202. if (caps2 & MMC_CAP2_HS400_1_2V &&
  203. card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
  204. hs200_max_dtr = MMC_HS200_MAX_DTR;
  205. avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
  206. }
  207. if ((caps2 & MMC_CAP2_HS400_ES) &&
  208. card->ext_csd.strobe_support &&
  209. (avail_type & EXT_CSD_CARD_TYPE_HS400))
  210. avail_type |= EXT_CSD_CARD_TYPE_HS400ES;
  211. card->ext_csd.hs_max_dtr = hs_max_dtr;
  212. card->ext_csd.hs200_max_dtr = hs200_max_dtr;
  213. card->mmc_avail_type = avail_type;
  214. }
  215. static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
  216. {
  217. u8 hc_erase_grp_sz, hc_wp_grp_sz;
  218. /*
  219. * Disable these attributes by default
  220. */
  221. card->ext_csd.enhanced_area_offset = -EINVAL;
  222. card->ext_csd.enhanced_area_size = -EINVAL;
  223. /*
  224. * Enhanced area feature support -- check whether the eMMC
  225. * card has the Enhanced area enabled. If so, export enhanced
  226. * area offset and size to user by adding sysfs interface.
  227. */
  228. if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
  229. (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
  230. if (card->ext_csd.partition_setting_completed) {
  231. hc_erase_grp_sz =
  232. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  233. hc_wp_grp_sz =
  234. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  235. /*
  236. * calculate the enhanced data area offset, in bytes
  237. */
  238. card->ext_csd.enhanced_area_offset =
  239. (((unsigned long long)ext_csd[139]) << 24) +
  240. (((unsigned long long)ext_csd[138]) << 16) +
  241. (((unsigned long long)ext_csd[137]) << 8) +
  242. (((unsigned long long)ext_csd[136]));
  243. if (mmc_card_blockaddr(card))
  244. card->ext_csd.enhanced_area_offset <<= 9;
  245. /*
  246. * calculate the enhanced data area size, in kilobytes
  247. */
  248. card->ext_csd.enhanced_area_size =
  249. (ext_csd[142] << 16) + (ext_csd[141] << 8) +
  250. ext_csd[140];
  251. card->ext_csd.enhanced_area_size *=
  252. (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
  253. card->ext_csd.enhanced_area_size <<= 9;
  254. } else {
  255. pr_warn("%s: defines enhanced area without partition setting complete\n",
  256. mmc_hostname(card->host));
  257. }
  258. }
  259. }
  260. static void mmc_part_add(struct mmc_card *card, u64 size,
  261. unsigned int part_cfg, char *name, int idx, bool ro,
  262. int area_type)
  263. {
  264. card->part[card->nr_parts].size = size;
  265. card->part[card->nr_parts].part_cfg = part_cfg;
  266. sprintf(card->part[card->nr_parts].name, name, idx);
  267. card->part[card->nr_parts].force_ro = ro;
  268. card->part[card->nr_parts].area_type = area_type;
  269. card->nr_parts++;
  270. }
  271. static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
  272. {
  273. int idx;
  274. u8 hc_erase_grp_sz, hc_wp_grp_sz;
  275. u64 part_size;
  276. /*
  277. * General purpose partition feature support --
  278. * If ext_csd has the size of general purpose partitions,
  279. * set size, part_cfg, partition name in mmc_part.
  280. */
  281. if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
  282. EXT_CSD_PART_SUPPORT_PART_EN) {
  283. hc_erase_grp_sz =
  284. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  285. hc_wp_grp_sz =
  286. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  287. for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
  288. if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
  289. !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
  290. !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
  291. continue;
  292. if (card->ext_csd.partition_setting_completed == 0) {
  293. pr_warn("%s: has partition size defined without partition complete\n",
  294. mmc_hostname(card->host));
  295. break;
  296. }
  297. part_size =
  298. (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
  299. << 16) +
  300. (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
  301. << 8) +
  302. ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
  303. part_size *= (hc_erase_grp_sz * hc_wp_grp_sz);
  304. mmc_part_add(card, part_size << 19,
  305. EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
  306. "gp%d", idx, false,
  307. MMC_BLK_DATA_AREA_GP);
  308. }
  309. }
  310. }
  311. /* Minimum partition switch timeout in milliseconds */
  312. #define MMC_MIN_PART_SWITCH_TIME 300
  313. /*
  314. * Decode extended CSD.
  315. */
  316. static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
  317. {
  318. int err = 0, idx;
  319. u64 part_size;
  320. struct device_node *np;
  321. bool broken_hpi = false;
  322. /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
  323. card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
  324. if (card->csd.structure == 3) {
  325. if (card->ext_csd.raw_ext_csd_structure > 2) {
  326. pr_err("%s: unrecognised EXT_CSD structure "
  327. "version %d\n", mmc_hostname(card->host),
  328. card->ext_csd.raw_ext_csd_structure);
  329. err = -EINVAL;
  330. goto out;
  331. }
  332. }
  333. np = mmc_of_find_child_device(card->host, 0);
  334. if (np && of_device_is_compatible(np, "mmc-card"))
  335. broken_hpi = of_property_read_bool(np, "broken-hpi");
  336. of_node_put(np);
  337. /*
  338. * The EXT_CSD format is meant to be forward compatible. As long
  339. * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
  340. * are authorized, see JEDEC JESD84-B50 section B.8.
  341. */
  342. card->ext_csd.rev = ext_csd[EXT_CSD_REV];
  343. /* fixup device after ext_csd revision field is updated */
  344. mmc_fixup_device(card, mmc_ext_csd_fixups);
  345. card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
  346. card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
  347. card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
  348. card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
  349. if (card->ext_csd.rev >= 2) {
  350. card->ext_csd.sectors =
  351. ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
  352. ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
  353. ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
  354. ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
  355. /* Cards with density > 2GiB are sector addressed */
  356. if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
  357. mmc_card_set_blockaddr(card);
  358. }
  359. card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];
  360. card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
  361. mmc_select_card_type(card);
  362. card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
  363. card->ext_csd.raw_erase_timeout_mult =
  364. ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
  365. card->ext_csd.raw_hc_erase_grp_size =
  366. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  367. if (card->ext_csd.rev >= 3) {
  368. u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
  369. card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
  370. /* EXT_CSD value is in units of 10ms, but we store in ms */
  371. card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
  372. /* Sleep / awake timeout in 100ns units */
  373. if (sa_shift > 0 && sa_shift <= 0x17)
  374. card->ext_csd.sa_timeout =
  375. 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
  376. card->ext_csd.erase_group_def =
  377. ext_csd[EXT_CSD_ERASE_GROUP_DEF];
  378. card->ext_csd.hc_erase_timeout = 300 *
  379. ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
  380. card->ext_csd.hc_erase_size =
  381. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
  382. card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
  383. /*
  384. * There are two boot regions of equal size, defined in
  385. * multiples of 128K.
  386. */
  387. if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
  388. for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
  389. part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
  390. mmc_part_add(card, part_size,
  391. EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
  392. "boot%d", idx, true,
  393. MMC_BLK_DATA_AREA_BOOT);
  394. }
  395. }
  396. }
  397. card->ext_csd.raw_hc_erase_gap_size =
  398. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  399. card->ext_csd.raw_sec_trim_mult =
  400. ext_csd[EXT_CSD_SEC_TRIM_MULT];
  401. card->ext_csd.raw_sec_erase_mult =
  402. ext_csd[EXT_CSD_SEC_ERASE_MULT];
  403. card->ext_csd.raw_sec_feature_support =
  404. ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
  405. card->ext_csd.raw_trim_mult =
  406. ext_csd[EXT_CSD_TRIM_MULT];
  407. card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
  408. card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
  409. if (card->ext_csd.rev >= 4) {
  410. if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
  411. EXT_CSD_PART_SETTING_COMPLETED)
  412. card->ext_csd.partition_setting_completed = 1;
  413. else
  414. card->ext_csd.partition_setting_completed = 0;
  415. mmc_manage_enhanced_area(card, ext_csd);
  416. mmc_manage_gp_partitions(card, ext_csd);
  417. card->ext_csd.sec_trim_mult =
  418. ext_csd[EXT_CSD_SEC_TRIM_MULT];
  419. card->ext_csd.sec_erase_mult =
  420. ext_csd[EXT_CSD_SEC_ERASE_MULT];
  421. card->ext_csd.sec_feature_support =
  422. ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
  423. card->ext_csd.trim_timeout = 300 *
  424. ext_csd[EXT_CSD_TRIM_MULT];
  425. /*
  426. * Note that the call to mmc_part_add above defaults to read
  427. * only. If this default assumption is changed, the call must
  428. * take into account the value of boot_locked below.
  429. */
  430. card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
  431. card->ext_csd.boot_ro_lockable = true;
  432. /* Save power class values */
  433. card->ext_csd.raw_pwr_cl_52_195 =
  434. ext_csd[EXT_CSD_PWR_CL_52_195];
  435. card->ext_csd.raw_pwr_cl_26_195 =
  436. ext_csd[EXT_CSD_PWR_CL_26_195];
  437. card->ext_csd.raw_pwr_cl_52_360 =
  438. ext_csd[EXT_CSD_PWR_CL_52_360];
  439. card->ext_csd.raw_pwr_cl_26_360 =
  440. ext_csd[EXT_CSD_PWR_CL_26_360];
  441. card->ext_csd.raw_pwr_cl_200_195 =
  442. ext_csd[EXT_CSD_PWR_CL_200_195];
  443. card->ext_csd.raw_pwr_cl_200_360 =
  444. ext_csd[EXT_CSD_PWR_CL_200_360];
  445. card->ext_csd.raw_pwr_cl_ddr_52_195 =
  446. ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
  447. card->ext_csd.raw_pwr_cl_ddr_52_360 =
  448. ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
  449. card->ext_csd.raw_pwr_cl_ddr_200_360 =
  450. ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
  451. }
  452. if (card->ext_csd.rev >= 5) {
  453. /* Adjust production date as per JEDEC JESD84-B451 */
  454. if (card->cid.year < 2010)
  455. card->cid.year += 16;
  456. /* check whether the eMMC card supports BKOPS */
  457. if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
  458. card->ext_csd.bkops = 1;
  459. card->ext_csd.man_bkops_en =
  460. (ext_csd[EXT_CSD_BKOPS_EN] &
  461. EXT_CSD_MANUAL_BKOPS_MASK);
  462. card->ext_csd.raw_bkops_status =
  463. ext_csd[EXT_CSD_BKOPS_STATUS];
  464. if (card->ext_csd.man_bkops_en)
  465. pr_debug("%s: MAN_BKOPS_EN bit is set\n",
  466. mmc_hostname(card->host));
  467. card->ext_csd.auto_bkops_en =
  468. (ext_csd[EXT_CSD_BKOPS_EN] &
  469. EXT_CSD_AUTO_BKOPS_MASK);
  470. if (card->ext_csd.auto_bkops_en)
  471. pr_debug("%s: AUTO_BKOPS_EN bit is set\n",
  472. mmc_hostname(card->host));
  473. }
  474. /* check whether the eMMC card supports HPI */
  475. if (!mmc_card_broken_hpi(card) &&
  476. !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
  477. card->ext_csd.hpi = 1;
  478. if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
  479. card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
  480. else
  481. card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
  482. /*
  483. * Indicate the maximum timeout to close
  484. * a command interrupted by HPI
  485. */
  486. card->ext_csd.out_of_int_time =
  487. ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
  488. }
  489. card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
  490. card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
  491. /*
  492. * RPMB regions are defined in multiples of 128K.
  493. */
  494. card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
  495. if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
  496. mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
  497. EXT_CSD_PART_CONFIG_ACC_RPMB,
  498. "rpmb", 0, false,
  499. MMC_BLK_DATA_AREA_RPMB);
  500. }
  501. }
  502. card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
  503. if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
  504. card->erased_byte = 0xFF;
  505. else
  506. card->erased_byte = 0x0;
  507. /* eMMC v4.5 or later */
  508. card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;
  509. if (card->ext_csd.rev >= 6) {
  510. card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
  511. card->ext_csd.generic_cmd6_time = 10 *
  512. ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
  513. card->ext_csd.power_off_longtime = 10 *
  514. ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
  515. card->ext_csd.cache_size =
  516. ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
  517. ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
  518. ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
  519. ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
  520. if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
  521. card->ext_csd.data_sector_size = 4096;
  522. else
  523. card->ext_csd.data_sector_size = 512;
  524. if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
  525. (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
  526. card->ext_csd.data_tag_unit_size =
  527. ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
  528. (card->ext_csd.data_sector_size);
  529. } else {
  530. card->ext_csd.data_tag_unit_size = 0;
  531. }
  532. card->ext_csd.max_packed_writes =
  533. ext_csd[EXT_CSD_MAX_PACKED_WRITES];
  534. card->ext_csd.max_packed_reads =
  535. ext_csd[EXT_CSD_MAX_PACKED_READS];
  536. } else {
  537. card->ext_csd.data_sector_size = 512;
  538. }
  539. /*
  540. * GENERIC_CMD6_TIME is to be used "unless a specific timeout is defined
  541. * when accessing a specific field", so use it here if there is no
  542. * PARTITION_SWITCH_TIME.
  543. */
  544. if (!card->ext_csd.part_time)
  545. card->ext_csd.part_time = card->ext_csd.generic_cmd6_time;
  546. /* Some eMMC set the value too low so set a minimum */
  547. if (card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
  548. card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
  549. /* eMMC v5 or later */
  550. if (card->ext_csd.rev >= 7) {
  551. memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
  552. MMC_FIRMWARE_LEN);
  553. card->ext_csd.ffu_capable =
  554. (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
  555. !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
  556. card->ext_csd.pre_eol_info = ext_csd[EXT_CSD_PRE_EOL_INFO];
  557. card->ext_csd.device_life_time_est_typ_a =
  558. ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_A];
  559. card->ext_csd.device_life_time_est_typ_b =
  560. ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_B];
  561. }
  562. /* eMMC v5.1 or later */
  563. if (card->ext_csd.rev >= 8) {
  564. card->ext_csd.cmdq_support = ext_csd[EXT_CSD_CMDQ_SUPPORT] &
  565. EXT_CSD_CMDQ_SUPPORTED;
  566. card->ext_csd.cmdq_depth = (ext_csd[EXT_CSD_CMDQ_DEPTH] &
  567. EXT_CSD_CMDQ_DEPTH_MASK) + 1;
  568. /* Exclude inefficiently small queue depths */
  569. if (card->ext_csd.cmdq_depth <= 2) {
  570. card->ext_csd.cmdq_support = false;
  571. card->ext_csd.cmdq_depth = 0;
  572. }
  573. if (card->ext_csd.cmdq_support) {
  574. pr_debug("%s: Command Queue supported depth %u\n",
  575. mmc_hostname(card->host),
  576. card->ext_csd.cmdq_depth);
  577. }
  578. card->ext_csd.enhanced_rpmb_supported =
  579. (card->ext_csd.rel_param &
  580. EXT_CSD_WR_REL_PARAM_EN_RPMB_REL_WR);
  581. }
  582. out:
  583. return err;
  584. }
  585. static int mmc_read_ext_csd(struct mmc_card *card)
  586. {
  587. u8 *ext_csd;
  588. int err;
  589. if (!mmc_can_ext_csd(card))
  590. return 0;
  591. err = mmc_get_ext_csd(card, &ext_csd);
  592. if (err) {
  593. /* If the host or the card can't do the switch,
  594. * fail more gracefully. */
  595. if ((err != -EINVAL)
  596. && (err != -ENOSYS)
  597. && (err != -EFAULT))
  598. return err;
  599. /*
  600. * High capacity cards should have this "magic" size
  601. * stored in their CSD.
  602. */
  603. if (card->csd.capacity == (4096 * 512)) {
  604. pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
  605. mmc_hostname(card->host));
  606. } else {
  607. pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
  608. mmc_hostname(card->host));
  609. err = 0;
  610. }
  611. return err;
  612. }
  613. err = mmc_decode_ext_csd(card, ext_csd);
  614. kfree(ext_csd);
  615. return err;
  616. }
  617. static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
  618. {
  619. u8 *bw_ext_csd;
  620. int err;
  621. if (bus_width == MMC_BUS_WIDTH_1)
  622. return 0;
  623. err = mmc_get_ext_csd(card, &bw_ext_csd);
  624. if (err)
  625. return err;
  626. /* only compare read only fields */
  627. err = !((card->ext_csd.raw_partition_support ==
  628. bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
  629. (card->ext_csd.raw_erased_mem_count ==
  630. bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
  631. (card->ext_csd.rev ==
  632. bw_ext_csd[EXT_CSD_REV]) &&
  633. (card->ext_csd.raw_ext_csd_structure ==
  634. bw_ext_csd[EXT_CSD_STRUCTURE]) &&
  635. (card->ext_csd.raw_card_type ==
  636. bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
  637. (card->ext_csd.raw_s_a_timeout ==
  638. bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
  639. (card->ext_csd.raw_hc_erase_gap_size ==
  640. bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
  641. (card->ext_csd.raw_erase_timeout_mult ==
  642. bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
  643. (card->ext_csd.raw_hc_erase_grp_size ==
  644. bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
  645. (card->ext_csd.raw_sec_trim_mult ==
  646. bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
  647. (card->ext_csd.raw_sec_erase_mult ==
  648. bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
  649. (card->ext_csd.raw_sec_feature_support ==
  650. bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
  651. (card->ext_csd.raw_trim_mult ==
  652. bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
  653. (card->ext_csd.raw_sectors[0] ==
  654. bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
  655. (card->ext_csd.raw_sectors[1] ==
  656. bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
  657. (card->ext_csd.raw_sectors[2] ==
  658. bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
  659. (card->ext_csd.raw_sectors[3] ==
  660. bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
  661. (card->ext_csd.raw_pwr_cl_52_195 ==
  662. bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
  663. (card->ext_csd.raw_pwr_cl_26_195 ==
  664. bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
  665. (card->ext_csd.raw_pwr_cl_52_360 ==
  666. bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
  667. (card->ext_csd.raw_pwr_cl_26_360 ==
  668. bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
  669. (card->ext_csd.raw_pwr_cl_200_195 ==
  670. bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
  671. (card->ext_csd.raw_pwr_cl_200_360 ==
  672. bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
  673. (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
  674. bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
  675. (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
  676. bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
  677. (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
  678. bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
  679. if (err)
  680. err = -EINVAL;
  681. kfree(bw_ext_csd);
  682. return err;
  683. }
  684. MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
  685. card->raw_cid[2], card->raw_cid[3]);
  686. MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
  687. card->raw_csd[2], card->raw_csd[3]);
  688. MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
  689. MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
  690. MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
  691. MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
  692. MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
  693. MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
  694. MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
  695. MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
  696. MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
  697. MMC_DEV_ATTR(rev, "0x%x\n", card->ext_csd.rev);
  698. MMC_DEV_ATTR(pre_eol_info, "0x%02x\n", card->ext_csd.pre_eol_info);
  699. MMC_DEV_ATTR(life_time, "0x%02x 0x%02x\n",
  700. card->ext_csd.device_life_time_est_typ_a,
  701. card->ext_csd.device_life_time_est_typ_b);
  702. MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
  703. MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
  704. card->ext_csd.enhanced_area_offset);
  705. MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
  706. MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
  707. MMC_DEV_ATTR(enhanced_rpmb_supported, "%#x\n",
  708. card->ext_csd.enhanced_rpmb_supported);
  709. MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
  710. MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
  711. MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
  712. MMC_DEV_ATTR(cmdq_en, "%d\n", card->ext_csd.cmdq_en);
  713. static ssize_t mmc_fwrev_show(struct device *dev,
  714. struct device_attribute *attr,
  715. char *buf)
  716. {
  717. struct mmc_card *card = mmc_dev_to_card(dev);
  718. if (card->ext_csd.rev < 7) {
  719. return sprintf(buf, "0x%x\n", card->cid.fwrev);
  720. } else {
  721. return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
  722. card->ext_csd.fwrev);
  723. }
  724. }
  725. static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
  726. static ssize_t mmc_dsr_show(struct device *dev,
  727. struct device_attribute *attr,
  728. char *buf)
  729. {
  730. struct mmc_card *card = mmc_dev_to_card(dev);
  731. struct mmc_host *host = card->host;
  732. if (card->csd.dsr_imp && host->dsr_req)
  733. return sprintf(buf, "0x%x\n", host->dsr);
  734. else
  735. /* return default DSR value */
  736. return sprintf(buf, "0x%x\n", 0x404);
  737. }
  738. static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
  739. static struct attribute *mmc_std_attrs[] = {
  740. &dev_attr_cid.attr,
  741. &dev_attr_csd.attr,
  742. &dev_attr_date.attr,
  743. &dev_attr_erase_size.attr,
  744. &dev_attr_preferred_erase_size.attr,
  745. &dev_attr_fwrev.attr,
  746. &dev_attr_ffu_capable.attr,
  747. &dev_attr_hwrev.attr,
  748. &dev_attr_manfid.attr,
  749. &dev_attr_name.attr,
  750. &dev_attr_oemid.attr,
  751. &dev_attr_prv.attr,
  752. &dev_attr_rev.attr,
  753. &dev_attr_pre_eol_info.attr,
  754. &dev_attr_life_time.attr,
  755. &dev_attr_serial.attr,
  756. &dev_attr_enhanced_area_offset.attr,
  757. &dev_attr_enhanced_area_size.attr,
  758. &dev_attr_raw_rpmb_size_mult.attr,
  759. &dev_attr_enhanced_rpmb_supported.attr,
  760. &dev_attr_rel_sectors.attr,
  761. &dev_attr_ocr.attr,
  762. &dev_attr_rca.attr,
  763. &dev_attr_dsr.attr,
  764. &dev_attr_cmdq_en.attr,
  765. NULL,
  766. };
  767. ATTRIBUTE_GROUPS(mmc_std);
  768. static struct device_type mmc_type = {
  769. .groups = mmc_std_groups,
  770. };
  771. /*
  772. * Select the PowerClass for the current bus width
  773. * If power class is defined for 4/8 bit bus in the
  774. * extended CSD register, select it by executing the
  775. * mmc_switch command.
  776. */
  777. static int __mmc_select_powerclass(struct mmc_card *card,
  778. unsigned int bus_width)
  779. {
  780. struct mmc_host *host = card->host;
  781. struct mmc_ext_csd *ext_csd = &card->ext_csd;
  782. unsigned int pwrclass_val = 0;
  783. int err = 0;
  784. switch (1 << host->ios.vdd) {
  785. case MMC_VDD_165_195:
  786. if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
  787. pwrclass_val = ext_csd->raw_pwr_cl_26_195;
  788. else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
  789. pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
  790. ext_csd->raw_pwr_cl_52_195 :
  791. ext_csd->raw_pwr_cl_ddr_52_195;
  792. else if (host->ios.clock <= MMC_HS200_MAX_DTR)
  793. pwrclass_val = ext_csd->raw_pwr_cl_200_195;
  794. break;
  795. case MMC_VDD_27_28:
  796. case MMC_VDD_28_29:
  797. case MMC_VDD_29_30:
  798. case MMC_VDD_30_31:
  799. case MMC_VDD_31_32:
  800. case MMC_VDD_32_33:
  801. case MMC_VDD_33_34:
  802. case MMC_VDD_34_35:
  803. case MMC_VDD_35_36:
  804. if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
  805. pwrclass_val = ext_csd->raw_pwr_cl_26_360;
  806. else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
  807. pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
  808. ext_csd->raw_pwr_cl_52_360 :
  809. ext_csd->raw_pwr_cl_ddr_52_360;
  810. else if (host->ios.clock <= MMC_HS200_MAX_DTR)
  811. pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
  812. ext_csd->raw_pwr_cl_ddr_200_360 :
  813. ext_csd->raw_pwr_cl_200_360;
  814. break;
  815. default:
  816. pr_warn("%s: Voltage range not supported for power class\n",
  817. mmc_hostname(host));
  818. return -EINVAL;
  819. }
  820. if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
  821. pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
  822. EXT_CSD_PWR_CL_8BIT_SHIFT;
  823. else
  824. pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
  825. EXT_CSD_PWR_CL_4BIT_SHIFT;
  826. /* If the power class is different from the default value */
  827. if (pwrclass_val > 0) {
  828. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  829. EXT_CSD_POWER_CLASS,
  830. pwrclass_val,
  831. card->ext_csd.generic_cmd6_time);
  832. }
  833. return err;
  834. }
  835. static int mmc_select_powerclass(struct mmc_card *card)
  836. {
  837. struct mmc_host *host = card->host;
  838. u32 bus_width, ext_csd_bits;
  839. int err, ddr;
  840. /* Power class selection is supported for versions >= 4.0 */
  841. if (!mmc_can_ext_csd(card))
  842. return 0;
  843. bus_width = host->ios.bus_width;
  844. /* Power class values are defined only for 4/8 bit bus */
  845. if (bus_width == MMC_BUS_WIDTH_1)
  846. return 0;
  847. ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
  848. if (ddr)
  849. ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
  850. EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
  851. else
  852. ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
  853. EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
  854. err = __mmc_select_powerclass(card, ext_csd_bits);
  855. if (err)
  856. pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
  857. mmc_hostname(host), 1 << bus_width, ddr);
  858. return err;
  859. }
  860. /*
  861. * Set the bus speed for the selected speed mode.
  862. */
  863. void mmc_set_bus_speed(struct mmc_card *card)
  864. {
  865. unsigned int max_dtr = (unsigned int)-1;
  866. if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
  867. max_dtr > card->ext_csd.hs200_max_dtr)
  868. max_dtr = card->ext_csd.hs200_max_dtr;
  869. else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
  870. max_dtr = card->ext_csd.hs_max_dtr;
  871. else if (max_dtr > card->csd.max_dtr)
  872. max_dtr = card->csd.max_dtr;
  873. mmc_set_clock(card->host, max_dtr);
  874. }
  875. /*
  876. * Select the bus width amoung 4-bit and 8-bit(SDR).
  877. * If the bus width is changed successfully, return the selected width value.
  878. * Zero is returned instead of error value if the wide width is not supported.
  879. */
  880. int mmc_select_bus_width(struct mmc_card *card)
  881. {
  882. static unsigned ext_csd_bits[] = {
  883. EXT_CSD_BUS_WIDTH_8,
  884. EXT_CSD_BUS_WIDTH_4,
  885. };
  886. static unsigned bus_widths[] = {
  887. MMC_BUS_WIDTH_8,
  888. MMC_BUS_WIDTH_4,
  889. };
  890. struct mmc_host *host = card->host;
  891. unsigned idx, bus_width = 0;
  892. int err = 0;
  893. if (!mmc_can_ext_csd(card) ||
  894. !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
  895. return 0;
  896. idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
  897. /*
  898. * Unlike SD, MMC cards dont have a configuration register to notify
  899. * supported bus width. So bus test command should be run to identify
  900. * the supported bus width or compare the ext csd values of current
  901. * bus width and ext csd values of 1 bit mode read earlier.
  902. */
  903. for (; idx < ARRAY_SIZE(bus_widths); idx++) {
  904. /*
  905. * Host is capable of 8bit transfer, then switch
  906. * the device to work in 8bit transfer mode. If the
  907. * mmc switch command returns error then switch to
  908. * 4bit transfer mode. On success set the corresponding
  909. * bus width on the host.
  910. */
  911. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  912. EXT_CSD_BUS_WIDTH,
  913. ext_csd_bits[idx],
  914. card->ext_csd.generic_cmd6_time);
  915. if (err)
  916. continue;
  917. bus_width = bus_widths[idx];
  918. mmc_set_bus_width(host, bus_width);
  919. /*
  920. * If controller can't handle bus width test,
  921. * compare ext_csd previously read in 1 bit mode
  922. * against ext_csd at new bus width
  923. */
  924. if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
  925. err = mmc_compare_ext_csds(card, bus_width);
  926. else
  927. err = mmc_bus_test(card, bus_width);
  928. if (!err) {
  929. err = bus_width;
  930. break;
  931. } else {
  932. pr_warn("%s: switch to bus width %d failed\n",
  933. mmc_hostname(host), 1 << bus_width);
  934. }
  935. }
  936. return err;
  937. }
  938. EXPORT_SYMBOL_GPL(mmc_select_bus_width);
  939. /*
  940. * Switch to the high-speed mode
  941. */
  942. int mmc_select_hs(struct mmc_card *card)
  943. {
  944. int err;
  945. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  946. EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
  947. card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,
  948. true, true);
  949. if (err)
  950. pr_warn("%s: switch to high-speed failed, err:%d\n",
  951. mmc_hostname(card->host), err);
  952. return err;
  953. }
  954. EXPORT_SYMBOL_GPL(mmc_select_hs);
  955. /*
  956. * Activate wide bus and DDR if supported.
  957. */
  958. int mmc_select_hs_ddr(struct mmc_card *card)
  959. {
  960. struct mmc_host *host = card->host;
  961. u32 bus_width, ext_csd_bits;
  962. int err = 0;
  963. if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
  964. return 0;
  965. bus_width = host->ios.bus_width;
  966. if (bus_width == MMC_BUS_WIDTH_1)
  967. return 0;
  968. ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
  969. EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
  970. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  971. EXT_CSD_BUS_WIDTH,
  972. ext_csd_bits,
  973. card->ext_csd.generic_cmd6_time,
  974. MMC_TIMING_MMC_DDR52,
  975. true, true);
  976. if (err) {
  977. pr_err("%s: switch to bus width %d ddr failed\n",
  978. mmc_hostname(host), 1 << bus_width);
  979. return err;
  980. }
  981. /*
  982. * eMMC cards can support 3.3V to 1.2V i/o (vccq)
  983. * signaling.
  984. *
  985. * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
  986. *
  987. * 1.8V vccq at 3.3V core voltage (vcc) is not required
  988. * in the JEDEC spec for DDR.
  989. *
  990. * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
  991. * host controller can support this, like some of the SDHCI
  992. * controller which connect to an eMMC device. Some of these
  993. * host controller still needs to use 1.8v vccq for supporting
  994. * DDR mode.
  995. *
  996. * So the sequence will be:
  997. * if (host and device can both support 1.2v IO)
  998. * use 1.2v IO;
  999. * else if (host and device can both support 1.8v IO)
  1000. * use 1.8v IO;
  1001. * so if host and device can only support 3.3v IO, this is the
  1002. * last choice.
  1003. *
  1004. * WARNING: eMMC rules are NOT the same as SD DDR
  1005. */
  1006. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
  1007. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
  1008. if (!err)
  1009. return 0;
  1010. }
  1011. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&
  1012. host->caps & MMC_CAP_1_8V_DDR)
  1013. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
  1014. /* make sure vccq is 3.3v after switching disaster */
  1015. if (err)
  1016. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
  1017. return err;
  1018. }
  1019. EXPORT_SYMBOL_GPL(mmc_select_hs_ddr);
  1020. int mmc_select_hs400(struct mmc_card *card)
  1021. {
  1022. struct mmc_host *host = card->host;
  1023. unsigned int max_dtr;
  1024. int err = 0;
  1025. u8 val;
  1026. /*
  1027. * HS400 mode requires 8-bit bus width
  1028. */
  1029. if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
  1030. host->ios.bus_width == MMC_BUS_WIDTH_8))
  1031. return 0;
  1032. /* Switch card to HS mode */
  1033. val = EXT_CSD_TIMING_HS;
  1034. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1035. EXT_CSD_HS_TIMING, val,
  1036. card->ext_csd.generic_cmd6_time, 0,
  1037. false, true);
  1038. if (err) {
  1039. pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
  1040. mmc_hostname(host), err);
  1041. return err;
  1042. }
  1043. /* Prepare host to downgrade to HS timing */
  1044. if (host->ops->hs400_downgrade)
  1045. host->ops->hs400_downgrade(host);
  1046. /* Set host controller to HS timing */
  1047. mmc_set_timing(host, MMC_TIMING_MMC_HS);
  1048. /* Reduce frequency to HS frequency */
  1049. max_dtr = card->ext_csd.hs_max_dtr;
  1050. mmc_set_clock(host, max_dtr);
  1051. err = mmc_switch_status(card, true);
  1052. if (err)
  1053. goto out_err;
  1054. if (host->ops->hs400_prepare_ddr)
  1055. host->ops->hs400_prepare_ddr(host);
  1056. /* Switch card to DDR */
  1057. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1058. EXT_CSD_BUS_WIDTH,
  1059. EXT_CSD_DDR_BUS_WIDTH_8,
  1060. card->ext_csd.generic_cmd6_time);
  1061. if (err) {
  1062. pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
  1063. mmc_hostname(host), err);
  1064. return err;
  1065. }
  1066. /* Switch card to HS400 */
  1067. val = EXT_CSD_TIMING_HS400 |
  1068. card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
  1069. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1070. EXT_CSD_HS_TIMING, val,
  1071. card->ext_csd.generic_cmd6_time, 0,
  1072. false, true);
  1073. if (err) {
  1074. pr_err("%s: switch to hs400 failed, err:%d\n",
  1075. mmc_hostname(host), err);
  1076. return err;
  1077. }
  1078. /* Set host controller to HS400 timing and frequency */
  1079. mmc_set_timing(host, MMC_TIMING_MMC_HS400);
  1080. mmc_set_bus_speed(card);
  1081. if (host->ops->hs400_complete)
  1082. host->ops->hs400_complete(host);
  1083. err = mmc_switch_status(card, true);
  1084. if (err)
  1085. goto out_err;
  1086. return 0;
  1087. out_err:
  1088. pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
  1089. __func__, err);
  1090. return err;
  1091. }
  1092. EXPORT_SYMBOL_GPL(mmc_select_hs400);
  1093. int mmc_hs200_to_hs400(struct mmc_card *card)
  1094. {
  1095. return mmc_select_hs400(card);
  1096. }
  1097. int mmc_hs400_to_hs200(struct mmc_card *card)
  1098. {
  1099. struct mmc_host *host = card->host;
  1100. unsigned int max_dtr;
  1101. int err;
  1102. u8 val;
  1103. /* Reduce frequency to HS */
  1104. max_dtr = card->ext_csd.hs_max_dtr;
  1105. mmc_set_clock(host, max_dtr);
  1106. /* Switch HS400 to HS DDR */
  1107. val = EXT_CSD_TIMING_HS;
  1108. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
  1109. val, card->ext_csd.generic_cmd6_time, 0,
  1110. false, true);
  1111. if (err)
  1112. goto out_err;
  1113. if (host->ops->hs400_downgrade)
  1114. host->ops->hs400_downgrade(host);
  1115. mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
  1116. err = mmc_switch_status(card, true);
  1117. if (err)
  1118. goto out_err;
  1119. /* Switch HS DDR to HS */
  1120. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
  1121. EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,
  1122. 0, false, true);
  1123. if (err)
  1124. goto out_err;
  1125. mmc_set_timing(host, MMC_TIMING_MMC_HS);
  1126. err = mmc_switch_status(card, true);
  1127. if (err)
  1128. goto out_err;
  1129. /* Switch HS to HS200 */
  1130. val = EXT_CSD_TIMING_HS200 |
  1131. card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
  1132. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
  1133. val, card->ext_csd.generic_cmd6_time, 0,
  1134. false, true);
  1135. if (err)
  1136. goto out_err;
  1137. mmc_set_timing(host, MMC_TIMING_MMC_HS200);
  1138. /*
  1139. * For HS200, CRC errors are not a reliable way to know the switch
  1140. * failed. If there really is a problem, we would expect tuning will
  1141. * fail and the result ends up the same.
  1142. */
  1143. err = mmc_switch_status(card, false);
  1144. if (err)
  1145. goto out_err;
  1146. mmc_set_bus_speed(card);
  1147. /* Prepare tuning for HS400 mode. */
  1148. if (host->ops->prepare_hs400_tuning)
  1149. host->ops->prepare_hs400_tuning(host, &host->ios);
  1150. return 0;
  1151. out_err:
  1152. pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
  1153. __func__, err);
  1154. return err;
  1155. }
  1156. static void mmc_select_driver_type(struct mmc_card *card)
  1157. {
  1158. int card_drv_type, drive_strength, drv_type = 0;
  1159. int fixed_drv_type = card->host->fixed_drv_type;
  1160. card_drv_type = card->ext_csd.raw_driver_strength |
  1161. mmc_driver_type_mask(0);
  1162. if (fixed_drv_type >= 0)
  1163. drive_strength = card_drv_type & mmc_driver_type_mask(fixed_drv_type)
  1164. ? fixed_drv_type : 0;
  1165. else
  1166. drive_strength = mmc_select_drive_strength(card,
  1167. card->ext_csd.hs200_max_dtr,
  1168. card_drv_type, &drv_type);
  1169. card->drive_strength = drive_strength;
  1170. if (drv_type)
  1171. mmc_set_driver_type(card->host, drv_type);
  1172. }
  1173. static int mmc_select_hs400es(struct mmc_card *card)
  1174. {
  1175. struct mmc_host *host = card->host;
  1176. int err = -EINVAL;
  1177. u8 val;
  1178. if (!(host->caps & MMC_CAP_8_BIT_DATA)) {
  1179. err = -ENOTSUPP;
  1180. goto out_err;
  1181. }
  1182. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)
  1183. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
  1184. if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)
  1185. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
  1186. /* If fails try again during next card power cycle */
  1187. if (err)
  1188. goto out_err;
  1189. err = mmc_select_bus_width(card);
  1190. if (err != MMC_BUS_WIDTH_8) {
  1191. pr_err("%s: switch to 8bit bus width failed, err:%d\n",
  1192. mmc_hostname(host), err);
  1193. err = err < 0 ? err : -ENOTSUPP;
  1194. goto out_err;
  1195. }
  1196. /* Switch card to HS mode */
  1197. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1198. EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
  1199. card->ext_csd.generic_cmd6_time, 0,
  1200. false, true);
  1201. if (err) {
  1202. pr_err("%s: switch to hs for hs400es failed, err:%d\n",
  1203. mmc_hostname(host), err);
  1204. goto out_err;
  1205. }
  1206. mmc_set_timing(host, MMC_TIMING_MMC_HS);
  1207. err = mmc_switch_status(card, true);
  1208. if (err)
  1209. goto out_err;
  1210. mmc_set_clock(host, card->ext_csd.hs_max_dtr);
  1211. /* Switch card to DDR with strobe bit */
  1212. val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;
  1213. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1214. EXT_CSD_BUS_WIDTH,
  1215. val,
  1216. card->ext_csd.generic_cmd6_time);
  1217. if (err) {
  1218. pr_err("%s: switch to bus width for hs400es failed, err:%d\n",
  1219. mmc_hostname(host), err);
  1220. goto out_err;
  1221. }
  1222. mmc_select_driver_type(card);
  1223. /* Switch card to HS400 */
  1224. val = EXT_CSD_TIMING_HS400 |
  1225. card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
  1226. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1227. EXT_CSD_HS_TIMING, val,
  1228. card->ext_csd.generic_cmd6_time, 0,
  1229. false, true);
  1230. if (err) {
  1231. pr_err("%s: switch to hs400es failed, err:%d\n",
  1232. mmc_hostname(host), err);
  1233. goto out_err;
  1234. }
  1235. /* Set host controller to HS400 timing and frequency */
  1236. mmc_set_timing(host, MMC_TIMING_MMC_HS400);
  1237. /* Controller enable enhanced strobe function */
  1238. host->ios.enhanced_strobe = true;
  1239. if (host->ops->hs400_enhanced_strobe)
  1240. host->ops->hs400_enhanced_strobe(host, &host->ios);
  1241. err = mmc_switch_status(card, true);
  1242. if (err)
  1243. goto out_err;
  1244. return 0;
  1245. out_err:
  1246. pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
  1247. __func__, err);
  1248. return err;
  1249. }
  1250. /*
  1251. * For device supporting HS200 mode, the following sequence
  1252. * should be done before executing the tuning process.
  1253. * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
  1254. * 2. switch to HS200 mode
  1255. * 3. set the clock to > 52Mhz and <=200MHz
  1256. */
  1257. static int mmc_select_hs200(struct mmc_card *card)
  1258. {
  1259. struct mmc_host *host = card->host;
  1260. unsigned int old_timing, old_signal_voltage;
  1261. int err = -EINVAL;
  1262. u8 val;
  1263. old_signal_voltage = host->ios.signal_voltage;
  1264. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
  1265. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
  1266. if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
  1267. err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
  1268. /* If fails try again during next card power cycle */
  1269. if (err)
  1270. return err;
  1271. mmc_select_driver_type(card);
  1272. /*
  1273. * Set the bus width(4 or 8) with host's support and
  1274. * switch to HS200 mode if bus width is set successfully.
  1275. */
  1276. err = mmc_select_bus_width(card);
  1277. if (err > 0) {
  1278. val = EXT_CSD_TIMING_HS200 |
  1279. card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
  1280. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1281. EXT_CSD_HS_TIMING, val,
  1282. card->ext_csd.generic_cmd6_time, 0,
  1283. false, true);
  1284. if (err)
  1285. goto err;
  1286. old_timing = host->ios.timing;
  1287. mmc_set_timing(host, MMC_TIMING_MMC_HS200);
  1288. /*
  1289. * For HS200, CRC errors are not a reliable way to know the
  1290. * switch failed. If there really is a problem, we would expect
  1291. * tuning will fail and the result ends up the same.
  1292. */
  1293. err = mmc_switch_status(card, false);
  1294. /*
  1295. * mmc_select_timing() assumes timing has not changed if
  1296. * it is a switch error.
  1297. */
  1298. if (err == -EBADMSG)
  1299. mmc_set_timing(host, old_timing);
  1300. }
  1301. err:
  1302. if (err) {
  1303. /* fall back to the old signal voltage, if fails report error */
  1304. if (mmc_set_signal_voltage(host, old_signal_voltage))
  1305. err = -EIO;
  1306. pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
  1307. __func__, err);
  1308. }
  1309. return err;
  1310. }
  1311. /*
  1312. * Activate High Speed, HS200 or HS400ES mode if supported.
  1313. */
  1314. int mmc_select_timing(struct mmc_card *card)
  1315. {
  1316. int err = 0;
  1317. if (!mmc_can_ext_csd(card))
  1318. goto bus_speed;
  1319. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES)
  1320. err = mmc_select_hs400es(card);
  1321. else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
  1322. err = mmc_select_hs200(card);
  1323. else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
  1324. err = mmc_select_hs(card);
  1325. if (err && err != -EBADMSG)
  1326. return err;
  1327. bus_speed:
  1328. /*
  1329. * Set the bus speed to the selected bus timing.
  1330. * If timing is not selected, backward compatible is the default.
  1331. */
  1332. mmc_set_bus_speed(card);
  1333. return 0;
  1334. }
  1335. EXPORT_SYMBOL_GPL(mmc_select_timing);
  1336. /*
  1337. * Execute tuning sequence to seek the proper bus operating
  1338. * conditions for HS200 and HS400, which sends CMD21 to the device.
  1339. */
  1340. int mmc_hs200_tuning(struct mmc_card *card)
  1341. {
  1342. struct mmc_host *host = card->host;
  1343. /*
  1344. * Timing should be adjusted to the HS400 target
  1345. * operation frequency for tuning process
  1346. */
  1347. if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
  1348. host->ios.bus_width == MMC_BUS_WIDTH_8)
  1349. if (host->ops->prepare_hs400_tuning)
  1350. host->ops->prepare_hs400_tuning(host, &host->ios);
  1351. return mmc_execute_tuning(card);
  1352. }
  1353. EXPORT_SYMBOL_GPL(mmc_hs200_tuning);
  1354. /*
  1355. * Handle the detection and initialisation of a card.
  1356. *
  1357. * In the case of a resume, "oldcard" will contain the card
  1358. * we're trying to reinitialise.
  1359. */
  1360. static int mmc_init_card(struct mmc_host *host, u32 ocr,
  1361. struct mmc_card *oldcard)
  1362. {
  1363. struct mmc_card *card;
  1364. int err;
  1365. u32 cid[4];
  1366. u32 rocr;
  1367. WARN_ON(!host->claimed);
  1368. /* Set correct bus mode for MMC before attempting init */
  1369. if (!mmc_host_is_spi(host))
  1370. mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
  1371. /*
  1372. * Since we're changing the OCR value, we seem to
  1373. * need to tell some cards to go back to the idle
  1374. * state. We wait 1ms to give cards time to
  1375. * respond.
  1376. * mmc_go_idle is needed for eMMC that are asleep
  1377. */
  1378. mmc_go_idle(host);
  1379. /* The extra bit indicates that we support high capacity */
  1380. err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
  1381. if (err)
  1382. goto err;
  1383. /*
  1384. * For SPI, enable CRC as appropriate.
  1385. */
  1386. if (mmc_host_is_spi(host)) {
  1387. err = mmc_spi_set_crc(host, use_spi_crc);
  1388. if (err)
  1389. goto err;
  1390. }
  1391. /*
  1392. * Fetch CID from card.
  1393. */
  1394. err = mmc_send_cid(host, cid);
  1395. if (err)
  1396. goto err;
  1397. if (oldcard) {
  1398. if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
  1399. pr_debug("%s: Perhaps the card was replaced\n",
  1400. mmc_hostname(host));
  1401. err = -ENOENT;
  1402. goto err;
  1403. }
  1404. card = oldcard;
  1405. } else {
  1406. /*
  1407. * Allocate card structure.
  1408. */
  1409. card = mmc_alloc_card(host, &mmc_type);
  1410. if (IS_ERR(card)) {
  1411. err = PTR_ERR(card);
  1412. goto err;
  1413. }
  1414. card->ocr = ocr;
  1415. card->type = MMC_TYPE_MMC;
  1416. card->rca = 1;
  1417. memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
  1418. }
  1419. /*
  1420. * Call the optional HC's init_card function to handle quirks.
  1421. */
  1422. if (host->ops->init_card)
  1423. host->ops->init_card(host, card);
  1424. /*
  1425. * For native busses: set card RCA and quit open drain mode.
  1426. */
  1427. if (!mmc_host_is_spi(host)) {
  1428. err = mmc_set_relative_addr(card);
  1429. if (err)
  1430. goto free_card;
  1431. mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
  1432. }
  1433. if (!oldcard) {
  1434. /*
  1435. * Fetch CSD from card.
  1436. */
  1437. err = mmc_send_csd(card, card->raw_csd);
  1438. if (err)
  1439. goto free_card;
  1440. err = mmc_decode_csd(card);
  1441. if (err)
  1442. goto free_card;
  1443. err = mmc_decode_cid(card);
  1444. if (err)
  1445. goto free_card;
  1446. }
  1447. /*
  1448. * handling only for cards supporting DSR and hosts requesting
  1449. * DSR configuration
  1450. */
  1451. if (card->csd.dsr_imp && host->dsr_req)
  1452. mmc_set_dsr(host);
  1453. /*
  1454. * Select card, as all following commands rely on that.
  1455. */
  1456. if (!mmc_host_is_spi(host)) {
  1457. err = mmc_select_card(card);
  1458. if (err)
  1459. goto free_card;
  1460. }
  1461. if (!oldcard) {
  1462. /* Read extended CSD. */
  1463. err = mmc_read_ext_csd(card);
  1464. if (err)
  1465. goto free_card;
  1466. /*
  1467. * If doing byte addressing, check if required to do sector
  1468. * addressing. Handle the case of <2GB cards needing sector
  1469. * addressing. See section 8.1 JEDEC Standard JED84-A441;
  1470. * ocr register has bit 30 set for sector addressing.
  1471. */
  1472. if (rocr & BIT(30))
  1473. mmc_card_set_blockaddr(card);
  1474. /* Erase size depends on CSD and Extended CSD */
  1475. mmc_set_erase_size(card);
  1476. }
  1477. /* Enable ERASE_GRP_DEF. This bit is lost after a reset or power off. */
  1478. if (card->ext_csd.rev >= 3) {
  1479. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1480. EXT_CSD_ERASE_GROUP_DEF, 1,
  1481. card->ext_csd.generic_cmd6_time);
  1482. if (err && err != -EBADMSG)
  1483. goto free_card;
  1484. if (err) {
  1485. err = 0;
  1486. /*
  1487. * Just disable enhanced area off & sz
  1488. * will try to enable ERASE_GROUP_DEF
  1489. * during next time reinit
  1490. */
  1491. card->ext_csd.enhanced_area_offset = -EINVAL;
  1492. card->ext_csd.enhanced_area_size = -EINVAL;
  1493. } else {
  1494. card->ext_csd.erase_group_def = 1;
  1495. /*
  1496. * enable ERASE_GRP_DEF successfully.
  1497. * This will affect the erase size, so
  1498. * here need to reset erase size
  1499. */
  1500. mmc_set_erase_size(card);
  1501. }
  1502. }
  1503. /*
  1504. * Ensure eMMC user default partition is enabled
  1505. */
  1506. if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
  1507. card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
  1508. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
  1509. card->ext_csd.part_config,
  1510. card->ext_csd.part_time);
  1511. if (err && err != -EBADMSG)
  1512. goto free_card;
  1513. }
  1514. /*
  1515. * Enable power_off_notification byte in the ext_csd register
  1516. */
  1517. if (card->ext_csd.rev >= 6) {
  1518. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1519. EXT_CSD_POWER_OFF_NOTIFICATION,
  1520. EXT_CSD_POWER_ON,
  1521. card->ext_csd.generic_cmd6_time);
  1522. if (err && err != -EBADMSG)
  1523. goto free_card;
  1524. /*
  1525. * The err can be -EBADMSG or 0,
  1526. * so check for success and update the flag
  1527. */
  1528. if (!err)
  1529. card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
  1530. }
  1531. /* set erase_arg */
  1532. if (mmc_can_discard(card))
  1533. card->erase_arg = MMC_DISCARD_ARG;
  1534. else if (mmc_can_trim(card))
  1535. card->erase_arg = MMC_TRIM_ARG;
  1536. else
  1537. card->erase_arg = MMC_ERASE_ARG;
  1538. /*
  1539. * Select timing interface
  1540. */
  1541. err = mmc_select_timing(card);
  1542. if (err)
  1543. goto free_card;
  1544. if (mmc_card_hs200(card)) {
  1545. host->doing_init_tune = 1;
  1546. err = mmc_hs200_tuning(card);
  1547. if (!err)
  1548. err = mmc_select_hs400(card);
  1549. host->doing_init_tune = 0;
  1550. if (err)
  1551. goto free_card;
  1552. } else if (!mmc_card_hs400es(card)) {
  1553. /* Select the desired bus width optionally */
  1554. err = mmc_select_bus_width(card);
  1555. if (err > 0 && mmc_card_hs(card)) {
  1556. err = mmc_select_hs_ddr(card);
  1557. if (err)
  1558. goto free_card;
  1559. }
  1560. }
  1561. /*
  1562. * Choose the power class with selected bus interface
  1563. */
  1564. mmc_select_powerclass(card);
  1565. /*
  1566. * Enable HPI feature (if supported)
  1567. */
  1568. if (card->ext_csd.hpi) {
  1569. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1570. EXT_CSD_HPI_MGMT, 1,
  1571. card->ext_csd.generic_cmd6_time);
  1572. if (err && err != -EBADMSG)
  1573. goto free_card;
  1574. if (err) {
  1575. pr_warn("%s: Enabling HPI failed\n",
  1576. mmc_hostname(card->host));
  1577. card->ext_csd.hpi_en = 0;
  1578. err = 0;
  1579. } else {
  1580. card->ext_csd.hpi_en = 1;
  1581. }
  1582. }
  1583. /*
  1584. * If cache size is higher than 0, this indicates the existence of cache
  1585. * and it can be turned on. Note that some eMMCs from Micron has been
  1586. * reported to need ~800 ms timeout, while enabling the cache after
  1587. * sudden power failure tests. Let's extend the timeout to a minimum of
  1588. * DEFAULT_CACHE_EN_TIMEOUT_MS and do it for all cards.
  1589. */
  1590. if (card->ext_csd.cache_size > 0) {
  1591. unsigned int timeout_ms = MIN_CACHE_EN_TIMEOUT_MS;
  1592. timeout_ms = max(card->ext_csd.generic_cmd6_time, timeout_ms);
  1593. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1594. EXT_CSD_CACHE_CTRL, 1, timeout_ms);
  1595. if (err && err != -EBADMSG)
  1596. goto free_card;
  1597. /*
  1598. * Only if no error, cache is turned on successfully.
  1599. */
  1600. if (err) {
  1601. pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
  1602. mmc_hostname(card->host), err);
  1603. card->ext_csd.cache_ctrl = 0;
  1604. err = 0;
  1605. } else {
  1606. card->ext_csd.cache_ctrl = 1;
  1607. }
  1608. }
  1609. /*
  1610. * Enable Command Queue if supported. Note that Packed Commands cannot
  1611. * be used with Command Queue.
  1612. */
  1613. card->ext_csd.cmdq_en = false;
  1614. if (card->ext_csd.cmdq_support && host->caps2 & MMC_CAP2_CQE) {
  1615. err = mmc_cmdq_enable(card);
  1616. if (err && err != -EBADMSG)
  1617. goto free_card;
  1618. if (err) {
  1619. pr_warn("%s: Enabling CMDQ failed\n",
  1620. mmc_hostname(card->host));
  1621. card->ext_csd.cmdq_support = false;
  1622. card->ext_csd.cmdq_depth = 0;
  1623. err = 0;
  1624. }
  1625. }
  1626. /*
  1627. * In some cases (e.g. RPMB or mmc_test), the Command Queue must be
  1628. * disabled for a time, so a flag is needed to indicate to re-enable the
  1629. * Command Queue.
  1630. */
  1631. card->reenable_cmdq = card->ext_csd.cmdq_en;
  1632. if (host->cqe_ops && !host->cqe_enabled) {
  1633. err = host->cqe_ops->cqe_enable(host, card);
  1634. if (!err) {
  1635. host->cqe_enabled = true;
  1636. if (card->ext_csd.cmdq_en) {
  1637. pr_info("%s: Command Queue Engine enabled\n",
  1638. mmc_hostname(host));
  1639. } else {
  1640. host->hsq_enabled = true;
  1641. pr_info("%s: Host Software Queue enabled\n",
  1642. mmc_hostname(host));
  1643. }
  1644. }
  1645. }
  1646. if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
  1647. host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
  1648. pr_err("%s: Host failed to negotiate down from 3.3V\n",
  1649. mmc_hostname(host));
  1650. err = -EINVAL;
  1651. goto free_card;
  1652. }
  1653. if (!oldcard)
  1654. host->card = card;
  1655. return 0;
  1656. free_card:
  1657. if (!oldcard)
  1658. mmc_remove_card(card);
  1659. err:
  1660. return err;
  1661. }
  1662. static int mmc_can_sleep(struct mmc_card *card)
  1663. {
  1664. return (card && card->ext_csd.rev >= 3);
  1665. }
  1666. static int mmc_sleep(struct mmc_host *host)
  1667. {
  1668. struct mmc_command cmd = {};
  1669. struct mmc_card *card = host->card;
  1670. unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
  1671. int err;
  1672. /* Re-tuning can't be done once the card is deselected */
  1673. mmc_retune_hold(host);
  1674. err = mmc_deselect_cards(host);
  1675. if (err)
  1676. goto out_release;
  1677. cmd.opcode = MMC_SLEEP_AWAKE;
  1678. cmd.arg = card->rca << 16;
  1679. cmd.arg |= 1 << 15;
  1680. /*
  1681. * If the max_busy_timeout of the host is specified, validate it against
  1682. * the sleep cmd timeout. A failure means we need to prevent the host
  1683. * from doing hw busy detection, which is done by converting to a R1
  1684. * response instead of a R1B. Note, some hosts requires R1B, which also
  1685. * means they are on their own when it comes to deal with the busy
  1686. * timeout.
  1687. */
  1688. if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
  1689. (timeout_ms > host->max_busy_timeout)) {
  1690. cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
  1691. } else {
  1692. cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
  1693. cmd.busy_timeout = timeout_ms;
  1694. }
  1695. err = mmc_wait_for_cmd(host, &cmd, 0);
  1696. if (err)
  1697. goto out_release;
  1698. /*
  1699. * If the host does not wait while the card signals busy, then we will
  1700. * will have to wait the sleep/awake timeout. Note, we cannot use the
  1701. * SEND_STATUS command to poll the status because that command (and most
  1702. * others) is invalid while the card sleeps.
  1703. */
  1704. if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
  1705. mmc_delay(timeout_ms);
  1706. out_release:
  1707. mmc_retune_release(host);
  1708. return err;
  1709. }
  1710. static int mmc_can_poweroff_notify(const struct mmc_card *card)
  1711. {
  1712. return card &&
  1713. mmc_card_mmc(card) &&
  1714. (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
  1715. }
  1716. static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
  1717. {
  1718. unsigned int timeout = card->ext_csd.generic_cmd6_time;
  1719. int err;
  1720. /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
  1721. if (notify_type == EXT_CSD_POWER_OFF_LONG)
  1722. timeout = card->ext_csd.power_off_longtime;
  1723. err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1724. EXT_CSD_POWER_OFF_NOTIFICATION,
  1725. notify_type, timeout, 0, false, false);
  1726. if (err)
  1727. pr_err("%s: Power Off Notification timed out, %u\n",
  1728. mmc_hostname(card->host), timeout);
  1729. /* Disable the power off notification after the switch operation. */
  1730. card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
  1731. return err;
  1732. }
  1733. /*
  1734. * Host is being removed. Free up the current card.
  1735. */
  1736. static void mmc_remove(struct mmc_host *host)
  1737. {
  1738. mmc_remove_card(host->card);
  1739. host->card = NULL;
  1740. }
  1741. /*
  1742. * Card detection - card is alive.
  1743. */
  1744. static int mmc_alive(struct mmc_host *host)
  1745. {
  1746. return mmc_send_status(host->card, NULL);
  1747. }
  1748. /*
  1749. * Card detection callback from host.
  1750. */
  1751. static void mmc_detect(struct mmc_host *host)
  1752. {
  1753. int err;
  1754. mmc_get_card(host->card, NULL);
  1755. /*
  1756. * Just check if our card has been removed.
  1757. */
  1758. err = _mmc_detect_card_removed(host);
  1759. mmc_put_card(host->card, NULL);
  1760. if (err) {
  1761. mmc_remove(host);
  1762. mmc_claim_host(host);
  1763. mmc_detach_bus(host);
  1764. mmc_power_off(host);
  1765. mmc_release_host(host);
  1766. }
  1767. }
  1768. static bool _mmc_cache_enabled(struct mmc_host *host)
  1769. {
  1770. return host->card->ext_csd.cache_size > 0 &&
  1771. host->card->ext_csd.cache_ctrl & 1;
  1772. }
  1773. static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
  1774. {
  1775. int err = 0;
  1776. unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
  1777. EXT_CSD_POWER_OFF_LONG;
  1778. mmc_claim_host(host);
  1779. if (mmc_card_suspended(host->card))
  1780. goto out;
  1781. err = mmc_flush_cache(host->card);
  1782. if (err)
  1783. goto out;
  1784. if (mmc_can_poweroff_notify(host->card) &&
  1785. ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend ||
  1786. (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND)))
  1787. err = mmc_poweroff_notify(host->card, notify_type);
  1788. else if (mmc_can_sleep(host->card))
  1789. err = mmc_sleep(host);
  1790. else if (!mmc_host_is_spi(host))
  1791. err = mmc_deselect_cards(host);
  1792. if (!err) {
  1793. mmc_power_off(host);
  1794. mmc_card_set_suspended(host->card);
  1795. }
  1796. out:
  1797. mmc_release_host(host);
  1798. return err;
  1799. }
  1800. /*
  1801. * Suspend callback
  1802. */
  1803. static int mmc_suspend(struct mmc_host *host)
  1804. {
  1805. int err;
  1806. err = _mmc_suspend(host, true);
  1807. if (!err) {
  1808. pm_runtime_disable(&host->card->dev);
  1809. pm_runtime_set_suspended(&host->card->dev);
  1810. }
  1811. return err;
  1812. }
  1813. /*
  1814. * This function tries to determine if the same card is still present
  1815. * and, if so, restore all state to it.
  1816. */
  1817. static int _mmc_resume(struct mmc_host *host)
  1818. {
  1819. int err = 0;
  1820. mmc_claim_host(host);
  1821. if (!mmc_card_suspended(host->card))
  1822. goto out;
  1823. mmc_power_up(host, host->card->ocr);
  1824. err = mmc_init_card(host, host->card->ocr, host->card);
  1825. mmc_card_clr_suspended(host->card);
  1826. out:
  1827. mmc_release_host(host);
  1828. return err;
  1829. }
  1830. /*
  1831. * Shutdown callback
  1832. */
  1833. static int mmc_shutdown(struct mmc_host *host)
  1834. {
  1835. int err = 0;
  1836. /*
  1837. * In a specific case for poweroff notify, we need to resume the card
  1838. * before we can shutdown it properly.
  1839. */
  1840. if (mmc_can_poweroff_notify(host->card) &&
  1841. !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
  1842. err = _mmc_resume(host);
  1843. if (!err)
  1844. err = _mmc_suspend(host, false);
  1845. return err;
  1846. }
  1847. /*
  1848. * Callback for resume.
  1849. */
  1850. static int mmc_resume(struct mmc_host *host)
  1851. {
  1852. pm_runtime_enable(&host->card->dev);
  1853. return 0;
  1854. }
  1855. /*
  1856. * Callback for runtime_suspend.
  1857. */
  1858. static int mmc_runtime_suspend(struct mmc_host *host)
  1859. {
  1860. int err;
  1861. if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
  1862. return 0;
  1863. err = _mmc_suspend(host, true);
  1864. if (err)
  1865. pr_err("%s: error %d doing aggressive suspend\n",
  1866. mmc_hostname(host), err);
  1867. return err;
  1868. }
  1869. /*
  1870. * Callback for runtime_resume.
  1871. */
  1872. static int mmc_runtime_resume(struct mmc_host *host)
  1873. {
  1874. int err;
  1875. err = _mmc_resume(host);
  1876. if (err && err != -ENOMEDIUM)
  1877. pr_err("%s: error %d doing runtime resume\n",
  1878. mmc_hostname(host), err);
  1879. return 0;
  1880. }
  1881. static int mmc_can_reset(struct mmc_card *card)
  1882. {
  1883. u8 rst_n_function;
  1884. rst_n_function = card->ext_csd.rst_n_function;
  1885. if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
  1886. return 0;
  1887. return 1;
  1888. }
  1889. static int _mmc_hw_reset(struct mmc_host *host)
  1890. {
  1891. struct mmc_card *card = host->card;
  1892. /*
  1893. * In the case of recovery, we can't expect flushing the cache to work
  1894. * always, but we have a go and ignore errors.
  1895. */
  1896. mmc_flush_cache(host->card);
  1897. if ((host->caps & MMC_CAP_HW_RESET) && host->ops->hw_reset &&
  1898. mmc_can_reset(card)) {
  1899. /* If the card accept RST_n signal, send it. */
  1900. mmc_set_clock(host, host->f_init);
  1901. host->ops->hw_reset(host);
  1902. /* Set initial state and call mmc_set_ios */
  1903. mmc_set_initial_state(host);
  1904. } else {
  1905. /* Do a brute force power cycle */
  1906. mmc_power_cycle(host, card->ocr);
  1907. mmc_pwrseq_reset(host);
  1908. }
  1909. return mmc_init_card(host, card->ocr, card);
  1910. }
  1911. static const struct mmc_bus_ops mmc_ops = {
  1912. .remove = mmc_remove,
  1913. .detect = mmc_detect,
  1914. .suspend = mmc_suspend,
  1915. .resume = mmc_resume,
  1916. .runtime_suspend = mmc_runtime_suspend,
  1917. .runtime_resume = mmc_runtime_resume,
  1918. .alive = mmc_alive,
  1919. .shutdown = mmc_shutdown,
  1920. .hw_reset = _mmc_hw_reset,
  1921. .cache_enabled = _mmc_cache_enabled,
  1922. };
  1923. /*
  1924. * Starting point for MMC card init.
  1925. */
  1926. int mmc_attach_mmc(struct mmc_host *host)
  1927. {
  1928. int err;
  1929. u32 ocr, rocr;
  1930. WARN_ON(!host->claimed);
  1931. /* Set correct bus mode for MMC before attempting attach */
  1932. if (!mmc_host_is_spi(host))
  1933. mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
  1934. err = mmc_send_op_cond(host, 0, &ocr);
  1935. if (err)
  1936. return err;
  1937. mmc_attach_bus(host, &mmc_ops);
  1938. if (host->ocr_avail_mmc)
  1939. host->ocr_avail = host->ocr_avail_mmc;
  1940. /*
  1941. * We need to get OCR a different way for SPI.
  1942. */
  1943. if (mmc_host_is_spi(host)) {
  1944. err = mmc_spi_read_ocr(host, 1, &ocr);
  1945. if (err)
  1946. goto err;
  1947. }
  1948. rocr = mmc_select_voltage(host, ocr);
  1949. /*
  1950. * Can we support the voltage of the card?
  1951. */
  1952. if (!rocr) {
  1953. err = -EINVAL;
  1954. goto err;
  1955. }
  1956. /*
  1957. * Detect and init the card.
  1958. */
  1959. err = mmc_init_card(host, rocr, NULL);
  1960. if (err)
  1961. goto err;
  1962. mmc_release_host(host);
  1963. err = mmc_add_card(host->card);
  1964. if (err)
  1965. goto remove_card;
  1966. mmc_claim_host(host);
  1967. return 0;
  1968. remove_card:
  1969. mmc_remove_card(host->card);
  1970. mmc_claim_host(host);
  1971. host->card = NULL;
  1972. err:
  1973. mmc_detach_bus(host);
  1974. pr_err("%s: error %d whilst initialising MMC card\n",
  1975. mmc_hostname(host), err);
  1976. return err;
  1977. }