← Back to branch summary

~ubuntu-branches/ubuntu/vivid/qemu/vivid

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-02-25 22:31:43 UTC
  • mfrom: (1.8.5)
  • Revision ID: package-import@ubuntu.com-20140225223143-odhqxfc60wxrjl15
Tags: 2.0.0~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/1294823
https://launchpad.net/bugs/1295072
* Merge 2.0.0-rc1
* debian/rules: consolidate ppc filter entries.
* Move qemu-system-arch64 into qemu-system-arm
* debian/patches/define-trusty-machine-type.patch: define a trusty machine
  type, currently the same as pc-i440fx-2.0, to put is in a better position
  to enable live migrations from trusty onward.  (LP: #1294823)
* debian/control: build-dep on libfdt >= 1.4.0  (LP: #1295072)
* Merge latest upstream git to commit dc9528f
* Debian/rules:
  - remove -enable-uname-release=2.6.32
  - don't make the aarch64 target Ubuntu-specific.
* Remove patches which are now upstream:
  - fix-smb-security-share.patch
  - slirp-smb-redirect-port-445-too.patch 
  - linux-user-Implement-sendmmsg-syscall.patch (better version is upstream)
  - signal-added-a-wrapper-for-sigprocmask-function.patch
  - ubuntu/signal-sigsegv-protection-on-do_sigprocmask.patch
  - ubuntu/Don-t-block-SIGSEGV-at-more-places.patch
  - ubuntu/ppc-force-cpu-threads-count-to-be-power-of-2.patch
* add link for /usr/share/qemu/bios-256k.bin
* Remove all linaro patches.
* Remove all arm64/ patches.  Many but not all are upstream.
* Remove CVE-2013-4377.patch which is upstream.
* debian/control-in: don't make qemu-system-aarch64 ubuntu-specific

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/ubuntu/linaro/0003-sd-Allow-sd_init-callers-to-specify-whether-card-is-.patch/hw/sd/ssi-sd.c
1
 
/*
2
 
 * SSI to SD card adapter.
3
 
 *
4
 
 * Copyright (c) 2007-2009 CodeSourcery.
5
 
 * Written by Paul Brook
6
 
 *
7
 
 * This code is licensed under the GNU GPL v2.
8
 
 *
9
 
 * Contributions after 2012-01-13 are licensed under the terms of the
10
 
 * GNU GPL, version 2 or (at your option) any later version.
11
 
 */
12
 
 
13
 
#include "sysemu/blockdev.h"
14
 
#include "hw/ssi.h"
15
 
#include "hw/sd.h"
16
 
 
17
 
//#define DEBUG_SSI_SD 1
18
 
 
19
 
#ifdef DEBUG_SSI_SD
20
 
#define DPRINTF(fmt, ...) \
21
 
do { printf("ssi_sd: " fmt , ## __VA_ARGS__); } while (0)
22
 
#define BADF(fmt, ...) \
23
 
do { fprintf(stderr, "ssi_sd: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
24
 
#else
25
 
#define DPRINTF(fmt, ...) do {} while(0)
26
 
#define BADF(fmt, ...) \
27
 
do { fprintf(stderr, "ssi_sd: error: " fmt , ## __VA_ARGS__);} while (0)
28
 
#endif
29
 
 
30
 
typedef enum {
31
 
    SSI_SD_CMD,
32
 
    SSI_SD_CMDARG,
33
 
    SSI_SD_RESPONSE,
34
 
    SSI_SD_DATA_START,
35
 
    SSI_SD_DATA_READ,
36
 
} ssi_sd_mode;
37
 
 
38
 
typedef struct {
39
 
    SSISlave ssidev;
40
 
    ssi_sd_mode mode;
41
 
    int cmd;
42
 
    uint8_t cmdarg[4];
43
 
    uint8_t response[5];
44
 
    int arglen;
45
 
    int response_pos;
46
 
    int stopping;
47
 
    SDState *sd;
48
 
} ssi_sd_state;
49
 
 
50
 
/* State word bits.  */
51
 
#define SSI_SDR_LOCKED          0x0001
52
 
#define SSI_SDR_WP_ERASE        0x0002
53
 
#define SSI_SDR_ERROR           0x0004
54
 
#define SSI_SDR_CC_ERROR        0x0008
55
 
#define SSI_SDR_ECC_FAILED      0x0010
56
 
#define SSI_SDR_WP_VIOLATION    0x0020
57
 
#define SSI_SDR_ERASE_PARAM     0x0040
58
 
#define SSI_SDR_OUT_OF_RANGE    0x0080
59
 
#define SSI_SDR_IDLE            0x0100
60
 
#define SSI_SDR_ERASE_RESET     0x0200
61
 
#define SSI_SDR_ILLEGAL_COMMAND 0x0400
62
 
#define SSI_SDR_COM_CRC_ERROR   0x0800
63
 
#define SSI_SDR_ERASE_SEQ_ERROR 0x1000
64
 
#define SSI_SDR_ADDRESS_ERROR   0x2000
65
 
#define SSI_SDR_PARAMETER_ERROR 0x4000
66
 
 
67
 
static uint32_t ssi_sd_transfer(SSISlave *dev, uint32_t val)
68
 
{
69
 
    ssi_sd_state *s = FROM_SSI_SLAVE(ssi_sd_state, dev);
70
 
 
71
 
    /* Special case: allow CMD12 (STOP TRANSMISSION) while reading data.  */
72
 
    if (s->mode == SSI_SD_DATA_READ && val == 0x4d) {
73
 
        s->mode = SSI_SD_CMD;
74
 
        /* There must be at least one byte delay before the card responds.  */
75
 
        s->stopping = 1;
76
 
    }
77
 
 
78
 
    switch (s->mode) {
79
 
    case SSI_SD_CMD:
80
 
        if (val == 0xff) {
81
 
            DPRINTF("NULL command\n");
82
 
            return 0xff;
83
 
        }
84
 
        s->cmd = val & 0x3f;
85
 
        s->mode = SSI_SD_CMDARG;
86
 
        s->arglen = 0;
87
 
        return 0xff;
88
 
    case SSI_SD_CMDARG:
89
 
        if (s->arglen == 4) {
90
 
            SDRequest request;
91
 
            uint8_t longresp[16];
92
 
            /* FIXME: Check CRC.  */
93
 
            request.cmd = s->cmd;
94
 
            request.arg = (s->cmdarg[0] << 24) | (s->cmdarg[1] << 16)
95
 
                           | (s->cmdarg[2] << 8) | s->cmdarg[3];
96
 
            DPRINTF("CMD%d arg 0x%08x\n", s->cmd, request.arg);
97
 
            s->arglen = sd_do_command(s->sd, &request, longresp);
98
 
            if (s->arglen <= 0) {
99
 
                s->arglen = 1;
100
 
                s->response[0] = 4;
101
 
                DPRINTF("SD command failed\n");
102
 
            } else if (s->cmd == 58) {
103
 
                /* CMD58 returns R3 response (OCR)  */
104
 
                DPRINTF("Returned OCR\n");
105
 
                s->arglen = 5;
106
 
                s->response[0] = 1;
107
 
                memcpy(&s->response[1], longresp, 4);
108
 
            } else if (s->arglen != 4) {
109
 
                BADF("Unexpected response to cmd %d\n", s->cmd);
110
 
                /* Illegal command is about as near as we can get.  */
111
 
                s->arglen = 1;
112
 
                s->response[0] = 4;
113
 
            } else {
114
 
                /* All other commands return status.  */
115
 
                uint32_t cardstatus;
116
 
                uint16_t status;
117
 
                /* CMD13 returns a 2-byte statuse work. Other commands
118
 
                   only return the first byte.  */
119
 
                s->arglen = (s->cmd == 13) ? 2 : 1;
120
 
                cardstatus = (longresp[0] << 24) | (longresp[1] << 16)
121
 
                             | (longresp[2] << 8) | longresp[3];
122
 
                status = 0;
123
 
                if (((cardstatus >> 9) & 0xf) < 4)
124
 
                    status |= SSI_SDR_IDLE;
125
 
                if (cardstatus & ERASE_RESET)
126
 
                    status |= SSI_SDR_ERASE_RESET;
127
 
                if (cardstatus & ILLEGAL_COMMAND)
128
 
                    status |= SSI_SDR_ILLEGAL_COMMAND;
129
 
                if (cardstatus & COM_CRC_ERROR)
130
 
                    status |= SSI_SDR_COM_CRC_ERROR;
131
 
                if (cardstatus & ERASE_SEQ_ERROR)
132
 
                    status |= SSI_SDR_ERASE_SEQ_ERROR;
133
 
                if (cardstatus & ADDRESS_ERROR)
134
 
                    status |= SSI_SDR_ADDRESS_ERROR;
135
 
                if (cardstatus & CARD_IS_LOCKED)
136
 
                    status |= SSI_SDR_LOCKED;
137
 
                if (cardstatus & (LOCK_UNLOCK_FAILED | WP_ERASE_SKIP))
138
 
                    status |= SSI_SDR_WP_ERASE;
139
 
                if (cardstatus & SD_ERROR)
140
 
                    status |= SSI_SDR_ERROR;
141
 
                if (cardstatus & CC_ERROR)
142
 
                    status |= SSI_SDR_CC_ERROR;
143
 
                if (cardstatus & CARD_ECC_FAILED)
144
 
                    status |= SSI_SDR_ECC_FAILED;
145
 
                if (cardstatus & WP_VIOLATION)
146
 
                    status |= SSI_SDR_WP_VIOLATION;
147
 
                if (cardstatus & ERASE_PARAM)
148
 
                    status |= SSI_SDR_ERASE_PARAM;
149
 
                if (cardstatus & (OUT_OF_RANGE | CID_CSD_OVERWRITE))
150
 
                    status |= SSI_SDR_OUT_OF_RANGE;
151
 
                /* ??? Don't know what Parameter Error really means, so
152
 
                   assume it's set if the second byte is nonzero.  */
153
 
                if (status & 0xff)
154
 
                    status |= SSI_SDR_PARAMETER_ERROR;
155
 
                s->response[0] = status >> 8;
156
 
                s->response[1] = status;
157
 
                DPRINTF("Card status 0x%02x\n", status);
158
 
            }
159
 
            s->mode = SSI_SD_RESPONSE;
160
 
            s->response_pos = 0;
161
 
        } else {
162
 
            s->cmdarg[s->arglen++] = val;
163
 
        }
164
 
        return 0xff;
165
 
    case SSI_SD_RESPONSE:
166
 
        if (s->stopping) {
167
 
            s->stopping = 0;
168
 
            return 0xff;
169
 
        }
170
 
        if (s->response_pos < s->arglen) {
171
 
            DPRINTF("Response 0x%02x\n", s->response[s->response_pos]);
172
 
            return s->response[s->response_pos++];
173
 
        }
174
 
        if (sd_data_ready(s->sd)) {
175
 
            DPRINTF("Data read\n");
176
 
            s->mode = SSI_SD_DATA_START;
177
 
        } else {
178
 
            DPRINTF("End of command\n");
179
 
            s->mode = SSI_SD_CMD;
180
 
        }
181
 
        return 0xff;
182
 
    case SSI_SD_DATA_START:
183
 
        DPRINTF("Start read block\n");
184
 
        s->mode = SSI_SD_DATA_READ;
185
 
        return 0xfe;
186
 
    case SSI_SD_DATA_READ:
187
 
        val = sd_read_data(s->sd);
188
 
        if (!sd_data_ready(s->sd)) {
189
 
            DPRINTF("Data read end\n");
190
 
            s->mode = SSI_SD_CMD;
191
 
        }
192
 
        return val;
193
 
    }
194
 
    /* Should never happen.  */
195
 
    return 0xff;
196
 
}
197
 
 
198
 
static void ssi_sd_save(QEMUFile *f, void *opaque)
199
 
{
200
 
    SSISlave *ss = SSI_SLAVE(opaque);
201
 
    ssi_sd_state *s = (ssi_sd_state *)opaque;
202
 
    int i;
203
 
 
204
 
    qemu_put_be32(f, s->mode);
205
 
    qemu_put_be32(f, s->cmd);
206
 
    for (i = 0; i < 4; i++)
207
 
        qemu_put_be32(f, s->cmdarg[i]);
208
 
    for (i = 0; i < 5; i++)
209
 
        qemu_put_be32(f, s->response[i]);
210
 
    qemu_put_be32(f, s->arglen);
211
 
    qemu_put_be32(f, s->response_pos);
212
 
    qemu_put_be32(f, s->stopping);
213
 
 
214
 
    qemu_put_be32(f, ss->cs);
215
 
}
216
 
 
217
 
static int ssi_sd_load(QEMUFile *f, void *opaque, int version_id)
218
 
{
219
 
    SSISlave *ss = SSI_SLAVE(opaque);
220
 
    ssi_sd_state *s = (ssi_sd_state *)opaque;
221
 
    int i;
222
 
 
223
 
    if (version_id != 1)
224
 
        return -EINVAL;
225
 
 
226
 
    s->mode = qemu_get_be32(f);
227
 
    s->cmd = qemu_get_be32(f);
228
 
    for (i = 0; i < 4; i++)
229
 
        s->cmdarg[i] = qemu_get_be32(f);
230
 
    for (i = 0; i < 5; i++)
231
 
        s->response[i] = qemu_get_be32(f);
232
 
    s->arglen = qemu_get_be32(f);
233
 
    s->response_pos = qemu_get_be32(f);
234
 
    s->stopping = qemu_get_be32(f);
235
 
 
236
 
    ss->cs = qemu_get_be32(f);
237
 
 
238
 
    return 0;
239
 
}
240
 
 
241
 
static int ssi_sd_init(SSISlave *dev)
242
 
{
243
 
    ssi_sd_state *s = FROM_SSI_SLAVE(ssi_sd_state, dev);
244
 
    DriveInfo *dinfo;
245
 
 
246
 
    s->mode = SSI_SD_CMD;
247
 
    dinfo = drive_get_next(IF_SD);
248
 
    s->sd = sd_init(dinfo ? dinfo->bdrv : NULL, true);
249
 
    if (s->sd == NULL) {
250
 
        return -1;
251
 
    }
252
 
    register_savevm(&dev->qdev, "ssi_sd", -1, 1, ssi_sd_save, ssi_sd_load, s);
253
 
    return 0;
254
 
}
255
 
 
256
 
static void ssi_sd_class_init(ObjectClass *klass, void *data)
257
 
{
258
 
    SSISlaveClass *k = SSI_SLAVE_CLASS(klass);
259
 
 
260
 
    k->init = ssi_sd_init;
261
 
    k->transfer = ssi_sd_transfer;
262
 
    k->cs_polarity = SSI_CS_LOW;
263
 
}
264
 
 
265
 
static const TypeInfo ssi_sd_info = {
266
 
    .name          = "ssi-sd",
267
 
    .parent        = TYPE_SSI_SLAVE,
268
 
    .instance_size = sizeof(ssi_sd_state),
269
 
    .class_init    = ssi_sd_class_init,
270
 
};
271
 
 
272
 
static void ssi_sd_register_types(void)
273
 
{
274
 
    type_register_static(&ssi_sd_info);
275
 
}
276
 
 
277
 
type_init(ssi_sd_register_types)