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 * 7272cc70bSAndy Fleming * See file CREDITS for list of people who contributed to this 8272cc70bSAndy Fleming * project. 9272cc70bSAndy Fleming * 10272cc70bSAndy Fleming * This program is free software; you can redistribute it and/or 11272cc70bSAndy Fleming * modify it under the terms of the GNU General Public License as 12272cc70bSAndy Fleming * published by the Free Software Foundation; either version 2 of 13272cc70bSAndy Fleming * the License, or (at your option) any later version. 14272cc70bSAndy Fleming * 15272cc70bSAndy Fleming * This program is distributed in the hope that it will be useful, 16272cc70bSAndy Fleming * but WITHOUT ANY WARRANTY; without even the implied warranty of 17272cc70bSAndy Fleming * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18272cc70bSAndy Fleming * GNU General Public License for more details. 19272cc70bSAndy Fleming * 20272cc70bSAndy Fleming * You should have received a copy of the GNU General Public License 21272cc70bSAndy Fleming * along with this program; if not, write to the Free Software 22272cc70bSAndy Fleming * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 23272cc70bSAndy Fleming * MA 02111-1307 USA 24272cc70bSAndy Fleming */ 25272cc70bSAndy Fleming 26272cc70bSAndy Fleming #include <config.h> 27272cc70bSAndy Fleming #include <common.h> 28272cc70bSAndy Fleming #include <command.h> 29272cc70bSAndy Fleming #include <mmc.h> 30272cc70bSAndy Fleming #include <part.h> 31272cc70bSAndy Fleming #include <malloc.h> 32272cc70bSAndy Fleming #include <linux/list.h> 339b1f942cSRabin Vincent #include <div64.h> 34272cc70bSAndy Fleming 35ce0fbcd2SMatt Waddel /* Set block count limit because of 16 bit register limit on some hardware*/ 36ce0fbcd2SMatt Waddel #ifndef CONFIG_SYS_MMC_MAX_BLK_COUNT 37ce0fbcd2SMatt Waddel #define CONFIG_SYS_MMC_MAX_BLK_COUNT 65535 38ce0fbcd2SMatt Waddel #endif 39ce0fbcd2SMatt Waddel 40272cc70bSAndy Fleming static struct list_head mmc_devices; 41272cc70bSAndy Fleming static int cur_dev_num = -1; 42272cc70bSAndy Fleming 43314284b1SThierry Reding int __board_mmc_getcd(struct mmc *mmc) { 4411fdade2SStefano Babic return -1; 4511fdade2SStefano Babic } 4611fdade2SStefano Babic 47314284b1SThierry Reding int board_mmc_getcd(struct mmc *mmc)__attribute__((weak, 4811fdade2SStefano Babic alias("__board_mmc_getcd"))); 4911fdade2SStefano Babic 50fdbb873eSKim Phillips static int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, 51fdbb873eSKim Phillips struct mmc_data *data) 52272cc70bSAndy Fleming { 538635ff9eSMarek Vasut struct mmc_data backup; 545db2fe3aSRaffaele Recalcati int ret; 558635ff9eSMarek Vasut 568635ff9eSMarek Vasut memset(&backup, 0, sizeof(backup)); 578635ff9eSMarek Vasut 588635ff9eSMarek Vasut #ifdef CONFIG_MMC_TRACE 595db2fe3aSRaffaele Recalcati int i; 605db2fe3aSRaffaele Recalcati u8 *ptr; 615db2fe3aSRaffaele Recalcati 625db2fe3aSRaffaele Recalcati printf("CMD_SEND:%d\n", cmd->cmdidx); 635db2fe3aSRaffaele Recalcati printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg); 645db2fe3aSRaffaele Recalcati ret = mmc->send_cmd(mmc, cmd, data); 655db2fe3aSRaffaele Recalcati switch (cmd->resp_type) { 665db2fe3aSRaffaele Recalcati case MMC_RSP_NONE: 675db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_NONE\n"); 685db2fe3aSRaffaele Recalcati break; 695db2fe3aSRaffaele Recalcati case MMC_RSP_R1: 705db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n", 715db2fe3aSRaffaele Recalcati cmd->response[0]); 725db2fe3aSRaffaele Recalcati break; 735db2fe3aSRaffaele Recalcati case MMC_RSP_R1b: 745db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n", 755db2fe3aSRaffaele Recalcati cmd->response[0]); 765db2fe3aSRaffaele Recalcati break; 775db2fe3aSRaffaele Recalcati case MMC_RSP_R2: 785db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R2\t\t 0x%08X \n", 795db2fe3aSRaffaele Recalcati cmd->response[0]); 805db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 815db2fe3aSRaffaele Recalcati cmd->response[1]); 825db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 835db2fe3aSRaffaele Recalcati cmd->response[2]); 845db2fe3aSRaffaele Recalcati printf("\t\t \t\t 0x%08X \n", 855db2fe3aSRaffaele Recalcati cmd->response[3]); 865db2fe3aSRaffaele Recalcati printf("\n"); 875db2fe3aSRaffaele Recalcati printf("\t\t\t\t\tDUMPING DATA\n"); 885db2fe3aSRaffaele Recalcati for (i = 0; i < 4; i++) { 895db2fe3aSRaffaele Recalcati int j; 905db2fe3aSRaffaele Recalcati printf("\t\t\t\t\t%03d - ", i*4); 91146bec79SDirk Behme ptr = (u8 *)&cmd->response[i]; 925db2fe3aSRaffaele Recalcati ptr += 3; 935db2fe3aSRaffaele Recalcati for (j = 0; j < 4; j++) 945db2fe3aSRaffaele Recalcati printf("%02X ", *ptr--); 955db2fe3aSRaffaele Recalcati printf("\n"); 965db2fe3aSRaffaele Recalcati } 975db2fe3aSRaffaele Recalcati break; 985db2fe3aSRaffaele Recalcati case MMC_RSP_R3: 995db2fe3aSRaffaele Recalcati printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n", 1005db2fe3aSRaffaele Recalcati cmd->response[0]); 1015db2fe3aSRaffaele Recalcati break; 1025db2fe3aSRaffaele Recalcati default: 1035db2fe3aSRaffaele Recalcati printf("\t\tERROR MMC rsp not supported\n"); 1045db2fe3aSRaffaele Recalcati break; 1055db2fe3aSRaffaele Recalcati } 1065db2fe3aSRaffaele Recalcati #else 1078635ff9eSMarek Vasut ret = mmc->send_cmd(mmc, cmd, data); 1085db2fe3aSRaffaele Recalcati #endif 1098635ff9eSMarek Vasut return ret; 110272cc70bSAndy Fleming } 111272cc70bSAndy Fleming 112fdbb873eSKim Phillips static int mmc_send_status(struct mmc *mmc, int timeout) 1135d4fc8d9SRaffaele Recalcati { 1145d4fc8d9SRaffaele Recalcati struct mmc_cmd cmd; 115d617c426SJan Kloetzke int err, retries = 5; 1165d4fc8d9SRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1175d4fc8d9SRaffaele Recalcati int status; 1185d4fc8d9SRaffaele Recalcati #endif 1195d4fc8d9SRaffaele Recalcati 1205d4fc8d9SRaffaele Recalcati cmd.cmdidx = MMC_CMD_SEND_STATUS; 1215d4fc8d9SRaffaele Recalcati cmd.resp_type = MMC_RSP_R1; 122aaf3d41aSMarek Vasut if (!mmc_host_is_spi(mmc)) 123aaf3d41aSMarek Vasut cmd.cmdarg = mmc->rca << 16; 1245d4fc8d9SRaffaele Recalcati 1255d4fc8d9SRaffaele Recalcati do { 1265d4fc8d9SRaffaele Recalcati err = mmc_send_cmd(mmc, &cmd, NULL); 127d617c426SJan Kloetzke if (!err) { 128d617c426SJan Kloetzke if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) && 129d617c426SJan Kloetzke (cmd.response[0] & MMC_STATUS_CURR_STATE) != 130d617c426SJan Kloetzke MMC_STATE_PRG) 1315d4fc8d9SRaffaele Recalcati break; 132d617c426SJan Kloetzke else if (cmd.response[0] & MMC_STATUS_MASK) { 133d617c426SJan Kloetzke printf("Status Error: 0x%08X\n", 134d617c426SJan Kloetzke cmd.response[0]); 135d617c426SJan Kloetzke return COMM_ERR; 136d617c426SJan Kloetzke } 137d617c426SJan Kloetzke } else if (--retries < 0) 138d617c426SJan Kloetzke return err; 1395d4fc8d9SRaffaele Recalcati 1405d4fc8d9SRaffaele Recalcati udelay(1000); 1415d4fc8d9SRaffaele Recalcati 1425d4fc8d9SRaffaele Recalcati } while (timeout--); 1435d4fc8d9SRaffaele Recalcati 1445db2fe3aSRaffaele Recalcati #ifdef CONFIG_MMC_TRACE 1455db2fe3aSRaffaele Recalcati status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9; 1465db2fe3aSRaffaele Recalcati printf("CURR STATE:%d\n", status); 1475db2fe3aSRaffaele Recalcati #endif 1485b0c942fSJongman Heo if (timeout <= 0) { 1495d4fc8d9SRaffaele Recalcati printf("Timeout waiting card ready\n"); 1505d4fc8d9SRaffaele Recalcati return TIMEOUT; 1515d4fc8d9SRaffaele Recalcati } 1525d4fc8d9SRaffaele Recalcati 1535d4fc8d9SRaffaele Recalcati return 0; 1545d4fc8d9SRaffaele Recalcati } 1555d4fc8d9SRaffaele Recalcati 156fdbb873eSKim Phillips static int mmc_set_blocklen(struct mmc *mmc, int len) 157272cc70bSAndy Fleming { 158272cc70bSAndy Fleming struct mmc_cmd cmd; 159272cc70bSAndy Fleming 160272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 161272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 162272cc70bSAndy Fleming cmd.cmdarg = len; 163272cc70bSAndy Fleming 164272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, NULL); 165272cc70bSAndy Fleming } 166272cc70bSAndy Fleming 167272cc70bSAndy Fleming struct mmc *find_mmc_device(int dev_num) 168272cc70bSAndy Fleming { 169272cc70bSAndy Fleming struct mmc *m; 170272cc70bSAndy Fleming struct list_head *entry; 171272cc70bSAndy Fleming 172272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 173272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 174272cc70bSAndy Fleming 175272cc70bSAndy Fleming if (m->block_dev.dev == dev_num) 176272cc70bSAndy Fleming return m; 177272cc70bSAndy Fleming } 178272cc70bSAndy Fleming 179272cc70bSAndy Fleming printf("MMC Device %d not found\n", dev_num); 180272cc70bSAndy Fleming 181272cc70bSAndy Fleming return NULL; 182272cc70bSAndy Fleming } 183272cc70bSAndy Fleming 184e6f99a56SLei Wen static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt) 185e6f99a56SLei Wen { 186e6f99a56SLei Wen struct mmc_cmd cmd; 187e6f99a56SLei Wen ulong end; 188e6f99a56SLei Wen int err, start_cmd, end_cmd; 189e6f99a56SLei Wen 190e6f99a56SLei Wen if (mmc->high_capacity) 191e6f99a56SLei Wen end = start + blkcnt - 1; 192e6f99a56SLei Wen else { 193e6f99a56SLei Wen end = (start + blkcnt - 1) * mmc->write_bl_len; 194e6f99a56SLei Wen start *= mmc->write_bl_len; 195e6f99a56SLei Wen } 196e6f99a56SLei Wen 197e6f99a56SLei Wen if (IS_SD(mmc)) { 198e6f99a56SLei Wen start_cmd = SD_CMD_ERASE_WR_BLK_START; 199e6f99a56SLei Wen end_cmd = SD_CMD_ERASE_WR_BLK_END; 200e6f99a56SLei Wen } else { 201e6f99a56SLei Wen start_cmd = MMC_CMD_ERASE_GROUP_START; 202e6f99a56SLei Wen end_cmd = MMC_CMD_ERASE_GROUP_END; 203e6f99a56SLei Wen } 204e6f99a56SLei Wen 205e6f99a56SLei Wen cmd.cmdidx = start_cmd; 206e6f99a56SLei Wen cmd.cmdarg = start; 207e6f99a56SLei Wen cmd.resp_type = MMC_RSP_R1; 208e6f99a56SLei Wen 209e6f99a56SLei Wen err = mmc_send_cmd(mmc, &cmd, NULL); 210e6f99a56SLei Wen if (err) 211e6f99a56SLei Wen goto err_out; 212e6f99a56SLei Wen 213e6f99a56SLei Wen cmd.cmdidx = end_cmd; 214e6f99a56SLei Wen cmd.cmdarg = end; 215e6f99a56SLei Wen 216e6f99a56SLei Wen err = mmc_send_cmd(mmc, &cmd, NULL); 217e6f99a56SLei Wen if (err) 218e6f99a56SLei Wen goto err_out; 219e6f99a56SLei Wen 220e6f99a56SLei Wen cmd.cmdidx = MMC_CMD_ERASE; 221e6f99a56SLei Wen cmd.cmdarg = SECURE_ERASE; 222e6f99a56SLei Wen cmd.resp_type = MMC_RSP_R1b; 223e6f99a56SLei Wen 224e6f99a56SLei Wen err = mmc_send_cmd(mmc, &cmd, NULL); 225e6f99a56SLei Wen if (err) 226e6f99a56SLei Wen goto err_out; 227e6f99a56SLei Wen 228e6f99a56SLei Wen return 0; 229e6f99a56SLei Wen 230e6f99a56SLei Wen err_out: 231e6f99a56SLei Wen puts("mmc erase failed\n"); 232e6f99a56SLei Wen return err; 233e6f99a56SLei Wen } 234e6f99a56SLei Wen 235e6f99a56SLei Wen static unsigned long 236e6f99a56SLei Wen mmc_berase(int dev_num, unsigned long start, lbaint_t blkcnt) 237e6f99a56SLei Wen { 238e6f99a56SLei Wen int err = 0; 239e6f99a56SLei Wen struct mmc *mmc = find_mmc_device(dev_num); 240e6f99a56SLei Wen lbaint_t blk = 0, blk_r = 0; 241d2d8afaeSJerry Huang int timeout = 1000; 242e6f99a56SLei Wen 243e6f99a56SLei Wen if (!mmc) 244e6f99a56SLei Wen return -1; 245e6f99a56SLei Wen 246e6f99a56SLei Wen if ((start % mmc->erase_grp_size) || (blkcnt % mmc->erase_grp_size)) 247e6f99a56SLei Wen printf("\n\nCaution! Your devices Erase group is 0x%x\n" 248e6f99a56SLei Wen "The erase range would be change to 0x%lx~0x%lx\n\n", 249e6f99a56SLei Wen mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1), 250e6f99a56SLei Wen ((start + blkcnt + mmc->erase_grp_size) 251e6f99a56SLei Wen & ~(mmc->erase_grp_size - 1)) - 1); 252e6f99a56SLei Wen 253e6f99a56SLei Wen while (blk < blkcnt) { 254e6f99a56SLei Wen blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ? 255e6f99a56SLei Wen mmc->erase_grp_size : (blkcnt - blk); 256e6f99a56SLei Wen err = mmc_erase_t(mmc, start + blk, blk_r); 257e6f99a56SLei Wen if (err) 258e6f99a56SLei Wen break; 259e6f99a56SLei Wen 260e6f99a56SLei Wen blk += blk_r; 261d2d8afaeSJerry Huang 262d2d8afaeSJerry Huang /* Waiting for the ready status */ 263d2d8afaeSJerry Huang if (mmc_send_status(mmc, timeout)) 264d2d8afaeSJerry Huang return 0; 265e6f99a56SLei Wen } 266e6f99a56SLei Wen 267e6f99a56SLei Wen return blk; 268e6f99a56SLei Wen } 269e6f99a56SLei Wen 270272cc70bSAndy Fleming static ulong 2710158126eSLei Wen mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src) 272272cc70bSAndy Fleming { 273272cc70bSAndy Fleming struct mmc_cmd cmd; 274272cc70bSAndy Fleming struct mmc_data data; 2755d4fc8d9SRaffaele Recalcati int timeout = 1000; 276272cc70bSAndy Fleming 277d2bf29e3SLei Wen if ((start + blkcnt) > mmc->block_dev.lba) { 278def412b6SSteve Sakoman printf("MMC: block number 0x%lx exceeds max(0x%lx)\n", 279d2bf29e3SLei Wen start + blkcnt, mmc->block_dev.lba); 280d2bf29e3SLei Wen return 0; 281d2bf29e3SLei Wen } 282272cc70bSAndy Fleming 283272cc70bSAndy Fleming if (blkcnt > 1) 284272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; 285272cc70bSAndy Fleming else 286272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK; 287272cc70bSAndy Fleming 288272cc70bSAndy Fleming if (mmc->high_capacity) 289272cc70bSAndy Fleming cmd.cmdarg = start; 290272cc70bSAndy Fleming else 291def412b6SSteve Sakoman cmd.cmdarg = start * mmc->write_bl_len; 292272cc70bSAndy Fleming 293272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 294272cc70bSAndy Fleming 295272cc70bSAndy Fleming data.src = src; 296272cc70bSAndy Fleming data.blocks = blkcnt; 297def412b6SSteve Sakoman data.blocksize = mmc->write_bl_len; 298272cc70bSAndy Fleming data.flags = MMC_DATA_WRITE; 299272cc70bSAndy Fleming 300def412b6SSteve Sakoman if (mmc_send_cmd(mmc, &cmd, &data)) { 301def412b6SSteve Sakoman printf("mmc write failed\n"); 302def412b6SSteve Sakoman return 0; 303272cc70bSAndy Fleming } 304272cc70bSAndy Fleming 305d52ebf10SThomas Chou /* SPI multiblock writes terminate using a special 306d52ebf10SThomas Chou * token, not a STOP_TRANSMISSION request. 307d52ebf10SThomas Chou */ 308d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc) && blkcnt > 1) { 309272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 310272cc70bSAndy Fleming cmd.cmdarg = 0; 311272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 312def412b6SSteve Sakoman if (mmc_send_cmd(mmc, &cmd, NULL)) { 313def412b6SSteve Sakoman printf("mmc fail to send stop cmd\n"); 314def412b6SSteve Sakoman return 0; 315272cc70bSAndy Fleming } 31693ad0d18SJan Kloetzke } 3175d4fc8d9SRaffaele Recalcati 3185d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 31993ad0d18SJan Kloetzke if (mmc_send_status(mmc, timeout)) 32093ad0d18SJan Kloetzke return 0; 3210158126eSLei Wen 3220158126eSLei Wen return blkcnt; 3230158126eSLei Wen } 3240158126eSLei Wen 3250158126eSLei Wen static ulong 3260158126eSLei Wen mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src) 3270158126eSLei Wen { 3280158126eSLei Wen lbaint_t cur, blocks_todo = blkcnt; 3290158126eSLei Wen 330def412b6SSteve Sakoman struct mmc *mmc = find_mmc_device(dev_num); 3310158126eSLei Wen if (!mmc) 332def412b6SSteve Sakoman return 0; 3330158126eSLei Wen 334def412b6SSteve Sakoman if (mmc_set_blocklen(mmc, mmc->write_bl_len)) 335def412b6SSteve Sakoman return 0; 3360158126eSLei Wen 3370158126eSLei Wen do { 3388feafcc4SJohn Rigby cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo; 3390158126eSLei Wen if(mmc_write_blocks(mmc, start, cur, src) != cur) 340def412b6SSteve Sakoman return 0; 3410158126eSLei Wen blocks_todo -= cur; 3420158126eSLei Wen start += cur; 3430158126eSLei Wen src += cur * mmc->write_bl_len; 3440158126eSLei Wen } while (blocks_todo > 0); 345272cc70bSAndy Fleming 346272cc70bSAndy Fleming return blkcnt; 347272cc70bSAndy Fleming } 348272cc70bSAndy Fleming 349fdbb873eSKim Phillips static int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, 350fdbb873eSKim Phillips lbaint_t blkcnt) 351272cc70bSAndy Fleming { 352272cc70bSAndy Fleming struct mmc_cmd cmd; 353272cc70bSAndy Fleming struct mmc_data data; 354272cc70bSAndy Fleming 3554a1a06bcSAlagu Sankar if (blkcnt > 1) 3564a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK; 3574a1a06bcSAlagu Sankar else 358272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 359272cc70bSAndy Fleming 360272cc70bSAndy Fleming if (mmc->high_capacity) 3614a1a06bcSAlagu Sankar cmd.cmdarg = start; 362272cc70bSAndy Fleming else 3634a1a06bcSAlagu Sankar cmd.cmdarg = start * mmc->read_bl_len; 364272cc70bSAndy Fleming 365272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 366272cc70bSAndy Fleming 367272cc70bSAndy Fleming data.dest = dst; 3684a1a06bcSAlagu Sankar data.blocks = blkcnt; 369272cc70bSAndy Fleming data.blocksize = mmc->read_bl_len; 370272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 371272cc70bSAndy Fleming 3724a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, &data)) 3734a1a06bcSAlagu Sankar return 0; 3744a1a06bcSAlagu Sankar 3754a1a06bcSAlagu Sankar if (blkcnt > 1) { 3764a1a06bcSAlagu Sankar cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 3774a1a06bcSAlagu Sankar cmd.cmdarg = 0; 3784a1a06bcSAlagu Sankar cmd.resp_type = MMC_RSP_R1b; 3794a1a06bcSAlagu Sankar if (mmc_send_cmd(mmc, &cmd, NULL)) { 3804a1a06bcSAlagu Sankar printf("mmc fail to send stop cmd\n"); 3814a1a06bcSAlagu Sankar return 0; 3824a1a06bcSAlagu Sankar } 383272cc70bSAndy Fleming } 384272cc70bSAndy Fleming 3854a1a06bcSAlagu Sankar return blkcnt; 386272cc70bSAndy Fleming } 387272cc70bSAndy Fleming 388272cc70bSAndy Fleming static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst) 389272cc70bSAndy Fleming { 3904a1a06bcSAlagu Sankar lbaint_t cur, blocks_todo = blkcnt; 391272cc70bSAndy Fleming 3924a1a06bcSAlagu Sankar if (blkcnt == 0) 3934a1a06bcSAlagu Sankar return 0; 3944a1a06bcSAlagu Sankar 3954a1a06bcSAlagu Sankar struct mmc *mmc = find_mmc_device(dev_num); 396272cc70bSAndy Fleming if (!mmc) 397272cc70bSAndy Fleming return 0; 398272cc70bSAndy Fleming 399d2bf29e3SLei Wen if ((start + blkcnt) > mmc->block_dev.lba) { 4004a1a06bcSAlagu Sankar printf("MMC: block number 0x%lx exceeds max(0x%lx)\n", 401d2bf29e3SLei Wen start + blkcnt, mmc->block_dev.lba); 402d2bf29e3SLei Wen return 0; 403d2bf29e3SLei Wen } 404272cc70bSAndy Fleming 4054a1a06bcSAlagu Sankar if (mmc_set_blocklen(mmc, mmc->read_bl_len)) 406272cc70bSAndy Fleming return 0; 407272cc70bSAndy Fleming 4084a1a06bcSAlagu Sankar do { 4098feafcc4SJohn Rigby cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo; 4104a1a06bcSAlagu Sankar if(mmc_read_blocks(mmc, dst, start, cur) != cur) 4114a1a06bcSAlagu Sankar return 0; 4124a1a06bcSAlagu Sankar blocks_todo -= cur; 4134a1a06bcSAlagu Sankar start += cur; 4144a1a06bcSAlagu Sankar dst += cur * mmc->read_bl_len; 4154a1a06bcSAlagu Sankar } while (blocks_todo > 0); 416272cc70bSAndy Fleming 417272cc70bSAndy Fleming return blkcnt; 418272cc70bSAndy Fleming } 419272cc70bSAndy Fleming 420fdbb873eSKim Phillips static int mmc_go_idle(struct mmc *mmc) 421272cc70bSAndy Fleming { 422272cc70bSAndy Fleming struct mmc_cmd cmd; 423272cc70bSAndy Fleming int err; 424272cc70bSAndy Fleming 425272cc70bSAndy Fleming udelay(1000); 426272cc70bSAndy Fleming 427272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 428272cc70bSAndy Fleming cmd.cmdarg = 0; 429272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_NONE; 430272cc70bSAndy Fleming 431272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 432272cc70bSAndy Fleming 433272cc70bSAndy Fleming if (err) 434272cc70bSAndy Fleming return err; 435272cc70bSAndy Fleming 436272cc70bSAndy Fleming udelay(2000); 437272cc70bSAndy Fleming 438272cc70bSAndy Fleming return 0; 439272cc70bSAndy Fleming } 440272cc70bSAndy Fleming 441fdbb873eSKim Phillips static int sd_send_op_cond(struct mmc *mmc) 442272cc70bSAndy Fleming { 443272cc70bSAndy Fleming int timeout = 1000; 444272cc70bSAndy Fleming int err; 445272cc70bSAndy Fleming struct mmc_cmd cmd; 446272cc70bSAndy Fleming 447272cc70bSAndy Fleming do { 448272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 449272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 450272cc70bSAndy Fleming cmd.cmdarg = 0; 451272cc70bSAndy Fleming 452272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 453272cc70bSAndy Fleming 454272cc70bSAndy Fleming if (err) 455272cc70bSAndy Fleming return err; 456272cc70bSAndy Fleming 457272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 458272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 459250de12bSStefano Babic 460250de12bSStefano Babic /* 461250de12bSStefano Babic * Most cards do not answer if some reserved bits 462250de12bSStefano Babic * in the ocr are set. However, Some controller 463250de12bSStefano Babic * can set bit 7 (reserved for low voltages), but 464250de12bSStefano Babic * how to manage low voltages SD card is not yet 465250de12bSStefano Babic * specified. 466250de12bSStefano Babic */ 467d52ebf10SThomas Chou cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 : 468d52ebf10SThomas Chou (mmc->voltages & 0xff8000); 469272cc70bSAndy Fleming 470272cc70bSAndy Fleming if (mmc->version == SD_VERSION_2) 471272cc70bSAndy Fleming cmd.cmdarg |= OCR_HCS; 472272cc70bSAndy Fleming 473272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 474272cc70bSAndy Fleming 475272cc70bSAndy Fleming if (err) 476272cc70bSAndy Fleming return err; 477272cc70bSAndy Fleming 478272cc70bSAndy Fleming udelay(1000); 479272cc70bSAndy Fleming } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--); 480272cc70bSAndy Fleming 481272cc70bSAndy Fleming if (timeout <= 0) 482272cc70bSAndy Fleming return UNUSABLE_ERR; 483272cc70bSAndy Fleming 484272cc70bSAndy Fleming if (mmc->version != SD_VERSION_2) 485272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 486272cc70bSAndy Fleming 487d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 488d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 489d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 490d52ebf10SThomas Chou cmd.cmdarg = 0; 491d52ebf10SThomas Chou 492d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 493d52ebf10SThomas Chou 494d52ebf10SThomas Chou if (err) 495d52ebf10SThomas Chou return err; 496d52ebf10SThomas Chou } 497d52ebf10SThomas Chou 498998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 499272cc70bSAndy Fleming 500272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 501272cc70bSAndy Fleming mmc->rca = 0; 502272cc70bSAndy Fleming 503272cc70bSAndy Fleming return 0; 504272cc70bSAndy Fleming } 505272cc70bSAndy Fleming 506fdbb873eSKim Phillips static int mmc_send_op_cond(struct mmc *mmc) 507272cc70bSAndy Fleming { 50831cacbabSRaffaele Recalcati int timeout = 10000; 509272cc70bSAndy Fleming struct mmc_cmd cmd; 510272cc70bSAndy Fleming int err; 511272cc70bSAndy Fleming 512272cc70bSAndy Fleming /* Some cards seem to need this */ 513272cc70bSAndy Fleming mmc_go_idle(mmc); 514272cc70bSAndy Fleming 51531cacbabSRaffaele Recalcati /* Asking to the card its capabilities */ 51631cacbabSRaffaele Recalcati cmd.cmdidx = MMC_CMD_SEND_OP_COND; 51731cacbabSRaffaele Recalcati cmd.resp_type = MMC_RSP_R3; 51831cacbabSRaffaele Recalcati cmd.cmdarg = 0; 51931cacbabSRaffaele Recalcati 52031cacbabSRaffaele Recalcati err = mmc_send_cmd(mmc, &cmd, NULL); 52131cacbabSRaffaele Recalcati 52231cacbabSRaffaele Recalcati if (err) 52331cacbabSRaffaele Recalcati return err; 52431cacbabSRaffaele Recalcati 52531cacbabSRaffaele Recalcati udelay(1000); 52631cacbabSRaffaele Recalcati 527272cc70bSAndy Fleming do { 528272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_OP_COND; 529272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 53031cacbabSRaffaele Recalcati cmd.cmdarg = (mmc_host_is_spi(mmc) ? 0 : 53131cacbabSRaffaele Recalcati (mmc->voltages & 53231cacbabSRaffaele Recalcati (cmd.response[0] & OCR_VOLTAGE_MASK)) | 53331cacbabSRaffaele Recalcati (cmd.response[0] & OCR_ACCESS_MODE)); 534b1f1e821SŁukasz Majewski 535b1f1e821SŁukasz Majewski if (mmc->host_caps & MMC_MODE_HC) 536b1f1e821SŁukasz Majewski cmd.cmdarg |= OCR_HCS; 537b1f1e821SŁukasz Majewski 538272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 539272cc70bSAndy Fleming 540272cc70bSAndy Fleming if (err) 541272cc70bSAndy Fleming return err; 542272cc70bSAndy Fleming 543272cc70bSAndy Fleming udelay(1000); 544272cc70bSAndy Fleming } while (!(cmd.response[0] & OCR_BUSY) && timeout--); 545272cc70bSAndy Fleming 546272cc70bSAndy Fleming if (timeout <= 0) 547272cc70bSAndy Fleming return UNUSABLE_ERR; 548272cc70bSAndy Fleming 549d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* read OCR for spi */ 550d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_READ_OCR; 551d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R3; 552d52ebf10SThomas Chou cmd.cmdarg = 0; 553d52ebf10SThomas Chou 554d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 555d52ebf10SThomas Chou 556d52ebf10SThomas Chou if (err) 557d52ebf10SThomas Chou return err; 558d52ebf10SThomas Chou } 559d52ebf10SThomas Chou 560272cc70bSAndy Fleming mmc->version = MMC_VERSION_UNKNOWN; 561998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 562272cc70bSAndy Fleming 563272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 564272cc70bSAndy Fleming mmc->rca = 0; 565272cc70bSAndy Fleming 566272cc70bSAndy Fleming return 0; 567272cc70bSAndy Fleming } 568272cc70bSAndy Fleming 569272cc70bSAndy Fleming 570fdbb873eSKim Phillips static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd) 571272cc70bSAndy Fleming { 572272cc70bSAndy Fleming struct mmc_cmd cmd; 573272cc70bSAndy Fleming struct mmc_data data; 574272cc70bSAndy Fleming int err; 575272cc70bSAndy Fleming 576272cc70bSAndy Fleming /* Get the Card Status Register */ 577272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 578272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 579272cc70bSAndy Fleming cmd.cmdarg = 0; 580272cc70bSAndy Fleming 581cdfd1ac6SYoshihiro Shimoda data.dest = (char *)ext_csd; 582272cc70bSAndy Fleming data.blocks = 1; 583272cc70bSAndy Fleming data.blocksize = 512; 584272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 585272cc70bSAndy Fleming 586272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 587272cc70bSAndy Fleming 588272cc70bSAndy Fleming return err; 589272cc70bSAndy Fleming } 590272cc70bSAndy Fleming 591272cc70bSAndy Fleming 592fdbb873eSKim Phillips static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 593272cc70bSAndy Fleming { 594272cc70bSAndy Fleming struct mmc_cmd cmd; 5955d4fc8d9SRaffaele Recalcati int timeout = 1000; 5965d4fc8d9SRaffaele Recalcati int ret; 597272cc70bSAndy Fleming 598272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SWITCH; 599272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 600272cc70bSAndy Fleming cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 601272cc70bSAndy Fleming (index << 16) | 602272cc70bSAndy Fleming (value << 8); 603272cc70bSAndy Fleming 6045d4fc8d9SRaffaele Recalcati ret = mmc_send_cmd(mmc, &cmd, NULL); 6055d4fc8d9SRaffaele Recalcati 6065d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 60793ad0d18SJan Kloetzke if (!ret) 60893ad0d18SJan Kloetzke ret = mmc_send_status(mmc, timeout); 6095d4fc8d9SRaffaele Recalcati 6105d4fc8d9SRaffaele Recalcati return ret; 6115d4fc8d9SRaffaele Recalcati 612272cc70bSAndy Fleming } 613272cc70bSAndy Fleming 614fdbb873eSKim Phillips static int mmc_change_freq(struct mmc *mmc) 615272cc70bSAndy Fleming { 616cdfd1ac6SYoshihiro Shimoda ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, 512); 617272cc70bSAndy Fleming char cardtype; 618272cc70bSAndy Fleming int err; 619272cc70bSAndy Fleming 620272cc70bSAndy Fleming mmc->card_caps = 0; 621272cc70bSAndy Fleming 622d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 623d52ebf10SThomas Chou return 0; 624d52ebf10SThomas Chou 625272cc70bSAndy Fleming /* Only version 4 supports high-speed */ 626272cc70bSAndy Fleming if (mmc->version < MMC_VERSION_4) 627272cc70bSAndy Fleming return 0; 628272cc70bSAndy Fleming 629272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 630272cc70bSAndy Fleming 631272cc70bSAndy Fleming if (err) 632272cc70bSAndy Fleming return err; 633272cc70bSAndy Fleming 6340560db18SLei Wen cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf; 635272cc70bSAndy Fleming 636272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 637272cc70bSAndy Fleming 638272cc70bSAndy Fleming if (err) 639272cc70bSAndy Fleming return err; 640272cc70bSAndy Fleming 641272cc70bSAndy Fleming /* Now check to see that it worked */ 642272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 643272cc70bSAndy Fleming 644272cc70bSAndy Fleming if (err) 645272cc70bSAndy Fleming return err; 646272cc70bSAndy Fleming 647272cc70bSAndy Fleming /* No high-speed support */ 6480560db18SLei Wen if (!ext_csd[EXT_CSD_HS_TIMING]) 649272cc70bSAndy Fleming return 0; 650272cc70bSAndy Fleming 651272cc70bSAndy Fleming /* High Speed is set, there are two types: 52MHz and 26MHz */ 652272cc70bSAndy Fleming if (cardtype & MMC_HS_52MHZ) 653272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 654272cc70bSAndy Fleming else 655272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 656272cc70bSAndy Fleming 657272cc70bSAndy Fleming return 0; 658272cc70bSAndy Fleming } 659272cc70bSAndy Fleming 660bc897b1dSLei Wen int mmc_switch_part(int dev_num, unsigned int part_num) 661bc897b1dSLei Wen { 662bc897b1dSLei Wen struct mmc *mmc = find_mmc_device(dev_num); 663bc897b1dSLei Wen 664bc897b1dSLei Wen if (!mmc) 665bc897b1dSLei Wen return -1; 666bc897b1dSLei Wen 667bc897b1dSLei Wen return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF, 668bc897b1dSLei Wen (mmc->part_config & ~PART_ACCESS_MASK) 669bc897b1dSLei Wen | (part_num & PART_ACCESS_MASK)); 670bc897b1dSLei Wen } 671bc897b1dSLei Wen 67248972d90SThierry Reding int mmc_getcd(struct mmc *mmc) 67348972d90SThierry Reding { 67448972d90SThierry Reding int cd; 67548972d90SThierry Reding 67648972d90SThierry Reding cd = board_mmc_getcd(mmc); 67748972d90SThierry Reding 67848972d90SThierry Reding if ((cd < 0) && mmc->getcd) 67948972d90SThierry Reding cd = mmc->getcd(mmc); 68048972d90SThierry Reding 68148972d90SThierry Reding return cd; 68248972d90SThierry Reding } 68348972d90SThierry Reding 684fdbb873eSKim Phillips static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 685272cc70bSAndy Fleming { 686272cc70bSAndy Fleming struct mmc_cmd cmd; 687272cc70bSAndy Fleming struct mmc_data data; 688272cc70bSAndy Fleming 689272cc70bSAndy Fleming /* Switch the frequency */ 690272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SWITCH_FUNC; 691272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 692272cc70bSAndy Fleming cmd.cmdarg = (mode << 31) | 0xffffff; 693272cc70bSAndy Fleming cmd.cmdarg &= ~(0xf << (group * 4)); 694272cc70bSAndy Fleming cmd.cmdarg |= value << (group * 4); 695272cc70bSAndy Fleming 696272cc70bSAndy Fleming data.dest = (char *)resp; 697272cc70bSAndy Fleming data.blocksize = 64; 698272cc70bSAndy Fleming data.blocks = 1; 699272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 700272cc70bSAndy Fleming 701272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, &data); 702272cc70bSAndy Fleming } 703272cc70bSAndy Fleming 704272cc70bSAndy Fleming 705fdbb873eSKim Phillips static int sd_change_freq(struct mmc *mmc) 706272cc70bSAndy Fleming { 707272cc70bSAndy Fleming int err; 708272cc70bSAndy Fleming struct mmc_cmd cmd; 709f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2); 710f781dd38SAnton staaf ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16); 711272cc70bSAndy Fleming struct mmc_data data; 712272cc70bSAndy Fleming int timeout; 713272cc70bSAndy Fleming 714272cc70bSAndy Fleming mmc->card_caps = 0; 715272cc70bSAndy Fleming 716d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) 717d52ebf10SThomas Chou return 0; 718d52ebf10SThomas Chou 719272cc70bSAndy Fleming /* Read the SCR to find out if this card supports higher speeds */ 720272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 721272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 722272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 723272cc70bSAndy Fleming 724272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 725272cc70bSAndy Fleming 726272cc70bSAndy Fleming if (err) 727272cc70bSAndy Fleming return err; 728272cc70bSAndy Fleming 729272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_SCR; 730272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 731272cc70bSAndy Fleming cmd.cmdarg = 0; 732272cc70bSAndy Fleming 733272cc70bSAndy Fleming timeout = 3; 734272cc70bSAndy Fleming 735272cc70bSAndy Fleming retry_scr: 736f781dd38SAnton staaf data.dest = (char *)scr; 737272cc70bSAndy Fleming data.blocksize = 8; 738272cc70bSAndy Fleming data.blocks = 1; 739272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 740272cc70bSAndy Fleming 741272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 742272cc70bSAndy Fleming 743272cc70bSAndy Fleming if (err) { 744272cc70bSAndy Fleming if (timeout--) 745272cc70bSAndy Fleming goto retry_scr; 746272cc70bSAndy Fleming 747272cc70bSAndy Fleming return err; 748272cc70bSAndy Fleming } 749272cc70bSAndy Fleming 7504e3d89baSYauhen Kharuzhy mmc->scr[0] = __be32_to_cpu(scr[0]); 7514e3d89baSYauhen Kharuzhy mmc->scr[1] = __be32_to_cpu(scr[1]); 752272cc70bSAndy Fleming 753272cc70bSAndy Fleming switch ((mmc->scr[0] >> 24) & 0xf) { 754272cc70bSAndy Fleming case 0: 755272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 756272cc70bSAndy Fleming break; 757272cc70bSAndy Fleming case 1: 758272cc70bSAndy Fleming mmc->version = SD_VERSION_1_10; 759272cc70bSAndy Fleming break; 760272cc70bSAndy Fleming case 2: 761272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 762272cc70bSAndy Fleming break; 763272cc70bSAndy Fleming default: 764272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 765272cc70bSAndy Fleming break; 766272cc70bSAndy Fleming } 767272cc70bSAndy Fleming 768b44c7083SAlagu Sankar if (mmc->scr[0] & SD_DATA_4BIT) 769b44c7083SAlagu Sankar mmc->card_caps |= MMC_MODE_4BIT; 770b44c7083SAlagu Sankar 771272cc70bSAndy Fleming /* Version 1.0 doesn't support switching */ 772272cc70bSAndy Fleming if (mmc->version == SD_VERSION_1_0) 773272cc70bSAndy Fleming return 0; 774272cc70bSAndy Fleming 775272cc70bSAndy Fleming timeout = 4; 776272cc70bSAndy Fleming while (timeout--) { 777272cc70bSAndy Fleming err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 778f781dd38SAnton staaf (u8 *)switch_status); 779272cc70bSAndy Fleming 780272cc70bSAndy Fleming if (err) 781272cc70bSAndy Fleming return err; 782272cc70bSAndy Fleming 783272cc70bSAndy Fleming /* The high-speed function is busy. Try again */ 7844e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 785272cc70bSAndy Fleming break; 786272cc70bSAndy Fleming } 787272cc70bSAndy Fleming 788272cc70bSAndy Fleming /* If high-speed isn't supported, we return */ 7894e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 790272cc70bSAndy Fleming return 0; 791272cc70bSAndy Fleming 7922c3fbf4cSMacpaul Lin /* 7932c3fbf4cSMacpaul Lin * If the host doesn't support SD_HIGHSPEED, do not switch card to 7942c3fbf4cSMacpaul Lin * HIGHSPEED mode even if the card support SD_HIGHSPPED. 7952c3fbf4cSMacpaul Lin * This can avoid furthur problem when the card runs in different 7962c3fbf4cSMacpaul Lin * mode between the host. 7972c3fbf4cSMacpaul Lin */ 7982c3fbf4cSMacpaul Lin if (!((mmc->host_caps & MMC_MODE_HS_52MHz) && 7992c3fbf4cSMacpaul Lin (mmc->host_caps & MMC_MODE_HS))) 8002c3fbf4cSMacpaul Lin return 0; 8012c3fbf4cSMacpaul Lin 802f781dd38SAnton staaf err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status); 803272cc70bSAndy Fleming 804272cc70bSAndy Fleming if (err) 805272cc70bSAndy Fleming return err; 806272cc70bSAndy Fleming 8074e3d89baSYauhen Kharuzhy if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 808272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 809272cc70bSAndy Fleming 810272cc70bSAndy Fleming return 0; 811272cc70bSAndy Fleming } 812272cc70bSAndy Fleming 813272cc70bSAndy Fleming /* frequency bases */ 814272cc70bSAndy Fleming /* divided by 10 to be nice to platforms without floating point */ 8155f837c2cSMike Frysinger static const int fbase[] = { 816272cc70bSAndy Fleming 10000, 817272cc70bSAndy Fleming 100000, 818272cc70bSAndy Fleming 1000000, 819272cc70bSAndy Fleming 10000000, 820272cc70bSAndy Fleming }; 821272cc70bSAndy Fleming 822272cc70bSAndy Fleming /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 823272cc70bSAndy Fleming * to platforms without floating point. 824272cc70bSAndy Fleming */ 8255f837c2cSMike Frysinger static const int multipliers[] = { 826272cc70bSAndy Fleming 0, /* reserved */ 827272cc70bSAndy Fleming 10, 828272cc70bSAndy Fleming 12, 829272cc70bSAndy Fleming 13, 830272cc70bSAndy Fleming 15, 831272cc70bSAndy Fleming 20, 832272cc70bSAndy Fleming 25, 833272cc70bSAndy Fleming 30, 834272cc70bSAndy Fleming 35, 835272cc70bSAndy Fleming 40, 836272cc70bSAndy Fleming 45, 837272cc70bSAndy Fleming 50, 838272cc70bSAndy Fleming 55, 839272cc70bSAndy Fleming 60, 840272cc70bSAndy Fleming 70, 841272cc70bSAndy Fleming 80, 842272cc70bSAndy Fleming }; 843272cc70bSAndy Fleming 844fdbb873eSKim Phillips static void mmc_set_ios(struct mmc *mmc) 845272cc70bSAndy Fleming { 846272cc70bSAndy Fleming mmc->set_ios(mmc); 847272cc70bSAndy Fleming } 848272cc70bSAndy Fleming 849272cc70bSAndy Fleming void mmc_set_clock(struct mmc *mmc, uint clock) 850272cc70bSAndy Fleming { 851272cc70bSAndy Fleming if (clock > mmc->f_max) 852272cc70bSAndy Fleming clock = mmc->f_max; 853272cc70bSAndy Fleming 854272cc70bSAndy Fleming if (clock < mmc->f_min) 855272cc70bSAndy Fleming clock = mmc->f_min; 856272cc70bSAndy Fleming 857272cc70bSAndy Fleming mmc->clock = clock; 858272cc70bSAndy Fleming 859272cc70bSAndy Fleming mmc_set_ios(mmc); 860272cc70bSAndy Fleming } 861272cc70bSAndy Fleming 862fdbb873eSKim Phillips static void mmc_set_bus_width(struct mmc *mmc, uint width) 863272cc70bSAndy Fleming { 864272cc70bSAndy Fleming mmc->bus_width = width; 865272cc70bSAndy Fleming 866272cc70bSAndy Fleming mmc_set_ios(mmc); 867272cc70bSAndy Fleming } 868272cc70bSAndy Fleming 869fdbb873eSKim Phillips static int mmc_startup(struct mmc *mmc) 870272cc70bSAndy Fleming { 8714137894eSLei Wen int err, width; 872272cc70bSAndy Fleming uint mult, freq; 873639b7827SYoshihiro Shimoda u64 cmult, csize, capacity; 874272cc70bSAndy Fleming struct mmc_cmd cmd; 875cdfd1ac6SYoshihiro Shimoda ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, 512); 876cdfd1ac6SYoshihiro Shimoda ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, 512); 8775d4fc8d9SRaffaele Recalcati int timeout = 1000; 878272cc70bSAndy Fleming 879d52ebf10SThomas Chou #ifdef CONFIG_MMC_SPI_CRC_ON 880d52ebf10SThomas Chou if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */ 881d52ebf10SThomas Chou cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF; 882d52ebf10SThomas Chou cmd.resp_type = MMC_RSP_R1; 883d52ebf10SThomas Chou cmd.cmdarg = 1; 884d52ebf10SThomas Chou err = mmc_send_cmd(mmc, &cmd, NULL); 885d52ebf10SThomas Chou 886d52ebf10SThomas Chou if (err) 887d52ebf10SThomas Chou return err; 888d52ebf10SThomas Chou } 889d52ebf10SThomas Chou #endif 890d52ebf10SThomas Chou 891272cc70bSAndy Fleming /* Put the Card in Identify Mode */ 892d52ebf10SThomas Chou cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID : 893d52ebf10SThomas Chou MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */ 894272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 895272cc70bSAndy Fleming cmd.cmdarg = 0; 896272cc70bSAndy Fleming 897272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 898272cc70bSAndy Fleming 899272cc70bSAndy Fleming if (err) 900272cc70bSAndy Fleming return err; 901272cc70bSAndy Fleming 902272cc70bSAndy Fleming memcpy(mmc->cid, cmd.response, 16); 903272cc70bSAndy Fleming 904272cc70bSAndy Fleming /* 905272cc70bSAndy Fleming * For MMC cards, set the Relative Address. 906272cc70bSAndy Fleming * For SD cards, get the Relatvie Address. 907272cc70bSAndy Fleming * This also puts the cards into Standby State 908272cc70bSAndy Fleming */ 909d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 910272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 911272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 912272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R6; 913272cc70bSAndy Fleming 914272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 915272cc70bSAndy Fleming 916272cc70bSAndy Fleming if (err) 917272cc70bSAndy Fleming return err; 918272cc70bSAndy Fleming 919272cc70bSAndy Fleming if (IS_SD(mmc)) 920998be3ddSRabin Vincent mmc->rca = (cmd.response[0] >> 16) & 0xffff; 921d52ebf10SThomas Chou } 922272cc70bSAndy Fleming 923272cc70bSAndy Fleming /* Get the Card-Specific Data */ 924272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_CSD; 925272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 926272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 927272cc70bSAndy Fleming 928272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 929272cc70bSAndy Fleming 9305d4fc8d9SRaffaele Recalcati /* Waiting for the ready status */ 9315d4fc8d9SRaffaele Recalcati mmc_send_status(mmc, timeout); 9325d4fc8d9SRaffaele Recalcati 933272cc70bSAndy Fleming if (err) 934272cc70bSAndy Fleming return err; 935272cc70bSAndy Fleming 936998be3ddSRabin Vincent mmc->csd[0] = cmd.response[0]; 937998be3ddSRabin Vincent mmc->csd[1] = cmd.response[1]; 938998be3ddSRabin Vincent mmc->csd[2] = cmd.response[2]; 939998be3ddSRabin Vincent mmc->csd[3] = cmd.response[3]; 940272cc70bSAndy Fleming 941272cc70bSAndy Fleming if (mmc->version == MMC_VERSION_UNKNOWN) { 9420b453ffeSRabin Vincent int version = (cmd.response[0] >> 26) & 0xf; 943272cc70bSAndy Fleming 944272cc70bSAndy Fleming switch (version) { 945272cc70bSAndy Fleming case 0: 946272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 947272cc70bSAndy Fleming break; 948272cc70bSAndy Fleming case 1: 949272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_4; 950272cc70bSAndy Fleming break; 951272cc70bSAndy Fleming case 2: 952272cc70bSAndy Fleming mmc->version = MMC_VERSION_2_2; 953272cc70bSAndy Fleming break; 954272cc70bSAndy Fleming case 3: 955272cc70bSAndy Fleming mmc->version = MMC_VERSION_3; 956272cc70bSAndy Fleming break; 957272cc70bSAndy Fleming case 4: 958272cc70bSAndy Fleming mmc->version = MMC_VERSION_4; 959272cc70bSAndy Fleming break; 960272cc70bSAndy Fleming default: 961272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 962272cc70bSAndy Fleming break; 963272cc70bSAndy Fleming } 964272cc70bSAndy Fleming } 965272cc70bSAndy Fleming 966272cc70bSAndy Fleming /* divide frequency by 10, since the mults are 10x bigger */ 9670b453ffeSRabin Vincent freq = fbase[(cmd.response[0] & 0x7)]; 9680b453ffeSRabin Vincent mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 969272cc70bSAndy Fleming 970272cc70bSAndy Fleming mmc->tran_speed = freq * mult; 971272cc70bSAndy Fleming 972998be3ddSRabin Vincent mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 973272cc70bSAndy Fleming 974272cc70bSAndy Fleming if (IS_SD(mmc)) 975272cc70bSAndy Fleming mmc->write_bl_len = mmc->read_bl_len; 976272cc70bSAndy Fleming else 977998be3ddSRabin Vincent mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 978272cc70bSAndy Fleming 979272cc70bSAndy Fleming if (mmc->high_capacity) { 980272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3f) << 16 981272cc70bSAndy Fleming | (mmc->csd[2] & 0xffff0000) >> 16; 982272cc70bSAndy Fleming cmult = 8; 983272cc70bSAndy Fleming } else { 984272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3ff) << 2 985272cc70bSAndy Fleming | (mmc->csd[2] & 0xc0000000) >> 30; 986272cc70bSAndy Fleming cmult = (mmc->csd[2] & 0x00038000) >> 15; 987272cc70bSAndy Fleming } 988272cc70bSAndy Fleming 989272cc70bSAndy Fleming mmc->capacity = (csize + 1) << (cmult + 2); 990272cc70bSAndy Fleming mmc->capacity *= mmc->read_bl_len; 991272cc70bSAndy Fleming 992272cc70bSAndy Fleming if (mmc->read_bl_len > 512) 993272cc70bSAndy Fleming mmc->read_bl_len = 512; 994272cc70bSAndy Fleming 995272cc70bSAndy Fleming if (mmc->write_bl_len > 512) 996272cc70bSAndy Fleming mmc->write_bl_len = 512; 997272cc70bSAndy Fleming 998272cc70bSAndy Fleming /* Select the card, and put it into Transfer Mode */ 999d52ebf10SThomas Chou if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */ 1000272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SELECT_CARD; 1001fe8f7066SAjay Bhargav cmd.resp_type = MMC_RSP_R1; 1002272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1003272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1004272cc70bSAndy Fleming 1005272cc70bSAndy Fleming if (err) 1006272cc70bSAndy Fleming return err; 1007d52ebf10SThomas Chou } 1008272cc70bSAndy Fleming 1009e6f99a56SLei Wen /* 1010e6f99a56SLei Wen * For SD, its erase group is always one sector 1011e6f99a56SLei Wen */ 1012e6f99a56SLei Wen mmc->erase_grp_size = 1; 1013bc897b1dSLei Wen mmc->part_config = MMCPART_NOAVAILABLE; 1014d23e2c09SSukumar Ghorai if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) { 1015d23e2c09SSukumar Ghorai /* check ext_csd version and capacity */ 1016d23e2c09SSukumar Ghorai err = mmc_send_ext_csd(mmc, ext_csd); 1017fdbb873eSKim Phillips if (!err && (ext_csd[EXT_CSD_REV] >= 2)) { 1018639b7827SYoshihiro Shimoda /* 1019639b7827SYoshihiro Shimoda * According to the JEDEC Standard, the value of 1020639b7827SYoshihiro Shimoda * ext_csd's capacity is valid if the value is more 1021639b7827SYoshihiro Shimoda * than 2GB 1022639b7827SYoshihiro Shimoda */ 10230560db18SLei Wen capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 10240560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 10250560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 2] << 16 10260560db18SLei Wen | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; 1027639b7827SYoshihiro Shimoda capacity *= 512; 1028b1f1e821SŁukasz Majewski if ((capacity >> 20) > 2 * 1024) 1029639b7827SYoshihiro Shimoda mmc->capacity = capacity; 1030d23e2c09SSukumar Ghorai } 1031bc897b1dSLei Wen 1032e6f99a56SLei Wen /* 1033e6f99a56SLei Wen * Check whether GROUP_DEF is set, if yes, read out 1034e6f99a56SLei Wen * group size from ext_csd directly, or calculate 1035e6f99a56SLei Wen * the group size from the csd value. 1036e6f99a56SLei Wen */ 10370560db18SLei Wen if (ext_csd[EXT_CSD_ERASE_GROUP_DEF]) 10380560db18SLei Wen mmc->erase_grp_size = 10390560db18SLei Wen ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024; 1040e6f99a56SLei Wen else { 1041e6f99a56SLei Wen int erase_gsz, erase_gmul; 1042e6f99a56SLei Wen erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10; 1043e6f99a56SLei Wen erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5; 1044e6f99a56SLei Wen mmc->erase_grp_size = (erase_gsz + 1) 1045e6f99a56SLei Wen * (erase_gmul + 1); 1046e6f99a56SLei Wen } 1047e6f99a56SLei Wen 1048bc897b1dSLei Wen /* store the partition info of emmc */ 10498948ea83SStephen Warren if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) || 10508948ea83SStephen Warren ext_csd[EXT_CSD_BOOT_MULT]) 10510560db18SLei Wen mmc->part_config = ext_csd[EXT_CSD_PART_CONF]; 1052d23e2c09SSukumar Ghorai } 1053d23e2c09SSukumar Ghorai 1054272cc70bSAndy Fleming if (IS_SD(mmc)) 1055272cc70bSAndy Fleming err = sd_change_freq(mmc); 1056272cc70bSAndy Fleming else 1057272cc70bSAndy Fleming err = mmc_change_freq(mmc); 1058272cc70bSAndy Fleming 1059272cc70bSAndy Fleming if (err) 1060272cc70bSAndy Fleming return err; 1061272cc70bSAndy Fleming 1062272cc70bSAndy Fleming /* Restrict card's capabilities by what the host can do */ 1063272cc70bSAndy Fleming mmc->card_caps &= mmc->host_caps; 1064272cc70bSAndy Fleming 1065272cc70bSAndy Fleming if (IS_SD(mmc)) { 1066272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_4BIT) { 1067272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 1068272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1069272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 1070272cc70bSAndy Fleming 1071272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1072272cc70bSAndy Fleming if (err) 1073272cc70bSAndy Fleming return err; 1074272cc70bSAndy Fleming 1075272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 1076272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 1077272cc70bSAndy Fleming cmd.cmdarg = 2; 1078272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1079272cc70bSAndy Fleming if (err) 1080272cc70bSAndy Fleming return err; 1081272cc70bSAndy Fleming 1082272cc70bSAndy Fleming mmc_set_bus_width(mmc, 4); 1083272cc70bSAndy Fleming } 1084272cc70bSAndy Fleming 1085272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) 1086ad5fd922SJaehoon Chung mmc->tran_speed = 50000000; 1087272cc70bSAndy Fleming else 1088ad5fd922SJaehoon Chung mmc->tran_speed = 25000000; 1089272cc70bSAndy Fleming } else { 109062722036SŁukasz Majewski width = ((mmc->host_caps & MMC_MODE_MASK_WIDTH_BITS) >> 109162722036SŁukasz Majewski MMC_MODE_WIDTH_BITS_SHIFT); 109262722036SŁukasz Majewski for (; width >= 0; width--) { 1093272cc70bSAndy Fleming /* Set the card to use 4 bit*/ 1094272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 10954137894eSLei Wen EXT_CSD_BUS_WIDTH, width); 1096272cc70bSAndy Fleming 1097272cc70bSAndy Fleming if (err) 10984137894eSLei Wen continue; 1099272cc70bSAndy Fleming 11004137894eSLei Wen if (!width) { 11014137894eSLei Wen mmc_set_bus_width(mmc, 1); 11024137894eSLei Wen break; 11034137894eSLei Wen } else 11044137894eSLei Wen mmc_set_bus_width(mmc, 4 * width); 1105272cc70bSAndy Fleming 11064137894eSLei Wen err = mmc_send_ext_csd(mmc, test_csd); 11074137894eSLei Wen if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \ 11084137894eSLei Wen == test_csd[EXT_CSD_PARTITIONING_SUPPORT] 11094137894eSLei Wen && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \ 11104137894eSLei Wen == test_csd[EXT_CSD_ERASE_GROUP_DEF] \ 11114137894eSLei Wen && ext_csd[EXT_CSD_REV] \ 11124137894eSLei Wen == test_csd[EXT_CSD_REV] 11134137894eSLei Wen && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \ 11144137894eSLei Wen == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] 11154137894eSLei Wen && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \ 11164137894eSLei Wen &test_csd[EXT_CSD_SEC_CNT], 4) == 0) { 1117272cc70bSAndy Fleming 11184137894eSLei Wen mmc->card_caps |= width; 11194137894eSLei Wen break; 11204137894eSLei Wen } 1121272cc70bSAndy Fleming } 1122272cc70bSAndy Fleming 1123272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) { 1124272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS_52MHz) 1125ad5fd922SJaehoon Chung mmc->tran_speed = 52000000; 1126272cc70bSAndy Fleming else 1127ad5fd922SJaehoon Chung mmc->tran_speed = 26000000; 1128272cc70bSAndy Fleming } 1129ad5fd922SJaehoon Chung } 1130ad5fd922SJaehoon Chung 1131ad5fd922SJaehoon Chung mmc_set_clock(mmc, mmc->tran_speed); 1132272cc70bSAndy Fleming 1133272cc70bSAndy Fleming /* fill in device description */ 1134272cc70bSAndy Fleming mmc->block_dev.lun = 0; 1135272cc70bSAndy Fleming mmc->block_dev.type = 0; 1136272cc70bSAndy Fleming mmc->block_dev.blksz = mmc->read_bl_len; 11379b1f942cSRabin Vincent mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 1138*babce5f6STaylor Hutt sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x", 1139*babce5f6STaylor Hutt mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff), 1140*babce5f6STaylor Hutt (mmc->cid[3] >> 16) & 0xffff); 1141*babce5f6STaylor Hutt sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff, 11420b453ffeSRabin Vincent (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 1143*babce5f6STaylor Hutt (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff, 1144*babce5f6STaylor Hutt (mmc->cid[2] >> 24) & 0xff); 1145*babce5f6STaylor Hutt sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf, 1146*babce5f6STaylor Hutt (mmc->cid[2] >> 16) & 0xf); 1147122efd43SMikhail Kshevetskiy #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT) 1148272cc70bSAndy Fleming init_part(&mmc->block_dev); 1149122efd43SMikhail Kshevetskiy #endif 1150272cc70bSAndy Fleming 1151272cc70bSAndy Fleming return 0; 1152272cc70bSAndy Fleming } 1153272cc70bSAndy Fleming 1154fdbb873eSKim Phillips static int mmc_send_if_cond(struct mmc *mmc) 1155272cc70bSAndy Fleming { 1156272cc70bSAndy Fleming struct mmc_cmd cmd; 1157272cc70bSAndy Fleming int err; 1158272cc70bSAndy Fleming 1159272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_IF_COND; 1160272cc70bSAndy Fleming /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 1161272cc70bSAndy Fleming cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa; 1162272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R7; 1163272cc70bSAndy Fleming 1164272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 1165272cc70bSAndy Fleming 1166272cc70bSAndy Fleming if (err) 1167272cc70bSAndy Fleming return err; 1168272cc70bSAndy Fleming 1169998be3ddSRabin Vincent if ((cmd.response[0] & 0xff) != 0xaa) 1170272cc70bSAndy Fleming return UNUSABLE_ERR; 1171272cc70bSAndy Fleming else 1172272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 1173272cc70bSAndy Fleming 1174272cc70bSAndy Fleming return 0; 1175272cc70bSAndy Fleming } 1176272cc70bSAndy Fleming 1177272cc70bSAndy Fleming int mmc_register(struct mmc *mmc) 1178272cc70bSAndy Fleming { 1179272cc70bSAndy Fleming /* Setup the universal parts of the block interface just once */ 1180272cc70bSAndy Fleming mmc->block_dev.if_type = IF_TYPE_MMC; 1181272cc70bSAndy Fleming mmc->block_dev.dev = cur_dev_num++; 1182272cc70bSAndy Fleming mmc->block_dev.removable = 1; 1183272cc70bSAndy Fleming mmc->block_dev.block_read = mmc_bread; 1184272cc70bSAndy Fleming mmc->block_dev.block_write = mmc_bwrite; 1185e6f99a56SLei Wen mmc->block_dev.block_erase = mmc_berase; 11868feafcc4SJohn Rigby if (!mmc->b_max) 11878feafcc4SJohn Rigby mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT; 1188272cc70bSAndy Fleming 1189272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc->link); 1190272cc70bSAndy Fleming 1191272cc70bSAndy Fleming list_add_tail (&mmc->link, &mmc_devices); 1192272cc70bSAndy Fleming 1193272cc70bSAndy Fleming return 0; 1194272cc70bSAndy Fleming } 1195272cc70bSAndy Fleming 1196df3fc526SMatthew McClintock #ifdef CONFIG_PARTITIONS 1197272cc70bSAndy Fleming block_dev_desc_t *mmc_get_dev(int dev) 1198272cc70bSAndy Fleming { 1199272cc70bSAndy Fleming struct mmc *mmc = find_mmc_device(dev); 12006bb4b4bcSBenoît Thébaudeau if (!mmc || mmc_init(mmc)) 120140242bc3SŁukasz Majewski return NULL; 1202272cc70bSAndy Fleming 120340242bc3SŁukasz Majewski return &mmc->block_dev; 1204272cc70bSAndy Fleming } 1205df3fc526SMatthew McClintock #endif 1206272cc70bSAndy Fleming 1207272cc70bSAndy Fleming int mmc_init(struct mmc *mmc) 1208272cc70bSAndy Fleming { 1209afd5932bSMacpaul Lin int err; 1210272cc70bSAndy Fleming 121148972d90SThierry Reding if (mmc_getcd(mmc) == 0) { 121248972d90SThierry Reding mmc->has_init = 0; 121348972d90SThierry Reding printf("MMC: no card present\n"); 121448972d90SThierry Reding return NO_CARD_ERR; 121548972d90SThierry Reding } 121648972d90SThierry Reding 1217bc897b1dSLei Wen if (mmc->has_init) 1218bc897b1dSLei Wen return 0; 1219bc897b1dSLei Wen 1220272cc70bSAndy Fleming err = mmc->init(mmc); 1221272cc70bSAndy Fleming 1222272cc70bSAndy Fleming if (err) 1223272cc70bSAndy Fleming return err; 1224272cc70bSAndy Fleming 1225b86b85e2SIlya Yanok mmc_set_bus_width(mmc, 1); 1226b86b85e2SIlya Yanok mmc_set_clock(mmc, 1); 1227b86b85e2SIlya Yanok 1228272cc70bSAndy Fleming /* Reset the Card */ 1229272cc70bSAndy Fleming err = mmc_go_idle(mmc); 1230272cc70bSAndy Fleming 1231272cc70bSAndy Fleming if (err) 1232272cc70bSAndy Fleming return err; 1233272cc70bSAndy Fleming 1234bc897b1dSLei Wen /* The internal partition reset to user partition(0) at every CMD0*/ 1235bc897b1dSLei Wen mmc->part_num = 0; 1236bc897b1dSLei Wen 1237272cc70bSAndy Fleming /* Test for SD version 2 */ 1238272cc70bSAndy Fleming err = mmc_send_if_cond(mmc); 1239272cc70bSAndy Fleming 1240272cc70bSAndy Fleming /* Now try to get the SD card's operating condition */ 1241272cc70bSAndy Fleming err = sd_send_op_cond(mmc); 1242272cc70bSAndy Fleming 1243272cc70bSAndy Fleming /* If the command timed out, we check for an MMC card */ 1244272cc70bSAndy Fleming if (err == TIMEOUT) { 1245272cc70bSAndy Fleming err = mmc_send_op_cond(mmc); 1246272cc70bSAndy Fleming 1247272cc70bSAndy Fleming if (err) { 1248272cc70bSAndy Fleming printf("Card did not respond to voltage select!\n"); 1249272cc70bSAndy Fleming return UNUSABLE_ERR; 1250272cc70bSAndy Fleming } 1251272cc70bSAndy Fleming } 1252272cc70bSAndy Fleming 1253bc897b1dSLei Wen err = mmc_startup(mmc); 1254bc897b1dSLei Wen if (err) 1255bc897b1dSLei Wen mmc->has_init = 0; 1256bc897b1dSLei Wen else 1257bc897b1dSLei Wen mmc->has_init = 1; 1258bc897b1dSLei Wen return err; 1259272cc70bSAndy Fleming } 1260272cc70bSAndy Fleming 1261272cc70bSAndy Fleming /* 1262272cc70bSAndy Fleming * CPU and board-specific MMC initializations. Aliased function 1263272cc70bSAndy Fleming * signals caller to move on 1264272cc70bSAndy Fleming */ 1265272cc70bSAndy Fleming static int __def_mmc_init(bd_t *bis) 1266272cc70bSAndy Fleming { 1267272cc70bSAndy Fleming return -1; 1268272cc70bSAndy Fleming } 1269272cc70bSAndy Fleming 1270f9a109b3SPeter Tyser int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1271f9a109b3SPeter Tyser int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 1272272cc70bSAndy Fleming 1273272cc70bSAndy Fleming void print_mmc_devices(char separator) 1274272cc70bSAndy Fleming { 1275272cc70bSAndy Fleming struct mmc *m; 1276272cc70bSAndy Fleming struct list_head *entry; 1277272cc70bSAndy Fleming 1278272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 1279272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 1280272cc70bSAndy Fleming 1281272cc70bSAndy Fleming printf("%s: %d", m->name, m->block_dev.dev); 1282272cc70bSAndy Fleming 1283272cc70bSAndy Fleming if (entry->next != &mmc_devices) 1284272cc70bSAndy Fleming printf("%c ", separator); 1285272cc70bSAndy Fleming } 1286272cc70bSAndy Fleming 1287272cc70bSAndy Fleming printf("\n"); 1288272cc70bSAndy Fleming } 1289272cc70bSAndy Fleming 1290ea6ebe21SLei Wen int get_mmc_num(void) 1291ea6ebe21SLei Wen { 1292ea6ebe21SLei Wen return cur_dev_num; 1293ea6ebe21SLei Wen } 1294ea6ebe21SLei Wen 1295272cc70bSAndy Fleming int mmc_initialize(bd_t *bis) 1296272cc70bSAndy Fleming { 1297272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc_devices); 1298272cc70bSAndy Fleming cur_dev_num = 0; 1299272cc70bSAndy Fleming 1300272cc70bSAndy Fleming if (board_mmc_init(bis) < 0) 1301272cc70bSAndy Fleming cpu_mmc_init(bis); 1302272cc70bSAndy Fleming 1303272cc70bSAndy Fleming print_mmc_devices(','); 1304272cc70bSAndy Fleming 1305272cc70bSAndy Fleming return 0; 1306272cc70bSAndy Fleming } 1307