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> 33272cc70bSAndy Fleming #include <mmc.h> 349b1f942cSRabin Vincent #include <div64.h> 35272cc70bSAndy Fleming 36272cc70bSAndy Fleming static struct list_head mmc_devices; 37272cc70bSAndy Fleming static int cur_dev_num = -1; 38272cc70bSAndy Fleming 3911fdade2SStefano Babic int __board_mmc_getcd(u8 *cd, struct mmc *mmc) { 4011fdade2SStefano Babic return -1; 4111fdade2SStefano Babic } 4211fdade2SStefano Babic 4311fdade2SStefano Babic int board_mmc_getcd(u8 *cd, struct mmc *mmc)__attribute__((weak, 4411fdade2SStefano Babic alias("__board_mmc_getcd"))); 4511fdade2SStefano Babic 46272cc70bSAndy Fleming int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data) 47272cc70bSAndy Fleming { 48272cc70bSAndy Fleming return mmc->send_cmd(mmc, cmd, data); 49272cc70bSAndy Fleming } 50272cc70bSAndy Fleming 51272cc70bSAndy Fleming int mmc_set_blocklen(struct mmc *mmc, int len) 52272cc70bSAndy Fleming { 53272cc70bSAndy Fleming struct mmc_cmd cmd; 54272cc70bSAndy Fleming 55272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SET_BLOCKLEN; 56272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 57272cc70bSAndy Fleming cmd.cmdarg = len; 58272cc70bSAndy Fleming cmd.flags = 0; 59272cc70bSAndy Fleming 60272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, NULL); 61272cc70bSAndy Fleming } 62272cc70bSAndy Fleming 63272cc70bSAndy Fleming struct mmc *find_mmc_device(int dev_num) 64272cc70bSAndy Fleming { 65272cc70bSAndy Fleming struct mmc *m; 66272cc70bSAndy Fleming struct list_head *entry; 67272cc70bSAndy Fleming 68272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 69272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 70272cc70bSAndy Fleming 71272cc70bSAndy Fleming if (m->block_dev.dev == dev_num) 72272cc70bSAndy Fleming return m; 73272cc70bSAndy Fleming } 74272cc70bSAndy Fleming 75272cc70bSAndy Fleming printf("MMC Device %d not found\n", dev_num); 76272cc70bSAndy Fleming 77272cc70bSAndy Fleming return NULL; 78272cc70bSAndy Fleming } 79272cc70bSAndy Fleming 80272cc70bSAndy Fleming static ulong 81272cc70bSAndy Fleming mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src) 82272cc70bSAndy Fleming { 83272cc70bSAndy Fleming struct mmc_cmd cmd; 84272cc70bSAndy Fleming struct mmc_data data; 85272cc70bSAndy Fleming int err; 86272cc70bSAndy Fleming int stoperr = 0; 87272cc70bSAndy Fleming struct mmc *mmc = find_mmc_device(dev_num); 88272cc70bSAndy Fleming int blklen; 89272cc70bSAndy Fleming 90272cc70bSAndy Fleming if (!mmc) 91272cc70bSAndy Fleming return -1; 92272cc70bSAndy Fleming 93272cc70bSAndy Fleming blklen = mmc->write_bl_len; 94272cc70bSAndy Fleming 95272cc70bSAndy Fleming err = mmc_set_blocklen(mmc, mmc->write_bl_len); 96272cc70bSAndy Fleming 97272cc70bSAndy Fleming if (err) { 98272cc70bSAndy Fleming printf("set write bl len failed\n\r"); 99272cc70bSAndy Fleming return err; 100272cc70bSAndy Fleming } 101272cc70bSAndy Fleming 102272cc70bSAndy Fleming if (blkcnt > 1) 103272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; 104272cc70bSAndy Fleming else 105272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK; 106272cc70bSAndy Fleming 107272cc70bSAndy Fleming if (mmc->high_capacity) 108272cc70bSAndy Fleming cmd.cmdarg = start; 109272cc70bSAndy Fleming else 110272cc70bSAndy Fleming cmd.cmdarg = start * blklen; 111272cc70bSAndy Fleming 112272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 113272cc70bSAndy Fleming cmd.flags = 0; 114272cc70bSAndy Fleming 115272cc70bSAndy Fleming data.src = src; 116272cc70bSAndy Fleming data.blocks = blkcnt; 117272cc70bSAndy Fleming data.blocksize = blklen; 118272cc70bSAndy Fleming data.flags = MMC_DATA_WRITE; 119272cc70bSAndy Fleming 120272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 121272cc70bSAndy Fleming 122272cc70bSAndy Fleming if (err) { 123272cc70bSAndy Fleming printf("mmc write failed\n\r"); 124272cc70bSAndy Fleming return err; 125272cc70bSAndy Fleming } 126272cc70bSAndy Fleming 127272cc70bSAndy Fleming if (blkcnt > 1) { 128272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 129272cc70bSAndy Fleming cmd.cmdarg = 0; 130272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 131272cc70bSAndy Fleming cmd.flags = 0; 132272cc70bSAndy Fleming stoperr = mmc_send_cmd(mmc, &cmd, NULL); 133272cc70bSAndy Fleming } 134272cc70bSAndy Fleming 135272cc70bSAndy Fleming return blkcnt; 136272cc70bSAndy Fleming } 137272cc70bSAndy Fleming 138272cc70bSAndy Fleming int mmc_read_block(struct mmc *mmc, void *dst, uint blocknum) 139272cc70bSAndy Fleming { 140272cc70bSAndy Fleming struct mmc_cmd cmd; 141272cc70bSAndy Fleming struct mmc_data data; 142272cc70bSAndy Fleming 143272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK; 144272cc70bSAndy Fleming 145272cc70bSAndy Fleming if (mmc->high_capacity) 146272cc70bSAndy Fleming cmd.cmdarg = blocknum; 147272cc70bSAndy Fleming else 148272cc70bSAndy Fleming cmd.cmdarg = blocknum * mmc->read_bl_len; 149272cc70bSAndy Fleming 150272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 151272cc70bSAndy Fleming cmd.flags = 0; 152272cc70bSAndy Fleming 153272cc70bSAndy Fleming data.dest = dst; 154272cc70bSAndy Fleming data.blocks = 1; 155272cc70bSAndy Fleming data.blocksize = mmc->read_bl_len; 156272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 157272cc70bSAndy Fleming 158272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, &data); 159272cc70bSAndy Fleming } 160272cc70bSAndy Fleming 161272cc70bSAndy Fleming int mmc_read(struct mmc *mmc, u64 src, uchar *dst, int size) 162272cc70bSAndy Fleming { 163272cc70bSAndy Fleming char *buffer; 164272cc70bSAndy Fleming int i; 165272cc70bSAndy Fleming int blklen = mmc->read_bl_len; 1669b1f942cSRabin Vincent int startblock = lldiv(src, mmc->read_bl_len); 1679b1f942cSRabin Vincent int endblock = lldiv(src + size - 1, mmc->read_bl_len); 168272cc70bSAndy Fleming int err = 0; 169272cc70bSAndy Fleming 170272cc70bSAndy Fleming /* Make a buffer big enough to hold all the blocks we might read */ 171272cc70bSAndy Fleming buffer = malloc(blklen); 172272cc70bSAndy Fleming 173272cc70bSAndy Fleming if (!buffer) { 174272cc70bSAndy Fleming printf("Could not allocate buffer for MMC read!\n"); 175272cc70bSAndy Fleming return -1; 176272cc70bSAndy Fleming } 177272cc70bSAndy Fleming 178272cc70bSAndy Fleming /* We always do full block reads from the card */ 179272cc70bSAndy Fleming err = mmc_set_blocklen(mmc, mmc->read_bl_len); 180272cc70bSAndy Fleming 181272cc70bSAndy Fleming if (err) 182*8c4444ffSWolfgang Denk goto free_buffer; 183272cc70bSAndy Fleming 184272cc70bSAndy Fleming for (i = startblock; i <= endblock; i++) { 185272cc70bSAndy Fleming int segment_size; 186272cc70bSAndy Fleming int offset; 187272cc70bSAndy Fleming 188272cc70bSAndy Fleming err = mmc_read_block(mmc, buffer, i); 189272cc70bSAndy Fleming 190272cc70bSAndy Fleming if (err) 191272cc70bSAndy Fleming goto free_buffer; 192272cc70bSAndy Fleming 193272cc70bSAndy Fleming /* 194272cc70bSAndy Fleming * The first block may not be aligned, so we 195272cc70bSAndy Fleming * copy from the desired point in the block 196272cc70bSAndy Fleming */ 197272cc70bSAndy Fleming offset = (src & (blklen - 1)); 198272cc70bSAndy Fleming segment_size = MIN(blklen - offset, size); 199272cc70bSAndy Fleming 200272cc70bSAndy Fleming memcpy(dst, buffer + offset, segment_size); 201272cc70bSAndy Fleming 202272cc70bSAndy Fleming dst += segment_size; 203272cc70bSAndy Fleming src += segment_size; 204272cc70bSAndy Fleming size -= segment_size; 205272cc70bSAndy Fleming } 206272cc70bSAndy Fleming 207272cc70bSAndy Fleming free_buffer: 208272cc70bSAndy Fleming free(buffer); 209272cc70bSAndy Fleming 210272cc70bSAndy Fleming return err; 211272cc70bSAndy Fleming } 212272cc70bSAndy Fleming 213272cc70bSAndy Fleming static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst) 214272cc70bSAndy Fleming { 215272cc70bSAndy Fleming int err; 216272cc70bSAndy Fleming int i; 217272cc70bSAndy Fleming struct mmc *mmc = find_mmc_device(dev_num); 218272cc70bSAndy Fleming 219272cc70bSAndy Fleming if (!mmc) 220272cc70bSAndy Fleming return 0; 221272cc70bSAndy Fleming 222272cc70bSAndy Fleming /* We always do full block reads from the card */ 223272cc70bSAndy Fleming err = mmc_set_blocklen(mmc, mmc->read_bl_len); 224272cc70bSAndy Fleming 225272cc70bSAndy Fleming if (err) { 226272cc70bSAndy Fleming return 0; 227272cc70bSAndy Fleming } 228272cc70bSAndy Fleming 229272cc70bSAndy Fleming for (i = start; i < start + blkcnt; i++, dst += mmc->read_bl_len) { 230272cc70bSAndy Fleming err = mmc_read_block(mmc, dst, i); 231272cc70bSAndy Fleming 232272cc70bSAndy Fleming if (err) { 233272cc70bSAndy Fleming printf("block read failed: %d\n", err); 234272cc70bSAndy Fleming return i - start; 235272cc70bSAndy Fleming } 236272cc70bSAndy Fleming } 237272cc70bSAndy Fleming 238272cc70bSAndy Fleming return blkcnt; 239272cc70bSAndy Fleming } 240272cc70bSAndy Fleming 241272cc70bSAndy Fleming int mmc_go_idle(struct mmc* mmc) 242272cc70bSAndy Fleming { 243272cc70bSAndy Fleming struct mmc_cmd cmd; 244272cc70bSAndy Fleming int err; 245272cc70bSAndy Fleming 246272cc70bSAndy Fleming udelay(1000); 247272cc70bSAndy Fleming 248272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_GO_IDLE_STATE; 249272cc70bSAndy Fleming cmd.cmdarg = 0; 250272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_NONE; 251272cc70bSAndy Fleming cmd.flags = 0; 252272cc70bSAndy Fleming 253272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 254272cc70bSAndy Fleming 255272cc70bSAndy Fleming if (err) 256272cc70bSAndy Fleming return err; 257272cc70bSAndy Fleming 258272cc70bSAndy Fleming udelay(2000); 259272cc70bSAndy Fleming 260272cc70bSAndy Fleming return 0; 261272cc70bSAndy Fleming } 262272cc70bSAndy Fleming 263272cc70bSAndy Fleming int 264272cc70bSAndy Fleming sd_send_op_cond(struct mmc *mmc) 265272cc70bSAndy Fleming { 266272cc70bSAndy Fleming int timeout = 1000; 267272cc70bSAndy Fleming int err; 268272cc70bSAndy Fleming struct mmc_cmd cmd; 269272cc70bSAndy Fleming 270272cc70bSAndy Fleming do { 271272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 272272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 273272cc70bSAndy Fleming cmd.cmdarg = 0; 274272cc70bSAndy Fleming cmd.flags = 0; 275272cc70bSAndy Fleming 276272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 277272cc70bSAndy Fleming 278272cc70bSAndy Fleming if (err) 279272cc70bSAndy Fleming return err; 280272cc70bSAndy Fleming 281272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; 282272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 283250de12bSStefano Babic 284250de12bSStefano Babic /* 285250de12bSStefano Babic * Most cards do not answer if some reserved bits 286250de12bSStefano Babic * in the ocr are set. However, Some controller 287250de12bSStefano Babic * can set bit 7 (reserved for low voltages), but 288250de12bSStefano Babic * how to manage low voltages SD card is not yet 289250de12bSStefano Babic * specified. 290250de12bSStefano Babic */ 291250de12bSStefano Babic cmd.cmdarg = mmc->voltages & 0xff8000; 292272cc70bSAndy Fleming 293272cc70bSAndy Fleming if (mmc->version == SD_VERSION_2) 294272cc70bSAndy Fleming cmd.cmdarg |= OCR_HCS; 295272cc70bSAndy Fleming 296272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 297272cc70bSAndy Fleming 298272cc70bSAndy Fleming if (err) 299272cc70bSAndy Fleming return err; 300272cc70bSAndy Fleming 301272cc70bSAndy Fleming udelay(1000); 302272cc70bSAndy Fleming } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--); 303272cc70bSAndy Fleming 304272cc70bSAndy Fleming if (timeout <= 0) 305272cc70bSAndy Fleming return UNUSABLE_ERR; 306272cc70bSAndy Fleming 307272cc70bSAndy Fleming if (mmc->version != SD_VERSION_2) 308272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 309272cc70bSAndy Fleming 310998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 311272cc70bSAndy Fleming 312272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 313272cc70bSAndy Fleming mmc->rca = 0; 314272cc70bSAndy Fleming 315272cc70bSAndy Fleming return 0; 316272cc70bSAndy Fleming } 317272cc70bSAndy Fleming 318272cc70bSAndy Fleming int mmc_send_op_cond(struct mmc *mmc) 319272cc70bSAndy Fleming { 320272cc70bSAndy Fleming int timeout = 1000; 321272cc70bSAndy Fleming struct mmc_cmd cmd; 322272cc70bSAndy Fleming int err; 323272cc70bSAndy Fleming 324272cc70bSAndy Fleming /* Some cards seem to need this */ 325272cc70bSAndy Fleming mmc_go_idle(mmc); 326272cc70bSAndy Fleming 327272cc70bSAndy Fleming do { 328272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_OP_COND; 329272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R3; 330272cc70bSAndy Fleming cmd.cmdarg = OCR_HCS | mmc->voltages; 331272cc70bSAndy Fleming cmd.flags = 0; 332272cc70bSAndy Fleming 333272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 334272cc70bSAndy Fleming 335272cc70bSAndy Fleming if (err) 336272cc70bSAndy Fleming return err; 337272cc70bSAndy Fleming 338272cc70bSAndy Fleming udelay(1000); 339272cc70bSAndy Fleming } while (!(cmd.response[0] & OCR_BUSY) && timeout--); 340272cc70bSAndy Fleming 341272cc70bSAndy Fleming if (timeout <= 0) 342272cc70bSAndy Fleming return UNUSABLE_ERR; 343272cc70bSAndy Fleming 344272cc70bSAndy Fleming mmc->version = MMC_VERSION_UNKNOWN; 345998be3ddSRabin Vincent mmc->ocr = cmd.response[0]; 346272cc70bSAndy Fleming 347272cc70bSAndy Fleming mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS); 348272cc70bSAndy Fleming mmc->rca = 0; 349272cc70bSAndy Fleming 350272cc70bSAndy Fleming return 0; 351272cc70bSAndy Fleming } 352272cc70bSAndy Fleming 353272cc70bSAndy Fleming 354272cc70bSAndy Fleming int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd) 355272cc70bSAndy Fleming { 356272cc70bSAndy Fleming struct mmc_cmd cmd; 357272cc70bSAndy Fleming struct mmc_data data; 358272cc70bSAndy Fleming int err; 359272cc70bSAndy Fleming 360272cc70bSAndy Fleming /* Get the Card Status Register */ 361272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_EXT_CSD; 362272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 363272cc70bSAndy Fleming cmd.cmdarg = 0; 364272cc70bSAndy Fleming cmd.flags = 0; 365272cc70bSAndy Fleming 366272cc70bSAndy Fleming data.dest = ext_csd; 367272cc70bSAndy Fleming data.blocks = 1; 368272cc70bSAndy Fleming data.blocksize = 512; 369272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 370272cc70bSAndy Fleming 371272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 372272cc70bSAndy Fleming 373272cc70bSAndy Fleming return err; 374272cc70bSAndy Fleming } 375272cc70bSAndy Fleming 376272cc70bSAndy Fleming 377272cc70bSAndy Fleming int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value) 378272cc70bSAndy Fleming { 379272cc70bSAndy Fleming struct mmc_cmd cmd; 380272cc70bSAndy Fleming 381272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SWITCH; 382272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 383272cc70bSAndy Fleming cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 384272cc70bSAndy Fleming (index << 16) | 385272cc70bSAndy Fleming (value << 8); 386272cc70bSAndy Fleming cmd.flags = 0; 387272cc70bSAndy Fleming 388272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, NULL); 389272cc70bSAndy Fleming } 390272cc70bSAndy Fleming 391272cc70bSAndy Fleming int mmc_change_freq(struct mmc *mmc) 392272cc70bSAndy Fleming { 393272cc70bSAndy Fleming char ext_csd[512]; 394272cc70bSAndy Fleming char cardtype; 395272cc70bSAndy Fleming int err; 396272cc70bSAndy Fleming 397272cc70bSAndy Fleming mmc->card_caps = 0; 398272cc70bSAndy Fleming 399272cc70bSAndy Fleming /* Only version 4 supports high-speed */ 400272cc70bSAndy Fleming if (mmc->version < MMC_VERSION_4) 401272cc70bSAndy Fleming return 0; 402272cc70bSAndy Fleming 403272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_4BIT; 404272cc70bSAndy Fleming 405272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 406272cc70bSAndy Fleming 407272cc70bSAndy Fleming if (err) 408272cc70bSAndy Fleming return err; 409272cc70bSAndy Fleming 410272cc70bSAndy Fleming if (ext_csd[212] || ext_csd[213] || ext_csd[214] || ext_csd[215]) 411272cc70bSAndy Fleming mmc->high_capacity = 1; 412272cc70bSAndy Fleming 413272cc70bSAndy Fleming cardtype = ext_csd[196] & 0xf; 414272cc70bSAndy Fleming 415272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1); 416272cc70bSAndy Fleming 417272cc70bSAndy Fleming if (err) 418272cc70bSAndy Fleming return err; 419272cc70bSAndy Fleming 420272cc70bSAndy Fleming /* Now check to see that it worked */ 421272cc70bSAndy Fleming err = mmc_send_ext_csd(mmc, ext_csd); 422272cc70bSAndy Fleming 423272cc70bSAndy Fleming if (err) 424272cc70bSAndy Fleming return err; 425272cc70bSAndy Fleming 426272cc70bSAndy Fleming /* No high-speed support */ 427272cc70bSAndy Fleming if (!ext_csd[185]) 428272cc70bSAndy Fleming return 0; 429272cc70bSAndy Fleming 430272cc70bSAndy Fleming /* High Speed is set, there are two types: 52MHz and 26MHz */ 431272cc70bSAndy Fleming if (cardtype & MMC_HS_52MHZ) 432272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS; 433272cc70bSAndy Fleming else 434272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 435272cc70bSAndy Fleming 436272cc70bSAndy Fleming return 0; 437272cc70bSAndy Fleming } 438272cc70bSAndy Fleming 439272cc70bSAndy Fleming int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp) 440272cc70bSAndy Fleming { 441272cc70bSAndy Fleming struct mmc_cmd cmd; 442272cc70bSAndy Fleming struct mmc_data data; 443272cc70bSAndy Fleming 444272cc70bSAndy Fleming /* Switch the frequency */ 445272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SWITCH_FUNC; 446272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 447272cc70bSAndy Fleming cmd.cmdarg = (mode << 31) | 0xffffff; 448272cc70bSAndy Fleming cmd.cmdarg &= ~(0xf << (group * 4)); 449272cc70bSAndy Fleming cmd.cmdarg |= value << (group * 4); 450272cc70bSAndy Fleming cmd.flags = 0; 451272cc70bSAndy Fleming 452272cc70bSAndy Fleming data.dest = (char *)resp; 453272cc70bSAndy Fleming data.blocksize = 64; 454272cc70bSAndy Fleming data.blocks = 1; 455272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 456272cc70bSAndy Fleming 457272cc70bSAndy Fleming return mmc_send_cmd(mmc, &cmd, &data); 458272cc70bSAndy Fleming } 459272cc70bSAndy Fleming 460272cc70bSAndy Fleming 461272cc70bSAndy Fleming int sd_change_freq(struct mmc *mmc) 462272cc70bSAndy Fleming { 463272cc70bSAndy Fleming int err; 464272cc70bSAndy Fleming struct mmc_cmd cmd; 465272cc70bSAndy Fleming uint scr[2]; 466272cc70bSAndy Fleming uint switch_status[16]; 467272cc70bSAndy Fleming struct mmc_data data; 468272cc70bSAndy Fleming int timeout; 469272cc70bSAndy Fleming 470272cc70bSAndy Fleming mmc->card_caps = 0; 471272cc70bSAndy Fleming 472272cc70bSAndy Fleming /* Read the SCR to find out if this card supports higher speeds */ 473272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 474272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 475272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 476272cc70bSAndy Fleming cmd.flags = 0; 477272cc70bSAndy Fleming 478272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 479272cc70bSAndy Fleming 480272cc70bSAndy Fleming if (err) 481272cc70bSAndy Fleming return err; 482272cc70bSAndy Fleming 483272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SEND_SCR; 484272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 485272cc70bSAndy Fleming cmd.cmdarg = 0; 486272cc70bSAndy Fleming cmd.flags = 0; 487272cc70bSAndy Fleming 488272cc70bSAndy Fleming timeout = 3; 489272cc70bSAndy Fleming 490272cc70bSAndy Fleming retry_scr: 491272cc70bSAndy Fleming data.dest = (char *)&scr; 492272cc70bSAndy Fleming data.blocksize = 8; 493272cc70bSAndy Fleming data.blocks = 1; 494272cc70bSAndy Fleming data.flags = MMC_DATA_READ; 495272cc70bSAndy Fleming 496272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, &data); 497272cc70bSAndy Fleming 498272cc70bSAndy Fleming if (err) { 499272cc70bSAndy Fleming if (timeout--) 500272cc70bSAndy Fleming goto retry_scr; 501272cc70bSAndy Fleming 502272cc70bSAndy Fleming return err; 503272cc70bSAndy Fleming } 504272cc70bSAndy Fleming 5054e3d89baSYauhen Kharuzhy mmc->scr[0] = __be32_to_cpu(scr[0]); 5064e3d89baSYauhen Kharuzhy mmc->scr[1] = __be32_to_cpu(scr[1]); 507272cc70bSAndy Fleming 508272cc70bSAndy Fleming switch ((mmc->scr[0] >> 24) & 0xf) { 509272cc70bSAndy Fleming case 0: 510272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 511272cc70bSAndy Fleming break; 512272cc70bSAndy Fleming case 1: 513272cc70bSAndy Fleming mmc->version = SD_VERSION_1_10; 514272cc70bSAndy Fleming break; 515272cc70bSAndy Fleming case 2: 516272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 517272cc70bSAndy Fleming break; 518272cc70bSAndy Fleming default: 519272cc70bSAndy Fleming mmc->version = SD_VERSION_1_0; 520272cc70bSAndy Fleming break; 521272cc70bSAndy Fleming } 522272cc70bSAndy Fleming 523272cc70bSAndy Fleming /* Version 1.0 doesn't support switching */ 524272cc70bSAndy Fleming if (mmc->version == SD_VERSION_1_0) 525272cc70bSAndy Fleming return 0; 526272cc70bSAndy Fleming 527272cc70bSAndy Fleming timeout = 4; 528272cc70bSAndy Fleming while (timeout--) { 529272cc70bSAndy Fleming err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1, 530272cc70bSAndy Fleming (u8 *)&switch_status); 531272cc70bSAndy Fleming 532272cc70bSAndy Fleming if (err) 533272cc70bSAndy Fleming return err; 534272cc70bSAndy Fleming 535272cc70bSAndy Fleming /* The high-speed function is busy. Try again */ 5364e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY)) 537272cc70bSAndy Fleming break; 538272cc70bSAndy Fleming } 539272cc70bSAndy Fleming 540272cc70bSAndy Fleming if (mmc->scr[0] & SD_DATA_4BIT) 541272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_4BIT; 542272cc70bSAndy Fleming 543272cc70bSAndy Fleming /* If high-speed isn't supported, we return */ 5444e3d89baSYauhen Kharuzhy if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) 545272cc70bSAndy Fleming return 0; 546272cc70bSAndy Fleming 547272cc70bSAndy Fleming err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)&switch_status); 548272cc70bSAndy Fleming 549272cc70bSAndy Fleming if (err) 550272cc70bSAndy Fleming return err; 551272cc70bSAndy Fleming 5524e3d89baSYauhen Kharuzhy if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000) 553272cc70bSAndy Fleming mmc->card_caps |= MMC_MODE_HS; 554272cc70bSAndy Fleming 555272cc70bSAndy Fleming return 0; 556272cc70bSAndy Fleming } 557272cc70bSAndy Fleming 558272cc70bSAndy Fleming /* frequency bases */ 559272cc70bSAndy Fleming /* divided by 10 to be nice to platforms without floating point */ 560272cc70bSAndy Fleming int fbase[] = { 561272cc70bSAndy Fleming 10000, 562272cc70bSAndy Fleming 100000, 563272cc70bSAndy Fleming 1000000, 564272cc70bSAndy Fleming 10000000, 565272cc70bSAndy Fleming }; 566272cc70bSAndy Fleming 567272cc70bSAndy Fleming /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice 568272cc70bSAndy Fleming * to platforms without floating point. 569272cc70bSAndy Fleming */ 570272cc70bSAndy Fleming int multipliers[] = { 571272cc70bSAndy Fleming 0, /* reserved */ 572272cc70bSAndy Fleming 10, 573272cc70bSAndy Fleming 12, 574272cc70bSAndy Fleming 13, 575272cc70bSAndy Fleming 15, 576272cc70bSAndy Fleming 20, 577272cc70bSAndy Fleming 25, 578272cc70bSAndy Fleming 30, 579272cc70bSAndy Fleming 35, 580272cc70bSAndy Fleming 40, 581272cc70bSAndy Fleming 45, 582272cc70bSAndy Fleming 50, 583272cc70bSAndy Fleming 55, 584272cc70bSAndy Fleming 60, 585272cc70bSAndy Fleming 70, 586272cc70bSAndy Fleming 80, 587272cc70bSAndy Fleming }; 588272cc70bSAndy Fleming 589272cc70bSAndy Fleming void mmc_set_ios(struct mmc *mmc) 590272cc70bSAndy Fleming { 591272cc70bSAndy Fleming mmc->set_ios(mmc); 592272cc70bSAndy Fleming } 593272cc70bSAndy Fleming 594272cc70bSAndy Fleming void mmc_set_clock(struct mmc *mmc, uint clock) 595272cc70bSAndy Fleming { 596272cc70bSAndy Fleming if (clock > mmc->f_max) 597272cc70bSAndy Fleming clock = mmc->f_max; 598272cc70bSAndy Fleming 599272cc70bSAndy Fleming if (clock < mmc->f_min) 600272cc70bSAndy Fleming clock = mmc->f_min; 601272cc70bSAndy Fleming 602272cc70bSAndy Fleming mmc->clock = clock; 603272cc70bSAndy Fleming 604272cc70bSAndy Fleming mmc_set_ios(mmc); 605272cc70bSAndy Fleming } 606272cc70bSAndy Fleming 607272cc70bSAndy Fleming void mmc_set_bus_width(struct mmc *mmc, uint width) 608272cc70bSAndy Fleming { 609272cc70bSAndy Fleming mmc->bus_width = width; 610272cc70bSAndy Fleming 611272cc70bSAndy Fleming mmc_set_ios(mmc); 612272cc70bSAndy Fleming } 613272cc70bSAndy Fleming 614272cc70bSAndy Fleming int mmc_startup(struct mmc *mmc) 615272cc70bSAndy Fleming { 616272cc70bSAndy Fleming int err; 617272cc70bSAndy Fleming uint mult, freq; 618272cc70bSAndy Fleming u64 cmult, csize; 619272cc70bSAndy Fleming struct mmc_cmd cmd; 620272cc70bSAndy Fleming 621272cc70bSAndy Fleming /* Put the Card in Identify Mode */ 622272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_ALL_SEND_CID; 623272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 624272cc70bSAndy Fleming cmd.cmdarg = 0; 625272cc70bSAndy Fleming cmd.flags = 0; 626272cc70bSAndy Fleming 627272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 628272cc70bSAndy Fleming 629272cc70bSAndy Fleming if (err) 630272cc70bSAndy Fleming return err; 631272cc70bSAndy Fleming 632272cc70bSAndy Fleming memcpy(mmc->cid, cmd.response, 16); 633272cc70bSAndy Fleming 634272cc70bSAndy Fleming /* 635272cc70bSAndy Fleming * For MMC cards, set the Relative Address. 636272cc70bSAndy Fleming * For SD cards, get the Relatvie Address. 637272cc70bSAndy Fleming * This also puts the cards into Standby State 638272cc70bSAndy Fleming */ 639272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; 640272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 641272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R6; 642272cc70bSAndy Fleming cmd.flags = 0; 643272cc70bSAndy Fleming 644272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 645272cc70bSAndy Fleming 646272cc70bSAndy Fleming if (err) 647272cc70bSAndy Fleming return err; 648272cc70bSAndy Fleming 649272cc70bSAndy Fleming if (IS_SD(mmc)) 650998be3ddSRabin Vincent mmc->rca = (cmd.response[0] >> 16) & 0xffff; 651272cc70bSAndy Fleming 652272cc70bSAndy Fleming /* Get the Card-Specific Data */ 653272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SEND_CSD; 654272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R2; 655272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 656272cc70bSAndy Fleming cmd.flags = 0; 657272cc70bSAndy Fleming 658272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 659272cc70bSAndy Fleming 660272cc70bSAndy Fleming if (err) 661272cc70bSAndy Fleming return err; 662272cc70bSAndy Fleming 663998be3ddSRabin Vincent mmc->csd[0] = cmd.response[0]; 664998be3ddSRabin Vincent mmc->csd[1] = cmd.response[1]; 665998be3ddSRabin Vincent mmc->csd[2] = cmd.response[2]; 666998be3ddSRabin Vincent mmc->csd[3] = cmd.response[3]; 667272cc70bSAndy Fleming 668272cc70bSAndy Fleming if (mmc->version == MMC_VERSION_UNKNOWN) { 6690b453ffeSRabin Vincent int version = (cmd.response[0] >> 26) & 0xf; 670272cc70bSAndy Fleming 671272cc70bSAndy Fleming switch (version) { 672272cc70bSAndy Fleming case 0: 673272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 674272cc70bSAndy Fleming break; 675272cc70bSAndy Fleming case 1: 676272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_4; 677272cc70bSAndy Fleming break; 678272cc70bSAndy Fleming case 2: 679272cc70bSAndy Fleming mmc->version = MMC_VERSION_2_2; 680272cc70bSAndy Fleming break; 681272cc70bSAndy Fleming case 3: 682272cc70bSAndy Fleming mmc->version = MMC_VERSION_3; 683272cc70bSAndy Fleming break; 684272cc70bSAndy Fleming case 4: 685272cc70bSAndy Fleming mmc->version = MMC_VERSION_4; 686272cc70bSAndy Fleming break; 687272cc70bSAndy Fleming default: 688272cc70bSAndy Fleming mmc->version = MMC_VERSION_1_2; 689272cc70bSAndy Fleming break; 690272cc70bSAndy Fleming } 691272cc70bSAndy Fleming } 692272cc70bSAndy Fleming 693272cc70bSAndy Fleming /* divide frequency by 10, since the mults are 10x bigger */ 6940b453ffeSRabin Vincent freq = fbase[(cmd.response[0] & 0x7)]; 6950b453ffeSRabin Vincent mult = multipliers[((cmd.response[0] >> 3) & 0xf)]; 696272cc70bSAndy Fleming 697272cc70bSAndy Fleming mmc->tran_speed = freq * mult; 698272cc70bSAndy Fleming 699998be3ddSRabin Vincent mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf); 700272cc70bSAndy Fleming 701272cc70bSAndy Fleming if (IS_SD(mmc)) 702272cc70bSAndy Fleming mmc->write_bl_len = mmc->read_bl_len; 703272cc70bSAndy Fleming else 704998be3ddSRabin Vincent mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf); 705272cc70bSAndy Fleming 706272cc70bSAndy Fleming if (mmc->high_capacity) { 707272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3f) << 16 708272cc70bSAndy Fleming | (mmc->csd[2] & 0xffff0000) >> 16; 709272cc70bSAndy Fleming cmult = 8; 710272cc70bSAndy Fleming } else { 711272cc70bSAndy Fleming csize = (mmc->csd[1] & 0x3ff) << 2 712272cc70bSAndy Fleming | (mmc->csd[2] & 0xc0000000) >> 30; 713272cc70bSAndy Fleming cmult = (mmc->csd[2] & 0x00038000) >> 15; 714272cc70bSAndy Fleming } 715272cc70bSAndy Fleming 716272cc70bSAndy Fleming mmc->capacity = (csize + 1) << (cmult + 2); 717272cc70bSAndy Fleming mmc->capacity *= mmc->read_bl_len; 718272cc70bSAndy Fleming 719272cc70bSAndy Fleming if (mmc->read_bl_len > 512) 720272cc70bSAndy Fleming mmc->read_bl_len = 512; 721272cc70bSAndy Fleming 722272cc70bSAndy Fleming if (mmc->write_bl_len > 512) 723272cc70bSAndy Fleming mmc->write_bl_len = 512; 724272cc70bSAndy Fleming 725272cc70bSAndy Fleming /* Select the card, and put it into Transfer Mode */ 726272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_SELECT_CARD; 727272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1b; 728272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 729272cc70bSAndy Fleming cmd.flags = 0; 730272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 731272cc70bSAndy Fleming 732272cc70bSAndy Fleming if (err) 733272cc70bSAndy Fleming return err; 734272cc70bSAndy Fleming 735272cc70bSAndy Fleming if (IS_SD(mmc)) 736272cc70bSAndy Fleming err = sd_change_freq(mmc); 737272cc70bSAndy Fleming else 738272cc70bSAndy Fleming err = mmc_change_freq(mmc); 739272cc70bSAndy Fleming 740272cc70bSAndy Fleming if (err) 741272cc70bSAndy Fleming return err; 742272cc70bSAndy Fleming 743272cc70bSAndy Fleming /* Restrict card's capabilities by what the host can do */ 744272cc70bSAndy Fleming mmc->card_caps &= mmc->host_caps; 745272cc70bSAndy Fleming 746272cc70bSAndy Fleming if (IS_SD(mmc)) { 747272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_4BIT) { 748272cc70bSAndy Fleming cmd.cmdidx = MMC_CMD_APP_CMD; 749272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 750272cc70bSAndy Fleming cmd.cmdarg = mmc->rca << 16; 751272cc70bSAndy Fleming cmd.flags = 0; 752272cc70bSAndy Fleming 753272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 754272cc70bSAndy Fleming if (err) 755272cc70bSAndy Fleming return err; 756272cc70bSAndy Fleming 757272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; 758272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R1; 759272cc70bSAndy Fleming cmd.cmdarg = 2; 760272cc70bSAndy Fleming cmd.flags = 0; 761272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 762272cc70bSAndy Fleming if (err) 763272cc70bSAndy Fleming return err; 764272cc70bSAndy Fleming 765272cc70bSAndy Fleming mmc_set_bus_width(mmc, 4); 766272cc70bSAndy Fleming } 767272cc70bSAndy Fleming 768272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) 769272cc70bSAndy Fleming mmc_set_clock(mmc, 50000000); 770272cc70bSAndy Fleming else 771272cc70bSAndy Fleming mmc_set_clock(mmc, 25000000); 772272cc70bSAndy Fleming } else { 773272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_4BIT) { 774272cc70bSAndy Fleming /* Set the card to use 4 bit*/ 775272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 776272cc70bSAndy Fleming EXT_CSD_BUS_WIDTH, 777272cc70bSAndy Fleming EXT_CSD_BUS_WIDTH_4); 778272cc70bSAndy Fleming 779272cc70bSAndy Fleming if (err) 780272cc70bSAndy Fleming return err; 781272cc70bSAndy Fleming 782272cc70bSAndy Fleming mmc_set_bus_width(mmc, 4); 783272cc70bSAndy Fleming } else if (mmc->card_caps & MMC_MODE_8BIT) { 784272cc70bSAndy Fleming /* Set the card to use 8 bit*/ 785272cc70bSAndy Fleming err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, 786272cc70bSAndy Fleming EXT_CSD_BUS_WIDTH, 787272cc70bSAndy Fleming EXT_CSD_BUS_WIDTH_8); 788272cc70bSAndy Fleming 789272cc70bSAndy Fleming if (err) 790272cc70bSAndy Fleming return err; 791272cc70bSAndy Fleming 792272cc70bSAndy Fleming mmc_set_bus_width(mmc, 8); 793272cc70bSAndy Fleming } 794272cc70bSAndy Fleming 795272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS) { 796272cc70bSAndy Fleming if (mmc->card_caps & MMC_MODE_HS_52MHz) 797272cc70bSAndy Fleming mmc_set_clock(mmc, 52000000); 798272cc70bSAndy Fleming else 799272cc70bSAndy Fleming mmc_set_clock(mmc, 26000000); 800272cc70bSAndy Fleming } else 801272cc70bSAndy Fleming mmc_set_clock(mmc, 20000000); 802272cc70bSAndy Fleming } 803272cc70bSAndy Fleming 804272cc70bSAndy Fleming /* fill in device description */ 805272cc70bSAndy Fleming mmc->block_dev.lun = 0; 806272cc70bSAndy Fleming mmc->block_dev.type = 0; 807272cc70bSAndy Fleming mmc->block_dev.blksz = mmc->read_bl_len; 8089b1f942cSRabin Vincent mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len); 8090b453ffeSRabin Vincent sprintf(mmc->block_dev.vendor, "Man %06x Snr %08x", mmc->cid[0] >> 8, 8100b453ffeSRabin Vincent (mmc->cid[2] << 8) | (mmc->cid[3] >> 24)); 8110b453ffeSRabin Vincent sprintf(mmc->block_dev.product, "%c%c%c%c%c", mmc->cid[0] & 0xff, 8120b453ffeSRabin Vincent (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff, 8130b453ffeSRabin Vincent (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff); 8140b453ffeSRabin Vincent sprintf(mmc->block_dev.revision, "%d.%d", mmc->cid[2] >> 28, 8150b453ffeSRabin Vincent (mmc->cid[2] >> 24) & 0xf); 816272cc70bSAndy Fleming init_part(&mmc->block_dev); 817272cc70bSAndy Fleming 818272cc70bSAndy Fleming return 0; 819272cc70bSAndy Fleming } 820272cc70bSAndy Fleming 821272cc70bSAndy Fleming int mmc_send_if_cond(struct mmc *mmc) 822272cc70bSAndy Fleming { 823272cc70bSAndy Fleming struct mmc_cmd cmd; 824272cc70bSAndy Fleming int err; 825272cc70bSAndy Fleming 826272cc70bSAndy Fleming cmd.cmdidx = SD_CMD_SEND_IF_COND; 827272cc70bSAndy Fleming /* We set the bit if the host supports voltages between 2.7 and 3.6 V */ 828272cc70bSAndy Fleming cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa; 829272cc70bSAndy Fleming cmd.resp_type = MMC_RSP_R7; 830272cc70bSAndy Fleming cmd.flags = 0; 831272cc70bSAndy Fleming 832272cc70bSAndy Fleming err = mmc_send_cmd(mmc, &cmd, NULL); 833272cc70bSAndy Fleming 834272cc70bSAndy Fleming if (err) 835272cc70bSAndy Fleming return err; 836272cc70bSAndy Fleming 837998be3ddSRabin Vincent if ((cmd.response[0] & 0xff) != 0xaa) 838272cc70bSAndy Fleming return UNUSABLE_ERR; 839272cc70bSAndy Fleming else 840272cc70bSAndy Fleming mmc->version = SD_VERSION_2; 841272cc70bSAndy Fleming 842272cc70bSAndy Fleming return 0; 843272cc70bSAndy Fleming } 844272cc70bSAndy Fleming 845272cc70bSAndy Fleming int mmc_register(struct mmc *mmc) 846272cc70bSAndy Fleming { 847272cc70bSAndy Fleming /* Setup the universal parts of the block interface just once */ 848272cc70bSAndy Fleming mmc->block_dev.if_type = IF_TYPE_MMC; 849272cc70bSAndy Fleming mmc->block_dev.dev = cur_dev_num++; 850272cc70bSAndy Fleming mmc->block_dev.removable = 1; 851272cc70bSAndy Fleming mmc->block_dev.block_read = mmc_bread; 852272cc70bSAndy Fleming mmc->block_dev.block_write = mmc_bwrite; 853272cc70bSAndy Fleming 854272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc->link); 855272cc70bSAndy Fleming 856272cc70bSAndy Fleming list_add_tail (&mmc->link, &mmc_devices); 857272cc70bSAndy Fleming 858272cc70bSAndy Fleming return 0; 859272cc70bSAndy Fleming } 860272cc70bSAndy Fleming 861272cc70bSAndy Fleming block_dev_desc_t *mmc_get_dev(int dev) 862272cc70bSAndy Fleming { 863272cc70bSAndy Fleming struct mmc *mmc = find_mmc_device(dev); 864272cc70bSAndy Fleming 865e85649c7SRabin Vincent return mmc ? &mmc->block_dev : NULL; 866272cc70bSAndy Fleming } 867272cc70bSAndy Fleming 868272cc70bSAndy Fleming int mmc_init(struct mmc *mmc) 869272cc70bSAndy Fleming { 870272cc70bSAndy Fleming int err; 871272cc70bSAndy Fleming 872272cc70bSAndy Fleming err = mmc->init(mmc); 873272cc70bSAndy Fleming 874272cc70bSAndy Fleming if (err) 875272cc70bSAndy Fleming return err; 876272cc70bSAndy Fleming 877b86b85e2SIlya Yanok mmc_set_bus_width(mmc, 1); 878b86b85e2SIlya Yanok mmc_set_clock(mmc, 1); 879b86b85e2SIlya Yanok 880272cc70bSAndy Fleming /* Reset the Card */ 881272cc70bSAndy Fleming err = mmc_go_idle(mmc); 882272cc70bSAndy Fleming 883272cc70bSAndy Fleming if (err) 884272cc70bSAndy Fleming return err; 885272cc70bSAndy Fleming 886272cc70bSAndy Fleming /* Test for SD version 2 */ 887272cc70bSAndy Fleming err = mmc_send_if_cond(mmc); 888272cc70bSAndy Fleming 889272cc70bSAndy Fleming /* Now try to get the SD card's operating condition */ 890272cc70bSAndy Fleming err = sd_send_op_cond(mmc); 891272cc70bSAndy Fleming 892272cc70bSAndy Fleming /* If the command timed out, we check for an MMC card */ 893272cc70bSAndy Fleming if (err == TIMEOUT) { 894272cc70bSAndy Fleming err = mmc_send_op_cond(mmc); 895272cc70bSAndy Fleming 896272cc70bSAndy Fleming if (err) { 897272cc70bSAndy Fleming printf("Card did not respond to voltage select!\n"); 898272cc70bSAndy Fleming return UNUSABLE_ERR; 899272cc70bSAndy Fleming } 900272cc70bSAndy Fleming } 901272cc70bSAndy Fleming 902272cc70bSAndy Fleming return mmc_startup(mmc); 903272cc70bSAndy Fleming } 904272cc70bSAndy Fleming 905272cc70bSAndy Fleming /* 906272cc70bSAndy Fleming * CPU and board-specific MMC initializations. Aliased function 907272cc70bSAndy Fleming * signals caller to move on 908272cc70bSAndy Fleming */ 909272cc70bSAndy Fleming static int __def_mmc_init(bd_t *bis) 910272cc70bSAndy Fleming { 911272cc70bSAndy Fleming return -1; 912272cc70bSAndy Fleming } 913272cc70bSAndy Fleming 914f9a109b3SPeter Tyser int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 915f9a109b3SPeter Tyser int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init"))); 916272cc70bSAndy Fleming 917272cc70bSAndy Fleming void print_mmc_devices(char separator) 918272cc70bSAndy Fleming { 919272cc70bSAndy Fleming struct mmc *m; 920272cc70bSAndy Fleming struct list_head *entry; 921272cc70bSAndy Fleming 922272cc70bSAndy Fleming list_for_each(entry, &mmc_devices) { 923272cc70bSAndy Fleming m = list_entry(entry, struct mmc, link); 924272cc70bSAndy Fleming 925272cc70bSAndy Fleming printf("%s: %d", m->name, m->block_dev.dev); 926272cc70bSAndy Fleming 927272cc70bSAndy Fleming if (entry->next != &mmc_devices) 928272cc70bSAndy Fleming printf("%c ", separator); 929272cc70bSAndy Fleming } 930272cc70bSAndy Fleming 931272cc70bSAndy Fleming printf("\n"); 932272cc70bSAndy Fleming } 933272cc70bSAndy Fleming 934272cc70bSAndy Fleming int mmc_initialize(bd_t *bis) 935272cc70bSAndy Fleming { 936272cc70bSAndy Fleming INIT_LIST_HEAD (&mmc_devices); 937272cc70bSAndy Fleming cur_dev_num = 0; 938272cc70bSAndy Fleming 939272cc70bSAndy Fleming if (board_mmc_init(bis) < 0) 940272cc70bSAndy Fleming cpu_mmc_init(bis); 941272cc70bSAndy Fleming 942272cc70bSAndy Fleming print_mmc_devices(','); 943272cc70bSAndy Fleming 944272cc70bSAndy Fleming return 0; 945272cc70bSAndy Fleming } 946