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