2 * QEMU ESP/NCR53C9x emulation
4 * Copyright (c) 2005-2006 Fabrice Bellard
5 * Copyright (c) 2012 Herve Poussineau
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #include "qemu/osdep.h"
27 #include "hw/sysbus.h"
28 #include "hw/scsi/esp.h"
30 #include "qapi/error.h"
34 * On Sparc32, this is the ESP (NCR53C90) part of chip STP2000 (Master I/O),
35 * also produced as NCR89C100. See
36 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C100.txt
38 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR53C9X.txt
41 static void esp_raise_irq(ESPState
*s
)
43 if (!(s
->rregs
[ESP_RSTAT
] & STAT_INT
)) {
44 s
->rregs
[ESP_RSTAT
] |= STAT_INT
;
45 qemu_irq_raise(s
->irq
);
46 trace_esp_raise_irq();
50 static void esp_lower_irq(ESPState
*s
)
52 if (s
->rregs
[ESP_RSTAT
] & STAT_INT
) {
53 s
->rregs
[ESP_RSTAT
] &= ~STAT_INT
;
54 qemu_irq_lower(s
->irq
);
55 trace_esp_lower_irq();
59 void esp_dma_enable(ESPState
*s
, int irq
, int level
)
63 trace_esp_dma_enable();
69 trace_esp_dma_disable();
74 void esp_request_cancelled(SCSIRequest
*req
)
76 ESPState
*s
= req
->hba_private
;
78 if (req
== s
->current_req
) {
79 scsi_req_unref(s
->current_req
);
80 s
->current_req
= NULL
;
81 s
->current_dev
= NULL
;
85 static uint32_t get_cmd(ESPState
*s
, uint8_t *buf
)
90 target
= s
->wregs
[ESP_WBUSID
] & BUSID_DID
;
92 dmalen
= s
->rregs
[ESP_TCLO
];
93 dmalen
|= s
->rregs
[ESP_TCMID
] << 8;
94 dmalen
|= s
->rregs
[ESP_TCHI
] << 16;
95 s
->dma_memory_read(s
->dma_opaque
, buf
, dmalen
);
98 memcpy(buf
, s
->ti_buf
, dmalen
);
101 trace_esp_get_cmd(dmalen
, target
);
107 if (s
->current_req
) {
108 /* Started a new command before the old one finished. Cancel it. */
109 scsi_req_cancel(s
->current_req
);
113 s
->current_dev
= scsi_device_find(&s
->bus
, 0, target
, 0);
114 if (!s
->current_dev
) {
116 s
->rregs
[ESP_RSTAT
] = 0;
117 s
->rregs
[ESP_RINTR
] = INTR_DC
;
118 s
->rregs
[ESP_RSEQ
] = SEQ_0
;
125 static void do_busid_cmd(ESPState
*s
, uint8_t *buf
, uint8_t busid
)
129 SCSIDevice
*current_lun
;
131 trace_esp_do_busid_cmd(busid
);
133 current_lun
= scsi_device_find(&s
->bus
, 0, s
->current_dev
->id
, lun
);
134 s
->current_req
= scsi_req_new(current_lun
, 0, lun
, buf
, s
);
135 datalen
= scsi_req_enqueue(s
->current_req
);
136 s
->ti_size
= datalen
;
138 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
142 s
->rregs
[ESP_RSTAT
] |= STAT_DI
;
144 s
->rregs
[ESP_RSTAT
] |= STAT_DO
;
146 scsi_req_continue(s
->current_req
);
148 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
149 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
153 static void do_cmd(ESPState
*s
, uint8_t *buf
)
155 uint8_t busid
= buf
[0];
157 do_busid_cmd(s
, &buf
[1], busid
);
160 static void handle_satn(ESPState
*s
)
165 if (s
->dma
&& !s
->dma_enabled
) {
166 s
->dma_cb
= handle_satn
;
169 len
= get_cmd(s
, buf
);
174 static void handle_s_without_atn(ESPState
*s
)
179 if (s
->dma
&& !s
->dma_enabled
) {
180 s
->dma_cb
= handle_s_without_atn
;
183 len
= get_cmd(s
, buf
);
185 do_busid_cmd(s
, buf
, 0);
189 static void handle_satn_stop(ESPState
*s
)
191 if (s
->dma
&& !s
->dma_enabled
) {
192 s
->dma_cb
= handle_satn_stop
;
195 s
->cmdlen
= get_cmd(s
, s
->cmdbuf
);
197 trace_esp_handle_satn_stop(s
->cmdlen
);
199 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_CD
;
200 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
201 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
206 static void write_response(ESPState
*s
)
208 trace_esp_write_response(s
->status
);
209 s
->ti_buf
[0] = s
->status
;
212 s
->dma_memory_write(s
->dma_opaque
, s
->ti_buf
, 2);
213 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_ST
;
214 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
215 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
220 s
->rregs
[ESP_RFLAGS
] = 2;
225 static void esp_dma_done(ESPState
*s
)
227 s
->rregs
[ESP_RSTAT
] |= STAT_TC
;
228 s
->rregs
[ESP_RINTR
] = INTR_BS
;
229 s
->rregs
[ESP_RSEQ
] = 0;
230 s
->rregs
[ESP_RFLAGS
] = 0;
231 s
->rregs
[ESP_TCLO
] = 0;
232 s
->rregs
[ESP_TCMID
] = 0;
233 s
->rregs
[ESP_TCHI
] = 0;
237 static void esp_do_dma(ESPState
*s
)
242 to_device
= (s
->ti_size
< 0);
245 trace_esp_do_dma(s
->cmdlen
, len
);
246 s
->dma_memory_read(s
->dma_opaque
, &s
->cmdbuf
[s
->cmdlen
], len
);
250 do_cmd(s
, s
->cmdbuf
);
253 if (s
->async_len
== 0) {
254 /* Defer until data is available. */
257 if (len
> s
->async_len
) {
261 s
->dma_memory_read(s
->dma_opaque
, s
->async_buf
, len
);
263 s
->dma_memory_write(s
->dma_opaque
, s
->async_buf
, len
);
272 if (s
->async_len
== 0) {
273 scsi_req_continue(s
->current_req
);
274 /* If there is still data to be read from the device then
275 complete the DMA operation immediately. Otherwise defer
276 until the scsi layer has completed. */
277 if (to_device
|| s
->dma_left
!= 0 || s
->ti_size
== 0) {
282 /* Partially filled a scsi buffer. Complete immediately. */
286 void esp_command_complete(SCSIRequest
*req
, uint32_t status
,
289 ESPState
*s
= req
->hba_private
;
291 trace_esp_command_complete();
292 if (s
->ti_size
!= 0) {
293 trace_esp_command_complete_unexpected();
299 trace_esp_command_complete_fail();
302 s
->rregs
[ESP_RSTAT
] = STAT_ST
;
304 if (s
->current_req
) {
305 scsi_req_unref(s
->current_req
);
306 s
->current_req
= NULL
;
307 s
->current_dev
= NULL
;
311 void esp_transfer_data(SCSIRequest
*req
, uint32_t len
)
313 ESPState
*s
= req
->hba_private
;
315 trace_esp_transfer_data(s
->dma_left
, s
->ti_size
);
317 s
->async_buf
= scsi_req_get_buf(req
);
320 } else if (s
->dma_counter
!= 0 && s
->ti_size
<= 0) {
321 /* If this was the last part of a DMA transfer then the
322 completion interrupt is deferred to here. */
327 static void handle_ti(ESPState
*s
)
329 uint32_t dmalen
, minlen
;
331 if (s
->dma
&& !s
->dma_enabled
) {
332 s
->dma_cb
= handle_ti
;
336 dmalen
= s
->rregs
[ESP_TCLO
];
337 dmalen
|= s
->rregs
[ESP_TCMID
] << 8;
338 dmalen
|= s
->rregs
[ESP_TCHI
] << 16;
342 s
->dma_counter
= dmalen
;
345 minlen
= (dmalen
< 32) ? dmalen
: 32;
346 else if (s
->ti_size
< 0)
347 minlen
= (dmalen
< -s
->ti_size
) ? dmalen
: -s
->ti_size
;
349 minlen
= (dmalen
< s
->ti_size
) ? dmalen
: s
->ti_size
;
350 trace_esp_handle_ti(minlen
);
352 s
->dma_left
= minlen
;
353 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
355 } else if (s
->do_cmd
) {
356 trace_esp_handle_ti_cmd(s
->cmdlen
);
360 do_cmd(s
, s
->cmdbuf
);
365 void esp_hard_reset(ESPState
*s
)
367 memset(s
->rregs
, 0, ESP_REGS
);
368 memset(s
->wregs
, 0, ESP_REGS
);
377 s
->rregs
[ESP_CFG1
] = 7;
380 static void esp_soft_reset(ESPState
*s
)
382 qemu_irq_lower(s
->irq
);
386 static void parent_esp_reset(ESPState
*s
, int irq
, int level
)
393 uint64_t esp_reg_read(ESPState
*s
, uint32_t saddr
)
397 trace_esp_mem_readb(saddr
, s
->rregs
[saddr
]);
400 if (s
->ti_size
> 0) {
402 if ((s
->rregs
[ESP_RSTAT
] & STAT_PIO_MASK
) == 0) {
404 qemu_log_mask(LOG_UNIMP
,
405 "esp: PIO data read not implemented\n");
406 s
->rregs
[ESP_FIFO
] = 0;
408 s
->rregs
[ESP_FIFO
] = s
->ti_buf
[s
->ti_rptr
++];
412 if (s
->ti_size
== 0) {
418 /* Clear sequence step, interrupt register and all status bits
420 old_val
= s
->rregs
[ESP_RINTR
];
421 s
->rregs
[ESP_RINTR
] = 0;
422 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
423 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
428 /* Return the unique id if the value has never been written */
429 if (!s
->tchi_written
) {
435 return s
->rregs
[saddr
];
438 void esp_reg_write(ESPState
*s
, uint32_t saddr
, uint64_t val
)
440 trace_esp_mem_writeb(saddr
, s
->wregs
[saddr
], val
);
443 s
->tchi_written
= true;
447 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
451 s
->cmdbuf
[s
->cmdlen
++] = val
& 0xff;
452 } else if (s
->ti_size
== TI_BUFSZ
- 1) {
453 trace_esp_error_fifo_overrun();
456 s
->ti_buf
[s
->ti_wptr
++] = val
& 0xff;
460 s
->rregs
[saddr
] = val
;
463 /* Reload DMA counter. */
464 s
->rregs
[ESP_TCLO
] = s
->wregs
[ESP_TCLO
];
465 s
->rregs
[ESP_TCMID
] = s
->wregs
[ESP_TCMID
];
466 s
->rregs
[ESP_TCHI
] = s
->wregs
[ESP_TCHI
];
470 switch(val
& CMD_CMD
) {
472 trace_esp_mem_writeb_cmd_nop(val
);
475 trace_esp_mem_writeb_cmd_flush(val
);
477 s
->rregs
[ESP_RINTR
] = INTR_FC
;
478 s
->rregs
[ESP_RSEQ
] = 0;
479 s
->rregs
[ESP_RFLAGS
] = 0;
482 trace_esp_mem_writeb_cmd_reset(val
);
486 trace_esp_mem_writeb_cmd_bus_reset(val
);
487 s
->rregs
[ESP_RINTR
] = INTR_RST
;
488 if (!(s
->wregs
[ESP_CFG1
] & CFG1_RESREPT
)) {
496 trace_esp_mem_writeb_cmd_iccs(val
);
498 s
->rregs
[ESP_RINTR
] = INTR_FC
;
499 s
->rregs
[ESP_RSTAT
] |= STAT_MI
;
502 trace_esp_mem_writeb_cmd_msgacc(val
);
503 s
->rregs
[ESP_RINTR
] = INTR_DC
;
504 s
->rregs
[ESP_RSEQ
] = 0;
505 s
->rregs
[ESP_RFLAGS
] = 0;
509 trace_esp_mem_writeb_cmd_pad(val
);
510 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
511 s
->rregs
[ESP_RINTR
] = INTR_FC
;
512 s
->rregs
[ESP_RSEQ
] = 0;
515 trace_esp_mem_writeb_cmd_satn(val
);
518 trace_esp_mem_writeb_cmd_rstatn(val
);
521 trace_esp_mem_writeb_cmd_sel(val
);
522 handle_s_without_atn(s
);
525 trace_esp_mem_writeb_cmd_selatn(val
);
529 trace_esp_mem_writeb_cmd_selatns(val
);
533 trace_esp_mem_writeb_cmd_ensel(val
);
534 s
->rregs
[ESP_RINTR
] = 0;
537 trace_esp_mem_writeb_cmd_dissel(val
);
538 s
->rregs
[ESP_RINTR
] = 0;
542 trace_esp_error_unhandled_command(val
);
546 case ESP_WBUSID
... ESP_WSYNO
:
549 case ESP_CFG2
: case ESP_CFG3
:
550 case ESP_RES3
: case ESP_RES4
:
551 s
->rregs
[saddr
] = val
;
553 case ESP_WCCF
... ESP_WTEST
:
556 trace_esp_error_invalid_write(val
, saddr
);
559 s
->wregs
[saddr
] = val
;
562 static bool esp_mem_accepts(void *opaque
, hwaddr addr
,
563 unsigned size
, bool is_write
)
565 return (size
== 1) || (is_write
&& size
== 4);
568 const VMStateDescription vmstate_esp
= {
571 .minimum_version_id
= 3,
572 .fields
= (VMStateField
[]) {
573 VMSTATE_BUFFER(rregs
, ESPState
),
574 VMSTATE_BUFFER(wregs
, ESPState
),
575 VMSTATE_INT32(ti_size
, ESPState
),
576 VMSTATE_UINT32(ti_rptr
, ESPState
),
577 VMSTATE_UINT32(ti_wptr
, ESPState
),
578 VMSTATE_BUFFER(ti_buf
, ESPState
),
579 VMSTATE_UINT32(status
, ESPState
),
580 VMSTATE_UINT32(dma
, ESPState
),
581 VMSTATE_BUFFER(cmdbuf
, ESPState
),
582 VMSTATE_UINT32(cmdlen
, ESPState
),
583 VMSTATE_UINT32(do_cmd
, ESPState
),
584 VMSTATE_UINT32(dma_left
, ESPState
),
585 VMSTATE_END_OF_LIST()
589 #define TYPE_ESP "esp"
590 #define ESP(obj) OBJECT_CHECK(SysBusESPState, (obj), TYPE_ESP)
594 SysBusDevice parent_obj
;
602 static void sysbus_esp_mem_write(void *opaque
, hwaddr addr
,
603 uint64_t val
, unsigned int size
)
605 SysBusESPState
*sysbus
= opaque
;
608 saddr
= addr
>> sysbus
->it_shift
;
609 esp_reg_write(&sysbus
->esp
, saddr
, val
);
612 static uint64_t sysbus_esp_mem_read(void *opaque
, hwaddr addr
,
615 SysBusESPState
*sysbus
= opaque
;
618 saddr
= addr
>> sysbus
->it_shift
;
619 return esp_reg_read(&sysbus
->esp
, saddr
);
622 static const MemoryRegionOps sysbus_esp_mem_ops
= {
623 .read
= sysbus_esp_mem_read
,
624 .write
= sysbus_esp_mem_write
,
625 .endianness
= DEVICE_NATIVE_ENDIAN
,
626 .valid
.accepts
= esp_mem_accepts
,
629 void esp_init(hwaddr espaddr
, int it_shift
,
630 ESPDMAMemoryReadWriteFunc dma_memory_read
,
631 ESPDMAMemoryReadWriteFunc dma_memory_write
,
632 void *dma_opaque
, qemu_irq irq
, qemu_irq
*reset
,
633 qemu_irq
*dma_enable
)
637 SysBusESPState
*sysbus
;
640 dev
= qdev_create(NULL
, TYPE_ESP
);
643 esp
->dma_memory_read
= dma_memory_read
;
644 esp
->dma_memory_write
= dma_memory_write
;
645 esp
->dma_opaque
= dma_opaque
;
646 sysbus
->it_shift
= it_shift
;
647 /* XXX for now until rc4030 has been changed to use DMA enable signal */
648 esp
->dma_enabled
= 1;
649 qdev_init_nofail(dev
);
650 s
= SYS_BUS_DEVICE(dev
);
651 sysbus_connect_irq(s
, 0, irq
);
652 sysbus_mmio_map(s
, 0, espaddr
);
653 *reset
= qdev_get_gpio_in(dev
, 0);
654 *dma_enable
= qdev_get_gpio_in(dev
, 1);
657 static const struct SCSIBusInfo esp_scsi_info
= {
659 .max_target
= ESP_MAX_DEVS
,
662 .transfer_data
= esp_transfer_data
,
663 .complete
= esp_command_complete
,
664 .cancel
= esp_request_cancelled
667 static void sysbus_esp_gpio_demux(void *opaque
, int irq
, int level
)
669 SysBusESPState
*sysbus
= ESP(opaque
);
670 ESPState
*s
= &sysbus
->esp
;
674 parent_esp_reset(s
, irq
, level
);
677 esp_dma_enable(opaque
, irq
, level
);
682 static void sysbus_esp_realize(DeviceState
*dev
, Error
**errp
)
684 SysBusDevice
*sbd
= SYS_BUS_DEVICE(dev
);
685 SysBusESPState
*sysbus
= ESP(dev
);
686 ESPState
*s
= &sysbus
->esp
;
689 sysbus_init_irq(sbd
, &s
->irq
);
690 assert(sysbus
->it_shift
!= -1);
692 s
->chip_id
= TCHI_FAS100A
;
693 memory_region_init_io(&sysbus
->iomem
, OBJECT(sysbus
), &sysbus_esp_mem_ops
,
694 sysbus
, "esp", ESP_REGS
<< sysbus
->it_shift
);
695 sysbus_init_mmio(sbd
, &sysbus
->iomem
);
697 qdev_init_gpio_in(dev
, sysbus_esp_gpio_demux
, 2);
699 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), dev
, &esp_scsi_info
, NULL
);
700 scsi_bus_legacy_handle_cmdline(&s
->bus
, &err
);
702 error_propagate(errp
, err
);
707 static void sysbus_esp_hard_reset(DeviceState
*dev
)
709 SysBusESPState
*sysbus
= ESP(dev
);
710 esp_hard_reset(&sysbus
->esp
);
713 static const VMStateDescription vmstate_sysbus_esp_scsi
= {
714 .name
= "sysbusespscsi",
716 .minimum_version_id
= 0,
717 .fields
= (VMStateField
[]) {
718 VMSTATE_STRUCT(esp
, SysBusESPState
, 0, vmstate_esp
, ESPState
),
719 VMSTATE_END_OF_LIST()
723 static void sysbus_esp_class_init(ObjectClass
*klass
, void *data
)
725 DeviceClass
*dc
= DEVICE_CLASS(klass
);
727 dc
->realize
= sysbus_esp_realize
;
728 dc
->reset
= sysbus_esp_hard_reset
;
729 dc
->vmsd
= &vmstate_sysbus_esp_scsi
;
730 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
733 static const TypeInfo sysbus_esp_info
= {
735 .parent
= TYPE_SYS_BUS_DEVICE
,
736 .instance_size
= sizeof(SysBusESPState
),
737 .class_init
= sysbus_esp_class_init
,
740 static void esp_register_types(void)
742 type_register_static(&sysbus_esp_info
);
745 type_init(esp_register_types
)