← Back to branch summary

~vcs-imports/qemu/git

« back to all changes in this revision

Viewing changes to hw/sd.c

  • Committer: pbrook
  • Date: 2006-10-22 00:18:54 UTC
  • Revision ID: git-v1:e6e5906b6e0a81718066ca43aef57515026c6624
ColdFire target.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@2196 c046a42c-6fe2-441c-8c8c-71466251a162

Show diffs side-by-side

added added

removed removed

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