1272cc70bSAndy Fleming /* 2272cc70bSAndy Fleming * Copyright 2008, Freescale Semiconductor, Inc 3272cc70bSAndy Fleming * Andy Fleming 4272cc70bSAndy Fleming * 5272cc70bSAndy Fleming * Based vaguely on the Linux code 6272cc70bSAndy Fleming * 71a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 8272cc70bSAndy Fleming */ 9272cc70bSAndy Fleming 10272cc70bSAndy Fleming #include <config.h> 11272cc70bSAndy Fleming #include <common.h> 12272cc70bSAndy Fleming #include <command.h> 138e3332e2SSjoerd Simons #include <dm.h> 148e3332e2SSjoerd Simons #include <dm/device-internal.h> 15d4622df3SStephen Warren #include <errno.h> 16272cc70bSAndy Fleming #include <mmc.h> 17272cc70bSAndy Fleming #include <part.h> 18272cc70bSAndy Fleming #include <malloc.h> 19cf92e05cSSimon Glass #include <memalign.h> 20272cc70bSAndy Fleming #include <linux/list.h> 219b1f942cSRabin Vincent #include <div64.h> 22da61fa5fSPaul Burton #include "mmc_private.h" 23272cc70bSAndy Fleming 24272cc70bSAndy Fleming static struct list_head mmc_devices; 25272cc70bSAndy Fleming static int cur_dev_num = -1; 26272cc70bSAndy Fleming 27750121c3SJeroen Hofstee __weak int board_mmc_getwp(struct mmc *mmc) 28d23d8d7eSNikita Kiryanov { 29d23d8d7eSNikita Kiryanov return -1; 30d23d8d7eSNikita Kiryanov } 31d23d8d7eSNikita Kiryanov 32d23d8d7eSNikita Kiryanov int mmc_getwp(struct mmc *mmc) 33d23d8d7eSNikita Kiryanov { 34d23d8d7eSNikita Kiryanov int wp; 35d23d8d7eSNikita Kiryanov 36d23d8d7eSNikita Kiryanov wp = board_mmc_getwp(mmc); 37d23d8d7eSNikita Kiryanov 38d4e1da4eSPeter Korsgaard if (wp < 0) { 3993bfd616SPantelis Antoniou if (mmc->cfg->ops->getwp) 4093bfd616SPantelis Antoniou wp = mmc->cfg->ops->getwp(mmc); 41d4e1da4eSPeter Korsgaard else 42d4e1da4eSPeter Korsgaard wp = 0; 43d4e1da4eSPeter Korsgaard } 44d23d8d7eSNikita Kiryanov 45d23d8d7eSNikita Kiryanov return wp; 46d23d8d7eSNikita Kiryanov } 47d23d8d7eSNikita Kiryanov 48cee9ab7cSJeroen Hofstee __weak int board_mmc_getcd(struct mmc *mmc) 49cee9ab7cSJeroen Hofstee { 5011fdade2SStefano Babic return -1; 5111fdade2SStefano Babic } 5211fdade2SStefano Babic 53da61fa5fSPaul Burton int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 54272cc70bSAndy Fleming { 555db2fe3aSRaffaele Recalcati int ret; 568635ff9eSMarek Vasut 578635ff9eSMarek Vasut #ifdef CONFIG_MMC_TRACE 585db2fe3aSRaffaele Recalcati int i; 595db2fe3aSRaffaele Recalcati u8 *ptr; 605db2fe3aSRaffaele Recalcati 615db2fe3aSRaffaele Recalcati printf("CMD_SEND:%d\n", cmd->cmdidx); 625db2fe3aSRaffaele Recalcati printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 6393bfd616SPantelis Antoniou ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 645db2fe3aSRaffaele Recalcati switch (cmd->resp_type) { 655db2fe3aSRaffaele Recalcati case MMC_RSP_NONE: 665db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_NONE\n"); 675db2fe3aSRaffaele Recalcati break; 685db2fe3aSRaffaele Recalcati case MMC_RSP_R1: 695db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 705db2fe3aSRaffaele Recalcati cmd->response[0]); 715db2fe3aSRaffaele Recalcati break; 725db2fe3aSRaffaele Recalcati case MMC_RSP_R1b: 735db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 745db2fe3aSRaffaele Recalcati cmd->response[0]); 755db2fe3aSRaffaele Recalcati break; 765db2fe3aSRaffaele Recalcati case MMC_RSP_R2: 775db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 785db2fe3aSRaffaele Recalcati cmd->response[0]); 795db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 805db2fe3aSRaffaele Recalcati cmd->response[1]); 815db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 825db2fe3aSRaffaele Recalcati cmd->response[2]); 835db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 845db2fe3aSRaffaele Recalcati cmd->response[3]); 855db2fe3aSRaffaele Recalcati printf("\n"); 865db2fe3aSRaffaele Recalcati printf("\t\t\t\t\tDUMPING DATA\n"); 875db2fe3aSRaffaele Recalcati for (i = 0; i < 4; i++) { 885db2fe3aSRaffaele Recalcati int j; 895db2fe3aSRaffaele Recalcati printf("\t\t\t\t\t%03d - ", i*4); 90146bec79SDirk Behme ptr = (u8 *)&cmd->response[i]; 915db2fe3aSRaffaele Recalcati ptr += 3; 925db2fe3aSRaffaele Recalcati for (j = 0; j < 4; j++) 935db2fe3aSRaffaele Recalcati printf("%02X ", *ptr--); 945db2fe3aSRaffaele Recalcati printf("\n"); 955db2fe3aSRaffaele Recalcati } 965db2fe3aSRaffaele Recalcati break; 975db2fe3aSRaffaele Recalcati case MMC_RSP_R3: 985db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 995db2fe3aSRaffaele Recalcati cmd->response[0]); 1005db2fe3aSRaffaele Recalcati break; 1015db2fe3aSRaffaele Recalcati default: 1025db2fe3aSRaffaele Recalcati printf("\t\tERROR MMC rsp not supported\n"); 1035db2fe3aSRaffaele Recalcati break; 1045db2fe3aSRaffaele Recalcati } 1055db2fe3aSRaffaele Recalcati #else 10693bfd616SPantelis Antoniou ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 1075db2fe3aSRaffaele Recalcati #endif 1088635ff9eSMarek Vasut return ret; 109272cc70bSAndy Fleming } 110272cc70bSAndy Fleming 111da61fa5fSPaul Burton int mmc_send_status(struct mmc *mmc, int timeout) 1125d4fc8d9SRaffaele Recalcati { 1135d4fc8d9SRaffaele Recalcati struct mmc_cmd cmd; 114d617c426SJan Kloetzke int err, retries = 5; 1155d4fc8d9SRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1165d4fc8d9SRaffaele Recalcati int status; 1175d4fc8d9SRaffaele Recalcati #endif 1185d4fc8d9SRaffaele Recalcati 1195d4fc8d9SRaffaele Recalcati cmd.cmdidx = MMC_CMD_SEND_STATUS; 1205d4fc8d9SRaffaele Recalcati cmd.resp_type = MMC_RSP_R1; 121aaf3d41aSMarek Vasut if (!mmc_host_is_spi(mmc)) 122aaf3d41aSMarek Vasut cmd.cmdarg = mmc->rca << 16; 1235d4fc8d9SRaffaele Recalcati 1241677eef4SAndrew Gabbasov while (1) { 1255d4fc8d9SRaffaele Recalcati err = mmc_send_cmd(mmc, &cmd, NULL); 126d617c426SJan Kloetzke if (!err) { 127d617c426SJan Kloetzke if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 128d617c426SJan Kloetzke (cmd.response[0] & MMC_STATUS_CURR_STATE) != 129d617c426SJan Kloetzke MMC_STATE_PRG) 1305d4fc8d9SRaffaele Recalcati break; 131d617c426SJan Kloetzke else if (cmd.response[0] & MMC_STATUS_MASK) { 13256196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 133d617c426SJan Kloetzke printf("Status Error: 0x%08X\n", 134d617c426SJan Kloetzke cmd.response[0]); 13556196826SPaul Burton #endif 136d617c426SJan Kloetzke return COMM_ERR; 137d617c426SJan Kloetzke } 138d617c426SJan Kloetzke } else if (--retries < 0) 139d617c426SJan Kloetzke return err; 1405d4fc8d9SRaffaele Recalcati 1411677eef4SAndrew Gabbasov if (timeout-- <= 0) 1421677eef4SAndrew Gabbasov break; 1435d4fc8d9SRaffaele Recalcati 1441677eef4SAndrew Gabbasov udelay(1000); 1451677eef4SAndrew Gabbasov } 1465d4fc8d9SRaffaele Recalcati 1475db2fe3aSRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1485db2fe3aSRaffaele Recalcati status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 1495db2fe3aSRaffaele Recalcati printf("CURR STATE:%d\n", status); 1505db2fe3aSRaffaele Recalcati #endif 1515b0c942fSJongman Heo if (timeout <= 0) { 15256196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1535d4fc8d9SRaffaele Recalcati printf("Timeout waiting card ready\n"); 15456196826SPaul Burton #endif 1555d4fc8d9SRaffaele Recalcati return TIMEOUT; 1565d4fc8d9SRaffaele Recalcati } 1576b2221b0SAndrew Gabbasov if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR) 1586b2221b0SAndrew Gabbasov return SWITCH_ERR; 1595d4fc8d9SRaffaele Recalcati 1605d4fc8d9SRaffaele Recalcati return 0; 1615d4fc8d9SRaffaele Recalcati } 1625d4fc8d9SRaffaele Recalcati 163da61fa5fSPaul Burton int mmc_set_blocklen(struct mmc *mmc, int len) 164272cc70bSAndy Fleming { 165272cc70bSAndy Fleming struct mmc_cmd cmd; 166272cc70bSAndy Fleming 167786e8f81SAndrew Gabbasov if (mmc->ddr_mode) 168d22e3d46SJaehoon Chung return 0; 169d22e3d46SJaehoon Chung 170272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 171272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 172272cc70bSAndy Fleming cmd.cmdarg = len; 173272cc70bSAndy Fleming 174272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, NULL); 175272cc70bSAndy Fleming } 176272cc70bSAndy Fleming 177272cc70bSAndy Fleming struct mmc *find_mmc_device(int dev_num) 178272cc70bSAndy Fleming { 179272cc70bSAndy Fleming struct mmc *m; 180272cc70bSAndy Fleming struct list_head *entry; 181272cc70bSAndy Fleming 182272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 183272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 184272cc70bSAndy Fleming 185272cc70bSAndy Fleming if (m->block_dev.dev == dev_num) 186272cc70bSAndy Fleming return m; 187272cc70bSAndy Fleming } 188272cc70bSAndy Fleming 18956196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 190272cc70bSAndy Fleming printf("MMC Device %d not found\n", dev_num); 19156196826SPaul Burton #endif 192272cc70bSAndy Fleming 193272cc70bSAndy Fleming return NULL; 194272cc70bSAndy Fleming } 195272cc70bSAndy Fleming 196ff8fef56SSascha Silbe static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 197fdbb873eSKim Phillips lbaint_t blkcnt) 198272cc70bSAndy Fleming { 199272cc70bSAndy Fleming struct mmc_cmd cmd; 200272cc70bSAndy Fleming struct mmc_data data; 201272cc70bSAndy Fleming 2024a1a06bcSAlagu Sankar if (blkcnt > 1) 2034a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 2044a1a06bcSAlagu Sankar else 205272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 206272cc70bSAndy Fleming 207272cc70bSAndy Fleming if (mmc->high_capacity) 2084a1a06bcSAlagu Sankar cmd.cmdarg = start; 209272cc70bSAndy Fleming else 2104a1a06bcSAlagu Sankar cmd.cmdarg = start * mmc->read_bl_len; 211272cc70bSAndy Fleming 212272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 213272cc70bSAndy Fleming 214272cc70bSAndy Fleming data.dest = dst; 2154a1a06bcSAlagu Sankar data.blocks = blkcnt; 216272cc70bSAndy Fleming data.blocksize = mmc->read_bl_len; 217272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 218272cc70bSAndy Fleming 2194a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, &data)) 2204a1a06bcSAlagu Sankar return 0; 2214a1a06bcSAlagu Sankar 2224a1a06bcSAlagu Sankar if (blkcnt > 1) { 2234a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 2244a1a06bcSAlagu Sankar cmd.cmdarg = 0; 2254a1a06bcSAlagu Sankar cmd.resp_type = MMC_RSP_R1b; 2264a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, NULL)) { 22756196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 2284a1a06bcSAlagu Sankar printf("mmc fail to send stop cmd\n"); 22956196826SPaul Burton #endif 2304a1a06bcSAlagu Sankar return 0; 2314a1a06bcSAlagu Sankar } 232272cc70bSAndy Fleming } 233272cc70bSAndy Fleming 2344a1a06bcSAlagu Sankar return blkcnt; 235272cc70bSAndy Fleming } 236272cc70bSAndy Fleming 237ff8fef56SSascha Silbe static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst) 238272cc70bSAndy Fleming { 2394a1a06bcSAlagu Sankar lbaint_t cur, blocks_todo = blkcnt; 240272cc70bSAndy Fleming 2414a1a06bcSAlagu Sankar if (blkcnt == 0) 2424a1a06bcSAlagu Sankar return 0; 2434a1a06bcSAlagu Sankar 2444a1a06bcSAlagu Sankar struct mmc *mmc = find_mmc_device(dev_num); 245272cc70bSAndy Fleming if (!mmc) 246272cc70bSAndy Fleming return 0; 247272cc70bSAndy Fleming 248d2bf29e3SLei Wen if ((start + blkcnt) > mmc->block_dev.lba) { 24956196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 250ff8fef56SSascha Silbe printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 251d2bf29e3SLei Wen start + blkcnt, mmc->block_dev.lba); 25256196826SPaul Burton #endif 253d2bf29e3SLei Wen return 0; 254d2bf29e3SLei Wen } 255272cc70bSAndy Fleming 25611692991SSimon Glass if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { 25711692991SSimon Glass debug("%s: Failed to set blocklen\n", __func__); 258272cc70bSAndy Fleming return 0; 25911692991SSimon Glass } 260272cc70bSAndy Fleming 2614a1a06bcSAlagu Sankar do { 26293bfd616SPantelis Antoniou cur = (blocks_todo > mmc->cfg->b_max) ? 26393bfd616SPantelis Antoniou mmc->cfg->b_max : blocks_todo; 26411692991SSimon Glass if (mmc_read_blocks(mmc, dst, start, cur) != cur) { 26511692991SSimon Glass debug("%s: Failed to read blocks\n", __func__); 2664a1a06bcSAlagu Sankar return 0; 26711692991SSimon Glass } 2684a1a06bcSAlagu Sankar blocks_todo -= cur; 2694a1a06bcSAlagu Sankar start += cur; 2704a1a06bcSAlagu Sankar dst += cur * mmc->read_bl_len; 2714a1a06bcSAlagu Sankar } while (blocks_todo > 0); 272272cc70bSAndy Fleming 273272cc70bSAndy Fleming return blkcnt; 274272cc70bSAndy Fleming } 275272cc70bSAndy Fleming 276fdbb873eSKim Phillips static int mmc_go_idle(struct mmc *mmc) 277272cc70bSAndy Fleming { 278272cc70bSAndy Fleming struct mmc_cmd cmd; 279272cc70bSAndy Fleming int err; 280272cc70bSAndy Fleming 281272cc70bSAndy Fleming udelay(1000); 282272cc70bSAndy Fleming 283272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 284272cc70bSAndy Fleming cmd.cmdarg = 0; 285272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_NONE; 286272cc70bSAndy Fleming 287272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 288272cc70bSAndy Fleming 289272cc70bSAndy Fleming if (err) 290272cc70bSAndy Fleming return err; 291272cc70bSAndy Fleming 292272cc70bSAndy Fleming udelay(2000); 293272cc70bSAndy Fleming 294272cc70bSAndy Fleming return 0; 295272cc70bSAndy Fleming } 296272cc70bSAndy Fleming 297fdbb873eSKim Phillips static int sd_send_op_cond(struct mmc *mmc) 298272cc70bSAndy Fleming { 299272cc70bSAndy Fleming int timeout = 1000; 300272cc70bSAndy Fleming int err; 301272cc70bSAndy Fleming struct mmc_cmd cmd; 302272cc70bSAndy Fleming 3031677eef4SAndrew Gabbasov while (1) { 304272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 305272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 306272cc70bSAndy Fleming cmd.cmdarg = 0; 307272cc70bSAndy Fleming 308272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 309272cc70bSAndy Fleming 310272cc70bSAndy Fleming if (err) 311272cc70bSAndy Fleming return err; 312272cc70bSAndy Fleming 313272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 314272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 315250de12bSStefano Babic 316250de12bSStefano Babic /* 317250de12bSStefano Babic * Most cards do not answer if some reserved bits 318250de12bSStefano Babic * in the ocr are set. However, Some controller 319250de12bSStefano Babic * can set bit 7 (reserved for low voltages), but 320250de12bSStefano Babic * how to manage low voltages SD card is not yet 321250de12bSStefano Babic * specified. 322250de12bSStefano Babic */ 323d52ebf10SThomas Chou cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 32493bfd616SPantelis Antoniou (mmc->cfg->voltages & 0xff8000); 325272cc70bSAndy Fleming 326272cc70bSAndy Fleming if (mmc->version == SD_VERSION_2) 327272cc70bSAndy Fleming cmd.cmdarg |= OCR_HCS; 328272cc70bSAndy Fleming 329272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 330272cc70bSAndy Fleming 331272cc70bSAndy Fleming if (err) 332272cc70bSAndy Fleming return err; 333272cc70bSAndy Fleming 3341677eef4SAndrew Gabbasov if (cmd.response[0] & OCR_BUSY) 3351677eef4SAndrew Gabbasov break; 336272cc70bSAndy Fleming 3371677eef4SAndrew Gabbasov if (timeout-- <= 0) 338272cc70bSAndy Fleming return UNUSABLE_ERR; 339272cc70bSAndy Fleming 3401677eef4SAndrew Gabbasov udelay(1000); 3411677eef4SAndrew Gabbasov } 3421677eef4SAndrew Gabbasov 343272cc70bSAndy Fleming if (mmc->version != SD_VERSION_2) 344272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 345272cc70bSAndy Fleming 346d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 347d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 348d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 349d52ebf10SThomas Chou cmd.cmdarg = 0; 350d52ebf10SThomas Chou 351d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 352d52ebf10SThomas Chou 353d52ebf10SThomas Chou if (err) 354d52ebf10SThomas Chou return err; 355d52ebf10SThomas Chou } 356d52ebf10SThomas Chou 357998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 358272cc70bSAndy Fleming 359272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 360272cc70bSAndy Fleming mmc->rca = 0; 361272cc70bSAndy Fleming 362272cc70bSAndy Fleming return 0; 363272cc70bSAndy Fleming } 364272cc70bSAndy Fleming 3655289b535SAndrew Gabbasov static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) 366272cc70bSAndy Fleming { 3675289b535SAndrew Gabbasov struct mmc_cmd cmd; 368272cc70bSAndy Fleming int err; 369272cc70bSAndy Fleming 3705289b535SAndrew Gabbasov cmd.cmdidx = MMC_CMD_SEND_OP_COND; 3715289b535SAndrew Gabbasov cmd.resp_type = MMC_RSP_R3; 3725289b535SAndrew Gabbasov cmd.cmdarg = 0; 3735a20397bSRob Herring if (use_arg && !mmc_host_is_spi(mmc)) 3745a20397bSRob Herring cmd.cmdarg = OCR_HCS | 37593bfd616SPantelis Antoniou (mmc->cfg->voltages & 376a626c8d4SAndrew Gabbasov (mmc->ocr & OCR_VOLTAGE_MASK)) | 377a626c8d4SAndrew Gabbasov (mmc->ocr & OCR_ACCESS_MODE); 378e9550449SChe-Liang Chiou 3795289b535SAndrew Gabbasov err = mmc_send_cmd(mmc, &cmd, NULL); 380e9550449SChe-Liang Chiou if (err) 381e9550449SChe-Liang Chiou return err; 3825289b535SAndrew Gabbasov mmc->ocr = cmd.response[0]; 383e9550449SChe-Liang Chiou return 0; 384e9550449SChe-Liang Chiou } 385e9550449SChe-Liang Chiou 386750121c3SJeroen Hofstee static int mmc_send_op_cond(struct mmc *mmc) 387e9550449SChe-Liang Chiou { 388e9550449SChe-Liang Chiou int err, i; 389e9550449SChe-Liang Chiou 390272cc70bSAndy Fleming /* Some cards seem to need this */ 391272cc70bSAndy Fleming mmc_go_idle(mmc); 392272cc70bSAndy Fleming 39331cacbabSRaffaele Recalcati /* Asking to the card its capabilities */ 394e9550449SChe-Liang Chiou for (i = 0; i < 2; i++) { 3955289b535SAndrew Gabbasov err = mmc_send_op_cond_iter(mmc, i != 0); 39631cacbabSRaffaele Recalcati if (err) 39731cacbabSRaffaele Recalcati return err; 39831cacbabSRaffaele Recalcati 399e9550449SChe-Liang Chiou /* exit if not busy (flag seems to be inverted) */ 400a626c8d4SAndrew Gabbasov if (mmc->ocr & OCR_BUSY) 401bd47c135SAndrew Gabbasov break; 402e9550449SChe-Liang Chiou } 403bd47c135SAndrew Gabbasov mmc->op_cond_pending = 1; 404bd47c135SAndrew Gabbasov return 0; 405e9550449SChe-Liang Chiou } 40631cacbabSRaffaele Recalcati 407750121c3SJeroen Hofstee static int mmc_complete_op_cond(struct mmc *mmc) 408e9550449SChe-Liang Chiou { 409e9550449SChe-Liang Chiou struct mmc_cmd cmd; 410e9550449SChe-Liang Chiou int timeout = 1000; 411e9550449SChe-Liang Chiou uint start; 412e9550449SChe-Liang Chiou int err; 413e9550449SChe-Liang Chiou 414e9550449SChe-Liang Chiou mmc->op_cond_pending = 0; 415cc17c01fSAndrew Gabbasov if (!(mmc->ocr & OCR_BUSY)) { 416e9550449SChe-Liang Chiou start = get_timer(0); 4171677eef4SAndrew Gabbasov while (1) { 4185289b535SAndrew Gabbasov err = mmc_send_op_cond_iter(mmc, 1); 419272cc70bSAndy Fleming if (err) 420272cc70bSAndy Fleming return err; 4211677eef4SAndrew Gabbasov if (mmc->ocr & OCR_BUSY) 4221677eef4SAndrew Gabbasov break; 423e9550449SChe-Liang Chiou if (get_timer(start) > timeout) 424272cc70bSAndy Fleming return UNUSABLE_ERR; 425e9550449SChe-Liang Chiou udelay(100); 4261677eef4SAndrew Gabbasov } 427cc17c01fSAndrew Gabbasov } 428272cc70bSAndy Fleming 429d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 430d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 431d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 432d52ebf10SThomas Chou cmd.cmdarg = 0; 433d52ebf10SThomas Chou 434d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 435d52ebf10SThomas Chou 436d52ebf10SThomas Chou if (err) 437d52ebf10SThomas Chou return err; 438a626c8d4SAndrew Gabbasov 439a626c8d4SAndrew Gabbasov mmc->ocr = cmd.response[0]; 440d52ebf10SThomas Chou } 441d52ebf10SThomas Chou 442272cc70bSAndy Fleming mmc->version = MMC_VERSION_UNKNOWN; 443272cc70bSAndy Fleming 444272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 445def816a2SStephen Warren mmc->rca = 1; 446272cc70bSAndy Fleming 447272cc70bSAndy Fleming return 0; 448272cc70bSAndy Fleming } 449272cc70bSAndy Fleming 450272cc70bSAndy Fleming 451fdbb873eSKim Phillips static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 452272cc70bSAndy Fleming { 453272cc70bSAndy Fleming struct mmc_cmd cmd; 454272cc70bSAndy Fleming struct mmc_data data; 455272cc70bSAndy Fleming int err; 456272cc70bSAndy Fleming 457272cc70bSAndy Fleming /* Get the Card Status Register */ 458272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 459272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 460272cc70bSAndy Fleming cmd.cmdarg = 0; 461272cc70bSAndy Fleming 462cdfd1ac6SYoshihiro Shimoda data.dest = (char *)ext_csd; 463272cc70bSAndy Fleming data.blocks = 1; 4648bfa195eSSimon Glass data.blocksize = MMC_MAX_BLOCK_LEN; 465272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 466272cc70bSAndy Fleming 467272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 468272cc70bSAndy Fleming 469272cc70bSAndy Fleming return err; 470272cc70bSAndy Fleming } 471272cc70bSAndy Fleming 472272cc70bSAndy Fleming 473fdbb873eSKim Phillips static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 474272cc70bSAndy Fleming { 475272cc70bSAndy Fleming struct mmc_cmd cmd; 4765d4fc8d9SRaffaele Recalcati int timeout = 1000; 4775d4fc8d9SRaffaele Recalcati int ret; 478272cc70bSAndy Fleming 479272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SWITCH; 480272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 481272cc70bSAndy Fleming cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 482272cc70bSAndy Fleming (index << 16) | 483272cc70bSAndy Fleming (value << 8); 484272cc70bSAndy Fleming 4855d4fc8d9SRaffaele Recalcati ret = mmc_send_cmd(mmc, &cmd, NULL); 4865d4fc8d9SRaffaele Recalcati 4875d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 48893ad0d18SJan Kloetzke if (!ret) 48993ad0d18SJan Kloetzke ret = mmc_send_status(mmc, timeout); 4905d4fc8d9SRaffaele Recalcati 4915d4fc8d9SRaffaele Recalcati return ret; 4925d4fc8d9SRaffaele Recalcati 493272cc70bSAndy Fleming } 494272cc70bSAndy Fleming 495fdbb873eSKim Phillips static int mmc_change_freq(struct mmc *mmc) 496272cc70bSAndy Fleming { 4978bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 498272cc70bSAndy Fleming char cardtype; 499272cc70bSAndy Fleming int err; 500272cc70bSAndy Fleming 501fc5b32fbSAndrew Gabbasov mmc->card_caps = 0; 502272cc70bSAndy Fleming 503d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 504d52ebf10SThomas Chou return 0; 505d52ebf10SThomas Chou 506272cc70bSAndy Fleming /* Only version 4 supports high-speed */ 507272cc70bSAndy Fleming if (mmc->version < MMC_VERSION_4) 508272cc70bSAndy Fleming return 0; 509272cc70bSAndy Fleming 510fc5b32fbSAndrew Gabbasov mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT; 511fc5b32fbSAndrew Gabbasov 512272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 513272cc70bSAndy Fleming 514272cc70bSAndy Fleming if (err) 515272cc70bSAndy Fleming return err; 516272cc70bSAndy Fleming 5170560db18SLei Wen cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 518272cc70bSAndy Fleming 519272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 520272cc70bSAndy Fleming 521272cc70bSAndy Fleming if (err) 5226b2221b0SAndrew Gabbasov return err == SWITCH_ERR ? 0 : err; 523272cc70bSAndy Fleming 524272cc70bSAndy Fleming /* Now check to see that it worked */ 525272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 526272cc70bSAndy Fleming 527272cc70bSAndy Fleming if (err) 528272cc70bSAndy Fleming return err; 529272cc70bSAndy Fleming 530272cc70bSAndy Fleming /* No high-speed support */ 5310560db18SLei Wen if (!ext_csd[EXT_CSD_HS_TIMING]) 532272cc70bSAndy Fleming return 0; 533272cc70bSAndy Fleming 534272cc70bSAndy Fleming /* High Speed is set, there are two types: 52MHz and 26MHz */ 535d22e3d46SJaehoon Chung if (cardtype & EXT_CSD_CARD_TYPE_52) { 536201d5ac4SAndrew Gabbasov if (cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V) 537d22e3d46SJaehoon Chung mmc->card_caps |= MMC_MODE_DDR_52MHz; 538272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 539d22e3d46SJaehoon Chung } else { 540272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 541d22e3d46SJaehoon Chung } 542272cc70bSAndy Fleming 543272cc70bSAndy Fleming return 0; 544272cc70bSAndy Fleming } 545272cc70bSAndy Fleming 546f866a46dSStephen Warren static int mmc_set_capacity(struct mmc *mmc, int part_num) 547f866a46dSStephen Warren { 548f866a46dSStephen Warren switch (part_num) { 549f866a46dSStephen Warren case 0: 550f866a46dSStephen Warren mmc->capacity = mmc->capacity_user; 551f866a46dSStephen Warren break; 552f866a46dSStephen Warren case 1: 553f866a46dSStephen Warren case 2: 554f866a46dSStephen Warren mmc->capacity = mmc->capacity_boot; 555f866a46dSStephen Warren break; 556f866a46dSStephen Warren case 3: 557f866a46dSStephen Warren mmc->capacity = mmc->capacity_rpmb; 558f866a46dSStephen Warren break; 559f866a46dSStephen Warren case 4: 560f866a46dSStephen Warren case 5: 561f866a46dSStephen Warren case 6: 562f866a46dSStephen Warren case 7: 563f866a46dSStephen Warren mmc->capacity = mmc->capacity_gp[part_num - 4]; 564f866a46dSStephen Warren break; 565f866a46dSStephen Warren default: 566f866a46dSStephen Warren return -1; 567f866a46dSStephen Warren } 568f866a46dSStephen Warren 569f866a46dSStephen Warren mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 570f866a46dSStephen Warren 571f866a46dSStephen Warren return 0; 572f866a46dSStephen Warren } 573f866a46dSStephen Warren 574d2356284SStephen Warren int mmc_select_hwpart(int dev_num, int hwpart) 575d2356284SStephen Warren { 576d2356284SStephen Warren struct mmc *mmc = find_mmc_device(dev_num); 577d2356284SStephen Warren int ret; 578d2356284SStephen Warren 579d2356284SStephen Warren if (!mmc) 580d4622df3SStephen Warren return -ENODEV; 581d2356284SStephen Warren 582d2356284SStephen Warren if (mmc->part_num == hwpart) 583d2356284SStephen Warren return 0; 584d2356284SStephen Warren 585d2356284SStephen Warren if (mmc->part_config == MMCPART_NOAVAILABLE) { 586d2356284SStephen Warren printf("Card doesn't support part_switch\n"); 587d4622df3SStephen Warren return -EMEDIUMTYPE; 588d2356284SStephen Warren } 589d2356284SStephen Warren 590d2356284SStephen Warren ret = mmc_switch_part(dev_num, hwpart); 591d2356284SStephen Warren if (ret) 592d4622df3SStephen Warren return ret; 593d2356284SStephen Warren 594d2356284SStephen Warren mmc->part_num = hwpart; 595d2356284SStephen Warren 596d2356284SStephen Warren return 0; 597d2356284SStephen Warren } 598d2356284SStephen Warren 599d2356284SStephen Warren 600bc897b1dSLei Wen int mmc_switch_part(int dev_num, unsigned int part_num) 601bc897b1dSLei Wen { 602bc897b1dSLei Wen struct mmc *mmc = find_mmc_device(dev_num); 603f866a46dSStephen Warren int ret; 604bc897b1dSLei Wen 605bc897b1dSLei Wen if (!mmc) 606bc897b1dSLei Wen return -1; 607bc897b1dSLei Wen 608f866a46dSStephen Warren ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 609bc897b1dSLei Wen (mmc->part_config & ~PART_ACCESS_MASK) 610bc897b1dSLei Wen | (part_num & PART_ACCESS_MASK)); 611f866a46dSStephen Warren 6126dc93e70SPeter Bigot /* 6136dc93e70SPeter Bigot * Set the capacity if the switch succeeded or was intended 6146dc93e70SPeter Bigot * to return to representing the raw device. 6156dc93e70SPeter Bigot */ 6166dc93e70SPeter Bigot if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) 6176dc93e70SPeter Bigot ret = mmc_set_capacity(mmc, part_num); 6186dc93e70SPeter Bigot 6196dc93e70SPeter Bigot return ret; 620bc897b1dSLei Wen } 621bc897b1dSLei Wen 622ac9da0e0SDiego Santa Cruz int mmc_hwpart_config(struct mmc *mmc, 623ac9da0e0SDiego Santa Cruz const struct mmc_hwpart_conf *conf, 624ac9da0e0SDiego Santa Cruz enum mmc_hwpart_conf_mode mode) 625ac9da0e0SDiego Santa Cruz { 626ac9da0e0SDiego Santa Cruz u8 part_attrs = 0; 627ac9da0e0SDiego Santa Cruz u32 enh_size_mult; 628ac9da0e0SDiego Santa Cruz u32 enh_start_addr; 629ac9da0e0SDiego Santa Cruz u32 gp_size_mult[4]; 630ac9da0e0SDiego Santa Cruz u32 max_enh_size_mult; 631ac9da0e0SDiego Santa Cruz u32 tot_enh_size_mult = 0; 6328dda5b0eSDiego Santa Cruz u8 wr_rel_set; 633ac9da0e0SDiego Santa Cruz int i, pidx, err; 634ac9da0e0SDiego Santa Cruz ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 635ac9da0e0SDiego Santa Cruz 636ac9da0e0SDiego Santa Cruz if (mode < MMC_HWPART_CONF_CHECK || mode > MMC_HWPART_CONF_COMPLETE) 637ac9da0e0SDiego Santa Cruz return -EINVAL; 638ac9da0e0SDiego Santa Cruz 639ac9da0e0SDiego Santa Cruz if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) { 640ac9da0e0SDiego Santa Cruz printf("eMMC >= 4.4 required for enhanced user data area\n"); 641ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 642ac9da0e0SDiego Santa Cruz } 643ac9da0e0SDiego Santa Cruz 644ac9da0e0SDiego Santa Cruz if (!(mmc->part_support & PART_SUPPORT)) { 645ac9da0e0SDiego Santa Cruz printf("Card does not support partitioning\n"); 646ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 647ac9da0e0SDiego Santa Cruz } 648ac9da0e0SDiego Santa Cruz 649ac9da0e0SDiego Santa Cruz if (!mmc->hc_wp_grp_size) { 650ac9da0e0SDiego Santa Cruz printf("Card does not define HC WP group size\n"); 651ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 652ac9da0e0SDiego Santa Cruz } 653ac9da0e0SDiego Santa Cruz 654ac9da0e0SDiego Santa Cruz /* check partition alignment and total enhanced size */ 655ac9da0e0SDiego Santa Cruz if (conf->user.enh_size) { 656ac9da0e0SDiego Santa Cruz if (conf->user.enh_size % mmc->hc_wp_grp_size || 657ac9da0e0SDiego Santa Cruz conf->user.enh_start % mmc->hc_wp_grp_size) { 658ac9da0e0SDiego Santa Cruz printf("User data enhanced area not HC WP group " 659ac9da0e0SDiego Santa Cruz "size aligned\n"); 660ac9da0e0SDiego Santa Cruz return -EINVAL; 661ac9da0e0SDiego Santa Cruz } 662ac9da0e0SDiego Santa Cruz part_attrs |= EXT_CSD_ENH_USR; 663ac9da0e0SDiego Santa Cruz enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size; 664ac9da0e0SDiego Santa Cruz if (mmc->high_capacity) { 665ac9da0e0SDiego Santa Cruz enh_start_addr = conf->user.enh_start; 666ac9da0e0SDiego Santa Cruz } else { 667ac9da0e0SDiego Santa Cruz enh_start_addr = (conf->user.enh_start << 9); 668ac9da0e0SDiego Santa Cruz } 669ac9da0e0SDiego Santa Cruz } else { 670ac9da0e0SDiego Santa Cruz enh_size_mult = 0; 671ac9da0e0SDiego Santa Cruz enh_start_addr = 0; 672ac9da0e0SDiego Santa Cruz } 673ac9da0e0SDiego Santa Cruz tot_enh_size_mult += enh_size_mult; 674ac9da0e0SDiego Santa Cruz 675ac9da0e0SDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 676ac9da0e0SDiego Santa Cruz if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) { 677ac9da0e0SDiego Santa Cruz printf("GP%i partition not HC WP group size " 678ac9da0e0SDiego Santa Cruz "aligned\n", pidx+1); 679ac9da0e0SDiego Santa Cruz return -EINVAL; 680ac9da0e0SDiego Santa Cruz } 681ac9da0e0SDiego Santa Cruz gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size; 682ac9da0e0SDiego Santa Cruz if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) { 683ac9da0e0SDiego Santa Cruz part_attrs |= EXT_CSD_ENH_GP(pidx); 684ac9da0e0SDiego Santa Cruz tot_enh_size_mult += gp_size_mult[pidx]; 685ac9da0e0SDiego Santa Cruz } 686ac9da0e0SDiego Santa Cruz } 687ac9da0e0SDiego Santa Cruz 688ac9da0e0SDiego Santa Cruz if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) { 689ac9da0e0SDiego Santa Cruz printf("Card does not support enhanced attribute\n"); 690ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 691ac9da0e0SDiego Santa Cruz } 692ac9da0e0SDiego Santa Cruz 693ac9da0e0SDiego Santa Cruz err = mmc_send_ext_csd(mmc, ext_csd); 694ac9da0e0SDiego Santa Cruz if (err) 695ac9da0e0SDiego Santa Cruz return err; 696ac9da0e0SDiego Santa Cruz 697ac9da0e0SDiego Santa Cruz max_enh_size_mult = 698ac9da0e0SDiego Santa Cruz (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+2] << 16) + 699ac9da0e0SDiego Santa Cruz (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+1] << 8) + 700ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT]; 701ac9da0e0SDiego Santa Cruz if (tot_enh_size_mult > max_enh_size_mult) { 702ac9da0e0SDiego Santa Cruz printf("Total enhanced size exceeds maximum (%u > %u)\n", 703ac9da0e0SDiego Santa Cruz tot_enh_size_mult, max_enh_size_mult); 704ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 705ac9da0e0SDiego Santa Cruz } 706ac9da0e0SDiego Santa Cruz 7078dda5b0eSDiego Santa Cruz /* The default value of EXT_CSD_WR_REL_SET is device 7088dda5b0eSDiego Santa Cruz * dependent, the values can only be changed if the 7098dda5b0eSDiego Santa Cruz * EXT_CSD_HS_CTRL_REL bit is set. The values can be 7108dda5b0eSDiego Santa Cruz * changed only once and before partitioning is completed. */ 7118dda5b0eSDiego Santa Cruz wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 7128dda5b0eSDiego Santa Cruz if (conf->user.wr_rel_change) { 7138dda5b0eSDiego Santa Cruz if (conf->user.wr_rel_set) 7148dda5b0eSDiego Santa Cruz wr_rel_set |= EXT_CSD_WR_DATA_REL_USR; 7158dda5b0eSDiego Santa Cruz else 7168dda5b0eSDiego Santa Cruz wr_rel_set &= ~EXT_CSD_WR_DATA_REL_USR; 7178dda5b0eSDiego Santa Cruz } 7188dda5b0eSDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 7198dda5b0eSDiego Santa Cruz if (conf->gp_part[pidx].wr_rel_change) { 7208dda5b0eSDiego Santa Cruz if (conf->gp_part[pidx].wr_rel_set) 7218dda5b0eSDiego Santa Cruz wr_rel_set |= EXT_CSD_WR_DATA_REL_GP(pidx); 7228dda5b0eSDiego Santa Cruz else 7238dda5b0eSDiego Santa Cruz wr_rel_set &= ~EXT_CSD_WR_DATA_REL_GP(pidx); 7248dda5b0eSDiego Santa Cruz } 7258dda5b0eSDiego Santa Cruz } 7268dda5b0eSDiego Santa Cruz 7278dda5b0eSDiego Santa Cruz if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET] && 7288dda5b0eSDiego Santa Cruz !(ext_csd[EXT_CSD_WR_REL_PARAM] & EXT_CSD_HS_CTRL_REL)) { 7298dda5b0eSDiego Santa Cruz puts("Card does not support host controlled partition write " 7308dda5b0eSDiego Santa Cruz "reliability settings\n"); 7318dda5b0eSDiego Santa Cruz return -EMEDIUMTYPE; 7328dda5b0eSDiego Santa Cruz } 7338dda5b0eSDiego Santa Cruz 734ac9da0e0SDiego Santa Cruz if (ext_csd[EXT_CSD_PARTITION_SETTING] & 735ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED) { 736ac9da0e0SDiego Santa Cruz printf("Card already partitioned\n"); 737ac9da0e0SDiego Santa Cruz return -EPERM; 738ac9da0e0SDiego Santa Cruz } 739ac9da0e0SDiego Santa Cruz 740ac9da0e0SDiego Santa Cruz if (mode == MMC_HWPART_CONF_CHECK) 741ac9da0e0SDiego Santa Cruz return 0; 742ac9da0e0SDiego Santa Cruz 743ac9da0e0SDiego Santa Cruz /* Partitioning requires high-capacity size definitions */ 744ac9da0e0SDiego Santa Cruz if (!(ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01)) { 745ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 746ac9da0e0SDiego Santa Cruz EXT_CSD_ERASE_GROUP_DEF, 1); 747ac9da0e0SDiego Santa Cruz 748ac9da0e0SDiego Santa Cruz if (err) 749ac9da0e0SDiego Santa Cruz return err; 750ac9da0e0SDiego Santa Cruz 751ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 752ac9da0e0SDiego Santa Cruz 753ac9da0e0SDiego Santa Cruz /* update erase group size to be high-capacity */ 754ac9da0e0SDiego Santa Cruz mmc->erase_grp_size = 755ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 756ac9da0e0SDiego Santa Cruz 757ac9da0e0SDiego Santa Cruz } 758ac9da0e0SDiego Santa Cruz 759ac9da0e0SDiego Santa Cruz /* all OK, write the configuration */ 760ac9da0e0SDiego Santa Cruz for (i = 0; i < 4; i++) { 761ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 762ac9da0e0SDiego Santa Cruz EXT_CSD_ENH_START_ADDR+i, 763ac9da0e0SDiego Santa Cruz (enh_start_addr >> (i*8)) & 0xFF); 764ac9da0e0SDiego Santa Cruz if (err) 765ac9da0e0SDiego Santa Cruz return err; 766ac9da0e0SDiego Santa Cruz } 767ac9da0e0SDiego Santa Cruz for (i = 0; i < 3; i++) { 768ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 769ac9da0e0SDiego Santa Cruz EXT_CSD_ENH_SIZE_MULT+i, 770ac9da0e0SDiego Santa Cruz (enh_size_mult >> (i*8)) & 0xFF); 771ac9da0e0SDiego Santa Cruz if (err) 772ac9da0e0SDiego Santa Cruz return err; 773ac9da0e0SDiego Santa Cruz } 774ac9da0e0SDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 775ac9da0e0SDiego Santa Cruz for (i = 0; i < 3; i++) { 776ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 777ac9da0e0SDiego Santa Cruz EXT_CSD_GP_SIZE_MULT+pidx*3+i, 778ac9da0e0SDiego Santa Cruz (gp_size_mult[pidx] >> (i*8)) & 0xFF); 779ac9da0e0SDiego Santa Cruz if (err) 780ac9da0e0SDiego Santa Cruz return err; 781ac9da0e0SDiego Santa Cruz } 782ac9da0e0SDiego Santa Cruz } 783ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 784ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITIONS_ATTRIBUTE, part_attrs); 785ac9da0e0SDiego Santa Cruz if (err) 786ac9da0e0SDiego Santa Cruz return err; 787ac9da0e0SDiego Santa Cruz 788ac9da0e0SDiego Santa Cruz if (mode == MMC_HWPART_CONF_SET) 789ac9da0e0SDiego Santa Cruz return 0; 790ac9da0e0SDiego Santa Cruz 7918dda5b0eSDiego Santa Cruz /* The WR_REL_SET is a write-once register but shall be 7928dda5b0eSDiego Santa Cruz * written before setting PART_SETTING_COMPLETED. As it is 7938dda5b0eSDiego Santa Cruz * write-once we can only write it when completing the 7948dda5b0eSDiego Santa Cruz * partitioning. */ 7958dda5b0eSDiego Santa Cruz if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET]) { 7968dda5b0eSDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 7978dda5b0eSDiego Santa Cruz EXT_CSD_WR_REL_SET, wr_rel_set); 7988dda5b0eSDiego Santa Cruz if (err) 7998dda5b0eSDiego Santa Cruz return err; 8008dda5b0eSDiego Santa Cruz } 8018dda5b0eSDiego Santa Cruz 802ac9da0e0SDiego Santa Cruz /* Setting PART_SETTING_COMPLETED confirms the partition 803ac9da0e0SDiego Santa Cruz * configuration but it only becomes effective after power 804ac9da0e0SDiego Santa Cruz * cycle, so we do not adjust the partition related settings 805ac9da0e0SDiego Santa Cruz * in the mmc struct. */ 806ac9da0e0SDiego Santa Cruz 807ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 808ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING, 809ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED); 810ac9da0e0SDiego Santa Cruz if (err) 811ac9da0e0SDiego Santa Cruz return err; 812ac9da0e0SDiego Santa Cruz 813ac9da0e0SDiego Santa Cruz return 0; 814ac9da0e0SDiego Santa Cruz } 815ac9da0e0SDiego Santa Cruz 81648972d90SThierry Reding int mmc_getcd(struct mmc *mmc) 81748972d90SThierry Reding { 81848972d90SThierry Reding int cd; 81948972d90SThierry Reding 82048972d90SThierry Reding cd = board_mmc_getcd(mmc); 82148972d90SThierry Reding 822d4e1da4eSPeter Korsgaard if (cd < 0) { 82393bfd616SPantelis Antoniou if (mmc->cfg->ops->getcd) 82493bfd616SPantelis Antoniou cd = mmc->cfg->ops->getcd(mmc); 825d4e1da4eSPeter Korsgaard else 826d4e1da4eSPeter Korsgaard cd = 1; 827d4e1da4eSPeter Korsgaard } 82848972d90SThierry Reding 82948972d90SThierry Reding return cd; 83048972d90SThierry Reding } 83148972d90SThierry Reding 832fdbb873eSKim Phillips static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 833272cc70bSAndy Fleming { 834272cc70bSAndy Fleming struct mmc_cmd cmd; 835272cc70bSAndy Fleming struct mmc_data data; 836272cc70bSAndy Fleming 837272cc70bSAndy Fleming /* Switch the frequency */ 838272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SWITCH_FUNC; 839272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 840272cc70bSAndy Fleming cmd.cmdarg = (mode << 31) | 0xffffff; 841272cc70bSAndy Fleming cmd.cmdarg &= ~(0xf << (group * 4)); 842272cc70bSAndy Fleming cmd.cmdarg |= value << (group * 4); 843272cc70bSAndy Fleming 844272cc70bSAndy Fleming data.dest = (char *)resp; 845272cc70bSAndy Fleming data.blocksize = 64; 846272cc70bSAndy Fleming data.blocks = 1; 847272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 848272cc70bSAndy Fleming 849272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, &data); 850272cc70bSAndy Fleming } 851272cc70bSAndy Fleming 852272cc70bSAndy Fleming 853fdbb873eSKim Phillips static int sd_change_freq(struct mmc *mmc) 854272cc70bSAndy Fleming { 855272cc70bSAndy Fleming int err; 856272cc70bSAndy Fleming struct mmc_cmd cmd; 857f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 858f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 859272cc70bSAndy Fleming struct mmc_data data; 860272cc70bSAndy Fleming int timeout; 861272cc70bSAndy Fleming 862272cc70bSAndy Fleming mmc->card_caps = 0; 863272cc70bSAndy Fleming 864d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 865d52ebf10SThomas Chou return 0; 866d52ebf10SThomas Chou 867272cc70bSAndy Fleming /* Read the SCR to find out if this card supports higher speeds */ 868272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 869272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 870272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 871272cc70bSAndy Fleming 872272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 873272cc70bSAndy Fleming 874272cc70bSAndy Fleming if (err) 875272cc70bSAndy Fleming return err; 876272cc70bSAndy Fleming 877272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_SCR; 878272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 879272cc70bSAndy Fleming cmd.cmdarg = 0; 880272cc70bSAndy Fleming 881272cc70bSAndy Fleming timeout = 3; 882272cc70bSAndy Fleming 883272cc70bSAndy Fleming retry_scr: 884f781dd38SAnton staaf data.dest = (char *)scr; 885272cc70bSAndy Fleming data.blocksize = 8; 886272cc70bSAndy Fleming data.blocks = 1; 887272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 888272cc70bSAndy Fleming 889272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 890272cc70bSAndy Fleming 891272cc70bSAndy Fleming if (err) { 892272cc70bSAndy Fleming if (timeout--) 893272cc70bSAndy Fleming goto retry_scr; 894272cc70bSAndy Fleming 895272cc70bSAndy Fleming return err; 896272cc70bSAndy Fleming } 897272cc70bSAndy Fleming 8984e3d89baSYauhen Kharuzhy mmc->scr[0] = __be32_to_cpu(scr[0]); 8994e3d89baSYauhen Kharuzhy mmc->scr[1] = __be32_to_cpu(scr[1]); 900272cc70bSAndy Fleming 901272cc70bSAndy Fleming switch ((mmc->scr[0] >> 24) & 0xf) { 902272cc70bSAndy Fleming case 0: 903272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 904272cc70bSAndy Fleming break; 905272cc70bSAndy Fleming case 1: 906272cc70bSAndy Fleming mmc->version = SD_VERSION_1_10; 907272cc70bSAndy Fleming break; 908272cc70bSAndy Fleming case 2: 909272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 9101741c64dSJaehoon Chung if ((mmc->scr[0] >> 15) & 0x1) 9111741c64dSJaehoon Chung mmc->version = SD_VERSION_3; 912272cc70bSAndy Fleming break; 913272cc70bSAndy Fleming default: 914272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 915272cc70bSAndy Fleming break; 916272cc70bSAndy Fleming } 917272cc70bSAndy Fleming 918b44c7083SAlagu Sankar if (mmc->scr[0] & SD_DATA_4BIT) 919b44c7083SAlagu Sankar mmc->card_caps |= MMC_MODE_4BIT; 920b44c7083SAlagu Sankar 921272cc70bSAndy Fleming /* Version 1.0 doesn't support switching */ 922272cc70bSAndy Fleming if (mmc->version == SD_VERSION_1_0) 923272cc70bSAndy Fleming return 0; 924272cc70bSAndy Fleming 925272cc70bSAndy Fleming timeout = 4; 926272cc70bSAndy Fleming while (timeout--) { 927272cc70bSAndy Fleming err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 928f781dd38SAnton staaf (u8 *)switch_status); 929272cc70bSAndy Fleming 930272cc70bSAndy Fleming if (err) 931272cc70bSAndy Fleming return err; 932272cc70bSAndy Fleming 933272cc70bSAndy Fleming /* The high-speed function is busy. Try again */ 9344e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 935272cc70bSAndy Fleming break; 936272cc70bSAndy Fleming } 937272cc70bSAndy Fleming 938272cc70bSAndy Fleming /* If high-speed isn't supported, we return */ 9394e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 940272cc70bSAndy Fleming return 0; 941272cc70bSAndy Fleming 9422c3fbf4cSMacpaul Lin /* 9432c3fbf4cSMacpaul Lin * If the host doesn't support SD_HIGHSPEED, do not switch card to 9442c3fbf4cSMacpaul Lin * HIGHSPEED mode even if the card support SD_HIGHSPPED. 9452c3fbf4cSMacpaul Lin * This can avoid furthur problem when the card runs in different 9462c3fbf4cSMacpaul Lin * mode between the host. 9472c3fbf4cSMacpaul Lin */ 94893bfd616SPantelis Antoniou if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) && 94993bfd616SPantelis Antoniou (mmc->cfg->host_caps & MMC_MODE_HS))) 9502c3fbf4cSMacpaul Lin return 0; 9512c3fbf4cSMacpaul Lin 952f781dd38SAnton staaf err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 953272cc70bSAndy Fleming 954272cc70bSAndy Fleming if (err) 955272cc70bSAndy Fleming return err; 956272cc70bSAndy Fleming 9574e3d89baSYauhen Kharuzhy if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 958272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 959272cc70bSAndy Fleming 960272cc70bSAndy Fleming return 0; 961272cc70bSAndy Fleming } 962272cc70bSAndy Fleming 963272cc70bSAndy Fleming /* frequency bases */ 964272cc70bSAndy Fleming /* divided by 10 to be nice to platforms without floating point */ 9655f837c2cSMike Frysinger static const int fbase[] = { 966272cc70bSAndy Fleming 10000, 967272cc70bSAndy Fleming 100000, 968272cc70bSAndy Fleming 1000000, 969272cc70bSAndy Fleming 10000000, 970272cc70bSAndy Fleming }; 971272cc70bSAndy Fleming 972272cc70bSAndy Fleming /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 973272cc70bSAndy Fleming * to platforms without floating point. 974272cc70bSAndy Fleming */ 9755f837c2cSMike Frysinger static const int multipliers[] = { 976272cc70bSAndy Fleming 0, /* reserved */ 977272cc70bSAndy Fleming 10, 978272cc70bSAndy Fleming 12, 979272cc70bSAndy Fleming 13, 980272cc70bSAndy Fleming 15, 981272cc70bSAndy Fleming 20, 982272cc70bSAndy Fleming 25, 983272cc70bSAndy Fleming 30, 984272cc70bSAndy Fleming 35, 985272cc70bSAndy Fleming 40, 986272cc70bSAndy Fleming 45, 987272cc70bSAndy Fleming 50, 988272cc70bSAndy Fleming 55, 989272cc70bSAndy Fleming 60, 990272cc70bSAndy Fleming 70, 991272cc70bSAndy Fleming 80, 992272cc70bSAndy Fleming }; 993272cc70bSAndy Fleming 994fdbb873eSKim Phillips static void mmc_set_ios(struct mmc *mmc) 995272cc70bSAndy Fleming { 99693bfd616SPantelis Antoniou if (mmc->cfg->ops->set_ios) 99793bfd616SPantelis Antoniou mmc->cfg->ops->set_ios(mmc); 998272cc70bSAndy Fleming } 999272cc70bSAndy Fleming 1000272cc70bSAndy Fleming void mmc_set_clock(struct mmc *mmc, uint clock) 1001272cc70bSAndy Fleming { 100293bfd616SPantelis Antoniou if (clock > mmc->cfg->f_max) 100393bfd616SPantelis Antoniou clock = mmc->cfg->f_max; 1004272cc70bSAndy Fleming 100593bfd616SPantelis Antoniou if (clock < mmc->cfg->f_min) 100693bfd616SPantelis Antoniou clock = mmc->cfg->f_min; 1007272cc70bSAndy Fleming 1008272cc70bSAndy Fleming mmc->clock = clock; 1009272cc70bSAndy Fleming 1010272cc70bSAndy Fleming mmc_set_ios(mmc); 1011272cc70bSAndy Fleming } 1012272cc70bSAndy Fleming 1013fdbb873eSKim Phillips static void mmc_set_bus_width(struct mmc *mmc, uint width) 1014272cc70bSAndy Fleming { 1015272cc70bSAndy Fleming mmc->bus_width = width; 1016272cc70bSAndy Fleming 1017272cc70bSAndy Fleming mmc_set_ios(mmc); 1018272cc70bSAndy Fleming } 1019272cc70bSAndy Fleming 1020fdbb873eSKim Phillips static int mmc_startup(struct mmc *mmc) 1021272cc70bSAndy Fleming { 1022f866a46dSStephen Warren int err, i; 1023272cc70bSAndy Fleming uint mult, freq; 1024639b7827SYoshihiro Shimoda u64 cmult, csize, capacity; 1025272cc70bSAndy Fleming struct mmc_cmd cmd; 10268bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 10278bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 10285d4fc8d9SRaffaele Recalcati int timeout = 1000; 10290c453bb7SDiego Santa Cruz bool has_parts = false; 10308a0cf490SDiego Santa Cruz bool part_completed; 1031272cc70bSAndy Fleming 1032d52ebf10SThomas Chou #ifdef CONFIG_MMC_SPI_CRC_ON 1033d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 1034d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 1035d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R1; 1036d52ebf10SThomas Chou cmd.cmdarg = 1; 1037d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 1038d52ebf10SThomas Chou 1039d52ebf10SThomas Chou if (err) 1040d52ebf10SThomas Chou return err; 1041d52ebf10SThomas Chou } 1042d52ebf10SThomas Chou #endif 1043d52ebf10SThomas Chou 1044272cc70bSAndy Fleming /* Put the Card in Identify Mode */ 1045d52ebf10SThomas Chou cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 1046d52ebf10SThomas Chou MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 1047272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 1048272cc70bSAndy Fleming cmd.cmdarg = 0; 1049272cc70bSAndy Fleming 1050272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1051272cc70bSAndy Fleming 1052272cc70bSAndy Fleming if (err) 1053272cc70bSAndy Fleming return err; 1054272cc70bSAndy Fleming 1055272cc70bSAndy Fleming memcpy(mmc->cid, cmd.response, 16); 1056272cc70bSAndy Fleming 1057272cc70bSAndy Fleming /* 1058272cc70bSAndy Fleming * For MMC cards, set the Relative Address. 1059272cc70bSAndy Fleming * For SD cards, get the Relatvie Address. 1060272cc70bSAndy Fleming * This also puts the cards into Standby State 1061272cc70bSAndy Fleming */ 1062d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1063272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 1064272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1065272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R6; 1066272cc70bSAndy Fleming 1067272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1068272cc70bSAndy Fleming 1069272cc70bSAndy Fleming if (err) 1070272cc70bSAndy Fleming return err; 1071272cc70bSAndy Fleming 1072272cc70bSAndy Fleming if (IS_SD(mmc)) 1073998be3ddSRabin Vincent mmc->rca = (cmd.response[0] >> 16) & 0xffff; 1074d52ebf10SThomas Chou } 1075272cc70bSAndy Fleming 1076272cc70bSAndy Fleming /* Get the Card-Specific Data */ 1077272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_CSD; 1078272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 1079272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1080272cc70bSAndy Fleming 1081272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1082272cc70bSAndy Fleming 10835d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 10845d4fc8d9SRaffaele Recalcati mmc_send_status(mmc, timeout); 10855d4fc8d9SRaffaele Recalcati 1086272cc70bSAndy Fleming if (err) 1087272cc70bSAndy Fleming return err; 1088272cc70bSAndy Fleming 1089998be3ddSRabin Vincent mmc->csd[0] = cmd.response[0]; 1090998be3ddSRabin Vincent mmc->csd[1] = cmd.response[1]; 1091998be3ddSRabin Vincent mmc->csd[2] = cmd.response[2]; 1092998be3ddSRabin Vincent mmc->csd[3] = cmd.response[3]; 1093272cc70bSAndy Fleming 1094272cc70bSAndy Fleming if (mmc->version == MMC_VERSION_UNKNOWN) { 10950b453ffeSRabin Vincent int version = (cmd.response[0] >> 26) & 0xf; 1096272cc70bSAndy Fleming 1097272cc70bSAndy Fleming switch (version) { 1098272cc70bSAndy Fleming case 0: 1099272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 1100272cc70bSAndy Fleming break; 1101272cc70bSAndy Fleming case 1: 1102272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_4; 1103272cc70bSAndy Fleming break; 1104272cc70bSAndy Fleming case 2: 1105272cc70bSAndy Fleming mmc->version = MMC_VERSION_2_2; 1106272cc70bSAndy Fleming break; 1107272cc70bSAndy Fleming case 3: 1108272cc70bSAndy Fleming mmc->version = MMC_VERSION_3; 1109272cc70bSAndy Fleming break; 1110272cc70bSAndy Fleming case 4: 1111272cc70bSAndy Fleming mmc->version = MMC_VERSION_4; 1112272cc70bSAndy Fleming break; 1113272cc70bSAndy Fleming default: 1114272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 1115272cc70bSAndy Fleming break; 1116272cc70bSAndy Fleming } 1117272cc70bSAndy Fleming } 1118272cc70bSAndy Fleming 1119272cc70bSAndy Fleming /* divide frequency by 10, since the mults are 10x bigger */ 11200b453ffeSRabin Vincent freq = fbase[(cmd.response[0] & 0x7)]; 11210b453ffeSRabin Vincent mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 1122272cc70bSAndy Fleming 1123272cc70bSAndy Fleming mmc->tran_speed = freq * mult; 1124272cc70bSAndy Fleming 1125ab71188cSMarkus Niebel mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 1126998be3ddSRabin Vincent mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 1127272cc70bSAndy Fleming 1128272cc70bSAndy Fleming if (IS_SD(mmc)) 1129272cc70bSAndy Fleming mmc->write_bl_len = mmc->read_bl_len; 1130272cc70bSAndy Fleming else 1131998be3ddSRabin Vincent mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 1132272cc70bSAndy Fleming 1133272cc70bSAndy Fleming if (mmc->high_capacity) { 1134272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3f) << 16 1135272cc70bSAndy Fleming | (mmc->csd[2] & 0xffff0000) >> 16; 1136272cc70bSAndy Fleming cmult = 8; 1137272cc70bSAndy Fleming } else { 1138272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3ff) << 2 1139272cc70bSAndy Fleming | (mmc->csd[2] & 0xc0000000) >> 30; 1140272cc70bSAndy Fleming cmult = (mmc->csd[2] & 0x00038000) >> 15; 1141272cc70bSAndy Fleming } 1142272cc70bSAndy Fleming 1143f866a46dSStephen Warren mmc->capacity_user = (csize + 1) << (cmult + 2); 1144f866a46dSStephen Warren mmc->capacity_user *= mmc->read_bl_len; 1145f866a46dSStephen Warren mmc->capacity_boot = 0; 1146f866a46dSStephen Warren mmc->capacity_rpmb = 0; 1147f866a46dSStephen Warren for (i = 0; i < 4; i++) 1148f866a46dSStephen Warren mmc->capacity_gp[i] = 0; 1149272cc70bSAndy Fleming 11508bfa195eSSimon Glass if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 11518bfa195eSSimon Glass mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 1152272cc70bSAndy Fleming 11538bfa195eSSimon Glass if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 11548bfa195eSSimon Glass mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 1155272cc70bSAndy Fleming 1156ab71188cSMarkus Niebel if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 1157ab71188cSMarkus Niebel cmd.cmdidx = MMC_CMD_SET_DSR; 1158ab71188cSMarkus Niebel cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 1159ab71188cSMarkus Niebel cmd.resp_type = MMC_RSP_NONE; 1160ab71188cSMarkus Niebel if (mmc_send_cmd(mmc, &cmd, NULL)) 1161ab71188cSMarkus Niebel printf("MMC: SET_DSR failed\n"); 1162ab71188cSMarkus Niebel } 1163ab71188cSMarkus Niebel 1164272cc70bSAndy Fleming /* Select the card, and put it into Transfer Mode */ 1165d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1166272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SELECT_CARD; 1167fe8f7066SAjay Bhargav cmd.resp_type = MMC_RSP_R1; 1168272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1169272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1170272cc70bSAndy Fleming 1171272cc70bSAndy Fleming if (err) 1172272cc70bSAndy Fleming return err; 1173d52ebf10SThomas Chou } 1174272cc70bSAndy Fleming 1175e6f99a56SLei Wen /* 1176e6f99a56SLei Wen * For SD, its erase group is always one sector 1177e6f99a56SLei Wen */ 1178e6f99a56SLei Wen mmc->erase_grp_size = 1; 1179bc897b1dSLei Wen mmc->part_config = MMCPART_NOAVAILABLE; 1180d23e2c09SSukumar Ghorai if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 1181d23e2c09SSukumar Ghorai /* check ext_csd version and capacity */ 1182d23e2c09SSukumar Ghorai err = mmc_send_ext_csd(mmc, ext_csd); 11839cf199ebSDiego Santa Cruz if (err) 11849cf199ebSDiego Santa Cruz return err; 11859cf199ebSDiego Santa Cruz if (ext_csd[EXT_CSD_REV] >= 2) { 1186639b7827SYoshihiro Shimoda /* 1187639b7827SYoshihiro Shimoda * According to the JEDEC Standard, the value of 1188639b7827SYoshihiro Shimoda * ext_csd's capacity is valid if the value is more 1189639b7827SYoshihiro Shimoda * than 2GB 1190639b7827SYoshihiro Shimoda */ 11910560db18SLei Wen capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 11920560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 11930560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 11940560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 11958bfa195eSSimon Glass capacity *= MMC_MAX_BLOCK_LEN; 1196b1f1e821SŁukasz Majewski if ((capacity >> 20) > 2 * 1024) 1197f866a46dSStephen Warren mmc->capacity_user = capacity; 1198d23e2c09SSukumar Ghorai } 1199bc897b1dSLei Wen 120064f4a619SJaehoon Chung switch (ext_csd[EXT_CSD_REV]) { 120164f4a619SJaehoon Chung case 1: 120264f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_1; 120364f4a619SJaehoon Chung break; 120464f4a619SJaehoon Chung case 2: 120564f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_2; 120664f4a619SJaehoon Chung break; 120764f4a619SJaehoon Chung case 3: 120864f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_3; 120964f4a619SJaehoon Chung break; 121064f4a619SJaehoon Chung case 5: 121164f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_41; 121264f4a619SJaehoon Chung break; 121364f4a619SJaehoon Chung case 6: 121464f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_5; 121564f4a619SJaehoon Chung break; 1216edab723bSMarkus Niebel case 7: 1217edab723bSMarkus Niebel mmc->version = MMC_VERSION_5_0; 1218edab723bSMarkus Niebel break; 121964f4a619SJaehoon Chung } 122064f4a619SJaehoon Chung 12218a0cf490SDiego Santa Cruz /* The partition data may be non-zero but it is only 12228a0cf490SDiego Santa Cruz * effective if PARTITION_SETTING_COMPLETED is set in 12238a0cf490SDiego Santa Cruz * EXT_CSD, so ignore any data if this bit is not set, 12248a0cf490SDiego Santa Cruz * except for enabling the high-capacity group size 12258a0cf490SDiego Santa Cruz * definition (see below). */ 12268a0cf490SDiego Santa Cruz part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] & 12278a0cf490SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED); 12288a0cf490SDiego Santa Cruz 12290c453bb7SDiego Santa Cruz /* store the partition info of emmc */ 12300c453bb7SDiego Santa Cruz mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT]; 12310c453bb7SDiego Santa Cruz if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 12320c453bb7SDiego Santa Cruz ext_csd[EXT_CSD_BOOT_MULT]) 12330c453bb7SDiego Santa Cruz mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 12348a0cf490SDiego Santa Cruz if (part_completed && 12358a0cf490SDiego Santa Cruz (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT)) 12360c453bb7SDiego Santa Cruz mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE]; 12370c453bb7SDiego Santa Cruz 12380c453bb7SDiego Santa Cruz mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17; 12390c453bb7SDiego Santa Cruz 12400c453bb7SDiego Santa Cruz mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17; 12410c453bb7SDiego Santa Cruz 12420c453bb7SDiego Santa Cruz for (i = 0; i < 4; i++) { 12430c453bb7SDiego Santa Cruz int idx = EXT_CSD_GP_SIZE_MULT + i * 3; 12448a0cf490SDiego Santa Cruz uint mult = (ext_csd[idx + 2] << 16) + 12450c453bb7SDiego Santa Cruz (ext_csd[idx + 1] << 8) + ext_csd[idx]; 12468a0cf490SDiego Santa Cruz if (mult) 12478a0cf490SDiego Santa Cruz has_parts = true; 12488a0cf490SDiego Santa Cruz if (!part_completed) 12498a0cf490SDiego Santa Cruz continue; 12508a0cf490SDiego Santa Cruz mmc->capacity_gp[i] = mult; 12510c453bb7SDiego Santa Cruz mmc->capacity_gp[i] *= 12520c453bb7SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 12530c453bb7SDiego Santa Cruz mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1254f8e89d67SDiego Santa Cruz mmc->capacity_gp[i] <<= 19; 12550c453bb7SDiego Santa Cruz } 12560c453bb7SDiego Santa Cruz 12578a0cf490SDiego Santa Cruz if (part_completed) { 1258a7f852b6SDiego Santa Cruz mmc->enh_user_size = 1259a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_SIZE_MULT+2] << 16) + 1260a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_SIZE_MULT+1] << 8) + 1261a7f852b6SDiego Santa Cruz ext_csd[EXT_CSD_ENH_SIZE_MULT]; 1262a7f852b6SDiego Santa Cruz mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 1263a7f852b6SDiego Santa Cruz mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1264a7f852b6SDiego Santa Cruz mmc->enh_user_size <<= 19; 1265a7f852b6SDiego Santa Cruz mmc->enh_user_start = 1266a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+3] << 24) + 1267a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+2] << 16) + 1268a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+1] << 8) + 1269a7f852b6SDiego Santa Cruz ext_csd[EXT_CSD_ENH_START_ADDR]; 1270a7f852b6SDiego Santa Cruz if (mmc->high_capacity) 1271a7f852b6SDiego Santa Cruz mmc->enh_user_start <<= 9; 12728a0cf490SDiego Santa Cruz } 1273a7f852b6SDiego Santa Cruz 1274e6f99a56SLei Wen /* 12751937e5aaSOliver Metz * Host needs to enable ERASE_GRP_DEF bit if device is 12761937e5aaSOliver Metz * partitioned. This bit will be lost every time after a reset 12771937e5aaSOliver Metz * or power off. This will affect erase size. 1278e6f99a56SLei Wen */ 12798a0cf490SDiego Santa Cruz if (part_completed) 12800c453bb7SDiego Santa Cruz has_parts = true; 12811937e5aaSOliver Metz if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 12820c453bb7SDiego Santa Cruz (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) 12830c453bb7SDiego Santa Cruz has_parts = true; 12840c453bb7SDiego Santa Cruz if (has_parts) { 12851937e5aaSOliver Metz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 12861937e5aaSOliver Metz EXT_CSD_ERASE_GROUP_DEF, 1); 12871937e5aaSOliver Metz 12881937e5aaSOliver Metz if (err) 12891937e5aaSOliver Metz return err; 1290021a8055SHannes Petermaier else 1291021a8055SHannes Petermaier ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 1292037dc0abSDiego Santa Cruz } 12931937e5aaSOliver Metz 1294037dc0abSDiego Santa Cruz if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) { 12951937e5aaSOliver Metz /* Read out group size from ext_csd */ 12960560db18SLei Wen mmc->erase_grp_size = 1297a4ff9f83SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 1298d7b29129SMarkus Niebel /* 1299d7b29129SMarkus Niebel * if high capacity and partition setting completed 1300d7b29129SMarkus Niebel * SEC_COUNT is valid even if it is smaller than 2 GiB 1301d7b29129SMarkus Niebel * JEDEC Standard JESD84-B45, 6.2.4 1302d7b29129SMarkus Niebel */ 13038a0cf490SDiego Santa Cruz if (mmc->high_capacity && part_completed) { 1304d7b29129SMarkus Niebel capacity = (ext_csd[EXT_CSD_SEC_CNT]) | 1305d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) | 1306d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) | 1307d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 3] << 24); 1308d7b29129SMarkus Niebel capacity *= MMC_MAX_BLOCK_LEN; 1309d7b29129SMarkus Niebel mmc->capacity_user = capacity; 1310d7b29129SMarkus Niebel } 13118bfa195eSSimon Glass } else { 13121937e5aaSOliver Metz /* Calculate the group size from the csd value. */ 1313e6f99a56SLei Wen int erase_gsz, erase_gmul; 1314e6f99a56SLei Wen erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1315e6f99a56SLei Wen erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1316e6f99a56SLei Wen mmc->erase_grp_size = (erase_gsz + 1) 1317e6f99a56SLei Wen * (erase_gmul + 1); 1318e6f99a56SLei Wen } 1319037dc0abSDiego Santa Cruz 1320037dc0abSDiego Santa Cruz mmc->hc_wp_grp_size = 1024 1321037dc0abSDiego Santa Cruz * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1322037dc0abSDiego Santa Cruz * ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 13239e41a00bSDiego Santa Cruz 13249e41a00bSDiego Santa Cruz mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 1325f866a46dSStephen Warren } 1326f866a46dSStephen Warren 1327f866a46dSStephen Warren err = mmc_set_capacity(mmc, mmc->part_num); 1328f866a46dSStephen Warren if (err) 1329f866a46dSStephen Warren return err; 1330d23e2c09SSukumar Ghorai 1331272cc70bSAndy Fleming if (IS_SD(mmc)) 1332272cc70bSAndy Fleming err = sd_change_freq(mmc); 1333272cc70bSAndy Fleming else 1334272cc70bSAndy Fleming err = mmc_change_freq(mmc); 1335272cc70bSAndy Fleming 1336272cc70bSAndy Fleming if (err) 1337272cc70bSAndy Fleming return err; 1338272cc70bSAndy Fleming 1339272cc70bSAndy Fleming /* Restrict card's capabilities by what the host can do */ 134093bfd616SPantelis Antoniou mmc->card_caps &= mmc->cfg->host_caps; 1341272cc70bSAndy Fleming 1342272cc70bSAndy Fleming if (IS_SD(mmc)) { 1343272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_4BIT) { 1344272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 1345272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1346272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1347272cc70bSAndy Fleming 1348272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1349272cc70bSAndy Fleming if (err) 1350272cc70bSAndy Fleming return err; 1351272cc70bSAndy Fleming 1352272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1353272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1354272cc70bSAndy Fleming cmd.cmdarg = 2; 1355272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1356272cc70bSAndy Fleming if (err) 1357272cc70bSAndy Fleming return err; 1358272cc70bSAndy Fleming 1359272cc70bSAndy Fleming mmc_set_bus_width(mmc, 4); 1360272cc70bSAndy Fleming } 1361272cc70bSAndy Fleming 1362272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) 1363ad5fd922SJaehoon Chung mmc->tran_speed = 50000000; 1364272cc70bSAndy Fleming else 1365ad5fd922SJaehoon Chung mmc->tran_speed = 25000000; 1366fc5b32fbSAndrew Gabbasov } else if (mmc->version >= MMC_VERSION_4) { 1367fc5b32fbSAndrew Gabbasov /* Only version 4 of MMC supports wider bus widths */ 13687798f6dbSAndy Fleming int idx; 13697798f6dbSAndy Fleming 13707798f6dbSAndy Fleming /* An array of possible bus widths in order of preference */ 13717798f6dbSAndy Fleming static unsigned ext_csd_bits[] = { 1372d22e3d46SJaehoon Chung EXT_CSD_DDR_BUS_WIDTH_8, 1373d22e3d46SJaehoon Chung EXT_CSD_DDR_BUS_WIDTH_4, 13747798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_8, 13757798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_4, 13767798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_1, 13777798f6dbSAndy Fleming }; 13787798f6dbSAndy Fleming 13797798f6dbSAndy Fleming /* An array to map CSD bus widths to host cap bits */ 13807798f6dbSAndy Fleming static unsigned ext_to_hostcaps[] = { 1381786e8f81SAndrew Gabbasov [EXT_CSD_DDR_BUS_WIDTH_4] = 1382786e8f81SAndrew Gabbasov MMC_MODE_DDR_52MHz | MMC_MODE_4BIT, 1383786e8f81SAndrew Gabbasov [EXT_CSD_DDR_BUS_WIDTH_8] = 1384786e8f81SAndrew Gabbasov MMC_MODE_DDR_52MHz | MMC_MODE_8BIT, 13857798f6dbSAndy Fleming [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT, 13867798f6dbSAndy Fleming [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT, 13877798f6dbSAndy Fleming }; 13887798f6dbSAndy Fleming 13897798f6dbSAndy Fleming /* An array to map chosen bus width to an integer */ 13907798f6dbSAndy Fleming static unsigned widths[] = { 1391d22e3d46SJaehoon Chung 8, 4, 8, 4, 1, 13927798f6dbSAndy Fleming }; 13937798f6dbSAndy Fleming 13947798f6dbSAndy Fleming for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) { 13957798f6dbSAndy Fleming unsigned int extw = ext_csd_bits[idx]; 1396786e8f81SAndrew Gabbasov unsigned int caps = ext_to_hostcaps[extw]; 13977798f6dbSAndy Fleming 13987798f6dbSAndy Fleming /* 1399bf477073SAndrew Gabbasov * If the bus width is still not changed, 1400bf477073SAndrew Gabbasov * don't try to set the default again. 1401bf477073SAndrew Gabbasov * Otherwise, recover from switch attempts 1402bf477073SAndrew Gabbasov * by switching to 1-bit bus width. 1403bf477073SAndrew Gabbasov */ 1404bf477073SAndrew Gabbasov if (extw == EXT_CSD_BUS_WIDTH_1 && 1405bf477073SAndrew Gabbasov mmc->bus_width == 1) { 1406bf477073SAndrew Gabbasov err = 0; 1407bf477073SAndrew Gabbasov break; 1408bf477073SAndrew Gabbasov } 1409bf477073SAndrew Gabbasov 1410bf477073SAndrew Gabbasov /* 1411786e8f81SAndrew Gabbasov * Check to make sure the card and controller support 1412786e8f81SAndrew Gabbasov * these capabilities 14137798f6dbSAndy Fleming */ 1414786e8f81SAndrew Gabbasov if ((mmc->card_caps & caps) != caps) 14157798f6dbSAndy Fleming continue; 14167798f6dbSAndy Fleming 1417272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 14187798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH, extw); 1419272cc70bSAndy Fleming 1420272cc70bSAndy Fleming if (err) 14214137894eSLei Wen continue; 1422272cc70bSAndy Fleming 1423786e8f81SAndrew Gabbasov mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0; 14247798f6dbSAndy Fleming mmc_set_bus_width(mmc, widths[idx]); 1425272cc70bSAndy Fleming 14264137894eSLei Wen err = mmc_send_ext_csd(mmc, test_csd); 1427272cc70bSAndy Fleming 1428786e8f81SAndrew Gabbasov if (err) 1429786e8f81SAndrew Gabbasov continue; 1430786e8f81SAndrew Gabbasov 1431786e8f81SAndrew Gabbasov /* Only compare read only fields */ 1432786e8f81SAndrew Gabbasov if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] 1433786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_PARTITIONING_SUPPORT] && 1434786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_HC_WP_GRP_SIZE] 1435786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_HC_WP_GRP_SIZE] && 1436786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_REV] 1437786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_REV] && 1438786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1439786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] && 1440786e8f81SAndrew Gabbasov memcmp(&ext_csd[EXT_CSD_SEC_CNT], 1441786e8f81SAndrew Gabbasov &test_csd[EXT_CSD_SEC_CNT], 4) == 0) 14424137894eSLei Wen break; 1443786e8f81SAndrew Gabbasov else 1444786e8f81SAndrew Gabbasov err = SWITCH_ERR; 14454137894eSLei Wen } 1446786e8f81SAndrew Gabbasov 1447786e8f81SAndrew Gabbasov if (err) 1448786e8f81SAndrew Gabbasov return err; 1449272cc70bSAndy Fleming 1450272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) { 1451272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS_52MHz) 1452ad5fd922SJaehoon Chung mmc->tran_speed = 52000000; 1453272cc70bSAndy Fleming else 1454ad5fd922SJaehoon Chung mmc->tran_speed = 26000000; 1455272cc70bSAndy Fleming } 1456ad5fd922SJaehoon Chung } 1457ad5fd922SJaehoon Chung 1458ad5fd922SJaehoon Chung mmc_set_clock(mmc, mmc->tran_speed); 1459272cc70bSAndy Fleming 14605af8f45cSAndrew Gabbasov /* Fix the block length for DDR mode */ 14615af8f45cSAndrew Gabbasov if (mmc->ddr_mode) { 14625af8f45cSAndrew Gabbasov mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 14635af8f45cSAndrew Gabbasov mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 14645af8f45cSAndrew Gabbasov } 14655af8f45cSAndrew Gabbasov 1466272cc70bSAndy Fleming /* fill in device description */ 1467272cc70bSAndy Fleming mmc->block_dev.lun = 0; 1468272cc70bSAndy Fleming mmc->block_dev.type = 0; 1469272cc70bSAndy Fleming mmc->block_dev.blksz = mmc->read_bl_len; 14700472fbfdSEgbert Eich mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz); 14719b1f942cSRabin Vincent mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 1472*fc011f64SSjoerd Simons #if !defined(CONFIG_SPL_BUILD) || \ 1473*fc011f64SSjoerd Simons (defined(CONFIG_SPL_LIBCOMMON_SUPPORT) && \ 1474*fc011f64SSjoerd Simons !defined(CONFIG_USE_TINY_PRINTF)) 1475babce5f6STaylor Hutt sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x", 1476babce5f6STaylor Hutt mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 1477babce5f6STaylor Hutt (mmc->cid[3] >> 16) & 0xffff); 1478babce5f6STaylor Hutt sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 14790b453ffeSRabin Vincent (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1480babce5f6STaylor Hutt (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 1481babce5f6STaylor Hutt (mmc->cid[2] >> 24) & 0xff); 1482babce5f6STaylor Hutt sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 1483babce5f6STaylor Hutt (mmc->cid[2] >> 16) & 0xf); 148456196826SPaul Burton #else 148556196826SPaul Burton mmc->block_dev.vendor[0] = 0; 148656196826SPaul Burton mmc->block_dev.product[0] = 0; 148756196826SPaul Burton mmc->block_dev.revision[0] = 0; 148856196826SPaul Burton #endif 1489122efd43SMikhail Kshevetskiy #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 1490272cc70bSAndy Fleming init_part(&mmc->block_dev); 1491122efd43SMikhail Kshevetskiy #endif 1492272cc70bSAndy Fleming 1493272cc70bSAndy Fleming return 0; 1494272cc70bSAndy Fleming } 1495272cc70bSAndy Fleming 1496fdbb873eSKim Phillips static int mmc_send_if_cond(struct mmc *mmc) 1497272cc70bSAndy Fleming { 1498272cc70bSAndy Fleming struct mmc_cmd cmd; 1499272cc70bSAndy Fleming int err; 1500272cc70bSAndy Fleming 1501272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_IF_COND; 1502272cc70bSAndy Fleming /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 150393bfd616SPantelis Antoniou cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa; 1504272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R7; 1505272cc70bSAndy Fleming 1506272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1507272cc70bSAndy Fleming 1508272cc70bSAndy Fleming if (err) 1509272cc70bSAndy Fleming return err; 1510272cc70bSAndy Fleming 1511998be3ddSRabin Vincent if ((cmd.response[0] & 0xff) != 0xaa) 1512272cc70bSAndy Fleming return UNUSABLE_ERR; 1513272cc70bSAndy Fleming else 1514272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 1515272cc70bSAndy Fleming 1516272cc70bSAndy Fleming return 0; 1517272cc70bSAndy Fleming } 1518272cc70bSAndy Fleming 151993bfd616SPantelis Antoniou /* not used any more */ 152093bfd616SPantelis Antoniou int __deprecated mmc_register(struct mmc *mmc) 1521272cc70bSAndy Fleming { 152293bfd616SPantelis Antoniou #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 152393bfd616SPantelis Antoniou printf("%s is deprecated! use mmc_create() instead.\n", __func__); 152493bfd616SPantelis Antoniou #endif 152593bfd616SPantelis Antoniou return -1; 152693bfd616SPantelis Antoniou } 152793bfd616SPantelis Antoniou 152893bfd616SPantelis Antoniou struct mmc *mmc_create(const struct mmc_config *cfg, void *priv) 152993bfd616SPantelis Antoniou { 153093bfd616SPantelis Antoniou struct mmc *mmc; 153193bfd616SPantelis Antoniou 153293bfd616SPantelis Antoniou /* quick validation */ 153393bfd616SPantelis Antoniou if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL || 153493bfd616SPantelis Antoniou cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0) 153593bfd616SPantelis Antoniou return NULL; 153693bfd616SPantelis Antoniou 153793bfd616SPantelis Antoniou mmc = calloc(1, sizeof(*mmc)); 153893bfd616SPantelis Antoniou if (mmc == NULL) 153993bfd616SPantelis Antoniou return NULL; 154093bfd616SPantelis Antoniou 154193bfd616SPantelis Antoniou mmc->cfg = cfg; 154293bfd616SPantelis Antoniou mmc->priv = priv; 154393bfd616SPantelis Antoniou 154493bfd616SPantelis Antoniou /* the following chunk was mmc_register() */ 154593bfd616SPantelis Antoniou 1546ab71188cSMarkus Niebel /* Setup dsr related values */ 1547ab71188cSMarkus Niebel mmc->dsr_imp = 0; 1548ab71188cSMarkus Niebel mmc->dsr = 0xffffffff; 1549272cc70bSAndy Fleming /* Setup the universal parts of the block interface just once */ 1550272cc70bSAndy Fleming mmc->block_dev.if_type = IF_TYPE_MMC; 1551272cc70bSAndy Fleming mmc->block_dev.dev = cur_dev_num++; 1552272cc70bSAndy Fleming mmc->block_dev.removable = 1; 1553272cc70bSAndy Fleming mmc->block_dev.block_read = mmc_bread; 1554272cc70bSAndy Fleming mmc->block_dev.block_write = mmc_bwrite; 1555e6f99a56SLei Wen mmc->block_dev.block_erase = mmc_berase; 155693bfd616SPantelis Antoniou 155793bfd616SPantelis Antoniou /* setup initial part type */ 155893bfd616SPantelis Antoniou mmc->block_dev.part_type = mmc->cfg->part_type; 1559272cc70bSAndy Fleming 1560272cc70bSAndy Fleming INIT_LIST_HEAD(&mmc->link); 1561272cc70bSAndy Fleming 1562272cc70bSAndy Fleming list_add_tail(&mmc->link, &mmc_devices); 1563272cc70bSAndy Fleming 156493bfd616SPantelis Antoniou return mmc; 156593bfd616SPantelis Antoniou } 156693bfd616SPantelis Antoniou 156793bfd616SPantelis Antoniou void mmc_destroy(struct mmc *mmc) 156893bfd616SPantelis Antoniou { 156993bfd616SPantelis Antoniou /* only freeing memory for now */ 157093bfd616SPantelis Antoniou free(mmc); 1571272cc70bSAndy Fleming } 1572272cc70bSAndy Fleming 1573df3fc526SMatthew McClintock #ifdef CONFIG_PARTITIONS 1574272cc70bSAndy Fleming block_dev_desc_t *mmc_get_dev(int dev) 1575272cc70bSAndy Fleming { 1576272cc70bSAndy Fleming struct mmc *mmc = find_mmc_device(dev); 15776bb4b4bcSBenoît Thébaudeau if (!mmc || mmc_init(mmc)) 157840242bc3SŁukasz Majewski return NULL; 1579272cc70bSAndy Fleming 158040242bc3SŁukasz Majewski return &mmc->block_dev; 1581272cc70bSAndy Fleming } 1582df3fc526SMatthew McClintock #endif 1583272cc70bSAndy Fleming 158495de9ab2SPaul Kocialkowski /* board-specific MMC power initializations. */ 158595de9ab2SPaul Kocialkowski __weak void board_mmc_power_init(void) 158695de9ab2SPaul Kocialkowski { 158795de9ab2SPaul Kocialkowski } 158895de9ab2SPaul Kocialkowski 1589e9550449SChe-Liang Chiou int mmc_start_init(struct mmc *mmc) 1590272cc70bSAndy Fleming { 1591afd5932bSMacpaul Lin int err; 1592272cc70bSAndy Fleming 1593ab769f22SPantelis Antoniou /* we pretend there's no card when init is NULL */ 159493bfd616SPantelis Antoniou if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) { 159548972d90SThierry Reding mmc->has_init = 0; 159656196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 159748972d90SThierry Reding printf("MMC: no card present\n"); 159856196826SPaul Burton #endif 159948972d90SThierry Reding return NO_CARD_ERR; 160048972d90SThierry Reding } 160148972d90SThierry Reding 1602bc897b1dSLei Wen if (mmc->has_init) 1603bc897b1dSLei Wen return 0; 1604bc897b1dSLei Wen 16055a8dbdc6SYangbo Lu #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 16065a8dbdc6SYangbo Lu mmc_adapter_card_type_ident(); 16075a8dbdc6SYangbo Lu #endif 160895de9ab2SPaul Kocialkowski board_mmc_power_init(); 160995de9ab2SPaul Kocialkowski 1610ab769f22SPantelis Antoniou /* made sure it's not NULL earlier */ 161193bfd616SPantelis Antoniou err = mmc->cfg->ops->init(mmc); 1612272cc70bSAndy Fleming 1613272cc70bSAndy Fleming if (err) 1614272cc70bSAndy Fleming return err; 1615272cc70bSAndy Fleming 1616786e8f81SAndrew Gabbasov mmc->ddr_mode = 0; 1617b86b85e2SIlya Yanok mmc_set_bus_width(mmc, 1); 1618b86b85e2SIlya Yanok mmc_set_clock(mmc, 1); 1619b86b85e2SIlya Yanok 1620272cc70bSAndy Fleming /* Reset the Card */ 1621272cc70bSAndy Fleming err = mmc_go_idle(mmc); 1622272cc70bSAndy Fleming 1623272cc70bSAndy Fleming if (err) 1624272cc70bSAndy Fleming return err; 1625272cc70bSAndy Fleming 1626bc897b1dSLei Wen /* The internal partition reset to user partition(0) at every CMD0*/ 1627bc897b1dSLei Wen mmc->part_num = 0; 1628bc897b1dSLei Wen 1629272cc70bSAndy Fleming /* Test for SD version 2 */ 1630272cc70bSAndy Fleming err = mmc_send_if_cond(mmc); 1631272cc70bSAndy Fleming 1632272cc70bSAndy Fleming /* Now try to get the SD card's operating condition */ 1633272cc70bSAndy Fleming err = sd_send_op_cond(mmc); 1634272cc70bSAndy Fleming 1635272cc70bSAndy Fleming /* If the command timed out, we check for an MMC card */ 1636272cc70bSAndy Fleming if (err == TIMEOUT) { 1637272cc70bSAndy Fleming err = mmc_send_op_cond(mmc); 1638272cc70bSAndy Fleming 1639bd47c135SAndrew Gabbasov if (err) { 164056196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1641272cc70bSAndy Fleming printf("Card did not respond to voltage select!\n"); 164256196826SPaul Burton #endif 1643272cc70bSAndy Fleming return UNUSABLE_ERR; 1644272cc70bSAndy Fleming } 1645272cc70bSAndy Fleming } 1646272cc70bSAndy Fleming 1647bd47c135SAndrew Gabbasov if (!err) 1648e9550449SChe-Liang Chiou mmc->init_in_progress = 1; 1649e9550449SChe-Liang Chiou 1650e9550449SChe-Liang Chiou return err; 1651e9550449SChe-Liang Chiou } 1652e9550449SChe-Liang Chiou 1653e9550449SChe-Liang Chiou static int mmc_complete_init(struct mmc *mmc) 1654e9550449SChe-Liang Chiou { 1655e9550449SChe-Liang Chiou int err = 0; 1656e9550449SChe-Liang Chiou 1657bd47c135SAndrew Gabbasov mmc->init_in_progress = 0; 1658e9550449SChe-Liang Chiou if (mmc->op_cond_pending) 1659e9550449SChe-Liang Chiou err = mmc_complete_op_cond(mmc); 1660e9550449SChe-Liang Chiou 1661e9550449SChe-Liang Chiou if (!err) 1662bc897b1dSLei Wen err = mmc_startup(mmc); 1663bc897b1dSLei Wen if (err) 1664bc897b1dSLei Wen mmc->has_init = 0; 1665bc897b1dSLei Wen else 1666bc897b1dSLei Wen mmc->has_init = 1; 1667e9550449SChe-Liang Chiou return err; 1668e9550449SChe-Liang Chiou } 1669e9550449SChe-Liang Chiou 1670e9550449SChe-Liang Chiou int mmc_init(struct mmc *mmc) 1671e9550449SChe-Liang Chiou { 1672bd47c135SAndrew Gabbasov int err = 0; 1673d803fea5SMateusz Zalega unsigned start; 1674e9550449SChe-Liang Chiou 1675e9550449SChe-Liang Chiou if (mmc->has_init) 1676e9550449SChe-Liang Chiou return 0; 1677d803fea5SMateusz Zalega 1678d803fea5SMateusz Zalega start = get_timer(0); 1679d803fea5SMateusz Zalega 1680e9550449SChe-Liang Chiou if (!mmc->init_in_progress) 1681e9550449SChe-Liang Chiou err = mmc_start_init(mmc); 1682e9550449SChe-Liang Chiou 1683bd47c135SAndrew Gabbasov if (!err) 1684e9550449SChe-Liang Chiou err = mmc_complete_init(mmc); 1685e9550449SChe-Liang Chiou debug("%s: %d, time %lu\n", __func__, err, get_timer(start)); 1686bc897b1dSLei Wen return err; 1687272cc70bSAndy Fleming } 1688272cc70bSAndy Fleming 1689ab71188cSMarkus Niebel int mmc_set_dsr(struct mmc *mmc, u16 val) 1690ab71188cSMarkus Niebel { 1691ab71188cSMarkus Niebel mmc->dsr = val; 1692ab71188cSMarkus Niebel return 0; 1693ab71188cSMarkus Niebel } 1694ab71188cSMarkus Niebel 1695cee9ab7cSJeroen Hofstee /* CPU-specific MMC initializations */ 1696cee9ab7cSJeroen Hofstee __weak int cpu_mmc_init(bd_t *bis) 1697272cc70bSAndy Fleming { 1698272cc70bSAndy Fleming return -1; 1699272cc70bSAndy Fleming } 1700272cc70bSAndy Fleming 1701cee9ab7cSJeroen Hofstee /* board-specific MMC initializations. */ 1702cee9ab7cSJeroen Hofstee __weak int board_mmc_init(bd_t *bis) 1703cee9ab7cSJeroen Hofstee { 1704cee9ab7cSJeroen Hofstee return -1; 1705cee9ab7cSJeroen Hofstee } 1706272cc70bSAndy Fleming 170756196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 170856196826SPaul Burton 1709272cc70bSAndy Fleming void print_mmc_devices(char separator) 1710272cc70bSAndy Fleming { 1711272cc70bSAndy Fleming struct mmc *m; 1712272cc70bSAndy Fleming struct list_head *entry; 171334dd9284SPrzemyslaw Marczak char *mmc_type; 1714272cc70bSAndy Fleming 1715272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 1716272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 1717272cc70bSAndy Fleming 171834dd9284SPrzemyslaw Marczak if (m->has_init) 171934dd9284SPrzemyslaw Marczak mmc_type = IS_SD(m) ? "SD" : "eMMC"; 172034dd9284SPrzemyslaw Marczak else 172134dd9284SPrzemyslaw Marczak mmc_type = NULL; 172234dd9284SPrzemyslaw Marczak 172393bfd616SPantelis Antoniou printf("%s: %d", m->cfg->name, m->block_dev.dev); 172434dd9284SPrzemyslaw Marczak if (mmc_type) 172534dd9284SPrzemyslaw Marczak printf(" (%s)", mmc_type); 1726272cc70bSAndy Fleming 1727e75eaf10SLubomir Popov if (entry->next != &mmc_devices) { 1728272cc70bSAndy Fleming printf("%c", separator); 1729e75eaf10SLubomir Popov if (separator != '\n') 1730e75eaf10SLubomir Popov puts (" "); 1731e75eaf10SLubomir Popov } 1732272cc70bSAndy Fleming } 1733272cc70bSAndy Fleming 1734272cc70bSAndy Fleming printf("\n"); 1735272cc70bSAndy Fleming } 1736272cc70bSAndy Fleming 173756196826SPaul Burton #else 173856196826SPaul Burton void print_mmc_devices(char separator) { } 173956196826SPaul Burton #endif 174056196826SPaul Burton 1741ea6ebe21SLei Wen int get_mmc_num(void) 1742ea6ebe21SLei Wen { 1743ea6ebe21SLei Wen return cur_dev_num; 1744ea6ebe21SLei Wen } 1745ea6ebe21SLei Wen 1746e9550449SChe-Liang Chiou void mmc_set_preinit(struct mmc *mmc, int preinit) 1747e9550449SChe-Liang Chiou { 1748e9550449SChe-Liang Chiou mmc->preinit = preinit; 1749e9550449SChe-Liang Chiou } 1750e9550449SChe-Liang Chiou 1751e9550449SChe-Liang Chiou static void do_preinit(void) 1752e9550449SChe-Liang Chiou { 1753e9550449SChe-Liang Chiou struct mmc *m; 1754e9550449SChe-Liang Chiou struct list_head *entry; 1755e9550449SChe-Liang Chiou 1756e9550449SChe-Liang Chiou list_for_each(entry, &mmc_devices) { 1757e9550449SChe-Liang Chiou m = list_entry(entry, struct mmc, link); 1758e9550449SChe-Liang Chiou 17595a8dbdc6SYangbo Lu #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 17605a8dbdc6SYangbo Lu mmc_set_preinit(m, 1); 17615a8dbdc6SYangbo Lu #endif 1762e9550449SChe-Liang Chiou if (m->preinit) 1763e9550449SChe-Liang Chiou mmc_start_init(m); 1764e9550449SChe-Liang Chiou } 1765e9550449SChe-Liang Chiou } 1766e9550449SChe-Liang Chiou 17678e3332e2SSjoerd Simons #if defined(CONFIG_DM_MMC) && defined(CONFIG_SPL_BUILD) 17688e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 17698e3332e2SSjoerd Simons { 17708e3332e2SSjoerd Simons return 0; 17718e3332e2SSjoerd Simons } 17728e3332e2SSjoerd Simons #elif defined(CONFIG_DM_MMC) 17738e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 17748e3332e2SSjoerd Simons { 17758e3332e2SSjoerd Simons int ret; 17768e3332e2SSjoerd Simons struct uclass *uc; 17778e3332e2SSjoerd Simons struct udevice *m; 17788e3332e2SSjoerd Simons 17798e3332e2SSjoerd Simons ret = uclass_get(UCLASS_MMC, &uc); 17808e3332e2SSjoerd Simons if (ret) 17818e3332e2SSjoerd Simons return ret; 17828e3332e2SSjoerd Simons 17838e3332e2SSjoerd Simons uclass_foreach_dev(m, uc) { 17848e3332e2SSjoerd Simons ret = device_probe(m); 17858e3332e2SSjoerd Simons if (ret) 17868e3332e2SSjoerd Simons printf("%s - probe failed: %d\n", m->name, ret); 17878e3332e2SSjoerd Simons } 17888e3332e2SSjoerd Simons 17898e3332e2SSjoerd Simons return 0; 17908e3332e2SSjoerd Simons } 17918e3332e2SSjoerd Simons #else 17928e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 17938e3332e2SSjoerd Simons { 17948e3332e2SSjoerd Simons if (board_mmc_init(bis) < 0) 17958e3332e2SSjoerd Simons cpu_mmc_init(bis); 17968e3332e2SSjoerd Simons 17978e3332e2SSjoerd Simons return 0; 17988e3332e2SSjoerd Simons } 17998e3332e2SSjoerd Simons #endif 1800e9550449SChe-Liang Chiou 1801272cc70bSAndy Fleming int mmc_initialize(bd_t *bis) 1802272cc70bSAndy Fleming { 18031b26bab1SDaniel Kochmański static int initialized = 0; 18048e3332e2SSjoerd Simons int ret; 18051b26bab1SDaniel Kochmański if (initialized) /* Avoid initializing mmc multiple times */ 18061b26bab1SDaniel Kochmański return 0; 18071b26bab1SDaniel Kochmański initialized = 1; 18081b26bab1SDaniel Kochmański 1809272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc_devices); 1810272cc70bSAndy Fleming cur_dev_num = 0; 1811272cc70bSAndy Fleming 18128e3332e2SSjoerd Simons ret = mmc_probe(bis); 18138e3332e2SSjoerd Simons if (ret) 18148e3332e2SSjoerd Simons return ret; 1815272cc70bSAndy Fleming 1816bb0dc108SYing Zhang #ifndef CONFIG_SPL_BUILD 1817272cc70bSAndy Fleming print_mmc_devices(','); 1818bb0dc108SYing Zhang #endif 1819272cc70bSAndy Fleming 1820e9550449SChe-Liang Chiou do_preinit(); 1821272cc70bSAndy Fleming return 0; 1822272cc70bSAndy Fleming } 18233690d6d6SAmar 18243690d6d6SAmar #ifdef CONFIG_SUPPORT_EMMC_BOOT 18253690d6d6SAmar /* 18263690d6d6SAmar * This function changes the size of boot partition and the size of rpmb 18273690d6d6SAmar * partition present on EMMC devices. 18283690d6d6SAmar * 18293690d6d6SAmar * Input Parameters: 18303690d6d6SAmar * struct *mmc: pointer for the mmc device strcuture 18313690d6d6SAmar * bootsize: size of boot partition 18323690d6d6SAmar * rpmbsize: size of rpmb partition 18333690d6d6SAmar * 18343690d6d6SAmar * Returns 0 on success. 18353690d6d6SAmar */ 18363690d6d6SAmar 18373690d6d6SAmar int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize, 18383690d6d6SAmar unsigned long rpmbsize) 18393690d6d6SAmar { 18403690d6d6SAmar int err; 18413690d6d6SAmar struct mmc_cmd cmd; 18423690d6d6SAmar 18433690d6d6SAmar /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */ 18443690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 18453690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 18463690d6d6SAmar cmd.cmdarg = MMC_CMD62_ARG1; 18473690d6d6SAmar 18483690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 18493690d6d6SAmar if (err) { 18503690d6d6SAmar debug("mmc_boot_partition_size_change: Error1 = %d\n", err); 18513690d6d6SAmar return err; 18523690d6d6SAmar } 18533690d6d6SAmar 18543690d6d6SAmar /* Boot partition changing mode */ 18553690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 18563690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 18573690d6d6SAmar cmd.cmdarg = MMC_CMD62_ARG2; 18583690d6d6SAmar 18593690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 18603690d6d6SAmar if (err) { 18613690d6d6SAmar debug("mmc_boot_partition_size_change: Error2 = %d\n", err); 18623690d6d6SAmar return err; 18633690d6d6SAmar } 18643690d6d6SAmar /* boot partition size is multiple of 128KB */ 18653690d6d6SAmar bootsize = (bootsize * 1024) / 128; 18663690d6d6SAmar 18673690d6d6SAmar /* Arg: boot partition size */ 18683690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 18693690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 18703690d6d6SAmar cmd.cmdarg = bootsize; 18713690d6d6SAmar 18723690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 18733690d6d6SAmar if (err) { 18743690d6d6SAmar debug("mmc_boot_partition_size_change: Error3 = %d\n", err); 18753690d6d6SAmar return err; 18763690d6d6SAmar } 18773690d6d6SAmar /* RPMB partition size is multiple of 128KB */ 18783690d6d6SAmar rpmbsize = (rpmbsize * 1024) / 128; 18793690d6d6SAmar /* Arg: RPMB partition size */ 18803690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 18813690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 18823690d6d6SAmar cmd.cmdarg = rpmbsize; 18833690d6d6SAmar 18843690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 18853690d6d6SAmar if (err) { 18863690d6d6SAmar debug("mmc_boot_partition_size_change: Error4 = %d\n", err); 18873690d6d6SAmar return err; 18883690d6d6SAmar } 18893690d6d6SAmar return 0; 18903690d6d6SAmar } 18913690d6d6SAmar 18923690d6d6SAmar /* 18935a99b9deSTom Rini * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH 18945a99b9deSTom Rini * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH 18955a99b9deSTom Rini * and BOOT_MODE. 18965a99b9deSTom Rini * 18975a99b9deSTom Rini * Returns 0 on success. 18985a99b9deSTom Rini */ 18995a99b9deSTom Rini int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode) 19005a99b9deSTom Rini { 19015a99b9deSTom Rini int err; 19025a99b9deSTom Rini 19035a99b9deSTom Rini err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH, 19045a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) | 19055a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) | 19065a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width)); 19075a99b9deSTom Rini 19085a99b9deSTom Rini if (err) 19095a99b9deSTom Rini return err; 19105a99b9deSTom Rini return 0; 19115a99b9deSTom Rini } 19125a99b9deSTom Rini 19135a99b9deSTom Rini /* 1914792970b0STom Rini * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG) 1915792970b0STom Rini * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and 1916792970b0STom Rini * PARTITION_ACCESS. 1917792970b0STom Rini * 1918792970b0STom Rini * Returns 0 on success. 1919792970b0STom Rini */ 1920792970b0STom Rini int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access) 1921792970b0STom Rini { 1922792970b0STom Rini int err; 1923792970b0STom Rini 1924792970b0STom Rini err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 1925792970b0STom Rini EXT_CSD_BOOT_ACK(ack) | 1926792970b0STom Rini EXT_CSD_BOOT_PART_NUM(part_num) | 1927792970b0STom Rini EXT_CSD_PARTITION_ACCESS(access)); 1928792970b0STom Rini 1929792970b0STom Rini if (err) 1930792970b0STom Rini return err; 1931792970b0STom Rini return 0; 1932792970b0STom Rini } 193333ace362STom Rini 193433ace362STom Rini /* 193533ace362STom Rini * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value 193633ace362STom Rini * for enable. Note that this is a write-once field for non-zero values. 193733ace362STom Rini * 193833ace362STom Rini * Returns 0 on success. 193933ace362STom Rini */ 194033ace362STom Rini int mmc_set_rst_n_function(struct mmc *mmc, u8 enable) 194133ace362STom Rini { 194233ace362STom Rini return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION, 194333ace362STom Rini enable); 194433ace362STom Rini } 19453690d6d6SAmar #endif 1946