2 * QEMU ESP/NCR53C9x emulation
4 * Copyright (c) 2005-2006 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
31 * On Sparc32, this is the ESP (NCR53C90) part of chip STP2000 (Master I/O),
32 * also produced as NCR89C100. See
33 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C100.txt
35 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR53C9X.txt
38 #define ESP_ERROR(fmt, ...) \
39 do { printf("ESP ERROR: %s: " fmt, __func__ , ## __VA_ARGS__); } while (0)
44 typedef struct ESPState ESPState
;
49 uint8_t rregs
[ESP_REGS
];
50 uint8_t wregs
[ESP_REGS
];
54 uint32_t ti_rptr
, ti_wptr
;
57 uint8_t ti_buf
[TI_BUFSZ
];
59 SCSIDevice
*current_dev
;
60 SCSIRequest
*current_req
;
61 uint8_t cmdbuf
[TI_BUFSZ
];
65 /* The amount of data left in the current DMA transfer. */
67 /* The size of the current DMA transfer. Zero if no transfer is in
75 ESPDMAMemoryReadWriteFunc dma_memory_read
;
76 ESPDMAMemoryReadWriteFunc dma_memory_write
;
78 void (*dma_cb
)(ESPState
*s
);
86 #define ESP_WBUSID 0x4
90 #define ESP_WSYNTP 0x6
91 #define ESP_RFLAGS 0x7
108 #define CMD_FLUSH 0x01
109 #define CMD_RESET 0x02
110 #define CMD_BUSRESET 0x03
112 #define CMD_ICCS 0x11
113 #define CMD_MSGACC 0x12
115 #define CMD_SATN 0x1a
117 #define CMD_SELATN 0x42
118 #define CMD_SELATNS 0x43
119 #define CMD_ENSEL 0x44
120 #define CMD_DISSEL 0x45
128 #define STAT_PIO_MASK 0x06
133 #define STAT_INT 0x80
135 #define BUSID_DID 0x07
140 #define INTR_RST 0x80
145 #define CFG1_RESREPT 0x40
147 #define TCHI_FAS100A 0x4
149 static void esp_raise_irq(ESPState
*s
)
151 if (!(s
->rregs
[ESP_RSTAT
] & STAT_INT
)) {
152 s
->rregs
[ESP_RSTAT
] |= STAT_INT
;
153 qemu_irq_raise(s
->irq
);
154 trace_esp_raise_irq();
158 static void esp_lower_irq(ESPState
*s
)
160 if (s
->rregs
[ESP_RSTAT
] & STAT_INT
) {
161 s
->rregs
[ESP_RSTAT
] &= ~STAT_INT
;
162 qemu_irq_lower(s
->irq
);
163 trace_esp_lower_irq();
167 static void esp_dma_enable(void *opaque
, int irq
, int level
)
169 DeviceState
*d
= opaque
;
170 ESPState
*s
= container_of(d
, ESPState
, busdev
.qdev
);
174 trace_esp_dma_enable();
180 trace_esp_dma_disable();
185 static void esp_request_cancelled(SCSIRequest
*req
)
187 ESPState
*s
= DO_UPCAST(ESPState
, busdev
.qdev
, req
->bus
->qbus
.parent
);
189 if (req
== s
->current_req
) {
190 scsi_req_unref(s
->current_req
);
191 s
->current_req
= NULL
;
192 s
->current_dev
= NULL
;
196 static uint32_t get_cmd(ESPState
*s
, uint8_t *buf
)
201 target
= s
->wregs
[ESP_WBUSID
] & BUSID_DID
;
203 dmalen
= s
->rregs
[ESP_TCLO
] | (s
->rregs
[ESP_TCMID
] << 8);
204 s
->dma_memory_read(s
->dma_opaque
, buf
, dmalen
);
207 memcpy(buf
, s
->ti_buf
, dmalen
);
208 buf
[0] = buf
[2] >> 5;
210 trace_esp_get_cmd(dmalen
, target
);
216 if (s
->current_req
) {
217 /* Started a new command before the old one finished. Cancel it. */
218 scsi_req_cancel(s
->current_req
);
222 s
->current_dev
= scsi_device_find(&s
->bus
, 0, target
, 0);
223 if (!s
->current_dev
) {
225 s
->rregs
[ESP_RSTAT
] = 0;
226 s
->rregs
[ESP_RINTR
] = INTR_DC
;
227 s
->rregs
[ESP_RSEQ
] = SEQ_0
;
234 static void do_busid_cmd(ESPState
*s
, uint8_t *buf
, uint8_t busid
)
238 SCSIDevice
*current_lun
;
240 trace_esp_do_busid_cmd(busid
);
242 current_lun
= scsi_device_find(&s
->bus
, 0, s
->current_dev
->id
, lun
);
243 s
->current_req
= scsi_req_new(current_lun
, 0, lun
, buf
, NULL
);
244 datalen
= scsi_req_enqueue(s
->current_req
);
245 s
->ti_size
= datalen
;
247 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
251 s
->rregs
[ESP_RSTAT
] |= STAT_DI
;
253 s
->rregs
[ESP_RSTAT
] |= STAT_DO
;
255 scsi_req_continue(s
->current_req
);
257 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
258 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
262 static void do_cmd(ESPState
*s
, uint8_t *buf
)
264 uint8_t busid
= buf
[0];
266 do_busid_cmd(s
, &buf
[1], busid
);
269 static void handle_satn(ESPState
*s
)
274 if (s
->dma
&& !s
->dma_enabled
) {
275 s
->dma_cb
= handle_satn
;
278 len
= get_cmd(s
, buf
);
283 static void handle_s_without_atn(ESPState
*s
)
288 if (s
->dma
&& !s
->dma_enabled
) {
289 s
->dma_cb
= handle_s_without_atn
;
292 len
= get_cmd(s
, buf
);
294 do_busid_cmd(s
, buf
, 0);
298 static void handle_satn_stop(ESPState
*s
)
300 if (s
->dma
&& !s
->dma_enabled
) {
301 s
->dma_cb
= handle_satn_stop
;
304 s
->cmdlen
= get_cmd(s
, s
->cmdbuf
);
306 trace_esp_handle_satn_stop(s
->cmdlen
);
308 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_CD
;
309 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
310 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
315 static void write_response(ESPState
*s
)
317 trace_esp_write_response(s
->status
);
318 s
->ti_buf
[0] = s
->status
;
321 s
->dma_memory_write(s
->dma_opaque
, s
->ti_buf
, 2);
322 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_ST
;
323 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
324 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
329 s
->rregs
[ESP_RFLAGS
] = 2;
334 static void esp_dma_done(ESPState
*s
)
336 s
->rregs
[ESP_RSTAT
] |= STAT_TC
;
337 s
->rregs
[ESP_RINTR
] = INTR_BS
;
338 s
->rregs
[ESP_RSEQ
] = 0;
339 s
->rregs
[ESP_RFLAGS
] = 0;
340 s
->rregs
[ESP_TCLO
] = 0;
341 s
->rregs
[ESP_TCMID
] = 0;
345 static void esp_do_dma(ESPState
*s
)
350 to_device
= (s
->ti_size
< 0);
353 trace_esp_do_dma(s
->cmdlen
, len
);
354 s
->dma_memory_read(s
->dma_opaque
, &s
->cmdbuf
[s
->cmdlen
], len
);
358 do_cmd(s
, s
->cmdbuf
);
361 if (s
->async_len
== 0) {
362 /* Defer until data is available. */
365 if (len
> s
->async_len
) {
369 s
->dma_memory_read(s
->dma_opaque
, s
->async_buf
, len
);
371 s
->dma_memory_write(s
->dma_opaque
, s
->async_buf
, len
);
380 if (s
->async_len
== 0) {
381 scsi_req_continue(s
->current_req
);
382 /* If there is still data to be read from the device then
383 complete the DMA operation immediately. Otherwise defer
384 until the scsi layer has completed. */
385 if (to_device
|| s
->dma_left
!= 0 || s
->ti_size
== 0) {
390 /* Partially filled a scsi buffer. Complete immediately. */
394 static void esp_command_complete(SCSIRequest
*req
, uint32_t status
,
397 ESPState
*s
= DO_UPCAST(ESPState
, busdev
.qdev
, req
->bus
->qbus
.parent
);
399 trace_esp_command_complete();
400 if (s
->ti_size
!= 0) {
401 trace_esp_command_complete_unexpected();
407 trace_esp_command_complete_fail();
410 s
->rregs
[ESP_RSTAT
] = STAT_ST
;
412 if (s
->current_req
) {
413 scsi_req_unref(s
->current_req
);
414 s
->current_req
= NULL
;
415 s
->current_dev
= NULL
;
419 static void esp_transfer_data(SCSIRequest
*req
, uint32_t len
)
421 ESPState
*s
= DO_UPCAST(ESPState
, busdev
.qdev
, req
->bus
->qbus
.parent
);
423 trace_esp_transfer_data(s
->dma_left
, s
->ti_size
);
425 s
->async_buf
= scsi_req_get_buf(req
);
428 } else if (s
->dma_counter
!= 0 && s
->ti_size
<= 0) {
429 /* If this was the last part of a DMA transfer then the
430 completion interrupt is deferred to here. */
435 static void handle_ti(ESPState
*s
)
437 uint32_t dmalen
, minlen
;
439 if (s
->dma
&& !s
->dma_enabled
) {
440 s
->dma_cb
= handle_ti
;
444 dmalen
= s
->rregs
[ESP_TCLO
] | (s
->rregs
[ESP_TCMID
] << 8);
448 s
->dma_counter
= dmalen
;
451 minlen
= (dmalen
< 32) ? dmalen
: 32;
452 else if (s
->ti_size
< 0)
453 minlen
= (dmalen
< -s
->ti_size
) ? dmalen
: -s
->ti_size
;
455 minlen
= (dmalen
< s
->ti_size
) ? dmalen
: s
->ti_size
;
456 trace_esp_handle_ti(minlen
);
458 s
->dma_left
= minlen
;
459 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
461 } else if (s
->do_cmd
) {
462 trace_esp_handle_ti_cmd(s
->cmdlen
);
466 do_cmd(s
, s
->cmdbuf
);
471 static void esp_hard_reset(DeviceState
*d
)
473 ESPState
*s
= container_of(d
, ESPState
, busdev
.qdev
);
475 memset(s
->rregs
, 0, ESP_REGS
);
476 memset(s
->wregs
, 0, ESP_REGS
);
477 s
->rregs
[ESP_TCHI
] = TCHI_FAS100A
; // Indicate fas100a
485 s
->rregs
[ESP_CFG1
] = 7;
488 static void esp_soft_reset(DeviceState
*d
)
490 ESPState
*s
= container_of(d
, ESPState
, busdev
.qdev
);
492 qemu_irq_lower(s
->irq
);
496 static void parent_esp_reset(void *opaque
, int irq
, int level
)
499 esp_soft_reset(opaque
);
503 static void esp_gpio_demux(void *opaque
, int irq
, int level
)
507 parent_esp_reset(opaque
, irq
, level
);
510 esp_dma_enable(opaque
, irq
, level
);
515 static uint64_t esp_mem_read(void *opaque
, target_phys_addr_t addr
,
518 ESPState
*s
= opaque
;
519 uint32_t saddr
, old_val
;
521 saddr
= addr
>> s
->it_shift
;
522 trace_esp_mem_readb(saddr
, s
->rregs
[saddr
]);
525 if (s
->ti_size
> 0) {
527 if ((s
->rregs
[ESP_RSTAT
] & STAT_PIO_MASK
) == 0) {
529 ESP_ERROR("PIO data read not implemented\n");
530 s
->rregs
[ESP_FIFO
] = 0;
532 s
->rregs
[ESP_FIFO
] = s
->ti_buf
[s
->ti_rptr
++];
536 if (s
->ti_size
== 0) {
542 /* Clear sequence step, interrupt register and all status bits
544 old_val
= s
->rregs
[ESP_RINTR
];
545 s
->rregs
[ESP_RINTR
] = 0;
546 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
547 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
554 return s
->rregs
[saddr
];
557 static void esp_mem_write(void *opaque
, target_phys_addr_t addr
,
558 uint64_t val
, unsigned size
)
560 ESPState
*s
= opaque
;
563 saddr
= addr
>> s
->it_shift
;
564 trace_esp_mem_writeb(saddr
, s
->wregs
[saddr
], val
);
568 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
572 s
->cmdbuf
[s
->cmdlen
++] = val
& 0xff;
573 } else if (s
->ti_size
== TI_BUFSZ
- 1) {
574 ESP_ERROR("fifo overrun\n");
577 s
->ti_buf
[s
->ti_wptr
++] = val
& 0xff;
581 s
->rregs
[saddr
] = val
;
584 /* Reload DMA counter. */
585 s
->rregs
[ESP_TCLO
] = s
->wregs
[ESP_TCLO
];
586 s
->rregs
[ESP_TCMID
] = s
->wregs
[ESP_TCMID
];
590 switch(val
& CMD_CMD
) {
592 trace_esp_mem_writeb_cmd_nop(val
);
595 trace_esp_mem_writeb_cmd_flush(val
);
597 s
->rregs
[ESP_RINTR
] = INTR_FC
;
598 s
->rregs
[ESP_RSEQ
] = 0;
599 s
->rregs
[ESP_RFLAGS
] = 0;
602 trace_esp_mem_writeb_cmd_reset(val
);
603 esp_soft_reset(&s
->busdev
.qdev
);
606 trace_esp_mem_writeb_cmd_bus_reset(val
);
607 s
->rregs
[ESP_RINTR
] = INTR_RST
;
608 if (!(s
->wregs
[ESP_CFG1
] & CFG1_RESREPT
)) {
616 trace_esp_mem_writeb_cmd_iccs(val
);
618 s
->rregs
[ESP_RINTR
] = INTR_FC
;
619 s
->rregs
[ESP_RSTAT
] |= STAT_MI
;
622 trace_esp_mem_writeb_cmd_msgacc(val
);
623 s
->rregs
[ESP_RINTR
] = INTR_DC
;
624 s
->rregs
[ESP_RSEQ
] = 0;
625 s
->rregs
[ESP_RFLAGS
] = 0;
629 trace_esp_mem_writeb_cmd_pad(val
);
630 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
631 s
->rregs
[ESP_RINTR
] = INTR_FC
;
632 s
->rregs
[ESP_RSEQ
] = 0;
635 trace_esp_mem_writeb_cmd_satn(val
);
638 trace_esp_mem_writeb_cmd_sel(val
);
639 handle_s_without_atn(s
);
642 trace_esp_mem_writeb_cmd_selatn(val
);
646 trace_esp_mem_writeb_cmd_selatns(val
);
650 trace_esp_mem_writeb_cmd_ensel(val
);
651 s
->rregs
[ESP_RINTR
] = 0;
654 trace_esp_mem_writeb_cmd_dissel(val
);
655 s
->rregs
[ESP_RINTR
] = 0;
659 ESP_ERROR("Unhandled ESP command (%2.2x)\n", (unsigned)val
);
663 case ESP_WBUSID
... ESP_WSYNO
:
666 s
->rregs
[saddr
] = val
;
668 case ESP_WCCF
... ESP_WTEST
:
670 case ESP_CFG2
... ESP_RES4
:
671 s
->rregs
[saddr
] = val
;
674 ESP_ERROR("invalid write of 0x%02x at [0x%x]\n", (unsigned)val
, saddr
);
677 s
->wregs
[saddr
] = val
;
680 static bool esp_mem_accepts(void *opaque
, target_phys_addr_t addr
,
681 unsigned size
, bool is_write
)
683 return (size
== 1) || (is_write
&& size
== 4);
686 static const MemoryRegionOps esp_mem_ops
= {
687 .read
= esp_mem_read
,
688 .write
= esp_mem_write
,
689 .endianness
= DEVICE_NATIVE_ENDIAN
,
690 .valid
.accepts
= esp_mem_accepts
,
693 static const VMStateDescription vmstate_esp
= {
696 .minimum_version_id
= 3,
697 .minimum_version_id_old
= 3,
698 .fields
= (VMStateField
[]) {
699 VMSTATE_BUFFER(rregs
, ESPState
),
700 VMSTATE_BUFFER(wregs
, ESPState
),
701 VMSTATE_INT32(ti_size
, ESPState
),
702 VMSTATE_UINT32(ti_rptr
, ESPState
),
703 VMSTATE_UINT32(ti_wptr
, ESPState
),
704 VMSTATE_BUFFER(ti_buf
, ESPState
),
705 VMSTATE_UINT32(status
, ESPState
),
706 VMSTATE_UINT32(dma
, ESPState
),
707 VMSTATE_BUFFER(cmdbuf
, ESPState
),
708 VMSTATE_UINT32(cmdlen
, ESPState
),
709 VMSTATE_UINT32(do_cmd
, ESPState
),
710 VMSTATE_UINT32(dma_left
, ESPState
),
711 VMSTATE_END_OF_LIST()
715 void esp_init(target_phys_addr_t espaddr
, int it_shift
,
716 ESPDMAMemoryReadWriteFunc dma_memory_read
,
717 ESPDMAMemoryReadWriteFunc dma_memory_write
,
718 void *dma_opaque
, qemu_irq irq
, qemu_irq
*reset
,
719 qemu_irq
*dma_enable
)
725 dev
= qdev_create(NULL
, "esp");
726 esp
= DO_UPCAST(ESPState
, busdev
.qdev
, dev
);
727 esp
->dma_memory_read
= dma_memory_read
;
728 esp
->dma_memory_write
= dma_memory_write
;
729 esp
->dma_opaque
= dma_opaque
;
730 esp
->it_shift
= it_shift
;
731 /* XXX for now until rc4030 has been changed to use DMA enable signal */
732 esp
->dma_enabled
= 1;
733 qdev_init_nofail(dev
);
734 s
= sysbus_from_qdev(dev
);
735 sysbus_connect_irq(s
, 0, irq
);
736 sysbus_mmio_map(s
, 0, espaddr
);
737 *reset
= qdev_get_gpio_in(dev
, 0);
738 *dma_enable
= qdev_get_gpio_in(dev
, 1);
741 static const struct SCSIBusInfo esp_scsi_info
= {
743 .max_target
= ESP_MAX_DEVS
,
746 .transfer_data
= esp_transfer_data
,
747 .complete
= esp_command_complete
,
748 .cancel
= esp_request_cancelled
751 static int esp_init1(SysBusDevice
*dev
)
753 ESPState
*s
= FROM_SYSBUS(ESPState
, dev
);
755 sysbus_init_irq(dev
, &s
->irq
);
756 assert(s
->it_shift
!= -1);
758 memory_region_init_io(&s
->iomem
, &esp_mem_ops
, s
,
759 "esp", ESP_REGS
<< s
->it_shift
);
760 sysbus_init_mmio(dev
, &s
->iomem
);
762 qdev_init_gpio_in(&dev
->qdev
, esp_gpio_demux
, 2);
764 scsi_bus_new(&s
->bus
, &dev
->qdev
, &esp_scsi_info
);
765 return scsi_bus_legacy_handle_cmdline(&s
->bus
);
768 static Property esp_properties
[] = {
772 static void esp_class_init(ObjectClass
*klass
, void *data
)
774 DeviceClass
*dc
= DEVICE_CLASS(klass
);
775 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
778 dc
->reset
= esp_hard_reset
;
779 dc
->vmsd
= &vmstate_esp
;
780 dc
->props
= esp_properties
;
783 static TypeInfo esp_info
= {
785 .parent
= TYPE_SYS_BUS_DEVICE
,
786 .instance_size
= sizeof(ESPState
),
787 .class_init
= esp_class_init
,
790 static void esp_register_types(void)
792 type_register_static(&esp_info
);
795 type_init(esp_register_types
)