Blame view

hw/esp.c 18 KB
bellard authored
1
/*
2
 * QEMU ESP/NCR53C9x emulation
3
 *
4
 * Copyright (c) 2005-2006 Fabrice Bellard
5
 *
bellard authored
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.
 */
24
pbrook authored
25
26
#include "hw.h"
#include "scsi-disk.h"
27
#include "scsi.h"
bellard authored
28
29

/* debug ESP card */
bellard authored
30
//#define DEBUG_ESP
bellard authored
31
32
/*
33
34
 * On Sparc32, this is the ESP (NCR53C90) part of chip STP2000 (Master I/O),
 * also produced as NCR89C100. See
35
36
37
38
39
 * 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
 */
bellard authored
40
#ifdef DEBUG_ESP
41
42
#define DPRINTF(fmt, ...)                                       \
    do { printf("ESP: " fmt , ## __VA_ARGS__); } while (0)
bellard authored
43
#else
44
#define DPRINTF(fmt, ...) do {} while (0)
bellard authored
45
46
#endif
47
48
#define ESP_ERROR(fmt, ...)                                             \
    do { printf("ESP ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
49
50
#define ESP_REGS 16
51
#define TI_BUFSZ 16
52
53
typedef struct ESPState ESPState;
bellard authored
54
55
struct ESPState {
56
    uint32_t it_shift;
57
    qemu_irq irq;
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];
blueswir1 authored
63
64
    uint32_t sense;
    uint32_t dma;
65
    SCSIDevice *scsi_dev[ESP_MAX_DEVS];
66
    SCSIDevice *current_dev;
pbrook authored
67
    uint8_t cmdbuf[TI_BUFSZ];
blueswir1 authored
68
69
    uint32_t cmdlen;
    uint32_t do_cmd;
70
pbrook authored
71
    /* The amount of data left in the current DMA transfer.  */
72
    uint32_t dma_left;
pbrook authored
73
74
75
    /* The size of the current DMA transfer.  Zero if no transfer is in
       progress.  */
    uint32_t dma_counter;
pbrook authored
76
    uint8_t *async_buf;
77
    uint32_t async_len;
78
79
80

    espdma_memory_read_write dma_memory_read;
    espdma_memory_read_write dma_memory_write;
81
    void *dma_opaque;
82
};
bellard authored
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
119
120
121
#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
bellard authored
122
123
124
125
#define STAT_DO 0x00
#define STAT_DI 0x01
#define STAT_CD 0x02
#define STAT_ST 0x03
126
127
#define STAT_MO 0x06
#define STAT_MI 0x07
128
#define STAT_PIO_MASK 0x06
bellard authored
129
130

#define STAT_TC 0x10
131
132
#define STAT_PE 0x20
#define STAT_GE 0x40
133
#define STAT_INT 0x80
bellard authored
134
135
136
#define BUSID_DID 0x07
bellard authored
137
138
139
#define INTR_FC 0x08
#define INTR_BS 0x10
#define INTR_DC 0x20
bellard authored
140
#define INTR_RST 0x80
bellard authored
141
142
143
144

#define SEQ_0 0x0
#define SEQ_CD 0x4
145
146
147
148
#define CFG1_RESREPT 0x40

#define TCHI_FAS100A 0x4
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
static void esp_raise_irq(ESPState *s)
{
    if (!(s->rregs[ESP_RSTAT] & STAT_INT)) {
        s->rregs[ESP_RSTAT] |= STAT_INT;
        qemu_irq_raise(s->irq);
    }
}

static void esp_lower_irq(ESPState *s)
{
    if (s->rregs[ESP_RSTAT] & STAT_INT) {
        s->rregs[ESP_RSTAT] &= ~STAT_INT;
        qemu_irq_lower(s->irq);
    }
}
blueswir1 authored
165
static uint32_t get_cmd(ESPState *s, uint8_t *buf)
bellard authored
166
{
pbrook authored
167
    uint32_t dmalen;
bellard authored
168
169
    int target;
170
    target = s->wregs[ESP_WBUSID] & BUSID_DID;
171
    if (s->dma) {
172
        dmalen = s->rregs[ESP_TCLO] | (s->rregs[ESP_TCMID] << 8);
173
        s->dma_memory_read(s->dma_opaque, buf, dmalen);
174
    } else {
175
176
        dmalen = s->ti_size;
        memcpy(buf, s->ti_buf, dmalen);
blueswir1 authored
177
        buf[0] = 0;
178
    }
179
    DPRINTF("get_cmd: len %d target %d\n", dmalen, target);
180
bellard authored
181
    s->ti_size = 0;
182
183
    s->ti_rptr = 0;
    s->ti_wptr = 0;
bellard authored
184
pbrook authored
185
186
    if (s->current_dev) {
        /* Started a new command before the old one finished.  Cancel it.  */
ths authored
187
        s->current_dev->cancel_io(s->current_dev, 0);
pbrook authored
188
189
190
        s->async_len = 0;
    }
191
    if (target >= ESP_MAX_DEVS || !s->scsi_dev[target]) {
192
        // No such drive
193
        s->rregs[ESP_RSTAT] = 0;
194
195
        s->rregs[ESP_RINTR] = INTR_DC;
        s->rregs[ESP_RSEQ] = SEQ_0;
196
        esp_raise_irq(s);
blueswir1 authored
197
        return 0;
bellard authored
198
    }
199
    s->current_dev = s->scsi_dev[target];
pbrook authored
200
201
202
203
204
205
206
207
208
209
    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;
ths authored
210
    datalen = s->current_dev->send_command(s->current_dev, 0, &buf[1], lun);
211
212
    s->ti_size = datalen;
    if (datalen != 0) {
213
        s->rregs[ESP_RSTAT] = STAT_TC;
pbrook authored
214
        s->dma_left = 0;
pbrook authored
215
        s->dma_counter = 0;
216
        if (datalen > 0) {
217
            s->rregs[ESP_RSTAT] |= STAT_DI;
ths authored
218
            s->current_dev->read_data(s->current_dev, 0);
219
        } else {
220
            s->rregs[ESP_RSTAT] |= STAT_DO;
ths authored
221
            s->current_dev->write_data(s->current_dev, 0);
222
        }
bellard authored
223
    }
224
225
    s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
    s->rregs[ESP_RSEQ] = SEQ_CD;
226
    esp_raise_irq(s);
bellard authored
227
228
}
pbrook authored
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
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;
245
        s->rregs[ESP_RSTAT] = STAT_TC | STAT_CD;
246
247
        s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
        s->rregs[ESP_RSEQ] = SEQ_CD;
248
        esp_raise_irq(s);
pbrook authored
249
250
251
    }
}
pbrook authored
252
static void write_response(ESPState *s)
bellard authored
253
{
pbrook authored
254
255
256
    DPRINTF("Transfer status (sense=%d)\n", s->sense);
    s->ti_buf[0] = s->sense;
    s->ti_buf[1] = 0;
257
    if (s->dma) {
258
        s->dma_memory_write(s->dma_opaque, s->ti_buf, 2);
259
        s->rregs[ESP_RSTAT] = STAT_TC | STAT_ST;
260
261
        s->rregs[ESP_RINTR] = INTR_BS | INTR_FC;
        s->rregs[ESP_RSEQ] = SEQ_CD;
262
    } else {
blueswir1 authored
263
264
265
        s->ti_size = 2;
        s->ti_rptr = 0;
        s->ti_wptr = 0;
266
        s->rregs[ESP_RFLAGS] = 2;
267
    }
268
    esp_raise_irq(s);
bellard authored
269
}
270
pbrook authored
271
272
static void esp_dma_done(ESPState *s)
{
273
    s->rregs[ESP_RSTAT] |= STAT_TC;
274
275
276
277
278
    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;
279
    esp_raise_irq(s);
pbrook authored
280
281
}
282
283
static void esp_do_dma(ESPState *s)
{
284
    uint32_t len;
285
    int to_device;
pbrook authored
286
287
    to_device = (s->ti_size < 0);
pbrook authored
288
    len = s->dma_left;
289
290
    if (s->do_cmd) {
        DPRINTF("command len %d + %d\n", s->cmdlen, len);
291
        s->dma_memory_read(s->dma_opaque, &s->cmdbuf[s->cmdlen], len);
292
293
294
295
296
        s->ti_size = 0;
        s->cmdlen = 0;
        s->do_cmd = 0;
        do_cmd(s, s->cmdbuf);
        return;
pbrook authored
297
298
299
300
301
302
303
304
305
    }
    if (s->async_len == 0) {
        /* Defer until data is available.  */
        return;
    }
    if (len > s->async_len) {
        len = s->async_len;
    }
    if (to_device) {
306
        s->dma_memory_read(s->dma_opaque, s->async_buf, len);
307
    } else {
308
        s->dma_memory_write(s->dma_opaque, s->async_buf, len);
pbrook authored
309
310
311
312
    }
    s->dma_left -= len;
    s->async_buf += len;
    s->async_len -= len;
pbrook authored
313
314
315
316
    if (to_device)
        s->ti_size += len;
    else
        s->ti_size -= len;
pbrook authored
317
    if (s->async_len == 0) {
318
        if (to_device) {
319
            // ti_size is negative
ths authored
320
            s->current_dev->write_data(s->current_dev, 0);
321
        } else {
ths authored
322
            s->current_dev->read_data(s->current_dev, 0);
pbrook authored
323
            /* If there is still data to be read from the device then
324
               complete the DMA operation immediately.  Otherwise defer
pbrook authored
325
326
327
328
               until the scsi layer has completed.  */
            if (s->dma_left == 0 && s->ti_size > 0) {
                esp_dma_done(s);
            }
329
        }
pbrook authored
330
331
    } else {
        /* Partially filled a scsi buffer. Complete immediately.  */
pbrook authored
332
333
        esp_dma_done(s);
    }
334
335
}
pbrook authored
336
337
static void esp_command_complete(void *opaque, int reason, uint32_t tag,
                                 uint32_t arg)
338
339
340
{
    ESPState *s = (ESPState *)opaque;
341
342
343
344
345
    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;
pbrook authored
346
347
348
        s->dma_left = 0;
        s->async_len = 0;
        if (arg)
349
            DPRINTF("Command failed\n");
pbrook authored
350
        s->sense = arg;
351
        s->rregs[ESP_RSTAT] = STAT_ST;
pbrook authored
352
353
        esp_dma_done(s);
        s->current_dev = NULL;
354
355
    } else {
        DPRINTF("transfer %d/%d\n", s->dma_left, s->ti_size);
pbrook authored
356
        s->async_len = arg;
ths authored
357
        s->async_buf = s->current_dev->get_buf(s->current_dev, 0);
pbrook authored
358
        if (s->dma_left) {
pbrook authored
359
            esp_do_dma(s);
pbrook authored
360
361
362
363
364
        } 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);
        }
365
    }
366
367
}
bellard authored
368
369
static void handle_ti(ESPState *s)
{
370
    uint32_t dmalen, minlen;
bellard authored
371
372
    dmalen = s->rregs[ESP_TCLO] | (s->rregs[ESP_TCMID] << 8);
pbrook authored
373
374
375
    if (dmalen==0) {
      dmalen=0x10000;
    }
pbrook authored
376
    s->dma_counter = dmalen;
pbrook authored
377
pbrook authored
378
379
    if (s->do_cmd)
        minlen = (dmalen < 32) ? dmalen : 32;
380
381
    else if (s->ti_size < 0)
        minlen = (dmalen < -s->ti_size) ? dmalen : -s->ti_size;
pbrook authored
382
383
    else
        minlen = (dmalen < s->ti_size) ? dmalen : s->ti_size;
pbrook authored
384
    DPRINTF("Transfer Information len %d\n", minlen);
385
    if (s->dma) {
386
        s->dma_left = minlen;
387
        s->rregs[ESP_RSTAT] &= ~STAT_TC;
388
        esp_do_dma(s);
pbrook authored
389
390
391
392
393
394
395
396
    } 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;
    }
bellard authored
397
398
}
399
static void esp_reset(void *opaque)
bellard authored
400
401
{
    ESPState *s = opaque;
402
403
404
    esp_lower_irq(s);
405
406
    memset(s->rregs, 0, ESP_REGS);
    memset(s->wregs, 0, ESP_REGS);
407
    s->rregs[ESP_TCHI] = TCHI_FAS100A; // Indicate fas100a
408
409
410
411
    s->ti_size = 0;
    s->ti_rptr = 0;
    s->ti_wptr = 0;
    s->dma = 0;
pbrook authored
412
    s->do_cmd = 0;
413
414

    s->rregs[ESP_CFG1] = 7;
bellard authored
415
416
}
417
418
419
420
421
422
static void parent_esp_reset(void *opaque, int irq, int level)
{
    if (level)
        esp_reset(opaque);
}
bellard authored
423
424
425
426
427
static uint32_t esp_mem_readb(void *opaque, target_phys_addr_t addr)
{
    ESPState *s = opaque;
    uint32_t saddr;
blueswir1 authored
428
    saddr = addr >> s->it_shift;
bellard authored
429
    DPRINTF("read reg[%d]: 0x%2.2x\n", saddr, s->rregs[saddr]);
bellard authored
430
    switch (saddr) {
431
    case ESP_FIFO:
blueswir1 authored
432
433
        if (s->ti_size > 0) {
            s->ti_size--;
434
            if ((s->rregs[ESP_RSTAT] & STAT_PIO_MASK) == 0) {
435
436
                /* Data out.  */
                ESP_ERROR("PIO data read not implemented\n");
437
                s->rregs[ESP_FIFO] = 0;
438
            } else {
439
                s->rregs[ESP_FIFO] = s->ti_buf[s->ti_rptr++];
440
            }
441
            esp_raise_irq(s);
blueswir1 authored
442
443
        }
        if (s->ti_size == 0) {
444
445
446
            s->ti_rptr = 0;
            s->ti_wptr = 0;
        }
blueswir1 authored
447
        break;
448
    case ESP_RINTR:
449
        // Clear interrupt/error status bits
450
451
        s->rregs[ESP_RSTAT] &= ~(STAT_GE | STAT_PE);
        esp_lower_irq(s);
bellard authored
452
        break;
bellard authored
453
    default:
blueswir1 authored
454
        break;
bellard authored
455
    }
bellard authored
456
    return s->rregs[saddr];
bellard authored
457
458
459
460
461
462
463
}

static void esp_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
{
    ESPState *s = opaque;
    uint32_t saddr;
blueswir1 authored
464
    saddr = addr >> s->it_shift;
465
466
    DPRINTF("write reg[%d]: 0x%2.2x -> 0x%2.2x\n", saddr, s->wregs[saddr],
            val);
bellard authored
467
    switch (saddr) {
468
469
470
    case ESP_TCLO:
    case ESP_TCMID:
        s->rregs[ESP_RSTAT] &= ~STAT_TC;
471
        break;
472
    case ESP_FIFO:
pbrook authored
473
474
        if (s->do_cmd) {
            s->cmdbuf[s->cmdlen++] = val & 0xff;
475
476
        } else if (s->ti_size == TI_BUFSZ - 1) {
            ESP_ERROR("fifo overrun\n");
477
478
479
480
        } else {
            s->ti_size++;
            s->ti_buf[s->ti_wptr++] = val & 0xff;
        }
blueswir1 authored
481
        break;
482
    case ESP_CMD:
483
        s->rregs[saddr] = val;
484
        if (val & CMD_DMA) {
blueswir1 authored
485
            s->dma = 1;
pbrook authored
486
            /* Reload DMA counter.  */
487
488
            s->rregs[ESP_TCLO] = s->wregs[ESP_TCLO];
            s->rregs[ESP_TCMID] = s->wregs[ESP_TCMID];
blueswir1 authored
489
490
491
        } else {
            s->dma = 0;
        }
492
493
        switch(val & CMD_CMD) {
        case CMD_NOP:
blueswir1 authored
494
495
            DPRINTF("NOP (%2.2x)\n", val);
            break;
496
        case CMD_FLUSH:
blueswir1 authored
497
            DPRINTF("Flush FIFO (%2.2x)\n", val);
bellard authored
498
            //s->ti_size = 0;
499
500
            s->rregs[ESP_RINTR] = INTR_FC;
            s->rregs[ESP_RSEQ] = 0;
501
            s->rregs[ESP_RFLAGS] = 0;
blueswir1 authored
502
            break;
503
        case CMD_RESET:
blueswir1 authored
504
505
506
            DPRINTF("Chip reset (%2.2x)\n", val);
            esp_reset(s);
            break;
507
        case CMD_BUSRESET:
blueswir1 authored
508
            DPRINTF("Bus reset (%2.2x)\n", val);
509
510
            s->rregs[ESP_RINTR] = INTR_RST;
            if (!(s->wregs[ESP_CFG1] & CFG1_RESREPT)) {
511
                esp_raise_irq(s);
bellard authored
512
            }
blueswir1 authored
513
            break;
514
        case CMD_TI:
blueswir1 authored
515
516
            handle_ti(s);
            break;
517
        case CMD_ICCS:
blueswir1 authored
518
519
            DPRINTF("Initiator Command Complete Sequence (%2.2x)\n", val);
            write_response(s);
520
521
            s->rregs[ESP_RINTR] = INTR_FC;
            s->rregs[ESP_RSTAT] |= STAT_MI;
blueswir1 authored
522
            break;
523
        case CMD_MSGACC:
blueswir1 authored
524
525
            DPRINTF("Message Accepted (%2.2x)\n", val);
            write_response(s);
526
527
            s->rregs[ESP_RINTR] = INTR_DC;
            s->rregs[ESP_RSEQ] = 0;
blueswir1 authored
528
            break;
529
        case CMD_SATN:
blueswir1 authored
530
531
            DPRINTF("Set ATN (%2.2x)\n", val);
            break;
532
        case CMD_SELATN:
blueswir1 authored
533
534
535
            DPRINTF("Set ATN (%2.2x)\n", val);
            handle_satn(s);
            break;
536
        case CMD_SELATNS:
blueswir1 authored
537
538
539
            DPRINTF("Set ATN & stop (%2.2x)\n", val);
            handle_satn_stop(s);
            break;
540
        case CMD_ENSEL:
541
            DPRINTF("Enable selection (%2.2x)\n", val);
542
            s->rregs[ESP_RINTR] = 0;
543
            break;
blueswir1 authored
544
        default:
545
            ESP_ERROR("Unhandled ESP command (%2.2x)\n", val);
blueswir1 authored
546
547
548
            break;
        }
        break;
549
    case ESP_WBUSID ... ESP_WSYNO:
blueswir1 authored
550
        break;
551
    case ESP_CFG1:
552
553
        s->rregs[saddr] = val;
        break;
554
    case ESP_WCCF ... ESP_WTEST:
555
        break;
556
    case ESP_CFG2 ... ESP_RES4:
557
558
        s->rregs[saddr] = val;
        break;
bellard authored
559
    default:
560
561
        ESP_ERROR("invalid write of 0x%02x at [0x%x]\n", val, saddr);
        return;
bellard authored
562
    }
bellard authored
563
    s->wregs[saddr] = val;
bellard authored
564
565
566
567
}

static CPUReadMemoryFunc *esp_mem_read[3] = {
    esp_mem_readb,
568
569
    NULL,
    NULL,
bellard authored
570
571
572
573
};

static CPUWriteMemoryFunc *esp_mem_write[3] = {
    esp_mem_writeb,
574
    NULL,
575
    esp_mem_writeb,
bellard authored
576
577
578
579
580
};

static void esp_save(QEMUFile *f, void *opaque)
{
    ESPState *s = opaque;
bellard authored
581
582
583
    qemu_put_buffer(f, s->rregs, ESP_REGS);
    qemu_put_buffer(f, s->wregs, ESP_REGS);
584
    qemu_put_sbe32s(f, &s->ti_size);
585
586
587
    qemu_put_be32s(f, &s->ti_rptr);
    qemu_put_be32s(f, &s->ti_wptr);
    qemu_put_buffer(f, s->ti_buf, TI_BUFSZ);
588
    qemu_put_be32s(f, &s->sense);
589
    qemu_put_be32s(f, &s->dma);
590
591
592
593
594
    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
bellard authored
595
596
597
598
599
}

static int esp_load(QEMUFile *f, void *opaque, int version_id)
{
    ESPState *s = opaque;
600
601
602
    if (version_id != 3)
        return -EINVAL; // Cannot emulate 2
bellard authored
603
604
605
    qemu_get_buffer(f, s->rregs, ESP_REGS);
    qemu_get_buffer(f, s->wregs, ESP_REGS);
606
    qemu_get_sbe32s(f, &s->ti_size);
607
608
609
    qemu_get_be32s(f, &s->ti_rptr);
    qemu_get_be32s(f, &s->ti_wptr);
    qemu_get_buffer(f, s->ti_buf, TI_BUFSZ);
610
    qemu_get_be32s(f, &s->sense);
611
    qemu_get_be32s(f, &s->dma);
612
613
614
615
    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);
bellard authored
616
bellard authored
617
618
619
    return 0;
}
620
621
622
623
624
625
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++) {
626
627
            if (id == (s->rregs[ESP_CFG1] & 0x7))
                continue;
628
629
630
631
632
633
634
635
636
637
            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);
ths authored
638
        s->scsi_dev[id]->destroy(s->scsi_dev[id]);
639
640
641
    }
    DPRINTF("Attaching block device %d\n", id);
    /* Command queueing is not implemented.  */
642
643
644
    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);
645
646
}
647
void *esp_init(target_phys_addr_t espaddr, int it_shift,
648
649
               espdma_memory_read_write dma_memory_read,
               espdma_memory_read_write dma_memory_write,
650
               void *dma_opaque, qemu_irq irq, qemu_irq *reset)
bellard authored
651
652
{
    ESPState *s;
653
    int esp_io_memory;
bellard authored
654
655
656

    s = qemu_mallocz(sizeof(ESPState));
657
    s->irq = irq;
658
    s->it_shift = it_shift;
659
660
    s->dma_memory_read = dma_memory_read;
    s->dma_memory_write = dma_memory_write;
661
    s->dma_opaque = dma_opaque;
bellard authored
662
663

    esp_io_memory = cpu_register_io_memory(0, esp_mem_read, esp_mem_write, s);
664
    cpu_register_physical_memory(espaddr, ESP_REGS << it_shift, esp_io_memory);
bellard authored
665
666
667

    esp_reset(s);
668
    register_savevm("esp", espaddr, 3, esp_save, esp_load, s);
bellard authored
669
670
    qemu_register_reset(esp_reset, s);
671
672
    *reset = *qemu_allocate_irqs(parent_esp_reset, s, 1);
673
674
    return s;
}