2 * SD Memory Card emulation as defined in the "SD Memory Card Physical
3 * layer specification, Version 2.00."
5 * Copyright (c) 2006 Andrzej Zaborowski <balrog@zabor.org>
6 * Copyright (c) 2007 CodeSourcery
7 * Copyright (c) 2018 Philippe Mathieu-Daudé <f4bug@amsat.org>
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
23 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
28 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include "qemu/osdep.h"
34 #include "qemu/units.h"
36 #include "hw/registerfields.h"
37 #include "sysemu/block-backend.h"
39 #include "migration/vmstate.h"
40 #include "qapi/error.h"
41 #include "qemu/bitmap.h"
42 #include "hw/qdev-properties.h"
43 #include "qemu/error-report.h"
44 #include "qemu/timer.h"
46 #include "qemu/module.h"
47 #include "sdmmc-internal.h"
53 sd_r0
= 0, /* no response */
54 sd_r1
, /* normal response command */
55 sd_r2_i
, /* CID register */
56 sd_r2_s
, /* CSD register */
57 sd_r3
, /* OCR register */
58 sd_r6
= 6, /* Published RCA response */
59 sd_r7
, /* Operating voltage */
66 sd_card_identification_mode
,
67 sd_data_transfer_mode
,
71 sd_inactive_state
= -1,
74 sd_identification_state
,
78 sd_receivingdata_state
,
84 DeviceState parent_obj
;
86 /* If true, created by sd_init() for a non-qdevified caller */
87 /* TODO purge them with fire */
88 bool me_no_qdev_me_kill_mammoth_with_rocks
;
90 /* SD Memory Card Registers */
97 uint8_t sd_status
[64];
99 /* Configurable properties */
100 uint8_t spec_version
;
104 uint32_t mode
; /* current card mode, one of SDCardModes */
105 int32_t state
; /* current card state, one of SDCardStates */
108 unsigned long *wp_groups
;
112 uint32_t multi_blk_cnt
;
113 uint32_t erase_start
;
117 uint8_t function_group
[6];
119 /* True if we will handle the next command as an ACMD. Note that this does
120 * *not* track the APP_CMD status bit!
123 uint32_t blk_written
;
125 uint32_t data_offset
;
127 qemu_irq readonly_cb
;
128 qemu_irq inserted_cb
;
129 QEMUTimer
*ocr_power_timer
;
130 const char *proto_name
;
136 static void sd_realize(DeviceState
*dev
, Error
**errp
);
138 static const char *sd_state_name(enum SDCardStates state
)
140 static const char *state_name
[] = {
141 [sd_idle_state
] = "idle",
142 [sd_ready_state
] = "ready",
143 [sd_identification_state
] = "identification",
144 [sd_standby_state
] = "standby",
145 [sd_transfer_state
] = "transfer",
146 [sd_sendingdata_state
] = "sendingdata",
147 [sd_receivingdata_state
] = "receivingdata",
148 [sd_programming_state
] = "programming",
149 [sd_disconnect_state
] = "disconnect",
151 if (state
== sd_inactive_state
) {
154 assert(state
< ARRAY_SIZE(state_name
));
155 return state_name
[state
];
158 static const char *sd_response_name(sd_rsp_type_t rsp
)
160 static const char *response_name
[] = {
161 [sd_r0
] = "RESP#0 (no response)",
162 [sd_r1
] = "RESP#1 (normal cmd)",
163 [sd_r2_i
] = "RESP#2 (CID reg)",
164 [sd_r2_s
] = "RESP#2 (CSD reg)",
165 [sd_r3
] = "RESP#3 (OCR reg)",
166 [sd_r6
] = "RESP#6 (RCA)",
167 [sd_r7
] = "RESP#7 (operating voltage)",
169 if (rsp
== sd_illegal
) {
170 return "ILLEGAL RESP";
175 assert(rsp
< ARRAY_SIZE(response_name
));
176 return response_name
[rsp
];
179 static uint8_t sd_get_dat_lines(SDState
*sd
)
181 return sd
->enable
? sd
->dat_lines
: 0;
184 static bool sd_get_cmd_line(SDState
*sd
)
186 return sd
->enable
? sd
->cmd_line
: false;
189 static void sd_set_voltage(SDState
*sd
, uint16_t millivolts
)
191 trace_sdcard_set_voltage(millivolts
);
193 switch (millivolts
) {
194 case 3001 ... 3600: /* SD_VOLTAGE_3_3V */
195 case 2001 ... 3000: /* SD_VOLTAGE_3_0V */
198 qemu_log_mask(LOG_GUEST_ERROR
, "SD card voltage not supported: %.3fV",
199 millivolts
/ 1000.f
);
203 static void sd_set_mode(SDState
*sd
)
206 case sd_inactive_state
:
207 sd
->mode
= sd_inactive
;
212 case sd_identification_state
:
213 sd
->mode
= sd_card_identification_mode
;
216 case sd_standby_state
:
217 case sd_transfer_state
:
218 case sd_sendingdata_state
:
219 case sd_receivingdata_state
:
220 case sd_programming_state
:
221 case sd_disconnect_state
:
222 sd
->mode
= sd_data_transfer_mode
;
227 static const sd_cmd_type_t sd_cmd_type
[SDMMC_CMD_MAX
] = {
228 sd_bc
, sd_none
, sd_bcr
, sd_bcr
, sd_none
, sd_none
, sd_none
, sd_ac
,
229 sd_bcr
, sd_ac
, sd_ac
, sd_adtc
, sd_ac
, sd_ac
, sd_none
, sd_ac
,
231 sd_ac
, sd_adtc
, sd_adtc
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
,
232 sd_adtc
, sd_adtc
, sd_adtc
, sd_adtc
, sd_ac
, sd_ac
, sd_adtc
, sd_none
,
234 sd_ac
, sd_ac
, sd_none
, sd_none
, sd_none
, sd_none
, sd_ac
, sd_none
,
235 sd_none
, sd_none
, sd_bc
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
,
237 sd_none
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
, sd_ac
,
238 sd_adtc
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
, sd_none
,
241 static const int sd_cmd_class
[SDMMC_CMD_MAX
] = {
242 0, 0, 0, 0, 0, 9, 10, 0, 0, 0, 0, 1, 0, 0, 0, 0,
243 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 6, 6, 6, 6,
244 5, 5, 10, 10, 10, 10, 5, 9, 9, 9, 7, 7, 7, 7, 7, 7,
245 7, 7, 10, 7, 9, 9, 9, 8, 8, 10, 8, 8, 8, 8, 8, 8,
248 static uint8_t sd_crc7(void *message
, size_t width
)
251 uint8_t shift_reg
= 0x00;
252 uint8_t *msg
= (uint8_t *) message
;
254 for (i
= 0; i
< width
; i
++, msg
++)
255 for (bit
= 7; bit
>= 0; bit
--) {
257 if ((shift_reg
>> 7) ^ ((*msg
>> bit
) & 1))
264 static uint16_t sd_crc16(void *message
, size_t width
)
267 uint16_t shift_reg
= 0x0000;
268 uint16_t *msg
= (uint16_t *) message
;
271 for (i
= 0; i
< width
; i
++, msg
++)
272 for (bit
= 15; bit
>= 0; bit
--) {
274 if ((shift_reg
>> 15) ^ ((*msg
>> bit
) & 1))
281 #define OCR_POWER_DELAY_NS 500000 /* 0.5ms */
283 FIELD(OCR
, VDD_VOLTAGE_WINDOW
, 0, 24)
284 FIELD(OCR
, VDD_VOLTAGE_WIN_LO
, 0, 8)
285 FIELD(OCR
, DUAL_VOLTAGE_CARD
, 7, 1)
286 FIELD(OCR
, VDD_VOLTAGE_WIN_HI
, 8, 16)
287 FIELD(OCR
, ACCEPT_SWITCH_1V8
, 24, 1) /* Only UHS-I */
288 FIELD(OCR
, UHS_II_CARD
, 29, 1) /* Only UHS-II */
289 FIELD(OCR
, CARD_CAPACITY
, 30, 1) /* 0:SDSC, 1:SDHC/SDXC */
290 FIELD(OCR
, CARD_POWER_UP
, 31, 1)
292 #define ACMD41_ENQUIRY_MASK 0x00ffffff
293 #define ACMD41_R3_MASK (R_OCR_VDD_VOLTAGE_WIN_HI_MASK \
294 | R_OCR_ACCEPT_SWITCH_1V8_MASK \
295 | R_OCR_UHS_II_CARD_MASK \
296 | R_OCR_CARD_CAPACITY_MASK \
297 | R_OCR_CARD_POWER_UP_MASK)
299 static void sd_set_ocr(SDState
*sd
)
301 /* All voltages OK */
302 sd
->ocr
= R_OCR_VDD_VOLTAGE_WIN_HI_MASK
;
305 static void sd_ocr_powerup(void *opaque
)
307 SDState
*sd
= opaque
;
309 trace_sdcard_powerup();
310 assert(!FIELD_EX32(sd
->ocr
, OCR
, CARD_POWER_UP
));
312 /* card power-up OK */
313 sd
->ocr
= FIELD_DP32(sd
->ocr
, OCR
, CARD_POWER_UP
, 1);
315 if (sd
->size
> 1 * GiB
) {
316 sd
->ocr
= FIELD_DP32(sd
->ocr
, OCR
, CARD_CAPACITY
, 1);
320 static void sd_set_scr(SDState
*sd
)
322 sd
->scr
[0] = 0 << 4; /* SCR structure version 1.0 */
323 if (sd
->spec_version
== SD_PHY_SPECv1_10_VERS
) {
324 sd
->scr
[0] |= 1; /* Spec Version 1.10 */
326 sd
->scr
[0] |= 2; /* Spec Version 2.00 or Version 3.0X */
328 sd
->scr
[1] = (2 << 4) /* SDSC Card (Security Version 1.01) */
329 | 0b0101; /* 1-bit or 4-bit width bus modes */
330 sd
->scr
[2] = 0x00; /* Extended Security is not supported. */
331 if (sd
->spec_version
>= SD_PHY_SPECv3_01_VERS
) {
332 sd
->scr
[2] |= 1 << 7; /* Spec Version 3.0X */
335 /* reserved for manufacturer usage */
349 static void sd_set_cid(SDState
*sd
)
351 sd
->cid
[0] = MID
; /* Fake card manufacturer ID (MID) */
352 sd
->cid
[1] = OID
[0]; /* OEM/Application ID (OID) */
354 sd
->cid
[3] = PNM
[0]; /* Fake product name (PNM) */
359 sd
->cid
[8] = PRV
; /* Fake product revision (PRV) */
360 sd
->cid
[9] = 0xde; /* Fake serial number (PSN) */
364 sd
->cid
[13] = 0x00 | /* Manufacture date (MDT) */
365 ((MDT_YR
- 2000) / 10);
366 sd
->cid
[14] = ((MDT_YR
% 10) << 4) | MDT_MON
;
367 sd
->cid
[15] = (sd_crc7(sd
->cid
, 15) << 1) | 1;
370 #define HWBLOCK_SHIFT 9 /* 512 bytes */
371 #define SECTOR_SHIFT 5 /* 16 kilobytes */
372 #define WPGROUP_SHIFT 7 /* 2 megs */
373 #define CMULT_SHIFT 9 /* 512 times HWBLOCK_SIZE */
374 #define WPGROUP_SIZE (1 << (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT))
376 static const uint8_t sd_csd_rw_mask
[16] = {
377 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
378 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfe,
381 static void sd_set_csd(SDState
*sd
, uint64_t size
)
383 uint32_t csize
= (size
>> (CMULT_SHIFT
+ HWBLOCK_SHIFT
)) - 1;
384 uint32_t sectsize
= (1 << (SECTOR_SHIFT
+ 1)) - 1;
385 uint32_t wpsize
= (1 << (WPGROUP_SHIFT
+ 1)) - 1;
387 if (size
<= 1 * GiB
) { /* Standard Capacity SD */
388 sd
->csd
[0] = 0x00; /* CSD structure */
389 sd
->csd
[1] = 0x26; /* Data read access-time-1 */
390 sd
->csd
[2] = 0x00; /* Data read access-time-2 */
391 sd
->csd
[3] = 0x32; /* Max. data transfer rate: 25 MHz */
392 sd
->csd
[4] = 0x5f; /* Card Command Classes */
393 sd
->csd
[5] = 0x50 | /* Max. read data block length */
395 sd
->csd
[6] = 0xe0 | /* Partial block for read allowed */
396 ((csize
>> 10) & 0x03);
397 sd
->csd
[7] = 0x00 | /* Device size */
398 ((csize
>> 2) & 0xff);
399 sd
->csd
[8] = 0x3f | /* Max. read current */
400 ((csize
<< 6) & 0xc0);
401 sd
->csd
[9] = 0xfc | /* Max. write current */
402 ((CMULT_SHIFT
- 2) >> 1);
403 sd
->csd
[10] = 0x40 | /* Erase sector size */
404 (((CMULT_SHIFT
- 2) << 7) & 0x80) | (sectsize
>> 1);
405 sd
->csd
[11] = 0x00 | /* Write protect group size */
406 ((sectsize
<< 7) & 0x80) | wpsize
;
407 sd
->csd
[12] = 0x90 | /* Write speed factor */
408 (HWBLOCK_SHIFT
>> 2);
409 sd
->csd
[13] = 0x20 | /* Max. write data block length */
410 ((HWBLOCK_SHIFT
<< 6) & 0xc0);
411 sd
->csd
[14] = 0x00; /* File format group */
422 sd
->csd
[7] = (size
>> 16) & 0xff;
423 sd
->csd
[8] = (size
>> 8) & 0xff;
424 sd
->csd
[9] = (size
& 0xff);
431 sd
->csd
[15] = (sd_crc7(sd
->csd
, 15) << 1) | 1;
434 static void sd_set_rca(SDState
*sd
)
439 FIELD(CSR
, AKE_SEQ_ERROR
, 3, 1)
440 FIELD(CSR
, APP_CMD
, 5, 1)
441 FIELD(CSR
, FX_EVENT
, 6, 1)
442 FIELD(CSR
, READY_FOR_DATA
, 8, 1)
443 FIELD(CSR
, CURRENT_STATE
, 9, 4)
444 FIELD(CSR
, ERASE_RESET
, 13, 1)
445 FIELD(CSR
, CARD_ECC_DISABLED
, 14, 1)
446 FIELD(CSR
, WP_ERASE_SKIP
, 15, 1)
447 FIELD(CSR
, CSD_OVERWRITE
, 16, 1)
448 FIELD(CSR
, DEFERRED_RESPONSE
, 17, 1)
449 FIELD(CSR
, ERROR
, 19, 1)
450 FIELD(CSR
, CC_ERROR
, 20, 1)
451 FIELD(CSR
, CARD_ECC_FAILED
, 21, 1)
452 FIELD(CSR
, ILLEGAL_COMMAND
, 22, 1)
453 FIELD(CSR
, COM_CRC_ERROR
, 23, 1)
454 FIELD(CSR
, LOCK_UNLOCK_FAILED
, 24, 1)
455 FIELD(CSR
, CARD_IS_LOCKED
, 25, 1)
456 FIELD(CSR
, WP_VIOLATION
, 26, 1)
457 FIELD(CSR
, ERASE_PARAM
, 27, 1)
458 FIELD(CSR
, ERASE_SEQ_ERROR
, 28, 1)
459 FIELD(CSR
, BLOCK_LEN_ERROR
, 29, 1)
460 FIELD(CSR
, ADDRESS_ERROR
, 30, 1)
461 FIELD(CSR
, OUT_OF_RANGE
, 31, 1)
463 /* Card status bits, split by clear condition:
464 * A : According to the card current state
465 * B : Always related to the previous command
466 * C : Cleared by read
468 #define CARD_STATUS_A (R_CSR_READY_FOR_DATA_MASK \
469 | R_CSR_CARD_ECC_DISABLED_MASK \
470 | R_CSR_CARD_IS_LOCKED_MASK)
471 #define CARD_STATUS_B (R_CSR_CURRENT_STATE_MASK \
472 | R_CSR_ILLEGAL_COMMAND_MASK \
473 | R_CSR_COM_CRC_ERROR_MASK)
474 #define CARD_STATUS_C (R_CSR_AKE_SEQ_ERROR_MASK \
475 | R_CSR_APP_CMD_MASK \
476 | R_CSR_ERASE_RESET_MASK \
477 | R_CSR_WP_ERASE_SKIP_MASK \
478 | R_CSR_CSD_OVERWRITE_MASK \
480 | R_CSR_CC_ERROR_MASK \
481 | R_CSR_CARD_ECC_FAILED_MASK \
482 | R_CSR_LOCK_UNLOCK_FAILED_MASK \
483 | R_CSR_WP_VIOLATION_MASK \
484 | R_CSR_ERASE_PARAM_MASK \
485 | R_CSR_ERASE_SEQ_ERROR_MASK \
486 | R_CSR_BLOCK_LEN_ERROR_MASK \
487 | R_CSR_ADDRESS_ERROR_MASK \
488 | R_CSR_OUT_OF_RANGE_MASK)
490 static void sd_set_cardstatus(SDState
*sd
)
492 sd
->card_status
= 0x00000100;
495 static void sd_set_sdstatus(SDState
*sd
)
497 memset(sd
->sd_status
, 0, 64);
500 static int sd_req_crc_validate(SDRequest
*req
)
503 buffer
[0] = 0x40 | req
->cmd
;
504 stl_be_p(&buffer
[1], req
->arg
);
506 return sd_crc7(buffer
, 5) != req
->crc
; /* TODO */
509 static void sd_response_r1_make(SDState
*sd
, uint8_t *response
)
511 stl_be_p(response
, sd
->card_status
);
513 /* Clear the "clear on read" status bits */
514 sd
->card_status
&= ~CARD_STATUS_C
;
517 static void sd_response_r3_make(SDState
*sd
, uint8_t *response
)
519 stl_be_p(response
, sd
->ocr
& ACMD41_R3_MASK
);
522 static void sd_response_r6_make(SDState
*sd
, uint8_t *response
)
526 status
= ((sd
->card_status
>> 8) & 0xc000) |
527 ((sd
->card_status
>> 6) & 0x2000) |
528 (sd
->card_status
& 0x1fff);
529 sd
->card_status
&= ~(CARD_STATUS_C
& 0xc81fff);
530 stw_be_p(response
+ 0, sd
->rca
);
531 stw_be_p(response
+ 2, status
);
534 static void sd_response_r7_make(SDState
*sd
, uint8_t *response
)
536 stl_be_p(response
, sd
->vhs
);
539 static inline uint64_t sd_addr_to_wpnum(uint64_t addr
)
541 return addr
>> (HWBLOCK_SHIFT
+ SECTOR_SHIFT
+ WPGROUP_SHIFT
);
544 static void sd_reset(DeviceState
*dev
)
546 SDState
*sd
= SD_CARD(dev
);
550 trace_sdcard_reset();
552 blk_get_geometry(sd
->blk
, §
);
558 sect
= sd_addr_to_wpnum(size
) + 1;
560 sd
->state
= sd_idle_state
;
565 sd_set_csd(sd
, size
);
566 sd_set_cardstatus(sd
);
569 g_free(sd
->wp_groups
);
570 sd
->wp_switch
= sd
->blk
? blk_is_read_only(sd
->blk
) : false;
571 sd
->wpgrps_size
= sect
;
572 sd
->wp_groups
= bitmap_new(sd
->wpgrps_size
);
573 memset(sd
->function_group
, 0, sizeof(sd
->function_group
));
579 sd
->expecting_acmd
= false;
582 sd
->multi_blk_cnt
= 0;
585 static bool sd_get_inserted(SDState
*sd
)
587 return sd
->blk
&& blk_is_inserted(sd
->blk
);
590 static bool sd_get_readonly(SDState
*sd
)
592 return sd
->wp_switch
;
595 static void sd_cardchange(void *opaque
, bool load
, Error
**errp
)
597 SDState
*sd
= opaque
;
598 DeviceState
*dev
= DEVICE(sd
);
600 bool inserted
= sd_get_inserted(sd
);
601 bool readonly
= sd_get_readonly(sd
);
604 trace_sdcard_inserted(readonly
);
607 trace_sdcard_ejected();
610 if (sd
->me_no_qdev_me_kill_mammoth_with_rocks
) {
611 qemu_set_irq(sd
->inserted_cb
, inserted
);
613 qemu_set_irq(sd
->readonly_cb
, readonly
);
616 sdbus
= SD_BUS(qdev_get_parent_bus(dev
));
617 sdbus_set_inserted(sdbus
, inserted
);
619 sdbus_set_readonly(sdbus
, readonly
);
624 static const BlockDevOps sd_block_ops
= {
625 .change_media_cb
= sd_cardchange
,
628 static bool sd_ocr_vmstate_needed(void *opaque
)
630 SDState
*sd
= opaque
;
632 /* Include the OCR state (and timer) if it is not yet powered up */
633 return !FIELD_EX32(sd
->ocr
, OCR
, CARD_POWER_UP
);
636 static const VMStateDescription sd_ocr_vmstate
= {
637 .name
= "sd-card/ocr-state",
639 .minimum_version_id
= 1,
640 .needed
= sd_ocr_vmstate_needed
,
641 .fields
= (VMStateField
[]) {
642 VMSTATE_UINT32(ocr
, SDState
),
643 VMSTATE_TIMER_PTR(ocr_power_timer
, SDState
),
644 VMSTATE_END_OF_LIST()
648 static int sd_vmstate_pre_load(void *opaque
)
650 SDState
*sd
= opaque
;
652 /* If the OCR state is not included (prior versions, or not
653 * needed), then the OCR must be set as powered up. If the OCR state
654 * is included, this will be replaced by the state restore.
661 static const VMStateDescription sd_vmstate
= {
664 .minimum_version_id
= 1,
665 .pre_load
= sd_vmstate_pre_load
,
666 .fields
= (VMStateField
[]) {
667 VMSTATE_UINT32(mode
, SDState
),
668 VMSTATE_INT32(state
, SDState
),
669 VMSTATE_UINT8_ARRAY(cid
, SDState
, 16),
670 VMSTATE_UINT8_ARRAY(csd
, SDState
, 16),
671 VMSTATE_UINT16(rca
, SDState
),
672 VMSTATE_UINT32(card_status
, SDState
),
673 VMSTATE_PARTIAL_BUFFER(sd_status
, SDState
, 1),
674 VMSTATE_UINT32(vhs
, SDState
),
675 VMSTATE_BITMAP(wp_groups
, SDState
, 0, wpgrps_size
),
676 VMSTATE_UINT32(blk_len
, SDState
),
677 VMSTATE_UINT32(multi_blk_cnt
, SDState
),
678 VMSTATE_UINT32(erase_start
, SDState
),
679 VMSTATE_UINT32(erase_end
, SDState
),
680 VMSTATE_UINT8_ARRAY(pwd
, SDState
, 16),
681 VMSTATE_UINT32(pwd_len
, SDState
),
682 VMSTATE_UINT8_ARRAY(function_group
, SDState
, 6),
683 VMSTATE_UINT8(current_cmd
, SDState
),
684 VMSTATE_BOOL(expecting_acmd
, SDState
),
685 VMSTATE_UINT32(blk_written
, SDState
),
686 VMSTATE_UINT64(data_start
, SDState
),
687 VMSTATE_UINT32(data_offset
, SDState
),
688 VMSTATE_UINT8_ARRAY(data
, SDState
, 512),
689 VMSTATE_UNUSED_V(1, 512),
690 VMSTATE_BOOL(enable
, SDState
),
691 VMSTATE_END_OF_LIST()
693 .subsections
= (const VMStateDescription
*[]) {
699 /* Legacy initialization function for use by non-qdevified callers */
700 SDState
*sd_init(BlockBackend
*blk
, bool is_spi
)
707 obj
= object_new(TYPE_SD_CARD
);
709 if (!qdev_prop_set_drive_err(dev
, "drive", blk
, &err
)) {
710 error_reportf_err(err
, "sd_init failed: ");
713 qdev_prop_set_bit(dev
, "spi", is_spi
);
716 * Realizing the device properly would put it into the QOM
717 * composition tree even though it is not plugged into an
718 * appropriate bus. That's a no-no. Hide the device from
719 * QOM/qdev, and call its qdev realize callback directly.
722 object_unparent(obj
);
723 sd_realize(dev
, &err
);
725 error_reportf_err(err
, "sd_init failed: ");
730 sd
->me_no_qdev_me_kill_mammoth_with_rocks
= true;
734 void sd_set_cb(SDState
*sd
, qemu_irq readonly
, qemu_irq insert
)
736 sd
->readonly_cb
= readonly
;
737 sd
->inserted_cb
= insert
;
738 qemu_set_irq(readonly
, sd
->blk
? blk_is_read_only(sd
->blk
) : 0);
739 qemu_set_irq(insert
, sd
->blk
? blk_is_inserted(sd
->blk
) : 0);
742 static void sd_erase(SDState
*sd
)
745 uint64_t erase_start
= sd
->erase_start
;
746 uint64_t erase_end
= sd
->erase_end
;
748 trace_sdcard_erase();
749 if (!sd
->erase_start
|| !sd
->erase_end
) {
750 sd
->card_status
|= ERASE_SEQ_ERROR
;
754 if (FIELD_EX32(sd
->ocr
, OCR
, CARD_CAPACITY
)) {
755 /* High capacity memory card: erase units are 512 byte blocks */
760 erase_start
= sd_addr_to_wpnum(erase_start
);
761 erase_end
= sd_addr_to_wpnum(erase_end
);
766 for (i
= erase_start
; i
<= erase_end
; i
++) {
767 if (test_bit(i
, sd
->wp_groups
)) {
768 sd
->card_status
|= WP_ERASE_SKIP
;
773 static uint32_t sd_wpbits(SDState
*sd
, uint64_t addr
)
778 wpnum
= sd_addr_to_wpnum(addr
);
780 for (i
= 0; i
< 32; i
++, wpnum
++, addr
+= WPGROUP_SIZE
) {
781 if (addr
< sd
->size
&& test_bit(wpnum
, sd
->wp_groups
)) {
789 static void sd_function_switch(SDState
*sd
, uint32_t arg
)
791 int i
, mode
, new_func
;
792 mode
= !!(arg
& 0x80000000);
794 sd
->data
[0] = 0x00; /* Maximum current consumption */
796 sd
->data
[2] = 0x80; /* Supported group 6 functions */
798 sd
->data
[4] = 0x80; /* Supported group 5 functions */
800 sd
->data
[6] = 0x80; /* Supported group 4 functions */
802 sd
->data
[8] = 0x80; /* Supported group 3 functions */
804 sd
->data
[10] = 0x80; /* Supported group 2 functions */
806 sd
->data
[12] = 0x80; /* Supported group 1 functions */
808 for (i
= 0; i
< 6; i
++) {
809 new_func
= (arg
>> (i
* 4)) & 0x0f;
810 if (mode
&& new_func
!= 0x0f)
811 sd
->function_group
[i
] = new_func
;
812 sd
->data
[14 + (i
>> 1)] = new_func
<< ((i
* 4) & 4);
814 memset(&sd
->data
[17], 0, 47);
815 stw_be_p(sd
->data
+ 64, sd_crc16(sd
->data
, 64));
818 static inline bool sd_wp_addr(SDState
*sd
, uint64_t addr
)
820 return test_bit(sd_addr_to_wpnum(addr
), sd
->wp_groups
);
823 static void sd_lock_command(SDState
*sd
)
825 int erase
, lock
, clr_pwd
, set_pwd
, pwd_len
;
826 erase
= !!(sd
->data
[0] & 0x08);
827 lock
= sd
->data
[0] & 0x04;
828 clr_pwd
= sd
->data
[0] & 0x02;
829 set_pwd
= sd
->data
[0] & 0x01;
832 pwd_len
= sd
->data
[1];
839 trace_sdcard_unlock();
842 if (!(sd
->card_status
& CARD_IS_LOCKED
) || sd
->blk_len
> 1 ||
843 set_pwd
|| clr_pwd
|| lock
|| sd
->wp_switch
||
844 (sd
->csd
[14] & 0x20)) {
845 sd
->card_status
|= LOCK_UNLOCK_FAILED
;
848 bitmap_zero(sd
->wp_groups
, sd
->wpgrps_size
);
849 sd
->csd
[14] &= ~0x10;
850 sd
->card_status
&= ~CARD_IS_LOCKED
;
852 /* Erasing the entire card here! */
853 fprintf(stderr
, "SD: Card force-erased by CMD42\n");
857 if (sd
->blk_len
< 2 + pwd_len
||
858 pwd_len
<= sd
->pwd_len
||
859 pwd_len
> sd
->pwd_len
+ 16) {
860 sd
->card_status
|= LOCK_UNLOCK_FAILED
;
864 if (sd
->pwd_len
&& memcmp(sd
->pwd
, sd
->data
+ 2, sd
->pwd_len
)) {
865 sd
->card_status
|= LOCK_UNLOCK_FAILED
;
869 pwd_len
-= sd
->pwd_len
;
870 if ((pwd_len
&& !set_pwd
) ||
871 (clr_pwd
&& (set_pwd
|| lock
)) ||
872 (lock
&& !sd
->pwd_len
&& !set_pwd
) ||
873 (!set_pwd
&& !clr_pwd
&&
874 (((sd
->card_status
& CARD_IS_LOCKED
) && lock
) ||
875 (!(sd
->card_status
& CARD_IS_LOCKED
) && !lock
)))) {
876 sd
->card_status
|= LOCK_UNLOCK_FAILED
;
881 memcpy(sd
->pwd
, sd
->data
+ 2 + sd
->pwd_len
, pwd_len
);
882 sd
->pwd_len
= pwd_len
;
890 sd
->card_status
|= CARD_IS_LOCKED
;
892 sd
->card_status
&= ~CARD_IS_LOCKED
;
895 static sd_rsp_type_t
sd_normal_command(SDState
*sd
, SDRequest req
)
897 uint32_t rca
= 0x0000;
898 uint64_t addr
= (sd
->ocr
& (1 << 30)) ? (uint64_t) req
.arg
<< 9 : req
.arg
;
900 /* CMD55 precedes an ACMD, so we are not interested in tracing it.
901 * However there is no ACMD55, so we want to trace this particular case.
903 if (req
.cmd
!= 55 || sd
->expecting_acmd
) {
904 trace_sdcard_normal_command(sd
->proto_name
,
905 sd_cmd_name(req
.cmd
), req
.cmd
,
906 req
.arg
, sd_state_name(sd
->state
));
909 /* Not interpreting this as an app command */
910 sd
->card_status
&= ~APP_CMD
;
912 if (sd_cmd_type
[req
.cmd
] == sd_ac
913 || sd_cmd_type
[req
.cmd
] == sd_adtc
) {
917 /* CMD23 (set block count) must be immediately followed by CMD18 or CMD25
918 * if not, its effects are cancelled */
919 if (sd
->multi_blk_cnt
!= 0 && !(req
.cmd
== 18 || req
.cmd
== 25)) {
920 sd
->multi_blk_cnt
= 0;
924 /* Basic commands (Class 0 and Class 1) */
925 case 0: /* CMD0: GO_IDLE_STATE */
927 case sd_inactive_state
:
928 return sd
->spi
? sd_r1
: sd_r0
;
931 sd
->state
= sd_idle_state
;
932 sd_reset(DEVICE(sd
));
933 return sd
->spi
? sd_r1
: sd_r0
;
937 case 1: /* CMD1: SEND_OP_CMD */
941 sd
->state
= sd_transfer_state
;
944 case 2: /* CMD2: ALL_SEND_CID */
949 sd
->state
= sd_identification_state
;
957 case 3: /* CMD3: SEND_RELATIVE_ADDR */
961 case sd_identification_state
:
962 case sd_standby_state
:
963 sd
->state
= sd_standby_state
;
972 case 4: /* CMD4: SEND_DSR */
976 case sd_standby_state
:
984 case 5: /* CMD5: reserved for SDIO cards */
987 case 6: /* CMD6: SWITCH_FUNCTION */
989 case sd_data_transfer_mode
:
990 sd_function_switch(sd
, req
.arg
);
991 sd
->state
= sd_sendingdata_state
;
1001 case 7: /* CMD7: SELECT/DESELECT_CARD */
1004 switch (sd
->state
) {
1005 case sd_standby_state
:
1009 sd
->state
= sd_transfer_state
;
1012 case sd_transfer_state
:
1013 case sd_sendingdata_state
:
1017 sd
->state
= sd_standby_state
;
1020 case sd_disconnect_state
:
1024 sd
->state
= sd_programming_state
;
1027 case sd_programming_state
:
1031 sd
->state
= sd_disconnect_state
;
1039 case 8: /* CMD8: SEND_IF_COND */
1040 if (sd
->spec_version
< SD_PHY_SPECv2_00_VERS
) {
1043 if (sd
->state
!= sd_idle_state
) {
1048 /* No response if not exactly one VHS bit is set. */
1049 if (!(req
.arg
>> 8) || (req
.arg
>> (ctz32(req
.arg
& ~0xff) + 1))) {
1050 return sd
->spi
? sd_r7
: sd_r0
;
1057 case 9: /* CMD9: SEND_CSD */
1058 switch (sd
->state
) {
1059 case sd_standby_state
:
1065 case sd_transfer_state
:
1068 sd
->state
= sd_sendingdata_state
;
1069 memcpy(sd
->data
, sd
->csd
, 16);
1070 sd
->data_start
= addr
;
1071 sd
->data_offset
= 0;
1079 case 10: /* CMD10: SEND_CID */
1080 switch (sd
->state
) {
1081 case sd_standby_state
:
1087 case sd_transfer_state
:
1090 sd
->state
= sd_sendingdata_state
;
1091 memcpy(sd
->data
, sd
->cid
, 16);
1092 sd
->data_start
= addr
;
1093 sd
->data_offset
= 0;
1101 case 12: /* CMD12: STOP_TRANSMISSION */
1102 switch (sd
->state
) {
1103 case sd_sendingdata_state
:
1104 sd
->state
= sd_transfer_state
;
1107 case sd_receivingdata_state
:
1108 sd
->state
= sd_programming_state
;
1109 /* Bzzzzzzztt .... Operation complete. */
1110 sd
->state
= sd_transfer_state
;
1118 case 13: /* CMD13: SEND_STATUS */
1120 case sd_data_transfer_mode
:
1131 case 15: /* CMD15: GO_INACTIVE_STATE */
1135 case sd_data_transfer_mode
:
1139 sd
->state
= sd_inactive_state
;
1147 /* Block read commands (Classs 2) */
1148 case 16: /* CMD16: SET_BLOCKLEN */
1149 switch (sd
->state
) {
1150 case sd_transfer_state
:
1151 if (req
.arg
> (1 << HWBLOCK_SHIFT
)) {
1152 sd
->card_status
|= BLOCK_LEN_ERROR
;
1154 trace_sdcard_set_blocklen(req
.arg
);
1155 sd
->blk_len
= req
.arg
;
1165 case 17: /* CMD17: READ_SINGLE_BLOCK */
1166 switch (sd
->state
) {
1167 case sd_transfer_state
:
1168 sd
->state
= sd_sendingdata_state
;
1169 sd
->data_start
= addr
;
1170 sd
->data_offset
= 0;
1172 if (sd
->data_start
+ sd
->blk_len
> sd
->size
)
1173 sd
->card_status
|= ADDRESS_ERROR
;
1181 case 18: /* CMD18: READ_MULTIPLE_BLOCK */
1182 switch (sd
->state
) {
1183 case sd_transfer_state
:
1184 sd
->state
= sd_sendingdata_state
;
1185 sd
->data_start
= addr
;
1186 sd
->data_offset
= 0;
1188 if (sd
->data_start
+ sd
->blk_len
> sd
->size
)
1189 sd
->card_status
|= ADDRESS_ERROR
;
1197 case 19: /* CMD19: SEND_TUNING_BLOCK (SD) */
1198 if (sd
->spec_version
< SD_PHY_SPECv3_01_VERS
) {
1201 if (sd
->state
== sd_transfer_state
) {
1202 sd
->state
= sd_sendingdata_state
;
1203 sd
->data_offset
= 0;
1208 case 23: /* CMD23: SET_BLOCK_COUNT */
1209 if (sd
->spec_version
< SD_PHY_SPECv3_01_VERS
) {
1212 switch (sd
->state
) {
1213 case sd_transfer_state
:
1214 sd
->multi_blk_cnt
= req
.arg
;
1222 /* Block write commands (Class 4) */
1223 case 24: /* CMD24: WRITE_SINGLE_BLOCK */
1224 switch (sd
->state
) {
1225 case sd_transfer_state
:
1226 /* Writing in SPI mode not implemented. */
1229 sd
->state
= sd_receivingdata_state
;
1230 sd
->data_start
= addr
;
1231 sd
->data_offset
= 0;
1232 sd
->blk_written
= 0;
1234 if (sd
->data_start
+ sd
->blk_len
> sd
->size
)
1235 sd
->card_status
|= ADDRESS_ERROR
;
1236 if (sd_wp_addr(sd
, sd
->data_start
))
1237 sd
->card_status
|= WP_VIOLATION
;
1238 if (sd
->csd
[14] & 0x30)
1239 sd
->card_status
|= WP_VIOLATION
;
1247 case 25: /* CMD25: WRITE_MULTIPLE_BLOCK */
1248 switch (sd
->state
) {
1249 case sd_transfer_state
:
1250 /* Writing in SPI mode not implemented. */
1253 sd
->state
= sd_receivingdata_state
;
1254 sd
->data_start
= addr
;
1255 sd
->data_offset
= 0;
1256 sd
->blk_written
= 0;
1258 if (sd
->data_start
+ sd
->blk_len
> sd
->size
)
1259 sd
->card_status
|= ADDRESS_ERROR
;
1260 if (sd_wp_addr(sd
, sd
->data_start
))
1261 sd
->card_status
|= WP_VIOLATION
;
1262 if (sd
->csd
[14] & 0x30)
1263 sd
->card_status
|= WP_VIOLATION
;
1271 case 26: /* CMD26: PROGRAM_CID */
1274 switch (sd
->state
) {
1275 case sd_transfer_state
:
1276 sd
->state
= sd_receivingdata_state
;
1278 sd
->data_offset
= 0;
1286 case 27: /* CMD27: PROGRAM_CSD */
1287 switch (sd
->state
) {
1288 case sd_transfer_state
:
1289 sd
->state
= sd_receivingdata_state
;
1291 sd
->data_offset
= 0;
1299 /* Write protection (Class 6) */
1300 case 28: /* CMD28: SET_WRITE_PROT */
1301 switch (sd
->state
) {
1302 case sd_transfer_state
:
1303 if (addr
>= sd
->size
) {
1304 sd
->card_status
|= ADDRESS_ERROR
;
1308 sd
->state
= sd_programming_state
;
1309 set_bit(sd_addr_to_wpnum(addr
), sd
->wp_groups
);
1310 /* Bzzzzzzztt .... Operation complete. */
1311 sd
->state
= sd_transfer_state
;
1319 case 29: /* CMD29: CLR_WRITE_PROT */
1320 switch (sd
->state
) {
1321 case sd_transfer_state
:
1322 if (addr
>= sd
->size
) {
1323 sd
->card_status
|= ADDRESS_ERROR
;
1327 sd
->state
= sd_programming_state
;
1328 clear_bit(sd_addr_to_wpnum(addr
), sd
->wp_groups
);
1329 /* Bzzzzzzztt .... Operation complete. */
1330 sd
->state
= sd_transfer_state
;
1338 case 30: /* CMD30: SEND_WRITE_PROT */
1339 switch (sd
->state
) {
1340 case sd_transfer_state
:
1341 sd
->state
= sd_sendingdata_state
;
1342 *(uint32_t *) sd
->data
= sd_wpbits(sd
, req
.arg
);
1343 sd
->data_start
= addr
;
1344 sd
->data_offset
= 0;
1352 /* Erase commands (Class 5) */
1353 case 32: /* CMD32: ERASE_WR_BLK_START */
1354 switch (sd
->state
) {
1355 case sd_transfer_state
:
1356 sd
->erase_start
= req
.arg
;
1364 case 33: /* CMD33: ERASE_WR_BLK_END */
1365 switch (sd
->state
) {
1366 case sd_transfer_state
:
1367 sd
->erase_end
= req
.arg
;
1375 case 38: /* CMD38: ERASE */
1376 switch (sd
->state
) {
1377 case sd_transfer_state
:
1378 if (sd
->csd
[14] & 0x30) {
1379 sd
->card_status
|= WP_VIOLATION
;
1383 sd
->state
= sd_programming_state
;
1385 /* Bzzzzzzztt .... Operation complete. */
1386 sd
->state
= sd_transfer_state
;
1394 /* Lock card commands (Class 7) */
1395 case 42: /* CMD42: LOCK_UNLOCK */
1396 switch (sd
->state
) {
1397 case sd_transfer_state
:
1398 sd
->state
= sd_receivingdata_state
;
1400 sd
->data_offset
= 0;
1409 /* CMD52, CMD53, CMD54: reserved for SDIO cards
1410 * (see the SDIO Simplified Specification V2.0)
1411 * Handle as illegal command but do not complain
1412 * on stderr, as some OSes may use these in their
1413 * probing for presence of an SDIO card.
1417 /* Application specific commands (Class 8) */
1418 case 55: /* CMD55: APP_CMD */
1419 switch (sd
->state
) {
1420 case sd_ready_state
:
1421 case sd_identification_state
:
1422 case sd_inactive_state
:
1426 qemu_log_mask(LOG_GUEST_ERROR
,
1427 "SD: illegal RCA 0x%04x for APP_CMD\n", req
.cmd
);
1433 if (sd
->rca
!= rca
) {
1437 sd
->expecting_acmd
= true;
1438 sd
->card_status
|= APP_CMD
;
1441 case 56: /* CMD56: GEN_CMD */
1442 switch (sd
->state
) {
1443 case sd_transfer_state
:
1444 sd
->data_offset
= 0;
1446 sd
->state
= sd_sendingdata_state
;
1448 sd
->state
= sd_receivingdata_state
;
1456 case 58: /* CMD58: READ_OCR (SPI) */
1462 case 59: /* CMD59: CRC_ON_OFF (SPI) */
1466 goto unimplemented_spi_cmd
;
1470 qemu_log_mask(LOG_GUEST_ERROR
, "SD: Unknown CMD%i\n", req
.cmd
);
1473 unimplemented_spi_cmd
:
1474 /* Commands that are recognised but not yet implemented in SPI mode. */
1475 qemu_log_mask(LOG_UNIMP
, "SD: CMD%i not implemented in SPI mode\n",
1480 qemu_log_mask(LOG_GUEST_ERROR
, "SD: CMD%i in a wrong state\n", req
.cmd
);
1484 static sd_rsp_type_t
sd_app_command(SDState
*sd
,
1487 trace_sdcard_app_command(sd
->proto_name
, sd_acmd_name(req
.cmd
),
1488 req
.cmd
, req
.arg
, sd_state_name(sd
->state
));
1489 sd
->card_status
|= APP_CMD
;
1491 case 6: /* ACMD6: SET_BUS_WIDTH */
1493 goto unimplemented_spi_cmd
;
1495 switch (sd
->state
) {
1496 case sd_transfer_state
:
1497 sd
->sd_status
[0] &= 0x3f;
1498 sd
->sd_status
[0] |= (req
.arg
& 0x03) << 6;
1506 case 13: /* ACMD13: SD_STATUS */
1507 switch (sd
->state
) {
1508 case sd_transfer_state
:
1509 sd
->state
= sd_sendingdata_state
;
1511 sd
->data_offset
= 0;
1519 case 22: /* ACMD22: SEND_NUM_WR_BLOCKS */
1520 switch (sd
->state
) {
1521 case sd_transfer_state
:
1522 *(uint32_t *) sd
->data
= sd
->blk_written
;
1524 sd
->state
= sd_sendingdata_state
;
1526 sd
->data_offset
= 0;
1534 case 23: /* ACMD23: SET_WR_BLK_ERASE_COUNT */
1535 switch (sd
->state
) {
1536 case sd_transfer_state
:
1544 case 41: /* ACMD41: SD_APP_OP_COND */
1547 sd
->state
= sd_transfer_state
;
1550 if (sd
->state
!= sd_idle_state
) {
1553 /* If it's the first ACMD41 since reset, we need to decide
1554 * whether to power up. If this is not an enquiry ACMD41,
1555 * we immediately report power on and proceed below to the
1556 * ready state, but if it is, we set a timer to model a
1557 * delay for power up. This works around a bug in EDK2
1558 * UEFI, which sends an initial enquiry ACMD41, but
1559 * assumes that the card is in ready state as soon as it
1560 * sees the power up bit set. */
1561 if (!FIELD_EX32(sd
->ocr
, OCR
, CARD_POWER_UP
)) {
1562 if ((req
.arg
& ACMD41_ENQUIRY_MASK
) != 0) {
1563 timer_del(sd
->ocr_power_timer
);
1566 trace_sdcard_inquiry_cmd41();
1567 if (!timer_pending(sd
->ocr_power_timer
)) {
1568 timer_mod_ns(sd
->ocr_power_timer
,
1569 (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
)
1570 + OCR_POWER_DELAY_NS
));
1575 if (FIELD_EX32(sd
->ocr
& req
.arg
, OCR
, VDD_VOLTAGE_WINDOW
)) {
1576 /* We accept any voltage. 10000 V is nothing.
1578 * Once we're powered up, we advance straight to ready state
1579 * unless it's an enquiry ACMD41 (bits 23:0 == 0).
1581 sd
->state
= sd_ready_state
;
1586 case 42: /* ACMD42: SET_CLR_CARD_DETECT */
1587 switch (sd
->state
) {
1588 case sd_transfer_state
:
1589 /* Bringing in the 50KOhm pull-up resistor... Done. */
1597 case 51: /* ACMD51: SEND_SCR */
1598 switch (sd
->state
) {
1599 case sd_transfer_state
:
1600 sd
->state
= sd_sendingdata_state
;
1602 sd
->data_offset
= 0;
1610 case 18: /* Reserved for SD security applications */
1615 /* Refer to the "SD Specifications Part3 Security Specification" for
1616 * information about the SD Security Features.
1618 qemu_log_mask(LOG_UNIMP
, "SD: CMD%i Security not implemented\n",
1623 /* Fall back to standard commands. */
1624 return sd_normal_command(sd
, req
);
1626 unimplemented_spi_cmd
:
1627 /* Commands that are recognised but not yet implemented in SPI mode. */
1628 qemu_log_mask(LOG_UNIMP
, "SD: CMD%i not implemented in SPI mode\n",
1633 qemu_log_mask(LOG_GUEST_ERROR
, "SD: ACMD%i in a wrong state\n", req
.cmd
);
1637 static int cmd_valid_while_locked(SDState
*sd
, SDRequest
*req
)
1639 /* Valid commands in locked state:
1641 * lock card class (7)
1643 * implicitly, the ACMD prefix CMD55
1645 * Anything else provokes an "illegal command" response.
1647 if (sd
->expecting_acmd
) {
1648 return req
->cmd
== 41 || req
->cmd
== 42;
1650 if (req
->cmd
== 16 || req
->cmd
== 55) {
1653 return sd_cmd_class
[req
->cmd
] == 0
1654 || sd_cmd_class
[req
->cmd
] == 7;
1657 int sd_do_command(SDState
*sd
, SDRequest
*req
,
1658 uint8_t *response
) {
1660 sd_rsp_type_t rtype
;
1663 if (!sd
->blk
|| !blk_is_inserted(sd
->blk
) || !sd
->enable
) {
1667 if (sd_req_crc_validate(req
)) {
1668 sd
->card_status
|= COM_CRC_ERROR
;
1673 if (req
->cmd
>= SDMMC_CMD_MAX
) {
1674 qemu_log_mask(LOG_GUEST_ERROR
, "SD: incorrect command 0x%02x\n",
1679 if (sd
->card_status
& CARD_IS_LOCKED
) {
1680 if (!cmd_valid_while_locked(sd
, req
)) {
1681 sd
->card_status
|= ILLEGAL_COMMAND
;
1682 sd
->expecting_acmd
= false;
1683 qemu_log_mask(LOG_GUEST_ERROR
, "SD: Card is locked\n");
1689 last_state
= sd
->state
;
1692 if (sd
->expecting_acmd
) {
1693 sd
->expecting_acmd
= false;
1694 rtype
= sd_app_command(sd
, *req
);
1696 rtype
= sd_normal_command(sd
, *req
);
1699 if (rtype
== sd_illegal
) {
1700 sd
->card_status
|= ILLEGAL_COMMAND
;
1702 /* Valid command, we can update the 'state before command' bits.
1703 * (Do this now so they appear in r1 responses.)
1705 sd
->current_cmd
= req
->cmd
;
1706 sd
->card_status
&= ~CURRENT_STATE
;
1707 sd
->card_status
|= (last_state
<< 9);
1714 sd_response_r1_make(sd
, response
);
1719 memcpy(response
, sd
->cid
, sizeof(sd
->cid
));
1724 memcpy(response
, sd
->csd
, sizeof(sd
->csd
));
1729 sd_response_r3_make(sd
, response
);
1734 sd_response_r6_make(sd
, response
);
1739 sd_response_r7_make(sd
, response
);
1748 g_assert_not_reached();
1750 trace_sdcard_response(sd_response_name(rtype
), rsplen
);
1752 if (rtype
!= sd_illegal
) {
1753 /* Clear the "clear on valid command" status bits now we've
1756 sd
->card_status
&= ~CARD_STATUS_B
;
1760 qemu_hexdump((const char *)response
, stderr
, "Response", rsplen
);
1766 static void sd_blk_read(SDState
*sd
, uint64_t addr
, uint32_t len
)
1768 trace_sdcard_read_block(addr
, len
);
1769 if (!sd
->blk
|| blk_pread(sd
->blk
, addr
, sd
->data
, len
) < 0) {
1770 fprintf(stderr
, "sd_blk_read: read error on host side\n");
1774 static void sd_blk_write(SDState
*sd
, uint64_t addr
, uint32_t len
)
1776 trace_sdcard_write_block(addr
, len
);
1777 if (!sd
->blk
|| blk_pwrite(sd
->blk
, addr
, sd
->data
, len
, 0) < 0) {
1778 fprintf(stderr
, "sd_blk_write: write error on host side\n");
1782 #define BLK_READ_BLOCK(a, len) sd_blk_read(sd, a, len)
1783 #define BLK_WRITE_BLOCK(a, len) sd_blk_write(sd, a, len)
1784 #define APP_READ_BLOCK(a, len) memset(sd->data, 0xec, len)
1785 #define APP_WRITE_BLOCK(a, len)
1787 void sd_write_data(SDState
*sd
, uint8_t value
)
1791 if (!sd
->blk
|| !blk_is_inserted(sd
->blk
) || !sd
->enable
)
1794 if (sd
->state
!= sd_receivingdata_state
) {
1795 qemu_log_mask(LOG_GUEST_ERROR
,
1796 "sd_write_data: not in Receiving-Data state\n");
1800 if (sd
->card_status
& (ADDRESS_ERROR
| WP_VIOLATION
))
1803 trace_sdcard_write_data(sd
->proto_name
,
1804 sd_acmd_name(sd
->current_cmd
),
1805 sd
->current_cmd
, value
);
1806 switch (sd
->current_cmd
) {
1807 case 24: /* CMD24: WRITE_SINGLE_BLOCK */
1808 sd
->data
[sd
->data_offset
++] = value
;
1809 if (sd
->data_offset
>= sd
->blk_len
) {
1810 /* TODO: Check CRC before committing */
1811 sd
->state
= sd_programming_state
;
1812 BLK_WRITE_BLOCK(sd
->data_start
, sd
->data_offset
);
1814 sd
->csd
[14] |= 0x40;
1815 /* Bzzzzzzztt .... Operation complete. */
1816 sd
->state
= sd_transfer_state
;
1820 case 25: /* CMD25: WRITE_MULTIPLE_BLOCK */
1821 if (sd
->data_offset
== 0) {
1822 /* Start of the block - let's check the address is valid */
1823 if (sd
->data_start
+ sd
->blk_len
> sd
->size
) {
1824 sd
->card_status
|= ADDRESS_ERROR
;
1827 if (sd_wp_addr(sd
, sd
->data_start
)) {
1828 sd
->card_status
|= WP_VIOLATION
;
1832 sd
->data
[sd
->data_offset
++] = value
;
1833 if (sd
->data_offset
>= sd
->blk_len
) {
1834 /* TODO: Check CRC before committing */
1835 sd
->state
= sd_programming_state
;
1836 BLK_WRITE_BLOCK(sd
->data_start
, sd
->data_offset
);
1838 sd
->data_start
+= sd
->blk_len
;
1839 sd
->data_offset
= 0;
1840 sd
->csd
[14] |= 0x40;
1842 /* Bzzzzzzztt .... Operation complete. */
1843 if (sd
->multi_blk_cnt
!= 0) {
1844 if (--sd
->multi_blk_cnt
== 0) {
1846 sd
->state
= sd_transfer_state
;
1851 sd
->state
= sd_receivingdata_state
;
1855 case 26: /* CMD26: PROGRAM_CID */
1856 sd
->data
[sd
->data_offset
++] = value
;
1857 if (sd
->data_offset
>= sizeof(sd
->cid
)) {
1858 /* TODO: Check CRC before committing */
1859 sd
->state
= sd_programming_state
;
1860 for (i
= 0; i
< sizeof(sd
->cid
); i
++)
1861 if ((sd
->cid
[i
] | 0x00) != sd
->data
[i
])
1862 sd
->card_status
|= CID_CSD_OVERWRITE
;
1864 if (!(sd
->card_status
& CID_CSD_OVERWRITE
))
1865 for (i
= 0; i
< sizeof(sd
->cid
); i
++) {
1867 sd
->cid
[i
] &= sd
->data
[i
];
1869 /* Bzzzzzzztt .... Operation complete. */
1870 sd
->state
= sd_transfer_state
;
1874 case 27: /* CMD27: PROGRAM_CSD */
1875 sd
->data
[sd
->data_offset
++] = value
;
1876 if (sd
->data_offset
>= sizeof(sd
->csd
)) {
1877 /* TODO: Check CRC before committing */
1878 sd
->state
= sd_programming_state
;
1879 for (i
= 0; i
< sizeof(sd
->csd
); i
++)
1880 if ((sd
->csd
[i
] | sd_csd_rw_mask
[i
]) !=
1881 (sd
->data
[i
] | sd_csd_rw_mask
[i
]))
1882 sd
->card_status
|= CID_CSD_OVERWRITE
;
1884 /* Copy flag (OTP) & Permanent write protect */
1885 if (sd
->csd
[14] & ~sd
->data
[14] & 0x60)
1886 sd
->card_status
|= CID_CSD_OVERWRITE
;
1888 if (!(sd
->card_status
& CID_CSD_OVERWRITE
))
1889 for (i
= 0; i
< sizeof(sd
->csd
); i
++) {
1890 sd
->csd
[i
] |= sd_csd_rw_mask
[i
];
1891 sd
->csd
[i
] &= sd
->data
[i
];
1893 /* Bzzzzzzztt .... Operation complete. */
1894 sd
->state
= sd_transfer_state
;
1898 case 42: /* CMD42: LOCK_UNLOCK */
1899 sd
->data
[sd
->data_offset
++] = value
;
1900 if (sd
->data_offset
>= sd
->blk_len
) {
1901 /* TODO: Check CRC before committing */
1902 sd
->state
= sd_programming_state
;
1903 sd_lock_command(sd
);
1904 /* Bzzzzzzztt .... Operation complete. */
1905 sd
->state
= sd_transfer_state
;
1909 case 56: /* CMD56: GEN_CMD */
1910 sd
->data
[sd
->data_offset
++] = value
;
1911 if (sd
->data_offset
>= sd
->blk_len
) {
1912 APP_WRITE_BLOCK(sd
->data_start
, sd
->data_offset
);
1913 sd
->state
= sd_transfer_state
;
1918 qemu_log_mask(LOG_GUEST_ERROR
, "sd_write_data: unknown command\n");
1923 #define SD_TUNING_BLOCK_SIZE 64
1925 static const uint8_t sd_tuning_block_pattern
[SD_TUNING_BLOCK_SIZE
] = {
1926 /* See: Physical Layer Simplified Specification Version 3.01, Table 4-2 */
1927 0xff, 0x0f, 0xff, 0x00, 0x0f, 0xfc, 0xc3, 0xcc,
1928 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
1929 0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb,
1930 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
1931 0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c,
1932 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
1933 0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff,
1934 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde,
1937 uint8_t sd_read_data(SDState
*sd
)
1939 /* TODO: Append CRCs */
1943 if (!sd
->blk
|| !blk_is_inserted(sd
->blk
) || !sd
->enable
)
1946 if (sd
->state
!= sd_sendingdata_state
) {
1947 qemu_log_mask(LOG_GUEST_ERROR
,
1948 "sd_read_data: not in Sending-Data state\n");
1952 if (sd
->card_status
& (ADDRESS_ERROR
| WP_VIOLATION
))
1955 io_len
= (sd
->ocr
& (1 << 30)) ? 512 : sd
->blk_len
;
1957 trace_sdcard_read_data(sd
->proto_name
,
1958 sd_acmd_name(sd
->current_cmd
),
1959 sd
->current_cmd
, io_len
);
1960 switch (sd
->current_cmd
) {
1961 case 6: /* CMD6: SWITCH_FUNCTION */
1962 ret
= sd
->data
[sd
->data_offset
++];
1964 if (sd
->data_offset
>= 64)
1965 sd
->state
= sd_transfer_state
;
1968 case 9: /* CMD9: SEND_CSD */
1969 case 10: /* CMD10: SEND_CID */
1970 ret
= sd
->data
[sd
->data_offset
++];
1972 if (sd
->data_offset
>= 16)
1973 sd
->state
= sd_transfer_state
;
1976 case 13: /* ACMD13: SD_STATUS */
1977 ret
= sd
->sd_status
[sd
->data_offset
++];
1979 if (sd
->data_offset
>= sizeof(sd
->sd_status
))
1980 sd
->state
= sd_transfer_state
;
1983 case 17: /* CMD17: READ_SINGLE_BLOCK */
1984 if (sd
->data_offset
== 0)
1985 BLK_READ_BLOCK(sd
->data_start
, io_len
);
1986 ret
= sd
->data
[sd
->data_offset
++];
1988 if (sd
->data_offset
>= io_len
)
1989 sd
->state
= sd_transfer_state
;
1992 case 18: /* CMD18: READ_MULTIPLE_BLOCK */
1993 if (sd
->data_offset
== 0) {
1994 if (sd
->data_start
+ io_len
> sd
->size
) {
1995 sd
->card_status
|= ADDRESS_ERROR
;
1998 BLK_READ_BLOCK(sd
->data_start
, io_len
);
2000 ret
= sd
->data
[sd
->data_offset
++];
2002 if (sd
->data_offset
>= io_len
) {
2003 sd
->data_start
+= io_len
;
2004 sd
->data_offset
= 0;
2006 if (sd
->multi_blk_cnt
!= 0) {
2007 if (--sd
->multi_blk_cnt
== 0) {
2009 sd
->state
= sd_transfer_state
;
2016 case 19: /* CMD19: SEND_TUNING_BLOCK (SD) */
2017 if (sd
->data_offset
>= SD_TUNING_BLOCK_SIZE
- 1) {
2018 sd
->state
= sd_transfer_state
;
2020 ret
= sd_tuning_block_pattern
[sd
->data_offset
++];
2023 case 22: /* ACMD22: SEND_NUM_WR_BLOCKS */
2024 ret
= sd
->data
[sd
->data_offset
++];
2026 if (sd
->data_offset
>= 4)
2027 sd
->state
= sd_transfer_state
;
2030 case 30: /* CMD30: SEND_WRITE_PROT */
2031 ret
= sd
->data
[sd
->data_offset
++];
2033 if (sd
->data_offset
>= 4)
2034 sd
->state
= sd_transfer_state
;
2037 case 51: /* ACMD51: SEND_SCR */
2038 ret
= sd
->scr
[sd
->data_offset
++];
2040 if (sd
->data_offset
>= sizeof(sd
->scr
))
2041 sd
->state
= sd_transfer_state
;
2044 case 56: /* CMD56: GEN_CMD */
2045 if (sd
->data_offset
== 0)
2046 APP_READ_BLOCK(sd
->data_start
, sd
->blk_len
);
2047 ret
= sd
->data
[sd
->data_offset
++];
2049 if (sd
->data_offset
>= sd
->blk_len
)
2050 sd
->state
= sd_transfer_state
;
2054 qemu_log_mask(LOG_GUEST_ERROR
, "sd_read_data: unknown command\n");
2061 bool sd_data_ready(SDState
*sd
)
2063 return sd
->state
== sd_sendingdata_state
;
2066 void sd_enable(SDState
*sd
, bool enable
)
2068 sd
->enable
= enable
;
2071 static void sd_instance_init(Object
*obj
)
2073 SDState
*sd
= SD_CARD(obj
);
2076 sd
->ocr_power_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, sd_ocr_powerup
, sd
);
2079 static void sd_instance_finalize(Object
*obj
)
2081 SDState
*sd
= SD_CARD(obj
);
2083 timer_del(sd
->ocr_power_timer
);
2084 timer_free(sd
->ocr_power_timer
);
2087 static void sd_realize(DeviceState
*dev
, Error
**errp
)
2089 SDState
*sd
= SD_CARD(dev
);
2092 sd
->proto_name
= sd
->spi
? "SPI" : "SD";
2094 switch (sd
->spec_version
) {
2095 case SD_PHY_SPECv1_10_VERS
2096 ... SD_PHY_SPECv3_01_VERS
:
2099 error_setg(errp
, "Invalid SD card Spec version: %u", sd
->spec_version
);
2103 if (sd
->blk
&& blk_is_read_only(sd
->blk
)) {
2104 error_setg(errp
, "Cannot use read-only drive as SD card");
2109 ret
= blk_set_perm(sd
->blk
, BLK_PERM_CONSISTENT_READ
| BLK_PERM_WRITE
,
2110 BLK_PERM_ALL
, errp
);
2114 blk_set_dev_ops(sd
->blk
, &sd_block_ops
, sd
);
2118 static Property sd_properties
[] = {
2119 DEFINE_PROP_UINT8("spec_version", SDState
,
2120 spec_version
, SD_PHY_SPECv2_00_VERS
),
2121 DEFINE_PROP_DRIVE("drive", SDState
, blk
),
2122 /* We do not model the chip select pin, so allow the board to select
2123 * whether card should be in SSI or MMC/SD mode. It is also up to the
2124 * board to ensure that ssi transfers only occur when the chip select
2126 DEFINE_PROP_BOOL("spi", SDState
, spi
, false),
2127 DEFINE_PROP_END_OF_LIST()
2130 static void sd_class_init(ObjectClass
*klass
, void *data
)
2132 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2133 SDCardClass
*sc
= SD_CARD_CLASS(klass
);
2135 dc
->realize
= sd_realize
;
2136 device_class_set_props(dc
, sd_properties
);
2137 dc
->vmsd
= &sd_vmstate
;
2138 dc
->reset
= sd_reset
;
2139 dc
->bus_type
= TYPE_SD_BUS
;
2140 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
2142 sc
->set_voltage
= sd_set_voltage
;
2143 sc
->get_dat_lines
= sd_get_dat_lines
;
2144 sc
->get_cmd_line
= sd_get_cmd_line
;
2145 sc
->do_command
= sd_do_command
;
2146 sc
->write_data
= sd_write_data
;
2147 sc
->read_data
= sd_read_data
;
2148 sc
->data_ready
= sd_data_ready
;
2149 sc
->enable
= sd_enable
;
2150 sc
->get_inserted
= sd_get_inserted
;
2151 sc
->get_readonly
= sd_get_readonly
;
2154 static const TypeInfo sd_info
= {
2155 .name
= TYPE_SD_CARD
,
2156 .parent
= TYPE_DEVICE
,
2157 .instance_size
= sizeof(SDState
),
2158 .class_size
= sizeof(SDCardClass
),
2159 .class_init
= sd_class_init
,
2160 .instance_init
= sd_instance_init
,
2161 .instance_finalize
= sd_instance_finalize
,
2164 static void sd_register_types(void)
2166 type_register_static(&sd_info
);
2169 type_init(sd_register_types
)