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"
33 * On Sparc32, this is the ESP (NCR53C90) part of chip STP2000 (Master I/O),
34 * also produced as NCR89C100. See
35 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR89C100.txt
37 * http://www.ibiblio.org/pub/historic-linux/early-ports/Sparc/NCR/NCR53C9X.txt
40 static void esp_raise_irq(ESPState
*s
)
42 if (!(s
->rregs
[ESP_RSTAT
] & STAT_INT
)) {
43 s
->rregs
[ESP_RSTAT
] |= STAT_INT
;
44 qemu_irq_raise(s
->irq
);
45 trace_esp_raise_irq();
49 static void esp_lower_irq(ESPState
*s
)
51 if (s
->rregs
[ESP_RSTAT
] & STAT_INT
) {
52 s
->rregs
[ESP_RSTAT
] &= ~STAT_INT
;
53 qemu_irq_lower(s
->irq
);
54 trace_esp_lower_irq();
58 void esp_dma_enable(ESPState
*s
, int irq
, int level
)
62 trace_esp_dma_enable();
68 trace_esp_dma_disable();
73 void esp_request_cancelled(SCSIRequest
*req
)
75 ESPState
*s
= req
->hba_private
;
77 if (req
== s
->current_req
) {
78 scsi_req_unref(s
->current_req
);
79 s
->current_req
= NULL
;
80 s
->current_dev
= NULL
;
84 static uint32_t get_cmd(ESPState
*s
, uint8_t *buf
)
89 target
= s
->wregs
[ESP_WBUSID
] & BUSID_DID
;
91 dmalen
= s
->rregs
[ESP_TCLO
];
92 dmalen
|= s
->rregs
[ESP_TCMID
] << 8;
93 dmalen
|= s
->rregs
[ESP_TCHI
] << 16;
94 s
->dma_memory_read(s
->dma_opaque
, buf
, dmalen
);
97 memcpy(buf
, s
->ti_buf
, dmalen
);
100 trace_esp_get_cmd(dmalen
, target
);
106 if (s
->current_req
) {
107 /* Started a new command before the old one finished. Cancel it. */
108 scsi_req_cancel(s
->current_req
);
112 s
->current_dev
= scsi_device_find(&s
->bus
, 0, target
, 0);
113 if (!s
->current_dev
) {
115 s
->rregs
[ESP_RSTAT
] = 0;
116 s
->rregs
[ESP_RINTR
] = INTR_DC
;
117 s
->rregs
[ESP_RSEQ
] = SEQ_0
;
124 static void do_busid_cmd(ESPState
*s
, uint8_t *buf
, uint8_t busid
)
128 SCSIDevice
*current_lun
;
130 trace_esp_do_busid_cmd(busid
);
132 current_lun
= scsi_device_find(&s
->bus
, 0, s
->current_dev
->id
, lun
);
133 s
->current_req
= scsi_req_new(current_lun
, 0, lun
, buf
, s
);
134 datalen
= scsi_req_enqueue(s
->current_req
);
135 s
->ti_size
= datalen
;
137 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
141 s
->rregs
[ESP_RSTAT
] |= STAT_DI
;
143 s
->rregs
[ESP_RSTAT
] |= STAT_DO
;
145 scsi_req_continue(s
->current_req
);
147 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
148 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
152 static void do_cmd(ESPState
*s
, uint8_t *buf
)
154 uint8_t busid
= buf
[0];
156 do_busid_cmd(s
, &buf
[1], busid
);
159 static void handle_satn(ESPState
*s
)
164 if (s
->dma
&& !s
->dma_enabled
) {
165 s
->dma_cb
= handle_satn
;
168 len
= get_cmd(s
, buf
);
173 static void handle_s_without_atn(ESPState
*s
)
178 if (s
->dma
&& !s
->dma_enabled
) {
179 s
->dma_cb
= handle_s_without_atn
;
182 len
= get_cmd(s
, buf
);
184 do_busid_cmd(s
, buf
, 0);
188 static void handle_satn_stop(ESPState
*s
)
190 if (s
->dma
&& !s
->dma_enabled
) {
191 s
->dma_cb
= handle_satn_stop
;
194 s
->cmdlen
= get_cmd(s
, s
->cmdbuf
);
196 trace_esp_handle_satn_stop(s
->cmdlen
);
198 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_CD
;
199 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
200 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
205 static void write_response(ESPState
*s
)
207 trace_esp_write_response(s
->status
);
208 s
->ti_buf
[0] = s
->status
;
211 s
->dma_memory_write(s
->dma_opaque
, s
->ti_buf
, 2);
212 s
->rregs
[ESP_RSTAT
] = STAT_TC
| STAT_ST
;
213 s
->rregs
[ESP_RINTR
] = INTR_BS
| INTR_FC
;
214 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
219 s
->rregs
[ESP_RFLAGS
] = 2;
224 static void esp_dma_done(ESPState
*s
)
226 s
->rregs
[ESP_RSTAT
] |= STAT_TC
;
227 s
->rregs
[ESP_RINTR
] = INTR_BS
;
228 s
->rregs
[ESP_RSEQ
] = 0;
229 s
->rregs
[ESP_RFLAGS
] = 0;
230 s
->rregs
[ESP_TCLO
] = 0;
231 s
->rregs
[ESP_TCMID
] = 0;
232 s
->rregs
[ESP_TCHI
] = 0;
236 static void esp_do_dma(ESPState
*s
)
241 to_device
= (s
->ti_size
< 0);
244 trace_esp_do_dma(s
->cmdlen
, len
);
245 s
->dma_memory_read(s
->dma_opaque
, &s
->cmdbuf
[s
->cmdlen
], len
);
249 do_cmd(s
, s
->cmdbuf
);
252 if (s
->async_len
== 0) {
253 /* Defer until data is available. */
256 if (len
> s
->async_len
) {
260 s
->dma_memory_read(s
->dma_opaque
, s
->async_buf
, len
);
262 s
->dma_memory_write(s
->dma_opaque
, s
->async_buf
, len
);
271 if (s
->async_len
== 0) {
272 scsi_req_continue(s
->current_req
);
273 /* If there is still data to be read from the device then
274 complete the DMA operation immediately. Otherwise defer
275 until the scsi layer has completed. */
276 if (to_device
|| s
->dma_left
!= 0 || s
->ti_size
== 0) {
281 /* Partially filled a scsi buffer. Complete immediately. */
285 void esp_command_complete(SCSIRequest
*req
, uint32_t status
,
288 ESPState
*s
= req
->hba_private
;
290 trace_esp_command_complete();
291 if (s
->ti_size
!= 0) {
292 trace_esp_command_complete_unexpected();
298 trace_esp_command_complete_fail();
301 s
->rregs
[ESP_RSTAT
] = STAT_ST
;
303 if (s
->current_req
) {
304 scsi_req_unref(s
->current_req
);
305 s
->current_req
= NULL
;
306 s
->current_dev
= NULL
;
310 void esp_transfer_data(SCSIRequest
*req
, uint32_t len
)
312 ESPState
*s
= req
->hba_private
;
314 trace_esp_transfer_data(s
->dma_left
, s
->ti_size
);
316 s
->async_buf
= scsi_req_get_buf(req
);
319 } else if (s
->dma_counter
!= 0 && s
->ti_size
<= 0) {
320 /* If this was the last part of a DMA transfer then the
321 completion interrupt is deferred to here. */
326 static void handle_ti(ESPState
*s
)
328 uint32_t dmalen
, minlen
;
330 if (s
->dma
&& !s
->dma_enabled
) {
331 s
->dma_cb
= handle_ti
;
335 dmalen
= s
->rregs
[ESP_TCLO
];
336 dmalen
|= s
->rregs
[ESP_TCMID
] << 8;
337 dmalen
|= s
->rregs
[ESP_TCHI
] << 16;
341 s
->dma_counter
= dmalen
;
344 minlen
= (dmalen
< 32) ? dmalen
: 32;
345 else if (s
->ti_size
< 0)
346 minlen
= (dmalen
< -s
->ti_size
) ? dmalen
: -s
->ti_size
;
348 minlen
= (dmalen
< s
->ti_size
) ? dmalen
: s
->ti_size
;
349 trace_esp_handle_ti(minlen
);
351 s
->dma_left
= minlen
;
352 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
354 } else if (s
->do_cmd
) {
355 trace_esp_handle_ti_cmd(s
->cmdlen
);
359 do_cmd(s
, s
->cmdbuf
);
364 void esp_hard_reset(ESPState
*s
)
366 memset(s
->rregs
, 0, ESP_REGS
);
367 memset(s
->wregs
, 0, ESP_REGS
);
376 s
->rregs
[ESP_CFG1
] = 7;
379 static void esp_soft_reset(ESPState
*s
)
381 qemu_irq_lower(s
->irq
);
385 static void parent_esp_reset(ESPState
*s
, int irq
, int level
)
392 uint64_t esp_reg_read(ESPState
*s
, uint32_t saddr
)
396 trace_esp_mem_readb(saddr
, s
->rregs
[saddr
]);
399 if (s
->ti_size
> 0) {
401 if ((s
->rregs
[ESP_RSTAT
] & STAT_PIO_MASK
) == 0) {
403 qemu_log_mask(LOG_UNIMP
,
404 "esp: PIO data read not implemented\n");
405 s
->rregs
[ESP_FIFO
] = 0;
407 s
->rregs
[ESP_FIFO
] = s
->ti_buf
[s
->ti_rptr
++];
411 if (s
->ti_size
== 0) {
417 /* Clear sequence step, interrupt register and all status bits
419 old_val
= s
->rregs
[ESP_RINTR
];
420 s
->rregs
[ESP_RINTR
] = 0;
421 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
422 s
->rregs
[ESP_RSEQ
] = SEQ_CD
;
427 /* Return the unique id if the value has never been written */
428 if (!s
->tchi_written
) {
434 return s
->rregs
[saddr
];
437 void esp_reg_write(ESPState
*s
, uint32_t saddr
, uint64_t val
)
439 trace_esp_mem_writeb(saddr
, s
->wregs
[saddr
], val
);
442 s
->tchi_written
= true;
446 s
->rregs
[ESP_RSTAT
] &= ~STAT_TC
;
450 s
->cmdbuf
[s
->cmdlen
++] = val
& 0xff;
451 } else if (s
->ti_size
== TI_BUFSZ
- 1) {
452 trace_esp_error_fifo_overrun();
455 s
->ti_buf
[s
->ti_wptr
++] = val
& 0xff;
459 s
->rregs
[saddr
] = val
;
462 /* Reload DMA counter. */
463 s
->rregs
[ESP_TCLO
] = s
->wregs
[ESP_TCLO
];
464 s
->rregs
[ESP_TCMID
] = s
->wregs
[ESP_TCMID
];
465 s
->rregs
[ESP_TCHI
] = s
->wregs
[ESP_TCHI
];
469 switch(val
& CMD_CMD
) {
471 trace_esp_mem_writeb_cmd_nop(val
);
474 trace_esp_mem_writeb_cmd_flush(val
);
476 s
->rregs
[ESP_RINTR
] = INTR_FC
;
477 s
->rregs
[ESP_RSEQ
] = 0;
478 s
->rregs
[ESP_RFLAGS
] = 0;
481 trace_esp_mem_writeb_cmd_reset(val
);
485 trace_esp_mem_writeb_cmd_bus_reset(val
);
486 s
->rregs
[ESP_RINTR
] = INTR_RST
;
487 if (!(s
->wregs
[ESP_CFG1
] & CFG1_RESREPT
)) {
495 trace_esp_mem_writeb_cmd_iccs(val
);
497 s
->rregs
[ESP_RINTR
] = INTR_FC
;
498 s
->rregs
[ESP_RSTAT
] |= STAT_MI
;
501 trace_esp_mem_writeb_cmd_msgacc(val
);
502 s
->rregs
[ESP_RINTR
] = INTR_DC
;
503 s
->rregs
[ESP_RSEQ
] = 0;
504 s
->rregs
[ESP_RFLAGS
] = 0;
508 trace_esp_mem_writeb_cmd_pad(val
);
509 s
->rregs
[ESP_RSTAT
] = STAT_TC
;
510 s
->rregs
[ESP_RINTR
] = INTR_FC
;
511 s
->rregs
[ESP_RSEQ
] = 0;
514 trace_esp_mem_writeb_cmd_satn(val
);
517 trace_esp_mem_writeb_cmd_rstatn(val
);
520 trace_esp_mem_writeb_cmd_sel(val
);
521 handle_s_without_atn(s
);
524 trace_esp_mem_writeb_cmd_selatn(val
);
528 trace_esp_mem_writeb_cmd_selatns(val
);
532 trace_esp_mem_writeb_cmd_ensel(val
);
533 s
->rregs
[ESP_RINTR
] = 0;
536 trace_esp_mem_writeb_cmd_dissel(val
);
537 s
->rregs
[ESP_RINTR
] = 0;
541 trace_esp_error_unhandled_command(val
);
545 case ESP_WBUSID
... ESP_WSYNO
:
548 case ESP_CFG2
: case ESP_CFG3
:
549 case ESP_RES3
: case ESP_RES4
:
550 s
->rregs
[saddr
] = val
;
552 case ESP_WCCF
... ESP_WTEST
:
555 trace_esp_error_invalid_write(val
, saddr
);
558 s
->wregs
[saddr
] = val
;
561 static bool esp_mem_accepts(void *opaque
, hwaddr addr
,
562 unsigned size
, bool is_write
)
564 return (size
== 1) || (is_write
&& size
== 4);
567 const VMStateDescription vmstate_esp
= {
570 .minimum_version_id
= 3,
571 .fields
= (VMStateField
[]) {
572 VMSTATE_BUFFER(rregs
, ESPState
),
573 VMSTATE_BUFFER(wregs
, ESPState
),
574 VMSTATE_INT32(ti_size
, ESPState
),
575 VMSTATE_UINT32(ti_rptr
, ESPState
),
576 VMSTATE_UINT32(ti_wptr
, ESPState
),
577 VMSTATE_BUFFER(ti_buf
, ESPState
),
578 VMSTATE_UINT32(status
, ESPState
),
579 VMSTATE_UINT32(dma
, ESPState
),
580 VMSTATE_BUFFER(cmdbuf
, ESPState
),
581 VMSTATE_UINT32(cmdlen
, ESPState
),
582 VMSTATE_UINT32(do_cmd
, ESPState
),
583 VMSTATE_UINT32(dma_left
, ESPState
),
584 VMSTATE_END_OF_LIST()
588 #define TYPE_ESP "esp"
589 #define ESP(obj) OBJECT_CHECK(SysBusESPState, (obj), TYPE_ESP)
593 SysBusDevice parent_obj
;
601 static void sysbus_esp_mem_write(void *opaque
, hwaddr addr
,
602 uint64_t val
, unsigned int size
)
604 SysBusESPState
*sysbus
= opaque
;
607 saddr
= addr
>> sysbus
->it_shift
;
608 esp_reg_write(&sysbus
->esp
, saddr
, val
);
611 static uint64_t sysbus_esp_mem_read(void *opaque
, hwaddr addr
,
614 SysBusESPState
*sysbus
= opaque
;
617 saddr
= addr
>> sysbus
->it_shift
;
618 return esp_reg_read(&sysbus
->esp
, saddr
);
621 static const MemoryRegionOps sysbus_esp_mem_ops
= {
622 .read
= sysbus_esp_mem_read
,
623 .write
= sysbus_esp_mem_write
,
624 .endianness
= DEVICE_NATIVE_ENDIAN
,
625 .valid
.accepts
= esp_mem_accepts
,
628 void esp_init(hwaddr espaddr
, int it_shift
,
629 ESPDMAMemoryReadWriteFunc dma_memory_read
,
630 ESPDMAMemoryReadWriteFunc dma_memory_write
,
631 void *dma_opaque
, qemu_irq irq
, qemu_irq
*reset
,
632 qemu_irq
*dma_enable
)
636 SysBusESPState
*sysbus
;
639 dev
= qdev_create(NULL
, TYPE_ESP
);
642 esp
->dma_memory_read
= dma_memory_read
;
643 esp
->dma_memory_write
= dma_memory_write
;
644 esp
->dma_opaque
= dma_opaque
;
645 sysbus
->it_shift
= it_shift
;
646 /* XXX for now until rc4030 has been changed to use DMA enable signal */
647 esp
->dma_enabled
= 1;
648 qdev_init_nofail(dev
);
649 s
= SYS_BUS_DEVICE(dev
);
650 sysbus_connect_irq(s
, 0, irq
);
651 sysbus_mmio_map(s
, 0, espaddr
);
652 *reset
= qdev_get_gpio_in(dev
, 0);
653 *dma_enable
= qdev_get_gpio_in(dev
, 1);
656 static const struct SCSIBusInfo esp_scsi_info
= {
658 .max_target
= ESP_MAX_DEVS
,
661 .transfer_data
= esp_transfer_data
,
662 .complete
= esp_command_complete
,
663 .cancel
= esp_request_cancelled
666 static void sysbus_esp_gpio_demux(void *opaque
, int irq
, int level
)
668 SysBusESPState
*sysbus
= ESP(opaque
);
669 ESPState
*s
= &sysbus
->esp
;
673 parent_esp_reset(s
, irq
, level
);
676 esp_dma_enable(opaque
, irq
, level
);
681 static void sysbus_esp_realize(DeviceState
*dev
, Error
**errp
)
683 SysBusDevice
*sbd
= SYS_BUS_DEVICE(dev
);
684 SysBusESPState
*sysbus
= ESP(dev
);
685 ESPState
*s
= &sysbus
->esp
;
688 sysbus_init_irq(sbd
, &s
->irq
);
689 assert(sysbus
->it_shift
!= -1);
691 s
->chip_id
= TCHI_FAS100A
;
692 memory_region_init_io(&sysbus
->iomem
, OBJECT(sysbus
), &sysbus_esp_mem_ops
,
693 sysbus
, "esp", ESP_REGS
<< sysbus
->it_shift
);
694 sysbus_init_mmio(sbd
, &sysbus
->iomem
);
696 qdev_init_gpio_in(dev
, sysbus_esp_gpio_demux
, 2);
698 scsi_bus_new(&s
->bus
, sizeof(s
->bus
), dev
, &esp_scsi_info
, NULL
);
699 scsi_bus_legacy_handle_cmdline(&s
->bus
, &err
);
701 error_propagate(errp
, err
);
706 static void sysbus_esp_hard_reset(DeviceState
*dev
)
708 SysBusESPState
*sysbus
= ESP(dev
);
709 esp_hard_reset(&sysbus
->esp
);
712 static const VMStateDescription vmstate_sysbus_esp_scsi
= {
713 .name
= "sysbusespscsi",
715 .minimum_version_id
= 0,
716 .fields
= (VMStateField
[]) {
717 VMSTATE_STRUCT(esp
, SysBusESPState
, 0, vmstate_esp
, ESPState
),
718 VMSTATE_END_OF_LIST()
722 static void sysbus_esp_class_init(ObjectClass
*klass
, void *data
)
724 DeviceClass
*dc
= DEVICE_CLASS(klass
);
726 dc
->realize
= sysbus_esp_realize
;
727 dc
->reset
= sysbus_esp_hard_reset
;
728 dc
->vmsd
= &vmstate_sysbus_esp_scsi
;
729 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
732 static const TypeInfo sysbus_esp_info
= {
734 .parent
= TYPE_SYS_BUS_DEVICE
,
735 .instance_size
= sizeof(SysBusESPState
),
736 .class_init
= sysbus_esp_class_init
,
739 static void esp_register_types(void)
741 type_register_static(&sysbus_esp_info
);
744 type_init(esp_register_types
)