Lines Matching defs:mmc
24 static struct mmc mmc_drv_data;
48 * Arguments : mmc - Pointer to mmc struct
55 static void set_speed(struct mmc *mmc, uint32_t clock)
81 esdhc_out32(&mmc->esdhc_regs->sysctl,
89 * Arguments : mmc - Pointer to mmc struct
100 static int esdhc_init(struct mmc *mmc, bool card_detect)
106 val = esdhc_in32(&mmc->esdhc_regs->sysctl) | ESDHC_SYSCTL_RSTA;
107 esdhc_out32(&mmc->esdhc_regs->sysctl, val);
112 val = esdhc_in32(&mmc->esdhc_regs->sysctl) & ESDHC_SYSCTL_RSTA;
118 val = esdhc_in32(&mmc->esdhc_regs->sysctl) &
126 set_speed(mmc, CARD_IDENTIFICATION_FREQ);
130 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
139 val = esdhc_in32(&mmc->esdhc_regs->sysctl) | ESDHC_SYSCTL_SDCLKEN;
140 esdhc_out32(&mmc->esdhc_regs->sysctl, val);
143 val = esdhc_in32(&mmc->esdhc_regs->sysctl) | ESDHC_SYSCTL_INITA;
144 esdhc_out32(&mmc->esdhc_regs->sysctl, val);
148 val = esdhc_in32(&mmc->esdhc_regs->sysctl) & ESDHC_SYSCTL_INITA;
154 val = esdhc_in32(&mmc->esdhc_regs->sysctl) & ESDHC_SYSCTL_INITA;
162 val = esdhc_in32(&mmc->esdhc_regs->proctl);
166 esdhc_out32(&mmc->esdhc_regs->proctl, val);
169 val = esdhc_in32(&mmc->esdhc_regs->ctl) | ESDHC_DCR_SNOOP;
170 esdhc_out32(&mmc->esdhc_regs->ctl, val);
177 * Arguments : mmc - Pointer to mmc struct
183 static int esdhc_send_cmd(struct mmc *mmc, uint32_t cmd, uint32_t args)
189 esdhc_out32(&mmc->esdhc_regs->irqstat, ESDHC_IRQSTAT_CLEAR_ALL);
195 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
202 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
212 } else if (cmd == CMD7 || (cmd == CMD6 && mmc->card.type == MMC_CARD)) {
225 mmc->card.type == MMC_CARD) {
234 if (!(mmc->card.type == MMC_CARD && cmd == CMD6)) {
245 if (mmc->dma_support != 0) {
251 if ((cmd == CMD17 || cmd == CMD24) && (mmc->dma_support != 0)) {
257 esdhc_out32(&mmc->esdhc_regs->cmdarg, args);
258 esdhc_out32(&mmc->esdhc_regs->xfertyp, xfertyp);
270 * Arguments : mmc - Pointer to mmc struct
279 static int esdhc_wait_response(struct mmc *mmc, uint32_t *response)
288 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_CC;
294 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_CC;
300 status = esdhc_in32(&mmc->esdhc_regs->irqstat);
322 response[0] = esdhc_in32(&mmc->esdhc_regs->cmdrsp[0]);
323 response[1] = esdhc_in32(&mmc->esdhc_regs->cmdrsp[1]);
324 response[2] = esdhc_in32(&mmc->esdhc_regs->cmdrsp[2]);
325 response[3] = esdhc_in32(&mmc->esdhc_regs->cmdrsp[3]);
337 val = esdhc_in32(&mmc->esdhc_regs->irqstat) | ESDHC_IRQSTAT_CC;
338 esdhc_out32(&mmc->esdhc_regs->irqstat, val);
345 * Arguments : mmc - Pointer to mmc struct
347 * Description : mmc card below ver 4.0 does not support high speed
354 static int mmc_switch_to_high_frquency(struct mmc *mmc)
360 mmc->card.bus_freq = MMC_SS_20MHZ;
361 /* mmc card below ver 4.0 does not support high speed */
362 if (mmc->card.version < MMC_CARD_VERSION_4_X) {
367 error = esdhc_send_cmd(mmc, CMD_SWITCH_FUNC, SET_EXT_CSD_HS_TIMING);
371 error = esdhc_wait_response(mmc, response);
379 error = esdhc_send_cmd(mmc,
380 CMD_SEND_STATUS, mmc->card.rca << 16);
385 error = esdhc_wait_response(mmc, response);
394 mmc->card.bus_freq = MMC_HS_26MHZ;
396 mmc->card.bus_freq = MMC_HS_52MHZ;
404 * Arguments : mmc - Pointer to mmc struct
410 static int esdhc_set_data_attributes(struct mmc *mmc, uint32_t *dest_ptr,
422 val = esdhc_in32(&mmc->esdhc_regs->prsstat) & ESDHC_PRSSTAT_DLA;
428 val = esdhc_in32(&mmc->esdhc_regs->prsstat) & ESDHC_PRSSTAT_DLA;
434 wml = esdhc_in32(&mmc->esdhc_regs->wml);
438 if ((mmc->dma_support != 0) && (dest_ptr != NULL)) {
440 esdhc_out32(&mmc->esdhc_regs->wml,
442 esdhc_out32(&mmc->esdhc_regs->wml,
446 esdhc_out32(&mmc->esdhc_regs->dsaddr, dst);
451 esdhc_out32(&mmc->esdhc_regs->wml, wml | ESDHC_WML_RD_WML(wl));
455 esdhc_out32(&mmc->esdhc_regs->blkattr,
458 mmc->block_len = blklen;
465 * Arguments : mmc - Pointer to mmc struct
472 static int esdhc_read_data_nodma(struct mmc *mmc, void *dest_ptr, uint32_t len)
481 num_blocks = len / mmc->block_len;
487 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
494 val = esdhc_in32(&mmc->esdhc_regs->prsstat)
500 for (i = 0U, status = esdhc_in32(&mmc->esdhc_regs->irqstat);
501 i < mmc->block_len / 4; i++, dst++) {
504 (uintptr_t)&mmc->esdhc_regs->datport);
507 status = esdhc_in32(&mmc->esdhc_regs->irqstat);
522 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_TC;
528 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_TC;
539 * Arguments : mmc - Pointer to mmc struct
546 static int esdhc_write_data_nodma(struct mmc *mmc, void *src_ptr, uint32_t len)
555 num_blocks = len / mmc->block_len;
560 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
567 val = esdhc_in32(&mmc->esdhc_regs->prsstat) &
573 for (i = 0U, status = esdhc_in32(&mmc->esdhc_regs->irqstat);
574 i < mmc->block_len / 4; i++, src++) {
577 mmio_write_32((uintptr_t)&mmc->esdhc_regs->datport,
580 status = esdhc_in32(&mmc->esdhc_regs->irqstat);
594 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_TC;
600 val = esdhc_in32(&mmc->esdhc_regs->irqstat) & ESDHC_IRQSTAT_TC;
611 * Arguments : mmc - Pointer to mmc struct
616 static int esdhc_read_data_dma(struct mmc *mmc, uint32_t len)
622 tblk = SD_BLOCK_TIMEOUT * (len / mmc->block_len);
628 status = esdhc_in32(&mmc->esdhc_regs->irqstat);
643 ((esdhc_in32(&mmc->esdhc_regs->prsstat) & ESDHC_PRSSTAT_DLA) != 0) &&
656 * Arguments : mmc - Pointer to mmc struct
661 static int esdhc_write_data_dma(struct mmc *mmc, uint32_t len)
667 tblk = SD_BLOCK_TIMEOUT * (len / mmc->block_len);
673 status = esdhc_in32(&mmc->esdhc_regs->irqstat);
687 ((esdhc_in32(&mmc->esdhc_regs->prsstat) & ESDHC_PRSSTAT_DLA) != 0) &&
700 * Arguments : mmc - Pointer to mmc struct
706 int esdhc_read_data(struct mmc *mmc, void *dest_ptr, uint32_t len)
710 if (mmc->dma_support && len > 64) {
711 ret = esdhc_read_data_dma(mmc, len);
713 ret = esdhc_read_data_nodma(mmc, dest_ptr, len);
717 esdhc_out32(&mmc->esdhc_regs->irqstat, ESDHC_IRQSTAT_CLEAR_ALL);
724 * Arguments : mmc - Pointer to mmc struct
730 int esdhc_write_data(struct mmc *mmc, void *src_ptr, uint32_t len)
734 if (mmc->dma_support && len > 64) {
735 ret = esdhc_write_data_dma(mmc, len);
737 ret = esdhc_write_data_nodma(mmc, src_ptr, len);
741 esdhc_out32(&mmc->esdhc_regs->irqstat, ESDHC_IRQSTAT_CLEAR_ALL);
748 * Arguments : mmc - Pointer to mmc struct
759 static int sd_switch_to_high_freq(struct mmc *mmc)
770 mmc->card.bus_freq = SD_SS_25MHZ;
772 err = esdhc_send_cmd(mmc, CMD_APP_CMD, mmc->card.rca << 16);
777 err = esdhc_wait_response(mmc, response);
782 esdhc_set_data_attributes(mmc, NULL, 1, 8);
784 err = esdhc_send_cmd(mmc, CMD_SEND_SCR, mmc->card.rca << 16);
788 err = esdhc_wait_response(mmc, response);
794 err = esdhc_read_data(mmc, scr, 8U);
802 mmc->card.version = sd_versions[version];
804 mmc->card.version = SD_CARD_VERSION_2_0;
808 if (mmc->card.version == SD_CARD_VERSION_1_0) {
813 esdhc_set_data_attributes(mmc, NULL, 1U, 64U);
817 err = esdhc_send_cmd(mmc, CMD_SWITCH_FUNC,
822 err = esdhc_wait_response(mmc, response);
827 err = esdhc_read_data(mmc, status, 64U);
842 esdhc_set_data_attributes(mmc, NULL, 1, 64);
843 err = esdhc_send_cmd(mmc, CMD_SWITCH_FUNC, SD_SWITCH_FUNC_SWITCH_MODE);
847 err = esdhc_wait_response(mmc, response);
852 err = esdhc_read_data(mmc, status, 64U);
858 mmc->card.bus_freq = SD_HS_50MHZ;
866 * Arguments : mmc - Pointer to mmc struct
873 static int change_state_to_transfer_state(struct mmc *mmc)
882 error = esdhc_send_cmd(mmc, CMD_SELECT_CARD, mmc->card.rca << 16);
886 error = esdhc_wait_response(mmc, response);
894 error = esdhc_send_cmd(mmc,
895 CMD_SEND_STATUS, mmc->card.rca << 16);
899 error = esdhc_wait_response(mmc, response);
918 * Arguments : mmc - Pointer to mmc struct
921 * 2. get RCA for SD cards, set rca for mmc cards
926 static int get_cid_rca_csd(struct mmc *mmc)
935 err = esdhc_send_cmd(mmc, CMD_ALL_SEND_CID, 0);
939 err = esdhc_wait_response(mmc, response);
944 /* get RCA for SD cards, set rca for mmc cards */
945 mmc->card.rca = SD_MMC_CARD_RCA;
948 err = esdhc_send_cmd(mmc, CMD_SEND_RELATIVE_ADDR, mmc->card.rca << 16);
952 err = esdhc_wait_response(mmc, response);
958 if (mmc->card.type == SD_CARD) {
959 mmc->card.rca = (response[0] >> 16) & 0xFFFF;
963 err = esdhc_send_cmd(mmc, CMD_SEND_CSD, mmc->card.rca << 16);
967 err = esdhc_wait_response(mmc, response);
973 if (mmc->card.type == MMC_CARD) {
975 mmc->card.version = mmc_version[version];
977 mmc->card.version = MMC_CARD_VERSION_4_X;
981 mmc->card.block_len = 1 << ((response[2] >> 8) & 0xF);
983 if (mmc->card.block_len > BLOCK_LEN_512) {
984 mmc->card.block_len = BLOCK_LEN_512;
992 * Arguments : mmc - Pointer to mmc struct
999 static int identify_mmc_card(struct mmc *mmc)
1007 ret = esdhc_send_cmd(mmc, CMD_GO_IDLE_STATE, 0U);
1011 ret = esdhc_wait_response(mmc, resp);
1022 args = mmc->voltages_caps | MMC_OCR_SECTOR_MODE;
1023 ret = esdhc_send_cmd(mmc, CMD_MMC_SEND_OP_COND, args);
1027 ret = esdhc_wait_response(mmc, resp);
1039 mmc->card.is_high_capacity = 1;
1047 * Arguments : mmc - Pointer to mmc struct
1056 static int check_for_sd_card(struct mmc *mmc)
1064 ret = esdhc_send_cmd(mmc, CMD_GO_IDLE_STATE, 0U);
1068 ret = esdhc_wait_response(mmc, resp);
1075 ret = esdhc_send_cmd(mmc, CMD_SEND_IF_COND, args);
1079 ret = esdhc_wait_response(mmc, resp);
1081 mmc->card.is_high_capacity = 0;
1083 mmc->card.version = SD_CARD_VERSION_2_0;
1093 ret = esdhc_send_cmd(mmc, CMD_APP_CMD, 0U);
1097 ret = esdhc_wait_response(mmc, resp);
1103 args = mmc->voltages_caps;
1104 if (mmc->card.version == SD_CARD_VERSION_2_0) {
1109 ret = esdhc_send_cmd(mmc, CMD_SD_SEND_OP_COND, args);
1113 ret = esdhc_wait_response(mmc, resp);
1129 mmc->card.is_high_capacity = 1;
1137 * Arguments : mmc - Pointer to mmc struct
1142 int esdhc_emmc_init(struct mmc *mmc, bool card_detect)
1147 error = esdhc_init(mmc, card_detect);
1152 mmc->card.bus_freq = CARD_IDENTIFICATION_FREQ;
1153 mmc->card.rca = 0;
1154 mmc->card.is_high_capacity = 0;
1155 mmc->card.type = ERROR_ESDHC_UNUSABLE_CARD;
1159 mmc->voltages_caps = MMC_OCR_VDD_FF8;
1163 mmc->dma_support = esdhc_in32(&mmc->esdhc_regs->hostcapblt) &
1166 mmc->dma_support = 0;
1171 ret = check_for_sd_card(mmc);
1174 mmc->card.type = SD_CARD;
1179 if (identify_mmc_card(mmc) == MMC_CARD) {
1180 mmc->card.type = MMC_CARD;
1191 error = get_cid_rca_csd(mmc);
1197 error = change_state_to_transfer_state(mmc);
1203 if (mmc->card.type == SD_CARD) {
1204 error = sd_switch_to_high_freq(mmc);
1206 error = mmc_switch_to_high_frquency(mmc);
1212 /* mmc: 20000000, 26000000, 52000000 */
1214 set_speed(mmc, mmc->card.bus_freq);
1222 * Arguments : mmc - Pointer to mmc struct
1229 struct mmc *mmc = NULL;
1232 mmc = &mmc_drv_data;
1233 memset(mmc, 0, sizeof(struct mmc));
1234 mmc->esdhc_regs = (struct esdhc_regs *)nxp_esdhc_addr;
1237 ret = esdhc_emmc_init(mmc, card_detect);
1243 * Arguments : mmc - Pointer to mmc struct
1251 static int esdhc_read_block(struct mmc *mmc, void *dst, uint32_t block)
1257 err = esdhc_send_cmd(mmc, CMD_SET_BLOCKLEN, mmc->card.block_len);
1261 err = esdhc_wait_response(mmc, NULL);
1266 if (mmc->card.is_high_capacity != 0) {
1269 offset = block * mmc->card.block_len;
1272 esdhc_set_data_attributes(mmc, dst, 1, mmc->card.block_len);
1273 err = esdhc_send_cmd(mmc, CMD_READ_SINGLE_BLOCK, offset);
1277 err = esdhc_wait_response(mmc, NULL);
1282 err = esdhc_read_data(mmc, dst, mmc->card.block_len);
1289 * Arguments : mmc - Pointer to mmc struct
1297 static int esdhc_write_block(struct mmc *mmc, void *src, uint32_t block)
1303 err = esdhc_send_cmd(mmc, CMD_SET_BLOCKLEN, mmc->card.block_len);
1307 err = esdhc_wait_response(mmc, NULL);
1312 if (mmc->card.is_high_capacity != 0) {
1315 offset = block * mmc->card.block_len;
1318 esdhc_set_data_attributes(mmc, src, 1, mmc->card.block_len);
1319 err = esdhc_send_cmd(mmc, CMD_WRITE_SINGLE_BLOCK, offset);
1323 err = esdhc_wait_response(mmc, NULL);
1328 err = esdhc_write_data(mmc, src, mmc->card.block_len);
1335 * Arguments : src_offset - offset on sd/mmc to read from. Should be block
1343 int esdhc_read(struct mmc *mmc, uint32_t src_offset, uintptr_t dst, size_t size)
1350 INFO("sd mmc read\n");
1359 if ((size % mmc->card.block_len) != 0) {
1364 if ((src_offset % mmc->card.block_len) != 0) {
1370 blk = src_offset / mmc->card.block_len;
1376 num_blocks = size / mmc->card.block_len;
1379 error = esdhc_read_block(mmc, buff, blk);
1385 buff = buff + mmc->card.block_len;
1390 INFO("sd-mmc read done.\n");
1397 * dst_offset - offset on sd/mmc to write to. Should be block
1404 int esdhc_write(struct mmc *mmc, uintptr_t src, uint32_t dst_offset,
1412 INFO("sd mmc write\n");
1421 if ((size % mmc->card.block_len) != 0) {
1426 if ((dst_offset % mmc->card.block_len) != 0) {
1432 blk = dst_offset / mmc->card.block_len;
1438 num_blocks = size / mmc->card.block_len;
1441 error = esdhc_write_block(mmc, buff, blk);
1447 buff = buff + mmc->card.block_len;
1452 INFO("sd-mmc write done.\n");
1458 struct mmc *mmc = NULL;
1461 mmc = &mmc_drv_data;
1463 ret = esdhc_read(mmc, lba, buf, size);