esp.c 17.3 KB
Newer Older
B
bellard 已提交
1
/*
2
 * QEMU ESP/NCR53C9x emulation
3
 *
P
pbrook 已提交
4
 * Copyright (c) 2005-2006 Fabrice Bellard
5
 *
B
bellard 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
P
pbrook 已提交
24 25 26 27 28 29
#include "hw.h"
#include "block.h"
#include "scsi-disk.h"
#include "sun4m.h"
/* FIXME: Only needed for MAX_DISKS, which is probably wrong.  */
#include "sysemu.h"
B
bellard 已提交
30 31

/* debug ESP card */
B
bellard 已提交
32
//#define DEBUG_ESP
B
bellard 已提交
33

34
/*
35 36
 * On Sparc32, this is the ESP (NCR53C90) part of chip STP2000 (Master I/O),
 * also produced as NCR89C100. See
37 38 39 40 41
 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C100.txt
 * and
 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR53C9X.txt
 */

B
bellard 已提交
42 43 44 45 46 47 48
#ifdef DEBUG_ESP
#define DPRINTF(fmt, args...) \
do { printf("ESP: " fmt , ##args); } while (0)
#else
#define DPRINTF(fmt, args...)
#endif

B
blueswir1 已提交
49 50 51
#define ESP_MASK 0x3f
#define ESP_REGS 16
#define ESP_SIZE (ESP_REGS * 4)
P
pbrook 已提交
52
#define TI_BUFSZ 32
53

P
pbrook 已提交
54
typedef struct ESPState ESPState;
B
bellard 已提交
55

P
pbrook 已提交
56
struct ESPState {
57
    qemu_irq irq;
B
blueswir1 已提交
58 59
    uint8_t rregs[ESP_REGS];
    uint8_t wregs[ESP_REGS];
60
    int32_t ti_size;
61 62
    uint32_t ti_rptr, ti_wptr;
    uint8_t ti_buf[TI_BUFSZ];
P
pbrook 已提交
63
    int sense;
64
    int dma;
T
ths 已提交
65
    SCSIDevice *scsi_dev[ESP_MAX_DEVS];
P
pbrook 已提交
66
    SCSIDevice *current_dev;
P
pbrook 已提交
67 68 69
    uint8_t cmdbuf[TI_BUFSZ];
    int cmdlen;
    int do_cmd;
P
pbrook 已提交
70

P
pbrook 已提交
71
    /* The amount of data left in the current DMA transfer.  */
P
pbrook 已提交
72
    uint32_t dma_left;
P
pbrook 已提交
73 74 75
    /* The size of the current DMA transfer.  Zero if no transfer is in
       progress.  */
    uint32_t dma_counter;
P
pbrook 已提交
76
    uint8_t *async_buf;
P
pbrook 已提交
77
    uint32_t async_len;
78
    void *dma_opaque;
P
pbrook 已提交
79
};
B
bellard 已提交
80

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
#define ESP_TCLO   0x0
#define ESP_TCMID  0x1
#define ESP_FIFO   0x2
#define ESP_CMD    0x3
#define ESP_RSTAT  0x4
#define ESP_WBUSID 0x4
#define ESP_RINTR  0x5
#define ESP_WSEL   0x5
#define ESP_RSEQ   0x6
#define ESP_WSYNTP 0x6
#define ESP_RFLAGS 0x7
#define ESP_WSYNO  0x7
#define ESP_CFG1   0x8
#define ESP_RRES1  0x9
#define ESP_WCCF   0x9
#define ESP_RRES2  0xa
#define ESP_WTEST  0xa
#define ESP_CFG2   0xb
#define ESP_CFG3   0xc
#define ESP_RES3   0xd
#define ESP_TCHI   0xe
#define ESP_RES4   0xf

#define CMD_DMA 0x80
#define CMD_CMD 0x7f

#define CMD_NOP      0x00
#define CMD_FLUSH    0x01
#define CMD_RESET    0x02
#define CMD_BUSRESET 0x03
#define CMD_TI       0x10
#define CMD_ICCS     0x11
#define CMD_MSGACC   0x12
#define CMD_SATN     0x1a
#define CMD_SELATN   0x42
#define CMD_SELATNS  0x43
#define CMD_ENSEL    0x44

B
bellard 已提交
119 120 121 122 123 124
#define STAT_DO 0x00
#define STAT_DI 0x01
#define STAT_CD 0x02
#define STAT_ST 0x03
#define STAT_MI 0x06
#define STAT_MO 0x07
125
#define STAT_PIO_MASK 0x06
B
bellard 已提交
126 127

#define STAT_TC 0x10
P
pbrook 已提交
128 129
#define STAT_PE 0x20
#define STAT_GE 0x40
B
bellard 已提交
130 131 132 133 134
#define STAT_IN 0x80

#define INTR_FC 0x08
#define INTR_BS 0x10
#define INTR_DC 0x20
B
bellard 已提交
135
#define INTR_RST 0x80
B
bellard 已提交
136 137 138 139

#define SEQ_0 0x0
#define SEQ_CD 0x4

140 141 142 143 144 145
#define CFG1_RESREPT 0x40

#define CFG2_MASK 0x15

#define TCHI_FAS100A 0x4

P
pbrook 已提交
146
static int get_cmd(ESPState *s, uint8_t *buf)
B
bellard 已提交
147
{
P
pbrook 已提交
148
    uint32_t dmalen;
B
bellard 已提交
149 150
    int target;

151 152
    dmalen = s->rregs[ESP_TCLO] | (s->rregs[ESP_TCMID] << 8);
    target = s->wregs[ESP_WBUSID] & 7;
P
pbrook 已提交
153
    DPRINTF("get_cmd: len %d target %d\n", dmalen, target);
154
    if (s->dma) {
155
        espdma_memory_read(s->dma_opaque, buf, dmalen);
156
    } else {
B
blueswir1 已提交
157 158 159
        buf[0] = 0;
        memcpy(&buf[1], s->ti_buf, dmalen);
        dmalen++;
160
    }
P
pbrook 已提交
161

B
bellard 已提交
162
    s->ti_size = 0;
163 164
    s->ti_rptr = 0;
    s->ti_wptr = 0;
B
bellard 已提交
165

P
pbrook 已提交
166 167
    if (s->current_dev) {
        /* Started a new command before the old one finished.  Cancel it.  */
T
ths 已提交
168
        s->current_dev->cancel_io(s->current_dev, 0);
P
pbrook 已提交
169 170 171
        s->async_len = 0;
    }

T
ths 已提交
172
    if (target >= ESP_MAX_DEVS || !s->scsi_dev[target]) {
P
pbrook 已提交
173
        // No such drive
174 175 176
        s->rregs[ESP_RSTAT] = STAT_IN;
        s->rregs[ESP_RINTR] = INTR_DC;
        s->rregs[ESP_RSEQ] = SEQ_0;
B
blueswir1 已提交
177 178
        qemu_irq_raise(s->irq);
        return 0;
B
bellard 已提交
179
    }
P
pbrook 已提交
180
    s->current_dev = s->scsi_dev[target];
P
pbrook 已提交
181 182 183 184 185 186 187 188 189 190
    return dmalen;
}

static void do_cmd(ESPState *s, uint8_t *buf)
{
    int32_t datalen;
    int lun;

    DPRINTF("do_cmd: busid 0x%x\n", buf[0]);
    lun = buf[0] & 7;
T
ths 已提交
191
    datalen = s->current_dev->send_command(s->current_dev, 0, &buf[1], lun);
192 193
    s->ti_size = datalen;
    if (datalen != 0) {
194
        s->rregs[ESP_RSTAT] = STAT_IN | STAT_TC;
P
pbrook 已提交
195
        s->dma_left = 0;
P
pbrook 已提交
196
        s->dma_counter = 0;
P
pbrook 已提交
197
        if (datalen > 0) {
198
            s->rregs[ESP_RSTAT] |= STAT_DI;
T
ths 已提交
199
            s->current_dev->read_data(s->current_dev, 0);
P
pbrook 已提交
200
        } else {
201
            s->rregs[ESP_RSTAT] |= STAT_DO;
T
ths 已提交
202
            s->current_dev->write_data(s->current_dev, 0);
B
bellard 已提交
203
        }
B
bellard 已提交
204
    }
205 206
    s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
    s->rregs[ESP_RSEQ] = SEQ_CD;
207
    qemu_irq_raise(s->irq);
B
bellard 已提交
208 209
}

P
pbrook 已提交
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
static void handle_satn(ESPState *s)
{
    uint8_t buf[32];
    int len;

    len = get_cmd(s, buf);
    if (len)
        do_cmd(s, buf);
}

static void handle_satn_stop(ESPState *s)
{
    s->cmdlen = get_cmd(s, s->cmdbuf);
    if (s->cmdlen) {
        DPRINTF("Set ATN & Stop: cmdlen %d\n", s->cmdlen);
        s->do_cmd = 1;
226 227 228
        s->rregs[ESP_RSTAT] = STAT_IN | STAT_TC | STAT_CD;
        s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
        s->rregs[ESP_RSEQ] = SEQ_CD;
229
        qemu_irq_raise(s->irq);
P
pbrook 已提交
230 231 232
    }
}

P
pbrook 已提交
233
static void write_response(ESPState *s)
B
bellard 已提交
234
{
P
pbrook 已提交
235 236 237
    DPRINTF("Transfer status (sense=%d)\n", s->sense);
    s->ti_buf[0] = s->sense;
    s->ti_buf[1] = 0;
238
    if (s->dma) {
239
        espdma_memory_write(s->dma_opaque, s->ti_buf, 2);
240 241 242
        s->rregs[ESP_RSTAT] = STAT_IN | STAT_TC | STAT_ST;
        s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
        s->rregs[ESP_RSEQ] = SEQ_CD;
243
    } else {
B
blueswir1 已提交
244 245 246
        s->ti_size = 2;
        s->ti_rptr = 0;
        s->ti_wptr = 0;
247
        s->rregs[ESP_RFLAGS] = 2;
248
    }
249
    qemu_irq_raise(s->irq);
B
bellard 已提交
250
}
251

P
pbrook 已提交
252 253
static void esp_dma_done(ESPState *s)
{
254 255 256 257 258 259
    s->rregs[ESP_RSTAT] |= STAT_IN | STAT_TC;
    s->rregs[ESP_RINTR] = INTR_BS;
    s->rregs[ESP_RSEQ] = 0;
    s->rregs[ESP_RFLAGS] = 0;
    s->rregs[ESP_TCLO] = 0;
    s->rregs[ESP_TCMID] = 0;
260
    qemu_irq_raise(s->irq);
P
pbrook 已提交
261 262
}

P
pbrook 已提交
263 264
static void esp_do_dma(ESPState *s)
{
265
    uint32_t len;
P
pbrook 已提交
266
    int to_device;
P
pbrook 已提交
267

268
    to_device = (s->ti_size < 0);
P
pbrook 已提交
269
    len = s->dma_left;
P
pbrook 已提交
270 271
    if (s->do_cmd) {
        DPRINTF("command len %d + %d\n", s->cmdlen, len);
272
        espdma_memory_read(s->dma_opaque, &s->cmdbuf[s->cmdlen], len);
P
pbrook 已提交
273 274 275 276 277
        s->ti_size = 0;
        s->cmdlen = 0;
        s->do_cmd = 0;
        do_cmd(s, s->cmdbuf);
        return;
P
pbrook 已提交
278 279 280 281 282 283 284 285 286
    }
    if (s->async_len == 0) {
        /* Defer until data is available.  */
        return;
    }
    if (len > s->async_len) {
        len = s->async_len;
    }
    if (to_device) {
287
        espdma_memory_read(s->dma_opaque, s->async_buf, len);
P
pbrook 已提交
288
    } else {
289
        espdma_memory_write(s->dma_opaque, s->async_buf, len);
P
pbrook 已提交
290 291 292 293
    }
    s->dma_left -= len;
    s->async_buf += len;
    s->async_len -= len;
P
pbrook 已提交
294 295 296 297
    if (to_device)
        s->ti_size += len;
    else
        s->ti_size -= len;
P
pbrook 已提交
298
    if (s->async_len == 0) {
P
pbrook 已提交
299
        if (to_device) {
300
            // ti_size is negative
T
ths 已提交
301
            s->current_dev->write_data(s->current_dev, 0);
P
pbrook 已提交
302
        } else {
T
ths 已提交
303
            s->current_dev->read_data(s->current_dev, 0);
P
pbrook 已提交
304 305 306 307 308 309
            /* If there is still data to be read from the device then
               complete the DMA operation immeriately.  Otherwise defer
               until the scsi layer has completed.  */
            if (s->dma_left == 0 && s->ti_size > 0) {
                esp_dma_done(s);
            }
P
pbrook 已提交
310
        }
P
pbrook 已提交
311 312
    } else {
        /* Partially filled a scsi buffer. Complete immediately.  */
P
pbrook 已提交
313 314
        esp_dma_done(s);
    }
P
pbrook 已提交
315 316
}

P
pbrook 已提交
317 318
static void esp_command_complete(void *opaque, int reason, uint32_t tag,
                                 uint32_t arg)
P
pbrook 已提交
319 320 321
{
    ESPState *s = (ESPState *)opaque;

P
pbrook 已提交
322 323 324 325 326
    if (reason == SCSI_REASON_DONE) {
        DPRINTF("SCSI Command complete\n");
        if (s->ti_size != 0)
            DPRINTF("SCSI command completed unexpectedly\n");
        s->ti_size = 0;
P
pbrook 已提交
327 328 329
        s->dma_left = 0;
        s->async_len = 0;
        if (arg)
P
pbrook 已提交
330
            DPRINTF("Command failed\n");
P
pbrook 已提交
331
        s->sense = arg;
332
        s->rregs[ESP_RSTAT] = STAT_ST;
P
pbrook 已提交
333 334
        esp_dma_done(s);
        s->current_dev = NULL;
P
pbrook 已提交
335 336
    } else {
        DPRINTF("transfer %d/%d\n", s->dma_left, s->ti_size);
P
pbrook 已提交
337
        s->async_len = arg;
T
ths 已提交
338
        s->async_buf = s->current_dev->get_buf(s->current_dev, 0);
P
pbrook 已提交
339
        if (s->dma_left) {
P
pbrook 已提交
340
            esp_do_dma(s);
P
pbrook 已提交
341 342 343 344 345
        } else if (s->dma_counter != 0 && s->ti_size <= 0) {
            /* If this was the last part of a DMA transfer then the
               completion interrupt is deferred to here.  */
            esp_dma_done(s);
        }
P
pbrook 已提交
346
    }
P
pbrook 已提交
347 348
}

B
bellard 已提交
349 350
static void handle_ti(ESPState *s)
{
P
pbrook 已提交
351
    uint32_t dmalen, minlen;
B
bellard 已提交
352

353
    dmalen = s->rregs[ESP_TCLO] | (s->rregs[ESP_TCMID] << 8);
P
pbrook 已提交
354 355 356
    if (dmalen==0) {
      dmalen=0x10000;
    }
P
pbrook 已提交
357
    s->dma_counter = dmalen;
P
pbrook 已提交
358

P
pbrook 已提交
359 360
    if (s->do_cmd)
        minlen = (dmalen < 32) ? dmalen : 32;
361 362
    else if (s->ti_size < 0)
        minlen = (dmalen < -s->ti_size) ? dmalen : -s->ti_size;
P
pbrook 已提交
363 364
    else
        minlen = (dmalen < s->ti_size) ? dmalen : s->ti_size;
P
pbrook 已提交
365
    DPRINTF("Transfer Information len %d\n", minlen);
366
    if (s->dma) {
P
pbrook 已提交
367
        s->dma_left = minlen;
368
        s->rregs[ESP_RSTAT] &= ~STAT_TC;
P
pbrook 已提交
369
        esp_do_dma(s);
P
pbrook 已提交
370 371 372 373 374 375 376 377
    } else if (s->do_cmd) {
        DPRINTF("command len %d\n", s->cmdlen);
        s->ti_size = 0;
        s->cmdlen = 0;
        s->do_cmd = 0;
        do_cmd(s, s->cmdbuf);
        return;
    }
B
bellard 已提交
378 379
}

B
blueswir1 已提交
380
static void esp_reset(void *opaque)
B
bellard 已提交
381 382
{
    ESPState *s = opaque;
383

B
blueswir1 已提交
384 385
    memset(s->rregs, 0, ESP_REGS);
    memset(s->wregs, 0, ESP_REGS);
386
    s->rregs[ESP_TCHI] = TCHI_FAS100A; // Indicate fas100a
P
pbrook 已提交
387 388 389 390
    s->ti_size = 0;
    s->ti_rptr = 0;
    s->ti_wptr = 0;
    s->dma = 0;
P
pbrook 已提交
391
    s->do_cmd = 0;
B
bellard 已提交
392 393
}

394 395 396 397 398 399
static void parent_esp_reset(void *opaque, int irq, int level)
{
    if (level)
        esp_reset(opaque);
}

B
bellard 已提交
400 401 402 403 404
static uint32_t esp_mem_readb(void *opaque, target_phys_addr_t addr)
{
    ESPState *s = opaque;
    uint32_t saddr;

B
blueswir1 已提交
405
    saddr = (addr & ESP_MASK) >> 2;
B
bellard 已提交
406
    DPRINTF("read reg[%d]: 0x%2.2x\n", saddr, s->rregs[saddr]);
B
bellard 已提交
407
    switch (saddr) {
408
    case ESP_FIFO:
B
blueswir1 已提交
409 410
        if (s->ti_size > 0) {
            s->ti_size--;
411
            if ((s->rregs[ESP_RSTAT] & STAT_PIO_MASK) == 0) {
P
pbrook 已提交
412
                /* Data in/out.  */
P
pbrook 已提交
413
                fprintf(stderr, "esp: PIO data read not implemented\n");
414
                s->rregs[ESP_FIFO] = 0;
P
pbrook 已提交
415
            } else {
416
                s->rregs[ESP_FIFO] = s->ti_buf[s->ti_rptr++];
P
pbrook 已提交
417
            }
418
            qemu_irq_raise(s->irq);
B
blueswir1 已提交
419 420
        }
        if (s->ti_size == 0) {
421 422 423
            s->ti_rptr = 0;
            s->ti_wptr = 0;
        }
B
blueswir1 已提交
424
        break;
425
    case ESP_RINTR:
P
pbrook 已提交
426
        // Clear interrupt/error status bits
427
        s->rregs[ESP_RSTAT] &= ~(STAT_IN | STAT_GE | STAT_PE);
B
blueswir1 已提交
428
        qemu_irq_lower(s->irq);
B
bellard 已提交
429
        break;
B
bellard 已提交
430
    default:
B
blueswir1 已提交
431
        break;
B
bellard 已提交
432
    }
B
bellard 已提交
433
    return s->rregs[saddr];
B
bellard 已提交
434 435 436 437 438 439 440
}

static void esp_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
{
    ESPState *s = opaque;
    uint32_t saddr;

B
blueswir1 已提交
441
    saddr = (addr & ESP_MASK) >> 2;
442 443
    DPRINTF("write reg[%d]: 0x%2.2x -> 0x%2.2x\n", saddr, s->wregs[saddr],
            val);
B
bellard 已提交
444
    switch (saddr) {
445 446 447
    case ESP_TCLO:
    case ESP_TCMID:
        s->rregs[ESP_RSTAT] &= ~STAT_TC;
448
        break;
449
    case ESP_FIFO:
P
pbrook 已提交
450 451
        if (s->do_cmd) {
            s->cmdbuf[s->cmdlen++] = val & 0xff;
452
        } else if ((s->rregs[ESP_RSTAT] & STAT_PIO_MASK) == 0) {
P
pbrook 已提交
453 454 455
            uint8_t buf;
            buf = val & 0xff;
            s->ti_size--;
P
pbrook 已提交
456
            fprintf(stderr, "esp: PIO data write not implemented\n");
P
pbrook 已提交
457 458 459 460
        } else {
            s->ti_size++;
            s->ti_buf[s->ti_wptr++] = val & 0xff;
        }
B
blueswir1 已提交
461
        break;
462
    case ESP_CMD:
463
        s->rregs[saddr] = val;
464
        if (val & CMD_DMA) {
B
blueswir1 已提交
465
            s->dma = 1;
P
pbrook 已提交
466
            /* Reload DMA counter.  */
467 468
            s->rregs[ESP_TCLO] = s->wregs[ESP_TCLO];
            s->rregs[ESP_TCMID] = s->wregs[ESP_TCMID];
B
blueswir1 已提交
469 470 471
        } else {
            s->dma = 0;
        }
472 473
        switch(val & CMD_CMD) {
        case CMD_NOP:
B
blueswir1 已提交
474 475
            DPRINTF("NOP (%2.2x)\n", val);
            break;
476
        case CMD_FLUSH:
B
blueswir1 已提交
477
            DPRINTF("Flush FIFO (%2.2x)\n", val);
B
bellard 已提交
478
            //s->ti_size = 0;
479 480
            s->rregs[ESP_RINTR] = INTR_FC;
            s->rregs[ESP_RSEQ] = 0;
B
blueswir1 已提交
481
            break;
482
        case CMD_RESET:
B
blueswir1 已提交
483 484 485
            DPRINTF("Chip reset (%2.2x)\n", val);
            esp_reset(s);
            break;
486
        case CMD_BUSRESET:
B
blueswir1 已提交
487
            DPRINTF("Bus reset (%2.2x)\n", val);
488 489
            s->rregs[ESP_RINTR] = INTR_RST;
            if (!(s->wregs[ESP_CFG1] & CFG1_RESREPT)) {
490
                qemu_irq_raise(s->irq);
B
bellard 已提交
491
            }
B
blueswir1 已提交
492
            break;
493
        case CMD_TI:
B
blueswir1 已提交
494 495
            handle_ti(s);
            break;
496
        case CMD_ICCS:
B
blueswir1 已提交
497 498 499
            DPRINTF("Initiator Command Complete Sequence (%2.2x)\n", val);
            write_response(s);
            break;
500
        case CMD_MSGACC:
B
blueswir1 已提交
501 502
            DPRINTF("Message Accepted (%2.2x)\n", val);
            write_response(s);
503 504
            s->rregs[ESP_RINTR] = INTR_DC;
            s->rregs[ESP_RSEQ] = 0;
B
blueswir1 已提交
505
            break;
506
        case CMD_SATN:
B
blueswir1 已提交
507 508
            DPRINTF("Set ATN (%2.2x)\n", val);
            break;
509
        case CMD_SELATN:
B
blueswir1 已提交
510 511 512
            DPRINTF("Set ATN (%2.2x)\n", val);
            handle_satn(s);
            break;
513
        case CMD_SELATNS:
B
blueswir1 已提交
514 515 516
            DPRINTF("Set ATN & stop (%2.2x)\n", val);
            handle_satn_stop(s);
            break;
517
        case CMD_ENSEL:
B
blueswir1 已提交
518 519
            DPRINTF("Enable selection (%2.2x)\n", val);
            break;
B
blueswir1 已提交
520 521 522 523 524
        default:
            DPRINTF("Unhandled ESP command (%2.2x)\n", val);
            break;
        }
        break;
525
    case ESP_WBUSID ... ESP_WSYNO:
B
blueswir1 已提交
526
        break;
527
    case ESP_CFG1:
528 529
        s->rregs[saddr] = val;
        break;
530
    case ESP_WCCF ... ESP_WTEST:
531
        break;
532 533
    case ESP_CFG2:
        s->rregs[saddr] = val & CFG2_MASK;
B
bellard 已提交
534
        break;
535
    case ESP_CFG3 ... ESP_RES4:
536 537
        s->rregs[saddr] = val;
        break;
B
bellard 已提交
538
    default:
B
blueswir1 已提交
539
        break;
B
bellard 已提交
540
    }
B
bellard 已提交
541
    s->wregs[saddr] = val;
B
bellard 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
}

static CPUReadMemoryFunc *esp_mem_read[3] = {
    esp_mem_readb,
    esp_mem_readb,
    esp_mem_readb,
};

static CPUWriteMemoryFunc *esp_mem_write[3] = {
    esp_mem_writeb,
    esp_mem_writeb,
    esp_mem_writeb,
};

static void esp_save(QEMUFile *f, void *opaque)
{
    ESPState *s = opaque;
B
bellard 已提交
559

B
blueswir1 已提交
560 561
    qemu_put_buffer(f, s->rregs, ESP_REGS);
    qemu_put_buffer(f, s->wregs, ESP_REGS);
562 563 564 565
    qemu_put_be32s(f, &s->ti_size);
    qemu_put_be32s(f, &s->ti_rptr);
    qemu_put_be32s(f, &s->ti_wptr);
    qemu_put_buffer(f, s->ti_buf, TI_BUFSZ);
B
blueswir1 已提交
566
    qemu_put_be32s(f, &s->sense);
567
    qemu_put_be32s(f, &s->dma);
B
blueswir1 已提交
568 569 570 571 572
    qemu_put_buffer(f, s->cmdbuf, TI_BUFSZ);
    qemu_put_be32s(f, &s->cmdlen);
    qemu_put_be32s(f, &s->do_cmd);
    qemu_put_be32s(f, &s->dma_left);
    // There should be no transfers in progress, so dma_counter is not saved
B
bellard 已提交
573 574 575 576 577
}

static int esp_load(QEMUFile *f, void *opaque, int version_id)
{
    ESPState *s = opaque;
578

B
blueswir1 已提交
579 580
    if (version_id != 3)
        return -EINVAL; // Cannot emulate 2
B
bellard 已提交
581

B
blueswir1 已提交
582 583
    qemu_get_buffer(f, s->rregs, ESP_REGS);
    qemu_get_buffer(f, s->wregs, ESP_REGS);
584 585 586 587
    qemu_get_be32s(f, &s->ti_size);
    qemu_get_be32s(f, &s->ti_rptr);
    qemu_get_be32s(f, &s->ti_wptr);
    qemu_get_buffer(f, s->ti_buf, TI_BUFSZ);
B
blueswir1 已提交
588
    qemu_get_be32s(f, &s->sense);
589
    qemu_get_be32s(f, &s->dma);
B
blueswir1 已提交
590 591 592 593
    qemu_get_buffer(f, s->cmdbuf, TI_BUFSZ);
    qemu_get_be32s(f, &s->cmdlen);
    qemu_get_be32s(f, &s->do_cmd);
    qemu_get_be32s(f, &s->dma_left);
B
bellard 已提交
594

B
bellard 已提交
595 596 597
    return 0;
}

T
ths 已提交
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
void esp_scsi_attach(void *opaque, BlockDriverState *bd, int id)
{
    ESPState *s = (ESPState *)opaque;

    if (id < 0) {
        for (id = 0; id < ESP_MAX_DEVS; id++) {
            if (s->scsi_dev[id] == NULL)
                break;
        }
    }
    if (id >= ESP_MAX_DEVS) {
        DPRINTF("Bad Device ID %d\n", id);
        return;
    }
    if (s->scsi_dev[id]) {
        DPRINTF("Destroying device %d\n", id);
T
ths 已提交
614
        s->scsi_dev[id]->destroy(s->scsi_dev[id]);
T
ths 已提交
615 616 617
    }
    DPRINTF("Attaching block device %d\n", id);
    /* Command queueing is not implemented.  */
618 619 620
    s->scsi_dev[id] = scsi_generic_init(bd, 0, esp_command_complete, s);
    if (s->scsi_dev[id] == NULL)
        s->scsi_dev[id] = scsi_disk_init(bd, 0, esp_command_complete, s);
T
ths 已提交
621 622
}

T
ths 已提交
623
void *esp_init(target_phys_addr_t espaddr,
624
               void *dma_opaque, qemu_irq irq, qemu_irq *reset)
B
bellard 已提交
625 626
{
    ESPState *s;
627
    int esp_io_memory;
B
bellard 已提交
628 629 630

    s = qemu_mallocz(sizeof(ESPState));
    if (!s)
631
        return NULL;
B
bellard 已提交
632

633
    s->irq = irq;
634
    s->dma_opaque = dma_opaque;
B
bellard 已提交
635 636

    esp_io_memory = cpu_register_io_memory(0, esp_mem_read, esp_mem_write, s);
B
blueswir1 已提交
637
    cpu_register_physical_memory(espaddr, ESP_SIZE, esp_io_memory);
B
bellard 已提交
638 639 640

    esp_reset(s);

B
blueswir1 已提交
641
    register_savevm("esp", espaddr, 3, esp_save, esp_load, s);
B
bellard 已提交
642 643
    qemu_register_reset(esp_reset, s);

644 645
    *reset = *qemu_allocate_irqs(parent_esp_reset, s, 1);

646 647
    return s;
}