esp.c 14.9 KB
Newer Older
bellard's avatar
bellard committed
1
2
3
/*
 * QEMU ESP emulation
 * 
pbrook's avatar
pbrook committed
4
 * Copyright (c) 2005-2006 Fabrice Bellard
bellard's avatar
bellard committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 * 
 * 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.
 */
#include "vl.h"

/* debug ESP card */
bellard's avatar
bellard committed
27
//#define DEBUG_ESP
bellard's avatar
bellard committed
28
29
30
31

#ifdef DEBUG_ESP
#define DPRINTF(fmt, args...) \
do { printf("ESP: " fmt , ##args); } while (0)
bellard's avatar
bellard committed
32
33
#define pic_set_irq(irq, level) \
do { printf("ESP: set_irq(%d): %d\n", (irq), (level)); pic_set_irq((irq),(level));} while (0)
bellard's avatar
bellard committed
34
35
36
37
38
39
40
#else
#define DPRINTF(fmt, args...)
#endif

#define ESPDMA_REGS 4
#define ESPDMA_MAXADDR (ESPDMA_REGS * 4 - 1)
#define ESP_MAXREG 0x3f
pbrook's avatar
pbrook committed
41
#define TI_BUFSZ 32
42
#define DMA_VER 0xa0000000
bellard's avatar
bellard committed
43
44
#define DMA_INTR 1
#define DMA_INTREN 0x10
pbrook's avatar
pbrook committed
45
#define DMA_WRITE_MEM 0x100
46
#define DMA_LOADED 0x04000000
pbrook's avatar
pbrook committed
47
typedef struct ESPState ESPState;
bellard's avatar
bellard committed
48

pbrook's avatar
pbrook committed
49
struct ESPState {
bellard's avatar
bellard committed
50
    BlockDriverState **bd;
bellard's avatar
bellard committed
51
52
    uint8_t rregs[ESP_MAXREG];
    uint8_t wregs[ESP_MAXREG];
bellard's avatar
bellard committed
53
54
    int irq;
    uint32_t espdmaregs[ESPDMA_REGS];
bellard's avatar
bellard committed
55
    uint32_t ti_size;
56
57
    uint32_t ti_rptr, ti_wptr;
    uint8_t ti_buf[TI_BUFSZ];
pbrook's avatar
pbrook committed
58
    int sense;
59
    int dma;
pbrook's avatar
pbrook committed
60
61
    SCSIDevice *scsi_dev[MAX_DISKS];
    SCSIDevice *current_dev;
pbrook's avatar
pbrook committed
62
63
64
    uint8_t cmdbuf[TI_BUFSZ];
    int cmdlen;
    int do_cmd;
pbrook's avatar
pbrook committed
65
66
67
68
69

    uint32_t dma_left;
    uint8_t async_buf[TARGET_PAGE_SIZE];
    uint32_t async_ptr;
    uint32_t async_len;
pbrook's avatar
pbrook committed
70
};
bellard's avatar
bellard committed
71

bellard's avatar
bellard committed
72
73
74
75
76
77
78
79
#define STAT_DO 0x00
#define STAT_DI 0x01
#define STAT_CD 0x02
#define STAT_ST 0x03
#define STAT_MI 0x06
#define STAT_MO 0x07

#define STAT_TC 0x10
pbrook's avatar
pbrook committed
80
81
#define STAT_PE 0x20
#define STAT_GE 0x40
bellard's avatar
bellard committed
82
83
84
85
86
#define STAT_IN 0x80

#define INTR_FC 0x08
#define INTR_BS 0x10
#define INTR_DC 0x20
bellard's avatar
bellard committed
87
#define INTR_RST 0x80
bellard's avatar
bellard committed
88
89
90
91

#define SEQ_0 0x0
#define SEQ_CD 0x4

pbrook's avatar
pbrook committed
92
static int get_cmd(ESPState *s, uint8_t *buf)
bellard's avatar
bellard committed
93
94
95
96
97
{
    uint32_t dmaptr, dmalen;
    int target;

    dmalen = s->wregs[0] | (s->wregs[1] << 8);
98
    target = s->wregs[4] & 7;
pbrook's avatar
pbrook committed
99
    DPRINTF("get_cmd: len %d target %d\n", dmalen, target);
100
101
    if (s->dma) {
	dmaptr = iommu_translate(s->espdmaregs[1]);
pbrook's avatar
pbrook committed
102
103
	DPRINTF("DMA Direction: %c, addr 0x%8.8x\n",
                s->espdmaregs[0] & DMA_WRITE_MEM ? 'w': 'r', dmaptr);
104
105
106
107
108
109
	cpu_physical_memory_read(dmaptr, buf, dmalen);
    } else {
	buf[0] = 0;
	memcpy(&buf[1], s->ti_buf, dmalen);
	dmalen++;
    }
pbrook's avatar
pbrook committed
110

bellard's avatar
bellard committed
111
    s->ti_size = 0;
112
113
    s->ti_rptr = 0;
    s->ti_wptr = 0;
bellard's avatar
bellard committed
114

pbrook's avatar
pbrook committed
115
116
    if (target >= 4 || !s->scsi_dev[target]) {
        // No such drive
bellard's avatar
bellard committed
117
118
119
	s->rregs[4] = STAT_IN;
	s->rregs[5] = INTR_DC;
	s->rregs[6] = SEQ_0;
bellard's avatar
bellard committed
120
	s->espdmaregs[0] |= DMA_INTR;
bellard's avatar
bellard committed
121
	pic_set_irq(s->irq, 1);
pbrook's avatar
pbrook committed
122
	return 0;
bellard's avatar
bellard committed
123
    }
pbrook's avatar
pbrook committed
124
    s->current_dev = s->scsi_dev[target];
pbrook's avatar
pbrook committed
125
126
127
128
129
130
131
132
133
134
    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;
pbrook's avatar
pbrook committed
135
    datalen = scsi_send_command(s->current_dev, 0, &buf[1], lun);
pbrook's avatar
pbrook committed
136
137
138
139
140
141
142
143
144
145
    if (datalen == 0) {
        s->ti_size = 0;
    } else {
        s->rregs[4] = STAT_IN | STAT_TC;
        if (datalen > 0) {
            s->rregs[4] |= STAT_DI;
            s->ti_size = datalen;
        } else {
            s->rregs[4] |= STAT_DO;
            s->ti_size = -datalen;
bellard's avatar
bellard committed
146
        }
bellard's avatar
bellard committed
147
148
149
    }
    s->rregs[5] = INTR_BS | INTR_FC;
    s->rregs[6] = SEQ_CD;
bellard's avatar
bellard committed
150
    s->espdmaregs[0] |= DMA_INTR;
bellard's avatar
bellard committed
151
152
153
    pic_set_irq(s->irq, 1);
}

pbrook's avatar
pbrook committed
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
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;
        s->espdmaregs[1] += s->cmdlen;
        s->rregs[4] = STAT_IN | STAT_TC | STAT_CD;
        s->rregs[5] = INTR_BS | INTR_FC;
        s->rregs[6] = SEQ_CD;
        s->espdmaregs[0] |= DMA_INTR;
        pic_set_irq(s->irq, 1);
    }
}

pbrook's avatar
pbrook committed
179
static void write_response(ESPState *s)
bellard's avatar
bellard committed
180
{
pbrook's avatar
pbrook committed
181
    uint32_t dmaptr;
bellard's avatar
bellard committed
182

pbrook's avatar
pbrook committed
183
184
185
    DPRINTF("Transfer status (sense=%d)\n", s->sense);
    s->ti_buf[0] = s->sense;
    s->ti_buf[1] = 0;
186
187
    if (s->dma) {
	dmaptr = iommu_translate(s->espdmaregs[1]);
pbrook's avatar
pbrook committed
188
189
	DPRINTF("DMA Direction: %c\n",
                s->espdmaregs[0] & DMA_WRITE_MEM ? 'w': 'r');
pbrook's avatar
pbrook committed
190
	cpu_physical_memory_write(dmaptr, s->ti_buf, 2);
191
192
193
194
	s->rregs[4] = STAT_IN | STAT_TC | STAT_ST;
	s->rregs[5] = INTR_BS | INTR_FC;
	s->rregs[6] = SEQ_CD;
    } else {
pbrook's avatar
pbrook committed
195
	s->ti_size = 2;
196
197
	s->ti_rptr = 0;
	s->ti_wptr = 0;
pbrook's avatar
pbrook committed
198
	s->rregs[7] = 2;
199
    }
bellard's avatar
bellard committed
200
    s->espdmaregs[0] |= DMA_INTR;
bellard's avatar
bellard committed
201
202
203
    pic_set_irq(s->irq, 1);

}
204

pbrook's avatar
pbrook committed
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
static void esp_do_dma(ESPState *s)
{
    uint32_t dmaptr, minlen, len, from, to;
    int to_device;
    to_device = (s->espdmaregs[0] & DMA_WRITE_MEM) == 0;
    from = s->espdmaregs[1];
    minlen = s->dma_left;
    to = from + minlen;
    dmaptr = iommu_translate(s->espdmaregs[1]);
    if ((from & TARGET_PAGE_MASK) != (to & TARGET_PAGE_MASK)) {
       len = TARGET_PAGE_SIZE - (from & ~TARGET_PAGE_MASK);
    } else {
       len = to - from;
    }
    DPRINTF("DMA address p %08x v %08x len %08x, from %08x, to %08x\n", dmaptr, s->espdmaregs[1], len, from, to);
    if (s->do_cmd) {
pbrook's avatar
pbrook committed
221
        s->espdmaregs[1] += len;
pbrook's avatar
pbrook committed
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
        s->ti_size -= len;
        DPRINTF("command len %d + %d\n", s->cmdlen, len);
        cpu_physical_memory_read(dmaptr, &s->cmdbuf[s->cmdlen], len);
        s->ti_size = 0;
        s->cmdlen = 0;
        s->do_cmd = 0;
        do_cmd(s, s->cmdbuf);
        return;
    } else {
        s->async_len = len;
        s->dma_left -= len;
        if (to_device) {
            s->async_ptr = -1;
            cpu_physical_memory_read(dmaptr, s->async_buf, len);
            scsi_write_data(s->current_dev, s->async_buf, len);
        } else {
            s->async_ptr = dmaptr;
            scsi_read_data(s->current_dev, s->async_buf, len);
        }
    }
}

static void esp_command_complete(void *opaque, uint32_t reason, int sense)
pbrook's avatar
pbrook committed
245
246
247
{
    ESPState *s = (ESPState *)opaque;

pbrook's avatar
pbrook committed
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
    s->ti_size -= s->async_len;
    s->espdmaregs[1] += s->async_len;
    if (s->async_ptr != (uint32_t)-1) {
        cpu_physical_memory_write(s->async_ptr, s->async_buf, s->async_len);
    }
    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;
        if (sense)
            DPRINTF("Command failed\n");
        s->sense = sense;
    } else {
        DPRINTF("transfer %d/%d\n", s->dma_left, s->ti_size);
    }
    if (s->dma_left) {
        esp_do_dma(s);
    } else {
        if (s->ti_size) {
            s->rregs[4] |= STAT_IN | STAT_TC;
        } else {
            s->rregs[4] = STAT_IN | STAT_TC | STAT_ST;
        }
        s->rregs[5] = INTR_BS;
	s->rregs[6] = 0;
	s->rregs[7] = 0;
	s->espdmaregs[0] |= DMA_INTR;
        pic_set_irq(s->irq, 1);
    }
pbrook's avatar
pbrook committed
278
279
}

bellard's avatar
bellard committed
280
281
static void handle_ti(ESPState *s)
{
pbrook's avatar
pbrook committed
282
    uint32_t dmalen, minlen;
bellard's avatar
bellard committed
283
284

    dmalen = s->wregs[0] | (s->wregs[1] << 8);
pbrook's avatar
pbrook committed
285
286
287
288
    if (dmalen==0) {
      dmalen=0x10000;
    }

pbrook's avatar
pbrook committed
289
290
291
292
    if (s->do_cmd)
        minlen = (dmalen < 32) ? dmalen : 32;
    else
        minlen = (dmalen < s->ti_size) ? dmalen : s->ti_size;
pbrook's avatar
pbrook committed
293
    DPRINTF("Transfer Information len %d\n", minlen);
294
    if (s->dma) {
pbrook's avatar
pbrook committed
295
296
297
        s->dma_left = minlen;
        s->rregs[4] &= ~STAT_TC;
        esp_do_dma(s);
pbrook's avatar
pbrook committed
298
299
300
301
302
303
304
305
    } 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's avatar
bellard committed
306
307
}

bellard's avatar
bellard committed
308
309
310
static void esp_reset(void *opaque)
{
    ESPState *s = opaque;
bellard's avatar
bellard committed
311
    memset(s->rregs, 0, ESP_MAXREG);
pbrook's avatar
pbrook committed
312
    memset(s->wregs, 0, ESP_MAXREG);
bellard's avatar
bellard committed
313
    s->rregs[0x0e] = 0x4; // Indicate fas100a
bellard's avatar
bellard committed
314
    memset(s->espdmaregs, 0, ESPDMA_REGS * 4);
pbrook's avatar
pbrook committed
315
316
317
318
    s->ti_size = 0;
    s->ti_rptr = 0;
    s->ti_wptr = 0;
    s->dma = 0;
pbrook's avatar
pbrook committed
319
    s->do_cmd = 0;
bellard's avatar
bellard committed
320
321
322
323
324
325
326
327
}

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

    saddr = (addr & ESP_MAXREG) >> 2;
bellard's avatar
bellard committed
328
    DPRINTF("read reg[%d]: 0x%2.2x\n", saddr, s->rregs[saddr]);
bellard's avatar
bellard committed
329
    switch (saddr) {
330
331
332
333
    case 2:
	// FIFO
	if (s->ti_size > 0) {
	    s->ti_size--;
pbrook's avatar
pbrook committed
334
335
336
337
338
339
            if ((s->rregs[4] & 6) == 0) {
                /* Data in/out.  */
                scsi_read_data(s->current_dev, &s->rregs[2], 0);
            } else {
                s->rregs[2] = s->ti_buf[s->ti_rptr++];
            }
340
341
342
343
344
345
346
	    pic_set_irq(s->irq, 1);
	}
	if (s->ti_size == 0) {
            s->ti_rptr = 0;
            s->ti_wptr = 0;
        }
	break;
bellard's avatar
bellard committed
347
348
    case 5:
        // interrupt
pbrook's avatar
pbrook committed
349
350
        // Clear interrupt/error status bits
        s->rregs[4] &= ~(STAT_IN | STAT_GE | STAT_PE);
bellard's avatar
bellard committed
351
352
353
        pic_set_irq(s->irq, 0);
	s->espdmaregs[0] &= ~DMA_INTR;
        break;
bellard's avatar
bellard committed
354
355
356
    default:
	break;
    }
bellard's avatar
bellard committed
357
    return s->rregs[saddr];
bellard's avatar
bellard committed
358
359
360
361
362
363
364
365
}

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

    saddr = (addr & ESP_MAXREG) >> 2;
bellard's avatar
bellard committed
366
    DPRINTF("write reg[%d]: 0x%2.2x -> 0x%2.2x\n", saddr, s->wregs[saddr], val);
bellard's avatar
bellard committed
367
    switch (saddr) {
368
369
370
    case 0:
    case 1:
        s->rregs[saddr] = val;
pbrook's avatar
pbrook committed
371
        s->rregs[4] &= ~STAT_TC;
372
373
374
        break;
    case 2:
	// FIFO
pbrook's avatar
pbrook committed
375
376
377
        if (s->do_cmd) {
            s->cmdbuf[s->cmdlen++] = val & 0xff;
        } else if ((s->rregs[4] & 6) == 0) {
pbrook's avatar
pbrook committed
378
379
380
381
382
383
384
385
            uint8_t buf;
            buf = val & 0xff;
            s->ti_size--;
            scsi_write_data(s->current_dev, &buf, 0);
        } else {
            s->ti_size++;
            s->ti_buf[s->ti_wptr++] = val & 0xff;
        }
386
	break;
bellard's avatar
bellard committed
387
    case 3:
388
        s->rregs[saddr] = val;
bellard's avatar
bellard committed
389
	// Command
390
391
392
393
394
	if (val & 0x80) {
	    s->dma = 1;
	} else {
	    s->dma = 0;
	}
bellard's avatar
bellard committed
395
396
	switch(val & 0x7f) {
	case 0:
bellard's avatar
bellard committed
397
398
399
400
	    DPRINTF("NOP (%2.2x)\n", val);
	    break;
	case 1:
	    DPRINTF("Flush FIFO (%2.2x)\n", val);
bellard's avatar
bellard committed
401
            //s->ti_size = 0;
bellard's avatar
bellard committed
402
	    s->rregs[5] = INTR_FC;
bellard's avatar
bellard committed
403
	    s->rregs[6] = 0;
bellard's avatar
bellard committed
404
405
	    break;
	case 2:
bellard's avatar
bellard committed
406
	    DPRINTF("Chip reset (%2.2x)\n", val);
bellard's avatar
bellard committed
407
408
409
	    esp_reset(s);
	    break;
	case 3:
bellard's avatar
bellard committed
410
	    DPRINTF("Bus reset (%2.2x)\n", val);
bellard's avatar
bellard committed
411
412
413
414
415
	    s->rregs[5] = INTR_RST;
            if (!(s->wregs[8] & 0x40)) {
                s->espdmaregs[0] |= DMA_INTR;
                pic_set_irq(s->irq, 1);
            }
bellard's avatar
bellard committed
416
417
418
419
420
421
	    break;
	case 0x10:
	    handle_ti(s);
	    break;
	case 0x11:
	    DPRINTF("Initiator Command Complete Sequence (%2.2x)\n", val);
pbrook's avatar
pbrook committed
422
	    write_response(s);
bellard's avatar
bellard committed
423
424
425
	    break;
	case 0x12:
	    DPRINTF("Message Accepted (%2.2x)\n", val);
pbrook's avatar
pbrook committed
426
	    write_response(s);
bellard's avatar
bellard committed
427
428
	    s->rregs[5] = INTR_DC;
	    s->rregs[6] = 0;
bellard's avatar
bellard committed
429
430
	    break;
	case 0x1a:
bellard's avatar
bellard committed
431
	    DPRINTF("Set ATN (%2.2x)\n", val);
bellard's avatar
bellard committed
432
433
	    break;
	case 0x42:
pbrook's avatar
pbrook committed
434
	    DPRINTF("Set ATN (%2.2x)\n", val);
bellard's avatar
bellard committed
435
436
437
438
	    handle_satn(s);
	    break;
	case 0x43:
	    DPRINTF("Set ATN & stop (%2.2x)\n", val);
pbrook's avatar
pbrook committed
439
	    handle_satn_stop(s);
bellard's avatar
bellard committed
440
441
	    break;
	default:
442
	    DPRINTF("Unhandled ESP command (%2.2x)\n", val);
bellard's avatar
bellard committed
443
444
445
446
447
	    break;
	}
	break;
    case 4 ... 7:
	break;
448
449
450
451
452
    case 8:
        s->rregs[saddr] = val;
        break;
    case 9 ... 10:
        break;
bellard's avatar
bellard committed
453
454
455
456
    case 11:
        s->rregs[saddr] = val & 0x15;
        break;
    case 12 ... 15:
457
458
        s->rregs[saddr] = val;
        break;
bellard's avatar
bellard committed
459
460
461
    default:
	break;
    }
bellard's avatar
bellard committed
462
    s->wregs[saddr] = val;
bellard's avatar
bellard committed
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
}

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 uint32_t espdma_mem_readl(void *opaque, target_phys_addr_t addr)
{
    ESPState *s = opaque;
    uint32_t saddr;

    saddr = (addr & ESPDMA_MAXADDR) >> 2;
483
484
    DPRINTF("read dmareg[%d]: 0x%8.8x\n", saddr, s->espdmaregs[saddr]);

bellard's avatar
bellard committed
485
486
487
488
489
490
491
492
493
    return s->espdmaregs[saddr];
}

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

    saddr = (addr & ESPDMA_MAXADDR) >> 2;
494
    DPRINTF("write dmareg[%d]: 0x%8.8x -> 0x%8.8x\n", saddr, s->espdmaregs[saddr], val);
bellard's avatar
bellard committed
495
496
    switch (saddr) {
    case 0:
bellard's avatar
bellard committed
497
	if (!(val & DMA_INTREN))
bellard's avatar
bellard committed
498
	    pic_set_irq(s->irq, 0);
499
500
501
502
503
504
505
506
	if (val & 0x80) {
            esp_reset(s);
        } else if (val & 0x40) {
            val &= ~0x40;
        } else if (val == 0)
            val = 0x40;
        val &= 0x0fffffff;
        val |= DMA_VER;
bellard's avatar
bellard committed
507
	break;
508
    case 1:
509
        s->espdmaregs[0] |= DMA_LOADED;
510
        break;
bellard's avatar
bellard committed
511
512
513
    default:
	break;
    }
bellard's avatar
bellard committed
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
    s->espdmaregs[saddr] = val;
}

static CPUReadMemoryFunc *espdma_mem_read[3] = {
    espdma_mem_readl,
    espdma_mem_readl,
    espdma_mem_readl,
};

static CPUWriteMemoryFunc *espdma_mem_write[3] = {
    espdma_mem_writel,
    espdma_mem_writel,
    espdma_mem_writel,
};

static void esp_save(QEMUFile *f, void *opaque)
{
    ESPState *s = opaque;
bellard's avatar
bellard committed
532
533
534
535
536
537
538
    unsigned int i;

    qemu_put_buffer(f, s->rregs, ESP_MAXREG);
    qemu_put_buffer(f, s->wregs, ESP_MAXREG);
    qemu_put_be32s(f, &s->irq);
    for (i = 0; i < ESPDMA_REGS; i++)
	qemu_put_be32s(f, &s->espdmaregs[i]);
539
540
541
542
543
    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);
    qemu_put_be32s(f, &s->dma);
bellard's avatar
bellard committed
544
545
546
547
548
}

static int esp_load(QEMUFile *f, void *opaque, int version_id)
{
    ESPState *s = opaque;
bellard's avatar
bellard committed
549
    unsigned int i;
bellard's avatar
bellard committed
550
551
552
553
    
    if (version_id != 1)
        return -EINVAL;

bellard's avatar
bellard committed
554
555
556
557
558
    qemu_get_buffer(f, s->rregs, ESP_MAXREG);
    qemu_get_buffer(f, s->wregs, ESP_MAXREG);
    qemu_get_be32s(f, &s->irq);
    for (i = 0; i < ESPDMA_REGS; i++)
	qemu_get_be32s(f, &s->espdmaregs[i]);
559
560
561
562
563
    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);
    qemu_get_be32s(f, &s->dma);
bellard's avatar
bellard committed
564

bellard's avatar
bellard committed
565
566
567
568
569
570
571
    return 0;
}

void esp_init(BlockDriverState **bd, int irq, uint32_t espaddr, uint32_t espdaddr)
{
    ESPState *s;
    int esp_io_memory, espdma_io_memory;
pbrook's avatar
pbrook committed
572
    int i;
bellard's avatar
bellard committed
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590

    s = qemu_mallocz(sizeof(ESPState));
    if (!s)
        return;

    s->bd = bd;
    s->irq = irq;

    esp_io_memory = cpu_register_io_memory(0, esp_mem_read, esp_mem_write, s);
    cpu_register_physical_memory(espaddr, ESP_MAXREG*4, esp_io_memory);

    espdma_io_memory = cpu_register_io_memory(0, espdma_mem_read, espdma_mem_write, s);
    cpu_register_physical_memory(espdaddr, 16, espdma_io_memory);

    esp_reset(s);

    register_savevm("esp", espaddr, 1, esp_save, esp_load, s);
    qemu_register_reset(esp_reset, s);
pbrook's avatar
pbrook committed
591
592
593
594
595
596
    for (i = 0; i < MAX_DISKS; i++) {
        if (bs_table[i]) {
            s->scsi_dev[i] =
                scsi_disk_init(bs_table[i], esp_command_complete, s);
        }
    }
bellard's avatar
bellard committed
597
598
}