Previous 199869 Revisions Next

r17520 Monday 27th August, 2012 at 22:48:14 UTC by smf
converted 53c810 to a c++ device. (nw)
[src/emu/machine]53c810.c 53c810.h
[src/mame/drivers]model3.c
[src/mame/includes]model3.h
[src/mess/drivers]bebox.c
[src/mess/includes]bebox.h
[src/mess/machine]bebox.c

trunk/src/mame/includes/model3.h
r17519r17520
11#include "video/poly.h"
2#include "machine/53c810.h"
23
34typedef float MATRIX[4][4];
45typedef float VECTOR[4];
r17519r17520
1617   model3_state(const machine_config &mconfig, device_type type, const char *tag)
1718      : driver_device(mconfig, type, tag),
1819      m_maincpu(*this,"maincpu"),
20      m_lsi53c810(*this,"lsi53c810"),
1921      m_work_ram(*this, "work_ram"),
2022      m_paletteram64(*this, "paletteram64"),
2123      m_soundram(*this, "soundram"){ }
2224
2325   required_device<cpu_device> m_maincpu;
26   required_device<lsi53c810_device> m_lsi53c810;
2427
2528   required_shared_ptr<UINT64> m_work_ram;
2629   required_shared_ptr<UINT64> m_paletteram64;
trunk/src/mame/drivers/model3.c
r17519r17520
10011001   int reg = offset*8;
10021002   UINT64 r = 0;
10031003   if (ACCESSING_BITS_56_63) {
1004      r |= (UINT64)lsi53c810_reg_r(&space, reg+0) << 56;
1004      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+0) << 56;
10051005   }
10061006   if (ACCESSING_BITS_48_55) {
1007      r |= (UINT64)lsi53c810_reg_r(&space, reg+1) << 48;
1007      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+1) << 48;
10081008   }
10091009   if (ACCESSING_BITS_40_47) {
1010      r |= (UINT64)lsi53c810_reg_r(&space, reg+2) << 40;
1010      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+2) << 40;
10111011   }
10121012   if (ACCESSING_BITS_32_39) {
1013      r |= (UINT64)lsi53c810_reg_r(&space, reg+3) << 32;
1013      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+3) << 32;
10141014   }
10151015   if (ACCESSING_BITS_24_31) {
1016      r |= (UINT64)lsi53c810_reg_r(&space, reg+4) << 24;
1016      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+4) << 24;
10171017   }
10181018   if (ACCESSING_BITS_16_23) {
1019      r |= (UINT64)lsi53c810_reg_r(&space, reg+5) << 16;
1019      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+5) << 16;
10201020   }
10211021   if (ACCESSING_BITS_8_15) {
1022      r |= (UINT64)lsi53c810_reg_r(&space, reg+6) << 8;
1022      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+6) << 8;
10231023   }
10241024   if (ACCESSING_BITS_0_7) {
1025      r |= (UINT64)lsi53c810_reg_r(&space, reg+7) << 0;
1025      r |= (UINT64)m_lsi53c810->lsi53c810_reg_r(reg+7) << 0;
10261026   }
10271027
10281028   return r;
r17519r17520
10321032{
10331033   int reg = offset*8;
10341034   if (ACCESSING_BITS_56_63) {
1035      lsi53c810_reg_w(&space, reg+0, data >> 56);
1035      m_lsi53c810->lsi53c810_reg_w(reg+0, data >> 56);
10361036   }
10371037   if (ACCESSING_BITS_48_55) {
1038      lsi53c810_reg_w(&space, reg+1, data >> 48);
1038      m_lsi53c810->lsi53c810_reg_w(reg+1, data >> 48);
10391039   }
10401040   if (ACCESSING_BITS_40_47) {
1041      lsi53c810_reg_w(&space, reg+2, data >> 40);
1041      m_lsi53c810->lsi53c810_reg_w(reg+2, data >> 40);
10421042   }
10431043   if (ACCESSING_BITS_32_39) {
1044      lsi53c810_reg_w(&space, reg+3, data >> 32);
1044      m_lsi53c810->lsi53c810_reg_w(reg+3, data >> 32);
10451045   }
10461046   if (ACCESSING_BITS_24_31) {
1047      lsi53c810_reg_w(&space, reg+4, data >> 24);
1047      m_lsi53c810->lsi53c810_reg_w(reg+4, data >> 24);
10481048   }
10491049   if (ACCESSING_BITS_16_23) {
1050      lsi53c810_reg_w(&space, reg+5, data >> 16);
1050      m_lsi53c810->lsi53c810_reg_w(reg+5, data >> 16);
10511051   }
10521052   if (ACCESSING_BITS_8_15) {
1053      lsi53c810_reg_w(&space, reg+6, data >> 8);
1053      m_lsi53c810->lsi53c810_reg_w(reg+6, data >> 8);
10541054   }
10551055   if (ACCESSING_BITS_0_7) {
1056      lsi53c810_reg_w(&space, reg+7, data >> 0);
1056      m_lsi53c810->lsi53c810_reg_w(reg+7, data >> 0);
10571057   }
10581058}
10591059
r17519r17520
12411241
12421242static MACHINE_START(model3_10)
12431243{
1244   lsi53c810_init(machine, &scsi_intf);
12451244   configure_fast_ram(machine);
12461245
12471246   model3_state *state = machine.driver_data<model3_state>();
r17519r17520
12491248}
12501249static MACHINE_START(model3_15)
12511250{
1252   lsi53c810_init(machine, &scsi_intf);
12531251   configure_fast_ram(machine);
12541252
12551253   model3_state *state = machine.driver_data<model3_state>();
r17519r17520
53415339   MCFG_SOUND_CONFIG(scsp2_interface)
53425340   MCFG_SOUND_ROUTE(0, "lspeaker", 2.0)
53435341   MCFG_SOUND_ROUTE(0, "rspeaker", 2.0)
5342
5343   MCFG_LSI53C810_ADD( "lsi51c810", scsi_intf)   
53445344MACHINE_CONFIG_END
53455345
53465346static MACHINE_CONFIG_START( model3_15, model3_state )
r17519r17520
53805380   MCFG_SOUND_CONFIG(scsp2_interface)
53815381   MCFG_SOUND_ROUTE(0, "lspeaker", 2.0)
53825382   MCFG_SOUND_ROUTE(0, "rspeaker", 2.0)
5383
5384   MCFG_LSI53C810_ADD( "lsi51c810", scsi_intf)   
53835385MACHINE_CONFIG_END
53845386
53855387static MACHINE_CONFIG_START( model3_20, model3_state )
trunk/src/emu/machine/53c810.c
r17519r17520
77#define DMA_MAX_ICOUNT   512      /* Maximum number of DMA Scripts opcodes to run */
88#define DASM_OPCODES 0
99
10static scsidev_device *devices[8];   /* SCSI IDs 0-7 */
11static const struct LSI53C810interface *intf;
12static UINT8 last_id;
13
14static struct {
15   UINT8 scntl0;
16   UINT8 scntl1;
17   UINT8 scntl2;
18   UINT8 scntl3;
19   UINT8 scid;
20   UINT8 sxfer;
21   UINT8 socl;
22   UINT8 istat;
23   UINT8 dstat;
24   UINT8 sstat0;
25   UINT8 sstat1;
26   UINT8 sstat2;
27   UINT8 dien;
28   UINT8 dcntl;
29   UINT8 dmode;
30   UINT32 temp;
31   UINT32 dsa;
32   UINT32 dsp;
33   UINT32 dsps;
34   UINT32 dcmd;
35   UINT8 sien0;
36   UINT8 sien1;
37   UINT8 stime0;
38   UINT8 respid;
39   UINT8 stest1;
40   UINT8 scratch_a[4];
41   UINT8 scratch_b[4];
42   int dma_icount;
43   int halted;
44   int carry;
45   UINT32 (* fetch)(UINT32 dsp);
46   void (* irq_callback)(running_machine &machine);
47   void (* dma_callback)(UINT32, UINT32, int, int);
48} lsi810;
49
50typedef void (*opcode_handler)(running_machine &machine);
51#define OPCODE_HANDLER(name) void name(running_machine &machine)
52static opcode_handler dma_opcode[256];
53
54INLINE UINT32 FETCH(running_machine &machine)
10UINT32 lsi53c810_device::FETCH()
5511{
56   UINT32 r = intf->fetch(machine, lsi810.dsp);
57   lsi810.dsp += 4;
12   UINT32 r = fetch(machine(), dsp);
13   dsp += 4;
5814   return r;
5915}
6016
61#ifdef UNUSED_FUNCTION
62static UINT32 sign_extend24(UINT32 val)
17void lsi53c810_device::dmaop_invalid()
6318{
64   if (val & 0x00800000)
65      val |= 0xFF000000;
66   else
67      val &= ~0xFF000000;
68   return val;
19   fatalerror("LSI53C810: Invalid SCRIPTS DMA opcode %08X at %08X", dcmd, dsp);
6920}
70#endif
7121
72static OPCODE_HANDLER( dmaop_invalid )
22void lsi53c810_device::dmaop_move_memory()
7323{
74   fatalerror("LSI53C810: Invalid SCRIPTS DMA opcode %08X at %08X", lsi810.dcmd, lsi810.dsp);
75}
76
77static OPCODE_HANDLER( dmaop_move_memory )
78{
79   UINT32 src = FETCH(machine);
80   UINT32 dst = FETCH(machine);
24   UINT32 src = FETCH();
25   UINT32 dst = FETCH();
8126   int count;
8227
83   count = lsi810.dcmd & 0xffffff;
84   if(intf->dma_callback != NULL) {
85      intf->dma_callback(machine, src, dst, count, 1);
28   count = dcmd & 0xffffff;
29   if(dma_callback != NULL) {
30      dma_callback(machine(), src, dst, count, 1);
8631   }
8732}
8833
89static OPCODE_HANDLER( dmaop_interrupt )
34void lsi53c810_device::dmaop_interrupt()
9035{
91   if(lsi810.dcmd & 0x100000) {
36   if(dcmd & 0x100000) {
9237      fatalerror("LSI53C810: INTFLY opcode not implemented");
9338   }
94   lsi810.dsps = FETCH(machine);
39   dsps = FETCH();
9540
96   lsi810.istat |= 0x1;   /* DMA interrupt pending */
97   lsi810.dstat |= 0x4;   /* SIR (SCRIPTS Interrupt Instruction Received) */
41   istat |= 0x1;   /* DMA interrupt pending */
42   dstat |= 0x4;   /* SIR (SCRIPTS Interrupt Instruction Received) */
9843
99   if(intf->irq_callback != NULL) {
100      intf->irq_callback(machine, 1);
44   if(irq_callback != NULL) {
45      irq_callback(machine(), 1);
10146   }
102   lsi810.dma_icount = 0;
103   lsi810.halted = 1;
47   dma_icount = 0;
48   halted = 1;
10449}
10550
106static OPCODE_HANDLER( dmaop_block_move )
51void lsi53c810_device::dmaop_block_move()
10752{
10853   UINT32 address;
10954   UINT32 count;
11055   INT32 dsps;
11156
112   address = FETCH(machine);
113   count = lsi810.dcmd & 0x00ffffff;
57   address = FETCH();
58   count = dcmd & 0x00ffffff;
11459
11560   // normal indirect
116   if (lsi810.dcmd & 0x20000000)
117      address = intf->fetch(machine, address);
61   if (dcmd & 0x20000000)
62      address = fetch(machine(), address);
11863
11964   // table indirect
120   if (lsi810.dcmd & 0x10000000)
65   if (dcmd & 0x10000000)
12166   {
12267      dsps = (INT32)address&0xffffff;
12368      // sign extend
r17519r17520
12570      {
12671         dsps |= 0xff000000;
12772      }
128      logerror("table offset: %x, DSA = %x\n", dsps, lsi810.dsa);
129      dsps += lsi810.dsa;
73      logerror("table offset: %x, DSA = %x\n", dsps, dsa);
74      dsps += dsa;
13075
13176      logerror("Loading from table at %x\n", dsps);
132      count = lsi810.fetch(dsps);
133      address = lsi810.fetch(dsps+4);
77      count = fetch(machine(),dsps);
78      address = fetch(machine(),dsps+4);
13479   }
13580
136   logerror("block move: address %x count %x phase %x\n", address, count, (lsi810.dcmd>>24)&7);
81   logerror("block move: address %x count %x phase %x\n", address, count, (dcmd>>24)&7);
13782
138   if (lsi810.scntl0 & 0x01)
83   if (scntl0 & 0x01)
13984   {
14085      /* target mode */
14186      fatalerror("LSI53C810: dmaop_block_move not implemented in target mode");
r17519r17520
14792   }
14893}
14994
150static OPCODE_HANDLER( dmaop_select )
95void lsi53c810_device::dmaop_select()
15196{
15297//  UINT32 operand;
15398
154//  operand = FETCH(machine);
99//  operand = FETCH();
155100
156   if (lsi810.scntl0 & 0x01)
101   if (scntl0 & 0x01)
157102   {
158103      /* target mode */
159      logerror("LSI53C810: reselect ID #%d\n", (lsi810.dcmd >> 16) & 0x07);
104      logerror("LSI53C810: reselect ID #%d\n", (dcmd >> 16) & 0x07);
160105   }
161106   else
162107   {
163108      /* initiator mode */
164      logerror("53c810: SELECT: our ID %d, target ID %d\n", lsi810.scid&7, (lsi810.dcmd>>16)&7);
109      logerror("53c810: SELECT: our ID %d, target ID %d\n", scid&7, (dcmd>>16)&7);
165110
166      lsi810.sstat1 &= ~0x07;   // clear current bus phase
167      if (lsi810.dcmd & 0x01000000)   // select with ATN
111      sstat1 &= ~0x07;   // clear current bus phase
112      if (dcmd & 0x01000000)   // select with ATN
168113      {
169114         mame_printf_debug("53c810: want select with ATN, setting message phase\n");
170         lsi810.sstat1 |= 0x7;   // ATN means we want message in phase
115         sstat1 |= 0x7;   // ATN means we want message in phase
171116      }
172117   }
173118}
174119
175static OPCODE_HANDLER( dmaop_wait_disconnect )
120void lsi53c810_device::dmaop_wait_disconnect()
176121{
177122//  UINT32 operand;
178123
179//  operand = FETCH(machine);
124//  operand = FETCH();
180125
181   if (lsi810.scntl0 & 0x01)
126   if (scntl0 & 0x01)
182127   {
183128      /* target mode */
184129      fatalerror("LSI53C810: dmaop_wait_disconnect not implemented in target mode");
r17519r17520
190135   }
191136}
192137
193static OPCODE_HANDLER( dmaop_wait_reselect )
138void lsi53c810_device::dmaop_wait_reselect()
194139{
195140  //  UINT32 operand;
196141
197//  operand = FETCH(machine);
142//  operand = FETCH();
198143
199   if (lsi810.scntl0 & 0x01)
144   if (scntl0 & 0x01)
200145   {
201146      /* target mode */
202147      fatalerror("LSI53C810: dmaop_wait_reselect not implemented in target mode");
r17519r17520
208153   }
209154}
210155
211static OPCODE_HANDLER( dmaop_set )
156void lsi53c810_device::dmaop_set()
212157{
213158//  UINT32 operand;
214159
215//  operand = FETCH(machine);
160//  operand = FETCH();
216161
217162   /* initiator mode */
218   if (lsi810.dcmd & 0x8)
163   if (dcmd & 0x8)
219164   {
220165      // set ATN in SOCL
221      lsi810.socl |= 0x08;
166      socl |= 0x08;
222167   }
223   if (lsi810.dcmd & 0x40)
168   if (dcmd & 0x40)
224169   {
225170      // set ACK in SOCL
226      lsi810.socl |= 0x40;
171      socl |= 0x40;
227172   }
228   if (lsi810.dcmd & 0x200)
173   if (dcmd & 0x200)
229174   {
230175      // set target mode
231      lsi810.scntl0 |= 0x01;
176      scntl0 |= 0x01;
232177   }
233   if (lsi810.dcmd & 0x400)
178   if (dcmd & 0x400)
234179   {
235180      // set carry in ALU
236      lsi810.carry = 1;
181      carry = 1;
237182   }
238183}
239184
240static OPCODE_HANDLER( dmaop_clear )
185void lsi53c810_device::dmaop_clear()
241186{
242187//  UINT32 operand;
243188
244//  operand = FETCH(machine);
189//  operand = FETCH();
245190
246191   /* initiator mode */
247   if (lsi810.dcmd & 0x8)
192   if (dcmd & 0x8)
248193   {
249194      //  clear ATN in SOCL
250      lsi810.socl &= ~0x08;
195      socl &= ~0x08;
251196   }
252   if (lsi810.dcmd & 0x40)
197   if (dcmd & 0x40)
253198   {
254199      // clear ACK in SOCL
255      lsi810.socl &= ~0x40;
200      socl &= ~0x40;
256201   }
257   if (lsi810.dcmd & 0x200)
202   if (dcmd & 0x200)
258203   {
259204      // clear target mode
260      lsi810.scntl0 &= ~0x01;
205      scntl0 &= ~0x01;
261206   }
262   if (lsi810.dcmd & 0x400)
207   if (dcmd & 0x400)
263208   {
264209      // clear carry in ALU
265      lsi810.carry = 0;
210      carry = 0;
266211   }
267212}
268213
269static OPCODE_HANDLER( dmaop_move_from_sfbr )
214void lsi53c810_device::dmaop_move_from_sfbr()
270215{
271216   fatalerror("LSI53C810: dmaop_move_from_sfbr not implemented in target mode");
272217}
273218
274static OPCODE_HANDLER( dmaop_move_to_sfbr )
219void lsi53c810_device::dmaop_move_to_sfbr()
275220{
276221   fatalerror("LSI53C810: dmaop_move_to_sfbr not implemented");
277222}
278223
279static OPCODE_HANDLER( dmaop_read_modify_write )
224void lsi53c810_device::dmaop_read_modify_write()
280225{
281226   fatalerror("LSI53C810: dmaop_read_modify_write not implemented");
282227}
283228
284static int scripts_compute_branch(void)
229int lsi53c810_device::scripts_compute_branch()
285230{
286231   int dtest, ptest, wanted, passed;
287232
r17519r17520
292237//   |      |compare phase
293238//   |desired phase: message in
294239
295   if (lsi810.dcmd & 0x00200000)
240   if (dcmd & 0x00200000)
296241   {
297242      fatalerror("LSI53C810: jump with carry test not implemented");
298243   }
299244
300   if (lsi810.dcmd & 0x00100000)
245   if (dcmd & 0x00100000)
301246   {
302247      fatalerror("LSI53C810: jump with interrupt on the fly not implemented");
303248   }
304249
305250   // set desired result to take jump
306   wanted = (lsi810.dcmd & 0x00080000) ? 1 : 0;
251   wanted = (dcmd & 0x00080000) ? 1 : 0;
307252   // default to passing the tests in case they're disabled
308253   dtest = ptest = wanted;
309254
310255   // phase test?
311   if (lsi810.dcmd & 0x00020000)
256   if (dcmd & 0x00020000)
312257   {
313      logerror("53c810: phase test.  current: %x.  target: %x\n", lsi810.sstat1 & 7, (lsi810.dcmd>>24)&7);
258      logerror("53c810: phase test.  current: %x.  target: %x\n", sstat1 & 7, (dcmd>>24)&7);
314259
315260      // do the phases match?
316      if (((lsi810.dcmd>>24)&7) == (lsi810.sstat1 & 7))
261      if (((dcmd>>24)&7) == (sstat1 & 7))
317262      {
318263         ptest = 1;
319264      }
r17519r17520
324269   }
325270
326271   // data test?
327   if (lsi810.dcmd & 0x00040000)
272   if (dcmd & 0x00040000)
328273   {
329      logerror("53c810: data test.  target: %x [not yet implemented]\n", lsi810.dcmd&0xff);
274      logerror("53c810: data test.  target: %x [not yet implemented]\n", dcmd&0xff);
330275   }
331276
332277   // if all conditions go, take the jump
r17519r17520
341286   return passed;
342287}
343288
344static UINT32 scripts_get_jump_dest(running_machine &machine)
289UINT32 lsi53c810_device::scripts_get_jump_dest()
345290{
346291   INT32 dsps;
347292   UINT32 dest;
348293
349   dsps = FETCH(machine);
294   dsps = FETCH();
350295
351296   /* relative or absolute addressing? */
352   if (lsi810.dcmd & 0x00800000)
297   if (dcmd & 0x00800000)
353298   {
354299      // sign-extend the 24-bit value
355300      if (dsps & 0x00800000)
r17519r17520
357302         dsps |= 0xff000000;
358303      }
359304
360      logerror("dsps = %x, dsp = %x\n", dsps, lsi810.dsp);
361      dsps += lsi810.dsp;
305      logerror("dsps = %x, dsp = %x\n", dsps, dsp);
306      dsps += dsp;
362307   }
363308
364309   dest = (UINT32)dsps;
365310
366   logerror("cur DSP %x, dest %x\n", lsi810.dsp, dest);
311   logerror("cur DSP %x, dest %x\n", dsp, dest);
367312
368313   return dest;
369314}
370315
371static OPCODE_HANDLER( dmaop_jump )
316void lsi53c810_device::dmaop_jump()
372317{
373318   if (scripts_compute_branch())
374319   {
375      lsi810.dsp = scripts_get_jump_dest(machine);
320      dsp = scripts_get_jump_dest();
376321   }
377322   else
378323   {
379      FETCH(machine);   // skip operand to continue on
324      FETCH();   // skip operand to continue on
380325   }
381326}
382327
383static OPCODE_HANDLER( dmaop_call )
328void lsi53c810_device::dmaop_call()
384329{
385330   if (scripts_compute_branch())
386331   {
387332      // save return address
388      lsi810.temp = lsi810.dsp;
333      temp = dsp;
389334
390335      // and go
391      lsi810.dsp = scripts_get_jump_dest(machine);
336      dsp = scripts_get_jump_dest();
392337   }
393338   else
394339   {
395      FETCH(machine);   // skip operand to continue on
340      FETCH();   // skip operand to continue on
396341   }
397342}
398343
399static OPCODE_HANDLER( dmaop_return )
344void lsi53c810_device::dmaop_return()
400345{
401346   // is this correct?  return only happens if the condition is true?
402347   if (scripts_compute_branch())
403348   {
404349      // restore return address
405      lsi810.dsp = lsi810.temp;
350      dsp = temp;
406351   }
407352   else
408353   {
409      FETCH(machine);   // skip operand to continue on
354      FETCH();   // skip operand to continue on
410355   }
411356}
412357
413static OPCODE_HANDLER( dmaop_store )
358void lsi53c810_device::dmaop_store()
414359{
415360   fatalerror("LSI53C810: dmaop_store not implemented");
416361}
417362
418static OPCODE_HANDLER( dmaop_load )
363void lsi53c810_device::dmaop_load()
419364{
420365   fatalerror("LSI53C810: dmaop_load not implemented");
421366}
422367
423368
424369
425static void dma_exec(running_machine &machine)
370void lsi53c810_device::dma_exec()
426371{
427   lsi810.dma_icount = DMA_MAX_ICOUNT;
372   dma_icount = DMA_MAX_ICOUNT;
428373
429   while(lsi810.dma_icount > 0)
374   while(dma_icount > 0)
430375   {
431376      int op;
432377
433378      if (DASM_OPCODES)
434379      {
435380         char buf[256];
436         lsi53c810_dasm(machine, buf, lsi810.dsp);
437         logerror("0x%08X: %s\n", lsi810.dsp, buf);
381         lsi53c810_dasm(buf, dsp);
382         logerror("0x%08X: %s\n", dsp, buf);
438383      }
439384
440      lsi810.dcmd = FETCH(machine);
385      dcmd = FETCH();
441386
442      op = (lsi810.dcmd >> 24) & 0xff;
443      dma_opcode[op](machine);
387      op = (dcmd >> 24) & 0xff;
388      dma_opcode[op]();
444389
445      lsi810.dma_icount--;
390      dma_icount--;
446391   }
447392}
448393
449READ8_HANDLER( lsi53c810_reg_r )
394UINT8 lsi53c810_device::lsi53c810_reg_r( int offset )
450395{
451   logerror("53c810: read reg %d:0x%x (PC=%x)\n", offset, offset, cpu_get_pc(&space->device()));
396//   logerror("53c810: read reg %d:0x%x (PC=%x)\n", offset, offset, cpu_get_pc(&space->device()));
452397   switch(offset)
453398   {
454399      case 0x00:      /* SCNTL0 */
455         return lsi810.scntl0;
400         return scntl0;
456401      case 0x01:      /* SCNTL1 */
457         return lsi810.scntl1;
402         return scntl1;
458403      case 0x02:      /* SCNTL2 */
459         return lsi810.scntl2;
404         return scntl2;
460405      case 0x03:      /* SCNTL3 */
461         return lsi810.scntl3;
406         return scntl3;
462407      case 0x04:      /* SCID */
463         return lsi810.scid;
408         return scid;
464409      case 0x05:      /* SXFER */
465         return lsi810.sxfer;
410         return sxfer;
466411      case 0x09:      /* SOCL */
467         return lsi810.socl;
412         return socl;
468413      case 0x0c:      /* DSTAT */
469         return lsi810.dstat;
414         return dstat;
470415      case 0x0d:      /* SSTAT0 */
471         return lsi810.sstat0;
416         return sstat0;
472417      case 0x0e:      /* SSTAT1 */
473         return lsi810.sstat1;
418         return sstat1;
474419      case 0x0f:      /* SSTAT2 */
475         return lsi810.sstat2;
420         return sstat2;
476421      case 0x10:      /* DSA [7-0] */
477         return lsi810.dsa & 0xff;
422         return dsa & 0xff;
478423      case 0x11:      /* DSA [15-8] */
479         return (lsi810.dsa >> 8) & 0xff;
424         return (dsa >> 8) & 0xff;
480425      case 0x12:      /* DSA [23-16] */
481         return (lsi810.dsa >> 16) & 0xff;
426         return (dsa >> 16) & 0xff;
482427      case 0x13:      /* DSA [31-24] */
483         return (lsi810.dsa >> 24) & 0xff;
428         return (dsa >> 24) & 0xff;
484429      case 0x14:      /* ISTAT */
485430         // clear the interrupt on service
486         if(intf->irq_callback != NULL)
431         if(irq_callback != NULL)
487432         {
488            intf->irq_callback(space->machine(), 0);
433            irq_callback(machine(), 0);
489434         }
490435
491         return lsi810.istat;
436         return istat;
492437      case 0x2c:      /* DSP [7-0] */
493         return lsi810.dsp & 0xff;
438         return dsp & 0xff;
494439      case 0x2d:      /* DSP [15-8] */
495         return (lsi810.dsp >> 8) & 0xff;
440         return (dsp >> 8) & 0xff;
496441      case 0x2e:      /* DSP [23-16] */
497         return (lsi810.dsp >> 16) & 0xff;
442         return (dsp >> 16) & 0xff;
498443      case 0x2f:      /* DSP [31-24] */
499         return (lsi810.dsp >> 24) & 0xff;
444         return (dsp >> 24) & 0xff;
500445      case 0x34:      /* SCRATCH A */
501446      case 0x35:
502447      case 0x36:
503448      case 0x37:
504         return lsi810.scratch_a[offset % 4];
449         return scratch_a[offset % 4];
505450      case 0x39:      /* DIEN */
506         return lsi810.dien;
451         return dien;
507452      case 0x3b:      /* DCNTL */
508         return lsi810.dcntl;
453         return dcntl;
509454      case 0x40:      /* SIEN0 */
510         return lsi810.sien0;
455         return sien0;
511456      case 0x41:      /* SIEN1 */
512         return lsi810.sien1;
457         return sien1;
513458      case 0x48:      /* STIME0 */
514         return lsi810.stime0;
459         return stime0;
515460      case 0x4a:      /* RESPID */
516         return lsi810.respid;
461         return respid;
517462      case 0x4d:      /* STEST1 */
518         return lsi810.stest1;
463         return stest1;
519464      case 0x5c:      /* SCRATCH B */
520465      case 0x5d:
521466      case 0x5e:
522467      case 0x5f:
523         return lsi810.scratch_b[offset % 4];
468         return scratch_b[offset % 4];
524469
525470      default:
526471         fatalerror("LSI53C810: reg_r: Unknown reg %02X", offset);
r17519r17520
529474   return 0;
530475}
531476
532WRITE8_HANDLER( lsi53c810_reg_w )
477void lsi53c810_device::lsi53c810_reg_w(int offset, UINT8 data)
533478{
534   logerror("53c810: %02x to reg %d:0x%x (PC=%x)\n", data, offset, offset, cpu_get_pc(&space->device()));
479//   logerror("53c810: %02x to reg %d:0x%x (PC=%x)\n", data, offset, offset, cpu_get_pc(&space->device()));
535480   switch(offset)
536481   {
537482      case 0x00:      /* SCNTL0 */
538         lsi810.scntl0 = data;
483         scntl0 = data;
539484         break;
540485      case 0x01:      /* SCNTL1 */
541         lsi810.scntl1 = data;
486         scntl1 = data;
542487         break;
543488      case 0x02:      /* SCNTL2 */
544         lsi810.scntl2 = data;
489         scntl2 = data;
545490         break;
546491      case 0x03:      /* SCNTL3 */
547         lsi810.scntl3 = data;
492         scntl3 = data;
548493         break;
549494      case 0x04:      /* SCID */
550         lsi810.scid = data;
495         scid = data;
551496         break;
552497      case 0x05:      /* SXFER */
553         lsi810.sxfer = data;
498         sxfer = data;
554499         break;
555500      case 0x09:      /* SOCL */
556         lsi810.socl = data;
501         socl = data;
557502         break;
558503      case 0x0d:      /* SSTAT0 */
559         lsi810.sstat0 = data;
504         sstat0 = data;
560505         break;
561506      case 0x0e:      /* SSTAT1 */
562         lsi810.sstat1 = data;
507         sstat1 = data;
563508         break;
564509      case 0x0f:      /* SSTAT2 */
565         lsi810.sstat2 = data;
510         sstat2 = data;
566511         break;
567512      case 0x10:      /* DSA [7-0] */
568         lsi810.dsa &= 0xffffff00;
569         lsi810.dsa |= data;
513         dsa &= 0xffffff00;
514         dsa |= data;
570515         break;
571516      case 0x11:      /* DSA [15-8] */
572         lsi810.dsa &= 0xffff00ff;
573         lsi810.dsa |= data << 8;
517         dsa &= 0xffff00ff;
518         dsa |= data << 8;
574519         break;
575520      case 0x12:      /* DSA [23-16] */
576         lsi810.dsa &= 0xff00ffff;
577         lsi810.dsa |= data << 16;
521         dsa &= 0xff00ffff;
522         dsa |= data << 16;
578523         break;
579524      case 0x13:      /* DSA [31-24] */
580         lsi810.dsa &= 0x00ffffff;
581         lsi810.dsa |= data << 24;
525         dsa &= 0x00ffffff;
526         dsa |= data << 24;
582527         break;
583528      case 0x14:      /* ISTAT */
584         lsi810.istat = data;
529         istat = data;
585530         break;
586531      case 0x2c:      /* DSP [7-0] */
587         lsi810.dsp &= 0xffffff00;
588         lsi810.dsp |= data;
532         dsp &= 0xffffff00;
533         dsp |= data;
589534         break;
590535      case 0x2d:      /* DSP [15-8] */
591         lsi810.dsp &= 0xffff00ff;
592         lsi810.dsp |= data << 8;
536         dsp &= 0xffff00ff;
537         dsp |= data << 8;
593538         break;
594539      case 0x2e:      /* DSP [23-16] */
595         lsi810.dsp &= 0xff00ffff;
596         lsi810.dsp |= data << 16;
540         dsp &= 0xff00ffff;
541         dsp |= data << 16;
597542         break;
598543      case 0x2f:      /* DSP [31-24] */
599         lsi810.dsp &= 0x00ffffff;
600         lsi810.dsp |= data << 24;
601         lsi810.halted = 0;
602         if((lsi810.dmode & 0x1) == 0 && !lsi810.halted) {
603            dma_exec(space->machine());
544         dsp &= 0x00ffffff;
545         dsp |= data << 24;
546         halted = 0;
547         if((dmode & 0x1) == 0 && !halted) {
548            dma_exec();
604549         }
605550         break;
606551      case 0x34:      /* SCRATCH A */
607552      case 0x35:
608553      case 0x36:
609554      case 0x37:
610         lsi810.scratch_a[offset % 4] = data;
555         scratch_a[offset % 4] = data;
611556         break;
612557      case 0x38:      /* DMODE */
613         lsi810.dmode = data;
558         dmode = data;
614559         break;
615560      case 0x39:      /* DIEN */
616         lsi810.dien = data;
561         dien = data;
617562         break;
618563      case 0x3b:      /* DCNTL */
619         lsi810.dcntl = data;
564         dcntl = data;
620565
621         if(lsi810.dcntl & 0x14 && !lsi810.halted)      /* single-step & start DMA */
566         if(dcntl & 0x14 && !halted)      /* single-step & start DMA */
622567         {
623568            int op;
624            lsi810.dcmd = FETCH(space->machine());
625            op = (lsi810.dcmd >> 24) & 0xff;
626            dma_opcode[op](space->machine());
569            dcmd = FETCH();
570            op = (dcmd >> 24) & 0xff;
571            dma_opcode[op]();
627572
628            lsi810.istat |= 0x3;   /* DMA interrupt pending */
629            lsi810.dstat |= 0x8;   /* SSI (Single Step Interrupt) */
630            if(intf->irq_callback != NULL) {
631               intf->irq_callback(space->machine(), 1);
573            istat |= 0x3;   /* DMA interrupt pending */
574            dstat |= 0x8;   /* SSI (Single Step Interrupt) */
575            if(irq_callback != NULL) {
576               irq_callback(machine(), 1);
632577            }
633578         }
634         else if(lsi810.dcntl & 0x04 && !lsi810.halted)   /* manual start DMA */
579         else if(dcntl & 0x04 && !halted)   /* manual start DMA */
635580         {
636            dma_exec(space->machine());
581            dma_exec();
637582         }
638583         break;
639584      case 0x40:      /* SIEN0 */
640         lsi810.sien0 = data;
585         sien0 = data;
641586         break;
642587      case 0x41:      /* SIEN1 */
643         lsi810.sien1 = data;
588         sien1 = data;
644589         break;
645590      case 0x48:      /* STIME0 */
646         lsi810.stime0 = data;
591         stime0 = data;
647592         break;
648593      case 0x4a:      /* RESPID */
649         lsi810.respid = data;
594         respid = data;
650595         break;
651596      case 0x4d:      /* STEST1 */
652         lsi810.stest1 = data;
597         stest1 = data;
653598         break;
654599      case 0x5c:      /* SCRATCH B */
655600      case 0x5d:
656601      case 0x5e:
657602      case 0x5f:
658         lsi810.scratch_b[offset % 4] = data;
603         scratch_b[offset % 4] = data;
659604         break;
660605
661606      default:
r17519r17520
663608   }
664609}
665610
666static void add_opcode(UINT8 op, UINT8 mask, opcode_handler handler)
611void lsi53c810_device::add_opcode(UINT8 op, UINT8 mask, opcode_handler_delegate handler)
667612{
668613   int i;
669614   for(i=0; i < 256; i++) {
r17519r17520
673618   }
674619}
675620
676void lsi53c810_init(running_machine &machine, const struct LSI53C810interface *interface)
621lsi53c810_device::lsi53c810_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
622    : device_t(mconfig, LSI53C810, "53C810 SCSI", tag, owner, clock)
677623{
678   int i;
624}
679625
680   // save interface pointer for later
681   intf = interface;
626void lsi53c810_device::device_config_complete()
627{
628   // inherit a copy of the static data
629   const LSI53C810interface *intf = reinterpret_cast<const LSI53C810interface *>(static_config());
630   if (intf != NULL)
631   {
632      *static_cast<LSI53C810interface *>(this) = *intf;
633   }
634}
682635
683   memset(&lsi810, 0, sizeof(lsi810));
636void lsi53c810_device::device_start()
637{
638   int i;
639
684640   for(i = 0; i < 256; i++)
685641   {
686      dma_opcode[i] = dmaop_invalid;
642      dma_opcode[i] = opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_invalid ), this);
687643   }
688644
689   add_opcode(0x00, 0xc0, dmaop_block_move);
690   add_opcode(0x40, 0xf8, dmaop_select);
691   add_opcode(0x48, 0xf8, dmaop_wait_disconnect);
692   add_opcode(0x50, 0xf8, dmaop_wait_reselect);
693   add_opcode(0x58, 0xf8, dmaop_set);
694   add_opcode(0x60, 0xf8, dmaop_clear);
695   add_opcode(0x68, 0xf8, dmaop_move_from_sfbr);
696   add_opcode(0x70, 0xf8, dmaop_move_to_sfbr);
697   add_opcode(0x78, 0xf8, dmaop_read_modify_write);
698   add_opcode(0x80, 0xf8, dmaop_jump);
699   add_opcode(0x88, 0xf8, dmaop_call);
700   add_opcode(0x90, 0xf8, dmaop_return);
701   add_opcode(0x98, 0xf8, dmaop_interrupt);
702   add_opcode(0xc0, 0xfe, dmaop_move_memory);
703   add_opcode(0xe0, 0xed, dmaop_store);
704   add_opcode(0xe1, 0xed, dmaop_load);
645   add_opcode(0x00, 0xc0, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_block_move ), this));
646   add_opcode(0x40, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_select ), this));
647   add_opcode(0x48, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_wait_disconnect ), this));
648   add_opcode(0x50, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_wait_reselect ), this));
649   add_opcode(0x58, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_set ), this));
650   add_opcode(0x60, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_clear ), this));
651   add_opcode(0x68, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_from_sfbr ), this));
652   add_opcode(0x70, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_to_sfbr ), this));
653   add_opcode(0x78, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_read_modify_write ), this));
654   add_opcode(0x80, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_jump ), this));
655   add_opcode(0x88, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_call ), this));
656   add_opcode(0x90, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_return ), this));
657   add_opcode(0x98, 0xf8, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_interrupt ), this));
658   add_opcode(0xc0, 0xfe, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_move_memory ), this));
659   add_opcode(0xe0, 0xed, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_store ), this));
660   add_opcode(0xe1, 0xed, opcode_handler_delegate(FUNC( lsi53c810_device::dmaop_load ), this));
705661
706662   memset(devices, 0, sizeof(devices));
707663
708664   // try to open the devices
709   for (i = 0; i < interface->scsidevs->devs_present; i++)
665   for (i = 0; i < scsidevs->devs_present; i++)
710666   {
711      scsidev_device *device = machine.device<scsidev_device>( interface->scsidevs->devices[i].tag );
667      scsidev_device *device = owner()->subdevice<scsidev_device>( scsidevs->devices[i].tag );
712668      devices[device->GetDeviceID()] = device;
713669   }
714670}
715671
716void lsi53c810_read_data(int bytes, UINT8 *pData)
672void lsi53c810_device::lsi53c810_read_data(int bytes, UINT8 *pData)
717673{
718674   if (devices[last_id])
719675   {
r17519r17520
725681   }
726682}
727683
728void lsi53c810_write_data(int bytes, UINT8 *pData)
684void lsi53c810_device::lsi53c810_write_data(int bytes, UINT8 *pData)
729685{
730686   if (devices[last_id])
731687   {
r17519r17520
743699 *
744700 *************************************/
745701
746static UINT32 lsi53c810_dasm_fetch(running_machine &machine, UINT32 pc)
702UINT32 lsi53c810_device::lsi53c810_dasm_fetch(UINT32 pc)
747703{
748   return intf->fetch(machine, pc);
704   return fetch(machine(), pc);
749705}
750706
751unsigned lsi53c810_dasm(running_machine &machine, char *buf, UINT32 pc)
707unsigned lsi53c810_device::lsi53c810_dasm(char *buf, UINT32 pc)
752708{
753709   unsigned result = 0;
754710   const char *op_mnemonic = NULL;
755   UINT32 op = lsi53c810_dasm_fetch(machine, pc);
711   UINT32 op = lsi53c810_dasm_fetch(pc);
756712   UINT32 dest;
757713   int i;
758714
r17519r17520
765721   if ((op & 0xF8000000) == 0x40000000)
766722   {
767723      /* SELECT */
768      dest = lsi53c810_dasm_fetch(machine, pc + 4);
724      dest = lsi53c810_dasm_fetch(pc + 4);
769725
770726      buf += sprintf(buf, "SELECT%s %d, 0x%08X",
771727         (op & 0x01000000) ? " ATN" : "",
r17519r17520
824780         case 0x98000000: op_mnemonic = "INT"; break;
825781      }
826782
827      dest = lsi53c810_dasm_fetch(machine, pc + 4);
783      dest = lsi53c810_dasm_fetch(pc + 4);
828784
829785      if (op & 0x00800000)
830786      {
r17519r17520
870826   else if ((op & 0xE0000000) == 0x00000000)
871827   {
872828      /* MOVE FROM */
873      dest = lsi53c810_dasm_fetch(machine, pc + 4);
829      dest = lsi53c810_dasm_fetch(pc + 4);
874830
875831      buf += sprintf(buf, "MOVE FROM 0x%08X, WHEN %s",
876832         dest, phases[(op >> 24) & 0x07]);
r17519r17520
880836   else if ((op & 0xE0000000) == 0x20000000)
881837   {
882838      /* MOVE PTR */
883      dest = lsi53c810_dasm_fetch(machine, pc + 4);
839      dest = lsi53c810_dasm_fetch(pc + 4);
884840
885841      buf += sprintf(buf, "MOVE 0x%08X, PTR 0x%08X, WHEN %s",
886842         (op & 0x00FFFFFF), dest, phases[(op >> 24) & 0x07]);
r17519r17520
894850   return result;
895851}
896852
853const device_type LSI53C810 = &device_creator<lsi53c810_device>;
trunk/src/emu/machine/53c810.h
r17519r17520
11#ifndef LSI53C810_H
22#define LSI53C810_H
33
4#include "machine/scsi.h"
4#include "scsi.h"
5#include "scsidev.h"
56
67struct LSI53C810interface
78{
r17519r17520
1112   UINT32 (*fetch)(running_machine &machine, UINT32 dsp);
1213};
1314
14extern void lsi53c810_init(running_machine &machine, const struct LSI53C810interface *interface);
15#define MCFG_LSI53C810_ADD( _tag, _config ) \
16   MCFG_DEVICE_ADD( _tag, LSI53C810, 0 ) \
17   MCFG_DEVICE_CONFIG(_config)
1518
16extern void lsi53c810_read_data(int bytes, UINT8 *pData);
17extern void lsi53c810_write_data(int bytes, UINT8 *pData);
19class lsi53c810_device : public device_t,
20                  public LSI53C810interface
21{
22public:
23   // construction/destruction
24   lsi53c810_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
1825
19READ8_HANDLER( lsi53c810_reg_r );
20WRITE8_HANDLER( lsi53c810_reg_w );
26   void lsi53c810_read_data(int bytes, UINT8 *pData);
27   void lsi53c810_write_data(int bytes, UINT8 *pData);
2128
22unsigned lsi53c810_dasm(running_machine &machine, char *buf, UINT32 pc);
29   UINT8 lsi53c810_reg_r( int offset );
30   void lsi53c810_reg_w(int offset, UINT8 data);
2331
32protected:
33   // device-level overrides
34   virtual void device_config_complete();
35   virtual void device_start();
36
37private:
38   typedef delegate<void (void)> opcode_handler_delegate;
39   opcode_handler_delegate dma_opcode[256];
40
41   UINT32 FETCH();
42   void dmaop_invalid();
43   void dmaop_move_memory();
44   void dmaop_interrupt();
45   void dmaop_block_move();
46   void dmaop_select();
47   void dmaop_wait_disconnect();
48   void dmaop_wait_reselect();
49   void dmaop_set();
50   void dmaop_clear();
51   void dmaop_move_from_sfbr();
52   void dmaop_move_to_sfbr();
53   void dmaop_read_modify_write();
54   int scripts_compute_branch();
55   UINT32 scripts_get_jump_dest();
56   void dmaop_jump();
57   void dmaop_call();
58   void dmaop_return();
59   void dmaop_store();
60   void dmaop_load();
61   void dma_exec();
62   void add_opcode(UINT8 op, UINT8 mask, opcode_handler_delegate handler);
63   void lsi53c810_init();
64   UINT32 lsi53c810_dasm_fetch(UINT32 pc);
65   unsigned lsi53c810_dasm(char *buf, UINT32 pc);
66
67   scsidev_device *devices[8];   /* SCSI IDs 0-7 */
68   UINT8 last_id;
69
70   UINT8 scntl0;
71   UINT8 scntl1;
72   UINT8 scntl2;
73   UINT8 scntl3;
74   UINT8 scid;
75   UINT8 sxfer;
76   UINT8 socl;
77   UINT8 istat;
78   UINT8 dstat;
79   UINT8 sstat0;
80   UINT8 sstat1;
81   UINT8 sstat2;
82   UINT8 dien;
83   UINT8 dcntl;
84   UINT8 dmode;
85   UINT32 temp;
86   UINT32 dsa;
87   UINT32 dsp;
88   UINT32 dsps;
89   UINT32 dcmd;
90   UINT8 sien0;
91   UINT8 sien1;
92   UINT8 stime0;
93   UINT8 respid;
94   UINT8 stest1;
95   UINT8 scratch_a[4];
96   UINT8 scratch_b[4];
97   int dma_icount;
98   int halted;
99   int carry;
100};
101
102// device type definition
103extern const device_type LSI53C810;
104
24105#endif
trunk/src/mess/machine/bebox.c
r17519r17520
287287}
288288
289289
290static void bebox_set_irq_bit(running_machine &machine, unsigned int interrupt_bit, int val)
290void bebox_set_irq_bit(running_machine &machine, unsigned int interrupt_bit, int val)
291291{
292292   bebox_state *state = machine.driver_data<bebox_state>();
293293   static const char *const interrupt_names[32] =
r17519r17520
840840
841841static READ64_HANDLER( scsi53c810_r )
842842{
843   bebox_state *state = space->machine().driver_data<bebox_state>();
843844   int reg = offset*8;
844845   UINT64 r = 0;
845846   if (!(mem_mask & U64(0xff00000000000000))) {
846      r |= (UINT64)lsi53c810_reg_r(space, reg+0) << 56;
847      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+0) << 56;
847848   }
848849   if (!(mem_mask & U64(0x00ff000000000000))) {
849      r |= (UINT64)lsi53c810_reg_r(space, reg+1) << 48;
850      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+1) << 48;
850851   }
851852   if (!(mem_mask & U64(0x0000ff0000000000))) {
852      r |= (UINT64)lsi53c810_reg_r(space, reg+2) << 40;
853      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+2) << 40;
853854   }
854855   if (!(mem_mask & U64(0x000000ff00000000))) {
855      r |= (UINT64)lsi53c810_reg_r(space, reg+3) << 32;
856      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+3) << 32;
856857   }
857858   if (!(mem_mask & U64(0x00000000ff000000))) {
858      r |= (UINT64)lsi53c810_reg_r(space, reg+4) << 24;
859      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+4) << 24;
859860   }
860861   if (!(mem_mask & U64(0x0000000000ff0000))) {
861      r |= (UINT64)lsi53c810_reg_r(space, reg+5) << 16;
862      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+5) << 16;
862863   }
863864   if (!(mem_mask & U64(0x000000000000ff00))) {
864      r |= (UINT64)lsi53c810_reg_r(space, reg+6) << 8;
865      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+6) << 8;
865866   }
866867   if (!(mem_mask & U64(0x00000000000000ff))) {
867      r |= (UINT64)lsi53c810_reg_r(space, reg+7) << 0;
868      r |= (UINT64)state->m_lsi53c810->lsi53c810_reg_r(reg+7) << 0;
868869   }
869870
870871   return r;
r17519r17520
873874
874875static WRITE64_HANDLER( scsi53c810_w )
875876{
877   bebox_state *state = space->machine().driver_data<bebox_state>();
876878   int reg = offset*8;
877879   if (!(mem_mask & U64(0xff00000000000000))) {
878      lsi53c810_reg_w(space, reg+0, data >> 56);
880      state->m_lsi53c810->lsi53c810_reg_w(reg+0, data >> 56);
879881   }
880882   if (!(mem_mask & U64(0x00ff000000000000))) {
881      lsi53c810_reg_w(space, reg+1, data >> 48);
883      state->m_lsi53c810->lsi53c810_reg_w(reg+1, data >> 48);
882884   }
883885   if (!(mem_mask & U64(0x0000ff0000000000))) {
884      lsi53c810_reg_w(space, reg+2, data >> 40);
886      state->m_lsi53c810->lsi53c810_reg_w(reg+2, data >> 40);
885887   }
886888   if (!(mem_mask & U64(0x000000ff00000000))) {
887      lsi53c810_reg_w(space, reg+3, data >> 32);
889      state->m_lsi53c810->lsi53c810_reg_w(reg+3, data >> 32);
888890   }
889891   if (!(mem_mask & U64(0x00000000ff000000))) {
890      lsi53c810_reg_w(space, reg+4, data >> 24);
892      state->m_lsi53c810->lsi53c810_reg_w(reg+4, data >> 24);
891893   }
892894   if (!(mem_mask & U64(0x0000000000ff0000))) {
893      lsi53c810_reg_w(space, reg+5, data >> 16);
895      state->m_lsi53c810->lsi53c810_reg_w(reg+5, data >> 16);
894896   }
895897   if (!(mem_mask & U64(0x000000000000ff00))) {
896      lsi53c810_reg_w(space, reg+6, data >> 8);
898      state->m_lsi53c810->lsi53c810_reg_w(reg+6, data >> 8);
897899   }
898900   if (!(mem_mask & U64(0x00000000000000ff))) {
899      lsi53c810_reg_w(space, reg+7, data >> 0);
901      state->m_lsi53c810->lsi53c810_reg_w(reg+7, data >> 0);
900902   }
901903}
902904
903905
904#define BYTE_REVERSE32(x)      (((x >> 24) & 0xff) | \
905                        ((x >> 8) & 0xff00) | \
906                        ((x << 8) & 0xff0000) | \
907                        ((x << 24) & 0xff000000))
908
909static UINT32 scsi53c810_fetch(running_machine &machine, UINT32 dsp)
910{
911   UINT32 result;
912   result = machine.device("ppc1")->memory().space(AS_PROGRAM)->read_dword(dsp & 0x7FFFFFFF);
913   return BYTE_REVERSE32(result);
914}
915
916
917static void scsi53c810_irq_callback(running_machine &machine, int value)
918{
919   bebox_set_irq_bit(machine, 21, value);
920}
921
922
923static void scsi53c810_dma_callback(running_machine &machine, UINT32 src, UINT32 dst, int length, int byteswap)
924{
925}
926
927
928906UINT32 scsi53c810_pci_read(device_t *busdevice, device_t *device, int function, int offset, UINT32 mem_mask)
929907{
930908   bebox_state *state = device->machine().driver_data<bebox_state>();
r17519r17520
990968}
991969
992970
993static const SCSIConfigTable dev_table =
994{
995   2, /* 2 SCSI devices */
996   {
997      { "harddisk1" },
998      { "cdrom" }
999   }
1000};
1001
1002static const struct LSI53C810interface scsi53c810_intf =
1003{
1004   &dev_table,      /* SCSI device table */
1005   &scsi53c810_irq_callback,
1006   &scsi53c810_dma_callback,
1007   &scsi53c810_fetch,
1008};
1009
1010
1011971static TIMER_CALLBACK( bebox_get_devices ) {
1012972   bebox_state *state = machine.driver_data<bebox_state>();
1013973   state->m_devices.pic8259_master = machine.device("pic8259_master");
r17519r17520
10421002MACHINE_START( bebox )
10431003{
10441004   pc_fdc_init(machine, &bebox_fdc_interface);
1045   /* SCSI */
1046   lsi53c810_init(machine, &scsi53c810_intf);
10471005}
10481006
10491007DRIVER_INIT_MEMBER(bebox_state,bebox)
trunk/src/mess/includes/bebox.h
r17519r17520
1111
1212#include "machine/ins8250.h"
1313#include "machine/8237dma.h"
14#include "machine/53c810.h"
1415
1516typedef struct
1617{
r17519r17520
2526{
2627public:
2728   bebox_state(const machine_config &mconfig, device_type type, const char *tag)
28      : driver_device(mconfig, type, tag) { }
29      : driver_device(mconfig, type, tag),
30         m_lsi53c810(*this, "lsi53c810"){ }
2931
32   required_device<lsi53c810_device> m_lsi53c810;
3033   UINT32 m_cpu_imask[2];
3134   UINT32 m_interrupts;
3235   UINT32 m_crossproc_interrupts;
r17519r17520
7679WRITE8_HANDLER( bebox_flash_w );
7780
7881void bebox_ide_interrupt(device_t *device, int state);
82void bebox_set_irq_bit(running_machine &machine, unsigned int interrupt_bit, int val);
7983
8084UINT32 scsi53c810_pci_read(device_t *busdevice, device_t *device, int function, int offset, UINT32 mem_mask);
8185void scsi53c810_pci_write(device_t *busdevice, device_t *device, int function, int offset, UINT32 data, UINT32 mem_mask);
trunk/src/mess/drivers/bebox.c
r17519r17520
2727#include "machine/idectrl.h"
2828#include "machine/mpc105.h"
2929#include "machine/intelfsh.h"
30#include "machine/53c810.h"
3031
3132/* Devices */
3233#include "machine/scsicd.h"
r17519r17520
9394   AM_IMPORT_FROM(bebox_mem)
9495ADDRESS_MAP_END
9596
97static const SCSIConfigTable dev_table =
98{
99   2, /* 2 SCSI devices */
100   {
101      { "harddisk1" },
102      { "cdrom" }
103   }
104};
105
106#define BYTE_REVERSE32(x)      (((x >> 24) & 0xff) | \
107                        ((x >> 8) & 0xff00) | \
108                        ((x << 8) & 0xff0000) | \
109                        ((x << 24) & 0xff000000))
110
111static UINT32 scsi53c810_fetch(running_machine &machine, UINT32 dsp)
112{
113   UINT32 result;
114   result = machine.device("ppc1")->memory().space(AS_PROGRAM)->read_dword(dsp & 0x7FFFFFFF);
115   return BYTE_REVERSE32(result);
116}
117
118
119static void scsi53c810_irq_callback(running_machine &machine, int value)
120{
121   bebox_set_irq_bit(machine, 21, value);
122}
123
124
125static void scsi53c810_dma_callback(running_machine &machine, UINT32 src, UINT32 dst, int length, int byteswap)
126{
127}
128
129
130static const struct LSI53C810interface scsi53c810_intf =
131{
132   &dev_table,      /* SCSI device table */
133   &scsi53c810_irq_callback,
134   &scsi53c810_dma_callback,
135   &scsi53c810_fetch,
136};
137
138
96139static const floppy_interface bebox_floppy_interface =
97140{
98141   DEVCB_NULL,
r17519r17520
154197
155198   MCFG_FUJITSU_29F016A_ADD("flash")
156199
200   MCFG_LSI53C810_ADD( "lsi51c810", scsi53c810_intf)
157201   MCFG_SCSIDEV_ADD("harddisk1", SCSIHD, SCSI_ID_0)
158202   MCFG_SCSIDEV_ADD("cdrom", SCSICD, SCSI_ID_3)
159203

Previous 199869 Revisions Next

© 1997-2024 The MAME Team