← Back to branch summary

~ubuntu-branches/ubuntu/trusty/qemu/trusty

« back to all changes in this revision

Viewing changes to .pc/ubuntu/linaro/0003-sd-Allow-sd_init-callers-to-specify-whether-card-is-.patch/hw/sd/sd.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-04 12:13:08 UTC
  • mfrom: (10.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140204121308-1xq92lrfs75agw2g
Tags: 1.7.0+dfsg-3ubuntu1~ppa1
* Merge 1.7.0+dfsg-3 from debian.  Remaining changes:
  - debian/patches/ubuntu:
    * expose-vmx_qemu64cpu.patch
    * linaro (omap3) and arm64 patches
    * ubuntu/target-ppc-add-stubs-for-kvm-breakpoints: fix FTBFS
      on ppc
    * ubuntu/CVE-2013-4377.patch: fix denial of service via virtio
  - debian/qemu-system-x86.modprobe: set kvm_intel nested=1 options
  - debian/control:
    * add arm64 to Architectures
    * add qemu-common and qemu-system-aarch64 packages
  - debian/qemu-system-common.install: add debian/tmp/usr/lib
  - debian/qemu-system-common.preinst: add kvm group
  - debian/qemu-system-common.postinst: remove acl placed by udev,
    and add udevadm trigger.
  - qemu-system-x86.links: add eepro100.rom, remove pxe-virtio,
    pxe-e1000 and pxe-rtl8139.
  - add qemu-system-x86.qemu-kvm.upstart and .default
  - qemu-user-static.postinst-in: remove arm64 binfmt
  - debian/rules:
    * allow parallel build
    * add aarch64 to system_targets and sys_systems
    * add qemu-kvm-spice links
    * install qemu-system-x86.modprobe
  - add debian/qemu-system-common.links for OVMF.fd link
* Remove kvm-img, kvm-nbd, kvm-ifup and kvm-ifdown symlinks.

Show diffs side-by-side

added added

removed removed

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