hw/sd/sdcard: Add eMMC support
v49 cover hw/sd/sdcard: Add eMMC support
Tag to test Aspeed tree:
https://gitlab.com/philmd/qemu/-/tags/aspeed_emmc-v9
Since v48:
- Dropped "Implement 'boot-mode' reset timing" patch
- Re-introduce Joel "Support boot area in emmc image" patch
- Comment magic CSD values
Cédric Le Goater (2):
hw/sd/sdcard: Add emmc_cmd_SET_RELATIVE_ADDR handler (CMD3) hw/sd/sdcard: Fix SET_BLOCK_COUNT command argument on eMMC (CMD23)
Joel Stanley (1):
hw/sd/sdcard: Support boot area in emmc image
Luc Michel (1):
hw/sd/sdcard: Implement eMMC sleep state (CMD5)
Philippe Mathieu-Daudé (5):
hw/sd/sdcard: Basis for eMMC support hw/sd/sdcard: Register generic command handlers hw/sd/sdcard: Register unimplemented command handlers hw/sd/sdcard: Add emmc_cmd_PROGRAM_CID handler (CMD26) hw/sd/sdcard: Add eMMC 'boot-partition-size' property
Sai Pavan Boddu (1):
hw/sd/sdcard: Add mmc SWITCH function support (CMD6)
Vincent Palatin (1):
hw/sd/sdcard: Add emmc_cmd_SEND_EXT_CSD handler (CMD8)
include/hw/sd/sd.h | 3 + hw/sd/sd.c | 385 ++++++++++++++++++++++++++++++++++++++++++++- hw/sd/trace-events | 2 + 3 files changed, 384 insertions(+), 6 deletions(-)
Signature · 1 line
2.41.0
PATCH v49 1/11 hw/sd/sdcard: Basis for eMMC support
From: Philippe Mathieu-Daudé <[email protected]>
Since eMMC are soldered on boards, it is not user-creatable.
RCA register is initialized to 0x0001, per spec v4.3, chapter 8.5 "RCA register":
The default value of the RCA register is 0x0001. The value 0x0000 is reserved to set all cards into the Stand-by State with CMD7.
The CSD register is very similar to SD one, except the version announced is v4.3.
eMMC CID register is slightly different from SD:
- One extra PNM (5 -> 6)
- MDT is only 1 byte (2 -> 1).
--- include/hw/sd/sd.h | 3 ++ hw/sd/sd.c | 107 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 109 insertions(+), 1 deletion(-)
include/hw/sd/sd.h +3 -0
@@ -96,6 +96,9 @@ OBJECT_DECLARE_TYPE(SDState, SDCardClass, SD_CARD)#define TYPE_SD_CARD_SPI "sd-card-spi" DECLARE_INSTANCE_CHECKER(SDState, SD_CARD_SPI, TYPE_SD_CARD_SPI) +#define TYPE_EMMC "emmc" +DECLARE_INSTANCE_CHECKER(SDState, EMMC, TYPE_EMMC) +struct SDCardClass {/*< private >*/ DeviceClass parent_class;
hw/sd/sd.c +106 -1
173 lines not on this page · raw message
Signature · 1 line
2.41.0
PATCH v49 2/11 hw/sd/sdcard: Register generic command handlers
In reply to Philippe Mathieu-Daudé--- hw/sd/sd.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
hw/sd/sd.c +23 -0
@@ -2442,6 +2442,29 @@ static const SDProto sd_proto_emmc = {/* Only v4.3 is supported */ .name = "eMMC", .cmd = { + [0] = {0, sd_bc, "GO_IDLE_STATE", sd_cmd_GO_IDLE_STATE}, + [1] = {0, sd_bcr, "SEND_OP_COND", sd_cmd_SEND_OP_COND}, + [2] = {0, sd_bcr, "ALL_SEND_CID", sd_cmd_ALL_SEND_CID}, + [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, + [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD}, + [10] = {0, sd_ac, "SEND_CID", sd_cmd_SEND_CID}, + [12] = {0, sd_ac, "STOP_TRANSMISSION", sd_cmd_STOP_TRANSMISSION}, + [13] = {0, sd_ac, "SEND_STATUS", sd_cmd_SEND_STATUS}, + [15] = {0, sd_ac, "GO_INACTIVE_STATE", sd_cmd_GO_INACTIVE_STATE}, + [16] = {2, sd_ac, "SET_BLOCKLEN", sd_cmd_SET_BLOCKLEN}, + [17] = {2, sd_adtc, "READ_SINGLE_BLOCK", sd_cmd_READ_SINGLE_BLOCK}, + [23] = {2, sd_ac, "SET_BLOCK_COUNT", sd_cmd_SET_BLOCK_COUNT}, + [24] = {4, sd_adtc, "WRITE_SINGLE_BLOCK", sd_cmd_WRITE_SINGLE_BLOCK}, + [27] = {4, sd_adtc, "PROGRAM_CSD", sd_cmd_PROGRAM_CSD}, + [28] = {6, sd_ac, "SET_WRITE_PROT", sd_cmd_SET_WRITE_PROT}, + [29] = {6, sd_ac, "CLR_WRITE_PROT", sd_cmd_CLR_WRITE_PROT}, + [30] = {6, sd_adtc, "SEND_WRITE_PROT", sd_cmd_SEND_WRITE_PROT}, + [35] = {5, sd_ac, "ERASE_WR_BLK_START", sd_cmd_ERASE_WR_BLK_START}, + [36] = {5, sd_ac, "ERASE_WR_BLK_END", sd_cmd_ERASE_WR_BLK_END}, + [38] = {5, sd_ac, "ERASE", sd_cmd_ERASE}, + [42] = {7, sd_adtc, "LOCK_UNLOCK", sd_cmd_LOCK_UNLOCK}, + [55] = {8, sd_ac, "APP_CMD", sd_cmd_APP_CMD}, + [56] = {8, sd_adtc, "GEN_CMD", sd_cmd_GEN_CMD}, }, };
Signature · 1 line
2.41.0
PATCH v49 3/11 hw/sd/sdcard: Register unimplemented command handlers
In reply to Philippe Mathieu-DaudéPer the spec v4.3 these commands are mandatory, but we don't implement them.
--- hw/sd/sd.c | 9 +++++++++ 1 file changed, 9 insertions(+)
hw/sd/sd.c +9 -0
@@ -2445,24 +2445,33 @@ static const SDProto sd_proto_emmc = { [0] = {0, sd_bc, "GO_IDLE_STATE", sd_cmd_GO_IDLE_STATE}, [1] = {0, sd_bcr, "SEND_OP_COND", sd_cmd_SEND_OP_COND}, [2] = {0, sd_bcr, "ALL_SEND_CID", sd_cmd_ALL_SEND_CID}, + [4] = {0, sd_bc, "SEND_DSR", sd_cmd_unimplemented}, [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD}, [10] = {0, sd_ac, "SEND_CID", sd_cmd_SEND_CID}, + [11] = {1, sd_adtc, "READ_DAT_UNTIL_STOP", sd_cmd_unimplemented}, [12] = {0, sd_ac, "STOP_TRANSMISSION", sd_cmd_STOP_TRANSMISSION}, [13] = {0, sd_ac, "SEND_STATUS", sd_cmd_SEND_STATUS}, + [14] = {0, sd_adtc, "BUSTEST_R", sd_cmd_unimplemented}, [15] = {0, sd_ac, "GO_INACTIVE_STATE", sd_cmd_GO_INACTIVE_STATE}, [16] = {2, sd_ac, "SET_BLOCKLEN", sd_cmd_SET_BLOCKLEN}, [17] = {2, sd_adtc, "READ_SINGLE_BLOCK", sd_cmd_READ_SINGLE_BLOCK}, + [19] = {0, sd_adtc, "BUSTEST_W", sd_cmd_unimplemented}, + [20] = {3, sd_adtc, "WRITE_DAT_UNTIL_STOP", sd_cmd_unimplemented}, [23] = {2, sd_ac, "SET_BLOCK_COUNT", sd_cmd_SET_BLOCK_COUNT}, [24] = {4, sd_adtc, "WRITE_SINGLE_BLOCK", sd_cmd_WRITE_SINGLE_BLOCK}, [27] = {4, sd_adtc, "PROGRAM_CSD", sd_cmd_PROGRAM_CSD}, [28] = {6, sd_ac, "SET_WRITE_PROT", sd_cmd_SET_WRITE_PROT}, [29] = {6, sd_ac, "CLR_WRITE_PROT", sd_cmd_CLR_WRITE_PROT}, [30] = {6, sd_adtc, "SEND_WRITE_PROT", sd_cmd_SEND_WRITE_PROT}, + [31] = {6, sd_adtc, "SEND_WRITE_PROT_TYPE", sd_cmd_unimplemented}, [35] = {5, sd_ac, "ERASE_WR_BLK_START", sd_cmd_ERASE_WR_BLK_START}, [36] = {5, sd_ac, "ERASE_WR_BLK_END", sd_cmd_ERASE_WR_BLK_END}, [38] = {5, sd_ac, "ERASE", sd_cmd_ERASE}, + [39] = {9, sd_ac, "FAST_IO", sd_cmd_unimplemented}, + [40] = {9, sd_bcr, "GO_IRQ_STATE", sd_cmd_unimplemented}, [42] = {7, sd_adtc, "LOCK_UNLOCK", sd_cmd_LOCK_UNLOCK}, + [49] = {0, sd_adtc, "SET_TIME", sd_cmd_unimplemented}, [55] = {8, sd_ac, "APP_CMD", sd_cmd_APP_CMD}, [56] = {8, sd_adtc, "GEN_CMD", sd_cmd_GEN_CMD}, },
Signature · 1 line
2.41.0
PATCH v49 4/11 hw/sd/sdcard: Add emmc_cmd_SET_RELATIVE_ADDR handler (CMD3)
In reply to Philippe Mathieu-DaudéFrom: Cédric Le Goater <[email protected]>
--- hw/sd/sd.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
hw/sd/sd.c +15 -0
@@ -1280,6 +1280,20 @@ static sd_rsp_type_t sd_cmd_SEND_RELATIVE_ADDR(SDState *sd, SDRequest req) } } +static sd_rsp_type_t emmc_cmd_SET_RELATIVE_ADDR (SDState *sd,SDRequest req) +{ +switch (sd->state) { +case sd_identification_state: +case sd_standby_state: + sd->state = sd_standby_state; +sd_set_rca (sd, req.arg >>16 ); +return sd_r1; + +default : +return sd_invalid_state_for_cmd (sd, req); + } +} +/* CMD6 */ static sd_rsp_type_t sd_cmd_SWITCH_FUNCTION (SDState *sd,SDRequest req) {
@@ -2445,6 +2459,7 @@ static const SDProto sd_proto_emmc = { [0] = {0, sd_bc, "GO_IDLE_STATE", sd_cmd_GO_IDLE_STATE}, [1] = {0, sd_bcr, "SEND_OP_COND", sd_cmd_SEND_OP_COND}, [2] = {0, sd_bcr, "ALL_SEND_CID", sd_cmd_ALL_SEND_CID}, + [3] = {0, sd_ac, "SET_RELATIVE_ADDR", emmc_cmd_SET_RELATIVE_ADDR}, [4] = {0, sd_bc, "SEND_DSR", sd_cmd_unimplemented}, [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD},
Signature · 1 line
2.41.0
PATCH v49 5/11 hw/sd/sdcard: Fix SET_BLOCK_COUNT command argument on eMMC (CMD23)
In reply to Philippe Mathieu-DaudéFrom: Cédric Le Goater <[email protected]>
The number of blocks is defined in the lower bits [15:0].
--- hw/sd/sd.c | 3 +++ 1 file changed, 3 insertions(+)
hw/sd/sd.c +3 -0
@@ -1533,6 +1533,9 @@ static sd_rsp_type_t sd_cmd_SET_BLOCK_COUNT(SDState *sd, SDRequest req) } sd->multi_blk_cnt = req.arg; +if (sd_is_emmc (sd)) { + sd->multi_blk_cnt &=0xffff ; + }trace_sdcard_set_block_count (sd->multi_blk_cnt);return sd_r1;
Signature · 1 line
2.41.0
PATCH v49 6/11 hw/sd/sdcard: Add emmc_cmd_PROGRAM_CID handler (CMD26)
In reply to Philippe Mathieu-Daudé--- hw/sd/sd.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
hw/sd/sd.c +7 -3
@@ -1568,6 +1568,12 @@ static sd_rsp_type_t sd_cmd_WRITE_SINGLE_BLOCK(SDState *sd, SDRequest req)return sd_cmd_to_receivingdata (sd, req, addr, sd->blk_len); } +/* CMD26 */ +static sd_rsp_type_t emmc_cmd_PROGRAM_CID (SDState *sd,SDRequest req) +{ +return sd_cmd_to_receivingdata (sd, req,0 ,sizeof (sd->cid)); +} +/* CMD27 */ static sd_rsp_type_t sd_cmd_PROGRAM_CSD (SDState *sd,SDRequest req) {
@@ -1917,9 +1923,6 @@ static sd_rsp_type_t sd_normal_command(SDState *sd, SDRequest req) }break ; -case 26 :/* CMD26: PROGRAM_CID */ -return sd_cmd_to_receivingdata (sd, req,0 ,sizeof (sd->cid)); -default :qemu_log_mask (LOG_GUEST_ERROR ,"SD: Unknown CMD%i\n" , req.cmd);return sd_illegal;
@@ -2478,6 +2481,7 @@ static const SDProto sd_proto_emmc = { [20] = {3, sd_adtc, "WRITE_DAT_UNTIL_STOP", sd_cmd_unimplemented}, [23] = {2, sd_ac, "SET_BLOCK_COUNT", sd_cmd_SET_BLOCK_COUNT}, [24] = {4, sd_adtc, "WRITE_SINGLE_BLOCK", sd_cmd_WRITE_SINGLE_BLOCK}, + [26] = {4, sd_adtc, "PROGRAM_CID", emmc_cmd_PROGRAM_CID}, [27] = {4, sd_adtc, "PROGRAM_CSD", sd_cmd_PROGRAM_CSD}, [28] = {6, sd_ac, "SET_WRITE_PROT", sd_cmd_SET_WRITE_PROT}, [29] = {6, sd_ac, "CLR_WRITE_PROT", sd_cmd_CLR_WRITE_PROT},
Signature · 1 line
2.41.0
PATCH v49 7/11 hw/sd/sdcard: Implement eMMC sleep state (CMD5)
In reply to Philippe Mathieu-DaudéFrom: Luc Michel <[email protected]>
The JEDEC standards specifies a sleep state where the eMMC won't answer any command appart from RESET and WAKEUP and go to low power state. Implement this state and the corresponding command number 5.
--- hw/sd/sd.c | 47 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 45 insertions(+), 2 deletions(-)
hw/sd/sd.c +45 -2
@@ -1236,8 +1236,19 @@ static sd_rsp_type_t sd_cmd_to_sendingdata(SDState *sd, SDRequest req,/* CMD0 */ static sd_rsp_type_t sd_cmd_GO_IDLE_STATE (SDState *sd,SDRequest req) { - sd->state = sd_idle_state; -sd_reset (DEVICE (sd)); +if (sd->state == sd_sleep_state) { +switch (req.arg) { +case 0x00000000 : +case 0xf0f0f0f0 : +break ; +default : +return sd_r0; + } + } +if (sd->state != sd_inactive_state) { + sd->state = sd_idle_state; +sd_reset (DEVICE (sd)); + }return sd_is_spi (sd) ? sd_r1 : sd_r0; }
@@ -1294,6 +1305,30 @@ static sd_rsp_type_t emmc_cmd_SET_RELATIVE_ADDR(SDState *sd, SDRequest req) } } +/* CMD5 */ +static sd_rsp_type_t emmc_cmd_sleep_awake (SDState *sd,SDRequest req) +{ +bool do_sleep =extract32 (req.arg,15 ,1 ); + +switch (sd->state) { +case sd_sleep_state: +if (!do_sleep) { +/* Awake */ + sd->state = sd_standby_state; + } +return sd_r1b; + +case sd_standby_state: +if (do_sleep) { + sd->state = sd_sleep_state; + } +return sd_r1b; + +default : +return sd_invalid_state_for_cmd (sd, req); + } +} +/* CMD6 */ static sd_rsp_type_t sd_cmd_SWITCH_FUNCTION (SDState *sd,SDRequest req) {
@@ -1696,6 +1731,7 @@ static sd_rsp_type_t sd_cmd_APP_CMD(SDState *sd, SDRequest req)case sd_ready_state:case sd_identification_state:case sd_inactive_state: +case sd_sleep_state:return sd_invalid_state_for_cmd (sd, req);case sd_idle_state:if (!sd_is_spi (sd) &&sd_req_get_rca (sd, req) !=0x0000 ) {
@@ -2018,6 +2054,12 @@ int sd_do_command(SDState *sd, SDRequest *req, req->cmd &=0x3f ; } +if (sd->state == sd_sleep_state && req->cmd) { +qemu_log_mask (LOG_GUEST_ERROR ,"SD: Card is sleeping\n" ); + rtype = sd_r0; + goto send_response; + } +if (sd->card_status &CARD_IS_LOCKED ) {if (!cmd_valid_while_locked (sd, req->cmd)) { sd->card_status |=ILLEGAL_COMMAND ;
@@ -2467,6 +2509,7 @@ static const SDProto sd_proto_emmc = { [2] = {0, sd_bcr, "ALL_SEND_CID", sd_cmd_ALL_SEND_CID}, [3] = {0, sd_ac, "SET_RELATIVE_ADDR", emmc_cmd_SET_RELATIVE_ADDR}, [4] = {0, sd_bc, "SEND_DSR", sd_cmd_unimplemented}, + [5] = {0, sd_ac, "SLEEP/AWAKE", emmc_cmd_sleep_awake}, [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD}, [10] = {0, sd_ac, "SEND_CID", sd_cmd_SEND_CID},
Signature · 1 line
2.41.0
PATCH v49 8/11 hw/sd/sdcard: Add emmc_cmd_SEND_EXT_CSD handler (CMD8)
In reply to Philippe Mathieu-DaudéFrom: Vincent Palatin <[email protected]>
The parameters mimick a real 4GB eMMC, but it can be set to various sizes.
EXT_CSD values from Vincent's patch simplivied for Spec v4.3:
- Remove deprecated keys:
. EXT_CSD_SEC_ERASE_MULT
. EXT_CSD_SEC_TRIM_MULT
- Set some keys to not defined / implemented:
. EXT_CSD_HPI_FEATURES
. EXT_CSD_BKOPS_SUPPORT
. EXT_CSD_SEC_FEATURE_SUPPORT
. EXT_CSD_ERASE_TIMEOUT_MULT
. EXT_CSD_PART_SWITCH_TIME
. EXT_CSD_OUT_OF_INTERRUPT_TIME
- Simplify:
. EXT_CSD_ACC_SIZE (6 -> 1)
16KB of super_page_size -> 512B (BDRV_SECTOR_SIZE)
. EXT_CSD_HC_ERASE_GRP_SIZE (4 -> 1)
. EXT_CSD_HC_WP_GRP_SIZE (4 -> 1)
. EXT_CSD_S_C_VCC[Q] (8 -> 1)
. EXT_CSD_S_A_TIMEOUT (17 -> 1)
. EXT_CSD_CARD_TYPE (7 -> 3)
Dual data rate -> High-Speed mode- Update:
. EXT_CSD_CARD_TYPE (7 -> 3)
High-Speed MultiMediaCard @ 26MHz & 52MHz
. Performances (0xa -> 0x46)
Class B at 3MB/s. -> Class J at 21MB/s
. EXT_CSD_REV (5 -> 3)
Rev 1.5 (spec v4.41) -> Rev 1.3 (spec v4.3)- Use load/store API to set EXT_CSD_SEC_CNT
- Remove R/W keys, normally zeroed at reset
. EXT_CSD_BOOT_INFO
Migrate the Modes segment (192 lower bytes) but not the full EXT_CSD register, see Spec v4.3, chapter 8.4 "Extended CSD register":
The Extended CSD register defines the card properties and selected modes. It is 512 bytes long. The most significant 320 bytes are the Properties segment, which defines the card capabilities and cannot be modified by the host. The lower 192 bytes are the Modes segment, which defines the configuration the card is working in. These modes can be changed by the host by means of the SWITCH command.
--- hw/sd/sd.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+)
hw/sd/sd.c +70 -0
@@ -124,6 +124,13 @@ struct SDState {uint16_t rca;uint32_t card_status;uint8_t sd_status[64 ]; +union { +uint8_t ext_csd[512 ]; +struct { +uint8_t ext_csd_rw[192 ];/* Modes segment */ +uint8_t ext_csd_ro[320 ];/* Properties segment */ + }; + };/* Static properties */
@@ -476,6 +483,36 @@ static const uint8_t sd_csd_rw_mask[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfe, }; +static void emmc_set_ext_csd (SDState *sd,uint64_t size) +{ +uint32_t sectcount = size >>HWBLOCK_SHIFT ; + +memset (sd->ext_csd,0 ,sizeof (sd->ext_csd));/* FIXME only RW at reset */ + +/* Properties segment (RO) */ + sd->ext_csd[EXT_CSD_S_CMD_SET ] =0b1 ;/* supported command sets */ + sd->ext_csd[EXT_CSD_BOOT_INFO ] =0x0 ;/* Boot information */ + sd->ext_csd[EXT_CSD_BOOT_MULT ] =0x8 ;/* Boot partition size. 128KB unit */ + sd->ext_csd[EXT_CSD_ACC_SIZE ] =0x1 ;/* Access size */ + sd->ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE ] =0x01 ;/* HC Erase unit size */ + sd->ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT ] =0x01 ;/* HC erase timeout */ + sd->ext_csd[EXT_CSD_REL_WR_SEC_C ] =0x1 ;/* Reliable write sector count */ + sd->ext_csd[EXT_CSD_HC_WP_GRP_SIZE ] =0x01 ;/* HC write protect group size */ + sd->ext_csd[EXT_CSD_S_C_VCC ] =0x01 ;/* Sleep current VCC */ + sd->ext_csd[EXT_CSD_S_C_VCCQ ] =0x01 ;/* Sleep current VCCQ */ + sd->ext_csd[EXT_CSD_S_A_TIMEOUT ] =0x01 ;/* Sleep/Awake timeout */ +stl_le_p (&sd->ext_csd[EXT_CSD_SEC_CNT ], sectcount);/* Sector count */ + sd->ext_csd[210 ] =0x46 ;/* Min write perf for 8bit@52Mhz */ + sd->ext_csd[209 ] =0x46 ;/* Min read perf for 8bit@52Mhz */ + sd->ext_csd[208 ] =0x46 ;/* Min write perf for 4bit@52Mhz */ + sd->ext_csd[207 ] =0x46 ;/* Min read perf for 4bit@52Mhz */ + sd->ext_csd[206 ] =0x46 ;/* Min write perf for 4bit@26Mhz */ + sd->ext_csd[205 ] =0x46 ;/* Min read perf for 4bit@26Mhz */ + sd->ext_csd[EXT_CSD_CARD_TYPE ] =0b11 ; + sd->ext_csd[EXT_CSD_STRUCTURE ] =2 ; + sd->ext_csd[EXT_CSD_REV ] =3 ; +} +static void emmc_set_csd (SDState *sd,uint64_t size) {int hwblock_shift =HWBLOCK_SHIFT ;
@@ -512,6 +549,7 @@ static void emmc_set_csd(SDState *sd, uint64_t size) ((hwblock_shift <<6 ) &0xc0 ); sd->csd[14 ] =0x00 ; sd->csd[15 ] = (sd_crc7 (sd->csd,15 ) <<1 ) |1 ; +emmc_set_ext_csd (sd, size); }static void sd_set_csd (SDState *sd,uint64_t size)
@@ -847,6 +885,24 @@ static const VMStateDescription sd_ocr_vmstate = { }, }; +static bool vmstate_needed_for_emmc (void *opaque) +{ +SDState *sd = opaque; + +return sd_is_emmc (sd); +} + +static const VMStateDescription emmc_extcsd_vmstate = { + .name ="sd-card/ext_csd_modes-state" , + .version_id =1 , + .minimum_version_id =1 , + .needed = vmstate_needed_for_emmc, + .fields = (const VMStateField []) { +VMSTATE_UINT8_ARRAY (ext_csd_rw, SDState,192 ), +VMSTATE_END_OF_LIST () + }, +}; +static int sd_vmstate_pre_load (void *opaque) {SDState *sd = opaque;
@@ -894,6 +950,7 @@ static const VMStateDescription sd_vmstate = { }, .subsections = (const VMStateDescription * const []) { &sd_ocr_vmstate, + &emmc_extcsd_vmstate,NULL }, };
@@ -1405,6 +1462,17 @@ static sd_rsp_type_t sd_cmd_SEND_IF_COND(SDState *sd, SDRequest req)return sd_r7; } +/* CMD8 */ +static sd_rsp_type_t emmc_cmd_SEND_EXT_CSD (SDState *sd,SDRequest req) +{ +if (sd->state != sd_transfer_state) { +return sd_invalid_state_for_cmd (sd, req); + } + +return sd_cmd_to_sendingdata (sd, req,sd_req_get_address (sd, req), + sd->ext_csd,sizeof (sd->ext_csd)); +} +/* CMD9 */ static sd_rsp_type_t spi_cmd_SEND_CSD (SDState *sd,SDRequest req) {
@@ -2334,6 +2402,7 @@ uint8_t sd_read_byte(SDState *sd) sd->data_offset, sd->data_size, io_len);switch (sd->current_cmd) {case 6 :/* CMD6: SWITCH_FUNCTION */ +case 8 :/* CMD8: SEND_EXT_CSD */ case 9 :/* CMD9: SEND_CSD */ case 10 :/* CMD10: SEND_CID */ case 13 :/* ACMD13: SD_STATUS */
@@ -2511,6 +2580,7 @@ static const SDProto sd_proto_emmc = { [4] = {0, sd_bc, "SEND_DSR", sd_cmd_unimplemented}, [5] = {0, sd_ac, "SLEEP/AWAKE", emmc_cmd_sleep_awake}, [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, + [8] = {0, sd_adtc, "SEND_EXT_CSD", emmc_cmd_SEND_EXT_CSD}, [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD}, [10] = {0, sd_ac, "SEND_CID", sd_cmd_SEND_CID}, [11] = {1, sd_adtc, "READ_DAT_UNTIL_STOP", sd_cmd_unimplemented},
Signature · 1 line
2.41.0
PATCH v49 9/11 hw/sd/sdcard: Add eMMC 'boot-partition-size' property
In reply to Philippe Mathieu-DaudéAvoid hardcoding 1MiB boot size in EXT_CSD_BOOT_MULT, expose it as 'boot-partition-size' QOM property.
By default, do not use any size. The board is responsible to set the boot partition size property.
--- hw/sd/sd.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
hw/sd/sd.c +4 -1
@@ -135,6 +135,7 @@ struct SDState {/* Static properties */ uint8_t spec_version; +uint64_t boot_part_size;BlockBackend *blk;const SDProto *proto;
@@ -492,7 +493,8 @@ static void emmc_set_ext_csd(SDState *sd, uint64_t size)/* Properties segment (RO) */ sd->ext_csd[EXT_CSD_S_CMD_SET ] =0b1 ;/* supported command sets */ sd->ext_csd[EXT_CSD_BOOT_INFO ] =0x0 ;/* Boot information */ - sd->ext_csd[EXT_CSD_BOOT_MULT ] =0x8 ;/* Boot partition size. 128KB unit */ +/* Boot partition size. 128KB unit */ + sd->ext_csd[EXT_CSD_BOOT_MULT ] = sd->boot_part_size / (128 * KiB); sd->ext_csd[EXT_CSD_ACC_SIZE ] =0x1 ;/* Access size */ sd->ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE ] =0x01 ;/* HC Erase unit size */ sd->ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT ] =0x01 ;/* HC erase timeout */
@@ -2704,6 +2706,7 @@ static Property sd_properties[] = { };static Property emmc_properties[] = { +DEFINE_PROP_UINT64 ("boot-partition-size" , SDState, boot_part_size,0 ),DEFINE_PROP_END_OF_LIST () };
Signature · 1 line
2.41.0
PATCH v49 10/11 hw/sd/sdcard: Add mmc SWITCH function support (CMD6)
In reply to Philippe Mathieu-DaudéFrom: Sai Pavan Boddu <[email protected]>
switch operation in mmc cards, updated the ext_csd register to request changes in card operations. Here we implement similar sequence but requests are mostly dummy and make no change.
Implement SWITCH_ERROR if the write operation offset goes beyond length of ext_csd.
--- hw/sd/sd.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++ hw/sd/trace-events | 2 ++ 2 files changed, 58 insertions(+)
hw/sd/sd.c +56 -0
@@ -642,6 +642,7 @@ static bool sd_req_rca_same(SDState *s, SDRequest req) FIELD(CSR, AKE_SEQ_ERROR, 3, 1) FIELD(CSR, APP_CMD, 5, 1) FIELD(CSR, FX_EVENT, 6, 1) +FIELD(CSR, SWITCH_ERROR, 7, 1) FIELD(CSR, READY_FOR_DATA, 8, 1) FIELD(CSR, CURRENT_STATE, 9, 4)FIELD (CSR ,ERASE_RESET ,13 ,1 )
@@ -1091,6 +1092,47 @@ static uint32_t sd_wpbits(SDState *sd, uint64_t addr)return ret; } +enum ExtCsdAccessMode { +EXT_CSD_ACCESS_MODE_COMMAND_SET =0 , +EXT_CSD_ACCESS_MODE_SET_BITS =1 , +EXT_CSD_ACCESS_MODE_CLEAR_BITS =2 , +EXT_CSD_ACCESS_MODE_WRITE_BYTE =3 +}; + +static void emmc_function_switch (SDState *sd,uint32_t arg) +{ +uint8_t access =extract32 (arg,24 ,2 ); +uint8_t index =extract32 (arg,16 ,8 ); +uint8_t value =extract32 (arg,8 ,8 ); +uint8_t b = sd->ext_csd[index]; + +trace_sdcard_switch (access, index, value,extract32 (arg,0 ,2 )); + +if (index >=192 ) { +qemu_log_mask (LOG_GUEST_ERROR ,"MMC switching illegal offset\n" ); + sd->card_status |=R_CSR_SWITCH_ERROR_MASK ; +return ; + } + +switch (access) { +case EXT_CSD_ACCESS_MODE_COMMAND_SET : +qemu_log_mask (LOG_UNIMP ,"MMC Command set switching not supported\n" ); +return ; +case EXT_CSD_ACCESS_MODE_SET_BITS : + b |= value; +break ; +case EXT_CSD_ACCESS_MODE_CLEAR_BITS : + b &= ~value; +break ; +case EXT_CSD_ACCESS_MODE_WRITE_BYTE : + b = value; +break ; + } + +trace_sdcard_ext_csd_update (index, sd->ext_csd[index], b); + sd->ext_csd[index] = b; +} +static void sd_function_switch (SDState *sd,uint32_t arg) {int i, mode, new_func;
@@ -1402,6 +1444,19 @@ static sd_rsp_type_t sd_cmd_SWITCH_FUNCTION(SDState *sd, SDRequest req)return sd_cmd_to_sendingdata (sd, req,0 ,NULL ,64 ); } +static sd_rsp_type_t emmc_cmd_SWITCH (SDState *sd,SDRequest req) +{ +switch (sd->state) { +case sd_transfer_state: + sd->state = sd_programming_state; +emmc_function_switch (sd, req.arg); + sd->state = sd_transfer_state; +return sd_r1b; +default : +return sd_invalid_state_for_cmd (sd, req); + } +} +/* CMD7 */ static sd_rsp_type_t sd_cmd_DE_SELECT_CARD (SDState *sd,SDRequest req) {
@@ -2581,6 +2636,7 @@ static const SDProto sd_proto_emmc = { [3] = {0, sd_ac, "SET_RELATIVE_ADDR", emmc_cmd_SET_RELATIVE_ADDR}, [4] = {0, sd_bc, "SEND_DSR", sd_cmd_unimplemented}, [5] = {0, sd_ac, "SLEEP/AWAKE", emmc_cmd_sleep_awake}, + [6] = {10, sd_adtc, "SWITCH", emmc_cmd_SWITCH}, [7] = {0, sd_ac, "(DE)SELECT_CARD", sd_cmd_DE_SELECT_CARD}, [8] = {0, sd_adtc, "SEND_EXT_CSD", emmc_cmd_SEND_EXT_CSD}, [9] = {0, sd_ac, "SEND_CSD", sd_cmd_SEND_CSD},
hw/sd/trace-events +2 -0
@@ -57,6 +57,8 @@ sdcard_write_block(uint64_t addr, uint32_t len) "addr 0x%" PRIx64 " size 0x%x" sdcard_write_data(const char *proto, const char *cmd_desc, uint8_t cmd, uint32_t offset, uint8_t value) "%s %20s/ CMD%02d ofs %"PRIu32" value 0x%02x" sdcard_read_data(const char *proto, const char *cmd_desc, uint8_t cmd, uint32_t offset, uint64_t size, uint32_t blklen) "%s %20s/ CMD%02d ofs %"PRIu32" size %"PRIu64" blklen %" PRIu32 sdcard_set_voltage(uint16_t millivolts) "%u mV" +sdcard_ext_csd_update(unsigned index, uint8_t oval, uint8_t nval) "index %u: 0x%02x -> 0x%02x" +sdcard_switch(unsigned access, unsigned index, unsigned value, unsigned set) "SWITCH acc:%u idx:%u val:%u set:%u" # pxa2xx_mmci.c pxa2xx_mmci_read(uint8_t size, uint32_t addr, uint32_t value) "size %d addr 0x%02x value 0x%08x"
Signature · 1 line
2.41.0
PATCH v49 11/11 hw/sd/sdcard: Support boot area in emmc image
In reply to Philippe Mathieu-DaudéFrom: Joel Stanley <[email protected]>
This assumes a specially constructed image:
dd if=/dev/zero of=mmc-bootarea.img count=2 bs=1M dd if=u-boot-spl.bin of=mmc-bootarea.img conv=notrunc dd if=u-boot.bin of=mmc-bootarea.img conv=notrunc count=64 bs=1K cat mmc-bootarea.img obmc-phosphor-image.wic > mmc.img truncate --size 16GB mmc.img
For now this still requires a mtd image to load the SPL:
qemu-system-arm -M tacoma-bmc -nographic \ -global driver=sd-card,property=emmc,value=true \ -drive file=mmc.img,if=sd,index=2,format=raw
--- hw/sd/sd.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+)
hw/sd/sd.c +42 -0
@@ -137,6 +137,7 @@ struct SDState {uint8_t spec_version;uint64_t boot_part_size;BlockBackend *blk; +uint8_t boot_config;const SDProto *proto;
@@ -513,6 +514,9 @@ static void emmc_set_ext_csd(SDState *sd, uint64_t size) sd->ext_csd[EXT_CSD_CARD_TYPE ] =0b11 ; sd->ext_csd[EXT_CSD_STRUCTURE ] =2 ; sd->ext_csd[EXT_CSD_REV ] =3 ; + +/* Mode segment (RW) */ + sd->ext_csd[EXT_CSD_PART_CONFIG ] = sd->boot_config; }static void emmc_set_csd (SDState *sd,uint64_t size)
@@ -763,6 +767,40 @@ static uint32_t sd_blk_len(SDState *sd)return sd->blk_len; } +/* +* This requires a disk image that has two boot partitions inserted at the +* beginning of it. The size of the boot partitions is the "boot-size" +* property. +*/ +static uint32_t sd_bootpart_offset (SDState *sd) +{ +bool partitions_enabled; +unsigned partition_access; + +if (!sd->boot_part_size || !sd_is_emmc (sd)) { +return 0 ; + } + + partitions_enabled = sd->ext_csd[EXT_CSD_PART_CONFIG ] + &EXT_CSD_PART_CONFIG_EN_MASK ; +if (!partitions_enabled) { +return 0 ; + } + + partition_access = sd->ext_csd[EXT_CSD_PART_CONFIG ] + &EXT_CSD_PART_CONFIG_ACC_MASK ; +switch (partition_access) { +case EXT_CSD_PART_CONFIG_ACC_DEFAULT : +return sd->boot_part_size *2 ; +case EXT_CSD_PART_CONFIG_ACC_BOOT0 : +return 0 ; +case EXT_CSD_PART_CONFIG_ACC_BOOT0 +1 : +return sd->boot_part_size *1 ; +default : +g_assert_not_reached (); + } +} +static uint64_t sd_req_get_address (SDState *sd,SDRequest req) {uint64_t addr;
@@ -795,6 +833,7 @@ static void sd_reset(DeviceState *dev) sect =0 ; } size = sect <<HWBLOCK_SHIFT ; + size -=sd_bootpart_offset (sd); sect =sd_addr_to_wpnum (size) +1 ;
@@ -1003,6 +1042,7 @@ void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)static void sd_blk_read (SDState *sd,uint64_t addr,uint32_t len) {trace_sdcard_read_block (addr, len); + addr +=sd_bootpart_offset (sd);if (!sd->blk ||blk_pread (sd->blk, addr, len, sd->data,0 ) <0 ) {fprintf (stderr,"sd_blk_read: read error on host side\n" ); }
@@ -1011,6 +1051,7 @@ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)static void sd_blk_write (SDState *sd,uint64_t addr,uint32_t len) {trace_sdcard_write_block (addr, len); + addr +=sd_bootpart_offset (sd);if (!sd->blk ||blk_pwrite (sd->blk, addr, len, sd->data,0 ) <0 ) {fprintf (stderr,"sd_blk_write: write error on host side\n" ); }
@@ -2763,6 +2804,7 @@ static Property sd_properties[] = {static Property emmc_properties[] = {DEFINE_PROP_UINT64 ("boot-partition-size" , SDState, boot_part_size,0 ), +DEFINE_PROP_UINT8 ("boot-config" , SDState, boot_config,0x0 ),DEFINE_PROP_END_OF_LIST () };
Signature · 1 line
2.41.0
Quoted 2 lines · Philippe Mathieu-Daudé
Tag to test Aspeed tree:
https://gitlab.com/philmd/qemu/-/tags/aspeed_emmc-v9
Updated aspeed9.1 branch. LGTM.
Thanks,
C.
Quoted 34 lines
Since v48:
- Dropped "Implement 'boot-mode' reset timing" patch
- Re-introduce Joel "Support boot area in emmc image" patch
- Comment magic CSD valuesCédric Le Goater (2):
hw/sd/sdcard: Addemmc_cmd_SET_RELATIVE_ADDRhandler (CMD3) hw/sd/sdcard: FixSET_BLOCK_COUNTcommand argument on eMMC (CMD23)Joel Stanley (1):
hw/sd/sdcard: Support boot area in emmc imageLuc Michel (1):
hw/sd/sdcard: Implement eMMC sleep state (CMD5)Philippe Mathieu-Daudé (5):
hw/sd/sdcard: Basis for eMMC support hw/sd/sdcard: Register generic command handlers hw/sd/sdcard: Register unimplemented command handlers hw/sd/sdcard: Addemmc_cmd_PROGRAM_CIDhandler (CMD26) hw/sd/sdcard: Add eMMC 'boot-partition-size' propertySai Pavan Boddu (1):
hw/sd/sdcard: Add mmc SWITCH function support (CMD6)Vincent Palatin (1):
hw/sd/sdcard: Addemmc_cmd_SEND_EXT_CSDhandler (CMD8)include/hw/sd/sd.h | 3 + hw/sd/sd.c | 385 ++++++++++++++++++++++++++++++++++++++++++++- hw/sd/trace-events | 2 + 3 files changed, 384 insertions(+), 6 deletions(-)
Series queued, thanks.