2 * QEMU LSI53C895A SCSI Host Bus Adapter emulation
4 * Copyright (c) 2006 CodeSourcery.
5 * Written by Paul Brook
7 * This code is licenced under the LGPL.
10 /* ??? Need to check if the {read,write}[wl] routines work properly on
11 big-endian targets. */
16 //#define DEBUG_LSI_REG
19 #define DPRINTF(fmt, args...) \
20 do { printf("lsi_scsi: " fmt , ##args); } while (0)
21 #define BADF(fmt, args...) \
22 do { fprintf(stderr, "lsi_scsi: " fmt , ##args); exit(1);} while (0)
24 #define DPRINTF(fmt, args...) do {} while(0)
25 #define BADF(fmt, args...) \
26 do { fprintf(stderr, "lsi_scsi: " fmt , ##args); } while (0)
29 #define LSI_SCNTL0_TRG 0x01
30 #define LSI_SCNTL0_AAP 0x02
31 #define LSI_SCNTL0_EPC 0x08
32 #define LSI_SCNTL0_WATN 0x10
33 #define LSI_SCNTL0_START 0x20
35 #define LSI_SCNTL1_SST 0x01
36 #define LSI_SCNTL1_IARB 0x02
37 #define LSI_SCNTL1_AESP 0x04
38 #define LSI_SCNTL1_RST 0x08
39 #define LSI_SCNTL1_CON 0x10
40 #define LSI_SCNTL1_DHP 0x20
41 #define LSI_SCNTL1_ADB 0x40
42 #define LSI_SCNTL1_EXC 0x80
44 #define LSI_SCNTL2_WSR 0x01
45 #define LSI_SCNTL2_VUE0 0x02
46 #define LSI_SCNTL2_VUE1 0x04
47 #define LSI_SCNTL2_WSS 0x08
48 #define LSI_SCNTL2_SLPHBEN 0x10
49 #define LSI_SCNTL2_SLPMD 0x20
50 #define LSI_SCNTL2_CHM 0x40
51 #define LSI_SCNTL2_SDU 0x80
53 #define LSI_ISTAT0_DIP 0x01
54 #define LSI_ISTAT0_SIP 0x02
55 #define LSI_ISTAT0_INTF 0x04
56 #define LSI_ISTAT0_CON 0x08
57 #define LSI_ISTAT0_SEM 0x10
58 #define LSI_ISTAT0_SIGP 0x20
59 #define LSI_ISTAT0_SRST 0x40
60 #define LSI_ISTAT0_ABRT 0x80
62 #define LSI_ISTAT1_SI 0x01
63 #define LSI_ISTAT1_SRUN 0x02
64 #define LSI_ISTAT1_FLSH 0x04
66 #define LSI_SSTAT0_SDP0 0x01
67 #define LSI_SSTAT0_RST 0x02
68 #define LSI_SSTAT0_WOA 0x04
69 #define LSI_SSTAT0_LOA 0x08
70 #define LSI_SSTAT0_AIP 0x10
71 #define LSI_SSTAT0_OLF 0x20
72 #define LSI_SSTAT0_ORF 0x40
73 #define LSI_SSTAT0_ILF 0x80
75 #define LSI_SIST0_PAR 0x01
76 #define LSI_SIST0_RST 0x02
77 #define LSI_SIST0_UDC 0x04
78 #define LSI_SIST0_SGE 0x08
79 #define LSI_SIST0_RSL 0x10
80 #define LSI_SIST0_SEL 0x20
81 #define LSI_SIST0_CMP 0x40
82 #define LSI_SIST0_MA 0x80
84 #define LSI_SIST1_HTH 0x01
85 #define LSI_SIST1_GEN 0x02
86 #define LSI_SIST1_STO 0x04
87 #define LSI_SIST1_SBMC 0x10
89 #define LSI_SOCL_IO 0x01
90 #define LSI_SOCL_CD 0x02
91 #define LSI_SOCL_MSG 0x04
92 #define LSI_SOCL_ATN 0x08
93 #define LSI_SOCL_SEL 0x10
94 #define LSI_SOCL_BSY 0x20
95 #define LSI_SOCL_ACK 0x40
96 #define LSI_SOCL_REQ 0x80
98 #define LSI_DSTAT_IID 0x01
99 #define LSI_DSTAT_SIR 0x04
100 #define LSI_DSTAT_SSI 0x08
101 #define LSI_DSTAT_ABRT 0x10
102 #define LSI_DSTAT_BF 0x20
103 #define LSI_DSTAT_MDPE 0x40
104 #define LSI_DSTAT_DFE 0x80
106 #define LSI_DCNTL_COM 0x01
107 #define LSI_DCNTL_IRQD 0x02
108 #define LSI_DCNTL_STD 0x04
109 #define LSI_DCNTL_IRQM 0x08
110 #define LSI_DCNTL_SSM 0x10
111 #define LSI_DCNTL_PFEN 0x20
112 #define LSI_DCNTL_PFF 0x40
113 #define LSI_DCNTL_CLSE 0x80
115 #define LSI_DMODE_MAN 0x01
116 #define LSI_DMODE_BOF 0x02
117 #define LSI_DMODE_ERMP 0x04
118 #define LSI_DMODE_ERL 0x08
119 #define LSI_DMODE_DIOM 0x10
120 #define LSI_DMODE_SIOM 0x20
122 #define LSI_CTEST2_DACK 0x01
123 #define LSI_CTEST2_DREQ 0x02
124 #define LSI_CTEST2_TEOP 0x04
125 #define LSI_CTEST2_PCICIE 0x08
126 #define LSI_CTEST2_CM 0x10
127 #define LSI_CTEST2_CIO 0x20
128 #define LSI_CTEST2_SIGP 0x40
129 #define LSI_CTEST2_DDIR 0x80
131 #define LSI_CTEST5_BL2 0x04
132 #define LSI_CTEST5_DDIR 0x08
133 #define LSI_CTEST5_MASR 0x10
134 #define LSI_CTEST5_DFSN 0x20
135 #define LSI_CTEST5_BBCK 0x40
136 #define LSI_CTEST5_ADCK 0x80
138 #define LSI_CCNTL0_DILS 0x01
139 #define LSI_CCNTL0_DISFC 0x10
140 #define LSI_CCNTL0_ENNDJ 0x20
141 #define LSI_CCNTL0_PMJCTL 0x40
142 #define LSI_CCNTL0_ENPMJ 0x80
152 /* The HBA is ID 7, so for simplicitly limit to 7 devices. */
153 #define LSI_MAX_DEVS 7
159 uint32_t script_ram_base;
162 int carry; /* ??? Should this be an a visible register somewhere? */
165 /* Nonzero if a Wait Reselect instruction has been issued. */
167 SCSIDevice *scsi_dev[LSI_MAX_DEVS];
168 SCSIDevice *current_dev;
227 uint32_t scratch[13]; /* SCRATCHA-SCRATCHR */
229 /* Script ram is stored as 32-bit words in host byteorder. */
230 uint32_t script_ram[2048];
233 static void lsi_soft_reset(LSIState *s)
243 memset(s->scratch, 0, sizeof(s->scratch));
296 static uint8_t lsi_reg_readb(LSIState *s, int offset);
297 static void lsi_reg_writeb(LSIState *s, int offset, uint8_t val);
299 static inline uint32_t read_dword(LSIState *s, uint32_t addr)
303 /* Optimize reading from SCRIPTS RAM. */
304 if ((addr & 0xffffe000) == s->script_ram_base) {
305 return s->script_ram[(addr & 0x1fff) >> 2];
307 cpu_physical_memory_read(addr, (uint8_t *)&buf, 4);
308 return cpu_to_le32(buf);
311 static void lsi_stop_script(LSIState *s)
313 s->istat1 &= ~LSI_ISTAT1_SRUN;
316 static void lsi_update_irq(LSIState *s)
319 static int last_level;
321 /* It's unclear whether the DIP/SIP bits should be cleared when the
322 Interrupt Status Registers are cleared or when istat0 is read.
323 We currently do the formwer, which seems to work. */
326 if (s->dstat & s->dien)
328 s->istat0 |= LSI_ISTAT0_DIP;
330 s->istat0 &= ~LSI_ISTAT0_DIP;
333 if (s->sist0 || s->sist1) {
334 if ((s->sist0 & s->sien0) || (s->sist1 & s->sien1))
336 s->istat0 |= LSI_ISTAT0_SIP;
338 s->istat0 &= ~LSI_ISTAT0_SIP;
340 if (s->istat0 & LSI_ISTAT0_INTF)
343 if (level != last_level) {
344 DPRINTF("Update IRQ level %d dstat %02x sist %02x%02x\n",
345 level, s->dstat, s->sist1, s->sist0);
348 pci_set_irq(&s->pci_dev, 0, level);
351 /* Stop SCRIPTS execution and raise a SCSI interrupt. */
352 static void lsi_script_scsi_interrupt(LSIState *s, int stat0, int stat1)
357 DPRINTF("SCSI Interrupt 0x%02x%02x prev 0x%02x%02x\n",
358 stat1, stat0, s->sist1, s->sist0);
361 /* Stop processor on fatal or unmasked interrupt. As a special hack
362 we don't stop processing when raising STO. Instead continue
363 execution and stop at the next insn that accesses the SCSI bus. */
364 mask0 = s->sien0 | ~(LSI_SIST0_CMP | LSI_SIST0_SEL | LSI_SIST0_RSL);
365 mask1 = s->sien1 | ~(LSI_SIST1_GEN | LSI_SIST1_HTH);
366 mask1 &= ~LSI_SIST1_STO;
367 if (s->sist0 & mask0 || s->sist1 & mask1) {
373 /* Stop SCRIPTS execution and raise a DMA interrupt. */
374 static void lsi_script_dma_interrupt(LSIState *s, int stat)
376 DPRINTF("DMA Interrupt 0x%x prev 0x%x\n", stat, s->dstat);
382 static inline void lsi_set_phase(LSIState *s, int phase)
384 s->sstat1 = (s->sstat1 & ~PHASE_MASK) | phase;
387 static void lsi_bad_phase(LSIState *s, int out, int new_phase)
389 /* Trigger a phase mismatch. */
390 if (s->ccntl0 & LSI_CCNTL0_ENPMJ) {
391 if ((s->ccntl0 & LSI_CCNTL0_PMJCTL) || out) {
396 DPRINTF("Data phase mismatch jump to %08x\n", s->dsp);
398 DPRINTF("Phase mismatch interrupt\n");
399 lsi_script_scsi_interrupt(s, LSI_SIST0_MA, 0);
402 lsi_set_phase(s, new_phase);
405 static void lsi_do_dma(LSIState *s, int out)
407 uint8_t buf[TARGET_PAGE_SIZE];
414 DPRINTF("DMA %s addr=0x%08x len=%d avail=%d\n", out ? "out" : "in",
415 addr, count, s->data_len);
416 /* ??? Too long transfers are truncated. Don't know if this is the
418 if (count > s->data_len) {
419 /* If the DMA length is greater then the device data length then
420 a phase mismatch will occur. */
423 lsi_bad_phase(s, out, PHASE_ST);
428 /* ??? Set SFBR to first data byte. */
430 n = (count > TARGET_PAGE_SIZE) ? TARGET_PAGE_SIZE : count;
432 cpu_physical_memory_read(addr, buf, n);
433 scsi_write_data(s->current_dev, buf, n);
435 scsi_read_data(s->current_dev, buf, n);
436 cpu_physical_memory_write(addr, buf, n);
444 static void lsi_do_command(LSIState *s)
449 DPRINTF("Send command len=%d\n", s->dbc);
452 cpu_physical_memory_read(s->dnad, buf, s->dbc);
454 n = scsi_send_command(s->current_dev, 0, buf, s->current_lun);
457 lsi_set_phase(s, PHASE_DI);
460 lsi_set_phase(s, PHASE_DO);
464 static void lsi_command_complete(void *opaque, uint32_t tag, int sense)
466 LSIState *s = (LSIState *)opaque;
468 DPRINTF("Command complete sense=%d\n", sense);
470 lsi_set_phase(s, PHASE_ST);
473 static void lsi_do_status(LSIState *s)
475 DPRINTF("Get status len=%d sense=%d\n", s->dbc, s->sense);
477 BADF("Bad Status move\n");
480 cpu_physical_memory_write(s->dnad, &s->msg, 1);
482 lsi_set_phase(s, PHASE_MI);
483 s->msg = 0; /* COMMAND COMPLETE */
486 static void lsi_disconnect(LSIState *s)
488 s->scntl1 &= ~LSI_SCNTL1_CON;
489 s->sstat1 &= ~PHASE_MASK;
492 static void lsi_do_msgin(LSIState *s)
494 DPRINTF("Message in len=%d\n", s->dbc);
497 cpu_physical_memory_write(s->dnad, &s->msg, 1);
501 /* ??? Check if ATN (not yet implemented) is asserted and maybe
502 switch to PHASE_MO. */
503 lsi_set_phase(s, PHASE_CMD);
507 static void lsi_do_msgout(LSIState *s)
511 DPRINTF("MSG out len=%d\n", s->dbc);
513 /* Multibyte messages not implemented. */
514 s->msg = 7; /* MESSAGE REJECT */
516 //lsi_bad_phase(s, 1, PHASE_MI);
517 lsi_set_phase(s, PHASE_MI);
520 cpu_physical_memory_read(s->dnad, &msg, 1);
526 DPRINTF("Got Disconnect\n");
530 DPRINTF("Got No Operation\n");
531 lsi_set_phase(s, PHASE_CMD);
534 if ((msg & 0x80) == 0) {
535 DPRINTF("Unimplemented message 0x%d\n", msg);
536 s->msg = 7; /* MESSAGE REJECT */
537 lsi_bad_phase(s, 1, PHASE_MI);
540 s->current_lun = msg & 7;
541 DPRINTF("Select LUN %d\n", s->current_lun);
542 lsi_set_phase(s, PHASE_CMD);
545 /* Sign extend a 24-bit value. */
546 static inline int32_t sxt24(int32_t n)
548 return (n << 8) >> 8;
551 static void lsi_memcpy(LSIState *s, uint32_t dest, uint32_t src, int count)
554 uint8_t buf[TARGET_PAGE_SIZE];
556 DPRINTF("memcpy dest 0x%08x src 0x%08x count %d\n", dest, src, count);
558 n = (count > TARGET_PAGE_SIZE) ? TARGET_PAGE_SIZE : count;
559 cpu_physical_memory_read(src, buf, n);
560 cpu_physical_memory_write(dest, buf, n);
567 static void lsi_execute_script(LSIState *s)
573 s->istat1 |= LSI_ISTAT1_SRUN;
575 insn = read_dword(s, s->dsp);
576 addr = read_dword(s, s->dsp + 4);
577 DPRINTF("SCRIPTS dsp=%08x opcode %08x arg %08x\n", s->dsp, insn, addr);
579 s->dcmd = insn >> 24;
581 switch (insn >> 30) {
582 case 0: /* Block move. */
583 if (s->sist1 & LSI_SIST1_STO) {
584 DPRINTF("Delayed select timeout\n");
588 s->dbc = insn & 0xffffff;
590 if (insn & (1 << 29)) {
591 /* Indirect addressing. */
592 addr = read_dword(s, addr);
593 } else if (insn & (1 << 28)) {
596 /* Table indirect addressing. */
597 offset = sxt24(addr);
598 cpu_physical_memory_read(s->dsa + offset, (uint8_t *)buf, 8);
599 s->dbc = cpu_to_le32(buf[0]);
600 addr = cpu_to_le32(buf[1]);
602 if ((s->sstat1 & PHASE_MASK) != ((insn >> 24) & 7)) {
603 DPRINTF("Wrong phase got %d expected %d\n",
604 s->sstat1 & PHASE_MASK, (insn >> 24) & 7);
605 lsi_script_scsi_interrupt(s, LSI_SIST0_MA, 0);
609 switch (s->sstat1 & 0x7) {
629 BADF("Unimplemented phase %d\n", s->sstat1 & PHASE_MASK);
632 s->dfifo = s->dbc & 0xff;
633 s->ctest5 = (s->ctest5 & 0xfc) | ((s->dbc >> 8) & 3);
636 s->ua = addr + s->dbc;
641 case 1: /* IO or Read/Write instruction. */
642 opcode = (insn >> 27) & 7;
646 if (insn & (1 << 25)) {
647 id = read_dword(s, s->dsa + sxt24(insn));
651 id = (id >> 16) & 0xf;
652 if (insn & (1 << 26)) {
653 addr = s->dsp + sxt24(addr);
658 s->sstat0 |= LSI_SSTAT0_WOA;
659 s->scntl1 &= ~LSI_SCNTL1_IARB;
661 if (id >= LSI_MAX_DEVS || !s->scsi_dev[id]) {
662 DPRINTF("Selected absent target %d\n", id);
663 lsi_script_scsi_interrupt(s, 0, LSI_SIST1_STO);
667 DPRINTF("Selected target %d%s\n",
668 id, insn & (1 << 3) ? " ATN" : "");
669 /* ??? Linux drivers compain when this is set. Maybe
670 it only applies in low-level mode (unimplemented).
671 lsi_script_scsi_interrupt(s, LSI_SIST0_CMP, 0); */
672 s->current_dev = s->scsi_dev[id];
673 s->scntl1 |= LSI_SCNTL1_CON;
674 if (insn & (1 << 3)) {
675 s->socl |= LSI_SOCL_ATN;
677 lsi_set_phase(s, PHASE_MO);
679 case 1: /* Disconnect */
680 DPRINTF("Wait Disconect\n");
681 s->scntl1 &= ~LSI_SCNTL1_CON;
683 case 2: /* Wait Reselect */
684 DPRINTF("Wait Reselect\n");
688 DPRINTF("Set%s%s%s%s\n",
689 insn & (1 << 3) ? " ATN" : "",
690 insn & (1 << 6) ? " ACK" : "",
691 insn & (1 << 9) ? " TM" : "",
692 insn & (1 << 10) ? " CC" : "");
693 if (insn & (1 << 3)) {
694 s->socl |= LSI_SOCL_ATN;
695 lsi_set_phase(s, PHASE_MO);
697 if (insn & (1 << 9)) {
698 BADF("Target mode not implemented\n");
701 if (insn & (1 << 10))
705 DPRINTF("Clear%s%s%s%s\n",
706 insn & (1 << 3) ? " ATN" : "",
707 insn & (1 << 6) ? " ACK" : "",
708 insn & (1 << 9) ? " TM" : "",
709 insn & (1 << 10) ? " CC" : "");
710 if (insn & (1 << 3)) {
711 s->socl &= ~LSI_SOCL_ATN;
713 if (insn & (1 << 10))
724 static const char *opcode_names[3] =
725 {"Write", "Read", "Read-Modify-Write"};
726 static const char *operator_names[8] =
727 {"MOV", "SHL", "OR", "XOR", "AND", "SHR", "ADD", "ADC"};
730 reg = ((insn >> 16) & 0x7f) | (insn & 0x80);
731 data8 = (insn >> 8) & 0xff;
732 opcode = (insn >> 27) & 7;
733 operator = (insn >> 24) & 7;
734 DPRINTF("%s reg 0x%x %s data8 %d%s\n",
735 opcode_names[opcode - 5], reg,
736 operator_names[operator], data8,
737 (insn & (1 << 23)) ? " SFBR" : "");
740 case 5: /* From SFBR */
744 case 6: /* To SFBR */
746 op0 = lsi_reg_readb(s, reg);
749 case 7: /* Read-modify-write */
751 op0 = lsi_reg_readb(s, reg);
752 if (insn & (1 << 23)) {
764 case 1: /* Shift left */
766 op0 = (op0 << 1) | s->carry;
780 op0 = (op0 >> 1) | (s->carry << 7);
784 s->carry = op0 < op1;
787 op0 += op1 + s->carry;
789 s->carry = op0 <= op1;
791 s->carry = op0 < op1;
796 case 5: /* From SFBR */
797 case 7: /* Read-modify-write */
798 lsi_reg_writeb(s, reg, op0);
800 case 6: /* To SFBR */
807 case 2: /* Transfer Control. */
812 if ((insn & 0x002e0000) == 0) {
816 if (s->sist1 & LSI_SIST1_STO) {
817 DPRINTF("Delayed select timeout\n");
821 cond = jmp = (insn & (1 << 19)) != 0;
822 if (cond == jmp && (insn & (1 << 21))) {
823 DPRINTF("Compare carry %d\n", s->carry == jmp);
824 cond = s->carry != 0;
826 if (cond == jmp && (insn & (1 << 17))) {
827 DPRINTF("Compare phase %d %c= %d\n",
828 (s->sstat1 & PHASE_MASK),
831 cond = (s->sstat1 & PHASE_MASK) == ((insn >> 24) & 7);
833 if (cond == jmp && (insn & (1 << 18))) {
836 mask = (~insn >> 8) & 0xff;
837 DPRINTF("Compare data 0x%x & 0x%x %c= 0x%x\n",
838 s->sfbr, mask, jmp ? '=' : '!', insn & mask);
839 cond = (s->sfbr & mask) == (insn & mask);
842 if (insn & (1 << 23)) {
843 /* Relative address. */
844 addr = s->dsp + sxt24(addr);
846 switch ((insn >> 27) & 7) {
848 DPRINTF("Jump to 0x%08x\n", addr);
852 DPRINTF("Call 0x%08x\n", addr);
857 DPRINTF("Return to 0x%08x\n", s->temp);
860 case 3: /* Interrupt */
861 DPRINTF("Interrupt 0x%08x\n", s->dsps);
862 if ((insn & (1 << 20)) != 0) {
863 s->istat0 |= LSI_ISTAT0_INTF;
866 lsi_script_dma_interrupt(s, LSI_DSTAT_SIR);
870 DPRINTF("Illegal transfer control\n");
871 lsi_script_dma_interrupt(s, LSI_DSTAT_IID);
875 DPRINTF("Control condition failed\n");
881 if ((insn & (1 << 29)) == 0) {
884 /* ??? The docs imply the destination address is loaded into
885 the TEMP register. However the Linux drivers rely on
886 the value being presrved. */
887 dest = read_dword(s, s->dsp);
889 lsi_memcpy(s, dest, addr, insn & 0xffffff);
896 if (insn & (1 << 28)) {
897 addr = s->dsa + sxt24(addr);
900 reg = (insn >> 16) & 0xff;
901 if (insn & (1 << 24)) {
902 DPRINTF("Load reg 0x%x size %d addr 0x%08x\n", reg, n, addr);
903 cpu_physical_memory_read(addr, data, n);
904 for (i = 0; i < n; i++) {
905 lsi_reg_writeb(s, reg + i, data[i]);
908 DPRINTF("Store reg 0x%x size %d addr 0x%08x\n", reg, n, addr);
909 for (i = 0; i < n; i++) {
910 data[i] = lsi_reg_readb(s, reg + i);
912 cpu_physical_memory_write(addr, data, n);
916 /* ??? Need to avoid infinite loops. */
917 if (s->istat1 & LSI_ISTAT1_SRUN && !s->waiting) {
918 if (s->dcntl & LSI_DCNTL_SSM) {
919 lsi_script_dma_interrupt(s, LSI_DSTAT_SSI);
924 DPRINTF("SCRIPTS execution stopped\n");
927 static uint8_t lsi_reg_readb(LSIState *s, int offset)
930 #define CASE_GET_REG32(name, addr) \
931 case addr: return s->name & 0xff; \
932 case addr + 1: return (s->name >> 8) & 0xff; \
933 case addr + 2: return (s->name >> 16) & 0xff; \
934 case addr + 3: return (s->name >> 24) & 0xff;
937 DPRINTF("Read reg %x\n", offset);
940 case 0x00: /* SCNTL0 */
942 case 0x01: /* SCNTL1 */
944 case 0x02: /* SCNTL2 */
946 case 0x03: /* SCNTL3 */
948 case 0x04: /* SCID */
950 case 0x05: /* SXFER */
952 case 0x06: /* SDID */
954 case 0x07: /* GPREG0 */
957 /* ??? This is not correct. However it's (hopefully) only
958 used for diagnostics, so should be ok. */
960 case 0xc: /* DSTAT */
961 tmp = s->dstat | 0x80;
962 if ((s->istat0 & LSI_ISTAT0_INTF) == 0)
966 case 0x0d: /* SSTAT0 */
968 case 0x0e: /* SSTAT1 */
970 case 0x0f: /* SSTAT2 */
971 return s->scntl1 & LSI_SCNTL1_CON ? 0 : 2;
972 CASE_GET_REG32(dsa, 0x10)
973 case 0x14: /* ISTAT0 */
975 case 0x16: /* MBOX0 */
977 case 0x17: /* MBOX1 */
979 case 0x18: /* CTEST0 */
981 case 0x19: /* CTEST1 */
983 case 0x1a: /* CTEST2 */
984 tmp = LSI_CTEST2_DACK | LSI_CTEST2_CM;
985 if (s->istat0 & LSI_ISTAT0_SIGP) {
986 s->istat0 &= ~LSI_ISTAT0_SIGP;
987 tmp |= LSI_CTEST2_SIGP;
990 case 0x1b: /* CTEST3 */
992 CASE_GET_REG32(temp, 0x1c)
993 case 0x20: /* DFIFO */
995 case 0x21: /* CTEST4 */
997 case 0x22: /* CTEST5 */
999 case 0x24: /* DBC[0:7] */
1000 return s->dbc & 0xff;
1001 case 0x25: /* DBC[8:15] */
1002 return (s->dbc >> 8) & 0xff;
1003 case 0x26: /* DBC[16->23] */
1004 return (s->dbc >> 16) & 0xff;
1005 case 0x27: /* DCMD */
1007 CASE_GET_REG32(dsp, 0x2c)
1008 CASE_GET_REG32(dsps, 0x30)
1009 CASE_GET_REG32(scratch[0], 0x34)
1010 case 0x38: /* DMODE */
1012 case 0x39: /* DIEN */
1014 case 0x3b: /* DCNTL */
1016 case 0x40: /* SIEN0 */
1018 case 0x41: /* SIEN1 */
1020 case 0x42: /* SIST0 */
1025 case 0x43: /* SIST1 */
1030 case 0x47: /* GPCNTL0 */
1032 case 0x48: /* STIME0 */
1034 case 0x4a: /* RESPID0 */
1036 case 0x4b: /* RESPID1 */
1038 case 0x4d: /* STEST1 */
1040 case 0x4e: /* STEST2 */
1042 case 0x4f: /* STEST3 */
1044 case 0x52: /* STEST4 */
1046 case 0x56: /* CCNTL0 */
1048 case 0x57: /* CCNTL1 */
1050 case 0x58: case 0x59: /* SBDL */
1052 CASE_GET_REG32(mmrs, 0xa0)
1053 CASE_GET_REG32(mmws, 0xa4)
1054 CASE_GET_REG32(sfs, 0xa8)
1055 CASE_GET_REG32(drs, 0xac)
1056 CASE_GET_REG32(sbms, 0xb0)
1057 CASE_GET_REG32(dmbs, 0xb4)
1058 CASE_GET_REG32(dnad64, 0xb8)
1059 CASE_GET_REG32(pmjad1, 0xc0)
1060 CASE_GET_REG32(pmjad2, 0xc4)
1061 CASE_GET_REG32(rbc, 0xc8)
1062 CASE_GET_REG32(ua, 0xcc)
1063 CASE_GET_REG32(ia, 0xd4)
1064 CASE_GET_REG32(sbc, 0xd8)
1065 CASE_GET_REG32(csbc, 0xdc)
1067 if (offset >= 0x5c && offset < 0xa0) {
1070 n = (offset - 0x58) >> 2;
1071 shift = (offset & 3) * 8;
1072 return (s->scratch[n] >> shift) & 0xff;
1074 BADF("readb 0x%x\n", offset);
1076 #undef CASE_GET_REG32
1079 static void lsi_reg_writeb(LSIState *s, int offset, uint8_t val)
1081 #define CASE_SET_REG32(name, addr) \
1082 case addr : s->name &= 0xffffff00; s->name |= val; break; \
1083 case addr + 1: s->name &= 0xffff00ff; s->name |= val << 8; break; \
1084 case addr + 2: s->name &= 0xff00ffff; s->name |= val << 16; break; \
1085 case addr + 3: s->name &= 0x00ffffff; s->name |= val << 24; break;
1087 #ifdef DEBUG_LSI_REG
1088 DPRINTF("Write reg %x = %02x\n", offset, val);
1091 case 0x00: /* SCNTL0 */
1093 if (val & LSI_SCNTL0_START) {
1094 BADF("Start sequence not implemented\n");
1097 case 0x01: /* SCNTL1 */
1098 s->scntl1 = val & ~LSI_SCNTL1_SST;
1099 if (val & LSI_SCNTL1_IARB) {
1100 BADF("Immediate Arbritration not implemented\n");
1102 if (val & LSI_SCNTL1_RST) {
1103 s->sstat0 |= LSI_SSTAT0_RST;
1104 lsi_script_scsi_interrupt(s, LSI_SIST0_RST, 0);
1106 s->sstat0 &= ~LSI_SSTAT0_RST;
1109 case 0x02: /* SCNTL2 */
1110 val &= ~(LSI_SCNTL2_WSR | LSI_SCNTL2_WSS);
1113 case 0x03: /* SCNTL3 */
1116 case 0x04: /* SCID */
1119 case 0x05: /* SXFER */
1122 case 0x07: /* GPREG0 */
1124 case 0x0c: case 0x0d: case 0x0e: case 0x0f:
1125 /* Linux writes to these readonly registers on startup. */
1127 CASE_SET_REG32(dsa, 0x10)
1128 case 0x14: /* ISTAT0 */
1129 s->istat0 = (s->istat0 & 0x0f) | (val & 0xf0);
1130 if (val & LSI_ISTAT0_ABRT) {
1131 lsi_script_dma_interrupt(s, LSI_DSTAT_ABRT);
1133 if (val & LSI_ISTAT0_INTF) {
1134 s->istat0 &= ~LSI_ISTAT0_INTF;
1137 if (s->waiting && val & LSI_ISTAT0_SIGP) {
1138 DPRINTF("Woken by SIGP\n");
1141 lsi_execute_script(s);
1143 if (val & LSI_ISTAT0_SRST) {
1146 case 0x16: /* MBOX0 */
1148 case 0x17: /* MBOX1 */
1150 case 0x1b: /* CTEST3 */
1151 s->ctest3 = val & 0x0f;
1153 CASE_SET_REG32(temp, 0x1c)
1154 case 0x21: /* CTEST4 */
1156 BADF("Unimplemented CTEST4-FBL 0x%x\n", val);
1160 case 0x22: /* CTEST5 */
1161 if (val & (LSI_CTEST5_ADCK | LSI_CTEST5_BBCK)) {
1162 BADF("CTEST5 DMA increment not implemented\n");
1166 case 0x2c: /* DSPS[0:7] */
1167 s->dsp &= 0xffffff00;
1170 case 0x2d: /* DSPS[8:15] */
1171 s->dsp &= 0xffff00ff;
1174 case 0x2e: /* DSPS[16:23] */
1175 s->dsp &= 0xff00ffff;
1176 s->dsp |= val << 16;
1178 case 0x2f: /* DSPS[14:31] */
1179 s->dsp &= 0x00ffffff;
1180 s->dsp |= val << 24;
1181 if ((s->dmode & LSI_DMODE_MAN) == 0
1182 && (s->istat1 & LSI_ISTAT1_SRUN) == 0)
1183 lsi_execute_script(s);
1185 CASE_SET_REG32(dsps, 0x30)
1186 CASE_SET_REG32(scratch[0], 0x34)
1187 case 0x38: /* DMODE */
1188 if (val & (LSI_DMODE_SIOM | LSI_DMODE_DIOM)) {
1189 BADF("IO mappings not implemented\n");
1193 case 0x39: /* DIEN */
1197 case 0x3b: /* DCNTL */
1198 s->dcntl = val & ~(LSI_DCNTL_PFF | LSI_DCNTL_STD);
1199 if ((val & LSI_DCNTL_STD) && (s->istat1 & LSI_ISTAT1_SRUN) == 0)
1200 lsi_execute_script(s);
1202 case 0x40: /* SIEN0 */
1206 case 0x41: /* SIEN1 */
1210 case 0x47: /* GPCNTL0 */
1212 case 0x48: /* STIME0 */
1215 case 0x49: /* STIME1 */
1217 DPRINTF("General purpose timer not implemented\n");
1218 /* ??? Raising the interrupt immediately seems to be sufficient
1219 to keep the FreeBSD driver happy. */
1220 lsi_script_scsi_interrupt(s, 0, LSI_SIST1_GEN);
1223 case 0x4a: /* RESPID0 */
1226 case 0x4b: /* RESPID1 */
1229 case 0x4d: /* STEST1 */
1232 case 0x4e: /* STEST2 */
1234 BADF("Low level mode not implemented\n");
1238 case 0x4f: /* STEST3 */
1240 BADF("SCSI FIFO test mode not implemented\n");
1244 case 0x56: /* CCNTL0 */
1247 case 0x57: /* CCNTL1 */
1250 CASE_SET_REG32(mmrs, 0xa0)
1251 CASE_SET_REG32(mmws, 0xa4)
1252 CASE_SET_REG32(sfs, 0xa8)
1253 CASE_SET_REG32(drs, 0xac)
1254 CASE_SET_REG32(sbms, 0xb0)
1255 CASE_SET_REG32(dmbs, 0xb4)
1256 CASE_SET_REG32(dnad64, 0xb8)
1257 CASE_SET_REG32(pmjad1, 0xc0)
1258 CASE_SET_REG32(pmjad2, 0xc4)
1259 CASE_SET_REG32(rbc, 0xc8)
1260 CASE_SET_REG32(ua, 0xcc)
1261 CASE_SET_REG32(ia, 0xd4)
1262 CASE_SET_REG32(sbc, 0xd8)
1263 CASE_SET_REG32(csbc, 0xdc)
1265 if (offset >= 0x5c && offset < 0xa0) {
1268 n = (offset - 0x58) >> 2;
1269 shift = (offset & 3) * 8;
1270 s->scratch[n] &= ~(0xff << shift);
1271 s->scratch[n] |= (val & 0xff) << shift;
1273 BADF("Unhandled writeb 0x%x = 0x%x\n", offset, val);
1276 #undef CASE_SET_REG32
1279 static void lsi_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1281 LSIState *s = (LSIState *)opaque;
1283 lsi_reg_writeb(s, addr & 0xff, val);
1286 static void lsi_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1288 LSIState *s = (LSIState *)opaque;
1291 lsi_reg_writeb(s, addr, val & 0xff);
1292 lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1295 static void lsi_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1297 LSIState *s = (LSIState *)opaque;
1300 lsi_reg_writeb(s, addr, val & 0xff);
1301 lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1302 lsi_reg_writeb(s, addr + 2, (val >> 16) & 0xff);
1303 lsi_reg_writeb(s, addr + 3, (val >> 24) & 0xff);
1306 static uint32_t lsi_mmio_readb(void *opaque, target_phys_addr_t addr)
1308 LSIState *s = (LSIState *)opaque;
1310 return lsi_reg_readb(s, addr & 0xff);
1313 static uint32_t lsi_mmio_readw(void *opaque, target_phys_addr_t addr)
1315 LSIState *s = (LSIState *)opaque;
1319 val = lsi_reg_readb(s, addr);
1320 val |= lsi_reg_readb(s, addr + 1) << 8;
1324 static uint32_t lsi_mmio_readl(void *opaque, target_phys_addr_t addr)
1326 LSIState *s = (LSIState *)opaque;
1329 val = lsi_reg_readb(s, addr);
1330 val |= lsi_reg_readb(s, addr + 1) << 8;
1331 val |= lsi_reg_readb(s, addr + 2) << 16;
1332 val |= lsi_reg_readb(s, addr + 3) << 24;
1336 static CPUReadMemoryFunc *lsi_mmio_readfn[3] = {
1342 static CPUWriteMemoryFunc *lsi_mmio_writefn[3] = {
1348 static void lsi_ram_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1350 LSIState *s = (LSIState *)opaque;
1355 newval = s->script_ram[addr >> 2];
1356 shift = (addr & 3) * 8;
1357 newval &= ~(0xff << shift);
1358 newval |= val << shift;
1359 s->script_ram[addr >> 2] = newval;
1362 static void lsi_ram_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1364 LSIState *s = (LSIState *)opaque;
1368 newval = s->script_ram[addr >> 2];
1370 newval = (newval & 0xffff) | (val << 16);
1372 newval = (newval & 0xffff0000) | val;
1374 s->script_ram[addr >> 2] = newval;
1378 static void lsi_ram_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1380 LSIState *s = (LSIState *)opaque;
1383 s->script_ram[addr >> 2] = val;
1386 static uint32_t lsi_ram_readb(void *opaque, target_phys_addr_t addr)
1388 LSIState *s = (LSIState *)opaque;
1392 val = s->script_ram[addr >> 2];
1393 val >>= (addr & 3) * 8;
1397 static uint32_t lsi_ram_readw(void *opaque, target_phys_addr_t addr)
1399 LSIState *s = (LSIState *)opaque;
1403 val = s->script_ram[addr >> 2];
1406 return le16_to_cpu(val);
1409 static uint32_t lsi_ram_readl(void *opaque, target_phys_addr_t addr)
1411 LSIState *s = (LSIState *)opaque;
1414 return le32_to_cpu(s->script_ram[addr >> 2]);
1417 static CPUReadMemoryFunc *lsi_ram_readfn[3] = {
1423 static CPUWriteMemoryFunc *lsi_ram_writefn[3] = {
1429 static uint32_t lsi_io_readb(void *opaque, uint32_t addr)
1431 LSIState *s = (LSIState *)opaque;
1432 return lsi_reg_readb(s, addr & 0xff);
1435 static uint32_t lsi_io_readw(void *opaque, uint32_t addr)
1437 LSIState *s = (LSIState *)opaque;
1440 val = lsi_reg_readb(s, addr);
1441 val |= lsi_reg_readb(s, addr + 1) << 8;
1445 static uint32_t lsi_io_readl(void *opaque, uint32_t addr)
1447 LSIState *s = (LSIState *)opaque;
1450 val = lsi_reg_readb(s, addr);
1451 val |= lsi_reg_readb(s, addr + 1) << 8;
1452 val |= lsi_reg_readb(s, addr + 2) << 16;
1453 val |= lsi_reg_readb(s, addr + 3) << 24;
1457 static void lsi_io_writeb(void *opaque, uint32_t addr, uint32_t val)
1459 LSIState *s = (LSIState *)opaque;
1460 lsi_reg_writeb(s, addr & 0xff, val);
1463 static void lsi_io_writew(void *opaque, uint32_t addr, uint32_t val)
1465 LSIState *s = (LSIState *)opaque;
1467 lsi_reg_writeb(s, addr, val & 0xff);
1468 lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1471 static void lsi_io_writel(void *opaque, uint32_t addr, uint32_t val)
1473 LSIState *s = (LSIState *)opaque;
1475 lsi_reg_writeb(s, addr, val & 0xff);
1476 lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1477 lsi_reg_writeb(s, addr + 2, (val >> 16) & 0xff);
1478 lsi_reg_writeb(s, addr + 2, (val >> 24) & 0xff);
1481 static void lsi_io_mapfunc(PCIDevice *pci_dev, int region_num,
1482 uint32_t addr, uint32_t size, int type)
1484 LSIState *s = (LSIState *)pci_dev;
1486 DPRINTF("Mapping IO at %08x\n", addr);
1488 register_ioport_write(addr, 256, 1, lsi_io_writeb, s);
1489 register_ioport_read(addr, 256, 1, lsi_io_readb, s);
1490 register_ioport_write(addr, 256, 2, lsi_io_writew, s);
1491 register_ioport_read(addr, 256, 2, lsi_io_readw, s);
1492 register_ioport_write(addr, 256, 4, lsi_io_writel, s);
1493 register_ioport_read(addr, 256, 4, lsi_io_readl, s);
1496 static void lsi_ram_mapfunc(PCIDevice *pci_dev, int region_num,
1497 uint32_t addr, uint32_t size, int type)
1499 LSIState *s = (LSIState *)pci_dev;
1501 DPRINTF("Mapping ram at %08x\n", addr);
1502 s->script_ram_base = addr;
1503 cpu_register_physical_memory(addr + 0, 0x2000, s->ram_io_addr);
1506 static void lsi_mmio_mapfunc(PCIDevice *pci_dev, int region_num,
1507 uint32_t addr, uint32_t size, int type)
1509 LSIState *s = (LSIState *)pci_dev;
1511 DPRINTF("Mapping registers at %08x\n", addr);
1512 cpu_register_physical_memory(addr + 0, 0x400, s->mmio_io_addr);
1515 void lsi_scsi_attach(void *opaque, BlockDriverState *bd, int id)
1517 LSIState *s = (LSIState *)opaque;
1520 for (id = 0; id < LSI_MAX_DEVS; id++) {
1521 if (s->scsi_dev[id] == NULL)
1525 if (id >= LSI_MAX_DEVS) {
1526 BADF("Bad Device ID %d\n", id);
1529 if (s->scsi_dev[id]) {
1530 DPRINTF("Destroying device %d\n", id);
1531 scsi_disk_destroy(s->scsi_dev[id]);
1533 DPRINTF("Attaching block device %d\n", id);
1534 s->scsi_dev[id] = scsi_disk_init(bd, lsi_command_complete, s);
1537 void *lsi_scsi_init(PCIBus *bus, int devfn)
1541 s = (LSIState *)pci_register_device(bus, "LSI53C895A SCSI HBA",
1542 sizeof(*s), devfn, NULL, NULL);
1544 fprintf(stderr, "lsi-scsi: Failed to register PCI device\n");
1548 s->pci_dev.config[0x00] = 0x00;
1549 s->pci_dev.config[0x01] = 0x10;
1550 s->pci_dev.config[0x02] = 0x12;
1551 s->pci_dev.config[0x03] = 0x00;
1552 s->pci_dev.config[0x0b] = 0x01;
1553 s->pci_dev.config[0x3d] = 0x01; /* interrupt pin 1 */
1555 s->mmio_io_addr = cpu_register_io_memory(0, lsi_mmio_readfn,
1556 lsi_mmio_writefn, s);
1557 s->ram_io_addr = cpu_register_io_memory(0, lsi_ram_readfn,
1558 lsi_ram_writefn, s);
1560 pci_register_io_region((struct PCIDevice *)s, 0, 256,
1561 PCI_ADDRESS_SPACE_IO, lsi_io_mapfunc);
1562 pci_register_io_region((struct PCIDevice *)s, 1, 0x400,
1563 PCI_ADDRESS_SPACE_MEM, lsi_mmio_mapfunc);
1564 pci_register_io_region((struct PCIDevice *)s, 2, 0x2000,
1565 PCI_ADDRESS_SPACE_MEM, lsi_ram_mapfunc);