mmc.c 43 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693
  1. /*
  2. * linux/drivers/mmc/core/mmc.c
  3. *
  4. * Copyright (C) 2003-2004 Russell King, All Rights Reserved.
  5. * Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
  6. * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation.
  11. */
  12. #include <linux/err.h>
  13. #include <linux/slab.h>
  14. #include <linux/stat.h>
  15. #include <linux/mmc/host.h>
  16. #include <linux/mmc/card.h>
  17. #include <linux/mmc/mmc.h>
  18. #include "core.h"
  19. #include "bus.h"
  20. #include "mmc_ops.h"
  21. #include "sd_ops.h"
  22. static const unsigned int tran_exp[] = {
  23. 10000, 100000, 1000000, 10000000,
  24. 0, 0, 0, 0
  25. };
  26. static const unsigned char tran_mant[] = {
  27. 0, 10, 12, 13, 15, 20, 25, 30,
  28. 35, 40, 45, 50, 55, 60, 70, 80,
  29. };
  30. static const unsigned int tacc_exp[] = {
  31. 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
  32. };
  33. static const unsigned int tacc_mant[] = {
  34. 0, 10, 12, 13, 15, 20, 25, 30,
  35. 35, 40, 45, 50, 55, 60, 70, 80,
  36. };
  37. #define UNSTUFF_BITS(resp,start,size) \
  38. ({ \
  39. const int __size = size; \
  40. const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  41. const int __off = 3 - ((start) / 32); \
  42. const int __shft = (start) & 31; \
  43. u32 __res; \
  44. \
  45. __res = resp[__off] >> __shft; \
  46. if (__size + __shft > 32) \
  47. __res |= resp[__off-1] << ((32 - __shft) % 32); \
  48. __res & __mask; \
  49. })
  50. /*
  51. * Given the decoded CSD structure, decode the raw CID to our CID structure.
  52. */
  53. static int mmc_decode_cid(struct mmc_card *card)
  54. {
  55. u32 *resp = card->raw_cid;
  56. /*
  57. * The selection of the format here is based upon published
  58. * specs from sandisk and from what people have reported.
  59. */
  60. switch (card->csd.mmca_vsn) {
  61. case 0: /* MMC v1.0 - v1.2 */
  62. case 1: /* MMC v1.4 */
  63. card->cid.manfid = UNSTUFF_BITS(resp, 104, 24);
  64. card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
  65. card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
  66. card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
  67. card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
  68. card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
  69. card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
  70. card->cid.prod_name[6] = UNSTUFF_BITS(resp, 48, 8);
  71. card->cid.hwrev = UNSTUFF_BITS(resp, 44, 4);
  72. card->cid.fwrev = UNSTUFF_BITS(resp, 40, 4);
  73. card->cid.serial = UNSTUFF_BITS(resp, 16, 24);
  74. card->cid.month = UNSTUFF_BITS(resp, 12, 4);
  75. card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
  76. break;
  77. case 2: /* MMC v2.0 - v2.2 */
  78. case 3: /* MMC v3.1 - v3.3 */
  79. case 4: /* MMC v4 */
  80. card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
  81. card->cid.oemid = UNSTUFF_BITS(resp, 104, 16);
  82. card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
  83. card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
  84. card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
  85. card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
  86. card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
  87. card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);
  88. card->cid.prv = UNSTUFF_BITS(resp, 48, 8);
  89. card->cid.serial = UNSTUFF_BITS(resp, 16, 32);
  90. card->cid.month = UNSTUFF_BITS(resp, 12, 4);
  91. card->cid.year = UNSTUFF_BITS(resp, 8, 4) + 1997;
  92. break;
  93. default:
  94. pr_err("%s: card has unknown MMCA version %d\n",
  95. mmc_hostname(card->host), card->csd.mmca_vsn);
  96. return -EINVAL;
  97. }
  98. return 0;
  99. }
  100. static void mmc_set_erase_size(struct mmc_card *card)
  101. {
  102. if (card->ext_csd.erase_group_def & 1)
  103. card->erase_size = card->ext_csd.hc_erase_size;
  104. else
  105. card->erase_size = card->csd.erase_size;
  106. mmc_init_erase(card);
  107. }
  108. /*
  109. * Given a 128-bit response, decode to our card CSD structure.
  110. */
  111. static int mmc_decode_csd(struct mmc_card *card)
  112. {
  113. struct mmc_csd *csd = &card->csd;
  114. unsigned int e, m, a, b;
  115. u32 *resp = card->raw_csd;
  116. /*
  117. * We only understand CSD structure v1.1 and v1.2.
  118. * v1.2 has extra information in bits 15, 11 and 10.
  119. * We also support eMMC v4.4 & v4.41.
  120. */
  121. csd->structure = UNSTUFF_BITS(resp, 126, 2);
  122. if (csd->structure == 0) {
  123. pr_err("%s: unrecognised CSD structure version %d\n",
  124. mmc_hostname(card->host), csd->structure);
  125. return -EINVAL;
  126. }
  127. csd->mmca_vsn = UNSTUFF_BITS(resp, 122, 4);
  128. m = UNSTUFF_BITS(resp, 115, 4);
  129. e = UNSTUFF_BITS(resp, 112, 3);
  130. csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
  131. csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
  132. m = UNSTUFF_BITS(resp, 99, 4);
  133. e = UNSTUFF_BITS(resp, 96, 3);
  134. csd->max_dtr = tran_exp[e] * tran_mant[m];
  135. csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
  136. e = UNSTUFF_BITS(resp, 47, 3);
  137. m = UNSTUFF_BITS(resp, 62, 12);
  138. csd->capacity = (1 + m) << (e + 2);
  139. csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
  140. csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
  141. csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
  142. csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
  143. csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
  144. csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
  145. csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
  146. if (csd->write_blkbits >= 9) {
  147. a = UNSTUFF_BITS(resp, 42, 5);
  148. b = UNSTUFF_BITS(resp, 37, 5);
  149. csd->erase_size = (a + 1) * (b + 1);
  150. csd->erase_size <<= csd->write_blkbits - 9;
  151. }
  152. return 0;
  153. }
  154. /*
  155. * Read extended CSD.
  156. */
  157. static int mmc_get_ext_csd(struct mmc_card *card, u8 **new_ext_csd)
  158. {
  159. int err;
  160. u8 *ext_csd;
  161. BUG_ON(!card);
  162. BUG_ON(!new_ext_csd);
  163. *new_ext_csd = NULL;
  164. if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
  165. return 0;
  166. /*
  167. * As the ext_csd is so large and mostly unused, we don't store the
  168. * raw block in mmc_card.
  169. */
  170. ext_csd = kmalloc(512, GFP_KERNEL);
  171. if (!ext_csd) {
  172. pr_err("%s: could not allocate a buffer to "
  173. "receive the ext_csd.\n", mmc_hostname(card->host));
  174. return -ENOMEM;
  175. }
  176. err = mmc_send_ext_csd(card, ext_csd);
  177. if (err) {
  178. kfree(ext_csd);
  179. *new_ext_csd = NULL;
  180. /* If the host or the card can't do the switch,
  181. * fail more gracefully. */
  182. if ((err != -EINVAL)
  183. && (err != -ENOSYS)
  184. && (err != -EFAULT))
  185. return err;
  186. /*
  187. * High capacity cards should have this "magic" size
  188. * stored in their CSD.
  189. */
  190. if (card->csd.capacity == (4096 * 512)) {
  191. pr_err("%s: unable to read EXT_CSD "
  192. "on a possible high capacity card. "
  193. "Card will be ignored.\n",
  194. mmc_hostname(card->host));
  195. } else {
  196. pr_warning("%s: unable to read "
  197. "EXT_CSD, performance might "
  198. "suffer.\n",
  199. mmc_hostname(card->host));
  200. err = 0;
  201. }
  202. } else
  203. *new_ext_csd = ext_csd;
  204. return err;
  205. }
  206. static void mmc_select_card_type(struct mmc_card *card)
  207. {
  208. struct mmc_host *host = card->host;
  209. u8 card_type = card->ext_csd.raw_card_type & EXT_CSD_CARD_TYPE_MASK;
  210. u32 caps = host->caps, caps2 = host->caps2;
  211. unsigned int hs_max_dtr = 0;
  212. if (card_type & EXT_CSD_CARD_TYPE_26)
  213. hs_max_dtr = MMC_HIGH_26_MAX_DTR;
  214. if (caps & MMC_CAP_MMC_HIGHSPEED &&
  215. card_type & EXT_CSD_CARD_TYPE_52)
  216. hs_max_dtr = MMC_HIGH_52_MAX_DTR;
  217. if ((caps & MMC_CAP_1_8V_DDR &&
  218. card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) ||
  219. (caps & MMC_CAP_1_2V_DDR &&
  220. card_type & EXT_CSD_CARD_TYPE_DDR_1_2V))
  221. hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
  222. if ((caps2 & MMC_CAP2_HS200_1_8V_SDR &&
  223. card_type & EXT_CSD_CARD_TYPE_SDR_1_8V) ||
  224. (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
  225. card_type & EXT_CSD_CARD_TYPE_SDR_1_2V))
  226. hs_max_dtr = MMC_HS200_MAX_DTR;
  227. card->ext_csd.hs_max_dtr = hs_max_dtr;
  228. card->ext_csd.card_type = card_type;
  229. }
  230. /*
  231. * Decode extended CSD.
  232. */
  233. static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd)
  234. {
  235. int err = 0, idx;
  236. unsigned int part_size;
  237. u8 hc_erase_grp_sz = 0, hc_wp_grp_sz = 0;
  238. BUG_ON(!card);
  239. if (!ext_csd)
  240. return 0;
  241. /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
  242. card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
  243. if (card->csd.structure == 3) {
  244. if (card->ext_csd.raw_ext_csd_structure > 2) {
  245. pr_err("%s: unrecognised EXT_CSD structure "
  246. "version %d\n", mmc_hostname(card->host),
  247. card->ext_csd.raw_ext_csd_structure);
  248. err = -EINVAL;
  249. goto out;
  250. }
  251. }
  252. card->ext_csd.rev = ext_csd[EXT_CSD_REV];
  253. if (card->ext_csd.rev > 7) {
  254. pr_err("%s: unrecognised EXT_CSD revision %d\n",
  255. mmc_hostname(card->host), card->ext_csd.rev);
  256. err = -EINVAL;
  257. goto out;
  258. }
  259. card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
  260. card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
  261. card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
  262. card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
  263. if (card->ext_csd.rev >= 2) {
  264. card->ext_csd.sectors =
  265. ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
  266. ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
  267. ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
  268. ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
  269. /* Cards with density > 2GiB are sector addressed */
  270. if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
  271. mmc_card_set_blockaddr(card);
  272. }
  273. card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
  274. mmc_select_card_type(card);
  275. card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
  276. card->ext_csd.raw_erase_timeout_mult =
  277. ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
  278. card->ext_csd.raw_hc_erase_grp_size =
  279. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  280. if (card->ext_csd.rev >= 3) {
  281. u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
  282. card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
  283. /* EXT_CSD value is in units of 10ms, but we store in ms */
  284. card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
  285. /* Sleep / awake timeout in 100ns units */
  286. if (sa_shift > 0 && sa_shift <= 0x17)
  287. card->ext_csd.sa_timeout =
  288. 1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
  289. card->ext_csd.erase_group_def =
  290. ext_csd[EXT_CSD_ERASE_GROUP_DEF];
  291. card->ext_csd.hc_erase_timeout = 300 *
  292. ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
  293. card->ext_csd.hc_erase_size =
  294. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
  295. card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
  296. /*
  297. * There are two boot regions of equal size, defined in
  298. * multiples of 128K.
  299. */
  300. if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
  301. for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
  302. part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
  303. mmc_part_add(card, part_size,
  304. EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
  305. "boot%d", idx, true,
  306. MMC_BLK_DATA_AREA_BOOT);
  307. }
  308. }
  309. }
  310. card->ext_csd.raw_hc_erase_gap_size =
  311. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  312. card->ext_csd.raw_sec_trim_mult =
  313. ext_csd[EXT_CSD_SEC_TRIM_MULT];
  314. card->ext_csd.raw_sec_erase_mult =
  315. ext_csd[EXT_CSD_SEC_ERASE_MULT];
  316. card->ext_csd.raw_sec_feature_support =
  317. ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
  318. card->ext_csd.raw_trim_mult =
  319. ext_csd[EXT_CSD_TRIM_MULT];
  320. card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
  321. if (card->ext_csd.rev >= 4) {
  322. /*
  323. * Enhanced area feature support -- check whether the eMMC
  324. * card has the Enhanced area enabled. If so, export enhanced
  325. * area offset and size to user by adding sysfs interface.
  326. */
  327. if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
  328. (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
  329. hc_erase_grp_sz =
  330. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  331. hc_wp_grp_sz =
  332. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  333. card->ext_csd.enhanced_area_en = 1;
  334. /*
  335. * calculate the enhanced data area offset, in bytes
  336. */
  337. card->ext_csd.enhanced_area_offset =
  338. (ext_csd[139] << 24) + (ext_csd[138] << 16) +
  339. (ext_csd[137] << 8) + ext_csd[136];
  340. if (mmc_card_blockaddr(card))
  341. card->ext_csd.enhanced_area_offset <<= 9;
  342. /*
  343. * calculate the enhanced data area size, in kilobytes
  344. */
  345. card->ext_csd.enhanced_area_size =
  346. (ext_csd[142] << 16) + (ext_csd[141] << 8) +
  347. ext_csd[140];
  348. card->ext_csd.enhanced_area_size *=
  349. (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
  350. card->ext_csd.enhanced_area_size <<= 9;
  351. } else {
  352. /*
  353. * If the enhanced area is not enabled, disable these
  354. * device attributes.
  355. */
  356. card->ext_csd.enhanced_area_offset = -EINVAL;
  357. card->ext_csd.enhanced_area_size = -EINVAL;
  358. }
  359. /*
  360. * General purpose partition feature support --
  361. * If ext_csd has the size of general purpose partitions,
  362. * set size, part_cfg, partition name in mmc_part.
  363. */
  364. if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
  365. EXT_CSD_PART_SUPPORT_PART_EN) {
  366. if (card->ext_csd.enhanced_area_en != 1) {
  367. hc_erase_grp_sz =
  368. ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
  369. hc_wp_grp_sz =
  370. ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
  371. card->ext_csd.enhanced_area_en = 1;
  372. }
  373. for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
  374. if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
  375. !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
  376. !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
  377. continue;
  378. part_size =
  379. (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
  380. << 16) +
  381. (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
  382. << 8) +
  383. ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
  384. part_size *= (size_t)(hc_erase_grp_sz *
  385. hc_wp_grp_sz);
  386. mmc_part_add(card, part_size << 19,
  387. EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
  388. "gp%d", idx, false,
  389. MMC_BLK_DATA_AREA_GP);
  390. }
  391. }
  392. card->ext_csd.sec_trim_mult =
  393. ext_csd[EXT_CSD_SEC_TRIM_MULT];
  394. card->ext_csd.sec_erase_mult =
  395. ext_csd[EXT_CSD_SEC_ERASE_MULT];
  396. card->ext_csd.sec_feature_support =
  397. ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
  398. card->ext_csd.trim_timeout = 300 *
  399. ext_csd[EXT_CSD_TRIM_MULT];
  400. /*
  401. * Note that the call to mmc_part_add above defaults to read
  402. * only. If this default assumption is changed, the call must
  403. * take into account the value of boot_locked below.
  404. */
  405. card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
  406. card->ext_csd.boot_ro_lockable = true;
  407. /* Save power class values */
  408. card->ext_csd.raw_pwr_cl_52_195 =
  409. ext_csd[EXT_CSD_PWR_CL_52_195];
  410. card->ext_csd.raw_pwr_cl_26_195 =
  411. ext_csd[EXT_CSD_PWR_CL_26_195];
  412. card->ext_csd.raw_pwr_cl_52_360 =
  413. ext_csd[EXT_CSD_PWR_CL_52_360];
  414. card->ext_csd.raw_pwr_cl_26_360 =
  415. ext_csd[EXT_CSD_PWR_CL_26_360];
  416. card->ext_csd.raw_pwr_cl_200_195 =
  417. ext_csd[EXT_CSD_PWR_CL_200_195];
  418. card->ext_csd.raw_pwr_cl_200_360 =
  419. ext_csd[EXT_CSD_PWR_CL_200_360];
  420. card->ext_csd.raw_pwr_cl_ddr_52_195 =
  421. ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
  422. card->ext_csd.raw_pwr_cl_ddr_52_360 =
  423. ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
  424. }
  425. if (card->ext_csd.rev >= 5) {
  426. /* check whether the eMMC card supports BKOPS */
  427. if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
  428. card->ext_csd.bkops = 1;
  429. card->ext_csd.bkops_en = ext_csd[EXT_CSD_BKOPS_EN];
  430. card->ext_csd.raw_bkops_status =
  431. ext_csd[EXT_CSD_BKOPS_STATUS];
  432. if (!card->ext_csd.bkops_en)
  433. pr_info("%s: BKOPS_EN bit is not set\n",
  434. mmc_hostname(card->host));
  435. }
  436. /* check whether the eMMC card supports HPI */
  437. if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1) {
  438. card->ext_csd.hpi = 1;
  439. if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
  440. card->ext_csd.hpi_cmd = MMC_STOP_TRANSMISSION;
  441. else
  442. card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
  443. /*
  444. * Indicate the maximum timeout to close
  445. * a command interrupted by HPI
  446. */
  447. card->ext_csd.out_of_int_time =
  448. ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
  449. }
  450. card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
  451. card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
  452. /*
  453. * RPMB regions are defined in multiples of 128K.
  454. */
  455. card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
  456. if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
  457. mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
  458. EXT_CSD_PART_CONFIG_ACC_RPMB,
  459. "rpmb", 0, false,
  460. MMC_BLK_DATA_AREA_RPMB);
  461. }
  462. }
  463. card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
  464. if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
  465. card->erased_byte = 0xFF;
  466. else
  467. card->erased_byte = 0x0;
  468. /* eMMC v4.5 or later */
  469. if (card->ext_csd.rev >= 6) {
  470. card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
  471. card->ext_csd.generic_cmd6_time = 10 *
  472. ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
  473. card->ext_csd.power_off_longtime = 10 *
  474. ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
  475. card->ext_csd.cache_size =
  476. ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
  477. ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
  478. ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
  479. ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
  480. if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
  481. card->ext_csd.data_sector_size = 4096;
  482. else
  483. card->ext_csd.data_sector_size = 512;
  484. if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
  485. (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
  486. card->ext_csd.data_tag_unit_size =
  487. ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
  488. (card->ext_csd.data_sector_size);
  489. } else {
  490. card->ext_csd.data_tag_unit_size = 0;
  491. }
  492. card->ext_csd.max_packed_writes =
  493. ext_csd[EXT_CSD_MAX_PACKED_WRITES];
  494. card->ext_csd.max_packed_reads =
  495. ext_csd[EXT_CSD_MAX_PACKED_READS];
  496. } else {
  497. card->ext_csd.data_sector_size = 512;
  498. }
  499. out:
  500. return err;
  501. }
  502. static inline void mmc_free_ext_csd(u8 *ext_csd)
  503. {
  504. kfree(ext_csd);
  505. }
  506. static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
  507. {
  508. u8 *bw_ext_csd;
  509. int err;
  510. if (bus_width == MMC_BUS_WIDTH_1)
  511. return 0;
  512. err = mmc_get_ext_csd(card, &bw_ext_csd);
  513. if (err || bw_ext_csd == NULL) {
  514. err = -EINVAL;
  515. goto out;
  516. }
  517. /* only compare read only fields */
  518. err = !((card->ext_csd.raw_partition_support ==
  519. bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
  520. (card->ext_csd.raw_erased_mem_count ==
  521. bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
  522. (card->ext_csd.rev ==
  523. bw_ext_csd[EXT_CSD_REV]) &&
  524. (card->ext_csd.raw_ext_csd_structure ==
  525. bw_ext_csd[EXT_CSD_STRUCTURE]) &&
  526. (card->ext_csd.raw_card_type ==
  527. bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
  528. (card->ext_csd.raw_s_a_timeout ==
  529. bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
  530. (card->ext_csd.raw_hc_erase_gap_size ==
  531. bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
  532. (card->ext_csd.raw_erase_timeout_mult ==
  533. bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
  534. (card->ext_csd.raw_hc_erase_grp_size ==
  535. bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
  536. (card->ext_csd.raw_sec_trim_mult ==
  537. bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
  538. (card->ext_csd.raw_sec_erase_mult ==
  539. bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
  540. (card->ext_csd.raw_sec_feature_support ==
  541. bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
  542. (card->ext_csd.raw_trim_mult ==
  543. bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
  544. (card->ext_csd.raw_sectors[0] ==
  545. bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
  546. (card->ext_csd.raw_sectors[1] ==
  547. bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
  548. (card->ext_csd.raw_sectors[2] ==
  549. bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
  550. (card->ext_csd.raw_sectors[3] ==
  551. bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
  552. (card->ext_csd.raw_pwr_cl_52_195 ==
  553. bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
  554. (card->ext_csd.raw_pwr_cl_26_195 ==
  555. bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
  556. (card->ext_csd.raw_pwr_cl_52_360 ==
  557. bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
  558. (card->ext_csd.raw_pwr_cl_26_360 ==
  559. bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
  560. (card->ext_csd.raw_pwr_cl_200_195 ==
  561. bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
  562. (card->ext_csd.raw_pwr_cl_200_360 ==
  563. bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
  564. (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
  565. bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
  566. (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
  567. bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]));
  568. if (err)
  569. err = -EINVAL;
  570. out:
  571. mmc_free_ext_csd(bw_ext_csd);
  572. return err;
  573. }
  574. MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
  575. card->raw_cid[2], card->raw_cid[3]);
  576. MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
  577. card->raw_csd[2], card->raw_csd[3]);
  578. MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
  579. MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
  580. MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
  581. MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
  582. MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
  583. MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
  584. MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
  585. MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
  586. MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
  587. MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
  588. MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
  589. card->ext_csd.enhanced_area_offset);
  590. MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
  591. MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
  592. MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
  593. static struct attribute *mmc_std_attrs[] = {
  594. &dev_attr_cid.attr,
  595. &dev_attr_csd.attr,
  596. &dev_attr_date.attr,
  597. &dev_attr_erase_size.attr,
  598. &dev_attr_preferred_erase_size.attr,
  599. &dev_attr_fwrev.attr,
  600. &dev_attr_hwrev.attr,
  601. &dev_attr_manfid.attr,
  602. &dev_attr_name.attr,
  603. &dev_attr_oemid.attr,
  604. &dev_attr_prv.attr,
  605. &dev_attr_serial.attr,
  606. &dev_attr_enhanced_area_offset.attr,
  607. &dev_attr_enhanced_area_size.attr,
  608. &dev_attr_raw_rpmb_size_mult.attr,
  609. &dev_attr_rel_sectors.attr,
  610. NULL,
  611. };
  612. static struct attribute_group mmc_std_attr_group = {
  613. .attrs = mmc_std_attrs,
  614. };
  615. static const struct attribute_group *mmc_attr_groups[] = {
  616. &mmc_std_attr_group,
  617. NULL,
  618. };
  619. static struct device_type mmc_type = {
  620. .groups = mmc_attr_groups,
  621. };
  622. /*
  623. * Select the PowerClass for the current bus width
  624. * If power class is defined for 4/8 bit bus in the
  625. * extended CSD register, select it by executing the
  626. * mmc_switch command.
  627. */
  628. static int mmc_select_powerclass(struct mmc_card *card,
  629. unsigned int bus_width)
  630. {
  631. int err = 0;
  632. unsigned int pwrclass_val = 0;
  633. struct mmc_host *host;
  634. BUG_ON(!card);
  635. host = card->host;
  636. BUG_ON(!host);
  637. /* Power class selection is supported for versions >= 4.0 */
  638. if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
  639. return 0;
  640. /* Power class values are defined only for 4/8 bit bus */
  641. if (bus_width == EXT_CSD_BUS_WIDTH_1)
  642. return 0;
  643. switch (1 << host->ios.vdd) {
  644. case MMC_VDD_165_195:
  645. if (host->ios.clock <= 26000000)
  646. pwrclass_val = card->ext_csd.raw_pwr_cl_26_195;
  647. else if (host->ios.clock <= 52000000)
  648. pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
  649. card->ext_csd.raw_pwr_cl_52_195 :
  650. card->ext_csd.raw_pwr_cl_ddr_52_195;
  651. else if (host->ios.clock <= 200000000)
  652. pwrclass_val = card->ext_csd.raw_pwr_cl_200_195;
  653. break;
  654. case MMC_VDD_27_28:
  655. case MMC_VDD_28_29:
  656. case MMC_VDD_29_30:
  657. case MMC_VDD_30_31:
  658. case MMC_VDD_31_32:
  659. case MMC_VDD_32_33:
  660. case MMC_VDD_33_34:
  661. case MMC_VDD_34_35:
  662. case MMC_VDD_35_36:
  663. if (host->ios.clock <= 26000000)
  664. pwrclass_val = card->ext_csd.raw_pwr_cl_26_360;
  665. else if (host->ios.clock <= 52000000)
  666. pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
  667. card->ext_csd.raw_pwr_cl_52_360 :
  668. card->ext_csd.raw_pwr_cl_ddr_52_360;
  669. else if (host->ios.clock <= 200000000)
  670. pwrclass_val = card->ext_csd.raw_pwr_cl_200_360;
  671. break;
  672. default:
  673. pr_warning("%s: Voltage range not supported "
  674. "for power class.\n", mmc_hostname(host));
  675. return -EINVAL;
  676. }
  677. if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
  678. pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
  679. EXT_CSD_PWR_CL_8BIT_SHIFT;
  680. else
  681. pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
  682. EXT_CSD_PWR_CL_4BIT_SHIFT;
  683. /* If the power class is different from the default value */
  684. if (pwrclass_val > 0) {
  685. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  686. EXT_CSD_POWER_CLASS,
  687. pwrclass_val,
  688. card->ext_csd.generic_cmd6_time);
  689. }
  690. return err;
  691. }
  692. /*
  693. * Selects the desired buswidth and switch to the HS200 mode
  694. * if bus width set without error
  695. */
  696. static int mmc_select_hs200(struct mmc_card *card)
  697. {
  698. int idx, err = -EINVAL;
  699. struct mmc_host *host;
  700. static unsigned ext_csd_bits[] = {
  701. EXT_CSD_BUS_WIDTH_4,
  702. EXT_CSD_BUS_WIDTH_8,
  703. };
  704. static unsigned bus_widths[] = {
  705. MMC_BUS_WIDTH_4,
  706. MMC_BUS_WIDTH_8,
  707. };
  708. BUG_ON(!card);
  709. host = card->host;
  710. if (card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_2V &&
  711. host->caps2 & MMC_CAP2_HS200_1_2V_SDR)
  712. err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
  713. if (err && card->ext_csd.card_type & EXT_CSD_CARD_TYPE_SDR_1_8V &&
  714. host->caps2 & MMC_CAP2_HS200_1_8V_SDR)
  715. err = __mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
  716. /* If fails try again during next card power cycle */
  717. if (err)
  718. goto err;
  719. idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 1 : 0;
  720. /*
  721. * Unlike SD, MMC cards dont have a configuration register to notify
  722. * supported bus width. So bus test command should be run to identify
  723. * the supported bus width or compare the ext csd values of current
  724. * bus width and ext csd values of 1 bit mode read earlier.
  725. */
  726. for (; idx >= 0; idx--) {
  727. /*
  728. * Host is capable of 8bit transfer, then switch
  729. * the device to work in 8bit transfer mode. If the
  730. * mmc switch command returns error then switch to
  731. * 4bit transfer mode. On success set the corresponding
  732. * bus width on the host.
  733. */
  734. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  735. EXT_CSD_BUS_WIDTH,
  736. ext_csd_bits[idx],
  737. card->ext_csd.generic_cmd6_time);
  738. if (err)
  739. continue;
  740. mmc_set_bus_width(card->host, bus_widths[idx]);
  741. if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
  742. err = mmc_compare_ext_csds(card, bus_widths[idx]);
  743. else
  744. err = mmc_bus_test(card, bus_widths[idx]);
  745. if (!err)
  746. break;
  747. }
  748. /* switch to HS200 mode if bus width set successfully */
  749. if (!err)
  750. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  751. EXT_CSD_HS_TIMING, 2, 0);
  752. err:
  753. return err;
  754. }
  755. /*
  756. * Handle the detection and initialisation of a card.
  757. *
  758. * In the case of a resume, "oldcard" will contain the card
  759. * we're trying to reinitialise.
  760. */
  761. static int mmc_init_card(struct mmc_host *host, u32 ocr,
  762. struct mmc_card *oldcard)
  763. {
  764. struct mmc_card *card;
  765. int err, ddr = 0;
  766. u32 cid[4];
  767. unsigned int max_dtr;
  768. u32 rocr;
  769. u8 *ext_csd = NULL;
  770. BUG_ON(!host);
  771. WARN_ON(!host->claimed);
  772. /* Set correct bus mode for MMC before attempting init */
  773. if (!mmc_host_is_spi(host))
  774. mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
  775. /*
  776. * Since we're changing the OCR value, we seem to
  777. * need to tell some cards to go back to the idle
  778. * state. We wait 1ms to give cards time to
  779. * respond.
  780. * mmc_go_idle is needed for eMMC that are asleep
  781. */
  782. mmc_go_idle(host);
  783. /* The extra bit indicates that we support high capacity */
  784. err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
  785. if (err)
  786. goto err;
  787. /*
  788. * For SPI, enable CRC as appropriate.
  789. */
  790. if (mmc_host_is_spi(host)) {
  791. err = mmc_spi_set_crc(host, use_spi_crc);
  792. if (err)
  793. goto err;
  794. }
  795. /*
  796. * Fetch CID from card.
  797. */
  798. if (mmc_host_is_spi(host))
  799. err = mmc_send_cid(host, cid);
  800. else
  801. err = mmc_all_send_cid(host, cid);
  802. if (err)
  803. goto err;
  804. if (oldcard) {
  805. if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
  806. err = -ENOENT;
  807. goto err;
  808. }
  809. card = oldcard;
  810. } else {
  811. /*
  812. * Allocate card structure.
  813. */
  814. card = mmc_alloc_card(host, &mmc_type);
  815. if (IS_ERR(card)) {
  816. err = PTR_ERR(card);
  817. goto err;
  818. }
  819. card->type = MMC_TYPE_MMC;
  820. card->rca = 1;
  821. memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
  822. }
  823. /*
  824. * For native busses: set card RCA and quit open drain mode.
  825. */
  826. if (!mmc_host_is_spi(host)) {
  827. err = mmc_set_relative_addr(card);
  828. if (err)
  829. goto free_card;
  830. mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
  831. }
  832. if (!oldcard) {
  833. /*
  834. * Fetch CSD from card.
  835. */
  836. err = mmc_send_csd(card, card->raw_csd);
  837. if (err)
  838. goto free_card;
  839. err = mmc_decode_csd(card);
  840. if (err)
  841. goto free_card;
  842. err = mmc_decode_cid(card);
  843. if (err)
  844. goto free_card;
  845. }
  846. /*
  847. * Select card, as all following commands rely on that.
  848. */
  849. if (!mmc_host_is_spi(host)) {
  850. err = mmc_select_card(card);
  851. if (err)
  852. goto free_card;
  853. }
  854. if (!oldcard) {
  855. /*
  856. * Fetch and process extended CSD.
  857. */
  858. err = mmc_get_ext_csd(card, &ext_csd);
  859. if (err)
  860. goto free_card;
  861. err = mmc_read_ext_csd(card, ext_csd);
  862. if (err)
  863. goto free_card;
  864. /* If doing byte addressing, check if required to do sector
  865. * addressing. Handle the case of <2GB cards needing sector
  866. * addressing. See section 8.1 JEDEC Standard JED84-A441;
  867. * ocr register has bit 30 set for sector addressing.
  868. */
  869. if (!(mmc_card_blockaddr(card)) && (rocr & (1<<30)))
  870. mmc_card_set_blockaddr(card);
  871. /* Erase size depends on CSD and Extended CSD */
  872. mmc_set_erase_size(card);
  873. }
  874. /*
  875. * If enhanced_area_en is TRUE, host needs to enable ERASE_GRP_DEF
  876. * bit. This bit will be lost every time after a reset or power off.
  877. */
  878. if (card->ext_csd.enhanced_area_en ||
  879. (card->ext_csd.rev >= 3 && (host->caps2 & MMC_CAP2_HC_ERASE_SZ))) {
  880. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  881. EXT_CSD_ERASE_GROUP_DEF, 1,
  882. card->ext_csd.generic_cmd6_time);
  883. if (err && err != -EBADMSG)
  884. goto free_card;
  885. if (err) {
  886. err = 0;
  887. /*
  888. * Just disable enhanced area off & sz
  889. * will try to enable ERASE_GROUP_DEF
  890. * during next time reinit
  891. */
  892. card->ext_csd.enhanced_area_offset = -EINVAL;
  893. card->ext_csd.enhanced_area_size = -EINVAL;
  894. } else {
  895. card->ext_csd.erase_group_def = 1;
  896. /*
  897. * enable ERASE_GRP_DEF successfully.
  898. * This will affect the erase size, so
  899. * here need to reset erase size
  900. */
  901. mmc_set_erase_size(card);
  902. }
  903. }
  904. /*
  905. * Ensure eMMC user default partition is enabled
  906. */
  907. if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
  908. card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
  909. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
  910. card->ext_csd.part_config,
  911. card->ext_csd.part_time);
  912. if (err && err != -EBADMSG)
  913. goto free_card;
  914. }
  915. /*
  916. * If the host supports the power_off_notify capability then
  917. * set the notification byte in the ext_csd register of device
  918. */
  919. if ((host->caps2 & MMC_CAP2_POWEROFF_NOTIFY) &&
  920. (card->ext_csd.rev >= 6)) {
  921. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  922. EXT_CSD_POWER_OFF_NOTIFICATION,
  923. EXT_CSD_POWER_ON,
  924. card->ext_csd.generic_cmd6_time);
  925. if (err && err != -EBADMSG)
  926. goto free_card;
  927. /*
  928. * The err can be -EBADMSG or 0,
  929. * so check for success and update the flag
  930. */
  931. if (!err)
  932. card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
  933. }
  934. /*
  935. * Activate high speed (if supported)
  936. */
  937. if (card->ext_csd.hs_max_dtr != 0) {
  938. err = 0;
  939. if (card->ext_csd.hs_max_dtr > 52000000 &&
  940. host->caps2 & MMC_CAP2_HS200)
  941. err = mmc_select_hs200(card);
  942. else if (host->caps & MMC_CAP_MMC_HIGHSPEED)
  943. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  944. EXT_CSD_HS_TIMING, 1,
  945. card->ext_csd.generic_cmd6_time);
  946. if (err && err != -EBADMSG)
  947. goto free_card;
  948. if (err) {
  949. pr_warning("%s: switch to highspeed failed\n",
  950. mmc_hostname(card->host));
  951. err = 0;
  952. } else {
  953. if (card->ext_csd.hs_max_dtr > 52000000 &&
  954. host->caps2 & MMC_CAP2_HS200) {
  955. mmc_card_set_hs200(card);
  956. mmc_set_timing(card->host,
  957. MMC_TIMING_MMC_HS200);
  958. } else {
  959. mmc_card_set_highspeed(card);
  960. mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
  961. }
  962. }
  963. }
  964. /*
  965. * Compute bus speed.
  966. */
  967. max_dtr = (unsigned int)-1;
  968. if (mmc_card_highspeed(card) || mmc_card_hs200(card)) {
  969. if (max_dtr > card->ext_csd.hs_max_dtr)
  970. max_dtr = card->ext_csd.hs_max_dtr;
  971. if (mmc_card_highspeed(card) && (max_dtr > 52000000))
  972. max_dtr = 52000000;
  973. } else if (max_dtr > card->csd.max_dtr) {
  974. max_dtr = card->csd.max_dtr;
  975. }
  976. mmc_set_clock(host, max_dtr);
  977. /*
  978. * Indicate DDR mode (if supported).
  979. */
  980. if (mmc_card_highspeed(card)) {
  981. if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_8V)
  982. && ((host->caps & (MMC_CAP_1_8V_DDR |
  983. MMC_CAP_UHS_DDR50))
  984. == (MMC_CAP_1_8V_DDR | MMC_CAP_UHS_DDR50)))
  985. ddr = MMC_1_8V_DDR_MODE;
  986. else if ((card->ext_csd.card_type & EXT_CSD_CARD_TYPE_DDR_1_2V)
  987. && ((host->caps & (MMC_CAP_1_2V_DDR |
  988. MMC_CAP_UHS_DDR50))
  989. == (MMC_CAP_1_2V_DDR | MMC_CAP_UHS_DDR50)))
  990. ddr = MMC_1_2V_DDR_MODE;
  991. }
  992. /*
  993. * Indicate HS200 SDR mode (if supported).
  994. */
  995. if (mmc_card_hs200(card)) {
  996. u32 ext_csd_bits;
  997. u32 bus_width = card->host->ios.bus_width;
  998. /*
  999. * For devices supporting HS200 mode, the bus width has
  1000. * to be set before executing the tuning function. If
  1001. * set before tuning, then device will respond with CRC
  1002. * errors for responses on CMD line. So for HS200 the
  1003. * sequence will be
  1004. * 1. set bus width 4bit / 8 bit (1 bit not supported)
  1005. * 2. switch to HS200 mode
  1006. * 3. set the clock to > 52Mhz <=200MHz and
  1007. * 4. execute tuning for HS200
  1008. */
  1009. if ((host->caps2 & MMC_CAP2_HS200) &&
  1010. card->host->ops->execute_tuning) {
  1011. mmc_host_clk_hold(card->host);
  1012. err = card->host->ops->execute_tuning(card->host,
  1013. MMC_SEND_TUNING_BLOCK_HS200);
  1014. mmc_host_clk_release(card->host);
  1015. }
  1016. if (err) {
  1017. pr_warning("%s: tuning execution failed\n",
  1018. mmc_hostname(card->host));
  1019. goto err;
  1020. }
  1021. ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
  1022. EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
  1023. err = mmc_select_powerclass(card, ext_csd_bits);
  1024. if (err)
  1025. pr_warning("%s: power class selection to bus width %d"
  1026. " failed\n", mmc_hostname(card->host),
  1027. 1 << bus_width);
  1028. }
  1029. /*
  1030. * Activate wide bus and DDR (if supported).
  1031. */
  1032. if (!mmc_card_hs200(card) &&
  1033. (card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
  1034. (host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA))) {
  1035. static unsigned ext_csd_bits[][2] = {
  1036. { EXT_CSD_BUS_WIDTH_8, EXT_CSD_DDR_BUS_WIDTH_8 },
  1037. { EXT_CSD_BUS_WIDTH_4, EXT_CSD_DDR_BUS_WIDTH_4 },
  1038. { EXT_CSD_BUS_WIDTH_1, EXT_CSD_BUS_WIDTH_1 },
  1039. };
  1040. static unsigned bus_widths[] = {
  1041. MMC_BUS_WIDTH_8,
  1042. MMC_BUS_WIDTH_4,
  1043. MMC_BUS_WIDTH_1
  1044. };
  1045. unsigned idx, bus_width = 0;
  1046. if (host->caps & MMC_CAP_8_BIT_DATA)
  1047. idx = 0;
  1048. else
  1049. idx = 1;
  1050. for (; idx < ARRAY_SIZE(bus_widths); idx++) {
  1051. bus_width = bus_widths[idx];
  1052. if (bus_width == MMC_BUS_WIDTH_1)
  1053. ddr = 0; /* no DDR for 1-bit width */
  1054. err = mmc_select_powerclass(card, ext_csd_bits[idx][0]);
  1055. if (err)
  1056. pr_warning("%s: power class selection to "
  1057. "bus width %d failed\n",
  1058. mmc_hostname(card->host),
  1059. 1 << bus_width);
  1060. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1061. EXT_CSD_BUS_WIDTH,
  1062. ext_csd_bits[idx][0],
  1063. card->ext_csd.generic_cmd6_time);
  1064. if (!err) {
  1065. mmc_set_bus_width(card->host, bus_width);
  1066. /*
  1067. * If controller can't handle bus width test,
  1068. * compare ext_csd previously read in 1 bit mode
  1069. * against ext_csd at new bus width
  1070. */
  1071. if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
  1072. err = mmc_compare_ext_csds(card,
  1073. bus_width);
  1074. else
  1075. err = mmc_bus_test(card, bus_width);
  1076. if (!err)
  1077. break;
  1078. }
  1079. }
  1080. if (!err && ddr) {
  1081. err = mmc_select_powerclass(card, ext_csd_bits[idx][1]);
  1082. if (err)
  1083. pr_warning("%s: power class selection to "
  1084. "bus width %d ddr %d failed\n",
  1085. mmc_hostname(card->host),
  1086. 1 << bus_width, ddr);
  1087. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1088. EXT_CSD_BUS_WIDTH,
  1089. ext_csd_bits[idx][1],
  1090. card->ext_csd.generic_cmd6_time);
  1091. }
  1092. if (err) {
  1093. pr_warning("%s: switch to bus width %d ddr %d "
  1094. "failed\n", mmc_hostname(card->host),
  1095. 1 << bus_width, ddr);
  1096. goto free_card;
  1097. } else if (ddr) {
  1098. /*
  1099. * eMMC cards can support 3.3V to 1.2V i/o (vccq)
  1100. * signaling.
  1101. *
  1102. * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
  1103. *
  1104. * 1.8V vccq at 3.3V core voltage (vcc) is not required
  1105. * in the JEDEC spec for DDR.
  1106. *
  1107. * Do not force change in vccq since we are obviously
  1108. * working and no change to vccq is needed.
  1109. *
  1110. * WARNING: eMMC rules are NOT the same as SD DDR
  1111. */
  1112. if (ddr == MMC_1_2V_DDR_MODE) {
  1113. err = __mmc_set_signal_voltage(host,
  1114. MMC_SIGNAL_VOLTAGE_120);
  1115. if (err)
  1116. goto err;
  1117. }
  1118. mmc_card_set_ddr_mode(card);
  1119. mmc_set_timing(card->host, MMC_TIMING_UHS_DDR50);
  1120. mmc_set_bus_width(card->host, bus_width);
  1121. }
  1122. }
  1123. /*
  1124. * Enable HPI feature (if supported)
  1125. */
  1126. if (card->ext_csd.hpi) {
  1127. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1128. EXT_CSD_HPI_MGMT, 1,
  1129. card->ext_csd.generic_cmd6_time);
  1130. if (err && err != -EBADMSG)
  1131. goto free_card;
  1132. if (err) {
  1133. pr_warning("%s: Enabling HPI failed\n",
  1134. mmc_hostname(card->host));
  1135. err = 0;
  1136. } else
  1137. card->ext_csd.hpi_en = 1;
  1138. }
  1139. /*
  1140. * If cache size is higher than 0, this indicates
  1141. * the existence of cache and it can be turned on.
  1142. */
  1143. if ((host->caps2 & MMC_CAP2_CACHE_CTRL) &&
  1144. card->ext_csd.cache_size > 0) {
  1145. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1146. EXT_CSD_CACHE_CTRL, 1,
  1147. card->ext_csd.generic_cmd6_time);
  1148. if (err && err != -EBADMSG)
  1149. goto free_card;
  1150. /*
  1151. * Only if no error, cache is turned on successfully.
  1152. */
  1153. if (err) {
  1154. pr_warning("%s: Cache is supported, "
  1155. "but failed to turn on (%d)\n",
  1156. mmc_hostname(card->host), err);
  1157. card->ext_csd.cache_ctrl = 0;
  1158. err = 0;
  1159. } else {
  1160. card->ext_csd.cache_ctrl = 1;
  1161. }
  1162. }
  1163. /*
  1164. * The mandatory minimum values are defined for packed command.
  1165. * read: 5, write: 3
  1166. */
  1167. if (card->ext_csd.max_packed_writes >= 3 &&
  1168. card->ext_csd.max_packed_reads >= 5 &&
  1169. host->caps2 & MMC_CAP2_PACKED_CMD) {
  1170. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1171. EXT_CSD_EXP_EVENTS_CTRL,
  1172. EXT_CSD_PACKED_EVENT_EN,
  1173. card->ext_csd.generic_cmd6_time);
  1174. if (err && err != -EBADMSG)
  1175. goto free_card;
  1176. if (err) {
  1177. pr_warn("%s: Enabling packed event failed\n",
  1178. mmc_hostname(card->host));
  1179. card->ext_csd.packed_event_en = 0;
  1180. err = 0;
  1181. } else {
  1182. card->ext_csd.packed_event_en = 1;
  1183. }
  1184. }
  1185. if (!oldcard)
  1186. host->card = card;
  1187. mmc_free_ext_csd(ext_csd);
  1188. return 0;
  1189. free_card:
  1190. if (!oldcard)
  1191. mmc_remove_card(card);
  1192. err:
  1193. mmc_free_ext_csd(ext_csd);
  1194. return err;
  1195. }
  1196. static int mmc_can_sleep(struct mmc_card *card)
  1197. {
  1198. return (card && card->ext_csd.rev >= 3);
  1199. }
  1200. static int mmc_sleep(struct mmc_host *host)
  1201. {
  1202. struct mmc_command cmd = {0};
  1203. struct mmc_card *card = host->card;
  1204. int err;
  1205. if (host->caps2 & MMC_CAP2_NO_SLEEP_CMD)
  1206. return 0;
  1207. err = mmc_deselect_cards(host);
  1208. if (err)
  1209. return err;
  1210. cmd.opcode = MMC_SLEEP_AWAKE;
  1211. cmd.arg = card->rca << 16;
  1212. cmd.arg |= 1 << 15;
  1213. cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
  1214. err = mmc_wait_for_cmd(host, &cmd, 0);
  1215. if (err)
  1216. return err;
  1217. /*
  1218. * If the host does not wait while the card signals busy, then we will
  1219. * will have to wait the sleep/awake timeout. Note, we cannot use the
  1220. * SEND_STATUS command to poll the status because that command (and most
  1221. * others) is invalid while the card sleeps.
  1222. */
  1223. if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
  1224. mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000));
  1225. return err;
  1226. }
  1227. static int mmc_can_poweroff_notify(const struct mmc_card *card)
  1228. {
  1229. return card &&
  1230. mmc_card_mmc(card) &&
  1231. (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
  1232. }
  1233. static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
  1234. {
  1235. unsigned int timeout = card->ext_csd.generic_cmd6_time;
  1236. int err;
  1237. /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
  1238. if (notify_type == EXT_CSD_POWER_OFF_LONG)
  1239. timeout = card->ext_csd.power_off_longtime;
  1240. err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
  1241. EXT_CSD_POWER_OFF_NOTIFICATION,
  1242. notify_type, timeout);
  1243. if (err)
  1244. pr_err("%s: Power Off Notification timed out, %u\n",
  1245. mmc_hostname(card->host), timeout);
  1246. /* Disable the power off notification after the switch operation. */
  1247. card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
  1248. return err;
  1249. }
  1250. /*
  1251. * Host is being removed. Free up the current card.
  1252. */
  1253. static void mmc_remove(struct mmc_host *host)
  1254. {
  1255. BUG_ON(!host);
  1256. BUG_ON(!host->card);
  1257. mmc_remove_card(host->card);
  1258. host->card = NULL;
  1259. }
  1260. /*
  1261. * Card detection - card is alive.
  1262. */
  1263. static int mmc_alive(struct mmc_host *host)
  1264. {
  1265. return mmc_send_status(host->card, NULL);
  1266. }
  1267. /*
  1268. * Card detection callback from host.
  1269. */
  1270. static void mmc_detect(struct mmc_host *host)
  1271. {
  1272. int err;
  1273. BUG_ON(!host);
  1274. BUG_ON(!host->card);
  1275. mmc_get_card(host->card);
  1276. /*
  1277. * Just check if our card has been removed.
  1278. */
  1279. err = _mmc_detect_card_removed(host);
  1280. mmc_put_card(host->card);
  1281. if (err) {
  1282. mmc_remove(host);
  1283. mmc_claim_host(host);
  1284. mmc_detach_bus(host);
  1285. mmc_power_off(host);
  1286. mmc_release_host(host);
  1287. }
  1288. }
  1289. /*
  1290. * Suspend callback from host.
  1291. */
  1292. static int mmc_suspend(struct mmc_host *host)
  1293. {
  1294. int err = 0;
  1295. BUG_ON(!host);
  1296. BUG_ON(!host->card);
  1297. mmc_claim_host(host);
  1298. if (mmc_card_doing_bkops(host->card)) {
  1299. err = mmc_stop_bkops(host->card);
  1300. if (err)
  1301. goto out;
  1302. }
  1303. err = mmc_cache_ctrl(host, 0);
  1304. if (err)
  1305. goto out;
  1306. if (mmc_can_poweroff_notify(host->card))
  1307. err = mmc_poweroff_notify(host->card, EXT_CSD_POWER_OFF_SHORT);
  1308. else if (mmc_can_sleep(host->card))
  1309. err = mmc_sleep(host);
  1310. else if (!mmc_host_is_spi(host))
  1311. err = mmc_deselect_cards(host);
  1312. host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
  1313. out:
  1314. mmc_release_host(host);
  1315. return err;
  1316. }
  1317. /*
  1318. * Resume callback from host.
  1319. *
  1320. * This function tries to determine if the same card is still present
  1321. * and, if so, restore all state to it.
  1322. */
  1323. static int mmc_resume(struct mmc_host *host)
  1324. {
  1325. int err;
  1326. BUG_ON(!host);
  1327. BUG_ON(!host->card);
  1328. mmc_claim_host(host);
  1329. err = mmc_init_card(host, host->ocr, host->card);
  1330. mmc_release_host(host);
  1331. return err;
  1332. }
  1333. /*
  1334. * Callback for runtime_suspend.
  1335. */
  1336. static int mmc_runtime_suspend(struct mmc_host *host)
  1337. {
  1338. int err;
  1339. if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
  1340. return 0;
  1341. mmc_claim_host(host);
  1342. err = mmc_suspend(host);
  1343. if (err) {
  1344. pr_err("%s: error %d doing aggessive suspend\n",
  1345. mmc_hostname(host), err);
  1346. goto out;
  1347. }
  1348. mmc_power_off(host);
  1349. out:
  1350. mmc_release_host(host);
  1351. return err;
  1352. }
  1353. /*
  1354. * Callback for runtime_resume.
  1355. */
  1356. static int mmc_runtime_resume(struct mmc_host *host)
  1357. {
  1358. int err;
  1359. if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
  1360. return 0;
  1361. mmc_claim_host(host);
  1362. mmc_power_up(host);
  1363. err = mmc_resume(host);
  1364. if (err)
  1365. pr_err("%s: error %d doing aggessive resume\n",
  1366. mmc_hostname(host), err);
  1367. mmc_release_host(host);
  1368. return 0;
  1369. }
  1370. static int mmc_power_restore(struct mmc_host *host)
  1371. {
  1372. int ret;
  1373. host->card->state &= ~(MMC_STATE_HIGHSPEED | MMC_STATE_HIGHSPEED_200);
  1374. mmc_claim_host(host);
  1375. ret = mmc_init_card(host, host->ocr, host->card);
  1376. mmc_release_host(host);
  1377. return ret;
  1378. }
  1379. static const struct mmc_bus_ops mmc_ops = {
  1380. .remove = mmc_remove,
  1381. .detect = mmc_detect,
  1382. .suspend = NULL,
  1383. .resume = NULL,
  1384. .power_restore = mmc_power_restore,
  1385. .alive = mmc_alive,
  1386. };
  1387. static const struct mmc_bus_ops mmc_ops_unsafe = {
  1388. .remove = mmc_remove,
  1389. .detect = mmc_detect,
  1390. .suspend = mmc_suspend,
  1391. .resume = mmc_resume,
  1392. .runtime_suspend = mmc_runtime_suspend,
  1393. .runtime_resume = mmc_runtime_resume,
  1394. .power_restore = mmc_power_restore,
  1395. .alive = mmc_alive,
  1396. };
  1397. static void mmc_attach_bus_ops(struct mmc_host *host)
  1398. {
  1399. const struct mmc_bus_ops *bus_ops;
  1400. if (!mmc_card_is_removable(host))
  1401. bus_ops = &mmc_ops_unsafe;
  1402. else
  1403. bus_ops = &mmc_ops;
  1404. mmc_attach_bus(host, bus_ops);
  1405. }
  1406. /*
  1407. * Starting point for MMC card init.
  1408. */
  1409. int mmc_attach_mmc(struct mmc_host *host)
  1410. {
  1411. int err;
  1412. u32 ocr;
  1413. BUG_ON(!host);
  1414. WARN_ON(!host->claimed);
  1415. /* Set correct bus mode for MMC before attempting attach */
  1416. if (!mmc_host_is_spi(host))
  1417. mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
  1418. err = mmc_send_op_cond(host, 0, &ocr);
  1419. if (err)
  1420. return err;
  1421. mmc_attach_bus_ops(host);
  1422. if (host->ocr_avail_mmc)
  1423. host->ocr_avail = host->ocr_avail_mmc;
  1424. /*
  1425. * We need to get OCR a different way for SPI.
  1426. */
  1427. if (mmc_host_is_spi(host)) {
  1428. err = mmc_spi_read_ocr(host, 1, &ocr);
  1429. if (err)
  1430. goto err;
  1431. }
  1432. /*
  1433. * Sanity check the voltages that the card claims to
  1434. * support.
  1435. */
  1436. if (ocr & 0x7F) {
  1437. pr_warning("%s: card claims to support voltages "
  1438. "below the defined range. These will be ignored.\n",
  1439. mmc_hostname(host));
  1440. ocr &= ~0x7F;
  1441. }
  1442. host->ocr = mmc_select_voltage(host, ocr);
  1443. /*
  1444. * Can we support the voltage of the card?
  1445. */
  1446. if (!host->ocr) {
  1447. err = -EINVAL;
  1448. goto err;
  1449. }
  1450. /*
  1451. * Detect and init the card.
  1452. */
  1453. err = mmc_init_card(host, host->ocr, NULL);
  1454. if (err)
  1455. goto err;
  1456. mmc_release_host(host);
  1457. err = mmc_add_card(host->card);
  1458. mmc_claim_host(host);
  1459. if (err)
  1460. goto remove_card;
  1461. return 0;
  1462. remove_card:
  1463. mmc_release_host(host);
  1464. mmc_remove_card(host->card);
  1465. mmc_claim_host(host);
  1466. host->card = NULL;
  1467. err:
  1468. mmc_detach_bus(host);
  1469. pr_err("%s: error %d whilst initialising MMC card\n",
  1470. mmc_hostname(host), err);
  1471. return err;
  1472. }