hw/lsi53c895a.c

   1 /*
   2  * QEMU LSI53C895A SCSI Host Bus Adapter emulation
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Written by Paul Brook
   6  *
   7  * This code is licenced under the LGPL.
   8  */
   9
  10 /* ??? Need to check if the {read,write}[wl] routines work properly on
  11    big-endian targets.  */
  12
  13 #include <assert.h>
  14
  15 #include "hw.h"
  16 #include "pci.h"
  17 #include "scsi.h"
  18 #include "block_int.h"
  19
  20 //#define DEBUG_LSI
  21 //#define DEBUG_LSI_REG
  22
  23 #ifdef DEBUG_LSI
  24 #define DPRINTF(fmt, ...) \
  25 do { printf("lsi_scsi: " fmt , ## __VA_ARGS__); } while (0)
  26 #define BADF(fmt, ...) \
  27 do { fprintf(stderr, "lsi_scsi: error: " fmt , ## __VA_ARGS__); exit(1);} while (0)
  28 #else
  29 #define DPRINTF(fmt, ...) do {} while(0)
  30 #define BADF(fmt, ...) \
  31 do { fprintf(stderr, "lsi_scsi: error: " fmt , ## __VA_ARGS__);} while (0)
  32 #endif
  33
  34 #define LSI_MAX_DEVS 7
  35
  36 #define LSI_SCNTL0_TRG    0x01
  37 #define LSI_SCNTL0_AAP    0x02
  38 #define LSI_SCNTL0_EPC    0x08
  39 #define LSI_SCNTL0_WATN   0x10
  40 #define LSI_SCNTL0_START  0x20
  41
  42 #define LSI_SCNTL1_SST    0x01
  43 #define LSI_SCNTL1_IARB   0x02
  44 #define LSI_SCNTL1_AESP   0x04
  45 #define LSI_SCNTL1_RST    0x08
  46 #define LSI_SCNTL1_CON    0x10
  47 #define LSI_SCNTL1_DHP    0x20
  48 #define LSI_SCNTL1_ADB    0x40
  49 #define LSI_SCNTL1_EXC    0x80
  50
  51 #define LSI_SCNTL2_WSR    0x01
  52 #define LSI_SCNTL2_VUE0   0x02
  53 #define LSI_SCNTL2_VUE1   0x04
  54 #define LSI_SCNTL2_WSS    0x08
  55 #define LSI_SCNTL2_SLPHBEN 0x10
  56 #define LSI_SCNTL2_SLPMD  0x20
  57 #define LSI_SCNTL2_CHM    0x40
  58 #define LSI_SCNTL2_SDU    0x80
  59
  60 #define LSI_ISTAT0_DIP    0x01
  61 #define LSI_ISTAT0_SIP    0x02
  62 #define LSI_ISTAT0_INTF   0x04
  63 #define LSI_ISTAT0_CON    0x08
  64 #define LSI_ISTAT0_SEM    0x10
  65 #define LSI_ISTAT0_SIGP   0x20
  66 #define LSI_ISTAT0_SRST   0x40
  67 #define LSI_ISTAT0_ABRT   0x80
  68
  69 #define LSI_ISTAT1_SI     0x01
  70 #define LSI_ISTAT1_SRUN   0x02
  71 #define LSI_ISTAT1_FLSH   0x04
  72
  73 #define LSI_SSTAT0_SDP0   0x01
  74 #define LSI_SSTAT0_RST    0x02
  75 #define LSI_SSTAT0_WOA    0x04
  76 #define LSI_SSTAT0_LOA    0x08
  77 #define LSI_SSTAT0_AIP    0x10
  78 #define LSI_SSTAT0_OLF    0x20
  79 #define LSI_SSTAT0_ORF    0x40
  80 #define LSI_SSTAT0_ILF    0x80
  81
  82 #define LSI_SIST0_PAR     0x01
  83 #define LSI_SIST0_RST     0x02
  84 #define LSI_SIST0_UDC     0x04
  85 #define LSI_SIST0_SGE     0x08
  86 #define LSI_SIST0_RSL     0x10
  87 #define LSI_SIST0_SEL     0x20
  88 #define LSI_SIST0_CMP     0x40
  89 #define LSI_SIST0_MA      0x80
  90
  91 #define LSI_SIST1_HTH     0x01
  92 #define LSI_SIST1_GEN     0x02
  93 #define LSI_SIST1_STO     0x04
  94 #define LSI_SIST1_SBMC    0x10
  95
  96 #define LSI_SOCL_IO       0x01
  97 #define LSI_SOCL_CD       0x02
  98 #define LSI_SOCL_MSG      0x04
  99 #define LSI_SOCL_ATN      0x08
 100 #define LSI_SOCL_SEL      0x10
 101 #define LSI_SOCL_BSY      0x20
 102 #define LSI_SOCL_ACK      0x40
 103 #define LSI_SOCL_REQ      0x80
 104
 105 #define LSI_DSTAT_IID     0x01
 106 #define LSI_DSTAT_SIR     0x04
 107 #define LSI_DSTAT_SSI     0x08
 108 #define LSI_DSTAT_ABRT    0x10
 109 #define LSI_DSTAT_BF      0x20
 110 #define LSI_DSTAT_MDPE    0x40
 111 #define LSI_DSTAT_DFE     0x80
 112
 113 #define LSI_DCNTL_COM     0x01
 114 #define LSI_DCNTL_IRQD    0x02
 115 #define LSI_DCNTL_STD     0x04
 116 #define LSI_DCNTL_IRQM    0x08
 117 #define LSI_DCNTL_SSM     0x10
 118 #define LSI_DCNTL_PFEN    0x20
 119 #define LSI_DCNTL_PFF     0x40
 120 #define LSI_DCNTL_CLSE    0x80
 121
 122 #define LSI_DMODE_MAN     0x01
 123 #define LSI_DMODE_BOF     0x02
 124 #define LSI_DMODE_ERMP    0x04
 125 #define LSI_DMODE_ERL     0x08
 126 #define LSI_DMODE_DIOM    0x10
 127 #define LSI_DMODE_SIOM    0x20
 128
 129 #define LSI_CTEST2_DACK   0x01
 130 #define LSI_CTEST2_DREQ   0x02
 131 #define LSI_CTEST2_TEOP   0x04
 132 #define LSI_CTEST2_PCICIE 0x08
 133 #define LSI_CTEST2_CM     0x10
 134 #define LSI_CTEST2_CIO    0x20
 135 #define LSI_CTEST2_SIGP   0x40
 136 #define LSI_CTEST2_DDIR   0x80
 137
 138 #define LSI_CTEST5_BL2    0x04
 139 #define LSI_CTEST5_DDIR   0x08
 140 #define LSI_CTEST5_MASR   0x10
 141 #define LSI_CTEST5_DFSN   0x20
 142 #define LSI_CTEST5_BBCK   0x40
 143 #define LSI_CTEST5_ADCK   0x80
 144
 145 #define LSI_CCNTL0_DILS   0x01
 146 #define LSI_CCNTL0_DISFC  0x10
 147 #define LSI_CCNTL0_ENNDJ  0x20
 148 #define LSI_CCNTL0_PMJCTL 0x40
 149 #define LSI_CCNTL0_ENPMJ  0x80
 150
 151 #define LSI_CCNTL1_EN64DBMV  0x01
 152 #define LSI_CCNTL1_EN64TIBMV 0x02
 153 #define LSI_CCNTL1_64TIMOD   0x04
 154 #define LSI_CCNTL1_DDAC      0x08
 155 #define LSI_CCNTL1_ZMOD      0x80
 156
 157 /* Enable Response to Reselection */
 158 #define LSI_SCID_RRE      0x60
 159
 160 #define LSI_CCNTL1_40BIT (LSI_CCNTL1_EN64TIBMV|LSI_CCNTL1_64TIMOD)
 161
 162 #define PHASE_DO          0
 163 #define PHASE_DI          1
 164 #define PHASE_CMD         2
 165 #define PHASE_ST          3
 166 #define PHASE_MO          6
 167 #define PHASE_MI          7
 168 #define PHASE_MASK        7
 169
 170 /* Maximum length of MSG IN data.  */
 171 #define LSI_MAX_MSGIN_LEN 8
 172
 173 /* Flag set if this is a tagged command.  */
 174 #define LSI_TAG_VALID     (1 << 16)
 175
 176 typedef struct lsi_request {
 177     uint32_t tag;
 178     SCSIDevice *dev;
 179     uint32_t dma_len;
 180     uint8_t *dma_buf;
 181     uint32_t pending;
 182     int out;
 183     QTAILQ_ENTRY(lsi_request) next;
 184 } lsi_request;
 185
 186 typedef struct {
 187     PCIDevice dev;
 188     int mmio_io_addr;
 189     int ram_io_addr;
 190     uint32_t script_ram_base;
 191
 192     int carry; /* ??? Should this be an a visible register somewhere?  */
 193     int sense;
 194     /* Action to take at the end of a MSG IN phase.
 195        0 = COMMAND, 1 = disconnect, 2 = DATA OUT, 3 = DATA IN.  */
 196     int msg_action;
 197     int msg_len;
 198     uint8_t msg[LSI_MAX_MSGIN_LEN];
 199     /* 0 if SCRIPTS are running or stopped.
 200      * 1 if a Wait Reselect instruction has been issued.
 201      * 2 if processing DMA from lsi_execute_script.
 202      * 3 if a DMA operation is in progress.  */
 203     int waiting;
 204     SCSIBus bus;
 205     SCSIDevice *select_dev;
 206     int current_lun;
 207     /* The tag is a combination of the device ID and the SCSI tag.  */
 208     uint32_t select_tag;
 209     int command_complete;
 210     QTAILQ_HEAD(, lsi_request) queue;
 211     lsi_request *current;
 212
 213     uint32_t dsa;
 214     uint32_t temp;
 215     uint32_t dnad;
 216     uint32_t dbc;
 217     uint8_t istat0;
 218     uint8_t istat1;
 219     uint8_t dcmd;
 220     uint8_t dstat;
 221     uint8_t dien;
 222     uint8_t sist0;
 223     uint8_t sist1;
 224     uint8_t sien0;
 225     uint8_t sien1;
 226     uint8_t mbox0;
 227     uint8_t mbox1;
 228     uint8_t dfifo;
 229     uint8_t ctest2;
 230     uint8_t ctest3;
 231     uint8_t ctest4;
 232     uint8_t ctest5;
 233     uint8_t ccntl0;
 234     uint8_t ccntl1;
 235     uint32_t dsp;
 236     uint32_t dsps;
 237     uint8_t dmode;
 238     uint8_t dcntl;
 239     uint8_t scntl0;
 240     uint8_t scntl1;
 241     uint8_t scntl2;
 242     uint8_t scntl3;
 243     uint8_t sstat0;
 244     uint8_t sstat1;
 245     uint8_t scid;
 246     uint8_t sxfer;
 247     uint8_t socl;
 248     uint8_t sdid;
 249     uint8_t ssid;
 250     uint8_t sfbr;
 251     uint8_t stest1;
 252     uint8_t stest2;
 253     uint8_t stest3;
 254     uint8_t sidl;
 255     uint8_t stime0;
 256     uint8_t respid0;
 257     uint8_t respid1;
 258     uint32_t mmrs;
 259     uint32_t mmws;
 260     uint32_t sfs;
 261     uint32_t drs;
 262     uint32_t sbms;
 263     uint32_t dbms;
 264     uint32_t dnad64;
 265     uint32_t pmjad1;
 266     uint32_t pmjad2;
 267     uint32_t rbc;
 268     uint32_t ua;
 269     uint32_t ia;
 270     uint32_t sbc;
 271     uint32_t csbc;
 272     uint32_t scratch[18]; /* SCRATCHA-SCRATCHR */
 273     uint8_t sbr;
 274
 275     /* Script ram is stored as 32-bit words in host byteorder.  */
 276     uint32_t script_ram[2048];
 277 } LSIState;
 278
 279 static inline int lsi_irq_on_rsl(LSIState *s)
 280 {
 281     return (s->sien0 & LSI_SIST0_RSL) && (s->scid & LSI_SCID_RRE);
 282 }
 283
 284 static void lsi_soft_reset(LSIState *s)
 285 {
 286     lsi_request *p;
 287
 288     DPRINTF("Reset\n");
 289     s->carry = 0;
 290
 291     s->msg_action = 0;
 292     s->msg_len = 0;
 293     s->waiting = 0;
 294     s->dsa = 0;
 295     s->dnad = 0;
 296     s->dbc = 0;
 297     s->temp = 0;
 298     memset(s->scratch, 0, sizeof(s->scratch));
 299     s->istat0 = 0;
 300     s->istat1 = 0;
 301     s->dcmd = 0;
 302     s->dstat = 0;
 303     s->dien = 0;
 304     s->sist0 = 0;
 305     s->sist1 = 0;
 306     s->sien0 = 0;
 307     s->sien1 = 0;
 308     s->mbox0 = 0;
 309     s->mbox1 = 0;
 310     s->dfifo = 0;
 311     s->ctest2 = 0;
 312     s->ctest3 = 0;
 313     s->ctest4 = 0;
 314     s->ctest5 = 0;
 315     s->ccntl0 = 0;
 316     s->ccntl1 = 0;
 317     s->dsp = 0;
 318     s->dsps = 0;
 319     s->dmode = 0;
 320     s->dcntl = 0;
 321     s->scntl0 = 0xc0;
 322     s->scntl1 = 0;
 323     s->scntl2 = 0;
 324     s->scntl3 = 0;
 325     s->sstat0 = 0;
 326     s->sstat1 = 0;
 327     s->scid = 7;
 328     s->sxfer = 0;
 329     s->socl = 0;
 330     s->stest1 = 0;
 331     s->stest2 = 0;
 332     s->stest3 = 0;
 333     s->sidl = 0;
 334     s->stime0 = 0;
 335     s->respid0 = 0x80;
 336     s->respid1 = 0;
 337     s->mmrs = 0;
 338     s->mmws = 0;
 339     s->sfs = 0;
 340     s->drs = 0;
 341     s->sbms = 0;
 342     s->dbms = 0;
 343     s->dnad64 = 0;
 344     s->pmjad1 = 0;
 345     s->pmjad2 = 0;
 346     s->rbc = 0;
 347     s->ua = 0;
 348     s->ia = 0;
 349     s->sbc = 0;
 350     s->csbc = 0;
 351     s->sbr = 0;
 352     while (!QTAILQ_EMPTY(&s->queue)) {
 353         p = QTAILQ_FIRST(&s->queue);
 354         QTAILQ_REMOVE(&s->queue, p, next);
 355         qemu_free(p);
 356     }
 357     if (s->current) {
 358         qemu_free(s->current);
 359         s->current = NULL;
 360     }
 361 }
 362
 363 static int lsi_dma_40bit(LSIState *s)
 364 {
 365     if ((s->ccntl1 & LSI_CCNTL1_40BIT) == LSI_CCNTL1_40BIT)
 366         return 1;
 367     return 0;
 368 }
 369
 370 static int lsi_dma_ti64bit(LSIState *s)
 371 {
 372     if ((s->ccntl1 & LSI_CCNTL1_EN64TIBMV) == LSI_CCNTL1_EN64TIBMV)
 373         return 1;
 374     return 0;
 375 }
 376
 377 static int lsi_dma_64bit(LSIState *s)
 378 {
 379     if ((s->ccntl1 & LSI_CCNTL1_EN64DBMV) == LSI_CCNTL1_EN64DBMV)
 380         return 1;
 381     return 0;
 382 }
 383
 384 static uint8_t lsi_reg_readb(LSIState *s, int offset);
 385 static void lsi_reg_writeb(LSIState *s, int offset, uint8_t val);
 386 static void lsi_execute_script(LSIState *s);
 387 static void lsi_reselect(LSIState *s, lsi_request *p);
 388
 389 static inline uint32_t read_dword(LSIState *s, uint32_t addr)
 390 {
 391     uint32_t buf;
 392
 393     /* Optimize reading from SCRIPTS RAM.  */
 394     if ((addr & 0xffffe000) == s->script_ram_base) {
 395         return s->script_ram[(addr & 0x1fff) >> 2];
 396     }
 397     cpu_physical_memory_read(addr, (uint8_t *)&buf, 4);
 398     return cpu_to_le32(buf);
 399 }
 400
 401 static void lsi_stop_script(LSIState *s)
 402 {
 403     s->istat1 &= ~LSI_ISTAT1_SRUN;
 404 }
 405
 406 static void lsi_update_irq(LSIState *s)
 407 {
 408     int level;
 409     static int last_level;
 410     lsi_request *p;
 411
 412     /* It's unclear whether the DIP/SIP bits should be cleared when the
 413        Interrupt Status Registers are cleared or when istat0 is read.
 414        We currently do the formwer, which seems to work.  */
 415     level = 0;
 416     if (s->dstat) {
 417         if (s->dstat & s->dien)
 418             level = 1;
 419         s->istat0 |= LSI_ISTAT0_DIP;
 420     } else {
 421         s->istat0 &= ~LSI_ISTAT0_DIP;
 422     }
 423
 424     if (s->sist0 || s->sist1) {
 425         if ((s->sist0 & s->sien0) || (s->sist1 & s->sien1))
 426             level = 1;
 427         s->istat0 |= LSI_ISTAT0_SIP;
 428     } else {
 429         s->istat0 &= ~LSI_ISTAT0_SIP;
 430     }
 431     if (s->istat0 & LSI_ISTAT0_INTF)
 432         level = 1;
 433
 434     if (level != last_level) {
 435         DPRINTF("Update IRQ level %d dstat %02x sist %02x%02x\n",
 436                 level, s->dstat, s->sist1, s->sist0);
 437         last_level = level;
 438     }
 439     qemu_set_irq(s->dev.irq[0], level);
 440
 441     if (!level && lsi_irq_on_rsl(s) && !(s->scntl1 & LSI_SCNTL1_CON)) {
 442         DPRINTF("Handled IRQs & disconnected, looking for pending "
 443                 "processes\n");
 444         QTAILQ_FOREACH(p, &s->queue, next) {
 445             if (p->pending) {
 446                 lsi_reselect(s, p);
 447                 break;
 448             }
 449         }
 450     }
 451 }
 452
 453 /* Stop SCRIPTS execution and raise a SCSI interrupt.  */
 454 static void lsi_script_scsi_interrupt(LSIState *s, int stat0, int stat1)
 455 {
 456     uint32_t mask0;
 457     uint32_t mask1;
 458
 459     DPRINTF("SCSI Interrupt 0x%02x%02x prev 0x%02x%02x\n",
 460             stat1, stat0, s->sist1, s->sist0);
 461     s->sist0 |= stat0;
 462     s->sist1 |= stat1;
 463     /* Stop processor on fatal or unmasked interrupt.  As a special hack
 464        we don't stop processing when raising STO.  Instead continue
 465        execution and stop at the next insn that accesses the SCSI bus.  */
 466     mask0 = s->sien0 | ~(LSI_SIST0_CMP | LSI_SIST0_SEL | LSI_SIST0_RSL);
 467     mask1 = s->sien1 | ~(LSI_SIST1_GEN | LSI_SIST1_HTH);
 468     mask1 &= ~LSI_SIST1_STO;
 469     if (s->sist0 & mask0 || s->sist1 & mask1) {
 470         lsi_stop_script(s);
 471     }
 472     lsi_update_irq(s);
 473 }
 474
 475 /* Stop SCRIPTS execution and raise a DMA interrupt.  */
 476 static void lsi_script_dma_interrupt(LSIState *s, int stat)
 477 {
 478     DPRINTF("DMA Interrupt 0x%x prev 0x%x\n", stat, s->dstat);
 479     s->dstat |= stat;
 480     lsi_update_irq(s);
 481     lsi_stop_script(s);
 482 }
 483
 484 static inline void lsi_set_phase(LSIState *s, int phase)
 485 {
 486     s->sstat1 = (s->sstat1 & ~PHASE_MASK) | phase;
 487 }
 488
 489 static void lsi_bad_phase(LSIState *s, int out, int new_phase)
 490 {
 491     /* Trigger a phase mismatch.  */
 492     if (s->ccntl0 & LSI_CCNTL0_ENPMJ) {
 493         if ((s->ccntl0 & LSI_CCNTL0_PMJCTL) || out) {
 494             s->dsp = s->pmjad1;
 495         } else {
 496             s->dsp = s->pmjad2;
 497         }
 498         DPRINTF("Data phase mismatch jump to %08x\n", s->dsp);
 499     } else {
 500         DPRINTF("Phase mismatch interrupt\n");
 501         lsi_script_scsi_interrupt(s, LSI_SIST0_MA, 0);
 502         lsi_stop_script(s);
 503     }
 504     lsi_set_phase(s, new_phase);
 505 }
 506
 507
 508 /* Resume SCRIPTS execution after a DMA operation.  */
 509 static void lsi_resume_script(LSIState *s)
 510 {
 511     if (s->waiting != 2) {
 512         s->waiting = 0;
 513         lsi_execute_script(s);
 514     } else {
 515         s->waiting = 0;
 516     }
 517 }
 518
 519 /* Initiate a SCSI layer data transfer.  */
 520 static void lsi_do_dma(LSIState *s, int out)
 521 {
 522     uint32_t count;
 523     target_phys_addr_t addr;
 524
 525     assert(s->current);
 526     if (!s->current->dma_len) {
 527         /* Wait until data is available.  */
 528         DPRINTF("DMA no data available\n");
 529         return;
 530     }
 531
 532     count = s->dbc;
 533     if (count > s->current->dma_len)
 534         count = s->current->dma_len;
 535
 536     addr = s->dnad;
 537     /* both 40 and Table Indirect 64-bit DMAs store upper bits in dnad64 */
 538     if (lsi_dma_40bit(s) || lsi_dma_ti64bit(s))
 539         addr |= ((uint64_t)s->dnad64 << 32);
 540     else if (s->dbms)
 541         addr |= ((uint64_t)s->dbms << 32);
 542     else if (s->sbms)
 543         addr |= ((uint64_t)s->sbms << 32);
 544
 545     DPRINTF("DMA addr=0x" TARGET_FMT_plx " len=%d\n", addr, count);
 546     s->csbc += count;
 547     s->dnad += count;
 548     s->dbc -= count;
 549
 550     if (s->current->dma_buf == NULL) {
 551         s->current->dma_buf = s->current->dev->info->get_buf(s->current->dev,
 552                                                              s->current->tag);
 553     }
 554
 555     /* ??? Set SFBR to first data byte.  */
 556     if (out) {
 557         cpu_physical_memory_read(addr, s->current->dma_buf, count);
 558     } else {
 559         cpu_physical_memory_write(addr, s->current->dma_buf, count);
 560     }
 561     s->current->dma_len -= count;
 562     if (s->current->dma_len == 0) {
 563         s->current->dma_buf = NULL;
 564         if (out) {
 565             /* Write the data.  */
 566             s->current->dev->info->write_data(s->current->dev, s->current->tag);
 567         } else {
 568             /* Request any remaining data.  */
 569             s->current->dev->info->read_data(s->current->dev, s->current->tag);
 570         }
 571     } else {
 572         s->current->dma_buf += count;
 573         lsi_resume_script(s);
 574     }
 575 }
 576
 577
 578 /* Add a command to the queue.  */
 579 static void lsi_queue_command(LSIState *s)
 580 {
 581     lsi_request *p = s->current;
 582
 583     DPRINTF("Queueing tag=0x%x\n", s->current_tag);
 584     assert(s->current != NULL);
 585     assert(s->current->dma_len == 0);
 586     QTAILQ_INSERT_TAIL(&s->queue, s->current, next);
 587     s->current = NULL;
 588
 589     p->pending = 0;
 590     p->out = (s->sstat1 & PHASE_MASK) == PHASE_DO;
 591 }
 592
 593 /* Queue a byte for a MSG IN phase.  */
 594 static void lsi_add_msg_byte(LSIState *s, uint8_t data)
 595 {
 596     if (s->msg_len >= LSI_MAX_MSGIN_LEN) {
 597         BADF("MSG IN data too long\n");
 598     } else {
 599         DPRINTF("MSG IN 0x%02x\n", data);
 600         s->msg[s->msg_len++] = data;
 601     }
 602 }
 603
 604 /* Perform reselection to continue a command.  */
 605 static void lsi_reselect(LSIState *s, lsi_request *p)
 606 {
 607     int id;
 608
 609     assert(s->current == NULL);
 610     QTAILQ_REMOVE(&s->queue, p, next);
 611     s->current = p;
 612
 613     id = (p->tag >> 8) & 0xf;
 614     s->ssid = id | 0x80;
 615     /* LSI53C700 Family Compatibility, see LSI53C895A 4-73 */
 616     if (!(s->dcntl & LSI_DCNTL_COM)) {
 617         s->sfbr = 1 << (id & 0x7);
 618     }
 619     DPRINTF("Reselected target %d\n", id);
 620     s->scntl1 |= LSI_SCNTL1_CON;
 621     lsi_set_phase(s, PHASE_MI);
 622     s->msg_action = p->out ? 2 : 3;
 623     s->current->dma_len = p->pending;
 624     lsi_add_msg_byte(s, 0x80);
 625     if (s->current->tag & LSI_TAG_VALID) {
 626         lsi_add_msg_byte(s, 0x20);
 627         lsi_add_msg_byte(s, p->tag & 0xff);
 628     }
 629
 630     if (lsi_irq_on_rsl(s)) {
 631         lsi_script_scsi_interrupt(s, LSI_SIST0_RSL, 0);
 632     }
 633 }
 634
 635 /* Record that data is available for a queued command.  Returns zero if
 636    the device was reselected, nonzero if the IO is deferred.  */
 637 static int lsi_queue_tag(LSIState *s, uint32_t tag, uint32_t arg)
 638 {
 639     lsi_request *p;
 640
 641     QTAILQ_FOREACH(p, &s->queue, next) {
 642         if (p->tag == tag) {
 643             if (p->pending) {
 644                 BADF("Multiple IO pending for tag %d\n", tag);
 645             }
 646             p->pending = arg;
 647             /* Reselect if waiting for it, or if reselection triggers an IRQ
 648                and the bus is free.
 649                Since no interrupt stacking is implemented in the emulation, it
 650                is also required that there are no pending interrupts waiting
 651                for service from the device driver. */
 652             if (s->waiting == 1 ||
 653                 (lsi_irq_on_rsl(s) && !(s->scntl1 & LSI_SCNTL1_CON) &&
 654                  !(s->istat0 & (LSI_ISTAT0_SIP | LSI_ISTAT0_DIP)))) {
 655                 /* Reselect device.  */
 656                 lsi_reselect(s, p);
 657                 return 0;
 658             } else {
 659                 DPRINTF("Queueing IO tag=0x%x\n", tag);
 660                 p->pending = arg;
 661                 return 1;
 662             }
 663         }
 664     }
 665     BADF("IO with unknown tag %d\n", tag);
 666     return 1;
 667 }
 668
 669 /* Callback to indicate that the SCSI layer has completed a transfer.  */
 670 static void lsi_command_complete(SCSIBus *bus, int reason, uint32_t tag,
 671                                  uint32_t arg)
 672 {
 673     LSIState *s = DO_UPCAST(LSIState, dev.qdev, bus->qbus.parent);
 674     int out;
 675
 676     out = (s->sstat1 & PHASE_MASK) == PHASE_DO;
 677     if (reason == SCSI_REASON_DONE) {
 678         DPRINTF("Command complete sense=%d\n", (int)arg);
 679         s->sense = arg;
 680         s->command_complete = 2;
 681         if (s->waiting && s->dbc != 0) {
 682             /* Raise phase mismatch for short transfers.  */
 683             lsi_bad_phase(s, out, PHASE_ST);
 684         } else {
 685             lsi_set_phase(s, PHASE_ST);
 686         }
 687
 688         qemu_free(s->current);
 689         s->current = NULL;
 690
 691         lsi_resume_script(s);
 692         return;
 693     }
 694
 695     if (s->waiting == 1 || !s->current || tag != s->current->tag ||
 696         (lsi_irq_on_rsl(s) && !(s->scntl1 & LSI_SCNTL1_CON))) {
 697         if (lsi_queue_tag(s, tag, arg))
 698             return;
 699     }
 700
 701     /* host adapter (re)connected */
 702     DPRINTF("Data ready tag=0x%x len=%d\n", tag, arg);
 703     s->current->dma_len = arg;
 704     s->command_complete = 1;
 705     if (!s->waiting)
 706         return;
 707     if (s->waiting == 1 || s->dbc == 0) {
 708         lsi_resume_script(s);
 709     } else {
 710         lsi_do_dma(s, out);
 711     }
 712 }
 713
 714 static void lsi_do_command(LSIState *s)
 715 {
 716     uint8_t buf[16];
 717     int n;
 718
 719     DPRINTF("Send command len=%d\n", s->dbc);
 720     if (s->dbc > 16)
 721         s->dbc = 16;
 722     cpu_physical_memory_read(s->dnad, buf, s->dbc);
 723     s->sfbr = buf[0];
 724     s->command_complete = 0;
 725
 726     assert(s->current == NULL);
 727     s->current = qemu_mallocz(sizeof(lsi_request));
 728     s->current->tag = s->select_tag;
 729     s->current->dev = s->select_dev;
 730
 731     n = s->current->dev->info->send_command(s->current->dev, s->current->tag, buf,
 732                                             s->current_lun);
 733     if (n > 0) {
 734         lsi_set_phase(s, PHASE_DI);
 735         s->current->dev->info->read_data(s->current->dev, s->current->tag);
 736     } else if (n < 0) {
 737         lsi_set_phase(s, PHASE_DO);
 738         s->current->dev->info->write_data(s->current->dev, s->current->tag);
 739     }
 740
 741     if (!s->command_complete) {
 742         if (n) {
 743             /* Command did not complete immediately so disconnect.  */
 744             lsi_add_msg_byte(s, 2); /* SAVE DATA POINTER */
 745             lsi_add_msg_byte(s, 4); /* DISCONNECT */
 746             /* wait data */
 747             lsi_set_phase(s, PHASE_MI);
 748             s->msg_action = 1;
 749             lsi_queue_command(s);
 750         } else {
 751             /* wait command complete */
 752             lsi_set_phase(s, PHASE_DI);
 753         }
 754     }
 755 }
 756
 757 static void lsi_do_status(LSIState *s)
 758 {
 759     uint8_t sense;
 760     DPRINTF("Get status len=%d sense=%d\n", s->dbc, s->sense);
 761     if (s->dbc != 1)
 762         BADF("Bad Status move\n");
 763     s->dbc = 1;
 764     sense = s->sense;
 765     s->sfbr = sense;
 766     cpu_physical_memory_write(s->dnad, &sense, 1);
 767     lsi_set_phase(s, PHASE_MI);
 768     s->msg_action = 1;
 769     lsi_add_msg_byte(s, 0); /* COMMAND COMPLETE */
 770 }
 771
 772 static void lsi_disconnect(LSIState *s)
 773 {
 774     s->scntl1 &= ~LSI_SCNTL1_CON;
 775     s->sstat1 &= ~PHASE_MASK;
 776 }
 777
 778 static void lsi_do_msgin(LSIState *s)
 779 {
 780     int len;
 781     DPRINTF("Message in len=%d/%d\n", s->dbc, s->msg_len);
 782     s->sfbr = s->msg[0];
 783     len = s->msg_len;
 784     if (len > s->dbc)
 785         len = s->dbc;
 786     cpu_physical_memory_write(s->dnad, s->msg, len);
 787     /* Linux drivers rely on the last byte being in the SIDL.  */
 788     s->sidl = s->msg[len - 1];
 789     s->msg_len -= len;
 790     if (s->msg_len) {
 791         memmove(s->msg, s->msg + len, s->msg_len);
 792     } else {
 793         /* ??? Check if ATN (not yet implemented) is asserted and maybe
 794            switch to PHASE_MO.  */
 795         switch (s->msg_action) {
 796         case 0:
 797             lsi_set_phase(s, PHASE_CMD);
 798             break;
 799         case 1:
 800             lsi_disconnect(s);
 801             break;
 802         case 2:
 803             lsi_set_phase(s, PHASE_DO);
 804             break;
 805         case 3:
 806             lsi_set_phase(s, PHASE_DI);
 807             break;
 808         default:
 809             abort();
 810         }
 811     }
 812 }
 813
 814 /* Read the next byte during a MSGOUT phase.  */
 815 static uint8_t lsi_get_msgbyte(LSIState *s)
 816 {
 817     uint8_t data;
 818     cpu_physical_memory_read(s->dnad, &data, 1);
 819     s->dnad++;
 820     s->dbc--;
 821     return data;
 822 }
 823
 824 static void lsi_do_msgout(LSIState *s)
 825 {
 826     uint8_t msg;
 827     int len;
 828
 829     DPRINTF("MSG out len=%d\n", s->dbc);
 830     while (s->dbc) {
 831         msg = lsi_get_msgbyte(s);
 832         s->sfbr = msg;
 833
 834         switch (msg) {
 835         case 0x04:
 836             DPRINTF("MSG: Disconnect\n");
 837             lsi_disconnect(s);
 838             break;
 839         case 0x08:
 840             DPRINTF("MSG: No Operation\n");
 841             lsi_set_phase(s, PHASE_CMD);
 842             break;
 843         case 0x01:
 844             len = lsi_get_msgbyte(s);
 845             msg = lsi_get_msgbyte(s);
 846             DPRINTF("Extended message 0x%x (len %d)\n", msg, len);
 847             switch (msg) {
 848             case 1:
 849                 DPRINTF("SDTR (ignored)\n");
 850                 s->dbc -= 2;
 851                 break;
 852             case 3:
 853                 DPRINTF("WDTR (ignored)\n");
 854                 s->dbc -= 1;
 855                 break;
 856             default:
 857                 goto bad;
 858             }
 859             break;
 860         case 0x20: /* SIMPLE queue */
 861             s->select_tag |= lsi_get_msgbyte(s) | LSI_TAG_VALID;
 862             DPRINTF("SIMPLE queue tag=0x%x\n", s->current_tag & 0xff);
 863             break;
 864         case 0x21: /* HEAD of queue */
 865             BADF("HEAD queue not implemented\n");
 866             s->select_tag |= lsi_get_msgbyte(s) | LSI_TAG_VALID;
 867             break;
 868         case 0x22: /* ORDERED queue */
 869             BADF("ORDERED queue not implemented\n");
 870             s->select_tag |= lsi_get_msgbyte(s) | LSI_TAG_VALID;
 871             break;
 872         default:
 873             if ((msg & 0x80) == 0) {
 874                 goto bad;
 875             }
 876             s->current_lun = msg & 7;
 877             DPRINTF("Select LUN %d\n", s->current_lun);
 878             lsi_set_phase(s, PHASE_CMD);
 879             break;
 880         }
 881     }
 882     return;
 883 bad:
 884     BADF("Unimplemented message 0x%02x\n", msg);
 885     lsi_set_phase(s, PHASE_MI);
 886     lsi_add_msg_byte(s, 7); /* MESSAGE REJECT */
 887     s->msg_action = 0;
 888 }
 889
 890 /* Sign extend a 24-bit value.  */
 891 static inline int32_t sxt24(int32_t n)
 892 {
 893     return (n << 8) >> 8;
 894 }
 895
 896 #define LSI_BUF_SIZE 4096
 897 static void lsi_memcpy(LSIState *s, uint32_t dest, uint32_t src, int count)
 898 {
 899     int n;
 900     uint8_t buf[LSI_BUF_SIZE];
 901
 902     DPRINTF("memcpy dest 0x%08x src 0x%08x count %d\n", dest, src, count);
 903     while (count) {
 904         n = (count > LSI_BUF_SIZE) ? LSI_BUF_SIZE : count;
 905         cpu_physical_memory_read(src, buf, n);
 906         cpu_physical_memory_write(dest, buf, n);
 907         src += n;
 908         dest += n;
 909         count -= n;
 910     }
 911 }
 912
 913 static void lsi_wait_reselect(LSIState *s)
 914 {
 915     lsi_request *p;
 916
 917     DPRINTF("Wait Reselect\n");
 918
 919     QTAILQ_FOREACH(p, &s->queue, next) {
 920         if (p->pending) {
 921             lsi_reselect(s, p);
 922             break;
 923         }
 924     }
 925     if (s->current == NULL) {
 926         s->waiting = 1;
 927     }
 928 }
 929
 930 static void lsi_execute_script(LSIState *s)
 931 {
 932     uint32_t insn;
 933     uint32_t addr, addr_high;
 934     int opcode;
 935     int insn_processed = 0;
 936
 937     s->istat1 |= LSI_ISTAT1_SRUN;
 938 again:
 939     insn_processed++;
 940     insn = read_dword(s, s->dsp);
 941     if (!insn) {
 942         /* If we receive an empty opcode increment the DSP by 4 bytes
 943            instead of 8 and execute the next opcode at that location */
 944         s->dsp += 4;
 945         goto again;
 946     }
 947     addr = read_dword(s, s->dsp + 4);
 948     addr_high = 0;
 949     DPRINTF("SCRIPTS dsp=%08x opcode %08x arg %08x\n", s->dsp, insn, addr);
 950     s->dsps = addr;
 951     s->dcmd = insn >> 24;
 952     s->dsp += 8;
 953     switch (insn >> 30) {
 954     case 0: /* Block move.  */
 955         if (s->sist1 & LSI_SIST1_STO) {
 956             DPRINTF("Delayed select timeout\n");
 957             lsi_stop_script(s);
 958             break;
 959         }
 960         s->dbc = insn & 0xffffff;
 961         s->rbc = s->dbc;
 962         /* ??? Set ESA.  */
 963         s->ia = s->dsp - 8;
 964         if (insn & (1 << 29)) {
 965             /* Indirect addressing.  */
 966             addr = read_dword(s, addr);
 967         } else if (insn & (1 << 28)) {
 968             uint32_t buf[2];
 969             int32_t offset;
 970             /* Table indirect addressing.  */
 971
 972             /* 32-bit Table indirect */
 973             offset = sxt24(addr);
 974             cpu_physical_memory_read(s->dsa + offset, (uint8_t *)buf, 8);
 975             /* byte count is stored in bits 0:23 only */
 976             s->dbc = cpu_to_le32(buf[0]) & 0xffffff;
 977             s->rbc = s->dbc;
 978             addr = cpu_to_le32(buf[1]);
 979
 980             /* 40-bit DMA, upper addr bits [39:32] stored in first DWORD of
 981              * table, bits [31:24] */
 982             if (lsi_dma_40bit(s))
 983                 addr_high = cpu_to_le32(buf[0]) >> 24;
 984             else if (lsi_dma_ti64bit(s)) {
 985                 int selector = (cpu_to_le32(buf[0]) >> 24) & 0x1f;
 986                 switch (selector) {
 987                 case 0 ... 0x0f:
 988                     /* offset index into scratch registers since
 989                      * TI64 mode can use registers C to R */
 990                     addr_high = s->scratch[2 + selector];
 991                     break;
 992                 case 0x10:
 993                     addr_high = s->mmrs;
 994                     break;
 995                 case 0x11:
 996                     addr_high = s->mmws;
 997                     break;
 998                 case 0x12:
 999                     addr_high = s->sfs;
1000                     break;
1001                 case 0x13:
1002                     addr_high = s->drs;
1003                     break;
1004                 case 0x14:
1005                     addr_high = s->sbms;
1006                     break;
1007                 case 0x15:
1008                     addr_high = s->dbms;
1009                     break;
1010                 default:
1011                     BADF("Illegal selector specified (0x%x > 0x15)"
1012                          " for 64-bit DMA block move", selector);
1013                     break;
1014                 }
1015             }
1016         } else if (lsi_dma_64bit(s)) {
1017             /* fetch a 3rd dword if 64-bit direct move is enabled and
1018                only if we're not doing table indirect or indirect addressing */
1019             s->dbms = read_dword(s, s->dsp);
1020             s->dsp += 4;
1021             s->ia = s->dsp - 12;
1022         }
1023         if ((s->sstat1 & PHASE_MASK) != ((insn >> 24) & 7)) {
1024             DPRINTF("Wrong phase got %d expected %d\n",
1025                     s->sstat1 & PHASE_MASK, (insn >> 24) & 7);
1026             lsi_script_scsi_interrupt(s, LSI_SIST0_MA, 0);
1027             break;
1028         }
1029         s->dnad = addr;
1030         s->dnad64 = addr_high;
1031         switch (s->sstat1 & 0x7) {
1032         case PHASE_DO:
1033             s->waiting = 2;
1034             lsi_do_dma(s, 1);
1035             if (s->waiting)
1036                 s->waiting = 3;
1037             break;
1038         case PHASE_DI:
1039             s->waiting = 2;
1040             lsi_do_dma(s, 0);
1041             if (s->waiting)
1042                 s->waiting = 3;
1043             break;
1044         case PHASE_CMD:
1045             lsi_do_command(s);
1046             break;
1047         case PHASE_ST:
1048             lsi_do_status(s);
1049             break;
1050         case PHASE_MO:
1051             lsi_do_msgout(s);
1052             break;
1053         case PHASE_MI:
1054             lsi_do_msgin(s);
1055             break;
1056         default:
1057             BADF("Unimplemented phase %d\n", s->sstat1 & PHASE_MASK);
1058             exit(1);
1059         }
1060         s->dfifo = s->dbc & 0xff;
1061         s->ctest5 = (s->ctest5 & 0xfc) | ((s->dbc >> 8) & 3);
1062         s->sbc = s->dbc;
1063         s->rbc -= s->dbc;
1064         s->ua = addr + s->dbc;
1065         break;
1066
1067     case 1: /* IO or Read/Write instruction.  */
1068         opcode = (insn >> 27) & 7;
1069         if (opcode < 5) {
1070             uint32_t id;
1071
1072             if (insn & (1 << 25)) {
1073                 id = read_dword(s, s->dsa + sxt24(insn));
1074             } else {
1075                 id = insn;
1076             }
1077             id = (id >> 16) & 0xf;
1078             if (insn & (1 << 26)) {
1079                 addr = s->dsp + sxt24(addr);
1080             }
1081             s->dnad = addr;
1082             switch (opcode) {
1083             case 0: /* Select */
1084                 s->sdid = id;
1085                 if (s->scntl1 & LSI_SCNTL1_CON) {
1086                     DPRINTF("Already reselected, jumping to alternative address\n");
1087                     s->dsp = s->dnad;
1088                     break;
1089                 }
1090                 s->sstat0 |= LSI_SSTAT0_WOA;
1091                 s->scntl1 &= ~LSI_SCNTL1_IARB;
1092                 if (id >= LSI_MAX_DEVS || !s->bus.devs[id]) {
1093                     DPRINTF("Selected absent target %d\n", id);
1094                     lsi_script_scsi_interrupt(s, 0, LSI_SIST1_STO);
1095                     lsi_disconnect(s);
1096                     break;
1097                 }
1098                 DPRINTF("Selected target %d%s\n",
1099                         id, insn & (1 << 3) ? " ATN" : "");
1100                 /* ??? Linux drivers compain when this is set.  Maybe
1101                    it only applies in low-level mode (unimplemented).
1102                 lsi_script_scsi_interrupt(s, LSI_SIST0_CMP, 0); */
1103                 s->select_dev = s->bus.devs[id];
1104                 s->select_tag = id << 8;
1105                 s->scntl1 |= LSI_SCNTL1_CON;
1106                 if (insn & (1 << 3)) {
1107                     s->socl |= LSI_SOCL_ATN;
1108                 }
1109                 lsi_set_phase(s, PHASE_MO);
1110                 break;
1111             case 1: /* Disconnect */
1112                 DPRINTF("Wait Disconnect\n");
1113                 s->scntl1 &= ~LSI_SCNTL1_CON;
1114                 break;
1115             case 2: /* Wait Reselect */
1116                 if (!lsi_irq_on_rsl(s)) {
1117                     lsi_wait_reselect(s);
1118                 }
1119                 break;
1120             case 3: /* Set */
1121                 DPRINTF("Set%s%s%s%s\n",
1122                         insn & (1 << 3) ? " ATN" : "",
1123                         insn & (1 << 6) ? " ACK" : "",
1124                         insn & (1 << 9) ? " TM" : "",
1125                         insn & (1 << 10) ? " CC" : "");
1126                 if (insn & (1 << 3)) {
1127                     s->socl |= LSI_SOCL_ATN;
1128                     lsi_set_phase(s, PHASE_MO);
1129                 }
1130                 if (insn & (1 << 9)) {
1131                     BADF("Target mode not implemented\n");
1132                     exit(1);
1133                 }
1134                 if (insn & (1 << 10))
1135                     s->carry = 1;
1136                 break;
1137             case 4: /* Clear */
1138                 DPRINTF("Clear%s%s%s%s\n",
1139                         insn & (1 << 3) ? " ATN" : "",
1140                         insn & (1 << 6) ? " ACK" : "",
1141                         insn & (1 << 9) ? " TM" : "",
1142                         insn & (1 << 10) ? " CC" : "");
1143                 if (insn & (1 << 3)) {
1144                     s->socl &= ~LSI_SOCL_ATN;
1145                 }
1146                 if (insn & (1 << 10))
1147                     s->carry = 0;
1148                 break;
1149             }
1150         } else {
1151             uint8_t op0;
1152             uint8_t op1;
1153             uint8_t data8;
1154             int reg;
1155             int operator;
1156 #ifdef DEBUG_LSI
1157             static const char *opcode_names[3] =
1158                 {"Write", "Read", "Read-Modify-Write"};
1159             static const char *operator_names[8] =
1160                 {"MOV", "SHL", "OR", "XOR", "AND", "SHR", "ADD", "ADC"};
1161 #endif
1162
1163             reg = ((insn >> 16) & 0x7f) | (insn & 0x80);
1164             data8 = (insn >> 8) & 0xff;
1165             opcode = (insn >> 27) & 7;
1166             operator = (insn >> 24) & 7;
1167             DPRINTF("%s reg 0x%x %s data8=0x%02x sfbr=0x%02x%s\n",
1168                     opcode_names[opcode - 5], reg,
1169                     operator_names[operator], data8, s->sfbr,
1170                     (insn & (1 << 23)) ? " SFBR" : "");
1171             op0 = op1 = 0;
1172             switch (opcode) {
1173             case 5: /* From SFBR */
1174                 op0 = s->sfbr;
1175                 op1 = data8;
1176                 break;
1177             case 6: /* To SFBR */
1178                 if (operator)
1179                     op0 = lsi_reg_readb(s, reg);
1180                 op1 = data8;
1181                 break;
1182             case 7: /* Read-modify-write */
1183                 if (operator)
1184                     op0 = lsi_reg_readb(s, reg);
1185                 if (insn & (1 << 23)) {
1186                     op1 = s->sfbr;
1187                 } else {
1188                     op1 = data8;
1189                 }
1190                 break;
1191             }
1192
1193             switch (operator) {
1194             case 0: /* move */
1195                 op0 = op1;
1196                 break;
1197             case 1: /* Shift left */
1198                 op1 = op0 >> 7;
1199                 op0 = (op0 << 1) | s->carry;
1200                 s->carry = op1;
1201                 break;
1202             case 2: /* OR */
1203                 op0 |= op1;
1204                 break;
1205             case 3: /* XOR */
1206                 op0 ^= op1;
1207                 break;
1208             case 4: /* AND */
1209                 op0 &= op1;
1210                 break;
1211             case 5: /* SHR */
1212                 op1 = op0 & 1;
1213                 op0 = (op0 >> 1) | (s->carry << 7);
1214                 s->carry = op1;
1215                 break;
1216             case 6: /* ADD */
1217                 op0 += op1;
1218                 s->carry = op0 < op1;
1219                 break;
1220             case 7: /* ADC */
1221                 op0 += op1 + s->carry;
1222                 if (s->carry)
1223                     s->carry = op0 <= op1;
1224                 else
1225                     s->carry = op0 < op1;
1226                 break;
1227             }
1228
1229             switch (opcode) {
1230             case 5: /* From SFBR */
1231             case 7: /* Read-modify-write */
1232                 lsi_reg_writeb(s, reg, op0);
1233                 break;
1234             case 6: /* To SFBR */
1235                 s->sfbr = op0;
1236                 break;
1237             }
1238         }
1239         break;
1240
1241     case 2: /* Transfer Control.  */
1242         {
1243             int cond;
1244             int jmp;
1245
1246             if ((insn & 0x002e0000) == 0) {
1247                 DPRINTF("NOP\n");
1248                 break;
1249             }
1250             if (s->sist1 & LSI_SIST1_STO) {
1251                 DPRINTF("Delayed select timeout\n");
1252                 lsi_stop_script(s);
1253                 break;
1254             }
1255             cond = jmp = (insn & (1 << 19)) != 0;
1256             if (cond == jmp && (insn & (1 << 21))) {
1257                 DPRINTF("Compare carry %d\n", s->carry == jmp);
1258                 cond = s->carry != 0;
1259             }
1260             if (cond == jmp && (insn & (1 << 17))) {
1261                 DPRINTF("Compare phase %d %c= %d\n",
1262                         (s->sstat1 & PHASE_MASK),
1263                         jmp ? '=' : '!',
1264                         ((insn >> 24) & 7));
1265                 cond = (s->sstat1 & PHASE_MASK) == ((insn >> 24) & 7);
1266             }
1267             if (cond == jmp && (insn & (1 << 18))) {
1268                 uint8_t mask;
1269
1270                 mask = (~insn >> 8) & 0xff;
1271                 DPRINTF("Compare data 0x%x & 0x%x %c= 0x%x\n",
1272                         s->sfbr, mask, jmp ? '=' : '!', insn & mask);
1273                 cond = (s->sfbr & mask) == (insn & mask);
1274             }
1275             if (cond == jmp) {
1276                 if (insn & (1 << 23)) {
1277                     /* Relative address.  */
1278                     addr = s->dsp + sxt24(addr);
1279                 }
1280                 switch ((insn >> 27) & 7) {
1281                 case 0: /* Jump */
1282                     DPRINTF("Jump to 0x%08x\n", addr);
1283                     s->dsp = addr;
1284                     break;
1285                 case 1: /* Call */
1286                     DPRINTF("Call 0x%08x\n", addr);
1287                     s->temp = s->dsp;
1288                     s->dsp = addr;
1289                     break;
1290                 case 2: /* Return */
1291                     DPRINTF("Return to 0x%08x\n", s->temp);
1292                     s->dsp = s->temp;
1293                     break;
1294                 case 3: /* Interrupt */
1295                     DPRINTF("Interrupt 0x%08x\n", s->dsps);
1296                     if ((insn & (1 << 20)) != 0) {
1297                         s->istat0 |= LSI_ISTAT0_INTF;
1298                         lsi_update_irq(s);
1299                     } else {
1300                         lsi_script_dma_interrupt(s, LSI_DSTAT_SIR);
1301                     }
1302                     break;
1303                 default:
1304                     DPRINTF("Illegal transfer control\n");
1305                     lsi_script_dma_interrupt(s, LSI_DSTAT_IID);
1306                     break;
1307                 }
1308             } else {
1309                 DPRINTF("Control condition failed\n");
1310             }
1311         }
1312         break;
1313
1314     case 3:
1315         if ((insn & (1 << 29)) == 0) {
1316             /* Memory move.  */
1317             uint32_t dest;
1318             /* ??? The docs imply the destination address is loaded into
1319                the TEMP register.  However the Linux drivers rely on
1320                the value being presrved.  */
1321             dest = read_dword(s, s->dsp);
1322             s->dsp += 4;
1323             lsi_memcpy(s, dest, addr, insn & 0xffffff);
1324         } else {
1325             uint8_t data[7];
1326             int reg;
1327             int n;
1328             int i;
1329
1330             if (insn & (1 << 28)) {
1331                 addr = s->dsa + sxt24(addr);
1332             }
1333             n = (insn & 7);
1334             reg = (insn >> 16) & 0xff;
1335             if (insn & (1 << 24)) {
1336                 cpu_physical_memory_read(addr, data, n);
1337                 DPRINTF("Load reg 0x%x size %d addr 0x%08x = %08x\n", reg, n,
1338                         addr, *(int *)data);
1339                 for (i = 0; i < n; i++) {
1340                     lsi_reg_writeb(s, reg + i, data[i]);
1341                 }
1342             } else {
1343                 DPRINTF("Store reg 0x%x size %d addr 0x%08x\n", reg, n, addr);
1344                 for (i = 0; i < n; i++) {
1345                     data[i] = lsi_reg_readb(s, reg + i);
1346                 }
1347                 cpu_physical_memory_write(addr, data, n);
1348             }
1349         }
1350     }
1351     if (insn_processed > 10000 && !s->waiting) {
1352         /* Some windows drivers make the device spin waiting for a memory
1353            location to change.  If we have been executed a lot of code then
1354            assume this is the case and force an unexpected device disconnect.
1355            This is apparently sufficient to beat the drivers into submission.
1356          */
1357         if (!(s->sien0 & LSI_SIST0_UDC))
1358             fprintf(stderr, "inf. loop with UDC masked\n");
1359         lsi_script_scsi_interrupt(s, LSI_SIST0_UDC, 0);
1360         lsi_disconnect(s);
1361     } else if (s->istat1 & LSI_ISTAT1_SRUN && !s->waiting) {
1362         if (s->dcntl & LSI_DCNTL_SSM) {
1363             lsi_script_dma_interrupt(s, LSI_DSTAT_SSI);
1364         } else {
1365             goto again;
1366         }
1367     }
1368     DPRINTF("SCRIPTS execution stopped\n");
1369 }
1370
1371 static uint8_t lsi_reg_readb(LSIState *s, int offset)
1372 {
1373     uint8_t tmp;
1374 #define CASE_GET_REG24(name, addr) \
1375     case addr: return s->name & 0xff; \
1376     case addr + 1: return (s->name >> 8) & 0xff; \
1377     case addr + 2: return (s->name >> 16) & 0xff;
1378
1379 #define CASE_GET_REG32(name, addr) \
1380     case addr: return s->name & 0xff; \
1381     case addr + 1: return (s->name >> 8) & 0xff; \
1382     case addr + 2: return (s->name >> 16) & 0xff; \
1383     case addr + 3: return (s->name >> 24) & 0xff;
1384
1385 #ifdef DEBUG_LSI_REG
1386     DPRINTF("Read reg %x\n", offset);
1387 #endif
1388     switch (offset) {
1389     case 0x00: /* SCNTL0 */
1390         return s->scntl0;
1391     case 0x01: /* SCNTL1 */
1392         return s->scntl1;
1393     case 0x02: /* SCNTL2 */
1394         return s->scntl2;
1395     case 0x03: /* SCNTL3 */
1396         return s->scntl3;
1397     case 0x04: /* SCID */
1398         return s->scid;
1399     case 0x05: /* SXFER */
1400         return s->sxfer;
1401     case 0x06: /* SDID */
1402         return s->sdid;
1403     case 0x07: /* GPREG0 */
1404         return 0x7f;
1405     case 0x08: /* Revision ID */
1406         return 0x00;
1407     case 0xa: /* SSID */
1408         return s->ssid;
1409     case 0xb: /* SBCL */
1410         /* ??? This is not correct. However it's (hopefully) only
1411            used for diagnostics, so should be ok.  */
1412         return 0;
1413     case 0xc: /* DSTAT */
1414         tmp = s->dstat | 0x80;
1415         if ((s->istat0 & LSI_ISTAT0_INTF) == 0)
1416             s->dstat = 0;
1417         lsi_update_irq(s);
1418         return tmp;
1419     case 0x0d: /* SSTAT0 */
1420         return s->sstat0;
1421     case 0x0e: /* SSTAT1 */
1422         return s->sstat1;
1423     case 0x0f: /* SSTAT2 */
1424         return s->scntl1 & LSI_SCNTL1_CON ? 0 : 2;
1425     CASE_GET_REG32(dsa, 0x10)
1426     case 0x14: /* ISTAT0 */
1427         return s->istat0;
1428     case 0x15: /* ISTAT1 */
1429         return s->istat1;
1430     case 0x16: /* MBOX0 */
1431         return s->mbox0;
1432     case 0x17: /* MBOX1 */
1433         return s->mbox1;
1434     case 0x18: /* CTEST0 */
1435         return 0xff;
1436     case 0x19: /* CTEST1 */
1437         return 0;
1438     case 0x1a: /* CTEST2 */
1439         tmp = s->ctest2 | LSI_CTEST2_DACK | LSI_CTEST2_CM;
1440         if (s->istat0 & LSI_ISTAT0_SIGP) {
1441             s->istat0 &= ~LSI_ISTAT0_SIGP;
1442             tmp |= LSI_CTEST2_SIGP;
1443         }
1444         return tmp;
1445     case 0x1b: /* CTEST3 */
1446         return s->ctest3;
1447     CASE_GET_REG32(temp, 0x1c)
1448     case 0x20: /* DFIFO */
1449         return 0;
1450     case 0x21: /* CTEST4 */
1451         return s->ctest4;
1452     case 0x22: /* CTEST5 */
1453         return s->ctest5;
1454     case 0x23: /* CTEST6 */
1455          return 0;
1456     CASE_GET_REG24(dbc, 0x24)
1457     case 0x27: /* DCMD */
1458         return s->dcmd;
1459     CASE_GET_REG32(dnad, 0x28)
1460     CASE_GET_REG32(dsp, 0x2c)
1461     CASE_GET_REG32(dsps, 0x30)
1462     CASE_GET_REG32(scratch[0], 0x34)
1463     case 0x38: /* DMODE */
1464         return s->dmode;
1465     case 0x39: /* DIEN */
1466         return s->dien;
1467     case 0x3a: /* SBR */
1468         return s->sbr;
1469     case 0x3b: /* DCNTL */
1470         return s->dcntl;
1471     case 0x40: /* SIEN0 */
1472         return s->sien0;
1473     case 0x41: /* SIEN1 */
1474         return s->sien1;
1475     case 0x42: /* SIST0 */
1476         tmp = s->sist0;
1477         s->sist0 = 0;
1478         lsi_update_irq(s);
1479         return tmp;
1480     case 0x43: /* SIST1 */
1481         tmp = s->sist1;
1482         s->sist1 = 0;
1483         lsi_update_irq(s);
1484         return tmp;
1485     case 0x46: /* MACNTL */
1486         return 0x0f;
1487     case 0x47: /* GPCNTL0 */
1488         return 0x0f;
1489     case 0x48: /* STIME0 */
1490         return s->stime0;
1491     case 0x4a: /* RESPID0 */
1492         return s->respid0;
1493     case 0x4b: /* RESPID1 */
1494         return s->respid1;
1495     case 0x4d: /* STEST1 */
1496         return s->stest1;
1497     case 0x4e: /* STEST2 */
1498         return s->stest2;
1499     case 0x4f: /* STEST3 */
1500         return s->stest3;
1501     case 0x50: /* SIDL */
1502         /* This is needed by the linux drivers.  We currently only update it
1503            during the MSG IN phase.  */
1504         return s->sidl;
1505     case 0x52: /* STEST4 */
1506         return 0xe0;
1507     case 0x56: /* CCNTL0 */
1508         return s->ccntl0;
1509     case 0x57: /* CCNTL1 */
1510         return s->ccntl1;
1511     case 0x58: /* SBDL */
1512         /* Some drivers peek at the data bus during the MSG IN phase.  */
1513         if ((s->sstat1 & PHASE_MASK) == PHASE_MI)
1514             return s->msg[0];
1515         return 0;
1516     case 0x59: /* SBDL high */
1517         return 0;
1518     CASE_GET_REG32(mmrs, 0xa0)
1519     CASE_GET_REG32(mmws, 0xa4)
1520     CASE_GET_REG32(sfs, 0xa8)
1521     CASE_GET_REG32(drs, 0xac)
1522     CASE_GET_REG32(sbms, 0xb0)
1523     CASE_GET_REG32(dbms, 0xb4)
1524     CASE_GET_REG32(dnad64, 0xb8)
1525     CASE_GET_REG32(pmjad1, 0xc0)
1526     CASE_GET_REG32(pmjad2, 0xc4)
1527     CASE_GET_REG32(rbc, 0xc8)
1528     CASE_GET_REG32(ua, 0xcc)
1529     CASE_GET_REG32(ia, 0xd4)
1530     CASE_GET_REG32(sbc, 0xd8)
1531     CASE_GET_REG32(csbc, 0xdc)
1532     }
1533     if (offset >= 0x5c && offset < 0xa0) {
1534         int n;
1535         int shift;
1536         n = (offset - 0x58) >> 2;
1537         shift = (offset & 3) * 8;
1538         return (s->scratch[n] >> shift) & 0xff;
1539     }
1540     BADF("readb 0x%x\n", offset);
1541     exit(1);
1542 #undef CASE_GET_REG24
1543 #undef CASE_GET_REG32
1544 }
1545
1546 static void lsi_reg_writeb(LSIState *s, int offset, uint8_t val)
1547 {
1548 #define CASE_SET_REG24(name, addr) \
1549     case addr    : s->name &= 0xffffff00; s->name |= val;       break; \
1550     case addr + 1: s->name &= 0xffff00ff; s->name |= val << 8;  break; \
1551     case addr + 2: s->name &= 0xff00ffff; s->name |= val << 16; break;
1552
1553 #define CASE_SET_REG32(name, addr) \
1554     case addr    : s->name &= 0xffffff00; s->name |= val;       break; \
1555     case addr + 1: s->name &= 0xffff00ff; s->name |= val << 8;  break; \
1556     case addr + 2: s->name &= 0xff00ffff; s->name |= val << 16; break; \
1557     case addr + 3: s->name &= 0x00ffffff; s->name |= val << 24; break;
1558
1559 #ifdef DEBUG_LSI_REG
1560     DPRINTF("Write reg %x = %02x\n", offset, val);
1561 #endif
1562     switch (offset) {
1563     case 0x00: /* SCNTL0 */
1564         s->scntl0 = val;
1565         if (val & LSI_SCNTL0_START) {
1566             BADF("Start sequence not implemented\n");
1567         }
1568         break;
1569     case 0x01: /* SCNTL1 */
1570         s->scntl1 = val & ~LSI_SCNTL1_SST;
1571         if (val & LSI_SCNTL1_IARB) {
1572             BADF("Immediate Arbritration not implemented\n");
1573         }
1574         if (val & LSI_SCNTL1_RST) {
1575             s->sstat0 |= LSI_SSTAT0_RST;
1576             lsi_script_scsi_interrupt(s, LSI_SIST0_RST, 0);
1577         } else {
1578             s->sstat0 &= ~LSI_SSTAT0_RST;
1579         }
1580         break;
1581     case 0x02: /* SCNTL2 */
1582         val &= ~(LSI_SCNTL2_WSR | LSI_SCNTL2_WSS);
1583         s->scntl2 = val;
1584         break;
1585     case 0x03: /* SCNTL3 */
1586         s->scntl3 = val;
1587         break;
1588     case 0x04: /* SCID */
1589         s->scid = val;
1590         break;
1591     case 0x05: /* SXFER */
1592         s->sxfer = val;
1593         break;
1594     case 0x06: /* SDID */
1595         if ((val & 0xf) != (s->ssid & 0xf))
1596             BADF("Destination ID does not match SSID\n");
1597         s->sdid = val & 0xf;
1598         break;
1599     case 0x07: /* GPREG0 */
1600         break;
1601     case 0x08: /* SFBR */
1602         /* The CPU is not allowed to write to this register.  However the
1603            SCRIPTS register move instructions are.  */
1604         s->sfbr = val;
1605         break;
1606     case 0x0a: case 0x0b:
1607         /* Openserver writes to these readonly registers on startup */
1608         return;
1609     case 0x0c: case 0x0d: case 0x0e: case 0x0f:
1610         /* Linux writes to these readonly registers on startup.  */
1611         return;
1612     CASE_SET_REG32(dsa, 0x10)
1613     case 0x14: /* ISTAT0 */
1614         s->istat0 = (s->istat0 & 0x0f) | (val & 0xf0);
1615         if (val & LSI_ISTAT0_ABRT) {
1616             lsi_script_dma_interrupt(s, LSI_DSTAT_ABRT);
1617         }
1618         if (val & LSI_ISTAT0_INTF) {
1619             s->istat0 &= ~LSI_ISTAT0_INTF;
1620             lsi_update_irq(s);
1621         }
1622         if (s->waiting == 1 && val & LSI_ISTAT0_SIGP) {
1623             DPRINTF("Woken by SIGP\n");
1624             s->waiting = 0;
1625             s->dsp = s->dnad;
1626             lsi_execute_script(s);
1627         }
1628         if (val & LSI_ISTAT0_SRST) {
1629             lsi_soft_reset(s);
1630         }
1631         break;
1632     case 0x16: /* MBOX0 */
1633         s->mbox0 = val;
1634         break;
1635     case 0x17: /* MBOX1 */
1636         s->mbox1 = val;
1637         break;
1638     case 0x1a: /* CTEST2 */
1639         s->ctest2 = val & LSI_CTEST2_PCICIE;
1640         break;
1641     case 0x1b: /* CTEST3 */
1642         s->ctest3 = val & 0x0f;
1643         break;
1644     CASE_SET_REG32(temp, 0x1c)
1645     case 0x21: /* CTEST4 */
1646         if (val & 7) {
1647            BADF("Unimplemented CTEST4-FBL 0x%x\n", val);
1648         }
1649         s->ctest4 = val;
1650         break;
1651     case 0x22: /* CTEST5 */
1652         if (val & (LSI_CTEST5_ADCK | LSI_CTEST5_BBCK)) {
1653             BADF("CTEST5 DMA increment not implemented\n");
1654         }
1655         s->ctest5 = val;
1656         break;
1657     CASE_SET_REG24(dbc, 0x24)
1658     CASE_SET_REG32(dnad, 0x28)
1659     case 0x2c: /* DSP[0:7] */
1660         s->dsp &= 0xffffff00;
1661         s->dsp |= val;
1662         break;
1663     case 0x2d: /* DSP[8:15] */
1664         s->dsp &= 0xffff00ff;
1665         s->dsp |= val << 8;
1666         break;
1667     case 0x2e: /* DSP[16:23] */
1668         s->dsp &= 0xff00ffff;
1669         s->dsp |= val << 16;
1670         break;
1671     case 0x2f: /* DSP[24:31] */
1672         s->dsp &= 0x00ffffff;
1673         s->dsp |= val << 24;
1674         if ((s->dmode & LSI_DMODE_MAN) == 0
1675             && (s->istat1 & LSI_ISTAT1_SRUN) == 0)
1676             lsi_execute_script(s);
1677         break;
1678     CASE_SET_REG32(dsps, 0x30)
1679     CASE_SET_REG32(scratch[0], 0x34)
1680     case 0x38: /* DMODE */
1681         if (val & (LSI_DMODE_SIOM | LSI_DMODE_DIOM)) {
1682             BADF("IO mappings not implemented\n");
1683         }
1684         s->dmode = val;
1685         break;
1686     case 0x39: /* DIEN */
1687         s->dien = val;
1688         lsi_update_irq(s);
1689         break;
1690     case 0x3a: /* SBR */
1691         s->sbr = val;
1692         break;
1693     case 0x3b: /* DCNTL */
1694         s->dcntl = val & ~(LSI_DCNTL_PFF | LSI_DCNTL_STD);
1695         if ((val & LSI_DCNTL_STD) && (s->istat1 & LSI_ISTAT1_SRUN) == 0)
1696             lsi_execute_script(s);
1697         break;
1698     case 0x40: /* SIEN0 */
1699         s->sien0 = val;
1700         lsi_update_irq(s);
1701         break;
1702     case 0x41: /* SIEN1 */
1703         s->sien1 = val;
1704         lsi_update_irq(s);
1705         break;
1706     case 0x47: /* GPCNTL0 */
1707         break;
1708     case 0x48: /* STIME0 */
1709         s->stime0 = val;
1710         break;
1711     case 0x49: /* STIME1 */
1712         if (val & 0xf) {
1713             DPRINTF("General purpose timer not implemented\n");
1714             /* ??? Raising the interrupt immediately seems to be sufficient
1715                to keep the FreeBSD driver happy.  */
1716             lsi_script_scsi_interrupt(s, 0, LSI_SIST1_GEN);
1717         }
1718         break;
1719     case 0x4a: /* RESPID0 */
1720         s->respid0 = val;
1721         break;
1722     case 0x4b: /* RESPID1 */
1723         s->respid1 = val;
1724         break;
1725     case 0x4d: /* STEST1 */
1726         s->stest1 = val;
1727         break;
1728     case 0x4e: /* STEST2 */
1729         if (val & 1) {
1730             BADF("Low level mode not implemented\n");
1731         }
1732         s->stest2 = val;
1733         break;
1734     case 0x4f: /* STEST3 */
1735         if (val & 0x41) {
1736             BADF("SCSI FIFO test mode not implemented\n");
1737         }
1738         s->stest3 = val;
1739         break;
1740     case 0x56: /* CCNTL0 */
1741         s->ccntl0 = val;
1742         break;
1743     case 0x57: /* CCNTL1 */
1744         s->ccntl1 = val;
1745         break;
1746     CASE_SET_REG32(mmrs, 0xa0)
1747     CASE_SET_REG32(mmws, 0xa4)
1748     CASE_SET_REG32(sfs, 0xa8)
1749     CASE_SET_REG32(drs, 0xac)
1750     CASE_SET_REG32(sbms, 0xb0)
1751     CASE_SET_REG32(dbms, 0xb4)
1752     CASE_SET_REG32(dnad64, 0xb8)
1753     CASE_SET_REG32(pmjad1, 0xc0)
1754     CASE_SET_REG32(pmjad2, 0xc4)
1755     CASE_SET_REG32(rbc, 0xc8)
1756     CASE_SET_REG32(ua, 0xcc)
1757     CASE_SET_REG32(ia, 0xd4)
1758     CASE_SET_REG32(sbc, 0xd8)
1759     CASE_SET_REG32(csbc, 0xdc)
1760     default:
1761         if (offset >= 0x5c && offset < 0xa0) {
1762             int n;
1763             int shift;
1764             n = (offset - 0x58) >> 2;
1765             shift = (offset & 3) * 8;
1766             s->scratch[n] &= ~(0xff << shift);
1767             s->scratch[n] |= (val & 0xff) << shift;
1768         } else {
1769             BADF("Unhandled writeb 0x%x = 0x%x\n", offset, val);
1770         }
1771     }
1772 #undef CASE_SET_REG24
1773 #undef CASE_SET_REG32
1774 }
1775
1776 static void lsi_mmio_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1777 {
1778     LSIState *s = opaque;
1779
1780     lsi_reg_writeb(s, addr & 0xff, val);
1781 }
1782
1783 static void lsi_mmio_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1784 {
1785     LSIState *s = opaque;
1786
1787     addr &= 0xff;
1788     lsi_reg_writeb(s, addr, val & 0xff);
1789     lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1790 }
1791
1792 static void lsi_mmio_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1793 {
1794     LSIState *s = opaque;
1795
1796     addr &= 0xff;
1797     lsi_reg_writeb(s, addr, val & 0xff);
1798     lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1799     lsi_reg_writeb(s, addr + 2, (val >> 16) & 0xff);
1800     lsi_reg_writeb(s, addr + 3, (val >> 24) & 0xff);
1801 }
1802
1803 static uint32_t lsi_mmio_readb(void *opaque, target_phys_addr_t addr)
1804 {
1805     LSIState *s = opaque;
1806
1807     return lsi_reg_readb(s, addr & 0xff);
1808 }
1809
1810 static uint32_t lsi_mmio_readw(void *opaque, target_phys_addr_t addr)
1811 {
1812     LSIState *s = opaque;
1813     uint32_t val;
1814
1815     addr &= 0xff;
1816     val = lsi_reg_readb(s, addr);
1817     val |= lsi_reg_readb(s, addr + 1) << 8;
1818     return val;
1819 }
1820
1821 static uint32_t lsi_mmio_readl(void *opaque, target_phys_addr_t addr)
1822 {
1823     LSIState *s = opaque;
1824     uint32_t val;
1825     addr &= 0xff;
1826     val = lsi_reg_readb(s, addr);
1827     val |= lsi_reg_readb(s, addr + 1) << 8;
1828     val |= lsi_reg_readb(s, addr + 2) << 16;
1829     val |= lsi_reg_readb(s, addr + 3) << 24;
1830     return val;
1831 }
1832
1833 static CPUReadMemoryFunc * const lsi_mmio_readfn[3] = {
1834     lsi_mmio_readb,
1835     lsi_mmio_readw,
1836     lsi_mmio_readl,
1837 };
1838
1839 static CPUWriteMemoryFunc * const lsi_mmio_writefn[3] = {
1840     lsi_mmio_writeb,
1841     lsi_mmio_writew,
1842     lsi_mmio_writel,
1843 };
1844
1845 static void lsi_ram_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
1846 {
1847     LSIState *s = opaque;
1848     uint32_t newval;
1849     int shift;
1850
1851     addr &= 0x1fff;
1852     newval = s->script_ram[addr >> 2];
1853     shift = (addr & 3) * 8;
1854     newval &= ~(0xff << shift);
1855     newval |= val << shift;
1856     s->script_ram[addr >> 2] = newval;
1857 }
1858
1859 static void lsi_ram_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
1860 {
1861     LSIState *s = opaque;
1862     uint32_t newval;
1863
1864     addr &= 0x1fff;
1865     newval = s->script_ram[addr >> 2];
1866     if (addr & 2) {
1867         newval = (newval & 0xffff) | (val << 16);
1868     } else {
1869         newval = (newval & 0xffff0000) | val;
1870     }
1871     s->script_ram[addr >> 2] = newval;
1872 }
1873
1874
1875 static void lsi_ram_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1876 {
1877     LSIState *s = opaque;
1878
1879     addr &= 0x1fff;
1880     s->script_ram[addr >> 2] = val;
1881 }
1882
1883 static uint32_t lsi_ram_readb(void *opaque, target_phys_addr_t addr)
1884 {
1885     LSIState *s = opaque;
1886     uint32_t val;
1887
1888     addr &= 0x1fff;
1889     val = s->script_ram[addr >> 2];
1890     val >>= (addr & 3) * 8;
1891     return val & 0xff;
1892 }
1893
1894 static uint32_t lsi_ram_readw(void *opaque, target_phys_addr_t addr)
1895 {
1896     LSIState *s = opaque;
1897     uint32_t val;
1898
1899     addr &= 0x1fff;
1900     val = s->script_ram[addr >> 2];
1901     if (addr & 2)
1902         val >>= 16;
1903     return le16_to_cpu(val);
1904 }
1905
1906 static uint32_t lsi_ram_readl(void *opaque, target_phys_addr_t addr)
1907 {
1908     LSIState *s = opaque;
1909
1910     addr &= 0x1fff;
1911     return le32_to_cpu(s->script_ram[addr >> 2]);
1912 }
1913
1914 static CPUReadMemoryFunc * const lsi_ram_readfn[3] = {
1915     lsi_ram_readb,
1916     lsi_ram_readw,
1917     lsi_ram_readl,
1918 };
1919
1920 static CPUWriteMemoryFunc * const lsi_ram_writefn[3] = {
1921     lsi_ram_writeb,
1922     lsi_ram_writew,
1923     lsi_ram_writel,
1924 };
1925
1926 static uint32_t lsi_io_readb(void *opaque, uint32_t addr)
1927 {
1928     LSIState *s = opaque;
1929     return lsi_reg_readb(s, addr & 0xff);
1930 }
1931
1932 static uint32_t lsi_io_readw(void *opaque, uint32_t addr)
1933 {
1934     LSIState *s = opaque;
1935     uint32_t val;
1936     addr &= 0xff;
1937     val = lsi_reg_readb(s, addr);
1938     val |= lsi_reg_readb(s, addr + 1) << 8;
1939     return val;
1940 }
1941
1942 static uint32_t lsi_io_readl(void *opaque, uint32_t addr)
1943 {
1944     LSIState *s = opaque;
1945     uint32_t val;
1946     addr &= 0xff;
1947     val = lsi_reg_readb(s, addr);
1948     val |= lsi_reg_readb(s, addr + 1) << 8;
1949     val |= lsi_reg_readb(s, addr + 2) << 16;
1950     val |= lsi_reg_readb(s, addr + 3) << 24;
1951     return val;
1952 }
1953
1954 static void lsi_io_writeb(void *opaque, uint32_t addr, uint32_t val)
1955 {
1956     LSIState *s = opaque;
1957     lsi_reg_writeb(s, addr & 0xff, val);
1958 }
1959
1960 static void lsi_io_writew(void *opaque, uint32_t addr, uint32_t val)
1961 {
1962     LSIState *s = opaque;
1963     addr &= 0xff;
1964     lsi_reg_writeb(s, addr, val & 0xff);
1965     lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1966 }
1967
1968 static void lsi_io_writel(void *opaque, uint32_t addr, uint32_t val)
1969 {
1970     LSIState *s = opaque;
1971     addr &= 0xff;
1972     lsi_reg_writeb(s, addr, val & 0xff);
1973     lsi_reg_writeb(s, addr + 1, (val >> 8) & 0xff);
1974     lsi_reg_writeb(s, addr + 2, (val >> 16) & 0xff);
1975     lsi_reg_writeb(s, addr + 3, (val >> 24) & 0xff);
1976 }
1977
1978 static void lsi_io_mapfunc(PCIDevice *pci_dev, int region_num,
1979                            pcibus_t addr, pcibus_t size, int type)
1980 {
1981     LSIState *s = DO_UPCAST(LSIState, dev, pci_dev);
1982
1983     DPRINTF("Mapping IO at %08"FMT_PCIBUS"\n", addr);
1984
1985     register_ioport_write(addr, 256, 1, lsi_io_writeb, s);
1986     register_ioport_read(addr, 256, 1, lsi_io_readb, s);
1987     register_ioport_write(addr, 256, 2, lsi_io_writew, s);
1988     register_ioport_read(addr, 256, 2, lsi_io_readw, s);
1989     register_ioport_write(addr, 256, 4, lsi_io_writel, s);
1990     register_ioport_read(addr, 256, 4, lsi_io_readl, s);
1991 }
1992
1993 static void lsi_ram_mapfunc(PCIDevice *pci_dev, int region_num,
1994                             pcibus_t addr, pcibus_t size, int type)
1995 {
1996     LSIState *s = DO_UPCAST(LSIState, dev, pci_dev);
1997
1998     DPRINTF("Mapping ram at %08"FMT_PCIBUS"\n", addr);
1999     s->script_ram_base = addr;
2000     cpu_register_physical_memory(addr + 0, 0x2000, s->ram_io_addr);
2001 }
2002
2003 static void lsi_mmio_mapfunc(PCIDevice *pci_dev, int region_num,
2004                              pcibus_t addr, pcibus_t size, int type)
2005 {
2006     LSIState *s = DO_UPCAST(LSIState, dev, pci_dev);
2007
2008     DPRINTF("Mapping registers at %08"FMT_PCIBUS"\n", addr);
2009     cpu_register_physical_memory(addr + 0, 0x400, s->mmio_io_addr);
2010 }
2011
2012 static void lsi_scsi_reset(DeviceState *dev)
2013 {
2014     LSIState *s = DO_UPCAST(LSIState, dev.qdev, dev);
2015
2016     lsi_soft_reset(s);
2017 }
2018
2019 static void lsi_pre_save(void *opaque)
2020 {
2021     LSIState *s = opaque;
2022
2023     if (s->current) {
2024         assert(s->current->dma_buf == NULL);
2025         assert(s->current->dma_len == 0);
2026     }
2027     assert(QTAILQ_EMPTY(&s->queue));
2028 }
2029
2030 static const VMStateDescription vmstate_lsi_scsi = {
2031     .name = "lsiscsi",
2032     .version_id = 0,
2033     .minimum_version_id = 0,
2034     .minimum_version_id_old = 0,
2035     .pre_save = lsi_pre_save,
2036     .fields      = (VMStateField []) {
2037         VMSTATE_PCI_DEVICE(dev, LSIState),
2038
2039         VMSTATE_INT32(carry, LSIState),
2040         VMSTATE_INT32(sense, LSIState),
2041         VMSTATE_INT32(msg_action, LSIState),
2042         VMSTATE_INT32(msg_len, LSIState),
2043         VMSTATE_BUFFER(msg, LSIState),
2044         VMSTATE_INT32(waiting, LSIState),
2045
2046         VMSTATE_UINT32(dsa, LSIState),
2047         VMSTATE_UINT32(temp, LSIState),
2048         VMSTATE_UINT32(dnad, LSIState),
2049         VMSTATE_UINT32(dbc, LSIState),
2050         VMSTATE_UINT8(istat0, LSIState),
2051         VMSTATE_UINT8(istat1, LSIState),
2052         VMSTATE_UINT8(dcmd, LSIState),
2053         VMSTATE_UINT8(dstat, LSIState),
2054         VMSTATE_UINT8(dien, LSIState),
2055         VMSTATE_UINT8(sist0, LSIState),
2056         VMSTATE_UINT8(sist1, LSIState),
2057         VMSTATE_UINT8(sien0, LSIState),
2058         VMSTATE_UINT8(sien1, LSIState),
2059         VMSTATE_UINT8(mbox0, LSIState),
2060         VMSTATE_UINT8(mbox1, LSIState),
2061         VMSTATE_UINT8(dfifo, LSIState),
2062         VMSTATE_UINT8(ctest2, LSIState),
2063         VMSTATE_UINT8(ctest3, LSIState),
2064         VMSTATE_UINT8(ctest4, LSIState),
2065         VMSTATE_UINT8(ctest5, LSIState),
2066         VMSTATE_UINT8(ccntl0, LSIState),
2067         VMSTATE_UINT8(ccntl1, LSIState),
2068         VMSTATE_UINT32(dsp, LSIState),
2069         VMSTATE_UINT32(dsps, LSIState),
2070         VMSTATE_UINT8(dmode, LSIState),
2071         VMSTATE_UINT8(dcntl, LSIState),
2072         VMSTATE_UINT8(scntl0, LSIState),
2073         VMSTATE_UINT8(scntl1, LSIState),
2074         VMSTATE_UINT8(scntl2, LSIState),
2075         VMSTATE_UINT8(scntl3, LSIState),
2076         VMSTATE_UINT8(sstat0, LSIState),
2077         VMSTATE_UINT8(sstat1, LSIState),
2078         VMSTATE_UINT8(scid, LSIState),
2079         VMSTATE_UINT8(sxfer, LSIState),
2080         VMSTATE_UINT8(socl, LSIState),
2081         VMSTATE_UINT8(sdid, LSIState),
2082         VMSTATE_UINT8(ssid, LSIState),
2083         VMSTATE_UINT8(sfbr, LSIState),
2084         VMSTATE_UINT8(stest1, LSIState),
2085         VMSTATE_UINT8(stest2, LSIState),
2086         VMSTATE_UINT8(stest3, LSIState),
2087         VMSTATE_UINT8(sidl, LSIState),
2088         VMSTATE_UINT8(stime0, LSIState),
2089         VMSTATE_UINT8(respid0, LSIState),
2090         VMSTATE_UINT8(respid1, LSIState),
2091         VMSTATE_UINT32(mmrs, LSIState),
2092         VMSTATE_UINT32(mmws, LSIState),
2093         VMSTATE_UINT32(sfs, LSIState),
2094         VMSTATE_UINT32(drs, LSIState),
2095         VMSTATE_UINT32(sbms, LSIState),
2096         VMSTATE_UINT32(dbms, LSIState),
2097         VMSTATE_UINT32(dnad64, LSIState),
2098         VMSTATE_UINT32(pmjad1, LSIState),
2099         VMSTATE_UINT32(pmjad2, LSIState),
2100         VMSTATE_UINT32(rbc, LSIState),
2101         VMSTATE_UINT32(ua, LSIState),
2102         VMSTATE_UINT32(ia, LSIState),
2103         VMSTATE_UINT32(sbc, LSIState),
2104         VMSTATE_UINT32(csbc, LSIState),
2105         VMSTATE_BUFFER_UNSAFE(scratch, LSIState, 0, 18 * sizeof(uint32_t)),
2106         VMSTATE_UINT8(sbr, LSIState),
2107
2108         VMSTATE_BUFFER_UNSAFE(script_ram, LSIState, 0, 2048 * sizeof(uint32_t)),
2109         VMSTATE_END_OF_LIST()
2110     }
2111 };
2112
2113 static int lsi_scsi_uninit(PCIDevice *d)
2114 {
2115     LSIState *s = DO_UPCAST(LSIState, dev, d);
2116
2117     cpu_unregister_io_memory(s->mmio_io_addr);
2118     cpu_unregister_io_memory(s->ram_io_addr);
2119
2120     return 0;
2121 }
2122
2123 static int lsi_scsi_init(PCIDevice *dev)
2124 {
2125     LSIState *s = DO_UPCAST(LSIState, dev, dev);
2126     uint8_t *pci_conf;
2127
2128     pci_conf = s->dev.config;
2129
2130     /* PCI Vendor ID (word) */
2131     pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_LSI_LOGIC);
2132     /* PCI device ID (word) */
2133     pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_LSI_53C895A);
2134     /* PCI base class code */
2135     pci_config_set_class(pci_conf, PCI_CLASS_STORAGE_SCSI);
2136     /* PCI subsystem ID */
2137     pci_conf[PCI_SUBSYSTEM_ID] = 0x00;
2138     pci_conf[PCI_SUBSYSTEM_ID + 1] = 0x10;
2139     /* PCI latency timer = 255 */
2140     pci_conf[PCI_LATENCY_TIMER] = 0xff;
2141     /* TODO: RST# value should be 0 */
2142     /* Interrupt pin 1 */
2143     pci_conf[PCI_INTERRUPT_PIN] = 0x01;
2144
2145     s->mmio_io_addr = cpu_register_io_memory(lsi_mmio_readfn,
2146                                              lsi_mmio_writefn, s);
2147     s->ram_io_addr = cpu_register_io_memory(lsi_ram_readfn,
2148                                             lsi_ram_writefn, s);
2149
2150     /* TODO: use dev and get rid of cast below */
2151     pci_register_bar((struct PCIDevice *)s, 0, 256,
2152                            PCI_BASE_ADDRESS_SPACE_IO, lsi_io_mapfunc);
2153     pci_register_bar((struct PCIDevice *)s, 1, 0x400,
2154                            PCI_BASE_ADDRESS_SPACE_MEMORY, lsi_mmio_mapfunc);
2155     pci_register_bar((struct PCIDevice *)s, 2, 0x2000,
2156                            PCI_BASE_ADDRESS_SPACE_MEMORY, lsi_ram_mapfunc);
2157     QTAILQ_INIT(&s->queue);
2158
2159     scsi_bus_new(&s->bus, &dev->qdev, 1, LSI_MAX_DEVS, lsi_command_complete);
2160     if (!dev->qdev.hotplugged) {
2161         scsi_bus_legacy_handle_cmdline(&s->bus);
2162     }
2163     return 0;
2164 }
2165
2166 static PCIDeviceInfo lsi_info = {
2167     .qdev.name  = "lsi53c895a",
2168     .qdev.alias = "lsi",
2169     .qdev.size  = sizeof(LSIState),
2170     .qdev.reset = lsi_scsi_reset,
2171     .qdev.vmsd  = &vmstate_lsi_scsi,
2172     .init       = lsi_scsi_init,
2173     .exit       = lsi_scsi_uninit,
2174 };
2175
2176 static void lsi53c895a_register_devices(void)
2177 {
2178     pci_qdev_register(&lsi_info);
2179 }
2180
2181 device_init(lsi53c895a_register_devices);