Previous 15994 Revisions Next

r7355 Sunday 14th February, 2010 at 20:05:47 UTC by Phill Harvey-Smith
Implemented paged RAM, nimbus driver now supports all ram options supported
by the real machine.
[src/mess/drivers]rmnimbus.c
[src/mess/includes]rmnimbus.h
[src/mess/machine]rmnimbus.c
[src/mess/video]rmnimbus.c

src/mess/video/rmnimbus.c
r7354r7355
7979UINT16  pixel_mask;
8080UINT8   hs_count;
8181
82int debug_on;
82static int debug_on;
8383
84static UINT8 get_pixel(UINT16 x, UINT16 y);
85static UINT16 read_pixel_line(UINT16 x, UINT16 y, UINT8 width);
86static UINT16 read_pixel_data(UINT16 x, UINT16 y);
87static UINT16 read_reg_00A(void);
88
8489static void set_pixel(UINT16 x, UINT16 y, UINT8 colour);
8590static void write_pixel_line(UINT16 x, UINT16 y, UINT16    data, UINT8 width);
8691static void write_pixel_data(UINT16 x, UINT16 y, UINT16    data);
r7354r7355
114119        case    reg004  : result=vidregs[reg004]; break;
115120        case    reg006  : result=vidregs[reg006]; break;
116121        case    reg008  : result=vidregs[reg008]; break;
117        case    reg00A  : result=vidregs[reg00A]; break;
122        case    reg00A  : result=read_reg_00A(); break;
118123        case    reg00C  : result=vidregs[reg00C]; break;
119124        case    reg00E  : result=vidregs[reg00E]; break;
120125
r7354r7355
138143        default         : result=0; break;
139144    }
140145
141    if(debug_on & DEBUG_TEXT)
146    if(DEBUG_SET(DEBUG_TEXT))
142147        logerror("Nimbus video IOR at %05X from %04X mask=%04X, data=%04X\n",pc,(offset*2),mem_mask,result);
143148   
144149    return result;
145150}
146151
152static UINT8 get_pixel(UINT16 x, UINT16 y)
153{
154    UINT8   result = 0;
155
156    if((x<SCREEN_WIDTH_PIXELS) && (y<SCREEN_HEIGHT_LINES))
157    {
158        if(IS_80COL)
159            result=video_mem[x][y];
160        else
161            result=video_mem[x*2][y];
162    }
163   
164    return result;
165}
166
167static UINT16 read_pixel_line(UINT16 x, UINT16 y, UINT8 width)
168{
169    UINT16  result = 0;
170    UINT16  mask;
171    UINT16  pixel_x;
172    UINT16  colour;
173    UINT8   shifts;
174
175    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
176        logerror("read_pixel_line(x=%04X, y=%04X, width=%02X, bpp=%02X, pixel_mask=%02X)\n",x,y,width,bpp,pixel_mask);
177   
178    shifts=width-bpp;   
179   
180    for(mask=pixel_mask, pixel_x=(x*(width/bpp)); mask>0; mask=(mask>>bpp), pixel_x++)
181    {
182        colour=get_pixel(pixel_x,y);
183       
184        if(bpp==1)
185            colour=((colour==FG_COLOUR) ? 1 : 0) << shifts;
186        else
187            colour=colour << shifts;
188   
189        result=(result & ~mask)  | colour;
190
191        shifts-=bpp;
192    }
193
194    return result;
195}
196
197static UINT16 read_pixel_data(UINT16 x, UINT16 y)
198{
199    UINT16  result=0;
200   
201    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
202        logerror("read_pixel_data(x=%04X, y=%04X), reg022=%04X\n",x,y,vidregs[reg022]);
203   
204    if(IS_80COL)
205    {
206        switch (vidregs[reg022] & WIDTH_MASK)
207        {
208            case 0x00   : break;
209                     
210            case 0x01   : break;
211                     
212            case 0x02   : break;
213       
214            case 0x03   : break;
215       
216            case 0x04   : break;
217       
218            case 0x05   : break;
219       
220            case 0x06   : bpp=2; pixel_mask=0xC000;
221                          result=read_pixel_line(x,y,16);
222                          break;
223       
224            case 0x07   : break;   
225        }
226    }
227    else /* 40 Col */
228    {
229        switch (vidregs[reg022] & WIDTH_MASK)
230        {
231            case 0x00   : break;
232                     
233            case 0x01   : break;
234                     
235            case 0x02   : break;
236       
237            case 0x03   : break;
238       
239            case 0x04   : break;
240       
241            case 0x05   : break;
242       
243            case 0x06   : bpp=4; pixel_mask=0xF000;
244                          result=read_pixel_line(x,y,16);
245                          break;
246       
247            case 0x07   : break;   
248        }
249    }
250   
251    return result;
252}
253
254static UINT16 read_reg_00A(void)
255{
256    return read_pixel_data(++vidregs[reg002],vidregs[reg00C]);
257}
258
259
147260/*
148261    Write to the video registers, the default action is to write to the array of registers.
149262    If a register also needs some special action call the action function for that register.
r7354r7355
158271{
159272    int pc=cpu_get_pc(space->cpu);
160273
161    if(debug_on & DEBUG_TEXT)
162        logerror("Nimbus video IOW at %05X write of %04X to %04X mask=%04X\n",pc,data,(offset*2),mem_mask);
274    if(offset<reg028)
275    {
276        if(DEBUG_SET(DEBUG_TEXT))
277            logerror("Nimbus video IOW at %05X write of %04X to %04X mask=%04X\n",pc,data,(offset*2),mem_mask);
163278
164    if(debug_on & DEBUG_DB)
165        logerror("dw %05X,%05X\n",(offset*2),data);
279        if(DEBUG_SET(DEBUG_DB))
280            logerror("dw %05X,%05X\n",(offset*2),data);
281    }
166282   
167   
168283    switch (offset)
169284    {
170285        case    reg000  : vidregs[reg000]=data; break;
r7354r7355
200315
201316static void set_pixel(UINT16 x, UINT16 y, UINT8 colour)
202317{
203    if(debug_on & (DEBUG_TEXT | DEBUG_PIXEL))
318    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
204319        logerror("set_pixel(x=%04X, y=%04X, colour=%04X), IS_XOR=%02X\n",x,y,colour,IS_XOR);
205320   
206321    if(IS_80COL)
r7354r7355
228343    UINT16  colour;
229344    UINT8   shifts;
230345
231    if(debug_on & (DEBUG_TEXT | DEBUG_PIXEL))
346    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
232347        logerror("write_pixel_line(x=%04X, y=%04X, data=%04X, width=%02X, bpp=%02X, pixel_mask=%02X)\n",x,y,data,width,bpp,pixel_mask);
233348   
234349    shifts=width-bpp;   
r7354r7355
256371    UINT16  pixelno;
257372    UINT16  pixelx;
258373   
259    if(debug_on & (DEBUG_TEXT | DEBUG_PIXEL))
374    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
260375       logerror("move_pixel_line(x=%04X, y=%04X, data=%04X, width=%02X)\n",x,y,data,width);
261376       
262377    for(pixelno=0;pixelno<width;pixelno++)
263378    {
264379        pixelx=(x*width)+pixelno;
265        if(debug_on & (DEBUG_TEXT | DEBUG_PIXEL))
380        if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
266381            logerror("pixelx=%04X\n",pixelx);
267382        video_mem[pixelx][vidregs[reg020]]=video_mem[pixelx][y];
268383    }
269384}
270385
271386
387
272388/*
273389    The values in the bottom 3 bits of reg022 seem to determine the number of bits per pixel
274390    for following operations.
r7354r7355
282398    100 4bpp, must be a 16 bit word, of which the upper byte is a mask anded with the lower byte
283399              containing the pixel data for two pixels.
284400    101 Move pixel data at x,reg020 to x,y, used for scrolling.
285    110 4bpp, 16 bit word containing the pixel data for 4 pixels.
401    110 if 40 col
402            4bpp, 16 bit word containing the pixel data for 4 pixels.
403        else
404            2bpp, 16 bit word containing the pixel data for 8 pixels.
286405    111
287406   
288407    Bit 3 of reg022 is as follows :
r7354r7355
293412
294413static void write_pixel_data(UINT16 x, UINT16 y, UINT16    data)
295414{   
296    if(debug_on & (DEBUG_TEXT | DEBUG_PIXEL))
415    if(DEBUG_SET(DEBUG_TEXT | DEBUG_PIXEL))
297416        logerror("write_pixel_data(x=%04X, y=%04X, data=%04X), reg022=%04X\n",x,y,data,vidregs[reg022]);
298417   
299418    if(IS_80COL)
r7354r7355
418537
419538static void write_reg_026(void)
420539{
421    if(debug_on & DEBUG_TEXT)
540    if(DEBUG_SET(DEBUG_TEXT))
422541        logerror("reg 026 write, border_colour=%02X\n",vidregs[reg026] & 0x0F);
423542}
424543
r7354r7355
450569        paletteidx=(colours & mask) >> shifts;
451570        palette_set_color_rgb(machine, colourno, nimbus_palette[paletteidx][RED], nimbus_palette[paletteidx][GREEN], nimbus_palette[paletteidx][BLUE]);
452571       
453        if(debug_on & DEBUG_TEXT)
572        if(DEBUG_SET(DEBUG_TEXT))
454573            logerror("set colourno[%02X](r,g,b)=(%02X,%02X,%02X), paletteidx=%02X\n",colourno, nimbus_palette[paletteidx][RED], nimbus_palette[paletteidx][GREEN], nimbus_palette[paletteidx][BLUE],paletteidx);
455574        mask=mask<<4;
456575        shifts+=4;
src/mess/includes/rmnimbus.h
r7354r7355
1313#define DEBUG_DB    0x02
1414#define DEBUG_PIXEL 0x04
1515
16#define DEBUG_SET(flags)    ((debug_on & (flags))==(flags))
17
1618#define MAINCPU_TAG "maincpu"
1719#define IOCPU_TAG   "iocpu"
1820
r7354r7355
6769#define EXTERNAL_INT_Z80SIO     0x9C
6870#define EXTERNAL_INT_MSM5205    0x84
6971
72/* Memory controler */
73#define RAM_BANK00_TAG  "bank0"
74#define RAM_BANK01_TAG  "bank1"
75#define RAM_BANK02_TAG  "bank2"
76#define RAM_BANK03_TAG  "bank3"
77#define RAM_BANK04_TAG  "bank4"
78#define RAM_BANK05_TAG  "bank5"
79#define RAM_BANK06_TAG  "bank6"
80#define RAM_BANK07_TAG  "bank7"
81
82#define HIBLOCK_BASE_MASK   0x08
83#define HIBLOCK_SELECT_MASK 0x10
84
85READ8_HANDLER( mcu_r );
86WRITE8_HANDLER( mcu_w );
87
88
7089/* Z80 SIO for keyboard */
7190
7291#define Z80SIO_TAG          "z80sio"
src/mess/machine/rmnimbus.c
r7354r7355
1/*
1/*
22    machine/rmnimbus.c
3
3   
44    Machine driver for the Research Machines Nimbus.
5
5   
66    Phill Harvey-Smith
77    2009-11-29.
8
8   
99    80186 internal DMA/Timer/PIC code borrowed from Compis driver.
1010    Perhaps this needs merging into the 80186 core.....
1111*/
r7354r7355
1818#include "debug/debugcpu.h"
1919#include "debug/debugcon.h"
2020#include "devices/flopdrv.h"
21#include "devices/messram.h"
2122#include "machine/er59256.h"
2223#include "machine/pic8259.h"
2324#include "machine/pit8253.h"
r7354r7355
5152#define LOG_PC8031          0
5253#define LOG_PC8031_186      0
5354#define LOG_PC8031_PORT     0
54#define LOG_IOU             1
55#define LOG_IOU             
5556#define LOG_SOUND           0
57#define LOG_RAM             0
5658
5759/* Debugging */
5860
r7354r7355
146148
147149const wd17xx_interface nimbus_wd17xx_interface =
148150{
149   DEVCB_LINE_GND,
151    DEVCB_LINE_GND,
150152   DEVCB_LINE(nimbus_fdc_intrq_w),
151153   DEVCB_LINE(nimbus_fdc_drq_w),
152154   {FLOPPY_0, FLOPPY_1, FLOPPY_2, FLOPPY_3}
r7354r7355
190192    0x0280, 0x017F, 0xE822, 0x8129,
191193    0x0329, 0x0000, 0x0000, 0x0000,
192194    0x0000, 0x0000, 0x0000, 0x0000,
193    0x0000, 0x8796, 0x2025, 0xB9E6
195    0x0000, 0x8796, 0x2025, 0xB9E6
194196};
195197
198/* Memory controler */
199UINT8 mcu_reg080;
200
196201/* IO Unit */
197202UINT8 iou_reg092;
198203
r7354r7355
213218static void decode_dssi_f_plonk_char(running_device *device,UINT16  ds, UINT16 si);
214219static void decode_dssi_f_rw_sectors(running_device *device,UINT16  ds, UINT16 si);
215220
221static void nimbus_bank_memory(running_machine *machine);
222static void memory_reset(running_machine *machine);
216223static void fdc_reset(void);
217224static void generate_disk_int(running_machine *machine);
218225static void hdc_reset(running_machine *machine);
r7354r7355
266273    old=i186.intr.in_service;
267274
268275   i186.intr.in_service |= i186.intr.ack_mask;
269
276   
270277    if((LOG_INTERRUPTS) && (i186.intr.in_service!=old))
271278        logerror("i186.intr.in_service changed from %02X to %02X\n",old,i186.intr.in_service);
272
279   
273280    if (i186.intr.ack_mask == 0x0001)
274281   {
275282      switch (i186.intr.poll_status & 0x1f)
r7354r7355
299306        logerror("Ext vectors : %02X %02X\n",i186.intr.ext_vector[0],i186.intr.ext_vector[1]);
300307        logerror("Int %02X Calling vector %02X\n",i186.intr.poll_status,vector);
301308    }
302
309   
303310    return vector;
304311}
305312
306313
307314static void update_interrupt_state(running_machine *machine)
308{
315{   
309316    int new_vector = 0;
310317    int Priority;
311318    int IntNo;
312319
313   if (LOG_INTERRUPTS)
320   if (LOG_INTERRUPTS)
314321        logerror("update_interrupt_status: req=%04X stat=%04X serv=%04X priority_mask=%4X\n", i186.intr.request, i186.intr.status, i186.intr.in_service, i186.intr.priority_mask);
315322
316323   /* loop over priorities */
r7354r7355
366373         {
367374                if (LOG_INTERRUPTS)
368375                    logerror("Int%d priority=%d\n",IntNo,Priority);
369
376               
370377                /* if we're already servicing something at this level, don't generate anything new */
371378            if (i186.intr.in_service & (0x10 << IntNo))
372379               return;
r7354r7355
461468static void external_int(running_machine *machine, UINT16 intno, UINT8 vector)
462469{
463470   if (LOG_INTERRUPTS_EXT) logerror("generating external int %02X, vector %02X\n",intno,vector);
464
471
465472   // Only 4 external ints
466473    if(intno>3)
467474    {
468475        logerror("external_int() invalid external interupt no : 0x%02X (can only be 0..3)\n",intno);
469476        return;
470477    }
471
478   
472479    // Only set external vector if cascade mode enabled, only valid for
473480    // int 0 & int 1
474481    if (intno<2)
r7354r7355
476483        if(i186.intr.ext[intno] & EXTINT_CTRL_CASCADE)
477484            i186.intr.ext_vector[intno]=vector;
478485    }
479
486   
480487    // Turn on the requested request bit and handle interrupt
481488    i186.intr.request |= (0x010 << intno);
482489    update_interrupt_state(machine);
r7354r7355
553560   struct timer_state *t = &i186.timer[which];
554561   int update_int_timer = 0;
555562
556    if (LOG_TIMER)
563    if (LOG_TIMER)
557564        logerror("internal_timer_update: %d, new_count=%d, new_maxA=%d, new_maxB=%d,new_control=%d\n",which,new_count,new_maxA,new_maxB,new_control);
558565
559566   /* if we have a new count and we're on, update things */
r7354r7355
598605               new_maxB = 0x10000;
599606      }
600607      }
608   
601609
602
603610   /* handle control changes */
604611   if (new_control != -1)
605612   {
r7354r7355
755762    struct dma_state *dma = &i186.dma[which];
756763   const address_space *memory_space   = cpu_get_address_space(devtag_get_device(machine, MAINCPU_TAG), ADDRESS_SPACE_PROGRAM);
757764    const address_space *io_space       = cpu_get_address_space(devtag_get_device(machine, MAINCPU_TAG), ADDRESS_SPACE_IO);
758
765   
759766    const address_space *src_space;
760767    const address_space *dest_space;
761
768   
762769    UINT16  dma_word;
763770    UINT8   dma_byte;
764771    UINT8   incdec_size;
r7354r7355
770777    {
771778        logerror("%05X:ERROR! - drq%d with dma channel stopped\n",
772779         cpu_get_pc(devtag_get_device(machine, MAINCPU_TAG)), which);
773
780           
774781        return;
775782    }
776
783
777784    if(dma->control & DEST_MIO)
778785        dest_space=memory_space;
779786    else
780787        dest_space=io_space;
781
788   
782789    if(dma->control & SRC_MIO)
783790        src_space=memory_space;
784791    else
785792        src_space=io_space;
786
793   
787794    // Do the transfer
788795    if(dma->control & BYTE_WORD)
789796    {
r7354r7355
797804        memory_write_byte(dest_space,dma->dest,dma_byte);
798805        incdec_size=1;
799806    }
800
807   
801808    // Increment or Decrement destination ans source pointers as needed
802809    switch (dma->control & DEST_INCDEC_MASK)
803810    {
804811        case DEST_DECREMENT     : dma->dest -= incdec_size;
805812        case DEST_INCREMENT     : dma->dest += incdec_size;
806813    }
807
814   
808815    switch (dma->control & SRC_INCDEC_MASK)
809816    {
810817        case SRC_DECREMENT     : dma->source -= incdec_size;
811818        case SRC_INCREMENT     : dma->source += incdec_size;
812819    }
813
820   
814821    // decrement count
815822    dma->count -= 1;
816
823   
817824    // Terminate if count is zero, and terminate flag set
818825    if((dma->control & TERMINATE_ON_ZERO) && (dma->count==0))
819826    {
820827        dma->control &= ~ST_STOP;
821828        if (LOG_DMA) logerror("DMA terminated\n");
822829    }
823
830   
824831    // Interrupt if count is zero, and interrupt flag set
825832    if((dma->control & INTERRUPT_ON_ZERO) && (dma->count==0))
826833    {
827834      if (LOG_DMA>1) logerror("DMA%d - requesting interrupt: count = %04X, source = %04X\n", which, dma->count, dma->source);
828835      i186.intr.request |= 0x04 << which;
829      update_interrupt_state(machine);
836      update_interrupt_state(machine);     
830837    }
831838}
832839
r7354r7355
838845{
839846
840847    logerror("Machine reset\n");
841
848   
842849   /* create timers here so they stick around */
843850   i186.timer[0].int_timer = timer_alloc(machine, internal_timer_int, NULL);
844851   i186.timer[1].int_timer = timer_alloc(machine, internal_timer_int, NULL);
r7354r7355
862869   i186.intr.ext[2]         = 0x000f;
863870   i186.intr.ext[3]         = 0x000f;
864871    i186.intr.in_service        = 0x0000;
865
872   
866873    /* External vectors by default to internal int 0/1 vectors */
867874    i186.intr.ext_vector[0]      = 0x000C;
868875   i186.intr.ext_vector[1]      = 0x000D;
869
876   
870877    i186.intr.pending           = 0x0000;
871878   i186.intr.ack_mask          = 0x0000;
872879   i186.intr.request           = 0x0000;
873880   i186.intr.status            = 0x0000;
874881   i186.intr.poll_status       = 0x0000;
875
882   
876883    logerror("CPU reset done\n");
877884}
878885
r7354r7355
12751282MACHINE_RESET(nimbus)
12761283{
12771284   /* CPU */
1278   nimbus_cpu_reset(machine);
1285   nimbus_cpu_reset(machine);
12791286    iou_reset();
12801287    fdc_reset();
12811288    hdc_reset(machine);
12821289    keyboard_reset();
12831290    pc8031_reset(machine);
12841291    sound_reset(machine);
1292    memory_reset(machine);
12851293}
12861294
12871295DRIVER_INIT(nimbus)
r7354r7355
12941302    nimbus_cpu_init(machine);
12951303
12961304    keyboard.keyscan_timer=timer_alloc(machine, keyscan_callback, NULL);
1297
1305   
12981306   /* setup debug commands */
12991307   if (machine->debug_flags & DEBUG_FLAG_ENABLED)
13001308   {
r7354r7355
13041312
13051313        /* set up the instruction hook */
13061314        debug_cpu_set_instruction_hook(devtag_get_device(machine, MAINCPU_TAG), instruction_hook);
1307
1315     
13081316    }
1309
1317   
13101318    debug_flags=0;
13111319}
13121320
r7354r7355
13141322{
13151323    int IntNo;
13161324    int Vector;
1317
1325   
13181326    if(params>1)
1319    {
1327    {   
13201328        sscanf(param[0],"%X",&IntNo);
13211329        sscanf(param[1],"%X",&Vector);
13221330
13231331        debug_console_printf(machine,"triggering IRQ%d, Vector=%02X\n",IntNo,Vector);
1324        external_int(machine,IntNo,Vector);
1332        external_int(machine,IntNo,Vector);       
13251333    }
13261334    else
13271335    {
13281336        debug_console_printf(machine,"Error, you must supply an intno and vector to trigger\n");
13291337    }
1330
1331
1338   
1339   
13321340}
13331341
13341342
13351343static void execute_debug_intmasks(running_machine *machine, int ref, int params, const char *param[])
13361344{
13371345    int IntNo;
1338
1339
1346   
1347   
13401348    debug_console_printf(machine,"i186.intr.priority_mask=%4X\n",i186.intr.priority_mask);
13411349    for(IntNo=0; IntNo<4; IntNo++)
13421350    {
13431351        debug_console_printf(machine,"extInt%d mask=%4X\n",IntNo,i186.intr.ext[IntNo]);
13441352    }
1345
1353   
13461354    debug_console_printf(machine,"i186.intr.request   = %04X\n",i186.intr.request);
13471355    debug_console_printf(machine,"i186.intr.ack_mask  = %04X\n",i186.intr.ack_mask);
13481356    debug_console_printf(machine,"i186.intr.in_service= %04X\n",i186.intr.in_service);
r7354r7355
13511359static void nimbus_debug(running_machine *machine, int ref, int params, const char *param[])
13521360{
13531361    if(params>0)
1354    {
1355        sscanf(param[0],"%d",&debug_flags);
1362    {   
1363        sscanf(param[0],"%d",&debug_flags);       
13561364    }
13571365    else
13581366    {
r7354r7355
13691377{
13701378    const address_space *space = cpu_get_address_space(device, ADDRESS_SPACE_PROGRAM);
13711379    UINT8               *addr_ptr;
1372
1380   
13731381    addr_ptr = (UINT8*)memory_get_read_ptr(space,curpc);
1374
1382       
13751383    if ((addr_ptr !=NULL) && (addr_ptr[0]==0xCD) && (addr_ptr[1]==0xF0))
13761384        decode_subbios(device,curpc);
1377
1385   
13781386    return 0;
13791387}
13801388
r7354r7355
13871395    char    type_str[80];
13881396    char    drv_str[80];
13891397    char    func_str[80];
1390
1398   
13911399    void (*dump_dssi)(running_device *,UINT16, UINT16) = NULL;
13921400
13931401    running_device *cpu = devtag_get_device(device->machine,MAINCPU_TAG);
1394
1402   
13951403    UINT16  ax = cpu_get_reg(cpu,I8086_AX);
13961404    UINT16  bx = cpu_get_reg(cpu,I8086_BX);
13971405    UINT16  cx = cpu_get_reg(cpu,I8086_CX);
13981406    UINT16  ds = cpu_get_reg(cpu,I8086_DS);
13991407    UINT16  si = cpu_get_reg(cpu,I8086_SI);
1400
1408   
14011409    logerror("=======================================================================\n");
14021410    logerror("Sub-bios call at %08X, AX=%04X, BX=%04X, CX=%04X, DS:SI=%04X:%04X\n",pc,ax,bx,cx,ds,si);
14031411
14041412    set_type("invalid");
14051413    set_drv("invalid");
14061414    set_func("invalid");
1415   
14071416
1408
14091417    switch (cx)
14101418    {
1411        case 0   :
1419        case 0   :
14121420        {
14131421            set_type("t_mummu");
14141422            set_drv("d_mummu");
1415
1423           
14161424            switch (ax)
14171425            {
14181426                case 0  : set_func("f_get_version_number"); break;
r7354r7355
14251433                case 7  : set_func("f_get_copyright"); break;
14261434            }
14271435        }; break;
1428
1429        case 1   :
1436       
1437        case 1   :
14301438        {
14311439            set_type("t_character");
14321440            set_drv("d_printer");
1433
1441           
14341442            switch(ax)
14351443            {
14361444                case 0  : set_func("f_get_version_number"); break;
r7354r7355
14441452                case 8  : set_func("f_set_IO_parameters"); break;
14451453            }
14461454        }; break;
1447
1448        case 2   :
1455       
1456        case 2   :
14491457        {
14501458            set_type("t_disk");
1451
1459           
14521460            switch(bx)
14531461            {
14541462                case 0  : set_drv("d_floppy"); break;
r7354r7355
14571465                case 3  : set_drv("d_rompack"); break;
14581466                case 4  : set_drv("d_eeprom"); break;
14591467            }
1460
1468           
14611469            switch(ax)
14621470            {
1463                case 0  : set_func("f_get_version_number"); break;
1471                case 0  : set_func("f_get_version_number"); break;           
14641472                case 1  : set_func("f_initialise_unit"); break;
14651473                case 2  : set_func("f_pseudo_init_unit"); break;
14661474                case 3  : set_func("f_get_device_status"); break;
r7354r7355
14711479                case 8  : set_func("f_recalibrate"); break;
14721480                case 9  : set_func("f_motors_off"); break;
14731481            }
1474
1482           
14751483        }; break;
1476
1477        case 3   :
1484       
1485        case 3   :
14781486        {
14791487            set_type("t_piconet");
14801488            set_drv("d_piconet");
1481
1489           
14821490            switch(ax)
14831491            {
1484                case 0  : set_func("f_get_version_number"); break;
1492                case 0  : set_func("f_get_version_number"); break;
14851493                case 1  : set_func("f_get_slave_status"); break;
14861494                case 2  : set_func("f_get_slave_map"); break;
14871495                case 3  : set_func("f_change_slave_addr"); break;
r7354r7355
14921500                case 8  : set_func("f_send_data_block"); break;
14931501                case 9  : set_func("f_request_data_block"); break;
14941502                case 10 : set_func("f_reset_slave"); break;
1495
1503           
14961504            }
14971505        }; break;
1498
1499        case 4   :
1506       
1507        case 4   :
15001508        {
15011509            set_type("t_tick");
15021510            set_drv("d_tick");
1503
1511           
15041512            switch(ax)
15051513            {
1506                case 0  : set_func("f_get_version_number"); break;
1507                case 1  : set_func("f_ticks_per_second"); break;
1508                case 2  : set_func("f_link_tick_routine"); break;
1509                case 3  : set_func("f_unlink_tick_routine"); break;
1514                case 0  : set_func("f_get_version_number"); break;
1515                case 1  : set_func("f_ticks_per_second"); break;
1516                case 2  : set_func("f_link_tick_routine"); break;
1517                case 3  : set_func("f_unlink_tick_routine"); break;           
15101518            }
15111519        }; break;
1512
1513        case 5   :
1520       
1521        case 5   :
15141522        {
15151523            set_type("t_graphics_input");
15161524
15171525            switch(bx)
15181526            {
1519                case 0  : set_drv("d_mouse"); break;
1520                case 1  : set_drv("d_joystick_1"); break;
1521                case 2  : set_drv("d_joystick_2"); break;
1527                case 0  : set_drv("d_mouse"); break;
1528                case 1  : set_drv("d_joystick_1"); break;
1529                case 2  : set_drv("d_joystick_2"); break;
15221530            }
1523
1524
1531           
1532           
15251533            switch(ax)
15261534            {
1527                case 0  : set_func("f_get_version_number"); break;
1528                case 1  : set_func("f_graphics_input_cold_start"); break;
1529                case 2  : set_func("f_graphics_input_device_off"); break;
1530                case 3  : set_func("f_return_button_status"); break;
1531                case 4  : set_func("f_return_switch_and_button_stat"); break;
1535                case 0  : set_func("f_get_version_number"); break;           
1536                case 1  : set_func("f_graphics_input_cold_start"); break;   
1537                case 2  : set_func("f_graphics_input_device_off"); break;   
1538                case 3  : set_func("f_return_button_status"); break;     
1539                case 4  : set_func("f_return_switch_and_button_stat"); break;   
15321540                case 5  : set_func("f_start_tracking"); break;
15331541                case 6  : set_func("f_stop_tracking"); break;
15341542                case 7  : set_func("f_enquire_position"); break;
r7354r7355
15401548                case 13 : set_func("f_enquire_graphics_in_misc_data"); break;
15411549            }
15421550        }; break;
1543
1544        case 6   :
1551       
1552        case 6   :
15451553        {
15461554            set_type("t_graphics_output");
15471555            set_drv("d_ngc_screen");
15481556
15491557            switch(ax)
15501558            {
1551                case 0  : set_func("f_get_version_number");                 break;
1552                case 1  : set_func("f_graphics_output_cold_start");         break;
1553                case 2  : set_func("f_graphics_output_warm_start");         break;
1554                case 3  : set_func("f_graphics_output_off");                break;
1555                case 4  : set_func("f_reinit_graphics_output");             break;
1556                case 5  : set_func("f_polymarker");                         break;
1557                case 6  : set_func("f_polyline"); dump_dssi=&decode_dssi_f_fill_area;   break;
1558                case 7  : set_func("f_fill_area"); dump_dssi=&decode_dssi_f_fill_area; break;
1559                case 8  : set_func("f_flood_fill_area"); break;
1560                case 9  : set_func("f_plot_character_string"); dump_dssi=&decode_dssi_f_plot_character_string; break;
1561                case 10 : set_func("f_define_graphics_clipping_area"); break;
1562                case 11 : set_func("f_enquire_clipping_area_limits"); break;
1563                case 12 : set_func("f_select_graphics_clipping_area"); break;
1564                case 13 : set_func("f_enq_selctd_graphics_clip_area"); break;
1565                case 14 : set_func("f_set_clt_element"); break;
1566                case 15 : set_func("f_enquire_clt_element"); break;
1567                case 16 : set_func("f_set_new_clt"); dump_dssi=&decode_dssi_f_set_new_clt; break;
1568                case 17 : set_func("f_enquire_clt_contents"); break;
1569                case 18 : set_func("f_define_dithering_pattern"); break;
1570                case 19 : set_func("f_enquire_dithering_pattern"); break;
1571                case 20 : set_func("f_draw_sprite"); break;
1572                case 21 : set_func("f_move_sprite"); break;
1573                case 22 : set_func("f_erase_sprite"); break;
1574                case 23 : set_func("f_read_pixel"); break;
1575                case 24 : set_func("f_read_to_limit"); break;
1576                case 25 : set_func("f_read_area_pixel"); break;
1577                case 26 : set_func("f_write_area_pixel"); break;
1578                case 27 : set_func("f_copy_area_pixel"); break;
1559                case 0  : set_func("f_get_version_number");                 break;
1560                case 1  : set_func("f_graphics_output_cold_start");         break;
1561                case 2  : set_func("f_graphics_output_warm_start");         break;
1562                case 3  : set_func("f_graphics_output_off");                break;
1563                case 4  : set_func("f_reinit_graphics_output");             break;
1564                case 5  : set_func("f_polymarker");                         break;
1565                case 6  : set_func("f_polyline"); dump_dssi=&decode_dssi_f_fill_area;   break;
1566                case 7  : set_func("f_fill_area"); dump_dssi=&decode_dssi_f_fill_area; break;
1567                case 8  : set_func("f_flood_fill_area"); break;
1568                case 9  : set_func("f_plot_character_string"); dump_dssi=&decode_dssi_f_plot_character_string; break;
1569                case 10 : set_func("f_define_graphics_clipping_area"); break;
1570                case 11 : set_func("f_enquire_clipping_area_limits"); break;
1571                case 12 : set_func("f_select_graphics_clipping_area"); break;
1572                case 13 : set_func("f_enq_selctd_graphics_clip_area"); break;
1573                case 14 : set_func("f_set_clt_element"); break;
1574                case 15 : set_func("f_enquire_clt_element"); break;
1575                case 16 : set_func("f_set_new_clt"); dump_dssi=&decode_dssi_f_set_new_clt; break;
1576                case 17 : set_func("f_enquire_clt_contents"); break;
1577                case 18 : set_func("f_define_dithering_pattern"); break;
1578                case 19 : set_func("f_enquire_dithering_pattern"); break;
1579                case 20 : set_func("f_draw_sprite"); break;
1580                case 21 : set_func("f_move_sprite"); break;
1581                case 22 : set_func("f_erase_sprite"); break;
1582                case 23 : set_func("f_read_pixel"); break;
1583                case 24 : set_func("f_read_to_limit"); break;
1584                case 25 : set_func("f_read_area_pixel"); break;
1585                case 26 : set_func("f_write_area_pixel"); break;
1586                case 27 : set_func("f_copy_area_pixel"); break;
15791587
1580                case 29 : set_func("f_read_area_word"); break;
1581                case 30 : set_func("f_write_area_word"); break;
1582                case 31 : set_func("f_copy_area_word"); break;
1583                case 32 : set_func("f_swap_area_word"); break;
1584                case 33 : set_func("f_set_border_colour"); break;
1585                case 34 : set_func("f_enquire_border_colour"); break;
1586                case 35 : set_func("f_enquire_miscellaneous_data"); break;
1587                case 36  : set_func("f_circle"); break;
1588                case 29 : set_func("f_read_area_word"); break;
1589                case 30 : set_func("f_write_area_word"); break;
1590                case 31 : set_func("f_copy_area_word"); break;
1591                case 32 : set_func("f_swap_area_word"); break;
1592                case 33 : set_func("f_set_border_colour"); break;
1593                case 34 : set_func("f_enquire_border_colour"); break;
1594                case 35 : set_func("f_enquire_miscellaneous_data"); break;
1595                case 36  : set_func("f_circle"); break;
15881596
1589                case 38 : set_func("f_arc_of_ellipse"); break;
1590                case 39 : set_func("f_isin"); break;
1591                case 40 : set_func("f_icos"); break;
1592                case 41 : set_func("f_define_hatching_pattern"); break;
1593                case 42 : set_func("f_enquire_hatching_pattern"); break;
1594                case 43 : set_func("f_enquire_display_line"); break;
1595                case 44 : set_func("f_plonk_logo"); break;
1597                case 38 : set_func("f_arc_of_ellipse"); break;
1598                case 39 : set_func("f_isin"); break;
1599                case 40 : set_func("f_icos"); break;
1600                case 41 : set_func("f_define_hatching_pattern"); break;
1601                case 42 : set_func("f_enquire_hatching_pattern"); break;
1602                case 43 : set_func("f_enquire_display_line"); break;
1603                case 44 : set_func("f_plonk_logo"); break;
15961604            }
15971605        }; break;
1598
1599        case 7   :
1606       
1607        case 7   :
16001608        {
16011609            set_type("t_zend");
16021610            switch(ax)
16031611            {
1604                case 0  : set_func("f_get_version_number"); break;
1612                case 0  : set_func("f_get_version_number"); break;           
16051613            }
16061614        }; break;
1607
1608        case 8   :
1615       
1616        case 8   :
16091617        {
16101618            set_type("t_zep");
16111619            switch(ax)
16121620            {
1613                case 0  : set_func("f_get_version_number"); break;
1621                case 0  : set_func("f_get_version_number"); break;           
16141622            }
16151623        }; break;
1616
1617        case 9   :
1624       
1625        case 9   :
16181626        {
16191627            set_type("t_raw_console");
1620
1628           
16211629            switch(bx)
16221630            {
1623                case 0  :
1631                case 0  :
16241632                {
16251633                    set_drv("d_screen");
1626
1634           
16271635                    switch(ax)
16281636                    {
1629                        case 0  : set_func("f_get_version_number"); break;
1637                        case 0  : set_func("f_get_version_number"); break;           
16301638                        case 1  : set_func("f_plonk_char"); dump_dssi=decode_dssi_f_plonk_char; break;
16311639                        case 2  : set_func("f_plonk_cursor"); break;
16321640                        case 3  : set_func("f_kill_cursor"); break;
r7354r7355
16391647                        case 10 : set_func("f_set_cursor_flash_rate"); break;
16401648                    }
16411649                }; break;
1642
1650           
16431651                case 1  :
16441652                {
16451653                    set_drv("d_keyboard");
1646
1654                   
16471655                    switch(ax)
16481656                    {
1649                        case 0  : set_func("f_get_version_number"); break;
1657                        case 0  : set_func("f_get_version_number"); break;           
16501658                        case 1  : set_func("f_init_keyboard"); break;
16511659                        case 2  : set_func("f_get_last_key_code"); break;
16521660                        case 3  : set_func("f_get_bitmap"); break;
r7354r7355
16541662                }; break;
16551663            }
16561664        }; break;
1657
1658        case 10   :
1665       
1666        case 10   :
16591667        {
16601668
16611669            set_type("t_acoustics");
1662
1670                       
16631671            switch(bx)
16641672            {
1665                case 0  :
1673                case 0  :
16661674                {
16671675                    set_drv("d_sound");
1668
1676           
16691677                    switch(ax)
16701678                    {
1671                        case 0  : set_func("f_get_version_number"); break;
1679                        case 0  : set_func("f_get_version_number"); break;           
16721680                        case 1  : set_func("f_sound_enable"); break;
16731681                        case 2  : set_func("f_play_note"); break;
16741682                        case 3  : set_func("f_get_queue_status"); break;
16751683                    }
16761684                }; break;
1677
1685           
16781686                case 1  :
16791687                {
16801688                    set_drv("d_voice");
16811689
16821690                    switch(ax)
16831691                    {
1684                        case 0  : set_func("f_get_version_number"); break;
1692                        case 0  : set_func("f_get_version_number"); break;           
16851693                        case 1  : set_func("f_talk"); break;
16861694                        case 2  : set_func("f_wait_and_talk"); break;
16871695                        case 3  : set_func("f_test_talking"); break;
16881696                    }
16891697                }
1690            }
1698            }   
16911699        }; break;
1692
1693        case 11   :
1700       
1701        case 11   :
16941702        {
16951703            set_type("t_hard_sums");
16961704            switch(ax)
16971705            {
1698                case 0  : set_func("f_get_version_number"); break;
1706                case 0  : set_func("f_get_version_number"); break;           
16991707            }
1700        }; break;
1708        }; break;   
17011709    }
1702
1710   
17031711    logerror("Type=%s, Driver=%s, Function=%s\n",type_str,drv_str,func_str);
1704
1712   
17051713    if(dump_dssi!=NULL)
17061714        dump_dssi(device,ds,si);
17071715    logerror("=======================================================================\n");
r7354r7355
17201728static void decode_dssi_f_fill_area(running_device *device,UINT16  ds, UINT16 si)
17211729{
17221730    const address_space *space = cputag_get_address_space(device->machine,MAINCPU_TAG, ADDRESS_SPACE_PROGRAM);
1723
1731
17241732    UINT16          *addr_ptr;
17251733    t_area_params   *area_params;
17261734    t_nimbus_brush  *brush;
17271735    int             cocount;
17281736
17291737    area_params = (t_area_params   *)get_dssi_ptr(space,ds,si);
1730
1738   
17311739    OUTPUT_SEGOFS("SegBrush:OfsBrush",area_params->seg_brush,area_params->ofs_brush);
17321740    brush=(t_nimbus_brush  *)memory_get_read_ptr(space, LINEAR_ADDR(area_params->seg_brush,area_params->ofs_brush));
1733
1741   
17341742    logerror("Brush params\n");
17351743    logerror("Style=%04X,          StyleIndex=%04X\n",brush->style,brush->style_index);
17361744    logerror("Colour1=%04X,        Colour2=%04X\n",brush->colour1,brush->colour2);
17371745    logerror("transparency=%04X,   boundry_spec=%04X\n",brush->transparency,brush->boundary_spec);
17381746    logerror("boundry colour=%04X, save colour=%04X\n",brush->boundary_colour,brush->save_colour);
1739
1740
1747           
1748   
17411749    OUTPUT_SEGOFS("SegData:OfsData",area_params->seg_data,area_params->ofs_data);
1742
1750   
17431751    addr_ptr = (UINT16 *)memory_get_read_ptr(space, LINEAR_ADDR(area_params->seg_data,area_params->ofs_data));
17441752    for(cocount=0; cocount < area_params->count; cocount++)
17451753    {
r7354r7355
17501758static void decode_dssi_f_plot_character_string(running_device *device,UINT16  ds, UINT16 si)
17511759{
17521760    const address_space *space = cputag_get_address_space(device->machine,MAINCPU_TAG, ADDRESS_SPACE_PROGRAM);
1753
1761
17541762    UINT8          *char_ptr;
17551763    t_plot_string_params   *plot_string_params;
17561764    int             charno;
1757
1765       
17581766    plot_string_params=(t_plot_string_params   *)get_dssi_ptr(space,ds,si);
1759
1767   
17601768    OUTPUT_SEGOFS("SegFont:OfsFont",plot_string_params->seg_font,plot_string_params->ofs_font);
17611769    OUTPUT_SEGOFS("SegData:OfsData",plot_string_params->seg_data,plot_string_params->ofs_data);
1762
1770   
17631771    logerror("x=%d, y=%d, length=%d\n",plot_string_params->x,plot_string_params->y,plot_string_params->length);
1764
1772   
17651773    char_ptr=(UINT8*)memory_get_read_ptr(space, LINEAR_ADDR(plot_string_params->seg_data,plot_string_params->ofs_data));
17661774
17671775    if (plot_string_params->length==0xFFFF)
r7354r7355
17691777    else
17701778        for(charno=0;charno<plot_string_params->length;charno++)
17711779            logerror("%c",char_ptr[charno]);
1772
1780       
17731781    logerror("\n");
17741782}
17751783
r7354r7355
17791787    UINT16  *new_colours;
17801788    int     colour;
17811789    new_colours=(UINT16  *)get_dssi_ptr(space,ds,si);
1782
1790   
17831791    OUTPUT_SEGOFS("SegColours:OfsColours",ds,si);
1784
1792   
17851793    for(colour=0;colour<16;colour++)
17861794        logerror("colour #%02X=%04X\n",colour,new_colours[colour]);
1787
1795   
17881796}
17891797
17901798static void decode_dssi_f_plonk_char(running_device *device,UINT16  ds, UINT16 si)
r7354r7355
17921800    const address_space *space = cputag_get_address_space(device->machine,MAINCPU_TAG, ADDRESS_SPACE_PROGRAM);
17931801    UINT16  *params;
17941802    params=(UINT16  *)get_dssi_ptr(space,ds,si);
1795
1803   
17961804    OUTPUT_SEGOFS("SegParams:OfsParams",ds,si);
17971805
17981806    logerror("plonked_char=%c\n",params[0]);
r7354r7355
18031811    const address_space *space = cputag_get_address_space(device->machine,MAINCPU_TAG, ADDRESS_SPACE_PROGRAM);
18041812    UINT16  *params;
18051813    int     param_no;
1806
1814   
18071815    params=(UINT16  *)get_dssi_ptr(space,ds,si);
1808
1816   
18091817    for(param_no=0;param_no<16;param_no++)
18101818        logerror("%04X ",params[param_no]);
1811
1819       
18121820    logerror("\n");
18131821}
18141822
1823/*
1824    The Nimbus has 3 banks of memory each of which can be either 16x4164 or 16x41256 giving
1825    128K or 512K per bank. These banks are as follows :
1826   
1827    bank0   on nimbus motherboard.
1828    bank1   first half of expansion card.
1829    bank2   second half of expansion card.
1830
1831    The valid combinations are :
1832   
1833    bank0       bank1       bank2       total
1834    128K                                128K
1835    128K        128K                    256K
1836    128K        128K        128K        384K
1837    128K        512K                    640K (1)
1838    512K        128K                    640K (2)
1839    512K        512K                    1024K
1840    512K        512K        512K        1536K
1841       
1842    It will be noted that there are two possible ways of getting 640K, we emulate method 2
1843    (above).
1844   
1845    To allow for the greatest flexibility, the Nimbus allows 4 methods of mapping the
1846    banks of ram into the 1M addressable by the 81086.
1847   
1848    With only 128K banks present, they are mapped into the first 3 blocks of 128K in
1849    the memory map giving a total of up to 384K.
1850   
1851    If any of the blocks are 512K, then the block size is set to 512K and the map arranged
1852    so that the bottom block is a 512K block (if both 512K and 128K blocks are available).
1853   
1854    This is all determined by the value written to port 80 :-
1855   
1856    port80 = 0x07   start       end
1857        block0      0x00000     0x1FFFF
1858        block1      0x20000     0x3FFFF
1859        block2      0x40000     0x5FFFF
1860       
1861    port80 = 0x1F
1862        block0      0x00000     0x7FFFF
1863        block1      0x80000     0xEFFFF (0x9FFFF if 128K (2))
1864
1865    port80 = 0x0F
1866        block1      0x00000     0x7FFFF
1867        block0      0x80000     0xEFFFF (0x9FFFF if 128K (1))
1868
1869    port80 = 0x17
1870        block1      0x00000     0x7FFFF
1871        block2      0x80000     0xEFFFF
1872   
1873*/
1874
1875struct nimbus_meminfo
1876{
1877      offs_t   start;      /* start address of bank */
1878      offs_t   end;      /* End address of bank */
1879};
1880
1881static const struct nimbus_meminfo memmap[] =
1882{
1883    { 0x00000, 0x1FFFF },
1884    { 0x20000, 0x3FFFF },
1885    { 0x40000, 0x5FFFF },
1886    { 0x60000, 0x7FFFF },
1887    { 0x80000, 0x9FFFF },
1888    { 0xA0000, 0xBFFFF },
1889    { 0xC0000, 0xDFFFF },
1890    { 0xE0000, 0xEFFFF }
1891};
1892
1893typedef struct
1894{
1895    int     blockbase;
1896    int     blocksize;
1897} nimbus_block ;
1898
1899typedef nimbus_block    nimbus_blocks[3];
1900
1901static const nimbus_blocks ramblocks[] =
1902{
1903    {{ 0, 128 },    { 000, 000 },   { 000, 000 }} ,
1904    {{ 0, 128 },    { 128, 128 },   { 000, 000 }} ,
1905    {{ 0, 128 },    { 128, 128 },   { 256, 128 }} ,
1906    {{ 0, 512 },    { 000, 000 },   { 000, 000 }} ,
1907    {{ 0, 512 },    { 512, 128 },   { 000, 000 }} ,
1908    {{ 0, 512 },    { 512, 512 },   { 000, 000 }} ,
1909    {{ 0, 512 },    { 512, 512 },   { 1024, 512 } }
1910};
1911
1912static void nimbus_bank_memory(running_machine *machine)
1913{
1914    const address_space *space = cputag_get_address_space( machine, MAINCPU_TAG, ADDRESS_SPACE_PROGRAM );
1915   int     ramsize = messram_get_size(devtag_get_device(machine, "messram"));
1916    int     ramblock = 0;
1917    int     blockno;
1918    char   bank[10];
1919    UINT8   *ram    = &messram_get_ptr(devtag_get_device(machine, "messram"))[0];
1920    UINT8   *map_blocks[3];
1921    UINT8   *map_base;
1922    int     map_blockno;
1923    int     block_ofs;
1924
1925    UINT8   ramsel = (mcu_reg080 & 0x1F);
1926   
1927    // Invalid ramsel, return.
1928    if((ramsel & 0x07)!=0x07)
1929        return;
1930
1931    switch (ramsize / 1024)
1932    {
1933        case 128    : ramblock=0; break;
1934        case 256    : ramblock=1; break;
1935        case 384    : ramblock=2; break;
1936        case 512    : ramblock=3; break;
1937        case 640    : ramblock=4; break;
1938        case 1024   : ramblock=5; break;
1939        case 1536   : ramblock=6; break;
1940    }
1941   
1942    map_blocks[0]  = ram;
1943    map_blocks[1]  = (ramblocks[ramblock][1].blocksize==0) ? NULL : &ram[ramblocks[ramblock][1].blockbase*1024];
1944    map_blocks[2]  = (ramblocks[ramblock][2].blocksize==0) ? NULL : &ram[ramblocks[ramblock][2].blockbase*1024];
1945   
1946    if(LOG_RAM) logerror("\n\nmcu_reg080=%02X, ramblock=%d, map_blocks[0]=%X, map_blocks[1]=%X, map_blocks[2]=%X\n",mcu_reg080,ramblock,(int)map_blocks[0],(int)map_blocks[1],(int)map_blocks[2]);
1947   
1948    for(blockno=0;blockno<8;blockno++)
1949    {
1950        sprintf(bank,"bank%d",blockno);
1951       
1952        switch (ramsel)
1953        {
1954            case 0x07   : (blockno<3) ? map_blockno=blockno : map_blockno=-1; break;
1955            case 0x1F   : (blockno<4) ? map_blockno=0 : map_blockno=1; break;
1956            case 0x0F   : (blockno<4) ? map_blockno=1 : map_blockno=0; break;
1957            case 0x17   : (blockno<4) ? map_blockno=1 : map_blockno=2; break;
1958            default     : map_blockno=-1;                 
1959        }
1960        block_ofs=(ramsel==0x07) ? 0 : ((blockno % 4)*128);
1961           
1962           
1963        if(LOG_RAM) logerror("mapped %s",bank);
1964           
1965        if((block_ofs < ramblocks[ramblock][map_blockno].blocksize) &&
1966           (map_blocks[map_blockno]!=NULL) && (map_blockno>-1))
1967        {
1968            map_base=(ramsel==0x07) ? map_blocks[map_blockno] : &map_blocks[map_blockno][block_ofs*1024];
1969
1970            memory_set_bankptr(machine, bank, map_base);
1971            memory_install_readwrite_bank(space, memmap[blockno].start, memmap[blockno].end, 0, 0, bank);
1972            if(LOG_RAM) logerror(", base=%X\n",(int)map_base);
1973        }
1974        else
1975        {
1976            memory_nop_readwrite(space, memmap[blockno].start, memmap[blockno].end, 0, 0);
1977            if(LOG_RAM) logerror("NOP\n");
1978        }
1979    }
1980}
1981
1982READ8_HANDLER( mcu_r )
1983{
1984    return mcu_reg080;
1985}
1986
1987WRITE8_HANDLER( mcu_w )
1988{
1989    mcu_reg080=data;
1990   
1991    nimbus_bank_memory(space->machine);
1992}
1993
1994static void memory_reset(running_machine *machine)
1995{
1996    mcu_reg080=0x07;
1997    nimbus_bank_memory(machine);
1998}
1999
18152000READ16_HANDLER( nimbus_io_r )
18162001{
18172002    int pc=cpu_get_pc(space->cpu);
1818
2003   
18192004    logerror("Nimbus IOR at pc=%08X from %04X mask=%04X, data=%04X\n",pc,(offset*2)+0x30,mem_mask,IOPorts[offset]);
1820
2005   
18212006    switch (offset*2)
18222007    {
18232008        default         : return IOPorts[offset]; break;
r7354r7355
18302015    int pc=cpu_get_pc(space->cpu);
18312016
18322017    logerror("Nimbus IOW at %08X write of %04X to %04X mask=%04X\n",pc,data,(offset*2)+0x30,mem_mask);
1833
2018   
18342019    switch (offset*2)
18352020    {
18362021        default         : COMBINE_DATA(&IOPorts[offset]); break;
r7354r7355
18382023}
18392024
18402025
1841/*
1842    Keyboard emulation
1843
2026/*
2027    Keyboard emulation
2028   
18442029*/
18452030
18462031static void keyboard_reset(void)
18472032{
18482033    memset(keyboard.keyrows,0xFF,NIMBUS_KEYROWS);
1849
2034   
18502035    // Setup timer to scan keyboard.
18512036    timer_adjust_periodic(keyboard.keyscan_timer, attotime_zero, 0, ATTOTIME_IN_HZ(50));
18522037
r7354r7355
18832068    UINT8   mask;
18842069    static const char *const keynames[] = {
18852070        "KEY0", "KEY1", "KEY2", "KEY3", "KEY4",
1886        "KEY5", "KEY6", "KEY7", "KEY8", "KEY9",
2071        "KEY5", "KEY6", "KEY7", "KEY8", "KEY9",
18872072        "KEY10"
18882073    };
18892074
18902075    for(row=0;row<NIMBUS_KEYROWS;row++)
18912076    {
18922077        keyrow=input_port_read(machine, keynames[row]);
1893
2078       
18942079        for(mask=0x80, bitno=7;mask>0;mask=mask>>1, bitno-=1)
18952080        {
18962081            if(!(keyrow & mask) && (keyboard.keyrows[row] & mask))
r7354r7355
18982083                if (LOG_KEYBOARD) logerror("keypress %02X\n",(row<<3)+bitno);
18992084                queue_scancode((row<<3)+bitno);
19002085            }
1901
2086   
19022087            if((keyrow & mask) && !(keyboard.keyrows[row] & mask))
19032088            {
1904                if (LOG_KEYBOARD) logerror("keyrelease %02X\n",0x80+(row<<3)+bitno);
2089                if (LOG_KEYBOARD) logerror("keyrelease %02X\n",0x80+(row<<3)+bitno); 
19052090                queue_scancode(0x80+(row<<3)+bitno);
19062091            }
19072092        }
1908
2093       
19092094        keyboard.keyrows[row]=keyrow;
19102095    }
19112096}
19122097
19132098
1914/*
2099/*
19152100
1916Z80SIO, used for the keyboard interface
2101Z80SIO, used for the keyboard interface
19172102
19182103*/
19192104
r7354r7355
19212106{
19222107    int pc=cpu_get_pc(devtag_get_device(device->machine,MAINCPU_TAG));
19232108    UINT8 result = 0;
1924
2109   
19252110   switch (offset*2)
19262111   {
19272112        case 0 :
1928            result=z80sio_d_r(device, 0);
2113            result=z80sio_d_r(device, 0);
19292114            break;
19302115        case 2 :
1931            result=z80sio_d_r(device, 1);
2116            result=z80sio_d_r(device, 1);
19322117            break;
19332118        case 4 :
19342119            result=z80sio_c_r(device, 0);
r7354r7355
19792164    if(state!=sio_int_state)
19802165    {
19812166        sio_int_state=state;
1982
2167       
19832168        if(state)
19842169            external_int(device->machine,0,EXTERNAL_INT_Z80SIO);
19852170    }
r7354r7355
20002185{
20012186   if(channel==0)
20022187    {
2003        return keyboard_queue_read();
2188        return keyboard_queue_read();     
20042189    }
20052190    else
20062191        return -1;
r7354r7355
20232208    if(iou_reg092 & DISK_INT_ENABLE)
20242209    {
20252210        external_int(machine,0,EXTERNAL_INT_DISK);
2026    }
2211    }
20272212}
20282213
20292214static WRITE_LINE_DEVICE_HANDLER( nimbus_fdc_intrq_w )
r7354r7355
20372222
20382223    if(LOG_DISK)
20392224        logerror("nimbus_drives_drq_w(%d)\n", state);
2040
2225   
20412226    if(state && FDC_DRQ_ENABLED())
20422227        drq_callback(device->machine,1);
20432228}
20442229
2045/*
2046    0x410 read bits
2047
2230/*
2231    0x410 read bits
2232 
20482233    0   Ready from floppy
20492234    1   Index pulse from floppy
20502235    2   Motor on from floppy
r7354r7355
20602245      int result = 0;
20612246   running_device *fdc = devtag_get_device(space->machine, FDC_TAG);
20622247    running_device *hdc = devtag_get_device(space->machine, SCSIBUS_TAG);
2063
2248   
20642249    int pc=cpu_get_pc(space->cpu);
20652250    running_device *drive = devtag_get_device(space->machine, nimbus_wd17xx_interface.floppy_drive_tags[FDC_DRIVE()]);
2066
2251   
20672252    switch(offset*2)
20682253   {
20692254      case 0x08 :
r7354r7355
20832268            nimbus_drives.reg410_in &= ~FDC_BITS_410;
20842269            nimbus_drives.reg410_in |= (FDC_MOTOR() ? FDC_MOTOR_MASKI : 0x00);
20852270            nimbus_drives.reg410_in |= (floppy_drive_get_flag_state(drive, FLOPPY_DRIVE_INDEX) ? 0x00 : FDC_INDEX_MASK);
2086            nimbus_drives.reg410_in |= (floppy_drive_get_flag_state(drive, FLOPPY_DRIVE_READY) ? FDC_READY_MASK : 0x00);
2087
2271            nimbus_drives.reg410_in |= (floppy_drive_get_flag_state(drive, FLOPPY_DRIVE_READY) ? FDC_READY_MASK : 0x00);     
2272           
20882273            // Flip inverted bits
20892274            result=nimbus_drives.reg410_in ^ INV_BITS_410;
20902275            break;
r7354r7355
21002285
21012286    if((LOG_DISK_HDD) && ((offset*2)>=0x10))
21022287        logerror("Nimbus HDCR at pc=%08X from %04X data=%02X\n",pc,(offset*2)+0x400,result);
2288   
21032289
2104
21052290   return result;
21062291}
21072292
21082293/*
21092294    0x400 write bits
2110
2295   
21112296    0   drive 0 select
21122297    1   drive 1 select
21132298    2   drive 2 select
r7354r7355
21162301    5   fdc motor on
21172302    6   hdc drq enabled
21182303    7   fdc drq enabled
2119
2304   
21202305    0x410 write bits
2121
2306   
21222307    0   SCSI reset
21232308    1   SCSI SEL
2124    2   SCSI IRQ Enable
2309    2   SCSI IRQ Enable
21252310*/
21262311
21272312WRITE8_HANDLER( nimbus_disk_w )
r7354r7355
21302315    running_device *hdc = devtag_get_device(space->machine, SCSIBUS_TAG);
21312316    int                 pc=cpu_get_pc(space->cpu);
21322317    UINT8               reg400_old = nimbus_drives.reg400;
2133
2318   
21342319    if(LOG_DISK_FDD && ((offset*2)<=0x10))
21352320        logerror("Nimbus FDCW at %05X write of %02X to %04X\n",pc,data,(offset*2)+0x400);
21362321
r7354r7355
21412326   {
21422327        case 0x00 :
21432328            nimbus_drives.reg400=data;
2144
2329         
21452330            wd17xx_set_drive(fdc,FDC_DRIVE());
21462331            wd17xx_set_side(fdc, FDC_SIDE());
2332           
2333            // Nimbus FDC is hard wired for double density
2334            //wd17xx_set_density(fdc, DEN_MFM_LO);
21472335
21482336            // if we enable hdc drq with a pending condition, act on it
21492337            if((data & HDC_DRQ_MASK) && (~reg400_old & HDC_DRQ_MASK))
r7354r7355
21652353        case 0x10 :
21662354            hdc_ctrl_write(space->machine,data);
21672355            break;
2168
2356   
21692357        case 0x18 :
21702358            scsi_data_w(hdc, data);
21712359            hdc_post_rw(space->machine);
r7354r7355
21852373    nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_IO)  ? HDC_IO_MASK  : 0);
21862374    nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_BSY) ? HDC_BSY_MASK : 0);
21872375    nimbus_drives.reg410_in |= (get_scsi_line(hdc,SCSI_LINE_MSG) ? HDC_MSG_MASK : 0);
2188
2376   
21892377    nimbus_drives.drq_ff=0;
21902378}
21912379
21922380static void hdc_ctrl_write(running_machine *machine, UINT8 data)
21932381{
21942382   running_device *hdc = devtag_get_device(machine, SCSIBUS_TAG);
2195
2383   
21962384    // If we enable the HDC interupt, and an interrupt is pending, go deal with it.
2197    if(((data & HDC_IRQ_MASK) && (~nimbus_drives.reg410_out & HDC_IRQ_MASK)) &&
2385    if(((data & HDC_IRQ_MASK) && (~nimbus_drives.reg410_out & HDC_IRQ_MASK)) &&
21982386       ((~nimbus_drives.reg410_in & HDC_INT_TRIGGER)==HDC_INT_TRIGGER))
21992387        generate_disk_int(machine);
2200
2388           
22012389    nimbus_drives.reg410_out=data;
22022390
22032391    set_scsi_line(hdc, SCSI_LINE_RESET, (data & HDC_RESET_MASK) ? 0 : 1);
r7354r7355
22072395static void hdc_post_rw(running_machine *machine)
22082396{
22092397    running_device *hdc = devtag_get_device(machine, SCSIBUS_TAG);
2210
2398   
22112399    if((nimbus_drives.reg410_in & HDC_REQ_MASK)==0)
22122400        set_scsi_line(hdc,SCSI_LINE_ACK,0);
22132401
r7354r7355
22262414{
22272415    UINT8   mask = 0;
22282416    UINT8   last = 0;
2229
2417   
22302418    switch (line)
22312419    {
22322420        case SCSI_LINE_REQ   : mask=HDC_REQ_MASK; break;
r7354r7355
22352423        case SCSI_LINE_BSY   : mask=HDC_BSY_MASK; break;
22362424        case SCSI_LINE_MSG   : mask=HDC_MSG_MASK; break;
22372425    }
2238
2426   
22392427    last=nimbus_drives.reg410_in & mask;
2240
2428   
22412429    if(state)
22422430        nimbus_drives.reg410_in|=mask;
22432431    else
22442432        nimbus_drives.reg410_in&=~mask;
22452433
2246
2247    if(line==SCSI_LINE_REQ)
2434   
2435    if(line==SCSI_LINE_REQ)
22482436    {
22492437        if (state==0)
22502438        {
22512439            if(HDC_IRQ_ENABLED() && ((~nimbus_drives.reg410_in & HDC_INT_TRIGGER)==HDC_INT_TRIGGER))
2252                generate_disk_int(device->machine);
2253
2440                generate_disk_int(device->machine);
2441   
22542442            if(((nimbus_drives.reg410_in & HDC_CD_MASK)==HDC_CD_MASK) && (last!=0))
2255            {
2443            {   
22562444                nimbus_drives.drq_ff=1;
22572445                hdc_drq(device->machine);
22582446            }
r7354r7355
22692457    running_device *er59256 = machine->device(ER59256_TAG);
22702458
22712459    logerror("peripheral controler reset\n");
2272
2460   
22732461    memset(&ipc_interface,0,sizeof(ipc_interface));
2274
2462   
22752463    if(!data_loaded(er59256))
22762464        preload_rom(er59256,def_config,ARRAY_LENGTH(def_config));
22772465}
r7354r7355
22832471    logerror("in_data=%02X, in_status=%02X, out_data=%02X, out_status=%02X\n",
22842472              ipc_interface.ipc_in, ipc_interface.status_in,
22852473              ipc_interface.ipc_out, ipc_interface.status_out);
2286
2474             
22872475}
22882476#endif
22892477
2290READ8_HANDLER( pc8031_r )
2478READ8_HANDLER( pc8031_r )
22912479{
22922480   int pc=cpu_get_pc(space->cpu);
22932481    UINT8   result;
2294
2482
22952483    switch(offset*2)
22962484    {
2297        case 0x00   : result=ipc_interface.ipc_out;
2298                      ipc_interface.status_in   &= ~IPC_IN_READ_PEND;
2299                      ipc_interface.status_out  &= ~IPC_OUT_BYTE_AVAIL;
2485        case 0x00   : result=ipc_interface.ipc_out; 
2486                      ipc_interface.status_in   &= ~IPC_IN_READ_PEND;
2487                      ipc_interface.status_out  &= ~IPC_OUT_BYTE_AVAIL;
23002488                      break;
2301
2489                     
23022490        case 0x02   : result=ipc_interface.status_out;
23032491                      break;
2304
2492                     
23052493        default : result=0; break;
23062494    }
23072495
23082496    if(LOG_PC8031_186)
23092497        logerror("Nimbus PCIOR %08X read of %04X returns %02X\n",pc,(offset*2)+0xC0,result);
2310
2498       
23112499    return result;
23122500}
23132501
r7354r7355
23222510                      ipc_interface.status_in   &= ~IPC_IN_ADDR;
23232511                      ipc_interface.status_out  |= IPC_OUT_READ_PEND;
23242512                      break;
2325
2513                     
23262514        case 0x02   : ipc_interface.ipc_in=data;
23272515                      ipc_interface.status_in   |= IPC_IN_BYTE_AVAIL;
23282516                      ipc_interface.status_in   |= IPC_IN_ADDR;
r7354r7355
23412529{
23422530   int pc=cpu_get_pc(space->cpu);
23432531    UINT8   result = 0;
2344
2532   
23452533    switch (offset & 0x01)
23462534    {
23472535        case 0x00   : result=ipc_interface.ipc_in;
2348                      ipc_interface.status_out  &= ~IPC_OUT_READ_PEND;
2349                      ipc_interface.status_in   &= ~IPC_IN_BYTE_AVAIL;
2536                      ipc_interface.status_out  &= ~IPC_OUT_READ_PEND;
2537                      ipc_interface.status_in   &= ~IPC_IN_BYTE_AVAIL;
23502538                      break;
2351
2539                     
23522540        case 0x01   : result=ipc_interface.status_in;
23532541                      break;
23542542    }
2355
2356    if(((offset==2) || (offset==3)) && (iou_reg092 & PC8031_INT_ENABLE))
2543                       
2544    if(((offset==2) || (offset==3)) && (iou_reg092 & PC8031_INT_ENABLE))
23572545        external_int(space->machine,0,EXTERNAL_INT_PC8031_8C);
2358
2546   
23592547    if(LOG_PC8031)
2360        logerror("8031: PCIOR %04X read of %04X returns %02X\n",pc,offset,result);
2361
2548        logerror("8031: PCIOR %04X read of %04X returns %02X\n",pc,offset,result);
2549       
23622550    return result;
23632551}
23642552
23652553WRITE8_HANDLER( pc8031_iou_w )
23662554{
2367   int pc=cpu_get_pc(space->cpu);
2555   int pc=cpu_get_pc(space->cpu); 
23682556
23692557    if(LOG_PC8031)
23702558        logerror("8031 PCIOW %04X write of %02X to %04X\n",pc,data,offset);
2371
2559   
23722560    switch(offset & 0x03)
23732561    {
23742562        case 0x00   : ipc_interface.ipc_out=data;
r7354r7355
23762564                      ipc_interface.status_out  &= ~IPC_OUT_ADDR;
23772565                      ipc_interface.status_in   |= IPC_IN_READ_PEND;
23782566                      break;
2379
2567                     
23802568        case 0x01   : ipc_interface.ipc_out=data;
23812569                      ipc_interface.status_out   |= IPC_OUT_BYTE_AVAIL;
23822570                      ipc_interface.status_out   |= IPC_OUT_ADDR;
r7354r7355
23882576                      ipc_interface.status_out  &= ~IPC_OUT_ADDR;
23892577                      ipc_interface.status_in   |= IPC_IN_READ_PEND;
23902578                      if(iou_reg092 & PC8031_INT_ENABLE)
2391                        external_int(space->machine,0,EXTERNAL_INT_PC8031_8F);
2579                        external_int(space->machine,0,EXTERNAL_INT_PC8031_8F); 
23922580                      break;
2393
2581                     
23942582        case 0x03   : ipc_interface.ipc_out=data;
23952583                      //ipc_interface.status_out   |= IPC_OUT_BYTE_AVAIL;
23962584                      ipc_interface.status_out   |= IPC_OUT_ADDR;
23972585                      ipc_interface.status_in    |= IPC_IN_READ_PEND;
23982586                      if(iou_reg092 & PC8031_INT_ENABLE)
2399                        external_int(space->machine,0,EXTERNAL_INT_PC8031_8E);
2587                        external_int(space->machine,0,EXTERNAL_INT_PC8031_8E); 
24002588                      break;
24012589    }
24022590}
r7354r7355
24082596    UINT8   result = 0;
24092597
24102598    if(LOG_PC8031_PORT)
2411        logerror("8031: PCPORTR %04X read of %04X returns %02X\n",pc,offset,result);
2599        logerror("8031: PCPORTR %04X read of %04X returns %02X\n",pc,offset,result);
24122600
24132601    switch(offset)
24142602    {
r7354r7355
24472635
24482636    if(LOG_IOU)
24492637        logerror("Nimbus IOUR %08X read of %04X returns %02X\n",pc,(offset*2)+0x92,result);
2450
2638       
24512639    return result;
24522640}
24532641
r7354r7355
24712659    iou_reg092=0x00;
24722660}
24732661
2474/*
2662/*
24752663    Sound hardware : AY8910
2476
2664 
24772665    I believe that the IO ports of the 8910 are used to control the ROMPack ports, however
24782666    this is currently un-implemented (and may never be as I don't have any rompacks!).
2479
2667   
24802668    The registers are mapped as so :
2481
2669   
24822670    Address     0xE0                0xE2
24832671    Read        Data                ????
24842672    Write       Register Address    Data
2673 
2674*/   
24852675
2486*/
2487
24882676static void sound_reset(running_machine *machine)
24892677{
24902678    //running_device *ay8910 = devtag_get_device(machine, AY8910_TAG);
r7354r7355
25012689{
25022690   running_device *ay8910 = devtag_get_device(space->machine, AY8910_TAG);
25032691    UINT8   result=0;
2504
2692   
25052693    if ((offset*2)==0)
25062694        result=ay8910_r(ay8910,0);
2507
2695       
25082696    return result;
25092697}
25102698
r7354r7355
25122700{
25132701   int pc=cpu_get_pc(space->cpu);
25142702   running_device *ay8910 = devtag_get_device(space->machine, AY8910_TAG);
2515
2703   
25162704    if(LOG_SOUND)
25172705        logerror("Nimbus SoundW %05X write of %02X to %04X\n",pc,data,(offset*2)+0xE0);
25182706
src/mess/drivers/rmnimbus.c
r7354r7355
9797};
9898
9999static ADDRESS_MAP_START(nimbus_mem, ADDRESS_SPACE_PROGRAM, 16)
100    AM_RANGE( 0x00000, 0xEFFFF ) AM_RAM
100    AM_RANGE( 0x00000, 0x1FFFF ) AM_RAMBANK(RAM_BANK00_TAG)
101    AM_RANGE( 0x20000, 0x3FFFF ) AM_RAMBANK(RAM_BANK01_TAG)
102    AM_RANGE( 0x40000, 0x5FFFF ) AM_RAMBANK(RAM_BANK02_TAG)
103    AM_RANGE( 0x60000, 0x7FFFF ) AM_RAMBANK(RAM_BANK03_TAG)
104    AM_RANGE( 0x80000, 0x9FFFF ) AM_RAMBANK(RAM_BANK04_TAG)
105    AM_RANGE( 0xA0000, 0xBFFFF ) AM_RAMBANK(RAM_BANK05_TAG)
106    AM_RANGE( 0xC0000, 0xDFFFF ) AM_RAMBANK(RAM_BANK06_TAG)
107    AM_RANGE( 0xE0000, 0xEFFFF ) AM_RAMBANK(RAM_BANK07_TAG)
101108    AM_RANGE( 0xF0000, 0xFFFFF ) AM_ROM AM_REGION(MAINCPU_TAG, 0x0f0000)
102109ADDRESS_MAP_END
103110
104111static ADDRESS_MAP_START(nimbus_io, ADDRESS_SPACE_IO, 16)
105112    AM_RANGE( 0x0000, 0x002f) AM_READWRITE( nimbus_video_io_r, nimbus_video_io_w)
106    AM_RANGE( 0x0030, 0x008f) AM_READWRITE( nimbus_io_r, nimbus_io_w)
113    AM_RANGE( 0x0030, 0x007f) AM_READWRITE( nimbus_io_r, nimbus_io_w)
114    AM_RANGE( 0x0080, 0x0081) AM_READWRITE8( mcu_r, mcu_w, 0x00FF)
107115    AM_RANGE( 0x0092, 0x0093) AM_READWRITE8( iou_r, iou_w, 0x00FF)
108116    AM_RANGE( 0X00c0, 0X00cf) AM_READWRITE8( pc8031_r, pc8031_w, 0x00FF)
109117    AM_RANGE( 0X00e0, 0X00ef) AM_READWRITE8( sound_ay8910_r, sound_ay8910_w, 0x00FF)
r7354r7355
300308    MDRV_SCSIBUS_ADD(SCSIBUS_TAG, scsibus_config)
301309   
302310    MDRV_RAM_ADD("messram")
303   MDRV_RAM_DEFAULT_SIZE("512K")
304   MDRV_RAM_EXTRA_OPTIONS("1024K,1536K")
311   MDRV_RAM_DEFAULT_SIZE("1536K")
312   MDRV_RAM_EXTRA_OPTIONS("128K,256K,384K,512K,640K,1024K")
305313   
306314    /* Peripheral chips */
307315    MDRV_Z80SIO_ADD(Z80SIO_TAG, 4000000, sio_intf)

Previous 15994 Revisions Next

© 1998-2018 The MESS Team