Revision 775616c3 hw/sd.c
| b/hw/sd.c | ||
|---|---|---|
| 87 | 87 |
int pwd_len; |
| 88 | 88 |
int function_group[6]; |
| 89 | 89 |
|
| 90 |
int spi; |
|
| 90 | 91 |
int current_cmd; |
| 91 | 92 |
int blk_written; |
| 92 | 93 |
uint32_t data_start; |
| ... | ... | |
| 395 | 396 |
} |
| 396 | 397 |
} |
| 397 | 398 |
|
| 398 |
SDState *sd_init(BlockDriverState *bs) |
|
| 399 |
/* We do not model the chip select pin, so allow the board to select |
|
| 400 |
whether card should be in SSI ot MMC/SD mode. It is also up to the |
|
| 401 |
board to ensure that ssi transfers only occur when the chip select |
|
| 402 |
is asserted. */ |
|
| 403 |
SDState *sd_init(BlockDriverState *bs, int is_spi) |
|
| 399 | 404 |
{
|
| 400 | 405 |
SDState *sd; |
| 401 | 406 |
|
| 402 | 407 |
sd = (SDState *) qemu_mallocz(sizeof(SDState)); |
| 408 |
sd->spi = is_spi; |
|
| 403 | 409 |
sd_reset(sd, bs); |
| 404 | 410 |
bdrv_set_change_cb(sd->bdrv, sd_cardchange, sd); |
| 405 | 411 |
return sd; |
| ... | ... | |
| 567 | 573 |
case 0: /* CMD0: GO_IDLE_STATE */ |
| 568 | 574 |
switch (sd->state) {
|
| 569 | 575 |
case sd_inactive_state: |
| 570 |
return sd_r0; |
|
| 576 |
return sd->spi ? sd_r1 : sd_r0;
|
|
| 571 | 577 |
|
| 572 | 578 |
default: |
| 573 | 579 |
sd->state = sd_idle_state; |
| 574 | 580 |
sd_reset(sd, sd->bdrv); |
| 575 |
return sd_r0; |
|
| 581 |
return sd->spi ? sd_r1 : sd_r0;
|
|
| 576 | 582 |
} |
| 577 | 583 |
break; |
| 578 | 584 |
|
| 585 |
case 1: /* CMD1: SEND_OP_CMD */ |
|
| 586 |
if (!sd->spi) |
|
| 587 |
goto bad_cmd; |
|
| 588 |
|
|
| 589 |
sd->state = sd_transfer_state; |
|
| 590 |
return sd_r1; |
|
| 591 |
|
|
| 579 | 592 |
case 2: /* CMD2: ALL_SEND_CID */ |
| 593 |
if (sd->spi) |
|
| 594 |
goto bad_cmd; |
|
| 580 | 595 |
switch (sd->state) {
|
| 581 | 596 |
case sd_ready_state: |
| 582 | 597 |
sd->state = sd_identification_state; |
| ... | ... | |
| 588 | 603 |
break; |
| 589 | 604 |
|
| 590 | 605 |
case 3: /* CMD3: SEND_RELATIVE_ADDR */ |
| 606 |
if (sd->spi) |
|
| 607 |
goto bad_cmd; |
|
| 591 | 608 |
switch (sd->state) {
|
| 592 | 609 |
case sd_identification_state: |
| 593 | 610 |
case sd_standby_state: |
| ... | ... | |
| 601 | 618 |
break; |
| 602 | 619 |
|
| 603 | 620 |
case 4: /* CMD4: SEND_DSR */ |
| 621 |
if (sd->spi) |
|
| 622 |
goto bad_cmd; |
|
| 604 | 623 |
switch (sd->state) {
|
| 605 | 624 |
case sd_standby_state: |
| 606 | 625 |
break; |
| ... | ... | |
| 611 | 630 |
break; |
| 612 | 631 |
|
| 613 | 632 |
case 6: /* CMD6: SWITCH_FUNCTION */ |
| 633 |
if (sd->spi) |
|
| 634 |
goto bad_cmd; |
|
| 614 | 635 |
switch (sd->mode) {
|
| 615 | 636 |
case sd_data_transfer_mode: |
| 616 | 637 |
sd_function_switch(sd, req.arg); |
| ... | ... | |
| 625 | 646 |
break; |
| 626 | 647 |
|
| 627 | 648 |
case 7: /* CMD7: SELECT/DESELECT_CARD */ |
| 649 |
if (sd->spi) |
|
| 650 |
goto bad_cmd; |
|
| 628 | 651 |
switch (sd->state) {
|
| 629 | 652 |
case sd_standby_state: |
| 630 | 653 |
if (sd->rca != rca) |
| ... | ... | |
| 668 | 691 |
|
| 669 | 692 |
return sd_r2_s; |
| 670 | 693 |
|
| 694 |
case sd_transfer_state: |
|
| 695 |
if (!sd->spi) |
|
| 696 |
break; |
|
| 697 |
sd->state = sd_sendingdata_state; |
|
| 698 |
memcpy(sd->data, sd->csd, 16); |
|
| 699 |
sd->data_start = req.arg; |
|
| 700 |
sd->data_offset = 0; |
|
| 701 |
return sd_r1; |
|
| 702 |
|
|
| 671 | 703 |
default: |
| 672 | 704 |
break; |
| 673 | 705 |
} |
| ... | ... | |
| 681 | 713 |
|
| 682 | 714 |
return sd_r2_i; |
| 683 | 715 |
|
| 716 |
case sd_transfer_state: |
|
| 717 |
if (!sd->spi) |
|
| 718 |
break; |
|
| 719 |
sd->state = sd_sendingdata_state; |
|
| 720 |
memcpy(sd->data, sd->cid, 16); |
|
| 721 |
sd->data_start = req.arg; |
|
| 722 |
sd->data_offset = 0; |
|
| 723 |
return sd_r1; |
|
| 724 |
|
|
| 684 | 725 |
default: |
| 685 | 726 |
break; |
| 686 | 727 |
} |
| 687 | 728 |
break; |
| 688 | 729 |
|
| 689 | 730 |
case 11: /* CMD11: READ_DAT_UNTIL_STOP */ |
| 731 |
if (sd->spi) |
|
| 732 |
goto bad_cmd; |
|
| 690 | 733 |
switch (sd->state) {
|
| 691 | 734 |
case sd_transfer_state: |
| 692 | 735 |
sd->state = sd_sendingdata_state; |
| ... | ... | |
| 733 | 776 |
break; |
| 734 | 777 |
|
| 735 | 778 |
case 15: /* CMD15: GO_INACTIVE_STATE */ |
| 779 |
if (sd->spi) |
|
| 780 |
goto bad_cmd; |
|
| 736 | 781 |
switch (sd->mode) {
|
| 737 | 782 |
case sd_data_transfer_mode: |
| 738 | 783 |
if (sd->rca != rca) |
| ... | ... | |
| 796 | 841 |
|
| 797 | 842 |
/* Block write commands (Class 4) */ |
| 798 | 843 |
case 24: /* CMD24: WRITE_SINGLE_BLOCK */ |
| 844 |
if (sd->spi) |
|
| 845 |
goto unimplemented_cmd; |
|
| 799 | 846 |
switch (sd->state) {
|
| 800 | 847 |
case sd_transfer_state: |
| 848 |
/* Writing in SPI mode not implemented. */ |
|
| 849 |
if (sd->spi) |
|
| 850 |
break; |
|
| 801 | 851 |
sd->state = sd_receivingdata_state; |
| 802 | 852 |
sd->data_start = req.arg; |
| 803 | 853 |
sd->data_offset = 0; |
| ... | ... | |
| 817 | 867 |
break; |
| 818 | 868 |
|
| 819 | 869 |
case 25: /* CMD25: WRITE_MULTIPLE_BLOCK */ |
| 870 |
if (sd->spi) |
|
| 871 |
goto unimplemented_cmd; |
|
| 820 | 872 |
switch (sd->state) {
|
| 821 | 873 |
case sd_transfer_state: |
| 874 |
/* Writing in SPI mode not implemented. */ |
|
| 875 |
if (sd->spi) |
|
| 876 |
break; |
|
| 822 | 877 |
sd->state = sd_receivingdata_state; |
| 823 | 878 |
sd->data_start = req.arg; |
| 824 | 879 |
sd->data_offset = 0; |
| ... | ... | |
| 838 | 893 |
break; |
| 839 | 894 |
|
| 840 | 895 |
case 26: /* CMD26: PROGRAM_CID */ |
| 896 |
if (sd->spi) |
|
| 897 |
goto bad_cmd; |
|
| 841 | 898 |
switch (sd->state) {
|
| 842 | 899 |
case sd_transfer_state: |
| 843 | 900 |
sd->state = sd_receivingdata_state; |
| ... | ... | |
| 851 | 908 |
break; |
| 852 | 909 |
|
| 853 | 910 |
case 27: /* CMD27: PROGRAM_CSD */ |
| 911 |
if (sd->spi) |
|
| 912 |
goto unimplemented_cmd; |
|
| 854 | 913 |
switch (sd->state) {
|
| 855 | 914 |
case sd_transfer_state: |
| 856 | 915 |
sd->state = sd_receivingdata_state; |
| ... | ... | |
| 962 | 1021 |
|
| 963 | 1022 |
/* Lock card commands (Class 7) */ |
| 964 | 1023 |
case 42: /* CMD42: LOCK_UNLOCK */ |
| 1024 |
if (sd->spi) |
|
| 1025 |
goto unimplemented_cmd; |
|
| 965 | 1026 |
switch (sd->state) {
|
| 966 | 1027 |
case sd_transfer_state: |
| 967 | 1028 |
sd->state = sd_receivingdata_state; |
| ... | ... | |
| 1000 | 1061 |
break; |
| 1001 | 1062 |
|
| 1002 | 1063 |
default: |
| 1064 |
bad_cmd: |
|
| 1003 | 1065 |
sd->card_status |= ILLEGAL_COMMAND; |
| 1004 | 1066 |
|
| 1005 | 1067 |
printf("SD: Unknown CMD%i\n", req.cmd);
|
| 1006 | 1068 |
return sd_r0; |
| 1069 |
|
|
| 1070 |
unimplemented_cmd: |
|
| 1071 |
/* Commands that are recognised but not yet implemented in SPI mode. */ |
|
| 1072 |
sd->card_status |= ILLEGAL_COMMAND; |
|
| 1073 |
printf ("SD: CMD%i not implemented in SPI mode\n", req.cmd);
|
|
| 1074 |
return sd_r0; |
|
| 1007 | 1075 |
} |
| 1008 | 1076 |
|
| 1009 | 1077 |
sd->card_status |= ILLEGAL_COMMAND; |
| ... | ... | |
| 1069 | 1137 |
break; |
| 1070 | 1138 |
|
| 1071 | 1139 |
case 41: /* ACMD41: SD_APP_OP_COND */ |
| 1140 |
if (sd->spi) {
|
|
| 1141 |
/* SEND_OP_CMD */ |
|
| 1142 |
sd->state = sd_transfer_state; |
|
| 1143 |
return sd_r1; |
|
| 1144 |
} |
|
| 1072 | 1145 |
switch (sd->state) {
|
| 1073 | 1146 |
case sd_idle_state: |
| 1074 | 1147 |
/* We accept any voltage. 10000 V is nothing. */ |
| ... | ... | |
| 1414 | 1487 |
sd->state = sd_transfer_state; |
| 1415 | 1488 |
break; |
| 1416 | 1489 |
|
| 1490 |
case 9: /* CMD9: SEND_CSD */ |
|
| 1491 |
case 10: /* CMD10: SEND_CID */ |
|
| 1492 |
ret = sd->data[sd->data_offset ++]; |
|
| 1493 |
|
|
| 1494 |
if (sd->data_offset >= 16) |
|
| 1495 |
sd->state = sd_transfer_state; |
|
| 1496 |
break; |
|
| 1497 |
|
|
| 1417 | 1498 |
case 11: /* CMD11: READ_DAT_UNTIL_STOP */ |
| 1418 | 1499 |
if (sd->data_offset == 0) |
| 1419 | 1500 |
BLK_READ_BLOCK(sd->data_start, sd->blk_len); |
Also available in: Unified diff