← Back to branch summary

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

« back to all changes in this revision

Viewing changes to .pc/linaro-patches-1.5.0/0004-hw-sd.c-Add-MMC-emulation-support.patch/hw/sd/sd.c

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2013-10-22 22:47:07 UTC
  • mfrom: (1.8.3) (10.1.42 sid)
  • Revision ID: package-import@ubuntu.com-20131022224707-1lya34fw3k3f24tv
Tags: 1.6.0+dfsg-2ubuntu1
http://bugs.debian.org/709241
* Merge 1.6.0~rc0+dfsg-2exp from debian experimental.  Remaining changes:
  - debian/control
    * update maintainer
    * remove libiscsi, usb-redir, vde, vnc-jpeg, and libssh2-1-dev
      from build-deps
    * enable rbd
    * add qemu-system and qemu-common B/R to qemu-keymaps
    * add D:udev, R:qemu, R:qemu-common and B:qemu-common to
      qemu-system-common
    * qemu-system-arm, qemu-system-ppc, qemu-system-sparc:
      - add qemu-kvm to Provides
      - add qemu-common, qemu-kvm, kvm to B/R
      - remove openbios-sparc from qemu-system-sparc D
      - drop openbios-ppc and openhackware Depends to Suggests (for now)
    * qemu-system-x86:
      - add qemu-common to Breaks/Replaces.
      - add cpu-checker to Recommends.
    * qemu-user: add B/R:qemu-kvm
    * qemu-kvm:
      - add armhf armel powerpc sparc to Architecture
      - C/R/P: qemu-kvm-spice
    * add qemu-common package
    * drop qemu-slof which is not packaged in ubuntu
  - add qemu-system-common.links for tap ifup/down scripts and OVMF link.
  - qemu-system-x86.links:
    * remove pxe rom links which are in kvm-ipxe
    * add symlink for kvm.1 manpage
  - debian/rules
    * add kvm-spice symlink to qemu-kvm
    * call dh_installmodules for qemu-system-x86
    * update dh_installinit to install upstart script
    * run dh_installman (Closes: #709241) (cherrypicked from 1.5.0+dfsg-2)
  - Add qemu-utils.links for kvm-* symlinks.
  - Add qemu-system-x86.qemu-kvm.upstart and .default
  - Add qemu-system-x86.modprobe to set nesting=1
  - Add qemu-system-common.preinst to add kvm group
  - qemu-system-common.postinst: remove bad group acl if there, then have
    udev relabel /dev/kvm.
  - New linaro patches from qemu-linaro rebasing branch
  - Dropped patches:
    * xen-simplify-xen_enabled.patch
    * sparc-linux-user-fix-missing-symbols-in-.rel-.rela.plt-sections.patch
    * main_loop-do-not-set-nonblocking-if-xen_enabled.patch
    * xen_machine_pv-do-not-create-a-dummy-CPU-in-machine-.patch
    * virtio-rng-fix-crash
  - Kept patches:
    * expose_vms_qemu64cpu.patch - updated
    * linaro arm patches from qemu-linaro rebasing branch
  - New patches:
    * fix-pci-add: change CONFIG variable in ifdef to make sure that
      pci_add is defined.
* Add linaro patches
* Add experimental mach-virt patches for arm virtualization.
* qemu-system-common.install: add debian/tmp/usr/lib to install the
  qemu-bridge-helper

Show diffs side-by-side

added added

removed removed

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