mmc.c (8ac8a2630459bacb2d9b6516d49bedad61ca63f8) mmc.c (c744b6f6dcf6054f4eb8ff2428edb6ba408c4a46)
1/*
2 * Copyright 2008, Freescale Semiconductor, Inc
3 * Andy Fleming
4 *
5 * Based vaguely on the Linux code
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */

--- 1235 unchanged lines hidden (view full) ---

1244 mmc->tran_speed = 52000000;
1245 else
1246 mmc->tran_speed = 26000000;
1247 }
1248
1249 return err;
1250}
1251
1/*
2 * Copyright 2008, Freescale Semiconductor, Inc
3 * Andy Fleming
4 *
5 * Based vaguely on the Linux code
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */

--- 1235 unchanged lines hidden (view full) ---

1244 mmc->tran_speed = 52000000;
1245 else
1246 mmc->tran_speed = 26000000;
1247 }
1248
1249 return err;
1250}
1251
1252static int mmc_startup_v4(struct mmc *mmc, u8 *ext_csd)
1253{
1254 int err, i;
1255 u64 capacity;
1256 bool has_parts = false;
1257 bool part_completed;
1258
1259 if (IS_SD(mmc) || (mmc->version < MMC_VERSION_4))
1260 return 0;
1261
1262 /* check ext_csd version and capacity */
1263 err = mmc_send_ext_csd(mmc, ext_csd);
1264 if (err)
1265 return err;
1266 if (ext_csd[EXT_CSD_REV] >= 2) {
1267 /*
1268 * According to the JEDEC Standard, the value of
1269 * ext_csd's capacity is valid if the value is more
1270 * than 2GB
1271 */
1272 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1273 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1274 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1275 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1276 capacity *= MMC_MAX_BLOCK_LEN;
1277 if ((capacity >> 20) > 2 * 1024)
1278 mmc->capacity_user = capacity;
1279 }
1280
1281 switch (ext_csd[EXT_CSD_REV]) {
1282 case 1:
1283 mmc->version = MMC_VERSION_4_1;
1284 break;
1285 case 2:
1286 mmc->version = MMC_VERSION_4_2;
1287 break;
1288 case 3:
1289 mmc->version = MMC_VERSION_4_3;
1290 break;
1291 case 5:
1292 mmc->version = MMC_VERSION_4_41;
1293 break;
1294 case 6:
1295 mmc->version = MMC_VERSION_4_5;
1296 break;
1297 case 7:
1298 mmc->version = MMC_VERSION_5_0;
1299 break;
1300 case 8:
1301 mmc->version = MMC_VERSION_5_1;
1302 break;
1303 }
1304
1305 /* The partition data may be non-zero but it is only
1306 * effective if PARTITION_SETTING_COMPLETED is set in
1307 * EXT_CSD, so ignore any data if this bit is not set,
1308 * except for enabling the high-capacity group size
1309 * definition (see below).
1310 */
1311 part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] &
1312 EXT_CSD_PARTITION_SETTING_COMPLETED);
1313
1314 /* store the partition info of emmc */
1315 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT];
1316 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1317 ext_csd[EXT_CSD_BOOT_MULT])
1318 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1319 if (part_completed &&
1320 (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT))
1321 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE];
1322
1323 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1324
1325 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1326
1327 for (i = 0; i < 4; i++) {
1328 int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1329 uint mult = (ext_csd[idx + 2] << 16) +
1330 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1331 if (mult)
1332 has_parts = true;
1333 if (!part_completed)
1334 continue;
1335 mmc->capacity_gp[i] = mult;
1336 mmc->capacity_gp[i] *=
1337 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1338 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1339 mmc->capacity_gp[i] <<= 19;
1340 }
1341
1342 if (part_completed) {
1343 mmc->enh_user_size =
1344 (ext_csd[EXT_CSD_ENH_SIZE_MULT + 2] << 16) +
1345 (ext_csd[EXT_CSD_ENH_SIZE_MULT + 1] << 8) +
1346 ext_csd[EXT_CSD_ENH_SIZE_MULT];
1347 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1348 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1349 mmc->enh_user_size <<= 19;
1350 mmc->enh_user_start =
1351 (ext_csd[EXT_CSD_ENH_START_ADDR + 3] << 24) +
1352 (ext_csd[EXT_CSD_ENH_START_ADDR + 2] << 16) +
1353 (ext_csd[EXT_CSD_ENH_START_ADDR + 1] << 8) +
1354 ext_csd[EXT_CSD_ENH_START_ADDR];
1355 if (mmc->high_capacity)
1356 mmc->enh_user_start <<= 9;
1357 }
1358
1359 /*
1360 * Host needs to enable ERASE_GRP_DEF bit if device is
1361 * partitioned. This bit will be lost every time after a reset
1362 * or power off. This will affect erase size.
1363 */
1364 if (part_completed)
1365 has_parts = true;
1366 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1367 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB))
1368 has_parts = true;
1369 if (has_parts) {
1370 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1371 EXT_CSD_ERASE_GROUP_DEF, 1);
1372
1373 if (err)
1374 return err;
1375
1376 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
1377 }
1378
1379 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) {
1380 /* Read out group size from ext_csd */
1381 mmc->erase_grp_size =
1382 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024;
1383 /*
1384 * if high capacity and partition setting completed
1385 * SEC_COUNT is valid even if it is smaller than 2 GiB
1386 * JEDEC Standard JESD84-B45, 6.2.4
1387 */
1388 if (mmc->high_capacity && part_completed) {
1389 capacity = (ext_csd[EXT_CSD_SEC_CNT]) |
1390 (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) |
1391 (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) |
1392 (ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
1393 capacity *= MMC_MAX_BLOCK_LEN;
1394 mmc->capacity_user = capacity;
1395 }
1396 } else {
1397 /* Calculate the group size from the csd value. */
1398 int erase_gsz, erase_gmul;
1399
1400 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1401 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1402 mmc->erase_grp_size = (erase_gsz + 1)
1403 * (erase_gmul + 1);
1404 }
1405
1406 mmc->hc_wp_grp_size = 1024
1407 * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1408 * ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1409
1410 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
1411
1412 return 0;
1413}
1414
1252static int mmc_startup(struct mmc *mmc)
1253{
1254 int err, i;
1255 uint mult, freq;
1415static int mmc_startup(struct mmc *mmc)
1416{
1417 int err, i;
1418 uint mult, freq;
1256 u64 cmult, csize, capacity;
1419 u64 cmult, csize;
1257 struct mmc_cmd cmd;
1258 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
1420 struct mmc_cmd cmd;
1421 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
1259 bool has_parts = false;
1260 bool part_completed;
1261 struct blk_desc *bdesc;
1262
1263#ifdef CONFIG_MMC_SPI_CRC_ON
1264 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
1265 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
1266 cmd.resp_type = MMC_RSP_R1;
1267 cmd.cmdarg = 1;
1268 err = mmc_send_cmd(mmc, &cmd, NULL);

--- 131 unchanged lines hidden (view full) ---

1400 return err;
1401 }
1402
1403 /*
1404 * For SD, its erase group is always one sector
1405 */
1406 mmc->erase_grp_size = 1;
1407 mmc->part_config = MMCPART_NOAVAILABLE;
1422 struct blk_desc *bdesc;
1423
1424#ifdef CONFIG_MMC_SPI_CRC_ON
1425 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
1426 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
1427 cmd.resp_type = MMC_RSP_R1;
1428 cmd.cmdarg = 1;
1429 err = mmc_send_cmd(mmc, &cmd, NULL);

--- 131 unchanged lines hidden (view full) ---

1561 return err;
1562 }
1563
1564 /*
1565 * For SD, its erase group is always one sector
1566 */
1567 mmc->erase_grp_size = 1;
1568 mmc->part_config = MMCPART_NOAVAILABLE;
1408 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1409 /* check ext_csd version and capacity */
1410 err = mmc_send_ext_csd(mmc, ext_csd);
1411 if (err)
1412 return err;
1413 if (ext_csd[EXT_CSD_REV] >= 2) {
1414 /*
1415 * According to the JEDEC Standard, the value of
1416 * ext_csd's capacity is valid if the value is more
1417 * than 2GB
1418 */
1419 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1420 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1421 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1422 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1423 capacity *= MMC_MAX_BLOCK_LEN;
1424 if ((capacity >> 20) > 2 * 1024)
1425 mmc->capacity_user = capacity;
1426 }
1427
1569
1428 switch (ext_csd[EXT_CSD_REV]) {
1429 case 1:
1430 mmc->version = MMC_VERSION_4_1;
1431 break;
1432 case 2:
1433 mmc->version = MMC_VERSION_4_2;
1434 break;
1435 case 3:
1436 mmc->version = MMC_VERSION_4_3;
1437 break;
1438 case 5:
1439 mmc->version = MMC_VERSION_4_41;
1440 break;
1441 case 6:
1442 mmc->version = MMC_VERSION_4_5;
1443 break;
1444 case 7:
1445 mmc->version = MMC_VERSION_5_0;
1446 break;
1447 case 8:
1448 mmc->version = MMC_VERSION_5_1;
1449 break;
1450 }
1570 err = mmc_startup_v4(mmc, ext_csd);
1571 if (err)
1572 return err;
1451
1573
1452 /* The partition data may be non-zero but it is only
1453 * effective if PARTITION_SETTING_COMPLETED is set in
1454 * EXT_CSD, so ignore any data if this bit is not set,
1455 * except for enabling the high-capacity group size
1456 * definition (see below). */
1457 part_completed = !!(ext_csd[EXT_CSD_PARTITION_SETTING] &
1458 EXT_CSD_PARTITION_SETTING_COMPLETED);
1459
1460 /* store the partition info of emmc */
1461 mmc->part_support = ext_csd[EXT_CSD_PARTITIONING_SUPPORT];
1462 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1463 ext_csd[EXT_CSD_BOOT_MULT])
1464 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1465 if (part_completed &&
1466 (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & ENHNCD_SUPPORT))
1467 mmc->part_attr = ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE];
1468
1469 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1470
1471 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1472
1473 for (i = 0; i < 4; i++) {
1474 int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1475 uint mult = (ext_csd[idx + 2] << 16) +
1476 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1477 if (mult)
1478 has_parts = true;
1479 if (!part_completed)
1480 continue;
1481 mmc->capacity_gp[i] = mult;
1482 mmc->capacity_gp[i] *=
1483 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1484 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1485 mmc->capacity_gp[i] <<= 19;
1486 }
1487
1488 if (part_completed) {
1489 mmc->enh_user_size =
1490 (ext_csd[EXT_CSD_ENH_SIZE_MULT+2] << 16) +
1491 (ext_csd[EXT_CSD_ENH_SIZE_MULT+1] << 8) +
1492 ext_csd[EXT_CSD_ENH_SIZE_MULT];
1493 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1494 mmc->enh_user_size *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1495 mmc->enh_user_size <<= 19;
1496 mmc->enh_user_start =
1497 (ext_csd[EXT_CSD_ENH_START_ADDR+3] << 24) +
1498 (ext_csd[EXT_CSD_ENH_START_ADDR+2] << 16) +
1499 (ext_csd[EXT_CSD_ENH_START_ADDR+1] << 8) +
1500 ext_csd[EXT_CSD_ENH_START_ADDR];
1501 if (mmc->high_capacity)
1502 mmc->enh_user_start <<= 9;
1503 }
1504
1505 /*
1506 * Host needs to enable ERASE_GRP_DEF bit if device is
1507 * partitioned. This bit will be lost every time after a reset
1508 * or power off. This will affect erase size.
1509 */
1510 if (part_completed)
1511 has_parts = true;
1512 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1513 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB))
1514 has_parts = true;
1515 if (has_parts) {
1516 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1517 EXT_CSD_ERASE_GROUP_DEF, 1);
1518
1519 if (err)
1520 return err;
1521 else
1522 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
1523 }
1524
1525 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF] & 0x01) {
1526 /* Read out group size from ext_csd */
1527 mmc->erase_grp_size =
1528 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 1024;
1529 /*
1530 * if high capacity and partition setting completed
1531 * SEC_COUNT is valid even if it is smaller than 2 GiB
1532 * JEDEC Standard JESD84-B45, 6.2.4
1533 */
1534 if (mmc->high_capacity && part_completed) {
1535 capacity = (ext_csd[EXT_CSD_SEC_CNT]) |
1536 (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) |
1537 (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) |
1538 (ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
1539 capacity *= MMC_MAX_BLOCK_LEN;
1540 mmc->capacity_user = capacity;
1541 }
1542 } else {
1543 /* Calculate the group size from the csd value. */
1544 int erase_gsz, erase_gmul;
1545 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1546 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1547 mmc->erase_grp_size = (erase_gsz + 1)
1548 * (erase_gmul + 1);
1549 }
1550
1551 mmc->hc_wp_grp_size = 1024
1552 * ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1553 * ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1554
1555 mmc->wr_rel_set = ext_csd[EXT_CSD_WR_REL_SET];
1556 }
1557
1558 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart);
1559 if (err)
1560 return err;
1561
1562 if (IS_SD(mmc))
1563 err = sd_select_bus_freq_width(mmc);
1564 else
1565 err = mmc_select_bus_freq_width(mmc, ext_csd);

--- 348 unchanged lines hidden --- 		1574 err = mmc_set_capacity(mmc, mmc_get_blk_desc(mmc)->hwpart);
1575 if (err)
1576 return err;
1577
1578 if (IS_SD(mmc))
1579 err = sd_select_bus_freq_width(mmc);
1580 else
1581 err = mmc_select_bus_freq_width(mmc, ext_csd);

--- 348 unchanged lines hidden ---