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