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/pci/pci_device.h"
29 #include "hw/nvram/eeprom93xx.h"
30 #include "hw/scsi/esp.h"
31 #include "migration/vmstate.h"
33 #include "qapi/error.h"
35 #include "qemu/module.h"
36 #include "qom/object.h"
38 #define TYPE_AM53C974_DEVICE "am53c974"
40 typedef struct PCIESPState PCIESPState
;
41 DECLARE_INSTANCE_CHECKER(PCIESPState
, PCI_ESP
,
53 #define DMA_CMD_MASK 0x03
54 #define DMA_CMD_DIAG 0x04
55 #define DMA_CMD_MDL 0x10
56 #define DMA_CMD_INTE_P 0x20
57 #define DMA_CMD_INTE_D 0x40
58 #define DMA_CMD_DIR 0x80
60 #define DMA_STAT_PWDN 0x01
61 #define DMA_STAT_ERROR 0x02
62 #define DMA_STAT_ABORT 0x04
63 #define DMA_STAT_DONE 0x08
64 #define DMA_STAT_SCSIINT 0x10
65 #define DMA_STAT_BCMBLT 0x20
67 #define SBAC_STATUS (1 << 24)
80 static void esp_pci_update_irq(PCIESPState
*pci
)
82 int scsi_level
= !!(pci
->dma_regs
[DMA_STAT
] & DMA_STAT_SCSIINT
);
83 int dma_level
= (pci
->dma_regs
[DMA_CMD
] & DMA_CMD_INTE_D
) ?
84 !!(pci
->dma_regs
[DMA_STAT
] & DMA_STAT_DONE
) : 0;
85 int level
= scsi_level
|| dma_level
;
87 pci_set_irq(PCI_DEVICE(pci
), level
);
90 static void esp_irq_handler(void *opaque
, int irq_num
, int level
)
92 PCIESPState
*pci
= PCI_ESP(opaque
);
95 pci
->dma_regs
[DMA_STAT
] |= DMA_STAT_SCSIINT
;
98 * If raising the ESP IRQ to indicate end of DMA transfer, set
99 * DMA_STAT_DONE at the same time. In theory this should be done in
100 * esp_pci_dma_memory_rw(), however there is a delay between setting
101 * DMA_STAT_DONE and the ESP IRQ arriving which is visible to the
102 * guest that can cause confusion e.g. Linux
104 if ((pci
->dma_regs
[DMA_CMD
] & DMA_CMD_MASK
) == 0x3 &&
105 pci
->dma_regs
[DMA_WBC
] == 0) {
106 pci
->dma_regs
[DMA_STAT
] |= DMA_STAT_DONE
;
109 pci
->dma_regs
[DMA_STAT
] &= ~DMA_STAT_SCSIINT
;
112 esp_pci_update_irq(pci
);
115 static void esp_pci_handle_idle(PCIESPState
*pci
, uint32_t val
)
117 ESPState
*s
= &pci
->esp
;
119 trace_esp_pci_dma_idle(val
);
120 esp_dma_enable(s
, 0, 0);
123 static void esp_pci_handle_blast(PCIESPState
*pci
, uint32_t val
)
125 trace_esp_pci_dma_blast(val
);
126 qemu_log_mask(LOG_UNIMP
, "am53c974: cmd BLAST not implemented\n");
129 static void esp_pci_handle_abort(PCIESPState
*pci
, uint32_t val
)
131 ESPState
*s
= &pci
->esp
;
133 trace_esp_pci_dma_abort(val
);
134 if (s
->current_req
) {
135 scsi_req_cancel(s
->current_req
);
139 static void esp_pci_handle_start(PCIESPState
*pci
, uint32_t val
)
141 ESPState
*s
= &pci
->esp
;
143 trace_esp_pci_dma_start(val
);
145 pci
->dma_regs
[DMA_WBC
] = pci
->dma_regs
[DMA_STC
];
146 pci
->dma_regs
[DMA_WAC
] = pci
->dma_regs
[DMA_SPA
];
147 pci
->dma_regs
[DMA_WMAC
] = pci
->dma_regs
[DMA_SMDLA
];
149 pci
->dma_regs
[DMA_STAT
] &= ~(DMA_STAT_BCMBLT
| DMA_STAT_SCSIINT
150 | DMA_STAT_DONE
| DMA_STAT_ABORT
151 | DMA_STAT_ERROR
| DMA_STAT_PWDN
);
153 esp_dma_enable(s
, 0, 1);
156 static void esp_pci_dma_write(PCIESPState
*pci
, uint32_t saddr
, uint32_t val
)
158 trace_esp_pci_dma_write(saddr
, pci
->dma_regs
[saddr
], val
);
161 pci
->dma_regs
[saddr
] = val
;
162 switch (val
& DMA_CMD_MASK
) {
164 esp_pci_handle_idle(pci
, val
);
166 case 0x1: /* BLAST */
167 esp_pci_handle_blast(pci
, val
);
169 case 0x2: /* ABORT */
170 esp_pci_handle_abort(pci
, val
);
172 case 0x3: /* START */
173 esp_pci_handle_start(pci
, val
);
175 default: /* can't happen */
182 pci
->dma_regs
[saddr
] = val
;
185 if (pci
->sbac
& SBAC_STATUS
) {
186 /* clear some bits on write */
187 uint32_t mask
= DMA_STAT_ERROR
| DMA_STAT_ABORT
| DMA_STAT_DONE
;
188 pci
->dma_regs
[DMA_STAT
] &= ~(val
& mask
);
189 esp_pci_update_irq(pci
);
193 trace_esp_pci_error_invalid_write_dma(val
, saddr
);
198 static uint32_t esp_pci_dma_read(PCIESPState
*pci
, uint32_t saddr
)
202 val
= pci
->dma_regs
[saddr
];
203 if (saddr
== DMA_STAT
) {
204 if (!(pci
->sbac
& SBAC_STATUS
)) {
205 pci
->dma_regs
[DMA_STAT
] &= ~(DMA_STAT_ERROR
| DMA_STAT_ABORT
|
207 esp_pci_update_irq(pci
);
211 trace_esp_pci_dma_read(saddr
, val
);
215 static void esp_pci_io_write(void *opaque
, hwaddr addr
,
216 uint64_t val
, unsigned int size
)
218 PCIESPState
*pci
= opaque
;
219 ESPState
*s
= &pci
->esp
;
221 if (size
< 4 || addr
& 3) {
222 /* need to upgrade request: we only support 4-bytes accesses */
223 uint32_t current
= 0, mask
;
227 current
= s
->wregs
[addr
>> 2];
228 } else if (addr
< 0x60) {
229 current
= pci
->dma_regs
[(addr
- 0x40) >> 2];
230 } else if (addr
< 0x74) {
234 shift
= (4 - size
) * 8;
235 mask
= (~(uint32_t)0 << shift
) >> shift
;
237 shift
= ((4 - (addr
& 3)) & 3) * 8;
239 val
|= current
& ~(mask
<< shift
);
247 esp_reg_write(s
, addr
>> 2, val
);
248 } else if (addr
< 0x60) {
250 esp_pci_dma_write(pci
, (addr
- 0x40) >> 2, val
);
251 } else if (addr
== 0x70) {
252 /* DMA SCSI Bus and control */
253 trace_esp_pci_sbac_write(pci
->sbac
, val
);
256 trace_esp_pci_error_invalid_write((int)addr
);
260 static uint64_t esp_pci_io_read(void *opaque
, hwaddr addr
,
263 PCIESPState
*pci
= opaque
;
264 ESPState
*s
= &pci
->esp
;
269 ret
= esp_reg_read(s
, addr
>> 2);
270 } else if (addr
< 0x60) {
272 ret
= esp_pci_dma_read(pci
, (addr
- 0x40) >> 2);
273 } else if (addr
== 0x70) {
274 /* DMA SCSI Bus and control */
275 trace_esp_pci_sbac_read(pci
->sbac
);
279 trace_esp_pci_error_invalid_read((int)addr
);
283 /* give only requested data */
284 ret
>>= (addr
& 3) * 8;
285 ret
&= ~(~(uint64_t)0 << (8 * size
));
290 static void esp_pci_dma_memory_rw(PCIESPState
*pci
, uint8_t *buf
, int len
,
294 DMADirection expected_dir
;
296 if (pci
->dma_regs
[DMA_CMD
] & DMA_CMD_DIR
) {
297 expected_dir
= DMA_DIRECTION_FROM_DEVICE
;
299 expected_dir
= DMA_DIRECTION_TO_DEVICE
;
302 if (dir
!= expected_dir
) {
303 trace_esp_pci_error_invalid_dma_direction();
307 if (pci
->dma_regs
[DMA_STAT
] & DMA_CMD_MDL
) {
308 qemu_log_mask(LOG_UNIMP
, "am53c974: MDL transfer not implemented\n");
311 addr
= pci
->dma_regs
[DMA_WAC
];
312 if (pci
->dma_regs
[DMA_WBC
] < len
) {
313 len
= pci
->dma_regs
[DMA_WBC
];
316 pci_dma_rw(PCI_DEVICE(pci
), addr
, buf
, len
, dir
, MEMTXATTRS_UNSPECIFIED
);
318 /* update status registers */
319 pci
->dma_regs
[DMA_WBC
] -= len
;
320 pci
->dma_regs
[DMA_WAC
] += len
;
323 static void esp_pci_dma_memory_read(void *opaque
, uint8_t *buf
, int len
)
325 PCIESPState
*pci
= opaque
;
326 esp_pci_dma_memory_rw(pci
, buf
, len
, DMA_DIRECTION_TO_DEVICE
);
329 static void esp_pci_dma_memory_write(void *opaque
, uint8_t *buf
, int len
)
331 PCIESPState
*pci
= opaque
;
332 esp_pci_dma_memory_rw(pci
, buf
, len
, DMA_DIRECTION_FROM_DEVICE
);
335 static const MemoryRegionOps esp_pci_io_ops
= {
336 .read
= esp_pci_io_read
,
337 .write
= esp_pci_io_write
,
338 .endianness
= DEVICE_LITTLE_ENDIAN
,
340 .min_access_size
= 1,
341 .max_access_size
= 4,
345 static void esp_pci_hard_reset(DeviceState
*dev
)
347 PCIESPState
*pci
= PCI_ESP(dev
);
348 ESPState
*s
= &pci
->esp
;
351 pci
->dma_regs
[DMA_CMD
] &= ~(DMA_CMD_DIR
| DMA_CMD_INTE_D
| DMA_CMD_INTE_P
352 | DMA_CMD_MDL
| DMA_CMD_DIAG
| DMA_CMD_MASK
);
353 pci
->dma_regs
[DMA_WBC
] &= ~0xffff;
354 pci
->dma_regs
[DMA_WAC
] = 0xffffffff;
355 pci
->dma_regs
[DMA_STAT
] &= ~(DMA_STAT_BCMBLT
| DMA_STAT_SCSIINT
356 | DMA_STAT_DONE
| DMA_STAT_ABORT
358 pci
->dma_regs
[DMA_WMAC
] = 0xfffffffd;
361 static const VMStateDescription vmstate_esp_pci_scsi
= {
362 .name
= "pciespscsi",
364 .minimum_version_id
= 1,
365 .pre_save
= esp_pre_save
,
366 .fields
= (const VMStateField
[]) {
367 VMSTATE_PCI_DEVICE(parent_obj
, PCIESPState
),
368 VMSTATE_BUFFER_UNSAFE(dma_regs
, PCIESPState
, 0, 8 * sizeof(uint32_t)),
369 VMSTATE_UINT8_V(esp
.mig_version_id
, PCIESPState
, 2),
370 VMSTATE_STRUCT(esp
, PCIESPState
, 0, vmstate_esp
, ESPState
),
371 VMSTATE_END_OF_LIST()
375 static const struct SCSIBusInfo esp_pci_scsi_info
= {
377 .max_target
= ESP_MAX_DEVS
,
380 .transfer_data
= esp_transfer_data
,
381 .complete
= esp_command_complete
,
382 .cancel
= esp_request_cancelled
,
385 static void esp_pci_scsi_realize(PCIDevice
*dev
, Error
**errp
)
387 PCIESPState
*pci
= PCI_ESP(dev
);
388 DeviceState
*d
= DEVICE(dev
);
389 ESPState
*s
= &pci
->esp
;
392 if (!qdev_realize(DEVICE(s
), NULL
, errp
)) {
396 pci_conf
= dev
->config
;
398 /* Interrupt pin A */
399 pci_conf
[PCI_INTERRUPT_PIN
] = 0x01;
401 s
->dma_memory_read
= esp_pci_dma_memory_read
;
402 s
->dma_memory_write
= esp_pci_dma_memory_write
;
404 s
->chip_id
= TCHI_AM53C974
;
405 memory_region_init_io(&pci
->io
, OBJECT(pci
), &esp_pci_io_ops
, pci
,
408 pci_register_bar(dev
, 0, PCI_BASE_ADDRESS_SPACE_IO
, &pci
->io
);
409 s
->irq
= qemu_allocate_irq(esp_irq_handler
, pci
, 0);
411 scsi_bus_init(&s
->bus
, sizeof(s
->bus
), d
, &esp_pci_scsi_info
);
414 static void esp_pci_scsi_exit(PCIDevice
*d
)
416 PCIESPState
*pci
= PCI_ESP(d
);
417 ESPState
*s
= &pci
->esp
;
419 qemu_free_irq(s
->irq
);
422 static void esp_pci_init(Object
*obj
)
424 PCIESPState
*pci
= PCI_ESP(obj
);
426 object_initialize_child(obj
, "esp", &pci
->esp
, TYPE_ESP
);
429 static void esp_pci_class_init(ObjectClass
*klass
, void *data
)
431 DeviceClass
*dc
= DEVICE_CLASS(klass
);
432 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
434 k
->realize
= esp_pci_scsi_realize
;
435 k
->exit
= esp_pci_scsi_exit
;
436 k
->vendor_id
= PCI_VENDOR_ID_AMD
;
437 k
->device_id
= PCI_DEVICE_ID_AMD_SCSI
;
439 k
->class_id
= PCI_CLASS_STORAGE_SCSI
;
440 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
441 dc
->desc
= "AMD Am53c974 PCscsi-PCI SCSI adapter";
442 dc
->reset
= esp_pci_hard_reset
;
443 dc
->vmsd
= &vmstate_esp_pci_scsi
;
446 static const TypeInfo esp_pci_info
= {
447 .name
= TYPE_AM53C974_DEVICE
,
448 .parent
= TYPE_PCI_DEVICE
,
449 .instance_init
= esp_pci_init
,
450 .instance_size
= sizeof(PCIESPState
),
451 .class_init
= esp_pci_class_init
,
452 .interfaces
= (InterfaceInfo
[]) {
453 { INTERFACE_CONVENTIONAL_PCI_DEVICE
},
462 typedef struct DC390State DC390State
;
464 #define TYPE_DC390_DEVICE "dc390"
465 DECLARE_INSTANCE_CHECKER(DC390State
, DC390
,
468 #define EE_ADAPT_SCSI_ID 64
471 #define EE_TAG_CMD_NUM 67
472 #define EE_ADAPT_OPTIONS 68
473 #define EE_BOOT_SCSI_ID 69
474 #define EE_BOOT_SCSI_LUN 70
475 #define EE_CHKSUM1 126
476 #define EE_CHKSUM2 127
478 #define EE_ADAPT_OPTION_F6_F8_AT_BOOT 0x01
479 #define EE_ADAPT_OPTION_BOOT_FROM_CDROM 0x02
480 #define EE_ADAPT_OPTION_INT13 0x04
481 #define EE_ADAPT_OPTION_SCAM_SUPPORT 0x08
484 static uint32_t dc390_read_config(PCIDevice
*dev
, uint32_t addr
, int l
)
486 DC390State
*pci
= DC390(dev
);
489 val
= pci_default_read_config(dev
, addr
, l
);
491 if (addr
== 0x00 && l
== 1) {
492 /* First byte of address space is AND-ed with EEPROM DO line */
493 if (!eeprom93xx_read(pci
->eeprom
)) {
501 static void dc390_write_config(PCIDevice
*dev
,
502 uint32_t addr
, uint32_t val
, int l
)
504 DC390State
*pci
= DC390(dev
);
507 int eesk
= val
& 0x80 ? 1 : 0;
508 int eedi
= val
& 0x40 ? 1 : 0;
509 eeprom93xx_write(pci
->eeprom
, 1, eesk
, eedi
);
510 } else if (addr
== 0xc0) {
512 eeprom93xx_write(pci
->eeprom
, 0, 0, 0);
514 pci_default_write_config(dev
, addr
, val
, l
);
518 static void dc390_scsi_realize(PCIDevice
*dev
, Error
**errp
)
520 DC390State
*pci
= DC390(dev
);
526 /* init base class */
527 esp_pci_scsi_realize(dev
, &err
);
529 error_propagate(errp
, err
);
534 pci
->eeprom
= eeprom93xx_new(DEVICE(dev
), 64);
536 /* set default eeprom values */
537 contents
= (uint8_t *)eeprom93xx_data(pci
->eeprom
);
539 for (i
= 0; i
< 16; i
++) {
540 contents
[i
* 2] = 0x57;
541 contents
[i
* 2 + 1] = 0x00;
543 contents
[EE_ADAPT_SCSI_ID
] = 7;
544 contents
[EE_MODE2
] = 0x0f;
545 contents
[EE_TAG_CMD_NUM
] = 0x04;
546 contents
[EE_ADAPT_OPTIONS
] = EE_ADAPT_OPTION_F6_F8_AT_BOOT
547 | EE_ADAPT_OPTION_BOOT_FROM_CDROM
548 | EE_ADAPT_OPTION_INT13
;
550 /* update eeprom checksum */
551 for (i
= 0; i
< EE_CHKSUM1
; i
+= 2) {
552 chksum
+= contents
[i
] + (((uint16_t)contents
[i
+ 1]) << 8);
554 chksum
= 0x1234 - chksum
;
555 contents
[EE_CHKSUM1
] = chksum
& 0xff;
556 contents
[EE_CHKSUM2
] = chksum
>> 8;
559 static void dc390_class_init(ObjectClass
*klass
, void *data
)
561 DeviceClass
*dc
= DEVICE_CLASS(klass
);
562 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
564 k
->realize
= dc390_scsi_realize
;
565 k
->config_read
= dc390_read_config
;
566 k
->config_write
= dc390_write_config
;
567 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
568 dc
->desc
= "Tekram DC-390 SCSI adapter";
571 static const TypeInfo dc390_info
= {
572 .name
= TYPE_DC390_DEVICE
,
573 .parent
= TYPE_AM53C974_DEVICE
,
574 .instance_size
= sizeof(DC390State
),
575 .class_init
= dc390_class_init
,
578 static void esp_pci_register_types(void)
580 type_register_static(&esp_pci_info
);
581 type_register_static(&dc390_info
);
584 type_init(esp_pci_register_types
)