git.maemo.org Git - qemu/blob - hw/sd.c

   1 /*
   2  * SD Memory Card emulation as defined in the "SD Memory Card Physical
   3  * layer specification, Version 1.10."
   4  *
   5  * Copyright (c) 2006 Andrzej Zaborowski  <balrog@zabor.org>
   6  * Copyright (c) 2007 CodeSourcery
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS''
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  27  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "hw.h"
  33 #include "block.h"
  34 #include "sd.h"
  35
  36 //#define DEBUG_SD 1
  37
  38 #ifdef DEBUG_SD
  39 #define DPRINTF(fmt, ...) \
  40 do { fprintf(stderr, "SD: " fmt , ## __VA_ARGS__); } while (0)
  41 #else
  42 #define DPRINTF(fmt, ...) do {} while(0)
  43 #endif
  44
  45 typedef enum {
  46     sd_r0 = 0,    /* no response */
  47     sd_r1,        /* normal response command */
  48     sd_r2_i,      /* CID register */
  49     sd_r2_s,      /* CSD register */
  50     sd_r3,        /* OCR register */
  51     sd_r6 = 6,    /* Published RCA response */
  52     sd_r7,        /* Operating voltage */
  53     sd_r1b = -1,
  54 } sd_rsp_type_t;
  55
  56 struct SDState {
  57     enum {
  58         sd_inactive,
  59         sd_card_identification_mode,
  60         sd_data_transfer_mode,
  61     } mode;
  62     enum {
  63         sd_inactive_state = -1,
  64         sd_idle_state = 0,
  65         sd_ready_state,
  66         sd_identification_state,
  67         sd_standby_state,
  68         sd_transfer_state,
  69         sd_sendingdata_state,
  70         sd_receivingdata_state,
  71         sd_programming_state,
  72         sd_disconnect_state,
  73     } state;
  74     uint32_t ocr;
  75     uint8_t scr[8];
  76     uint8_t cid[16];
  77     uint8_t csd[16];
  78     uint16_t rca;
  79     uint32_t card_status;
  80     uint8_t sd_status[64];
  81     uint32_t vhs;
  82     int wp_switch;
  83     int *wp_groups;
  84     uint32_t size;
  85     int blk_len;
  86     uint32_t erase_start;
  87     uint32_t erase_end;
  88     uint8_t pwd[16];
  89     int pwd_len;
  90     int function_group[6];
  91
  92     int spi;
  93     int current_cmd;
  94     int blk_written;
  95     uint32_t data_start;
  96     uint32_t data_offset;
  97     uint8_t data[512];
  98     qemu_irq readonly_cb;
  99     qemu_irq inserted_cb;
 100     BlockDriverState *bdrv;
 101     uint8_t *buf;
 102
 103     int enable;
 104 };
 105
 106 static void sd_set_status(SDState *sd)
 107 {
 108     switch (sd->state) {
 109     case sd_inactive_state:
 110         sd->mode = sd_inactive;
 111         break;
 112
 113     case sd_idle_state:
 114     case sd_ready_state:
 115     case sd_identification_state:
 116         sd->mode = sd_card_identification_mode;
 117         break;
 118
 119     case sd_standby_state:
 120     case sd_transfer_state:
 121     case sd_sendingdata_state:
 122     case sd_receivingdata_state:
 123     case sd_programming_state:
 124     case sd_disconnect_state:
 125         sd->mode = sd_data_transfer_mode;
 126         break;
 127     }
 128
 129     sd->card_status &= ~CURRENT_STATE;
 130     sd->card_status |= sd->state << 9;
 131 }
 132
 133 static const sd_cmd_type_t sd_cmd_type[64] = {
 134     sd_bc,   sd_none, sd_bcr,  sd_bcr,  sd_none, sd_none, sd_none, sd_ac,
 135     sd_bcr,  sd_ac,   sd_ac,   sd_adtc, sd_ac,   sd_ac,   sd_none, sd_ac,
 136     sd_ac,   sd_adtc, sd_adtc, sd_none, sd_none, sd_none, sd_none, sd_none,
 137     sd_adtc, sd_adtc, sd_adtc, sd_adtc, sd_ac,   sd_ac,   sd_adtc, sd_none,
 138     sd_ac,   sd_ac,   sd_none, sd_none, sd_none, sd_none, sd_ac,   sd_none,
 139     sd_none, sd_none, sd_bc,   sd_none, sd_none, sd_none, sd_none, sd_none,
 140     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_ac,
 141     sd_adtc, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
 142 };
 143
 144 static const sd_cmd_type_t sd_acmd_type[64] = {
 145     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_ac,   sd_none,
 146     sd_none, sd_none, sd_none, sd_none, sd_none, sd_adtc, sd_none, sd_none,
 147     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_adtc, sd_ac,
 148     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
 149     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
 150     sd_none, sd_bcr,  sd_ac,   sd_none, sd_none, sd_none, sd_none, sd_none,
 151     sd_none, sd_none, sd_none, sd_adtc, sd_none, sd_none, sd_none, sd_none,
 152     sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none, sd_none,
 153 };
 154
 155 static const int sd_cmd_class[64] = {
 156     0,  0,  0,  0,  0,  9, 10,  0,  0,  0,  0,  1,  0,  0,  0,  0,
 157     2,  2,  2,  2,  3,  3,  3,  3,  4,  4,  4,  4,  6,  6,  6,  6,
 158     5,  5, 10, 10, 10, 10,  5,  9,  9,  9,  7,  7,  7,  7,  7,  7,
 159     7,  7, 10,  7,  9,  9,  9,  8,  8, 10,  8,  8,  8,  8,  8,  8,
 160 };
 161
 162 static uint8_t sd_crc7(void *message, size_t width)
 163 {
 164     int i, bit;
 165     uint8_t shift_reg = 0x00;
 166     uint8_t *msg = (uint8_t *) message;
 167
 168     for (i = 0; i < width; i ++, msg ++)
 169         for (bit = 7; bit >= 0; bit --) {
 170             shift_reg <<= 1;
 171             if ((shift_reg >> 7) ^ ((*msg >> bit) & 1))
 172                 shift_reg ^= 0x89;
 173         }
 174
 175     return shift_reg;
 176 }
 177
 178 static uint16_t sd_crc16(void *message, size_t width)
 179 {
 180     int i, bit;
 181     uint16_t shift_reg = 0x0000;
 182     uint16_t *msg = (uint16_t *) message;
 183     width <<= 1;
 184
 185     for (i = 0; i < width; i ++, msg ++)
 186         for (bit = 15; bit >= 0; bit --) {
 187             shift_reg <<= 1;
 188             if ((shift_reg >> 15) ^ ((*msg >> bit) & 1))
 189                 shift_reg ^= 0x1011;
 190         }
 191
 192     return shift_reg;
 193 }
 194
 195 static void sd_set_ocr(SDState *sd)
 196 {
 197     /* All voltages OK, card power-up OK, Standard Capacity SD Memory Card */
 198     sd->ocr = 0x80ffff00;
 199 }
 200
 201 static void sd_set_scr(SDState *sd)
 202 {
 203     sd->scr[0] = 0x00; /* SCR v1.0, SD spec v1.0/1.01 */
 204     sd->scr[1] = 0x25; /* erase=0, SD security v1.01, 1bit/4bit bus width */
 205     sd->scr[2] = 0x00;
 206     sd->scr[3] = 0x00;
 207     sd->scr[4] = 0x00;
 208     sd->scr[5] = 0x00;
 209     sd->scr[6] = 0x00;
 210     sd->scr[7] = 0x00;
 211 }
 212
 213 #define MID     0xaa
 214 #define OID     "XY"
 215 #define PNM     "QEMU!"
 216 #define PRV     0x01
 217 #define MDT_YR  2006
 218 #define MDT_MON 2
 219
 220 static void sd_set_cid(SDState *sd)
 221 {
 222     sd->cid[0] = MID;           /* Fake card manufacturer ID (MID) */
 223     sd->cid[1] = OID[0];        /* OEM/Application ID (OID) */
 224     sd->cid[2] = OID[1];
 225     sd->cid[3] = PNM[0];        /* Fake product name (PNM) */
 226     sd->cid[4] = PNM[1];
 227     sd->cid[5] = PNM[2];
 228     sd->cid[6] = PNM[3];
 229     sd->cid[7] = PNM[4];
 230     sd->cid[8] = PRV;           /* Fake product revision (PRV) */
 231     sd->cid[9] = 0xde;          /* Fake serial number (PSN) */
 232     sd->cid[10] = 0xad;
 233     sd->cid[11] = 0xbe;
 234     sd->cid[12] = 0xef;
 235     sd->cid[13] = 0x00 |        /* Manufacture date (MDT) */
 236         ((MDT_YR - 2000) / 10);
 237     sd->cid[14] = ((MDT_YR % 10) << 4) | MDT_MON;
 238     sd->cid[15] = (sd_crc7(sd->cid, 15) << 1) | 1;
 239 }
 240
 241 #define HWBLOCK_SHIFT   9                       /* 512 bytes */
 242 #define SECTOR_SHIFT    5                       /* 16 kilobytes */
 243 #define WPGROUP_SHIFT   7                       /* 2 megs */
 244 #define CMULT_SHIFT     9                       /* 512 times HWBLOCK_SIZE */
 245 #define WPGROUP_SIZE    (1 << (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT))
 246
 247 static const uint8_t sd_csd_rw_mask[16] = {
 248     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 249     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xfe,
 250 };
 251
 252 static void sd_set_csd(SDState *sd, uint32_t size)
 253 {
 254     uint32_t csize = (size >> (CMULT_SHIFT + HWBLOCK_SHIFT)) - 1;
 255     uint32_t sectsize = (1 << (SECTOR_SHIFT + 1)) - 1;
 256     uint32_t wpsize = (1 << (WPGROUP_SHIFT + 1)) - 1;
 257
 258     sd->csd[0] = 0x00;          /* CSD structure */
 259     sd->csd[1] = 0x26;          /* Data read access-time-1 */
 260     sd->csd[2] = 0x00;          /* Data read access-time-2 */
 261     sd->csd[3] = 0x5a;          /* Max. data transfer rate */
 262     sd->csd[4] = 0x5f;          /* Card Command Classes */
 263     sd->csd[5] = 0x50 |         /* Max. read data block length */
 264         HWBLOCK_SHIFT;
 265     sd->csd[6] = 0xe0 |         /* Partial block for read allowed */
 266         ((csize >> 10) & 0x03);
 267     sd->csd[7] = 0x00 |         /* Device size */
 268         ((csize >> 2) & 0xff);
 269     sd->csd[8] = 0x3f |         /* Max. read current */
 270         ((csize << 6) & 0xc0);
 271     sd->csd[9] = 0xfc |         /* Max. write current */
 272         ((CMULT_SHIFT - 2) >> 1);
 273     sd->csd[10] = 0x40 |        /* Erase sector size */
 274         (((CMULT_SHIFT - 2) << 7) & 0x80) | (sectsize >> 1);
 275     sd->csd[11] = 0x00 |        /* Write protect group size */
 276         ((sectsize << 7) & 0x80) | wpsize;
 277     sd->csd[12] = 0x90 |        /* Write speed factor */
 278         (HWBLOCK_SHIFT >> 2);
 279     sd->csd[13] = 0x20 |        /* Max. write data block length */
 280         ((HWBLOCK_SHIFT << 6) & 0xc0);
 281     sd->csd[14] = 0x00;         /* File format group */
 282     sd->csd[15] = (sd_crc7(sd->csd, 15) << 1) | 1;
 283 }
 284
 285 static void sd_set_rca(SDState *sd)
 286 {
 287     sd->rca += 0x4567;
 288 }
 289
 290 #define CARD_STATUS_A   0x02004100
 291 #define CARD_STATUS_B   0x00c01e00
 292 #define CARD_STATUS_C   0xfd39a028
 293
 294 static void sd_set_cardstatus(SDState *sd)
 295 {
 296     sd->card_status = 0x00000100;
 297 }
 298
 299 static void sd_set_sdstatus(SDState *sd)
 300 {
 301     memset(sd->sd_status, 0, 64);
 302 }
 303
 304 static int sd_req_crc_validate(SDRequest *req)
 305 {
 306     uint8_t buffer[5];
 307     buffer[0] = 0x40 | req->cmd;
 308     buffer[1] = (req->arg >> 24) & 0xff;
 309     buffer[2] = (req->arg >> 16) & 0xff;
 310     buffer[3] = (req->arg >> 8) & 0xff;
 311     buffer[4] = (req->arg >> 0) & 0xff;
 312     return 0;
 313     return sd_crc7(buffer, 5) != req->crc;      /* TODO */
 314 }
 315
 316 static void sd_response_r1_make(SDState *sd,
 317                                 uint8_t *response, uint32_t last_status)
 318 {
 319     uint32_t mask = CARD_STATUS_B ^ ILLEGAL_COMMAND;
 320     uint32_t status;
 321
 322     status = (sd->card_status & ~mask) | (last_status & mask);
 323     sd->card_status &= ~CARD_STATUS_C | APP_CMD;
 324
 325     response[0] = (status >> 24) & 0xff;
 326     response[1] = (status >> 16) & 0xff;
 327     response[2] = (status >> 8) & 0xff;
 328     response[3] = (status >> 0) & 0xff;
 329 }
 330
 331 static void sd_response_r3_make(SDState *sd, uint8_t *response)
 332 {
 333     response[0] = (sd->ocr >> 24) & 0xff;
 334     response[1] = (sd->ocr >> 16) & 0xff;
 335     response[2] = (sd->ocr >> 8) & 0xff;
 336     response[3] = (sd->ocr >> 0) & 0xff;
 337 }
 338
 339 static void sd_response_r6_make(SDState *sd, uint8_t *response)
 340 {
 341     uint16_t arg;
 342     uint16_t status;
 343
 344     arg = sd->rca;
 345     status = ((sd->card_status >> 8) & 0xc000) |
 346              ((sd->card_status >> 6) & 0x2000) |
 347               (sd->card_status & 0x1fff);
 348
 349     response[0] = (arg >> 8) & 0xff;
 350     response[1] = arg & 0xff;
 351     response[2] = (status >> 8) & 0xff;
 352     response[3] = status & 0xff;
 353 }
 354
 355 static void sd_response_r7_make(SDState *sd, uint8_t *response)
 356 {
 357     response[0] = (sd->vhs >> 24) & 0xff;
 358     response[1] = (sd->vhs >> 16) & 0xff;
 359     response[2] = (sd->vhs >>  8) & 0xff;
 360     response[3] = (sd->vhs >>  0) & 0xff;
 361 }
 362
 363 static void sd_reset(SDState *sd, BlockDriverState *bdrv)
 364 {
 365     uint32_t size;
 366     uint64_t sect;
 367
 368     if (bdrv) {
 369         bdrv_get_geometry(bdrv, &sect);
 370     } else {
 371         sect = 0;
 372     }
 373     sect <<= 9;
 374
 375     if (sect > 0x40000000)
 376         size = 0x40000000;      /* 1 gig */
 377     else
 378         size = sect + 1;
 379
 380     sect = (size >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)) + 1;
 381
 382     sd->state = sd_idle_state;
 383     sd->rca = 0x0000;
 384     sd_set_ocr(sd);
 385     sd_set_scr(sd);
 386     sd_set_cid(sd);
 387     sd_set_csd(sd, size);
 388     sd_set_cardstatus(sd);
 389     sd_set_sdstatus(sd);
 390
 391     sd->bdrv = bdrv;
 392
 393     if (sd->wp_groups)
 394         qemu_free(sd->wp_groups);
 395     sd->wp_switch = bdrv ? bdrv_is_read_only(bdrv) : 0;
 396     sd->wp_groups = (int *) qemu_mallocz(sizeof(int) * sect);
 397     memset(sd->function_group, 0, sizeof(int) * 6);
 398     sd->erase_start = 0;
 399     sd->erase_end = 0;
 400     sd->size = size;
 401     sd->blk_len = 0x200;
 402     sd->pwd_len = 0;
 403 }
 404
 405 static void sd_cardchange(void *opaque)
 406 {
 407     SDState *sd = opaque;
 408     qemu_set_irq(sd->inserted_cb, bdrv_is_inserted(sd->bdrv));
 409     if (bdrv_is_inserted(sd->bdrv)) {
 410         sd_reset(sd, sd->bdrv);
 411         qemu_set_irq(sd->readonly_cb, sd->wp_switch);
 412     }
 413 }
 414
 415 static void sd_save_state(QEMUFile *f, void *opaque)
 416 {
 417     struct SDState *s = (struct SDState *)opaque;
 418     int i;
 419     uint32_t wpgc = (s->size >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)) + 1;
 420     char *filename;
 421
 422     filename = qemu_mallocz(1024);
 423     bdrv_get_backing_filename(s->bdrv, filename, 1024);
 424     qemu_put_buffer(f, (uint8_t *)filename, 1024);
 425     free(filename);
 426
 427     qemu_put_sbe32(f, s->mode);
 428     qemu_put_sbe32(f, s->state);
 429     qemu_put_be32(f, s->ocr);
 430     qemu_put_buffer(f, s->scr, sizeof(s->scr));
 431     qemu_put_buffer(f, s->cid, sizeof(s->cid));
 432     qemu_put_buffer(f, s->csd, sizeof(s->csd));
 433     qemu_put_be16(f, s->rca);
 434     qemu_put_be32(f, s->card_status);
 435     qemu_put_buffer(f, s->sd_status, sizeof(s->sd_status));
 436     qemu_put_be32(f, s->vhs);
 437     for (i = 0; i < wpgc; i++)
 438         qemu_put_sbe32(f, s->wp_groups[i]);
 439     qemu_put_sbe32(f, s->blk_len);
 440     qemu_put_be32(f, s->erase_start);
 441     qemu_put_be32(f, s->erase_end);
 442     qemu_put_buffer(f, s->pwd, sizeof(s->pwd));
 443     qemu_put_sbe32(f, s->pwd_len);
 444     for (i = 0; i < 6; i++)
 445         qemu_put_sbe32(f, s->function_group[i]);
 446     qemu_put_sbe32(f, s->current_cmd);
 447     qemu_put_sbe32(f, s->blk_written);
 448     qemu_put_be32(f, s->data_start);
 449     qemu_put_be32(f, s->data_offset);
 450     qemu_put_buffer(f, s->data, sizeof(s->data));
 451     qemu_put_buffer(f, s->buf, 512);
 452     qemu_put_sbe32(f, s->enable);
 453 }
 454
 455 static int sd_load_state(QEMUFile *f, void *opaque, int version_id)
 456 {
 457     struct SDState *s = (struct SDState *)opaque;
 458     int i;
 459     uint32_t wpgc = (s->size >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)) + 1;
 460     char *filename1, *filename2;
 461     int result = 0;
 462
 463     if (version_id)
 464         return -EINVAL;
 465
 466     filename1 = qemu_mallocz(1024);
 467     filename2 = qemu_mallocz(1024);
 468     bdrv_get_backing_filename(s->bdrv, filename1, 1024);
 469     qemu_get_buffer(f, (uint8_t *)filename2, 1024);
 470     if (!strcmp(filename1, filename2)) {
 471         s->mode = qemu_get_sbe32(f);
 472         s->state = qemu_get_sbe32(f);
 473         s->ocr = qemu_get_be32(f);
 474         qemu_get_buffer(f, s->scr, sizeof(s->scr));
 475         qemu_get_buffer(f, s->cid, sizeof(s->cid));
 476         qemu_get_buffer(f, s->csd, sizeof(s->csd));
 477         s->rca = qemu_get_be16(f);
 478         s->card_status = qemu_get_be32(f);
 479         qemu_get_buffer(f, s->sd_status, sizeof(s->sd_status));
 480         s->vhs = qemu_get_be32(f);
 481         for (i = 0; i < wpgc; i++)
 482             s->wp_groups[i] = qemu_get_sbe32(f);
 483         s->blk_len = qemu_get_sbe32(f);
 484         s->erase_start = qemu_get_be32(f);
 485         s->erase_end = qemu_get_be32(f);
 486         qemu_get_buffer(f, s->pwd, sizeof(s->pwd));
 487         s->pwd_len = qemu_get_sbe32(f);
 488         for (i = 0; i < 6; i++)
 489             s->function_group[i] = qemu_get_sbe32(f);
 490         s->current_cmd = qemu_get_sbe32(f);
 491         s->blk_written = qemu_get_sbe32(f);
 492         s->data_start = qemu_get_be32(f);
 493         s->data_offset = qemu_get_be32(f);
 494         qemu_get_buffer(f, s->data, sizeof(s->data));
 495         qemu_get_buffer(f, s->buf, 512);
 496         s->enable = qemu_get_sbe32(f);
 497     } else
 498         result = -EINVAL;
 499     free(filename2);
 500     free(filename1);
 501     return result;
 502 }
 503
 504 /* We do not model the chip select pin, so allow the board to select
 505    whether card should be in SSI or MMC/SD mode.  It is also up to the
 506    board to ensure that ssi transfers only occur when the chip select
 507    is asserted.  */
 508 SDState *sd_init(BlockDriverState *bs, int is_spi)
 509 {
 510     SDState *sd;
 511     static int instance_number = 1;
 512
 513     sd = (SDState *) qemu_mallocz(sizeof(SDState));
 514     sd->buf = qemu_memalign(512, 512);
 515     sd->spi = is_spi;
 516     sd->enable = 1;
 517     sd_reset(sd, bs);
 518     if (sd->bdrv) {
 519         bdrv_set_change_cb(sd->bdrv, sd_cardchange, sd);
 520     }
 521     register_savevm("sd", instance_number++, 0,
 522                     sd_save_state, sd_load_state, sd);
 523     return sd;
 524 }
 525
 526 void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)
 527 {
 528     sd->readonly_cb = readonly;
 529     sd->inserted_cb = insert;
 530     qemu_set_irq(readonly, bdrv_is_read_only(sd->bdrv));
 531     qemu_set_irq(insert, bdrv_is_inserted(sd->bdrv));
 532 }
 533
 534 static void sd_erase(SDState *sd)
 535 {
 536     int i, start, end;
 537     if (!sd->erase_start || !sd->erase_end) {
 538         sd->card_status |= ERASE_SEQ_ERROR;
 539         return;
 540     }
 541
 542     start = sd->erase_start >>
 543             (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
 544     end = sd->erase_end >>
 545             (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
 546     sd->erase_start = 0;
 547     sd->erase_end = 0;
 548     sd->csd[14] |= 0x40;
 549
 550     for (i = start; i <= end; i ++)
 551         if (sd->wp_groups[i])
 552             sd->card_status |= WP_ERASE_SKIP;
 553 }
 554
 555 static uint32_t sd_wpbits(SDState *sd, uint32_t addr)
 556 {
 557     uint32_t i, wpnum;
 558     uint32_t ret = 0;
 559
 560     wpnum = addr >> (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT);
 561
 562     for (i = 0; i < 32; i ++, wpnum ++, addr += WPGROUP_SIZE)
 563         if (addr < sd->size && sd->wp_groups[wpnum])
 564             ret |= (1 << i);
 565
 566     return ret;
 567 }
 568
 569 static void sd_function_switch(SDState *sd, uint32_t arg)
 570 {
 571     int i, mode, new_func, crc;
 572     mode = !!(arg & 0x80000000);
 573
 574     sd->data[0] = 0x00;         /* Maximum current consumption */
 575     sd->data[1] = 0x01;
 576     sd->data[2] = 0x80;         /* Supported group 6 functions */
 577     sd->data[3] = 0x01;
 578     sd->data[4] = 0x80;         /* Supported group 5 functions */
 579     sd->data[5] = 0x01;
 580     sd->data[6] = 0x80;         /* Supported group 4 functions */
 581     sd->data[7] = 0x01;
 582     sd->data[8] = 0x80;         /* Supported group 3 functions */
 583     sd->data[9] = 0x01;
 584     sd->data[10] = 0x80;        /* Supported group 2 functions */
 585     sd->data[11] = 0x43;
 586     sd->data[12] = 0x80;        /* Supported group 1 functions */
 587     sd->data[13] = 0x03;
 588     for (i = 0; i < 6; i ++) {
 589         new_func = (arg >> (i * 4)) & 0x0f;
 590         if (mode && new_func != 0x0f)
 591             sd->function_group[i] = new_func;
 592         sd->data[14 + (i >> 1)] = new_func << ((i * 4) & 4);
 593     }
 594     memset(&sd->data[17], 0, 47);
 595     crc = sd_crc16(sd->data, 64);
 596     sd->data[65] = crc >> 8;
 597     sd->data[66] = crc & 0xff;
 598 }
 599
 600 static inline int sd_wp_addr(SDState *sd, uint32_t addr)
 601 {
 602     return sd->wp_groups[addr >>
 603             (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)];
 604 }
 605
 606 static void sd_lock_command(SDState *sd)
 607 {
 608     int erase, lock, clr_pwd, set_pwd, pwd_len;
 609     erase = !!(sd->data[0] & 0x08);
 610     lock = sd->data[0] & 0x04;
 611     clr_pwd = sd->data[0] & 0x02;
 612     set_pwd = sd->data[0] & 0x01;
 613
 614     if (sd->blk_len > 1)
 615         pwd_len = sd->data[1];
 616     else
 617         pwd_len = 0;
 618
 619     if (erase) {
 620         if (!(sd->card_status & CARD_IS_LOCKED) || sd->blk_len > 1 ||
 621                         set_pwd || clr_pwd || lock || sd->wp_switch ||
 622                         (sd->csd[14] & 0x20)) {
 623             sd->card_status |= LOCK_UNLOCK_FAILED;
 624             return;
 625         }
 626         memset(sd->wp_groups, 0, sizeof(int) * (sd->size >>
 627                         (HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)));
 628         sd->csd[14] &= ~0x10;
 629         sd->card_status &= ~CARD_IS_LOCKED;
 630         sd->pwd_len = 0;
 631         /* Erasing the entire card here! */
 632         fprintf(stderr, "SD: Card force-erased by CMD42\n");
 633         return;
 634     }
 635
 636     if (sd->blk_len < 2 + pwd_len ||
 637                     pwd_len <= sd->pwd_len ||
 638                     pwd_len > sd->pwd_len + 16) {
 639         sd->card_status |= LOCK_UNLOCK_FAILED;
 640         return;
 641     }
 642
 643     if (sd->pwd_len && memcmp(sd->pwd, sd->data + 2, sd->pwd_len)) {
 644         sd->card_status |= LOCK_UNLOCK_FAILED;
 645         return;
 646     }
 647
 648     pwd_len -= sd->pwd_len;
 649     if ((pwd_len && !set_pwd) ||
 650                     (clr_pwd && (set_pwd || lock)) ||
 651                     (lock && !sd->pwd_len && !set_pwd) ||
 652                     (!set_pwd && !clr_pwd &&
 653                      (((sd->card_status & CARD_IS_LOCKED) && lock) ||
 654                       (!(sd->card_status & CARD_IS_LOCKED) && !lock)))) {
 655         sd->card_status |= LOCK_UNLOCK_FAILED;
 656         return;
 657     }
 658
 659     if (set_pwd) {
 660         memcpy(sd->pwd, sd->data + 2 + sd->pwd_len, pwd_len);
 661         sd->pwd_len = pwd_len;
 662     }
 663
 664     if (clr_pwd) {
 665         sd->pwd_len = 0;
 666     }
 667
 668     if (lock)
 669         sd->card_status |= CARD_IS_LOCKED;
 670     else
 671         sd->card_status &= ~CARD_IS_LOCKED;
 672 }
 673
 674 static sd_rsp_type_t sd_normal_command(SDState *sd,
 675                                        SDRequest req)
 676 {
 677     uint32_t rca = 0x0000;
 678
 679     if (sd_cmd_type[req.cmd] == sd_ac || sd_cmd_type[req.cmd] == sd_adtc)
 680         rca = req.arg >> 16;
 681
 682     DPRINTF("CMD%d 0x%08x state %d\n", req.cmd, req.arg, sd->state);
 683     switch (req.cmd) {
 684     /* Basic commands (Class 0 and Class 1) */
 685     case 0:     /* CMD0:   GO_IDLE_STATE */
 686         switch (sd->state) {
 687         case sd_inactive_state:
 688             return sd->spi ? sd_r1 : sd_r0;
 689
 690         default:
 691             sd->state = sd_idle_state;
 692             sd_reset(sd, sd->bdrv);
 693             return sd->spi ? sd_r1 : sd_r0;
 694         }
 695         break;
 696
 697     case 1:     /* CMD1:   SEND_OP_CMD */
 698         if (!sd->spi)
 699             goto bad_cmd;
 700
 701         sd->state = sd_transfer_state;
 702         return sd_r1;
 703
 704     case 2:     /* CMD2:   ALL_SEND_CID */
 705         if (sd->spi)
 706             goto bad_cmd;
 707         switch (sd->state) {
 708         case sd_ready_state:
 709             sd->state = sd_identification_state;
 710             return sd_r2_i;
 711
 712         default:
 713             break;
 714         }
 715         break;
 716
 717     case 3:     /* CMD3:   SEND_RELATIVE_ADDR */
 718         if (sd->spi)
 719             goto bad_cmd;
 720         switch (sd->state) {
 721         case sd_identification_state:
 722         case sd_standby_state:
 723             sd->state = sd_standby_state;
 724             sd_set_rca(sd);
 725             return sd_r6;
 726
 727         default:
 728             break;
 729         }
 730         break;
 731
 732     case 4:     /* CMD4:   SEND_DSR */
 733         if (sd->spi)
 734             goto bad_cmd;
 735         switch (sd->state) {
 736         case sd_standby_state:
 737             return sd_r0;
 738
 739         default:
 740             break;
 741         }
 742         break;
 743
 744     case 6:     /* CMD6:   SWITCH_FUNCTION */
 745         if (sd->spi)
 746             goto bad_cmd;
 747         switch (sd->mode) {
 748         case sd_data_transfer_mode:
 749             sd_function_switch(sd, req.arg);
 750             sd->state = sd_sendingdata_state;
 751             sd->data_start = 0;
 752             sd->data_offset = 0;
 753             return sd_r1;
 754
 755         default:
 756             break;
 757         }
 758         break;
 759
 760     case 7:     /* CMD7:   SELECT/DESELECT_CARD */
 761         if (sd->spi)
 762             goto bad_cmd;
 763         switch (sd->state) {
 764         case sd_standby_state:
 765             if (sd->rca != rca)
 766                 return sd_r0;
 767
 768             sd->state = sd_transfer_state;
 769             return sd_r1b;
 770
 771         case sd_transfer_state:
 772         case sd_sendingdata_state:
 773             if (sd->rca == rca)
 774                 break;
 775
 776             sd->state = sd_standby_state;
 777             return sd_r1b;
 778
 779         case sd_disconnect_state:
 780             if (sd->rca != rca)
 781                 return sd_r0;
 782
 783             sd->state = sd_programming_state;
 784             return sd_r1b;
 785
 786         case sd_programming_state:
 787             if (sd->rca == rca)
 788                 break;
 789
 790             sd->state = sd_disconnect_state;
 791             return sd_r1b;
 792
 793         default:
 794             break;
 795         }
 796         break;
 797
 798     case 8:     /* CMD8:   SEND_IF_COND */
 799         /* Physical Layer Specification Version 2.00 command */
 800         switch (sd->state) {
 801         case sd_idle_state:
 802             sd->vhs = 0;
 803
 804             /* No response if not exactly one VHS bit is set.  */
 805             if (!(req.arg >> 8) || (req.arg >> ffs(req.arg & ~0xff)))
 806                 return sd->spi ? sd_r7 : sd_r0;
 807
 808             /* Accept.  */
 809             sd->vhs = req.arg;
 810             return sd_r7;
 811
 812         default:
 813             break;
 814         }
 815         break;
 816
 817     case 9:     /* CMD9:   SEND_CSD */
 818         switch (sd->state) {
 819         case sd_standby_state:
 820             if (sd->rca != rca)
 821                 return sd_r0;
 822
 823             return sd_r2_s;
 824
 825         case sd_transfer_state:
 826             if (!sd->spi)
 827                 break;
 828             sd->state = sd_sendingdata_state;
 829             memcpy(sd->data, sd->csd, 16);
 830             sd->data_start = req.arg;
 831             sd->data_offset = 0;
 832             return sd_r1;
 833
 834         default:
 835             break;
 836         }
 837         break;
 838
 839     case 10:    /* CMD10:  SEND_CID */
 840         switch (sd->state) {
 841         case sd_standby_state:
 842             if (sd->rca != rca)
 843                 return sd_r0;
 844
 845             return sd_r2_i;
 846
 847         case sd_transfer_state:
 848             if (!sd->spi)
 849                 break;
 850             sd->state = sd_sendingdata_state;
 851             memcpy(sd->data, sd->cid, 16);
 852             sd->data_start = req.arg;
 853             sd->data_offset = 0;
 854             return sd_r1;
 855
 856         default:
 857             break;
 858         }
 859         break;
 860
 861     case 11:    /* CMD11:  READ_DAT_UNTIL_STOP */
 862         if (sd->spi)
 863             goto bad_cmd;
 864         switch (sd->state) {
 865         case sd_transfer_state:
 866             sd->state = sd_sendingdata_state;
 867             sd->data_start = req.arg;
 868             sd->data_offset = 0;
 869
 870             if (sd->data_start + sd->blk_len > sd->size)
 871                 sd->card_status |= ADDRESS_ERROR;
 872             return sd_r0;
 873
 874         default:
 875             break;
 876         }
 877         break;
 878
 879     case 12:    /* CMD12:  STOP_TRANSMISSION */
 880         switch (sd->state) {
 881         case sd_sendingdata_state:
 882             sd->state = sd_transfer_state;
 883             return sd_r1b;
 884
 885         case sd_receivingdata_state:
 886             sd->state = sd_programming_state;
 887             /* Bzzzzzzztt .... Operation complete.  */
 888             sd->state = sd_transfer_state;
 889             return sd_r1b;
 890
 891         default:
 892             break;
 893         }
 894         break;
 895
 896     case 13:    /* CMD13:  SEND_STATUS */
 897         switch (sd->mode) {
 898         case sd_data_transfer_mode:
 899             if (sd->rca != rca)
 900                 return sd_r0;
 901
 902             return sd_r1;
 903
 904         default:
 905             break;
 906         }
 907         break;
 908
 909     case 15:    /* CMD15:  GO_INACTIVE_STATE */
 910         if (sd->spi)
 911             goto bad_cmd;
 912         switch (sd->mode) {
 913         case sd_data_transfer_mode:
 914             if (sd->rca != rca)
 915                 return sd_r0;
 916
 917             sd->state = sd_inactive_state;
 918             return sd_r0;
 919
 920         default:
 921             break;
 922         }
 923         break;
 924
 925     /* Block read commands (Classs 2) */
 926     case 16:    /* CMD16:  SET_BLOCKLEN */
 927         switch (sd->state) {
 928         case sd_transfer_state:
 929             if (req.arg > (1 << HWBLOCK_SHIFT))
 930                 sd->card_status |= BLOCK_LEN_ERROR;
 931             else
 932                 sd->blk_len = req.arg;
 933
 934             return sd_r1;
 935
 936         default:
 937             break;
 938         }
 939         break;
 940
 941     case 17:    /* CMD17:  READ_SINGLE_BLOCK */
 942         switch (sd->state) {
 943         case sd_transfer_state:
 944             sd->state = sd_sendingdata_state;
 945             sd->data_start = req.arg;
 946             sd->data_offset = 0;
 947
 948             if (sd->data_start + sd->blk_len > sd->size)
 949                 sd->card_status |= ADDRESS_ERROR;
 950             return sd_r1;
 951
 952         default:
 953             break;
 954         }
 955         break;
 956
 957     case 18:    /* CMD18:  READ_MULTIPLE_BLOCK */
 958         switch (sd->state) {
 959         case sd_transfer_state:
 960             sd->state = sd_sendingdata_state;
 961             sd->data_start = req.arg;
 962             sd->data_offset = 0;
 963
 964             if (sd->data_start + sd->blk_len > sd->size)
 965                 sd->card_status |= ADDRESS_ERROR;
 966             return sd_r1;
 967
 968         default:
 969             break;
 970         }
 971         break;
 972
 973     /* Block write commands (Class 4) */
 974     case 24:    /* CMD24:  WRITE_SINGLE_BLOCK */
 975         if (sd->spi)
 976             goto unimplemented_cmd;
 977         switch (sd->state) {
 978         case sd_transfer_state:
 979             /* Writing in SPI mode not implemented.  */
 980             if (sd->spi)
 981                 break;
 982             sd->state = sd_receivingdata_state;
 983             sd->data_start = req.arg;
 984             sd->data_offset = 0;
 985             sd->blk_written = 0;
 986
 987             if (sd->data_start + sd->blk_len > sd->size)
 988                 sd->card_status |= ADDRESS_ERROR;
 989             if (sd_wp_addr(sd, sd->data_start))
 990                 sd->card_status |= WP_VIOLATION;
 991             if (sd->csd[14] & 0x30)
 992                 sd->card_status |= WP_VIOLATION;
 993             return sd_r1;
 994
 995         default:
 996             break;
 997         }
 998         break;
 999
1000     case 25:    /* CMD25:  WRITE_MULTIPLE_BLOCK */
1001         if (sd->spi)
1002             goto unimplemented_cmd;
1003         switch (sd->state) {
1004         case sd_transfer_state:
1005             /* Writing in SPI mode not implemented.  */
1006             if (sd->spi)
1007                 break;
1008             sd->state = sd_receivingdata_state;
1009             sd->data_start = req.arg;
1010             sd->data_offset = 0;
1011             sd->blk_written = 0;
1012
1013             if (sd->data_start + sd->blk_len > sd->size)
1014                 sd->card_status |= ADDRESS_ERROR;
1015             if (sd_wp_addr(sd, sd->data_start))
1016                 sd->card_status |= WP_VIOLATION;
1017             if (sd->csd[14] & 0x30)
1018                 sd->card_status |= WP_VIOLATION;
1019             return sd_r1;
1020
1021         default:
1022             break;
1023         }
1024         break;
1025
1026     case 26:    /* CMD26:  PROGRAM_CID */
1027         if (sd->spi)
1028             goto bad_cmd;
1029         switch (sd->state) {
1030         case sd_transfer_state:
1031             sd->state = sd_receivingdata_state;
1032             sd->data_start = 0;
1033             sd->data_offset = 0;
1034             return sd_r1;
1035
1036         default:
1037             break;
1038         }
1039         break;
1040
1041     case 27:    /* CMD27:  PROGRAM_CSD */
1042         if (sd->spi)
1043             goto unimplemented_cmd;
1044         switch (sd->state) {
1045         case sd_transfer_state:
1046             sd->state = sd_receivingdata_state;
1047             sd->data_start = 0;
1048             sd->data_offset = 0;
1049             return sd_r1;
1050
1051         default:
1052             break;
1053         }
1054         break;
1055
1056     /* Write protection (Class 6) */
1057     case 28:    /* CMD28:  SET_WRITE_PROT */
1058         switch (sd->state) {
1059         case sd_transfer_state:
1060             if (req.arg >= sd->size) {
1061                 sd->card_status = ADDRESS_ERROR;
1062                 return sd_r1b;
1063             }
1064
1065             sd->state = sd_programming_state;
1066             sd->wp_groups[req.arg >> (HWBLOCK_SHIFT +
1067                             SECTOR_SHIFT + WPGROUP_SHIFT)] = 1;
1068             /* Bzzzzzzztt .... Operation complete.  */
1069             sd->state = sd_transfer_state;
1070             return sd_r1b;
1071
1072         default:
1073             break;
1074         }
1075         break;
1076
1077     case 29:    /* CMD29:  CLR_WRITE_PROT */
1078         switch (sd->state) {
1079         case sd_transfer_state:
1080             if (req.arg >= sd->size) {
1081                 sd->card_status = ADDRESS_ERROR;
1082                 return sd_r1b;
1083             }
1084
1085             sd->state = sd_programming_state;
1086             sd->wp_groups[req.arg >> (HWBLOCK_SHIFT +
1087                             SECTOR_SHIFT + WPGROUP_SHIFT)] = 0;
1088             /* Bzzzzzzztt .... Operation complete.  */
1089             sd->state = sd_transfer_state;
1090             return sd_r1b;
1091
1092         default:
1093             break;
1094         }
1095         break;
1096
1097     case 30:    /* CMD30:  SEND_WRITE_PROT */
1098         switch (sd->state) {
1099         case sd_transfer_state:
1100             sd->state = sd_sendingdata_state;
1101             *(uint32_t *) sd->data = sd_wpbits(sd, req.arg);
1102             sd->data_start = req.arg;
1103             sd->data_offset = 0;
1104             return sd_r1b;
1105
1106         default:
1107             break;
1108         }
1109         break;
1110
1111     /* Erase commands (Class 5) */
1112     case 32:    /* CMD32:  ERASE_WR_BLK_START */
1113         switch (sd->state) {
1114         case sd_transfer_state:
1115             sd->erase_start = req.arg;
1116             return sd_r1;
1117
1118         default:
1119             break;
1120         }
1121         break;
1122
1123     case 33:    /* CMD33:  ERASE_WR_BLK_END */
1124         switch (sd->state) {
1125         case sd_transfer_state:
1126             sd->erase_end = req.arg;
1127             return sd_r1;
1128
1129         default:
1130             break;
1131         }
1132         break;
1133
1134     case 38:    /* CMD38:  ERASE */
1135         switch (sd->state) {
1136         case sd_transfer_state:
1137             if (sd->csd[14] & 0x30) {
1138                 sd->card_status |= WP_VIOLATION;
1139                 return sd_r1b;
1140             }
1141
1142             sd->state = sd_programming_state;
1143             sd_erase(sd);
1144             /* Bzzzzzzztt .... Operation complete.  */
1145             sd->state = sd_transfer_state;
1146             return sd_r1b;
1147
1148         default:
1149             break;
1150         }
1151         break;
1152
1153     /* Lock card commands (Class 7) */
1154     case 42:    /* CMD42:  LOCK_UNLOCK */
1155         if (sd->spi)
1156             goto unimplemented_cmd;
1157         switch (sd->state) {
1158         case sd_transfer_state:
1159             sd->state = sd_receivingdata_state;
1160             sd->data_start = 0;
1161             sd->data_offset = 0;
1162             return sd_r1;
1163
1164         default:
1165             break;
1166         }
1167         break;
1168
1169     /* Application specific commands (Class 8) */
1170     case 55:    /* CMD55:  APP_CMD */
1171         if (sd->rca != rca)
1172             return sd_r0;
1173
1174         sd->card_status |= APP_CMD;
1175         return sd_r1;
1176
1177     case 56:    /* CMD56:  GEN_CMD */
1178         fprintf(stderr, "SD: GEN_CMD 0x%08x\n", req.arg);
1179
1180         switch (sd->state) {
1181         case sd_transfer_state:
1182             sd->data_offset = 0;
1183             if (req.arg & 1)
1184                 sd->state = sd_sendingdata_state;
1185             else
1186                 sd->state = sd_receivingdata_state;
1187             return sd_r1;
1188
1189         default:
1190             break;
1191         }
1192         break;
1193
1194     default:
1195     bad_cmd:
1196         sd->card_status |= ILLEGAL_COMMAND;
1197
1198         fprintf(stderr, "SD: Unknown CMD%i\n", req.cmd);
1199         return sd_r0;
1200
1201     unimplemented_cmd:
1202         /* Commands that are recognised but not yet implemented in SPI mode.  */
1203         sd->card_status |= ILLEGAL_COMMAND;
1204         fprintf(stderr, "SD: CMD%i not implemented in SPI mode\n", req.cmd);
1205         return sd_r0;
1206     }
1207
1208     sd->card_status |= ILLEGAL_COMMAND;
1209     fprintf(stderr, "SD: CMD%i in a wrong state\n", req.cmd);
1210     return sd_r0;
1211 }
1212
1213 static sd_rsp_type_t sd_app_command(SDState *sd,
1214                                     SDRequest req) {
1215     uint32_t rca;
1216
1217     if (sd_cmd_type[req.cmd] == sd_ac || sd_cmd_type[req.cmd] == sd_adtc)
1218         rca = req.arg >> 16;
1219
1220     DPRINTF("ACMD%d 0x%08x\n", req.cmd, req.arg);
1221     switch (req.cmd) {
1222     case 6:     /* ACMD6:  SET_BUS_WIDTH */
1223         switch (sd->state) {
1224         case sd_transfer_state:
1225             sd->sd_status[0] &= 0x3f;
1226             sd->sd_status[0] |= (req.arg & 0x03) << 6;
1227             return sd_r1;
1228
1229         default:
1230             break;
1231         }
1232         break;
1233
1234     case 13:    /* ACMD13: SD_STATUS */
1235         switch (sd->state) {
1236         case sd_transfer_state:
1237             sd->data_start = 0;
1238             sd->data_offset = 0;
1239             return sd_r1;
1240
1241         default:
1242             break;
1243         }
1244         break;
1245
1246     case 22:    /* ACMD22: SEND_NUM_WR_BLOCKS */
1247         switch (sd->state) {
1248         case sd_transfer_state:
1249             *(uint32_t *) sd->data = sd->blk_written;
1250
1251             sd->data_start = 0;
1252             sd->data_offset = 0;
1253             return sd_r1;
1254
1255         default:
1256             break;
1257         }
1258         break;
1259
1260     case 23:    /* ACMD23: SET_WR_BLK_ERASE_COUNT */
1261         switch (sd->state) {
1262         case sd_transfer_state:
1263             return sd_r1;
1264
1265         default:
1266             break;
1267         }
1268         break;
1269
1270     case 41:    /* ACMD41: SD_APP_OP_COND */
1271         if (sd->spi) {
1272             /* SEND_OP_CMD */
1273             sd->state = sd_transfer_state;
1274             return sd_r1;
1275         }
1276         switch (sd->state) {
1277         case sd_idle_state:
1278             /* We accept any voltage.  10000 V is nothing.  */
1279             if (req.arg)
1280                 sd->state = sd_ready_state;
1281
1282             return sd_r3;
1283
1284         default:
1285             break;
1286         }
1287         break;
1288
1289     case 42:    /* ACMD42: SET_CLR_CARD_DETECT */
1290         switch (sd->state) {
1291         case sd_transfer_state:
1292             /* Bringing in the 50KOhm pull-up resistor... Done.  */
1293             return sd_r1;
1294
1295         default:
1296             break;
1297         }
1298         break;
1299
1300     case 51:    /* ACMD51: SEND_SCR */
1301         switch (sd->state) {
1302         case sd_transfer_state:
1303             sd->state = sd_sendingdata_state;
1304             sd->data_start = 0;
1305             sd->data_offset = 0;
1306             return sd_r1;
1307
1308         default:
1309             break;
1310         }
1311         break;
1312
1313     default:
1314         /* Fall back to standard commands.  */
1315         sd->card_status &= ~APP_CMD;
1316         return sd_normal_command(sd, req);
1317     }
1318
1319     fprintf(stderr, "SD: ACMD%i in a wrong state\n", req.cmd);
1320     return sd_r0;
1321 }
1322
1323 int sd_do_command(SDState *sd, SDRequest *req,
1324                   uint8_t *response) {
1325     uint32_t last_status = sd->card_status;
1326     sd_rsp_type_t rtype;
1327     int rsplen;
1328
1329     if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable) {
1330         return 0;
1331     }
1332
1333     if (sd_req_crc_validate(req)) {
1334         sd->card_status &= ~COM_CRC_ERROR;
1335         return 0;
1336     }
1337
1338     sd->card_status &= ~CARD_STATUS_B;
1339     sd_set_status(sd);
1340
1341     if (last_status & CARD_IS_LOCKED)
1342         if (((last_status & APP_CMD) &&
1343                                  req->cmd == 41) ||
1344                         (!(last_status & APP_CMD) &&
1345                          (sd_cmd_class[req->cmd] == 0 ||
1346                           sd_cmd_class[req->cmd] == 7 ||
1347                           req->cmd == 16 || req->cmd == 55))) {
1348             sd->card_status |= ILLEGAL_COMMAND;
1349             fprintf(stderr, "SD: Card is locked\n");
1350             return 0;
1351         }
1352
1353     if (last_status & APP_CMD) {
1354         rtype = sd_app_command(sd, *req);
1355         sd->card_status &= ~APP_CMD;
1356     } else
1357         rtype = sd_normal_command(sd, *req);
1358
1359     sd->current_cmd = req->cmd;
1360
1361     switch (rtype) {
1362     case sd_r1:
1363     case sd_r1b:
1364         sd_response_r1_make(sd, response, last_status);
1365         rsplen = 4;
1366         break;
1367
1368     case sd_r2_i:
1369         memcpy(response, sd->cid, sizeof(sd->cid));
1370         rsplen = 16;
1371         break;
1372
1373     case sd_r2_s:
1374         memcpy(response, sd->csd, sizeof(sd->csd));
1375         rsplen = 16;
1376         break;
1377
1378     case sd_r3:
1379         sd_response_r3_make(sd, response);
1380         rsplen = 4;
1381         break;
1382
1383     case sd_r6:
1384         sd_response_r6_make(sd, response);
1385         rsplen = 4;
1386         break;
1387
1388     case sd_r7:
1389         sd_response_r7_make(sd, response);
1390         rsplen = 4;
1391         break;
1392
1393     case sd_r0:
1394     default:
1395         rsplen = 0;
1396         break;
1397     }
1398
1399     if (sd->card_status & ILLEGAL_COMMAND)
1400         rsplen = 0;
1401
1402 #ifdef DEBUG_SD
1403     if (rsplen) {
1404         int i;
1405         DPRINTF("Response:");
1406         for (i = 0; i < rsplen; i++)
1407             fprintf(stderr, " %02x", response[i]);
1408         fprintf(stderr, " state %d\n", sd->state);
1409     } else {
1410         DPRINTF("No response %d\n", sd->state);
1411     }
1412 #endif
1413
1414     return rsplen;
1415 }
1416
1417 /* No real need for 64 bit addresses here */
1418 static void sd_blk_read(SDState *sd, uint32_t addr, uint32_t len)
1419 {
1420     uint32_t end = addr + len;
1421
1422     if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) == -1) {
1423         fprintf(stderr, "sd_blk_read: read error on host side\n");
1424         return;
1425     }
1426
1427     if (end > (addr & ~511) + 512) {
1428         memcpy(sd->data, sd->buf + (addr & 511), 512 - (addr & 511));
1429
1430         if (bdrv_read(sd->bdrv, end >> 9, sd->buf, 1) == -1) {
1431             fprintf(stderr, "sd_blk_read: read error on host side\n");
1432             return;
1433         }
1434         memcpy(sd->data + 512 - (addr & 511), sd->buf, end & 511);
1435     } else
1436         memcpy(sd->data, sd->buf + (addr & 511), len);
1437 }
1438
1439 static void sd_blk_write(SDState *sd, uint32_t addr, uint32_t len)
1440 {
1441     uint32_t end = addr + len;
1442
1443     if ((addr & 511) || len < 512)
1444         if (!sd->bdrv || bdrv_read(sd->bdrv, addr >> 9, sd->buf, 1) == -1) {
1445             fprintf(stderr, "sd_blk_write: read error on host side\n");
1446             return;
1447         }
1448
1449     if (end > (addr & ~511) + 512) {
1450         memcpy(sd->buf + (addr & 511), sd->data, 512 - (addr & 511));
1451         if (bdrv_write(sd->bdrv, addr >> 9, sd->buf, 1) == -1) {
1452             fprintf(stderr, "sd_blk_write: write error on host side\n");
1453             return;
1454         }
1455
1456         if (bdrv_read(sd->bdrv, end >> 9, sd->buf, 1) == -1) {
1457             fprintf(stderr, "sd_blk_write: read error on host side\n");
1458             return;
1459         }
1460         memcpy(sd->buf, sd->data + 512 - (addr & 511), end & 511);
1461         if (bdrv_write(sd->bdrv, end >> 9, sd->buf, 1) == -1)
1462             fprintf(stderr, "sd_blk_write: write error on host side\n");
1463     } else {
1464         memcpy(sd->buf + (addr & 511), sd->data, len);
1465         if (!sd->bdrv || bdrv_write(sd->bdrv, addr >> 9, sd->buf, 1) == -1)
1466             fprintf(stderr, "sd_blk_write: write error on host side\n");
1467     }
1468 }
1469
1470 #define BLK_READ_BLOCK(a, len)  sd_blk_read(sd, a, len)
1471 #define BLK_WRITE_BLOCK(a, len) sd_blk_write(sd, a, len)
1472 #define APP_READ_BLOCK(a, len)  memset(sd->data, 0xec, len)
1473 #define APP_WRITE_BLOCK(a, len)
1474
1475 void sd_write_data(SDState *sd, uint8_t value)
1476 {
1477     int i;
1478
1479     if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable)
1480         return;
1481
1482     if (sd->state != sd_receivingdata_state) {
1483         fprintf(stderr, "sd_write_data: not in Receiving-Data state\n");
1484         return;
1485     }
1486
1487     if (sd->card_status & (ADDRESS_ERROR | WP_VIOLATION))
1488         return;
1489
1490     switch (sd->current_cmd) {
1491     case 24:    /* CMD24:  WRITE_SINGLE_BLOCK */
1492         sd->data[sd->data_offset ++] = value;
1493         if (sd->data_offset >= sd->blk_len) {
1494             /* TODO: Check CRC before committing */
1495             sd->state = sd_programming_state;
1496             BLK_WRITE_BLOCK(sd->data_start, sd->data_offset);
1497             sd->blk_written ++;
1498             sd->csd[14] |= 0x40;
1499             /* Bzzzzzzztt .... Operation complete.  */
1500             sd->state = sd_transfer_state;
1501         }
1502         break;
1503
1504     case 25:    /* CMD25:  WRITE_MULTIPLE_BLOCK */
1505         sd->data[sd->data_offset ++] = value;
1506         if (sd->data_offset >= sd->blk_len) {
1507             /* TODO: Check CRC before committing */
1508             sd->state = sd_programming_state;
1509             BLK_WRITE_BLOCK(sd->data_start, sd->data_offset);
1510             sd->blk_written ++;
1511             sd->data_start += sd->blk_len;
1512             sd->data_offset = 0;
1513             if (sd->data_start + sd->blk_len > sd->size) {
1514                 sd->card_status |= ADDRESS_ERROR;
1515                 break;
1516             }
1517             if (sd_wp_addr(sd, sd->data_start)) {
1518                 sd->card_status |= WP_VIOLATION;
1519                 break;
1520             }
1521             sd->csd[14] |= 0x40;
1522
1523             /* Bzzzzzzztt .... Operation complete.  */
1524             sd->state = sd_receivingdata_state;
1525         }
1526         break;
1527
1528     case 26:    /* CMD26:  PROGRAM_CID */
1529         sd->data[sd->data_offset ++] = value;
1530         if (sd->data_offset >= sizeof(sd->cid)) {
1531             /* TODO: Check CRC before committing */
1532             sd->state = sd_programming_state;
1533             for (i = 0; i < sizeof(sd->cid); i ++)
1534                 if ((sd->cid[i] | 0x00) != sd->data[i])
1535                     sd->card_status |= CID_CSD_OVERWRITE;
1536
1537             if (!(sd->card_status & CID_CSD_OVERWRITE))
1538                 for (i = 0; i < sizeof(sd->cid); i ++) {
1539                     sd->cid[i] |= 0x00;
1540                     sd->cid[i] &= sd->data[i];
1541                 }
1542             /* Bzzzzzzztt .... Operation complete.  */
1543             sd->state = sd_transfer_state;
1544         }
1545         break;
1546
1547     case 27:    /* CMD27:  PROGRAM_CSD */
1548         sd->data[sd->data_offset ++] = value;
1549         if (sd->data_offset >= sizeof(sd->csd)) {
1550             /* TODO: Check CRC before committing */
1551             sd->state = sd_programming_state;
1552             for (i = 0; i < sizeof(sd->csd); i ++)
1553                 if ((sd->csd[i] | sd_csd_rw_mask[i]) !=
1554                     (sd->data[i] | sd_csd_rw_mask[i]))
1555                     sd->card_status |= CID_CSD_OVERWRITE;
1556
1557             /* Copy flag (OTP) & Permanent write protect */
1558             if (sd->csd[14] & ~sd->data[14] & 0x60)
1559                 sd->card_status |= CID_CSD_OVERWRITE;
1560
1561             if (!(sd->card_status & CID_CSD_OVERWRITE))
1562                 for (i = 0; i < sizeof(sd->csd); i ++) {
1563                     sd->csd[i] |= sd_csd_rw_mask[i];
1564                     sd->csd[i] &= sd->data[i];
1565                 }
1566             /* Bzzzzzzztt .... Operation complete.  */
1567             sd->state = sd_transfer_state;
1568         }
1569         break;
1570
1571     case 42:    /* CMD42:  LOCK_UNLOCK */
1572         sd->data[sd->data_offset ++] = value;
1573         if (sd->data_offset >= sd->blk_len) {
1574             /* TODO: Check CRC before committing */
1575             sd->state = sd_programming_state;
1576             sd_lock_command(sd);
1577             /* Bzzzzzzztt .... Operation complete.  */
1578             sd->state = sd_transfer_state;
1579         }
1580         break;
1581
1582     case 56:    /* CMD56:  GEN_CMD */
1583         sd->data[sd->data_offset ++] = value;
1584         if (sd->data_offset >= sd->blk_len) {
1585             APP_WRITE_BLOCK(sd->data_start, sd->data_offset);
1586             sd->state = sd_transfer_state;
1587         }
1588         break;
1589
1590     default:
1591         fprintf(stderr, "sd_write_data: unknown command\n");
1592         break;
1593     }
1594 }
1595
1596 uint8_t sd_read_data(SDState *sd)
1597 {
1598     /* TODO: Append CRCs */
1599     uint8_t ret;
1600
1601     if (!sd->bdrv || !bdrv_is_inserted(sd->bdrv) || !sd->enable)
1602         return 0x00;
1603
1604     if (sd->state != sd_sendingdata_state) {
1605         fprintf(stderr, "sd_read_data: not in Sending-Data state (state=%d)\n", sd->state);
1606         return 0x00;
1607     }
1608
1609     if (sd->card_status & (ADDRESS_ERROR | WP_VIOLATION))
1610         return 0x00;
1611
1612     switch (sd->current_cmd) {
1613     case 6:     /* CMD6:   SWITCH_FUNCTION */
1614         ret = sd->data[sd->data_offset ++];
1615
1616         if (sd->data_offset >= 64)
1617             sd->state = sd_transfer_state;
1618         break;
1619
1620     case 9:     /* CMD9:   SEND_CSD */
1621     case 10:    /* CMD10:  SEND_CID */
1622         ret = sd->data[sd->data_offset ++];
1623
1624         if (sd->data_offset >= 16)
1625             sd->state = sd_transfer_state;
1626         break;
1627
1628     case 11:    /* CMD11:  READ_DAT_UNTIL_STOP */
1629         if (sd->data_offset == 0)
1630             BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1631         ret = sd->data[sd->data_offset ++];
1632
1633         if (sd->data_offset >= sd->blk_len) {
1634             sd->data_start += sd->blk_len;
1635             sd->data_offset = 0;
1636             if (sd->data_start + sd->blk_len > sd->size) {
1637                 sd->card_status |= ADDRESS_ERROR;
1638                 break;
1639             }
1640         }
1641         break;
1642
1643     case 13:    /* ACMD13: SD_STATUS */
1644         ret = sd->sd_status[sd->data_offset ++];
1645
1646         if (sd->data_offset >= sizeof(sd->sd_status))
1647             sd->state = sd_transfer_state;
1648         break;
1649
1650     case 17:    /* CMD17:  READ_SINGLE_BLOCK */
1651         if (sd->data_offset == 0)
1652             BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1653         ret = sd->data[sd->data_offset ++];
1654
1655         if (sd->data_offset >= sd->blk_len)
1656             sd->state = sd_transfer_state;
1657         break;
1658
1659     case 18:    /* CMD18:  READ_MULTIPLE_BLOCK */
1660         if (sd->data_offset == 0)
1661             BLK_READ_BLOCK(sd->data_start, sd->blk_len);
1662         ret = sd->data[sd->data_offset ++];
1663
1664         if (sd->data_offset >= sd->blk_len) {
1665             sd->data_start += sd->blk_len;
1666             sd->data_offset = 0;
1667             if (sd->data_start + sd->blk_len > sd->size) {
1668                 sd->card_status |= ADDRESS_ERROR;
1669                 break;
1670             }
1671         }
1672         break;
1673
1674     case 22:    /* ACMD22: SEND_NUM_WR_BLOCKS */
1675         ret = sd->data[sd->data_offset ++];
1676
1677         if (sd->data_offset >= 4)
1678             sd->state = sd_transfer_state;
1679         break;
1680
1681     case 30:    /* CMD30:  SEND_WRITE_PROT */
1682         ret = sd->data[sd->data_offset ++];
1683
1684         if (sd->data_offset >= 4)
1685             sd->state = sd_transfer_state;
1686         break;
1687
1688     case 51:    /* ACMD51: SEND_SCR */
1689         ret = sd->scr[sd->data_offset ++];
1690
1691         if (sd->data_offset >= sizeof(sd->scr))
1692             sd->state = sd_transfer_state;
1693         break;
1694
1695     case 56:    /* CMD56:  GEN_CMD */
1696         if (sd->data_offset == 0)
1697             APP_READ_BLOCK(sd->data_start, sd->blk_len);
1698         ret = sd->data[sd->data_offset ++];
1699
1700         if (sd->data_offset >= sd->blk_len)
1701             sd->state = sd_transfer_state;
1702         break;
1703
1704     default:
1705         fprintf(stderr, "sd_read_data: unknown command\n");
1706         return 0x00;
1707     }
1708
1709     return ret;
1710 }
1711
1712 int sd_data_ready(SDState *sd)
1713 {
1714     return sd->state == sd_sendingdata_state;
1715 }
1716
1717 void sd_enable(SDState *sd, int enable)
1718 {
1719     sd->enable = enable;
1720 }