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); 647863ce58SBin Meng if (ret) { 657863ce58SBin Meng printf("\t\tRET\t\t\t %d\n", ret); 667863ce58SBin Meng } else { 675db2fe3aSRaffaele Recalcati switch (cmd->resp_type) { 685db2fe3aSRaffaele Recalcati case MMC_RSP_NONE: 695db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_NONE\n"); 705db2fe3aSRaffaele Recalcati break; 715db2fe3aSRaffaele Recalcati case MMC_RSP_R1: 725db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 735db2fe3aSRaffaele Recalcati cmd->response[0]); 745db2fe3aSRaffaele Recalcati break; 755db2fe3aSRaffaele Recalcati case MMC_RSP_R1b: 765db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 775db2fe3aSRaffaele Recalcati cmd->response[0]); 785db2fe3aSRaffaele Recalcati break; 795db2fe3aSRaffaele Recalcati case MMC_RSP_R2: 805db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 815db2fe3aSRaffaele Recalcati cmd->response[0]); 825db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 835db2fe3aSRaffaele Recalcati cmd->response[1]); 845db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 855db2fe3aSRaffaele Recalcati cmd->response[2]); 865db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 875db2fe3aSRaffaele Recalcati cmd->response[3]); 885db2fe3aSRaffaele Recalcati printf("\n"); 895db2fe3aSRaffaele Recalcati printf("\t\t\t\t\tDUMPING DATA\n"); 905db2fe3aSRaffaele Recalcati for (i = 0; i < 4; i++) { 915db2fe3aSRaffaele Recalcati int j; 925db2fe3aSRaffaele Recalcati printf("\t\t\t\t\t%03d - ", i*4); 93146bec79SDirk Behme ptr = (u8 *)&cmd->response[i]; 945db2fe3aSRaffaele Recalcati ptr += 3; 955db2fe3aSRaffaele Recalcati for (j = 0; j < 4; j++) 965db2fe3aSRaffaele Recalcati printf("%02X ", *ptr--); 975db2fe3aSRaffaele Recalcati printf("\n"); 985db2fe3aSRaffaele Recalcati } 995db2fe3aSRaffaele Recalcati break; 1005db2fe3aSRaffaele Recalcati case MMC_RSP_R3: 1015db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 1025db2fe3aSRaffaele Recalcati cmd->response[0]); 1035db2fe3aSRaffaele Recalcati break; 1045db2fe3aSRaffaele Recalcati default: 1055db2fe3aSRaffaele Recalcati printf("\t\tERROR MMC rsp not supported\n"); 1065db2fe3aSRaffaele Recalcati break; 1075db2fe3aSRaffaele Recalcati } 1087863ce58SBin Meng } 1095db2fe3aSRaffaele Recalcati #else 11093bfd616SPantelis Antoniou ret = mmc->cfg->ops->send_cmd(mmc, cmd, data); 1115db2fe3aSRaffaele Recalcati #endif 1128635ff9eSMarek Vasut return ret; 113272cc70bSAndy Fleming } 114272cc70bSAndy Fleming 115da61fa5fSPaul Burton int mmc_send_status(struct mmc *mmc, int timeout) 1165d4fc8d9SRaffaele Recalcati { 1175d4fc8d9SRaffaele Recalcati struct mmc_cmd cmd; 118d617c426SJan Kloetzke int err, retries = 5; 1195d4fc8d9SRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1205d4fc8d9SRaffaele Recalcati int status; 1215d4fc8d9SRaffaele Recalcati #endif 1225d4fc8d9SRaffaele Recalcati 1235d4fc8d9SRaffaele Recalcati cmd.cmdidx = MMC_CMD_SEND_STATUS; 1245d4fc8d9SRaffaele Recalcati cmd.resp_type = MMC_RSP_R1; 125aaf3d41aSMarek Vasut if (!mmc_host_is_spi(mmc)) 126aaf3d41aSMarek Vasut cmd.cmdarg = mmc->rca << 16; 1275d4fc8d9SRaffaele Recalcati 1281677eef4SAndrew Gabbasov while (1) { 1295d4fc8d9SRaffaele Recalcati err = mmc_send_cmd(mmc, &cmd, NULL); 130d617c426SJan Kloetzke if (!err) { 131d617c426SJan Kloetzke if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 132d617c426SJan Kloetzke (cmd.response[0] & MMC_STATUS_CURR_STATE) != 133d617c426SJan Kloetzke MMC_STATE_PRG) 1345d4fc8d9SRaffaele Recalcati break; 135d617c426SJan Kloetzke else if (cmd.response[0] & MMC_STATUS_MASK) { 13656196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 137d617c426SJan Kloetzke printf("Status Error: 0x%08X\n", 138d617c426SJan Kloetzke cmd.response[0]); 13956196826SPaul Burton #endif 140d617c426SJan Kloetzke return COMM_ERR; 141d617c426SJan Kloetzke } 142d617c426SJan Kloetzke } else if (--retries < 0) 143d617c426SJan Kloetzke return err; 1445d4fc8d9SRaffaele Recalcati 1451677eef4SAndrew Gabbasov if (timeout-- <= 0) 1461677eef4SAndrew Gabbasov break; 1475d4fc8d9SRaffaele Recalcati 1481677eef4SAndrew Gabbasov udelay(1000); 1491677eef4SAndrew Gabbasov } 1505d4fc8d9SRaffaele Recalcati 1515db2fe3aSRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1525db2fe3aSRaffaele Recalcati status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 1535db2fe3aSRaffaele Recalcati printf("CURR STATE:%d\n", status); 1545db2fe3aSRaffaele Recalcati #endif 1555b0c942fSJongman Heo if (timeout <= 0) { 15656196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1575d4fc8d9SRaffaele Recalcati printf("Timeout waiting card ready\n"); 15856196826SPaul Burton #endif 1595d4fc8d9SRaffaele Recalcati return TIMEOUT; 1605d4fc8d9SRaffaele Recalcati } 1616b2221b0SAndrew Gabbasov if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR) 1626b2221b0SAndrew Gabbasov return SWITCH_ERR; 1635d4fc8d9SRaffaele Recalcati 1645d4fc8d9SRaffaele Recalcati return 0; 1655d4fc8d9SRaffaele Recalcati } 1665d4fc8d9SRaffaele Recalcati 167da61fa5fSPaul Burton int mmc_set_blocklen(struct mmc *mmc, int len) 168272cc70bSAndy Fleming { 169272cc70bSAndy Fleming struct mmc_cmd cmd; 170272cc70bSAndy Fleming 171786e8f81SAndrew Gabbasov if (mmc->ddr_mode) 172d22e3d46SJaehoon Chung return 0; 173d22e3d46SJaehoon Chung 174272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 175272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 176272cc70bSAndy Fleming cmd.cmdarg = len; 177272cc70bSAndy Fleming 178272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, NULL); 179272cc70bSAndy Fleming } 180272cc70bSAndy Fleming 181272cc70bSAndy Fleming struct mmc *find_mmc_device(int dev_num) 182272cc70bSAndy Fleming { 183272cc70bSAndy Fleming struct mmc *m; 184272cc70bSAndy Fleming struct list_head *entry; 185272cc70bSAndy Fleming 186272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 187272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 188272cc70bSAndy Fleming 189bcce53d0SSimon Glass if (m->block_dev.devnum == dev_num) 190272cc70bSAndy Fleming return m; 191272cc70bSAndy Fleming } 192272cc70bSAndy Fleming 19356196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 194272cc70bSAndy Fleming printf("MMC Device %d not found\n", dev_num); 19556196826SPaul Burton #endif 196272cc70bSAndy Fleming 197272cc70bSAndy Fleming return NULL; 198272cc70bSAndy Fleming } 199272cc70bSAndy Fleming 200ff8fef56SSascha Silbe static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, 201fdbb873eSKim Phillips lbaint_t blkcnt) 202272cc70bSAndy Fleming { 203272cc70bSAndy Fleming struct mmc_cmd cmd; 204272cc70bSAndy Fleming struct mmc_data data; 205272cc70bSAndy Fleming 2064a1a06bcSAlagu Sankar if (blkcnt > 1) 2074a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 2084a1a06bcSAlagu Sankar else 209272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 210272cc70bSAndy Fleming 211272cc70bSAndy Fleming if (mmc->high_capacity) 2124a1a06bcSAlagu Sankar cmd.cmdarg = start; 213272cc70bSAndy Fleming else 2144a1a06bcSAlagu Sankar cmd.cmdarg = start * mmc->read_bl_len; 215272cc70bSAndy Fleming 216272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 217272cc70bSAndy Fleming 218272cc70bSAndy Fleming data.dest = dst; 2194a1a06bcSAlagu Sankar data.blocks = blkcnt; 220272cc70bSAndy Fleming data.blocksize = mmc->read_bl_len; 221272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 222272cc70bSAndy Fleming 2234a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, &data)) 2244a1a06bcSAlagu Sankar return 0; 2254a1a06bcSAlagu Sankar 2264a1a06bcSAlagu Sankar if (blkcnt > 1) { 2274a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 2284a1a06bcSAlagu Sankar cmd.cmdarg = 0; 2294a1a06bcSAlagu Sankar cmd.resp_type = MMC_RSP_R1b; 2304a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, NULL)) { 23156196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 2324a1a06bcSAlagu Sankar printf("mmc fail to send stop cmd\n"); 23356196826SPaul Burton #endif 2344a1a06bcSAlagu Sankar return 0; 2354a1a06bcSAlagu Sankar } 236272cc70bSAndy Fleming } 237272cc70bSAndy Fleming 2384a1a06bcSAlagu Sankar return blkcnt; 239272cc70bSAndy Fleming } 240272cc70bSAndy Fleming 2414101f687SSimon Glass static ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, 2427c4213f6SStephen Warren lbaint_t blkcnt, void *dst) 243272cc70bSAndy Fleming { 244bcce53d0SSimon Glass int dev_num = block_dev->devnum; 245873cc1d7SStephen Warren int err; 2464a1a06bcSAlagu Sankar lbaint_t cur, blocks_todo = blkcnt; 247272cc70bSAndy Fleming 2484a1a06bcSAlagu Sankar if (blkcnt == 0) 2494a1a06bcSAlagu Sankar return 0; 2504a1a06bcSAlagu Sankar 2514a1a06bcSAlagu Sankar struct mmc *mmc = find_mmc_device(dev_num); 252272cc70bSAndy Fleming if (!mmc) 253272cc70bSAndy Fleming return 0; 254272cc70bSAndy Fleming 255873cc1d7SStephen Warren err = mmc_select_hwpart(dev_num, block_dev->hwpart); 256873cc1d7SStephen Warren if (err < 0) 257873cc1d7SStephen Warren return 0; 258873cc1d7SStephen Warren 259d2bf29e3SLei Wen if ((start + blkcnt) > mmc->block_dev.lba) { 26056196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 261ff8fef56SSascha Silbe printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 262d2bf29e3SLei Wen start + blkcnt, mmc->block_dev.lba); 26356196826SPaul Burton #endif 264d2bf29e3SLei Wen return 0; 265d2bf29e3SLei Wen } 266272cc70bSAndy Fleming 26711692991SSimon Glass if (mmc_set_blocklen(mmc, mmc->read_bl_len)) { 26811692991SSimon Glass debug("%s: Failed to set blocklen\n", __func__); 269272cc70bSAndy Fleming return 0; 27011692991SSimon Glass } 271272cc70bSAndy Fleming 2724a1a06bcSAlagu Sankar do { 27393bfd616SPantelis Antoniou cur = (blocks_todo > mmc->cfg->b_max) ? 27493bfd616SPantelis Antoniou mmc->cfg->b_max : blocks_todo; 27511692991SSimon Glass if (mmc_read_blocks(mmc, dst, start, cur) != cur) { 27611692991SSimon Glass debug("%s: Failed to read blocks\n", __func__); 2774a1a06bcSAlagu Sankar return 0; 27811692991SSimon Glass } 2794a1a06bcSAlagu Sankar blocks_todo -= cur; 2804a1a06bcSAlagu Sankar start += cur; 2814a1a06bcSAlagu Sankar dst += cur * mmc->read_bl_len; 2824a1a06bcSAlagu Sankar } while (blocks_todo > 0); 283272cc70bSAndy Fleming 284272cc70bSAndy Fleming return blkcnt; 285272cc70bSAndy Fleming } 286272cc70bSAndy Fleming 287fdbb873eSKim Phillips static int mmc_go_idle(struct mmc *mmc) 288272cc70bSAndy Fleming { 289272cc70bSAndy Fleming struct mmc_cmd cmd; 290272cc70bSAndy Fleming int err; 291272cc70bSAndy Fleming 292272cc70bSAndy Fleming udelay(1000); 293272cc70bSAndy Fleming 294272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 295272cc70bSAndy Fleming cmd.cmdarg = 0; 296272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_NONE; 297272cc70bSAndy Fleming 298272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 299272cc70bSAndy Fleming 300272cc70bSAndy Fleming if (err) 301272cc70bSAndy Fleming return err; 302272cc70bSAndy Fleming 303272cc70bSAndy Fleming udelay(2000); 304272cc70bSAndy Fleming 305272cc70bSAndy Fleming return 0; 306272cc70bSAndy Fleming } 307272cc70bSAndy Fleming 308fdbb873eSKim Phillips static int sd_send_op_cond(struct mmc *mmc) 309272cc70bSAndy Fleming { 310272cc70bSAndy Fleming int timeout = 1000; 311272cc70bSAndy Fleming int err; 312272cc70bSAndy Fleming struct mmc_cmd cmd; 313272cc70bSAndy Fleming 3141677eef4SAndrew Gabbasov while (1) { 315272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 316272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 317272cc70bSAndy Fleming cmd.cmdarg = 0; 318272cc70bSAndy Fleming 319272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 320272cc70bSAndy Fleming 321272cc70bSAndy Fleming if (err) 322272cc70bSAndy Fleming return err; 323272cc70bSAndy Fleming 324272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 325272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 326250de12bSStefano Babic 327250de12bSStefano Babic /* 328250de12bSStefano Babic * Most cards do not answer if some reserved bits 329250de12bSStefano Babic * in the ocr are set. However, Some controller 330250de12bSStefano Babic * can set bit 7 (reserved for low voltages), but 331250de12bSStefano Babic * how to manage low voltages SD card is not yet 332250de12bSStefano Babic * specified. 333250de12bSStefano Babic */ 334d52ebf10SThomas Chou cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 33593bfd616SPantelis Antoniou (mmc->cfg->voltages & 0xff8000); 336272cc70bSAndy Fleming 337272cc70bSAndy Fleming if (mmc->version == SD_VERSION_2) 338272cc70bSAndy Fleming cmd.cmdarg |= OCR_HCS; 339272cc70bSAndy Fleming 340272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 341272cc70bSAndy Fleming 342272cc70bSAndy Fleming if (err) 343272cc70bSAndy Fleming return err; 344272cc70bSAndy Fleming 3451677eef4SAndrew Gabbasov if (cmd.response[0] & OCR_BUSY) 3461677eef4SAndrew Gabbasov break; 347272cc70bSAndy Fleming 3481677eef4SAndrew Gabbasov if (timeout-- <= 0) 349272cc70bSAndy Fleming return UNUSABLE_ERR; 350272cc70bSAndy Fleming 3511677eef4SAndrew Gabbasov udelay(1000); 3521677eef4SAndrew Gabbasov } 3531677eef4SAndrew Gabbasov 354272cc70bSAndy Fleming if (mmc->version != SD_VERSION_2) 355272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 356272cc70bSAndy Fleming 357d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 358d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 359d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 360d52ebf10SThomas Chou cmd.cmdarg = 0; 361d52ebf10SThomas Chou 362d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 363d52ebf10SThomas Chou 364d52ebf10SThomas Chou if (err) 365d52ebf10SThomas Chou return err; 366d52ebf10SThomas Chou } 367d52ebf10SThomas Chou 368998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 369272cc70bSAndy Fleming 370272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 371272cc70bSAndy Fleming mmc->rca = 0; 372272cc70bSAndy Fleming 373272cc70bSAndy Fleming return 0; 374272cc70bSAndy Fleming } 375272cc70bSAndy Fleming 3765289b535SAndrew Gabbasov static int mmc_send_op_cond_iter(struct mmc *mmc, int use_arg) 377272cc70bSAndy Fleming { 3785289b535SAndrew Gabbasov struct mmc_cmd cmd; 379272cc70bSAndy Fleming int err; 380272cc70bSAndy Fleming 3815289b535SAndrew Gabbasov cmd.cmdidx = MMC_CMD_SEND_OP_COND; 3825289b535SAndrew Gabbasov cmd.resp_type = MMC_RSP_R3; 3835289b535SAndrew Gabbasov cmd.cmdarg = 0; 3845a20397bSRob Herring if (use_arg && !mmc_host_is_spi(mmc)) 3855a20397bSRob Herring cmd.cmdarg = OCR_HCS | 38693bfd616SPantelis Antoniou (mmc->cfg->voltages & 387a626c8d4SAndrew Gabbasov (mmc->ocr & OCR_VOLTAGE_MASK)) | 388a626c8d4SAndrew Gabbasov (mmc->ocr & OCR_ACCESS_MODE); 389e9550449SChe-Liang Chiou 3905289b535SAndrew Gabbasov err = mmc_send_cmd(mmc, &cmd, NULL); 391e9550449SChe-Liang Chiou if (err) 392e9550449SChe-Liang Chiou return err; 3935289b535SAndrew Gabbasov mmc->ocr = cmd.response[0]; 394e9550449SChe-Liang Chiou return 0; 395e9550449SChe-Liang Chiou } 396e9550449SChe-Liang Chiou 397750121c3SJeroen Hofstee static int mmc_send_op_cond(struct mmc *mmc) 398e9550449SChe-Liang Chiou { 399e9550449SChe-Liang Chiou int err, i; 400e9550449SChe-Liang Chiou 401272cc70bSAndy Fleming /* Some cards seem to need this */ 402272cc70bSAndy Fleming mmc_go_idle(mmc); 403272cc70bSAndy Fleming 40431cacbabSRaffaele Recalcati /* Asking to the card its capabilities */ 405e9550449SChe-Liang Chiou for (i = 0; i < 2; i++) { 4065289b535SAndrew Gabbasov err = mmc_send_op_cond_iter(mmc, i != 0); 40731cacbabSRaffaele Recalcati if (err) 40831cacbabSRaffaele Recalcati return err; 40931cacbabSRaffaele Recalcati 410e9550449SChe-Liang Chiou /* exit if not busy (flag seems to be inverted) */ 411a626c8d4SAndrew Gabbasov if (mmc->ocr & OCR_BUSY) 412bd47c135SAndrew Gabbasov break; 413e9550449SChe-Liang Chiou } 414bd47c135SAndrew Gabbasov mmc->op_cond_pending = 1; 415bd47c135SAndrew Gabbasov return 0; 416e9550449SChe-Liang Chiou } 41731cacbabSRaffaele Recalcati 418750121c3SJeroen Hofstee static int mmc_complete_op_cond(struct mmc *mmc) 419e9550449SChe-Liang Chiou { 420e9550449SChe-Liang Chiou struct mmc_cmd cmd; 421e9550449SChe-Liang Chiou int timeout = 1000; 422e9550449SChe-Liang Chiou uint start; 423e9550449SChe-Liang Chiou int err; 424e9550449SChe-Liang Chiou 425e9550449SChe-Liang Chiou mmc->op_cond_pending = 0; 426cc17c01fSAndrew Gabbasov if (!(mmc->ocr & OCR_BUSY)) { 427e9550449SChe-Liang Chiou start = get_timer(0); 4281677eef4SAndrew Gabbasov while (1) { 4295289b535SAndrew Gabbasov err = mmc_send_op_cond_iter(mmc, 1); 430272cc70bSAndy Fleming if (err) 431272cc70bSAndy Fleming return err; 4321677eef4SAndrew Gabbasov if (mmc->ocr & OCR_BUSY) 4331677eef4SAndrew Gabbasov break; 434e9550449SChe-Liang Chiou if (get_timer(start) > timeout) 435272cc70bSAndy Fleming return UNUSABLE_ERR; 436e9550449SChe-Liang Chiou udelay(100); 4371677eef4SAndrew Gabbasov } 438cc17c01fSAndrew Gabbasov } 439272cc70bSAndy Fleming 440d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 441d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 442d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 443d52ebf10SThomas Chou cmd.cmdarg = 0; 444d52ebf10SThomas Chou 445d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 446d52ebf10SThomas Chou 447d52ebf10SThomas Chou if (err) 448d52ebf10SThomas Chou return err; 449a626c8d4SAndrew Gabbasov 450a626c8d4SAndrew Gabbasov mmc->ocr = cmd.response[0]; 451d52ebf10SThomas Chou } 452d52ebf10SThomas Chou 453272cc70bSAndy Fleming mmc->version = MMC_VERSION_UNKNOWN; 454272cc70bSAndy Fleming 455272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 456def816a2SStephen Warren mmc->rca = 1; 457272cc70bSAndy Fleming 458272cc70bSAndy Fleming return 0; 459272cc70bSAndy Fleming } 460272cc70bSAndy Fleming 461272cc70bSAndy Fleming 462fdbb873eSKim Phillips static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 463272cc70bSAndy Fleming { 464272cc70bSAndy Fleming struct mmc_cmd cmd; 465272cc70bSAndy Fleming struct mmc_data data; 466272cc70bSAndy Fleming int err; 467272cc70bSAndy Fleming 468272cc70bSAndy Fleming /* Get the Card Status Register */ 469272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 470272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 471272cc70bSAndy Fleming cmd.cmdarg = 0; 472272cc70bSAndy Fleming 473cdfd1ac6SYoshihiro Shimoda data.dest = (char *)ext_csd; 474272cc70bSAndy Fleming data.blocks = 1; 4758bfa195eSSimon Glass data.blocksize = MMC_MAX_BLOCK_LEN; 476272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 477272cc70bSAndy Fleming 478272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 479272cc70bSAndy Fleming 480272cc70bSAndy Fleming return err; 481272cc70bSAndy Fleming } 482272cc70bSAndy Fleming 483272cc70bSAndy Fleming 484fdbb873eSKim Phillips static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 485272cc70bSAndy Fleming { 486272cc70bSAndy Fleming struct mmc_cmd cmd; 4875d4fc8d9SRaffaele Recalcati int timeout = 1000; 4885d4fc8d9SRaffaele Recalcati int ret; 489272cc70bSAndy Fleming 490272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SWITCH; 491272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 492272cc70bSAndy Fleming cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 493272cc70bSAndy Fleming (index << 16) | 494272cc70bSAndy Fleming (value << 8); 495272cc70bSAndy Fleming 4965d4fc8d9SRaffaele Recalcati ret = mmc_send_cmd(mmc, &cmd, NULL); 4975d4fc8d9SRaffaele Recalcati 4985d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 49993ad0d18SJan Kloetzke if (!ret) 50093ad0d18SJan Kloetzke ret = mmc_send_status(mmc, timeout); 5015d4fc8d9SRaffaele Recalcati 5025d4fc8d9SRaffaele Recalcati return ret; 5035d4fc8d9SRaffaele Recalcati 504272cc70bSAndy Fleming } 505272cc70bSAndy Fleming 506fdbb873eSKim Phillips static int mmc_change_freq(struct mmc *mmc) 507272cc70bSAndy Fleming { 5088bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 509272cc70bSAndy Fleming char cardtype; 510272cc70bSAndy Fleming int err; 511272cc70bSAndy Fleming 512fc5b32fbSAndrew Gabbasov mmc->card_caps = 0; 513272cc70bSAndy Fleming 514d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 515d52ebf10SThomas Chou return 0; 516d52ebf10SThomas Chou 517272cc70bSAndy Fleming /* Only version 4 supports high-speed */ 518272cc70bSAndy Fleming if (mmc->version < MMC_VERSION_4) 519272cc70bSAndy Fleming return 0; 520272cc70bSAndy Fleming 521fc5b32fbSAndrew Gabbasov mmc->card_caps |= MMC_MODE_4BIT | MMC_MODE_8BIT; 522fc5b32fbSAndrew Gabbasov 523272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 524272cc70bSAndy Fleming 525272cc70bSAndy Fleming if (err) 526272cc70bSAndy Fleming return err; 527272cc70bSAndy Fleming 5280560db18SLei Wen cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 529272cc70bSAndy Fleming 530272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 531272cc70bSAndy Fleming 532272cc70bSAndy Fleming if (err) 5336b2221b0SAndrew Gabbasov return err == SWITCH_ERR ? 0 : err; 534272cc70bSAndy Fleming 535272cc70bSAndy Fleming /* Now check to see that it worked */ 536272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 537272cc70bSAndy Fleming 538272cc70bSAndy Fleming if (err) 539272cc70bSAndy Fleming return err; 540272cc70bSAndy Fleming 541272cc70bSAndy Fleming /* No high-speed support */ 5420560db18SLei Wen if (!ext_csd[EXT_CSD_HS_TIMING]) 543272cc70bSAndy Fleming return 0; 544272cc70bSAndy Fleming 545272cc70bSAndy Fleming /* High Speed is set, there are two types: 52MHz and 26MHz */ 546d22e3d46SJaehoon Chung if (cardtype & EXT_CSD_CARD_TYPE_52) { 547201d5ac4SAndrew Gabbasov if (cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V) 548d22e3d46SJaehoon Chung mmc->card_caps |= MMC_MODE_DDR_52MHz; 549272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 550d22e3d46SJaehoon Chung } else { 551272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 552d22e3d46SJaehoon Chung } 553272cc70bSAndy Fleming 554272cc70bSAndy Fleming return 0; 555272cc70bSAndy Fleming } 556272cc70bSAndy Fleming 557f866a46dSStephen Warren static int mmc_set_capacity(struct mmc *mmc, int part_num) 558f866a46dSStephen Warren { 559f866a46dSStephen Warren switch (part_num) { 560f866a46dSStephen Warren case 0: 561f866a46dSStephen Warren mmc->capacity = mmc->capacity_user; 562f866a46dSStephen Warren break; 563f866a46dSStephen Warren case 1: 564f866a46dSStephen Warren case 2: 565f866a46dSStephen Warren mmc->capacity = mmc->capacity_boot; 566f866a46dSStephen Warren break; 567f866a46dSStephen Warren case 3: 568f866a46dSStephen Warren mmc->capacity = mmc->capacity_rpmb; 569f866a46dSStephen Warren break; 570f866a46dSStephen Warren case 4: 571f866a46dSStephen Warren case 5: 572f866a46dSStephen Warren case 6: 573f866a46dSStephen Warren case 7: 574f866a46dSStephen Warren mmc->capacity = mmc->capacity_gp[part_num - 4]; 575f866a46dSStephen Warren break; 576f866a46dSStephen Warren default: 577f866a46dSStephen Warren return -1; 578f866a46dSStephen Warren } 579f866a46dSStephen Warren 580f866a46dSStephen Warren mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 581f866a46dSStephen Warren 582f866a46dSStephen Warren return 0; 583f866a46dSStephen Warren } 584f866a46dSStephen Warren 585bc897b1dSLei Wen int mmc_switch_part(int dev_num, unsigned int part_num) 586bc897b1dSLei Wen { 587bc897b1dSLei Wen struct mmc *mmc = find_mmc_device(dev_num); 588f866a46dSStephen Warren int ret; 589bc897b1dSLei Wen 590bc897b1dSLei Wen if (!mmc) 591bc897b1dSLei Wen return -1; 592bc897b1dSLei Wen 593f866a46dSStephen Warren ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 594bc897b1dSLei Wen (mmc->part_config & ~PART_ACCESS_MASK) 595bc897b1dSLei Wen | (part_num & PART_ACCESS_MASK)); 596f866a46dSStephen Warren 5976dc93e70SPeter Bigot /* 5986dc93e70SPeter Bigot * Set the capacity if the switch succeeded or was intended 5996dc93e70SPeter Bigot * to return to representing the raw device. 6006dc93e70SPeter Bigot */ 601873cc1d7SStephen Warren if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0))) { 6026dc93e70SPeter Bigot ret = mmc_set_capacity(mmc, part_num); 603873cc1d7SStephen Warren mmc->block_dev.hwpart = part_num; 604873cc1d7SStephen Warren } 6056dc93e70SPeter Bigot 6066dc93e70SPeter Bigot return ret; 607bc897b1dSLei Wen } 608bc897b1dSLei Wen 609*e17d1143SSimon Glass static int mmc_select_hwpartp(struct blk_desc *desc, int hwpart) 610*e17d1143SSimon Glass { 611*e17d1143SSimon Glass struct mmc *mmc = find_mmc_device(desc->devnum); 612*e17d1143SSimon Glass int ret; 613*e17d1143SSimon Glass 614*e17d1143SSimon Glass if (!mmc) 615*e17d1143SSimon Glass return -ENODEV; 616*e17d1143SSimon Glass 617*e17d1143SSimon Glass if (mmc->block_dev.hwpart == hwpart) 618*e17d1143SSimon Glass return 0; 619*e17d1143SSimon Glass 620*e17d1143SSimon Glass if (mmc->part_config == MMCPART_NOAVAILABLE) 621*e17d1143SSimon Glass return -EMEDIUMTYPE; 622*e17d1143SSimon Glass 623*e17d1143SSimon Glass ret = mmc_switch_part(desc->devnum, hwpart); 624*e17d1143SSimon Glass if (ret) 625*e17d1143SSimon Glass return ret; 626*e17d1143SSimon Glass 627*e17d1143SSimon Glass return 0; 628*e17d1143SSimon Glass } 629*e17d1143SSimon Glass 630ff3882acSSimon Glass int mmc_select_hwpart(int dev_num, int hwpart) 631ff3882acSSimon Glass { 632ff3882acSSimon Glass struct mmc *mmc = find_mmc_device(dev_num); 633ff3882acSSimon Glass int ret; 634ff3882acSSimon Glass 635ff3882acSSimon Glass if (!mmc) 636ff3882acSSimon Glass return -ENODEV; 637ff3882acSSimon Glass 638ff3882acSSimon Glass if (mmc->block_dev.hwpart == hwpart) 639ff3882acSSimon Glass return 0; 640ff3882acSSimon Glass 641ff3882acSSimon Glass if (mmc->part_config == MMCPART_NOAVAILABLE) 642ff3882acSSimon Glass return -EMEDIUMTYPE; 643ff3882acSSimon Glass 644ff3882acSSimon Glass ret = mmc_switch_part(dev_num, hwpart); 645ff3882acSSimon Glass if (ret) 646ff3882acSSimon Glass return ret; 647ff3882acSSimon Glass 648ff3882acSSimon Glass return 0; 649ff3882acSSimon Glass } 650ff3882acSSimon Glass 651ac9da0e0SDiego Santa Cruz int mmc_hwpart_config(struct mmc *mmc, 652ac9da0e0SDiego Santa Cruz const struct mmc_hwpart_conf *conf, 653ac9da0e0SDiego Santa Cruz enum mmc_hwpart_conf_mode mode) 654ac9da0e0SDiego Santa Cruz { 655ac9da0e0SDiego Santa Cruz u8 part_attrs = 0; 656ac9da0e0SDiego Santa Cruz u32 enh_size_mult; 657ac9da0e0SDiego Santa Cruz u32 enh_start_addr; 658ac9da0e0SDiego Santa Cruz u32 gp_size_mult[4]; 659ac9da0e0SDiego Santa Cruz u32 max_enh_size_mult; 660ac9da0e0SDiego Santa Cruz u32 tot_enh_size_mult = 0; 6618dda5b0eSDiego Santa Cruz u8 wr_rel_set; 662ac9da0e0SDiego Santa Cruz int i, pidx, err; 663ac9da0e0SDiego Santa Cruz ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 664ac9da0e0SDiego Santa Cruz 665ac9da0e0SDiego Santa Cruz if (mode < MMC_HWPART_CONF_CHECK || mode > MMC_HWPART_CONF_COMPLETE) 666ac9da0e0SDiego Santa Cruz return -EINVAL; 667ac9da0e0SDiego Santa Cruz 668ac9da0e0SDiego Santa Cruz if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4_41)) { 669ac9da0e0SDiego Santa Cruz printf("eMMC >= 4.4 required for enhanced user data area\n"); 670ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 671ac9da0e0SDiego Santa Cruz } 672ac9da0e0SDiego Santa Cruz 673ac9da0e0SDiego Santa Cruz if (!(mmc->part_support & PART_SUPPORT)) { 674ac9da0e0SDiego Santa Cruz printf("Card does not support partitioning\n"); 675ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 676ac9da0e0SDiego Santa Cruz } 677ac9da0e0SDiego Santa Cruz 678ac9da0e0SDiego Santa Cruz if (!mmc->hc_wp_grp_size) { 679ac9da0e0SDiego Santa Cruz printf("Card does not define HC WP group size\n"); 680ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 681ac9da0e0SDiego Santa Cruz } 682ac9da0e0SDiego Santa Cruz 683ac9da0e0SDiego Santa Cruz /* check partition alignment and total enhanced size */ 684ac9da0e0SDiego Santa Cruz if (conf->user.enh_size) { 685ac9da0e0SDiego Santa Cruz if (conf->user.enh_size % mmc->hc_wp_grp_size || 686ac9da0e0SDiego Santa Cruz conf->user.enh_start % mmc->hc_wp_grp_size) { 687ac9da0e0SDiego Santa Cruz printf("User data enhanced area not HC WP group " 688ac9da0e0SDiego Santa Cruz "size aligned\n"); 689ac9da0e0SDiego Santa Cruz return -EINVAL; 690ac9da0e0SDiego Santa Cruz } 691ac9da0e0SDiego Santa Cruz part_attrs |= EXT_CSD_ENH_USR; 692ac9da0e0SDiego Santa Cruz enh_size_mult = conf->user.enh_size / mmc->hc_wp_grp_size; 693ac9da0e0SDiego Santa Cruz if (mmc->high_capacity) { 694ac9da0e0SDiego Santa Cruz enh_start_addr = conf->user.enh_start; 695ac9da0e0SDiego Santa Cruz } else { 696ac9da0e0SDiego Santa Cruz enh_start_addr = (conf->user.enh_start << 9); 697ac9da0e0SDiego Santa Cruz } 698ac9da0e0SDiego Santa Cruz } else { 699ac9da0e0SDiego Santa Cruz enh_size_mult = 0; 700ac9da0e0SDiego Santa Cruz enh_start_addr = 0; 701ac9da0e0SDiego Santa Cruz } 702ac9da0e0SDiego Santa Cruz tot_enh_size_mult += enh_size_mult; 703ac9da0e0SDiego Santa Cruz 704ac9da0e0SDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 705ac9da0e0SDiego Santa Cruz if (conf->gp_part[pidx].size % mmc->hc_wp_grp_size) { 706ac9da0e0SDiego Santa Cruz printf("GP%i partition not HC WP group size " 707ac9da0e0SDiego Santa Cruz "aligned\n", pidx+1); 708ac9da0e0SDiego Santa Cruz return -EINVAL; 709ac9da0e0SDiego Santa Cruz } 710ac9da0e0SDiego Santa Cruz gp_size_mult[pidx] = conf->gp_part[pidx].size / mmc->hc_wp_grp_size; 711ac9da0e0SDiego Santa Cruz if (conf->gp_part[pidx].size && conf->gp_part[pidx].enhanced) { 712ac9da0e0SDiego Santa Cruz part_attrs |= EXT_CSD_ENH_GP(pidx); 713ac9da0e0SDiego Santa Cruz tot_enh_size_mult += gp_size_mult[pidx]; 714ac9da0e0SDiego Santa Cruz } 715ac9da0e0SDiego Santa Cruz } 716ac9da0e0SDiego Santa Cruz 717ac9da0e0SDiego Santa Cruz if (part_attrs && ! (mmc->part_support & ENHNCD_SUPPORT)) { 718ac9da0e0SDiego Santa Cruz printf("Card does not support enhanced attribute\n"); 719ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 720ac9da0e0SDiego Santa Cruz } 721ac9da0e0SDiego Santa Cruz 722ac9da0e0SDiego Santa Cruz err = mmc_send_ext_csd(mmc, ext_csd); 723ac9da0e0SDiego Santa Cruz if (err) 724ac9da0e0SDiego Santa Cruz return err; 725ac9da0e0SDiego Santa Cruz 726ac9da0e0SDiego Santa Cruz max_enh_size_mult = 727ac9da0e0SDiego Santa Cruz (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+2] << 16) + 728ac9da0e0SDiego Santa Cruz (ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT+1] << 8) + 729ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_MAX_ENH_SIZE_MULT]; 730ac9da0e0SDiego Santa Cruz if (tot_enh_size_mult > max_enh_size_mult) { 731ac9da0e0SDiego Santa Cruz printf("Total enhanced size exceeds maximum (%u > %u)\n", 732ac9da0e0SDiego Santa Cruz tot_enh_size_mult, max_enh_size_mult); 733ac9da0e0SDiego Santa Cruz return -EMEDIUMTYPE; 734ac9da0e0SDiego Santa Cruz } 735ac9da0e0SDiego Santa Cruz 7368dda5b0eSDiego Santa Cruz /* The default value of EXT_CSD_WR_REL_SET is device 7378dda5b0eSDiego Santa Cruz * dependent, the values can only be changed if the 7388dda5b0eSDiego Santa Cruz * EXT_CSD_HS_CTRL_REL bit is set. The values can be 7398dda5b0eSDiego Santa Cruz * changed only once and before partitioning is completed. */ 7408dda5b0eSDiego Santa Cruz wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 7418dda5b0eSDiego Santa Cruz if (conf->user.wr_rel_change) { 7428dda5b0eSDiego Santa Cruz if (conf->user.wr_rel_set) 7438dda5b0eSDiego Santa Cruz wr_rel_set |= EXT_CSD_WR_DATA_REL_USR; 7448dda5b0eSDiego Santa Cruz else 7458dda5b0eSDiego Santa Cruz wr_rel_set &= ~EXT_CSD_WR_DATA_REL_USR; 7468dda5b0eSDiego Santa Cruz } 7478dda5b0eSDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 7488dda5b0eSDiego Santa Cruz if (conf->gp_part[pidx].wr_rel_change) { 7498dda5b0eSDiego Santa Cruz if (conf->gp_part[pidx].wr_rel_set) 7508dda5b0eSDiego Santa Cruz wr_rel_set |= EXT_CSD_WR_DATA_REL_GP(pidx); 7518dda5b0eSDiego Santa Cruz else 7528dda5b0eSDiego Santa Cruz wr_rel_set &= ~EXT_CSD_WR_DATA_REL_GP(pidx); 7538dda5b0eSDiego Santa Cruz } 7548dda5b0eSDiego Santa Cruz } 7558dda5b0eSDiego Santa Cruz 7568dda5b0eSDiego Santa Cruz if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET] && 7578dda5b0eSDiego Santa Cruz !(ext_csd[EXT_CSD_WR_REL_PARAM] & EXT_CSD_HS_CTRL_REL)) { 7588dda5b0eSDiego Santa Cruz puts("Card does not support host controlled partition write " 7598dda5b0eSDiego Santa Cruz "reliability settings\n"); 7608dda5b0eSDiego Santa Cruz return -EMEDIUMTYPE; 7618dda5b0eSDiego Santa Cruz } 7628dda5b0eSDiego Santa Cruz 763ac9da0e0SDiego Santa Cruz if (ext_csd[EXT_CSD_PARTITION_SETTING] & 764ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED) { 765ac9da0e0SDiego Santa Cruz printf("Card already partitioned\n"); 766ac9da0e0SDiego Santa Cruz return -EPERM; 767ac9da0e0SDiego Santa Cruz } 768ac9da0e0SDiego Santa Cruz 769ac9da0e0SDiego Santa Cruz if (mode == MMC_HWPART_CONF_CHECK) 770ac9da0e0SDiego Santa Cruz return 0; 771ac9da0e0SDiego Santa Cruz 772ac9da0e0SDiego Santa Cruz /* Partitioning requires high-capacity size definitions */ 773ac9da0e0SDiego Santa Cruz if (!(ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01)) { 774ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 775ac9da0e0SDiego Santa Cruz EXT_CSD_ERASE_GROUP_DEF, 1); 776ac9da0e0SDiego Santa Cruz 777ac9da0e0SDiego Santa Cruz if (err) 778ac9da0e0SDiego Santa Cruz return err; 779ac9da0e0SDiego Santa Cruz 780ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 781ac9da0e0SDiego Santa Cruz 782ac9da0e0SDiego Santa Cruz /* update erase group size to be high-capacity */ 783ac9da0e0SDiego Santa Cruz mmc->erase_grp_size = 784ac9da0e0SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 785ac9da0e0SDiego Santa Cruz 786ac9da0e0SDiego Santa Cruz } 787ac9da0e0SDiego Santa Cruz 788ac9da0e0SDiego Santa Cruz /* all OK, write the configuration */ 789ac9da0e0SDiego Santa Cruz for (i = 0; i < 4; i++) { 790ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 791ac9da0e0SDiego Santa Cruz EXT_CSD_ENH_START_ADDR+i, 792ac9da0e0SDiego Santa Cruz (enh_start_addr >> (i*8)) & 0xFF); 793ac9da0e0SDiego Santa Cruz if (err) 794ac9da0e0SDiego Santa Cruz return err; 795ac9da0e0SDiego Santa Cruz } 796ac9da0e0SDiego Santa Cruz for (i = 0; i < 3; i++) { 797ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 798ac9da0e0SDiego Santa Cruz EXT_CSD_ENH_SIZE_MULT+i, 799ac9da0e0SDiego Santa Cruz (enh_size_mult >> (i*8)) & 0xFF); 800ac9da0e0SDiego Santa Cruz if (err) 801ac9da0e0SDiego Santa Cruz return err; 802ac9da0e0SDiego Santa Cruz } 803ac9da0e0SDiego Santa Cruz for (pidx = 0; pidx < 4; pidx++) { 804ac9da0e0SDiego Santa Cruz for (i = 0; i < 3; i++) { 805ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 806ac9da0e0SDiego Santa Cruz EXT_CSD_GP_SIZE_MULT+pidx*3+i, 807ac9da0e0SDiego Santa Cruz (gp_size_mult[pidx] >> (i*8)) & 0xFF); 808ac9da0e0SDiego Santa Cruz if (err) 809ac9da0e0SDiego Santa Cruz return err; 810ac9da0e0SDiego Santa Cruz } 811ac9da0e0SDiego Santa Cruz } 812ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 813ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITIONS_ATTRIBUTE, part_attrs); 814ac9da0e0SDiego Santa Cruz if (err) 815ac9da0e0SDiego Santa Cruz return err; 816ac9da0e0SDiego Santa Cruz 817ac9da0e0SDiego Santa Cruz if (mode == MMC_HWPART_CONF_SET) 818ac9da0e0SDiego Santa Cruz return 0; 819ac9da0e0SDiego Santa Cruz 8208dda5b0eSDiego Santa Cruz /* The WR_REL_SET is a write-once register but shall be 8218dda5b0eSDiego Santa Cruz * written before setting PART_SETTING_COMPLETED. As it is 8228dda5b0eSDiego Santa Cruz * write-once we can only write it when completing the 8238dda5b0eSDiego Santa Cruz * partitioning. */ 8248dda5b0eSDiego Santa Cruz if (wr_rel_set != ext_csd[EXT_CSD_WR_REL_SET]) { 8258dda5b0eSDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 8268dda5b0eSDiego Santa Cruz EXT_CSD_WR_REL_SET, wr_rel_set); 8278dda5b0eSDiego Santa Cruz if (err) 8288dda5b0eSDiego Santa Cruz return err; 8298dda5b0eSDiego Santa Cruz } 8308dda5b0eSDiego Santa Cruz 831ac9da0e0SDiego Santa Cruz /* Setting PART_SETTING_COMPLETED confirms the partition 832ac9da0e0SDiego Santa Cruz * configuration but it only becomes effective after power 833ac9da0e0SDiego Santa Cruz * cycle, so we do not adjust the partition related settings 834ac9da0e0SDiego Santa Cruz * in the mmc struct. */ 835ac9da0e0SDiego Santa Cruz 836ac9da0e0SDiego Santa Cruz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 837ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING, 838ac9da0e0SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED); 839ac9da0e0SDiego Santa Cruz if (err) 840ac9da0e0SDiego Santa Cruz return err; 841ac9da0e0SDiego Santa Cruz 842ac9da0e0SDiego Santa Cruz return 0; 843ac9da0e0SDiego Santa Cruz } 844ac9da0e0SDiego Santa Cruz 84548972d90SThierry Reding int mmc_getcd(struct mmc *mmc) 84648972d90SThierry Reding { 84748972d90SThierry Reding int cd; 84848972d90SThierry Reding 84948972d90SThierry Reding cd = board_mmc_getcd(mmc); 85048972d90SThierry Reding 851d4e1da4eSPeter Korsgaard if (cd < 0) { 85293bfd616SPantelis Antoniou if (mmc->cfg->ops->getcd) 85393bfd616SPantelis Antoniou cd = mmc->cfg->ops->getcd(mmc); 854d4e1da4eSPeter Korsgaard else 855d4e1da4eSPeter Korsgaard cd = 1; 856d4e1da4eSPeter Korsgaard } 85748972d90SThierry Reding 85848972d90SThierry Reding return cd; 85948972d90SThierry Reding } 86048972d90SThierry Reding 861fdbb873eSKim Phillips static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 862272cc70bSAndy Fleming { 863272cc70bSAndy Fleming struct mmc_cmd cmd; 864272cc70bSAndy Fleming struct mmc_data data; 865272cc70bSAndy Fleming 866272cc70bSAndy Fleming /* Switch the frequency */ 867272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SWITCH_FUNC; 868272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 869272cc70bSAndy Fleming cmd.cmdarg = (mode << 31) | 0xffffff; 870272cc70bSAndy Fleming cmd.cmdarg &= ~(0xf << (group * 4)); 871272cc70bSAndy Fleming cmd.cmdarg |= value << (group * 4); 872272cc70bSAndy Fleming 873272cc70bSAndy Fleming data.dest = (char *)resp; 874272cc70bSAndy Fleming data.blocksize = 64; 875272cc70bSAndy Fleming data.blocks = 1; 876272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 877272cc70bSAndy Fleming 878272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, &data); 879272cc70bSAndy Fleming } 880272cc70bSAndy Fleming 881272cc70bSAndy Fleming 882fdbb873eSKim Phillips static int sd_change_freq(struct mmc *mmc) 883272cc70bSAndy Fleming { 884272cc70bSAndy Fleming int err; 885272cc70bSAndy Fleming struct mmc_cmd cmd; 886f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 887f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 888272cc70bSAndy Fleming struct mmc_data data; 889272cc70bSAndy Fleming int timeout; 890272cc70bSAndy Fleming 891272cc70bSAndy Fleming mmc->card_caps = 0; 892272cc70bSAndy Fleming 893d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 894d52ebf10SThomas Chou return 0; 895d52ebf10SThomas Chou 896272cc70bSAndy Fleming /* Read the SCR to find out if this card supports higher speeds */ 897272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 898272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 899272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 900272cc70bSAndy Fleming 901272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 902272cc70bSAndy Fleming 903272cc70bSAndy Fleming if (err) 904272cc70bSAndy Fleming return err; 905272cc70bSAndy Fleming 906272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_SCR; 907272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 908272cc70bSAndy Fleming cmd.cmdarg = 0; 909272cc70bSAndy Fleming 910272cc70bSAndy Fleming timeout = 3; 911272cc70bSAndy Fleming 912272cc70bSAndy Fleming retry_scr: 913f781dd38SAnton staaf data.dest = (char *)scr; 914272cc70bSAndy Fleming data.blocksize = 8; 915272cc70bSAndy Fleming data.blocks = 1; 916272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 917272cc70bSAndy Fleming 918272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 919272cc70bSAndy Fleming 920272cc70bSAndy Fleming if (err) { 921272cc70bSAndy Fleming if (timeout--) 922272cc70bSAndy Fleming goto retry_scr; 923272cc70bSAndy Fleming 924272cc70bSAndy Fleming return err; 925272cc70bSAndy Fleming } 926272cc70bSAndy Fleming 9274e3d89baSYauhen Kharuzhy mmc->scr[0] = __be32_to_cpu(scr[0]); 9284e3d89baSYauhen Kharuzhy mmc->scr[1] = __be32_to_cpu(scr[1]); 929272cc70bSAndy Fleming 930272cc70bSAndy Fleming switch ((mmc->scr[0] >> 24) & 0xf) { 931272cc70bSAndy Fleming case 0: 932272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 933272cc70bSAndy Fleming break; 934272cc70bSAndy Fleming case 1: 935272cc70bSAndy Fleming mmc->version = SD_VERSION_1_10; 936272cc70bSAndy Fleming break; 937272cc70bSAndy Fleming case 2: 938272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 9391741c64dSJaehoon Chung if ((mmc->scr[0] >> 15) & 0x1) 9401741c64dSJaehoon Chung mmc->version = SD_VERSION_3; 941272cc70bSAndy Fleming break; 942272cc70bSAndy Fleming default: 943272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 944272cc70bSAndy Fleming break; 945272cc70bSAndy Fleming } 946272cc70bSAndy Fleming 947b44c7083SAlagu Sankar if (mmc->scr[0] & SD_DATA_4BIT) 948b44c7083SAlagu Sankar mmc->card_caps |= MMC_MODE_4BIT; 949b44c7083SAlagu Sankar 950272cc70bSAndy Fleming /* Version 1.0 doesn't support switching */ 951272cc70bSAndy Fleming if (mmc->version == SD_VERSION_1_0) 952272cc70bSAndy Fleming return 0; 953272cc70bSAndy Fleming 954272cc70bSAndy Fleming timeout = 4; 955272cc70bSAndy Fleming while (timeout--) { 956272cc70bSAndy Fleming err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 957f781dd38SAnton staaf (u8 *)switch_status); 958272cc70bSAndy Fleming 959272cc70bSAndy Fleming if (err) 960272cc70bSAndy Fleming return err; 961272cc70bSAndy Fleming 962272cc70bSAndy Fleming /* The high-speed function is busy. Try again */ 9634e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 964272cc70bSAndy Fleming break; 965272cc70bSAndy Fleming } 966272cc70bSAndy Fleming 967272cc70bSAndy Fleming /* If high-speed isn't supported, we return */ 9684e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 969272cc70bSAndy Fleming return 0; 970272cc70bSAndy Fleming 9712c3fbf4cSMacpaul Lin /* 9722c3fbf4cSMacpaul Lin * If the host doesn't support SD_HIGHSPEED, do not switch card to 9732c3fbf4cSMacpaul Lin * HIGHSPEED mode even if the card support SD_HIGHSPPED. 9742c3fbf4cSMacpaul Lin * This can avoid furthur problem when the card runs in different 9752c3fbf4cSMacpaul Lin * mode between the host. 9762c3fbf4cSMacpaul Lin */ 97793bfd616SPantelis Antoniou if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) && 97893bfd616SPantelis Antoniou (mmc->cfg->host_caps & MMC_MODE_HS))) 9792c3fbf4cSMacpaul Lin return 0; 9802c3fbf4cSMacpaul Lin 981f781dd38SAnton staaf err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 982272cc70bSAndy Fleming 983272cc70bSAndy Fleming if (err) 984272cc70bSAndy Fleming return err; 985272cc70bSAndy Fleming 9864e3d89baSYauhen Kharuzhy if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 987272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 988272cc70bSAndy Fleming 989272cc70bSAndy Fleming return 0; 990272cc70bSAndy Fleming } 991272cc70bSAndy Fleming 992272cc70bSAndy Fleming /* frequency bases */ 993272cc70bSAndy Fleming /* divided by 10 to be nice to platforms without floating point */ 9945f837c2cSMike Frysinger static const int fbase[] = { 995272cc70bSAndy Fleming 10000, 996272cc70bSAndy Fleming 100000, 997272cc70bSAndy Fleming 1000000, 998272cc70bSAndy Fleming 10000000, 999272cc70bSAndy Fleming }; 1000272cc70bSAndy Fleming 1001272cc70bSAndy Fleming /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 1002272cc70bSAndy Fleming * to platforms without floating point. 1003272cc70bSAndy Fleming */ 10045f837c2cSMike Frysinger static const int multipliers[] = { 1005272cc70bSAndy Fleming 0, /* reserved */ 1006272cc70bSAndy Fleming 10, 1007272cc70bSAndy Fleming 12, 1008272cc70bSAndy Fleming 13, 1009272cc70bSAndy Fleming 15, 1010272cc70bSAndy Fleming 20, 1011272cc70bSAndy Fleming 25, 1012272cc70bSAndy Fleming 30, 1013272cc70bSAndy Fleming 35, 1014272cc70bSAndy Fleming 40, 1015272cc70bSAndy Fleming 45, 1016272cc70bSAndy Fleming 50, 1017272cc70bSAndy Fleming 55, 1018272cc70bSAndy Fleming 60, 1019272cc70bSAndy Fleming 70, 1020272cc70bSAndy Fleming 80, 1021272cc70bSAndy Fleming }; 1022272cc70bSAndy Fleming 1023fdbb873eSKim Phillips static void mmc_set_ios(struct mmc *mmc) 1024272cc70bSAndy Fleming { 102593bfd616SPantelis Antoniou if (mmc->cfg->ops->set_ios) 102693bfd616SPantelis Antoniou mmc->cfg->ops->set_ios(mmc); 1027272cc70bSAndy Fleming } 1028272cc70bSAndy Fleming 1029272cc70bSAndy Fleming void mmc_set_clock(struct mmc *mmc, uint clock) 1030272cc70bSAndy Fleming { 103193bfd616SPantelis Antoniou if (clock > mmc->cfg->f_max) 103293bfd616SPantelis Antoniou clock = mmc->cfg->f_max; 1033272cc70bSAndy Fleming 103493bfd616SPantelis Antoniou if (clock < mmc->cfg->f_min) 103593bfd616SPantelis Antoniou clock = mmc->cfg->f_min; 1036272cc70bSAndy Fleming 1037272cc70bSAndy Fleming mmc->clock = clock; 1038272cc70bSAndy Fleming 1039272cc70bSAndy Fleming mmc_set_ios(mmc); 1040272cc70bSAndy Fleming } 1041272cc70bSAndy Fleming 1042fdbb873eSKim Phillips static void mmc_set_bus_width(struct mmc *mmc, uint width) 1043272cc70bSAndy Fleming { 1044272cc70bSAndy Fleming mmc->bus_width = width; 1045272cc70bSAndy Fleming 1046272cc70bSAndy Fleming mmc_set_ios(mmc); 1047272cc70bSAndy Fleming } 1048272cc70bSAndy Fleming 1049fdbb873eSKim Phillips static int mmc_startup(struct mmc *mmc) 1050272cc70bSAndy Fleming { 1051f866a46dSStephen Warren int err, i; 1052272cc70bSAndy Fleming uint mult, freq; 1053639b7827SYoshihiro Shimoda u64 cmult, csize, capacity; 1054272cc70bSAndy Fleming struct mmc_cmd cmd; 10558bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN); 10568bfa195eSSimon Glass ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN); 10575d4fc8d9SRaffaele Recalcati int timeout = 1000; 10580c453bb7SDiego Santa Cruz bool has_parts = false; 10598a0cf490SDiego Santa Cruz bool part_completed; 1060272cc70bSAndy Fleming 1061d52ebf10SThomas Chou #ifdef CONFIG_MMC_SPI_CRC_ON 1062d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 1063d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 1064d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R1; 1065d52ebf10SThomas Chou cmd.cmdarg = 1; 1066d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 1067d52ebf10SThomas Chou 1068d52ebf10SThomas Chou if (err) 1069d52ebf10SThomas Chou return err; 1070d52ebf10SThomas Chou } 1071d52ebf10SThomas Chou #endif 1072d52ebf10SThomas Chou 1073272cc70bSAndy Fleming /* Put the Card in Identify Mode */ 1074d52ebf10SThomas Chou cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 1075d52ebf10SThomas Chou MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 1076272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 1077272cc70bSAndy Fleming cmd.cmdarg = 0; 1078272cc70bSAndy Fleming 1079272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1080272cc70bSAndy Fleming 1081272cc70bSAndy Fleming if (err) 1082272cc70bSAndy Fleming return err; 1083272cc70bSAndy Fleming 1084272cc70bSAndy Fleming memcpy(mmc->cid, cmd.response, 16); 1085272cc70bSAndy Fleming 1086272cc70bSAndy Fleming /* 1087272cc70bSAndy Fleming * For MMC cards, set the Relative Address. 1088272cc70bSAndy Fleming * For SD cards, get the Relatvie Address. 1089272cc70bSAndy Fleming * This also puts the cards into Standby State 1090272cc70bSAndy Fleming */ 1091d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1092272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 1093272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1094272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R6; 1095272cc70bSAndy Fleming 1096272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1097272cc70bSAndy Fleming 1098272cc70bSAndy Fleming if (err) 1099272cc70bSAndy Fleming return err; 1100272cc70bSAndy Fleming 1101272cc70bSAndy Fleming if (IS_SD(mmc)) 1102998be3ddSRabin Vincent mmc->rca = (cmd.response[0] >> 16) & 0xffff; 1103d52ebf10SThomas Chou } 1104272cc70bSAndy Fleming 1105272cc70bSAndy Fleming /* Get the Card-Specific Data */ 1106272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_CSD; 1107272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 1108272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1109272cc70bSAndy Fleming 1110272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1111272cc70bSAndy Fleming 11125d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 11135d4fc8d9SRaffaele Recalcati mmc_send_status(mmc, timeout); 11145d4fc8d9SRaffaele Recalcati 1115272cc70bSAndy Fleming if (err) 1116272cc70bSAndy Fleming return err; 1117272cc70bSAndy Fleming 1118998be3ddSRabin Vincent mmc->csd[0] = cmd.response[0]; 1119998be3ddSRabin Vincent mmc->csd[1] = cmd.response[1]; 1120998be3ddSRabin Vincent mmc->csd[2] = cmd.response[2]; 1121998be3ddSRabin Vincent mmc->csd[3] = cmd.response[3]; 1122272cc70bSAndy Fleming 1123272cc70bSAndy Fleming if (mmc->version == MMC_VERSION_UNKNOWN) { 11240b453ffeSRabin Vincent int version = (cmd.response[0] >> 26) & 0xf; 1125272cc70bSAndy Fleming 1126272cc70bSAndy Fleming switch (version) { 1127272cc70bSAndy Fleming case 0: 1128272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 1129272cc70bSAndy Fleming break; 1130272cc70bSAndy Fleming case 1: 1131272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_4; 1132272cc70bSAndy Fleming break; 1133272cc70bSAndy Fleming case 2: 1134272cc70bSAndy Fleming mmc->version = MMC_VERSION_2_2; 1135272cc70bSAndy Fleming break; 1136272cc70bSAndy Fleming case 3: 1137272cc70bSAndy Fleming mmc->version = MMC_VERSION_3; 1138272cc70bSAndy Fleming break; 1139272cc70bSAndy Fleming case 4: 1140272cc70bSAndy Fleming mmc->version = MMC_VERSION_4; 1141272cc70bSAndy Fleming break; 1142272cc70bSAndy Fleming default: 1143272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 1144272cc70bSAndy Fleming break; 1145272cc70bSAndy Fleming } 1146272cc70bSAndy Fleming } 1147272cc70bSAndy Fleming 1148272cc70bSAndy Fleming /* divide frequency by 10, since the mults are 10x bigger */ 11490b453ffeSRabin Vincent freq = fbase[(cmd.response[0] & 0x7)]; 11500b453ffeSRabin Vincent mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 1151272cc70bSAndy Fleming 1152272cc70bSAndy Fleming mmc->tran_speed = freq * mult; 1153272cc70bSAndy Fleming 1154ab71188cSMarkus Niebel mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1); 1155998be3ddSRabin Vincent mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 1156272cc70bSAndy Fleming 1157272cc70bSAndy Fleming if (IS_SD(mmc)) 1158272cc70bSAndy Fleming mmc->write_bl_len = mmc->read_bl_len; 1159272cc70bSAndy Fleming else 1160998be3ddSRabin Vincent mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 1161272cc70bSAndy Fleming 1162272cc70bSAndy Fleming if (mmc->high_capacity) { 1163272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3f) << 16 1164272cc70bSAndy Fleming | (mmc->csd[2] & 0xffff0000) >> 16; 1165272cc70bSAndy Fleming cmult = 8; 1166272cc70bSAndy Fleming } else { 1167272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3ff) << 2 1168272cc70bSAndy Fleming | (mmc->csd[2] & 0xc0000000) >> 30; 1169272cc70bSAndy Fleming cmult = (mmc->csd[2] & 0x00038000) >> 15; 1170272cc70bSAndy Fleming } 1171272cc70bSAndy Fleming 1172f866a46dSStephen Warren mmc->capacity_user = (csize + 1) << (cmult + 2); 1173f866a46dSStephen Warren mmc->capacity_user *= mmc->read_bl_len; 1174f866a46dSStephen Warren mmc->capacity_boot = 0; 1175f866a46dSStephen Warren mmc->capacity_rpmb = 0; 1176f866a46dSStephen Warren for (i = 0; i < 4; i++) 1177f866a46dSStephen Warren mmc->capacity_gp[i] = 0; 1178272cc70bSAndy Fleming 11798bfa195eSSimon Glass if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN) 11808bfa195eSSimon Glass mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 1181272cc70bSAndy Fleming 11828bfa195eSSimon Glass if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN) 11838bfa195eSSimon Glass mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 1184272cc70bSAndy Fleming 1185ab71188cSMarkus Niebel if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) { 1186ab71188cSMarkus Niebel cmd.cmdidx = MMC_CMD_SET_DSR; 1187ab71188cSMarkus Niebel cmd.cmdarg = (mmc->dsr & 0xffff) << 16; 1188ab71188cSMarkus Niebel cmd.resp_type = MMC_RSP_NONE; 1189ab71188cSMarkus Niebel if (mmc_send_cmd(mmc, &cmd, NULL)) 1190ab71188cSMarkus Niebel printf("MMC: SET_DSR failed\n"); 1191ab71188cSMarkus Niebel } 1192ab71188cSMarkus Niebel 1193272cc70bSAndy Fleming /* Select the card, and put it into Transfer Mode */ 1194d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1195272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SELECT_CARD; 1196fe8f7066SAjay Bhargav cmd.resp_type = MMC_RSP_R1; 1197272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1198272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1199272cc70bSAndy Fleming 1200272cc70bSAndy Fleming if (err) 1201272cc70bSAndy Fleming return err; 1202d52ebf10SThomas Chou } 1203272cc70bSAndy Fleming 1204e6f99a56SLei Wen /* 1205e6f99a56SLei Wen * For SD, its erase group is always one sector 1206e6f99a56SLei Wen */ 1207e6f99a56SLei Wen mmc->erase_grp_size = 1; 1208bc897b1dSLei Wen mmc->part_config = MMCPART_NOAVAILABLE; 1209d23e2c09SSukumar Ghorai if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 1210d23e2c09SSukumar Ghorai /* check ext_csd version and capacity */ 1211d23e2c09SSukumar Ghorai err = mmc_send_ext_csd(mmc, ext_csd); 12129cf199ebSDiego Santa Cruz if (err) 12139cf199ebSDiego Santa Cruz return err; 12149cf199ebSDiego Santa Cruz if (ext_csd[EXT_CSD_REV] >= 2) { 1215639b7827SYoshihiro Shimoda /* 1216639b7827SYoshihiro Shimoda * According to the JEDEC Standard, the value of 1217639b7827SYoshihiro Shimoda * ext_csd's capacity is valid if the value is more 1218639b7827SYoshihiro Shimoda * than 2GB 1219639b7827SYoshihiro Shimoda */ 12200560db18SLei Wen capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 12210560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 12220560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 12230560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 12248bfa195eSSimon Glass capacity *= MMC_MAX_BLOCK_LEN; 1225b1f1e821SŁukasz Majewski if ((capacity >> 20) > 2 * 1024) 1226f866a46dSStephen Warren mmc->capacity_user = capacity; 1227d23e2c09SSukumar Ghorai } 1228bc897b1dSLei Wen 122964f4a619SJaehoon Chung switch (ext_csd[EXT_CSD_REV]) { 123064f4a619SJaehoon Chung case 1: 123164f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_1; 123264f4a619SJaehoon Chung break; 123364f4a619SJaehoon Chung case 2: 123464f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_2; 123564f4a619SJaehoon Chung break; 123664f4a619SJaehoon Chung case 3: 123764f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_3; 123864f4a619SJaehoon Chung break; 123964f4a619SJaehoon Chung case 5: 124064f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_41; 124164f4a619SJaehoon Chung break; 124264f4a619SJaehoon Chung case 6: 124364f4a619SJaehoon Chung mmc->version = MMC_VERSION_4_5; 124464f4a619SJaehoon Chung break; 1245edab723bSMarkus Niebel case 7: 1246edab723bSMarkus Niebel mmc->version = MMC_VERSION_5_0; 1247edab723bSMarkus Niebel break; 124864f4a619SJaehoon Chung } 124964f4a619SJaehoon Chung 12508a0cf490SDiego Santa Cruz /* The partition data may be non-zero but it is only 12518a0cf490SDiego Santa Cruz * effective if PARTITION_SETTING_COMPLETED is set in 12528a0cf490SDiego Santa Cruz * EXT_CSD, so ignore any data if this bit is not set, 12538a0cf490SDiego Santa Cruz * except for enabling the high-capacity group size 12548a0cf490SDiego Santa Cruz * definition (see below). */ 12558a0cf490SDiego Santa Cruz part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] & 12568a0cf490SDiego Santa Cruz EXT_CSD_PARTITION_SETTING_COMPLETED); 12578a0cf490SDiego Santa Cruz 12580c453bb7SDiego Santa Cruz /* store the partition info of emmc */ 12590c453bb7SDiego Santa Cruz mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT]; 12600c453bb7SDiego Santa Cruz if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 12610c453bb7SDiego Santa Cruz ext_csd[EXT_CSD_BOOT_MULT]) 12620c453bb7SDiego Santa Cruz mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 12638a0cf490SDiego Santa Cruz if (part_completed && 12648a0cf490SDiego Santa Cruz (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT)) 12650c453bb7SDiego Santa Cruz mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE]; 12660c453bb7SDiego Santa Cruz 12670c453bb7SDiego Santa Cruz mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17; 12680c453bb7SDiego Santa Cruz 12690c453bb7SDiego Santa Cruz mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17; 12700c453bb7SDiego Santa Cruz 12710c453bb7SDiego Santa Cruz for (i = 0; i < 4; i++) { 12720c453bb7SDiego Santa Cruz int idx = EXT_CSD_GP_SIZE_MULT + i * 3; 12738a0cf490SDiego Santa Cruz uint mult = (ext_csd[idx + 2] << 16) + 12740c453bb7SDiego Santa Cruz (ext_csd[idx + 1] << 8) + ext_csd[idx]; 12758a0cf490SDiego Santa Cruz if (mult) 12768a0cf490SDiego Santa Cruz has_parts = true; 12778a0cf490SDiego Santa Cruz if (!part_completed) 12788a0cf490SDiego Santa Cruz continue; 12798a0cf490SDiego Santa Cruz mmc->capacity_gp[i] = mult; 12800c453bb7SDiego Santa Cruz mmc->capacity_gp[i] *= 12810c453bb7SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 12820c453bb7SDiego Santa Cruz mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1283f8e89d67SDiego Santa Cruz mmc->capacity_gp[i] <<= 19; 12840c453bb7SDiego Santa Cruz } 12850c453bb7SDiego Santa Cruz 12868a0cf490SDiego Santa Cruz if (part_completed) { 1287a7f852b6SDiego Santa Cruz mmc->enh_user_size = 1288a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_SIZE_MULT+2] << 16) + 1289a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_SIZE_MULT+1] << 8) + 1290a7f852b6SDiego Santa Cruz ext_csd[EXT_CSD_ENH_SIZE_MULT]; 1291a7f852b6SDiego Santa Cruz mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]; 1292a7f852b6SDiego Santa Cruz mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 1293a7f852b6SDiego Santa Cruz mmc->enh_user_size <<= 19; 1294a7f852b6SDiego Santa Cruz mmc->enh_user_start = 1295a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+3] << 24) + 1296a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+2] << 16) + 1297a7f852b6SDiego Santa Cruz (ext_csd[EXT_CSD_ENH_START_ADDR+1] << 8) + 1298a7f852b6SDiego Santa Cruz ext_csd[EXT_CSD_ENH_START_ADDR]; 1299a7f852b6SDiego Santa Cruz if (mmc->high_capacity) 1300a7f852b6SDiego Santa Cruz mmc->enh_user_start <<= 9; 13018a0cf490SDiego Santa Cruz } 1302a7f852b6SDiego Santa Cruz 1303e6f99a56SLei Wen /* 13041937e5aaSOliver Metz * Host needs to enable ERASE_GRP_DEF bit if device is 13051937e5aaSOliver Metz * partitioned. This bit will be lost every time after a reset 13061937e5aaSOliver Metz * or power off. This will affect erase size. 1307e6f99a56SLei Wen */ 13088a0cf490SDiego Santa Cruz if (part_completed) 13090c453bb7SDiego Santa Cruz has_parts = true; 13101937e5aaSOliver Metz if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) && 13110c453bb7SDiego Santa Cruz (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) 13120c453bb7SDiego Santa Cruz has_parts = true; 13130c453bb7SDiego Santa Cruz if (has_parts) { 13141937e5aaSOliver Metz err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 13151937e5aaSOliver Metz EXT_CSD_ERASE_GROUP_DEF, 1); 13161937e5aaSOliver Metz 13171937e5aaSOliver Metz if (err) 13181937e5aaSOliver Metz return err; 1319021a8055SHannes Petermaier else 1320021a8055SHannes Petermaier ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1; 1321037dc0abSDiego Santa Cruz } 13221937e5aaSOliver Metz 1323037dc0abSDiego Santa Cruz if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) { 13241937e5aaSOliver Metz /* Read out group size from ext_csd */ 13250560db18SLei Wen mmc->erase_grp_size = 1326a4ff9f83SDiego Santa Cruz ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024; 1327d7b29129SMarkus Niebel /* 1328d7b29129SMarkus Niebel * if high capacity and partition setting completed 1329d7b29129SMarkus Niebel * SEC_COUNT is valid even if it is smaller than 2 GiB 1330d7b29129SMarkus Niebel * JEDEC Standard JESD84-B45, 6.2.4 1331d7b29129SMarkus Niebel */ 13328a0cf490SDiego Santa Cruz if (mmc->high_capacity && part_completed) { 1333d7b29129SMarkus Niebel capacity = (ext_csd[EXT_CSD_SEC_CNT]) | 1334d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) | 1335d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) | 1336d7b29129SMarkus Niebel (ext_csd[EXT_CSD_SEC_CNT + 3] << 24); 1337d7b29129SMarkus Niebel capacity *= MMC_MAX_BLOCK_LEN; 1338d7b29129SMarkus Niebel mmc->capacity_user = capacity; 1339d7b29129SMarkus Niebel } 13408bfa195eSSimon Glass } else { 13411937e5aaSOliver Metz /* Calculate the group size from the csd value. */ 1342e6f99a56SLei Wen int erase_gsz, erase_gmul; 1343e6f99a56SLei Wen erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1344e6f99a56SLei Wen erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1345e6f99a56SLei Wen mmc->erase_grp_size = (erase_gsz + 1) 1346e6f99a56SLei Wen * (erase_gmul + 1); 1347e6f99a56SLei Wen } 1348037dc0abSDiego Santa Cruz 1349037dc0abSDiego Santa Cruz mmc->hc_wp_grp_size = 1024 1350037dc0abSDiego Santa Cruz * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1351037dc0abSDiego Santa Cruz * ext_csd[EXT_CSD_HC_WP_GRP_SIZE]; 13529e41a00bSDiego Santa Cruz 13539e41a00bSDiego Santa Cruz mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET]; 1354f866a46dSStephen Warren } 1355f866a46dSStephen Warren 1356873cc1d7SStephen Warren err = mmc_set_capacity(mmc, mmc->block_dev.hwpart); 1357f866a46dSStephen Warren if (err) 1358f866a46dSStephen Warren return err; 1359d23e2c09SSukumar Ghorai 1360272cc70bSAndy Fleming if (IS_SD(mmc)) 1361272cc70bSAndy Fleming err = sd_change_freq(mmc); 1362272cc70bSAndy Fleming else 1363272cc70bSAndy Fleming err = mmc_change_freq(mmc); 1364272cc70bSAndy Fleming 1365272cc70bSAndy Fleming if (err) 1366272cc70bSAndy Fleming return err; 1367272cc70bSAndy Fleming 1368272cc70bSAndy Fleming /* Restrict card's capabilities by what the host can do */ 136993bfd616SPantelis Antoniou mmc->card_caps &= mmc->cfg->host_caps; 1370272cc70bSAndy Fleming 1371272cc70bSAndy Fleming if (IS_SD(mmc)) { 1372272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_4BIT) { 1373272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 1374272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1375272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1376272cc70bSAndy Fleming 1377272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1378272cc70bSAndy Fleming if (err) 1379272cc70bSAndy Fleming return err; 1380272cc70bSAndy Fleming 1381272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1382272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1383272cc70bSAndy Fleming cmd.cmdarg = 2; 1384272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1385272cc70bSAndy Fleming if (err) 1386272cc70bSAndy Fleming return err; 1387272cc70bSAndy Fleming 1388272cc70bSAndy Fleming mmc_set_bus_width(mmc, 4); 1389272cc70bSAndy Fleming } 1390272cc70bSAndy Fleming 1391272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) 1392ad5fd922SJaehoon Chung mmc->tran_speed = 50000000; 1393272cc70bSAndy Fleming else 1394ad5fd922SJaehoon Chung mmc->tran_speed = 25000000; 1395fc5b32fbSAndrew Gabbasov } else if (mmc->version >= MMC_VERSION_4) { 1396fc5b32fbSAndrew Gabbasov /* Only version 4 of MMC supports wider bus widths */ 13977798f6dbSAndy Fleming int idx; 13987798f6dbSAndy Fleming 13997798f6dbSAndy Fleming /* An array of possible bus widths in order of preference */ 14007798f6dbSAndy Fleming static unsigned ext_csd_bits[] = { 1401d22e3d46SJaehoon Chung EXT_CSD_DDR_BUS_WIDTH_8, 1402d22e3d46SJaehoon Chung EXT_CSD_DDR_BUS_WIDTH_4, 14037798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_8, 14047798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_4, 14057798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH_1, 14067798f6dbSAndy Fleming }; 14077798f6dbSAndy Fleming 14087798f6dbSAndy Fleming /* An array to map CSD bus widths to host cap bits */ 14097798f6dbSAndy Fleming static unsigned ext_to_hostcaps[] = { 1410786e8f81SAndrew Gabbasov [EXT_CSD_DDR_BUS_WIDTH_4] = 1411786e8f81SAndrew Gabbasov MMC_MODE_DDR_52MHz | MMC_MODE_4BIT, 1412786e8f81SAndrew Gabbasov [EXT_CSD_DDR_BUS_WIDTH_8] = 1413786e8f81SAndrew Gabbasov MMC_MODE_DDR_52MHz | MMC_MODE_8BIT, 14147798f6dbSAndy Fleming [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT, 14157798f6dbSAndy Fleming [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT, 14167798f6dbSAndy Fleming }; 14177798f6dbSAndy Fleming 14187798f6dbSAndy Fleming /* An array to map chosen bus width to an integer */ 14197798f6dbSAndy Fleming static unsigned widths[] = { 1420d22e3d46SJaehoon Chung 8, 4, 8, 4, 1, 14217798f6dbSAndy Fleming }; 14227798f6dbSAndy Fleming 14237798f6dbSAndy Fleming for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) { 14247798f6dbSAndy Fleming unsigned int extw = ext_csd_bits[idx]; 1425786e8f81SAndrew Gabbasov unsigned int caps = ext_to_hostcaps[extw]; 14267798f6dbSAndy Fleming 14277798f6dbSAndy Fleming /* 1428bf477073SAndrew Gabbasov * If the bus width is still not changed, 1429bf477073SAndrew Gabbasov * don't try to set the default again. 1430bf477073SAndrew Gabbasov * Otherwise, recover from switch attempts 1431bf477073SAndrew Gabbasov * by switching to 1-bit bus width. 1432bf477073SAndrew Gabbasov */ 1433bf477073SAndrew Gabbasov if (extw == EXT_CSD_BUS_WIDTH_1 && 1434bf477073SAndrew Gabbasov mmc->bus_width == 1) { 1435bf477073SAndrew Gabbasov err = 0; 1436bf477073SAndrew Gabbasov break; 1437bf477073SAndrew Gabbasov } 1438bf477073SAndrew Gabbasov 1439bf477073SAndrew Gabbasov /* 1440786e8f81SAndrew Gabbasov * Check to make sure the card and controller support 1441786e8f81SAndrew Gabbasov * these capabilities 14427798f6dbSAndy Fleming */ 1443786e8f81SAndrew Gabbasov if ((mmc->card_caps & caps) != caps) 14447798f6dbSAndy Fleming continue; 14457798f6dbSAndy Fleming 1446272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 14477798f6dbSAndy Fleming EXT_CSD_BUS_WIDTH, extw); 1448272cc70bSAndy Fleming 1449272cc70bSAndy Fleming if (err) 14504137894eSLei Wen continue; 1451272cc70bSAndy Fleming 1452786e8f81SAndrew Gabbasov mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0; 14537798f6dbSAndy Fleming mmc_set_bus_width(mmc, widths[idx]); 1454272cc70bSAndy Fleming 14554137894eSLei Wen err = mmc_send_ext_csd(mmc, test_csd); 1456272cc70bSAndy Fleming 1457786e8f81SAndrew Gabbasov if (err) 1458786e8f81SAndrew Gabbasov continue; 1459786e8f81SAndrew Gabbasov 1460786e8f81SAndrew Gabbasov /* Only compare read only fields */ 1461786e8f81SAndrew Gabbasov if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] 1462786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_PARTITIONING_SUPPORT] && 1463786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_HC_WP_GRP_SIZE] 1464786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_HC_WP_GRP_SIZE] && 1465786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_REV] 1466786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_REV] && 1467786e8f81SAndrew Gabbasov ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 1468786e8f81SAndrew Gabbasov == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] && 1469786e8f81SAndrew Gabbasov memcmp(&ext_csd[EXT_CSD_SEC_CNT], 1470786e8f81SAndrew Gabbasov &test_csd[EXT_CSD_SEC_CNT], 4) == 0) 14714137894eSLei Wen break; 1472786e8f81SAndrew Gabbasov else 1473786e8f81SAndrew Gabbasov err = SWITCH_ERR; 14744137894eSLei Wen } 1475786e8f81SAndrew Gabbasov 1476786e8f81SAndrew Gabbasov if (err) 1477786e8f81SAndrew Gabbasov return err; 1478272cc70bSAndy Fleming 1479272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) { 1480272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS_52MHz) 1481ad5fd922SJaehoon Chung mmc->tran_speed = 52000000; 1482272cc70bSAndy Fleming else 1483ad5fd922SJaehoon Chung mmc->tran_speed = 26000000; 1484272cc70bSAndy Fleming } 1485ad5fd922SJaehoon Chung } 1486ad5fd922SJaehoon Chung 1487ad5fd922SJaehoon Chung mmc_set_clock(mmc, mmc->tran_speed); 1488272cc70bSAndy Fleming 14895af8f45cSAndrew Gabbasov /* Fix the block length for DDR mode */ 14905af8f45cSAndrew Gabbasov if (mmc->ddr_mode) { 14915af8f45cSAndrew Gabbasov mmc->read_bl_len = MMC_MAX_BLOCK_LEN; 14925af8f45cSAndrew Gabbasov mmc->write_bl_len = MMC_MAX_BLOCK_LEN; 14935af8f45cSAndrew Gabbasov } 14945af8f45cSAndrew Gabbasov 1495272cc70bSAndy Fleming /* fill in device description */ 1496272cc70bSAndy Fleming mmc->block_dev.lun = 0; 1497873cc1d7SStephen Warren mmc->block_dev.hwpart = 0; 1498272cc70bSAndy Fleming mmc->block_dev.type = 0; 1499272cc70bSAndy Fleming mmc->block_dev.blksz = mmc->read_bl_len; 15000472fbfdSEgbert Eich mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz); 15019b1f942cSRabin Vincent mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 1502fc011f64SSjoerd Simons #if !defined(CONFIG_SPL_BUILD) || \ 1503fc011f64SSjoerd Simons (defined(CONFIG_SPL_LIBCOMMON_SUPPORT) && \ 1504fc011f64SSjoerd Simons !defined(CONFIG_USE_TINY_PRINTF)) 1505babce5f6STaylor Hutt sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x", 1506babce5f6STaylor Hutt mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 1507babce5f6STaylor Hutt (mmc->cid[3] >> 16) & 0xffff); 1508babce5f6STaylor Hutt sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 15090b453ffeSRabin Vincent (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1510babce5f6STaylor Hutt (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 1511babce5f6STaylor Hutt (mmc->cid[2] >> 24) & 0xff); 1512babce5f6STaylor Hutt sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 1513babce5f6STaylor Hutt (mmc->cid[2] >> 16) & 0xf); 151456196826SPaul Burton #else 151556196826SPaul Burton mmc->block_dev.vendor[0] = 0; 151656196826SPaul Burton mmc->block_dev.product[0] = 0; 151756196826SPaul Burton mmc->block_dev.revision[0] = 0; 151856196826SPaul Burton #endif 1519122efd43SMikhail Kshevetskiy #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 15203e8bd469SSimon Glass part_init(&mmc->block_dev); 1521122efd43SMikhail Kshevetskiy #endif 1522272cc70bSAndy Fleming 1523272cc70bSAndy Fleming return 0; 1524272cc70bSAndy Fleming } 1525272cc70bSAndy Fleming 1526fdbb873eSKim Phillips static int mmc_send_if_cond(struct mmc *mmc) 1527272cc70bSAndy Fleming { 1528272cc70bSAndy Fleming struct mmc_cmd cmd; 1529272cc70bSAndy Fleming int err; 1530272cc70bSAndy Fleming 1531272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_IF_COND; 1532272cc70bSAndy Fleming /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 153393bfd616SPantelis Antoniou cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa; 1534272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R7; 1535272cc70bSAndy Fleming 1536272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1537272cc70bSAndy Fleming 1538272cc70bSAndy Fleming if (err) 1539272cc70bSAndy Fleming return err; 1540272cc70bSAndy Fleming 1541998be3ddSRabin Vincent if ((cmd.response[0] & 0xff) != 0xaa) 1542272cc70bSAndy Fleming return UNUSABLE_ERR; 1543272cc70bSAndy Fleming else 1544272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 1545272cc70bSAndy Fleming 1546272cc70bSAndy Fleming return 0; 1547272cc70bSAndy Fleming } 1548272cc70bSAndy Fleming 154993bfd616SPantelis Antoniou /* not used any more */ 155093bfd616SPantelis Antoniou int __deprecated mmc_register(struct mmc *mmc) 1551272cc70bSAndy Fleming { 155293bfd616SPantelis Antoniou #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 155393bfd616SPantelis Antoniou printf("%s is deprecated! use mmc_create() instead.\n", __func__); 155493bfd616SPantelis Antoniou #endif 155593bfd616SPantelis Antoniou return -1; 155693bfd616SPantelis Antoniou } 155793bfd616SPantelis Antoniou 155893bfd616SPantelis Antoniou struct mmc *mmc_create(const struct mmc_config *cfg, void *priv) 155993bfd616SPantelis Antoniou { 156093bfd616SPantelis Antoniou struct mmc *mmc; 156193bfd616SPantelis Antoniou 156293bfd616SPantelis Antoniou /* quick validation */ 156393bfd616SPantelis Antoniou if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL || 156493bfd616SPantelis Antoniou cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0) 156593bfd616SPantelis Antoniou return NULL; 156693bfd616SPantelis Antoniou 156793bfd616SPantelis Antoniou mmc = calloc(1, sizeof(*mmc)); 156893bfd616SPantelis Antoniou if (mmc == NULL) 156993bfd616SPantelis Antoniou return NULL; 157093bfd616SPantelis Antoniou 157193bfd616SPantelis Antoniou mmc->cfg = cfg; 157293bfd616SPantelis Antoniou mmc->priv = priv; 157393bfd616SPantelis Antoniou 157493bfd616SPantelis Antoniou /* the following chunk was mmc_register() */ 157593bfd616SPantelis Antoniou 1576ab71188cSMarkus Niebel /* Setup dsr related values */ 1577ab71188cSMarkus Niebel mmc->dsr_imp = 0; 1578ab71188cSMarkus Niebel mmc->dsr = 0xffffffff; 1579272cc70bSAndy Fleming /* Setup the universal parts of the block interface just once */ 1580272cc70bSAndy Fleming mmc->block_dev.if_type = IF_TYPE_MMC; 1581bcce53d0SSimon Glass mmc->block_dev.devnum = cur_dev_num++; 1582272cc70bSAndy Fleming mmc->block_dev.removable = 1; 1583272cc70bSAndy Fleming mmc->block_dev.block_read = mmc_bread; 1584272cc70bSAndy Fleming mmc->block_dev.block_write = mmc_bwrite; 1585e6f99a56SLei Wen mmc->block_dev.block_erase = mmc_berase; 158693bfd616SPantelis Antoniou 158793bfd616SPantelis Antoniou /* setup initial part type */ 158893bfd616SPantelis Antoniou mmc->block_dev.part_type = mmc->cfg->part_type; 1589272cc70bSAndy Fleming 1590272cc70bSAndy Fleming INIT_LIST_HEAD(&mmc->link); 1591272cc70bSAndy Fleming 1592272cc70bSAndy Fleming list_add_tail(&mmc->link, &mmc_devices); 1593272cc70bSAndy Fleming 159493bfd616SPantelis Antoniou return mmc; 159593bfd616SPantelis Antoniou } 159693bfd616SPantelis Antoniou 159793bfd616SPantelis Antoniou void mmc_destroy(struct mmc *mmc) 159893bfd616SPantelis Antoniou { 159993bfd616SPantelis Antoniou /* only freeing memory for now */ 160093bfd616SPantelis Antoniou free(mmc); 1601272cc70bSAndy Fleming } 1602272cc70bSAndy Fleming 16033c457f4dSSimon Glass static int mmc_get_dev(int dev, struct blk_desc **descp) 1604663acabdSSimon Glass { 1605663acabdSSimon Glass struct mmc *mmc = find_mmc_device(dev); 1606663acabdSSimon Glass int ret; 1607663acabdSSimon Glass 1608663acabdSSimon Glass if (!mmc) 1609663acabdSSimon Glass return -ENODEV; 1610663acabdSSimon Glass ret = mmc_init(mmc); 1611663acabdSSimon Glass if (ret) 1612663acabdSSimon Glass return ret; 1613663acabdSSimon Glass 1614663acabdSSimon Glass *descp = &mmc->block_dev; 1615663acabdSSimon Glass 1616663acabdSSimon Glass return 0; 1617663acabdSSimon Glass } 1618663acabdSSimon Glass 161995de9ab2SPaul Kocialkowski /* board-specific MMC power initializations. */ 162095de9ab2SPaul Kocialkowski __weak void board_mmc_power_init(void) 162195de9ab2SPaul Kocialkowski { 162295de9ab2SPaul Kocialkowski } 162395de9ab2SPaul Kocialkowski 1624e9550449SChe-Liang Chiou int mmc_start_init(struct mmc *mmc) 1625272cc70bSAndy Fleming { 1626afd5932bSMacpaul Lin int err; 1627272cc70bSAndy Fleming 1628ab769f22SPantelis Antoniou /* we pretend there's no card when init is NULL */ 162993bfd616SPantelis Antoniou if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) { 163048972d90SThierry Reding mmc->has_init = 0; 163156196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 163248972d90SThierry Reding printf("MMC: no card present\n"); 163356196826SPaul Burton #endif 163448972d90SThierry Reding return NO_CARD_ERR; 163548972d90SThierry Reding } 163648972d90SThierry Reding 1637bc897b1dSLei Wen if (mmc->has_init) 1638bc897b1dSLei Wen return 0; 1639bc897b1dSLei Wen 16405a8dbdc6SYangbo Lu #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 16415a8dbdc6SYangbo Lu mmc_adapter_card_type_ident(); 16425a8dbdc6SYangbo Lu #endif 164395de9ab2SPaul Kocialkowski board_mmc_power_init(); 164495de9ab2SPaul Kocialkowski 1645ab769f22SPantelis Antoniou /* made sure it's not NULL earlier */ 164693bfd616SPantelis Antoniou err = mmc->cfg->ops->init(mmc); 1647272cc70bSAndy Fleming 1648272cc70bSAndy Fleming if (err) 1649272cc70bSAndy Fleming return err; 1650272cc70bSAndy Fleming 1651786e8f81SAndrew Gabbasov mmc->ddr_mode = 0; 1652b86b85e2SIlya Yanok mmc_set_bus_width(mmc, 1); 1653b86b85e2SIlya Yanok mmc_set_clock(mmc, 1); 1654b86b85e2SIlya Yanok 1655272cc70bSAndy Fleming /* Reset the Card */ 1656272cc70bSAndy Fleming err = mmc_go_idle(mmc); 1657272cc70bSAndy Fleming 1658272cc70bSAndy Fleming if (err) 1659272cc70bSAndy Fleming return err; 1660272cc70bSAndy Fleming 1661bc897b1dSLei Wen /* The internal partition reset to user partition(0) at every CMD0*/ 1662873cc1d7SStephen Warren mmc->block_dev.hwpart = 0; 1663bc897b1dSLei Wen 1664272cc70bSAndy Fleming /* Test for SD version 2 */ 1665272cc70bSAndy Fleming err = mmc_send_if_cond(mmc); 1666272cc70bSAndy Fleming 1667272cc70bSAndy Fleming /* Now try to get the SD card's operating condition */ 1668272cc70bSAndy Fleming err = sd_send_op_cond(mmc); 1669272cc70bSAndy Fleming 1670272cc70bSAndy Fleming /* If the command timed out, we check for an MMC card */ 1671272cc70bSAndy Fleming if (err == TIMEOUT) { 1672272cc70bSAndy Fleming err = mmc_send_op_cond(mmc); 1673272cc70bSAndy Fleming 1674bd47c135SAndrew Gabbasov if (err) { 167556196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 1676272cc70bSAndy Fleming printf("Card did not respond to voltage select!\n"); 167756196826SPaul Burton #endif 1678272cc70bSAndy Fleming return UNUSABLE_ERR; 1679272cc70bSAndy Fleming } 1680272cc70bSAndy Fleming } 1681272cc70bSAndy Fleming 1682bd47c135SAndrew Gabbasov if (!err) 1683e9550449SChe-Liang Chiou mmc->init_in_progress = 1; 1684e9550449SChe-Liang Chiou 1685e9550449SChe-Liang Chiou return err; 1686e9550449SChe-Liang Chiou } 1687e9550449SChe-Liang Chiou 1688e9550449SChe-Liang Chiou static int mmc_complete_init(struct mmc *mmc) 1689e9550449SChe-Liang Chiou { 1690e9550449SChe-Liang Chiou int err = 0; 1691e9550449SChe-Liang Chiou 1692bd47c135SAndrew Gabbasov mmc->init_in_progress = 0; 1693e9550449SChe-Liang Chiou if (mmc->op_cond_pending) 1694e9550449SChe-Liang Chiou err = mmc_complete_op_cond(mmc); 1695e9550449SChe-Liang Chiou 1696e9550449SChe-Liang Chiou if (!err) 1697bc897b1dSLei Wen err = mmc_startup(mmc); 1698bc897b1dSLei Wen if (err) 1699bc897b1dSLei Wen mmc->has_init = 0; 1700bc897b1dSLei Wen else 1701bc897b1dSLei Wen mmc->has_init = 1; 1702e9550449SChe-Liang Chiou return err; 1703e9550449SChe-Liang Chiou } 1704e9550449SChe-Liang Chiou 1705e9550449SChe-Liang Chiou int mmc_init(struct mmc *mmc) 1706e9550449SChe-Liang Chiou { 1707bd47c135SAndrew Gabbasov int err = 0; 1708d803fea5SMateusz Zalega unsigned start; 1709e9550449SChe-Liang Chiou 1710e9550449SChe-Liang Chiou if (mmc->has_init) 1711e9550449SChe-Liang Chiou return 0; 1712d803fea5SMateusz Zalega 1713d803fea5SMateusz Zalega start = get_timer(0); 1714d803fea5SMateusz Zalega 1715e9550449SChe-Liang Chiou if (!mmc->init_in_progress) 1716e9550449SChe-Liang Chiou err = mmc_start_init(mmc); 1717e9550449SChe-Liang Chiou 1718bd47c135SAndrew Gabbasov if (!err) 1719e9550449SChe-Liang Chiou err = mmc_complete_init(mmc); 1720e9550449SChe-Liang Chiou debug("%s: %d, time %lu\n", __func__, err, get_timer(start)); 1721bc897b1dSLei Wen return err; 1722272cc70bSAndy Fleming } 1723272cc70bSAndy Fleming 1724ab71188cSMarkus Niebel int mmc_set_dsr(struct mmc *mmc, u16 val) 1725ab71188cSMarkus Niebel { 1726ab71188cSMarkus Niebel mmc->dsr = val; 1727ab71188cSMarkus Niebel return 0; 1728ab71188cSMarkus Niebel } 1729ab71188cSMarkus Niebel 1730cee9ab7cSJeroen Hofstee /* CPU-specific MMC initializations */ 1731cee9ab7cSJeroen Hofstee __weak int cpu_mmc_init(bd_t *bis) 1732272cc70bSAndy Fleming { 1733272cc70bSAndy Fleming return -1; 1734272cc70bSAndy Fleming } 1735272cc70bSAndy Fleming 1736cee9ab7cSJeroen Hofstee /* board-specific MMC initializations. */ 1737cee9ab7cSJeroen Hofstee __weak int board_mmc_init(bd_t *bis) 1738cee9ab7cSJeroen Hofstee { 1739cee9ab7cSJeroen Hofstee return -1; 1740cee9ab7cSJeroen Hofstee } 1741272cc70bSAndy Fleming 174256196826SPaul Burton #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT) 174356196826SPaul Burton 1744272cc70bSAndy Fleming void print_mmc_devices(char separator) 1745272cc70bSAndy Fleming { 1746272cc70bSAndy Fleming struct mmc *m; 1747272cc70bSAndy Fleming struct list_head *entry; 174834dd9284SPrzemyslaw Marczak char *mmc_type; 1749272cc70bSAndy Fleming 1750272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 1751272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 1752272cc70bSAndy Fleming 175334dd9284SPrzemyslaw Marczak if (m->has_init) 175434dd9284SPrzemyslaw Marczak mmc_type = IS_SD(m) ? "SD" : "eMMC"; 175534dd9284SPrzemyslaw Marczak else 175634dd9284SPrzemyslaw Marczak mmc_type = NULL; 175734dd9284SPrzemyslaw Marczak 1758bcce53d0SSimon Glass printf("%s: %d", m->cfg->name, m->block_dev.devnum); 175934dd9284SPrzemyslaw Marczak if (mmc_type) 176034dd9284SPrzemyslaw Marczak printf(" (%s)", mmc_type); 1761272cc70bSAndy Fleming 1762e75eaf10SLubomir Popov if (entry->next != &mmc_devices) { 1763272cc70bSAndy Fleming printf("%c", separator); 1764e75eaf10SLubomir Popov if (separator != '\n') 1765e75eaf10SLubomir Popov puts (" "); 1766e75eaf10SLubomir Popov } 1767272cc70bSAndy Fleming } 1768272cc70bSAndy Fleming 1769272cc70bSAndy Fleming printf("\n"); 1770272cc70bSAndy Fleming } 1771272cc70bSAndy Fleming 177256196826SPaul Burton #else 177356196826SPaul Burton void print_mmc_devices(char separator) { } 177456196826SPaul Burton #endif 177556196826SPaul Burton 1776ea6ebe21SLei Wen int get_mmc_num(void) 1777ea6ebe21SLei Wen { 1778ea6ebe21SLei Wen return cur_dev_num; 1779ea6ebe21SLei Wen } 1780ea6ebe21SLei Wen 1781e9550449SChe-Liang Chiou void mmc_set_preinit(struct mmc *mmc, int preinit) 1782e9550449SChe-Liang Chiou { 1783e9550449SChe-Liang Chiou mmc->preinit = preinit; 1784e9550449SChe-Liang Chiou } 1785e9550449SChe-Liang Chiou 1786e9550449SChe-Liang Chiou static void do_preinit(void) 1787e9550449SChe-Liang Chiou { 1788e9550449SChe-Liang Chiou struct mmc *m; 1789e9550449SChe-Liang Chiou struct list_head *entry; 1790e9550449SChe-Liang Chiou 1791e9550449SChe-Liang Chiou list_for_each(entry, &mmc_devices) { 1792e9550449SChe-Liang Chiou m = list_entry(entry, struct mmc, link); 1793e9550449SChe-Liang Chiou 17945a8dbdc6SYangbo Lu #ifdef CONFIG_FSL_ESDHC_ADAPTER_IDENT 17955a8dbdc6SYangbo Lu mmc_set_preinit(m, 1); 17965a8dbdc6SYangbo Lu #endif 1797e9550449SChe-Liang Chiou if (m->preinit) 1798e9550449SChe-Liang Chiou mmc_start_init(m); 1799e9550449SChe-Liang Chiou } 1800e9550449SChe-Liang Chiou } 1801e9550449SChe-Liang Chiou 18028e3332e2SSjoerd Simons #if defined(CONFIG_DM_MMC) && defined(CONFIG_SPL_BUILD) 18038e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 18048e3332e2SSjoerd Simons { 18058e3332e2SSjoerd Simons return 0; 18068e3332e2SSjoerd Simons } 18078e3332e2SSjoerd Simons #elif defined(CONFIG_DM_MMC) 18088e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 18098e3332e2SSjoerd Simons { 18104a1db6d8SSimon Glass int ret, i; 18118e3332e2SSjoerd Simons struct uclass *uc; 18124a1db6d8SSimon Glass struct udevice *dev; 18138e3332e2SSjoerd Simons 18148e3332e2SSjoerd Simons ret = uclass_get(UCLASS_MMC, &uc); 18158e3332e2SSjoerd Simons if (ret) 18168e3332e2SSjoerd Simons return ret; 18178e3332e2SSjoerd Simons 18184a1db6d8SSimon Glass /* 18194a1db6d8SSimon Glass * Try to add them in sequence order. Really with driver model we 18204a1db6d8SSimon Glass * should allow holes, but the current MMC list does not allow that. 18214a1db6d8SSimon Glass * So if we request 0, 1, 3 we will get 0, 1, 2. 18224a1db6d8SSimon Glass */ 18234a1db6d8SSimon Glass for (i = 0; ; i++) { 18244a1db6d8SSimon Glass ret = uclass_get_device_by_seq(UCLASS_MMC, i, &dev); 18254a1db6d8SSimon Glass if (ret == -ENODEV) 18264a1db6d8SSimon Glass break; 18274a1db6d8SSimon Glass } 18284a1db6d8SSimon Glass uclass_foreach_dev(dev, uc) { 18294a1db6d8SSimon Glass ret = device_probe(dev); 18308e3332e2SSjoerd Simons if (ret) 18314a1db6d8SSimon Glass printf("%s - probe failed: %d\n", dev->name, ret); 18328e3332e2SSjoerd Simons } 18338e3332e2SSjoerd Simons 18348e3332e2SSjoerd Simons return 0; 18358e3332e2SSjoerd Simons } 18368e3332e2SSjoerd Simons #else 18378e3332e2SSjoerd Simons static int mmc_probe(bd_t *bis) 18388e3332e2SSjoerd Simons { 18398e3332e2SSjoerd Simons if (board_mmc_init(bis) < 0) 18408e3332e2SSjoerd Simons cpu_mmc_init(bis); 18418e3332e2SSjoerd Simons 18428e3332e2SSjoerd Simons return 0; 18438e3332e2SSjoerd Simons } 18448e3332e2SSjoerd Simons #endif 1845e9550449SChe-Liang Chiou 1846272cc70bSAndy Fleming int mmc_initialize(bd_t *bis) 1847272cc70bSAndy Fleming { 18481b26bab1SDaniel Kochmański static int initialized = 0; 18498e3332e2SSjoerd Simons int ret; 18501b26bab1SDaniel Kochmański if (initialized) /* Avoid initializing mmc multiple times */ 18511b26bab1SDaniel Kochmański return 0; 18521b26bab1SDaniel Kochmański initialized = 1; 18531b26bab1SDaniel Kochmański 1854272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc_devices); 1855272cc70bSAndy Fleming cur_dev_num = 0; 1856272cc70bSAndy Fleming 18578e3332e2SSjoerd Simons ret = mmc_probe(bis); 18588e3332e2SSjoerd Simons if (ret) 18598e3332e2SSjoerd Simons return ret; 1860272cc70bSAndy Fleming 1861bb0dc108SYing Zhang #ifndef CONFIG_SPL_BUILD 1862272cc70bSAndy Fleming print_mmc_devices(','); 1863bb0dc108SYing Zhang #endif 1864272cc70bSAndy Fleming 1865e9550449SChe-Liang Chiou do_preinit(); 1866272cc70bSAndy Fleming return 0; 1867272cc70bSAndy Fleming } 18683690d6d6SAmar 18693690d6d6SAmar #ifdef CONFIG_SUPPORT_EMMC_BOOT 18703690d6d6SAmar /* 18713690d6d6SAmar * This function changes the size of boot partition and the size of rpmb 18723690d6d6SAmar * partition present on EMMC devices. 18733690d6d6SAmar * 18743690d6d6SAmar * Input Parameters: 18753690d6d6SAmar * struct *mmc: pointer for the mmc device strcuture 18763690d6d6SAmar * bootsize: size of boot partition 18773690d6d6SAmar * rpmbsize: size of rpmb partition 18783690d6d6SAmar * 18793690d6d6SAmar * Returns 0 on success. 18803690d6d6SAmar */ 18813690d6d6SAmar 18823690d6d6SAmar int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize, 18833690d6d6SAmar unsigned long rpmbsize) 18843690d6d6SAmar { 18853690d6d6SAmar int err; 18863690d6d6SAmar struct mmc_cmd cmd; 18873690d6d6SAmar 18883690d6d6SAmar /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */ 18893690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 18903690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 18913690d6d6SAmar cmd.cmdarg = MMC_CMD62_ARG1; 18923690d6d6SAmar 18933690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 18943690d6d6SAmar if (err) { 18953690d6d6SAmar debug("mmc_boot_partition_size_change: Error1 = %d\n", err); 18963690d6d6SAmar return err; 18973690d6d6SAmar } 18983690d6d6SAmar 18993690d6d6SAmar /* Boot partition changing mode */ 19003690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 19013690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 19023690d6d6SAmar cmd.cmdarg = MMC_CMD62_ARG2; 19033690d6d6SAmar 19043690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 19053690d6d6SAmar if (err) { 19063690d6d6SAmar debug("mmc_boot_partition_size_change: Error2 = %d\n", err); 19073690d6d6SAmar return err; 19083690d6d6SAmar } 19093690d6d6SAmar /* boot partition size is multiple of 128KB */ 19103690d6d6SAmar bootsize = (bootsize * 1024) / 128; 19113690d6d6SAmar 19123690d6d6SAmar /* Arg: boot partition size */ 19133690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 19143690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 19153690d6d6SAmar cmd.cmdarg = bootsize; 19163690d6d6SAmar 19173690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 19183690d6d6SAmar if (err) { 19193690d6d6SAmar debug("mmc_boot_partition_size_change: Error3 = %d\n", err); 19203690d6d6SAmar return err; 19213690d6d6SAmar } 19223690d6d6SAmar /* RPMB partition size is multiple of 128KB */ 19233690d6d6SAmar rpmbsize = (rpmbsize * 1024) / 128; 19243690d6d6SAmar /* Arg: RPMB partition size */ 19253690d6d6SAmar cmd.cmdidx = MMC_CMD_RES_MAN; 19263690d6d6SAmar cmd.resp_type = MMC_RSP_R1b; 19273690d6d6SAmar cmd.cmdarg = rpmbsize; 19283690d6d6SAmar 19293690d6d6SAmar err = mmc_send_cmd(mmc, &cmd, NULL); 19303690d6d6SAmar if (err) { 19313690d6d6SAmar debug("mmc_boot_partition_size_change: Error4 = %d\n", err); 19323690d6d6SAmar return err; 19333690d6d6SAmar } 19343690d6d6SAmar return 0; 19353690d6d6SAmar } 19363690d6d6SAmar 19373690d6d6SAmar /* 19385a99b9deSTom Rini * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH 19395a99b9deSTom Rini * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH 19405a99b9deSTom Rini * and BOOT_MODE. 19415a99b9deSTom Rini * 19425a99b9deSTom Rini * Returns 0 on success. 19435a99b9deSTom Rini */ 19445a99b9deSTom Rini int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode) 19455a99b9deSTom Rini { 19465a99b9deSTom Rini int err; 19475a99b9deSTom Rini 19485a99b9deSTom Rini err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH, 19495a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) | 19505a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) | 19515a99b9deSTom Rini EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width)); 19525a99b9deSTom Rini 19535a99b9deSTom Rini if (err) 19545a99b9deSTom Rini return err; 19555a99b9deSTom Rini return 0; 19565a99b9deSTom Rini } 19575a99b9deSTom Rini 19585a99b9deSTom Rini /* 1959792970b0STom Rini * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG) 1960792970b0STom Rini * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and 1961792970b0STom Rini * PARTITION_ACCESS. 1962792970b0STom Rini * 1963792970b0STom Rini * Returns 0 on success. 1964792970b0STom Rini */ 1965792970b0STom Rini int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access) 1966792970b0STom Rini { 1967792970b0STom Rini int err; 1968792970b0STom Rini 1969792970b0STom Rini err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 1970792970b0STom Rini EXT_CSD_BOOT_ACK(ack) | 1971792970b0STom Rini EXT_CSD_BOOT_PART_NUM(part_num) | 1972792970b0STom Rini EXT_CSD_PARTITION_ACCESS(access)); 1973792970b0STom Rini 1974792970b0STom Rini if (err) 1975792970b0STom Rini return err; 1976792970b0STom Rini return 0; 1977792970b0STom Rini } 197833ace362STom Rini 197933ace362STom Rini /* 198033ace362STom Rini * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value 198133ace362STom Rini * for enable. Note that this is a write-once field for non-zero values. 198233ace362STom Rini * 198333ace362STom Rini * Returns 0 on success. 198433ace362STom Rini */ 198533ace362STom Rini int mmc_set_rst_n_function(struct mmc *mmc, u8 enable) 198633ace362STom Rini { 198733ace362STom Rini return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION, 198833ace362STom Rini enable); 198933ace362STom Rini } 19903690d6d6SAmar #endif 1991663acabdSSimon Glass 1992663acabdSSimon Glass U_BOOT_LEGACY_BLK(mmc) = { 1993663acabdSSimon Glass .if_typename = "mmc", 1994663acabdSSimon Glass .if_type = IF_TYPE_MMC, 1995663acabdSSimon Glass .max_devs = -1, 19963c457f4dSSimon Glass .get_dev = mmc_get_dev, 1997*e17d1143SSimon Glass .select_hwpart = mmc_select_hwpartp, 1998663acabdSSimon Glass }; 1999