Previous 15994 Revisions Next

r15547 Friday 6th July, 2012 at 20:31:57 UTC by Michael Zapf
tms9928/v9938: Using an own address space for the attached video memory [Michael Zapf]
[src/emu/video]tms9928a.c tms9928a.h v9938.c v9938.h

src/emu/video/tms9928a.c
r15546r15547
3434const device_type TMS9929A = &device_creator<tms9929a_device>;
3535const device_type TMS9129  = &device_creator<tms9129_device>;
3636
37/*
38    The TMS9928 has an own address space.
39*/
40static ADDRESS_MAP_START(memmap, AS_DATA, 8, tms9928a_device)
41   ADDRESS_MAP_GLOBAL_MASK(0x3fff)
42   AM_RANGE(0x0000, 0x3fff) AM_RAM
43ADDRESS_MAP_END
3744
3845/*
3946    New palette (R. Nabet).
r15546r15547
94101
95102
96103tms9928a_device::tms9928a_device( const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, bool is_50hz, bool is_reva )
97   : device_t( mconfig, type, name, tag, owner, clock )
104   : device_t( mconfig, type, name, tag, owner, clock ),
105     device_memory_interface(mconfig, *this),
106     m_space_config("vram", ENDIANNESS_BIG, 8, 14)
98107{
99108   m_50hz = is_50hz;
100109   m_reva = is_reva;
110   static_set_addrmap(*this, AS_DATA, ADDRESS_MAP_NAME(memmap));
101111}
102112
103113
104114tms9928a_device::tms9928a_device( const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock )
105   : device_t( mconfig, TMS9928A, "tms9928a", tag, owner, clock )
115   : device_t( mconfig, TMS9928A, "TMS9928A", tag, owner, clock ),
116     device_memory_interface(mconfig, *this),
117     m_space_config("vram", ENDIANNESS_BIG, 8, 14)
106118{
107119   m_50hz = false;
108120   m_reva = true;
121   static_set_addrmap(*this, AS_DATA, ADDRESS_MAP_NAME(memmap));
109122}
110123
111124
r15546r15547
113126{
114127   UINT8 data = m_ReadAhead;
115128
116   m_ReadAhead = m_vMem[ m_Addr ];
129   m_ReadAhead = m_vram_space->read_byte(m_Addr);
117130   m_Addr = (m_Addr + 1) & (m_vram_size - 1);
118131   m_latch = 0;
119132
r15546r15547
123136
124137WRITE8_MEMBER( tms9928a_device::vram_write )
125138{
126   m_vMem[ m_Addr ] = data;
139   m_vram_space->write_byte(m_Addr, data);
127140   m_Addr = (m_Addr + 1) & (m_vram_size - 1);
128141   m_ReadAhead = data;
129142   m_latch = 0;
r15546r15547
313326
314327            for ( int x = TMS9928A_HORZ_DISPLAY_START; x < TMS9928A_HORZ_DISPLAY_START + 256; x+= 8, addr++ )
315328            {
316               UINT8 charcode = m_vMem[ addr ];
317               UINT8 pattern = m_vMem[ m_pattern + ( charcode << 3 ) + ( y & 7 ) ];
318               UINT8 colour = m_vMem[ m_colour + ( charcode >> 3 ) ];
329               UINT8 charcode = m_vram_space->read_byte( addr );
330               UINT8 pattern =  m_vram_space->read_byte( m_pattern + ( charcode << 3 ) + ( y & 7 ) );
331               UINT8 colour =  m_vram_space->read_byte( m_colour + ( charcode >> 3 ) );
319332               UINT16 fg = (colour >> 4) ? (colour >> 4) : BackColour;
320333               UINT16 bg = (colour & 15) ? (colour & 15) : BackColour;
321334
r15546r15547
338351
339352            for ( int x = TMS9928A_HORZ_DISPLAY_START + 6; x < TMS9928A_HORZ_DISPLAY_START + 246; x+= 6, addr++ )
340353            {
341               UINT16 charcode = m_vMem[ addr ];
342               UINT8 pattern = m_vMem[ m_pattern + ( charcode << 3 ) + ( y & 7 ) ];
354               UINT16 charcode =  m_vram_space->read_byte( addr );
355               UINT8 pattern =  m_vram_space->read_byte( m_pattern + ( charcode << 3 ) + ( y & 7 ) );
343356
344357               for ( int i = 0; i < 6; pattern <<= 1, i++ )
345358                  p[x+i] = ( pattern & 0x80 ) ? fg : bg;
r15546r15547
358371
359372            for ( int x = TMS9928A_HORZ_DISPLAY_START; x < TMS9928A_HORZ_DISPLAY_START + 256; x+= 8, addr++ )
360373            {
361               UINT16 charcode = m_vMem[ addr ] + ( ( y >> 6 ) << 8 );
362               UINT8 pattern = m_vMem[ m_pattern + ( ( charcode & m_patternmask ) << 3 ) + ( y & 7 ) ];
363               UINT8 colour = m_vMem[ m_colour + ( ( charcode & m_colourmask ) << 3 ) + ( y & 7 ) ];
374               UINT16 charcode =  m_vram_space->read_byte( addr ) + ( ( y >> 6 ) << 8 );
375               UINT8 pattern =  m_vram_space->read_byte( m_pattern + ( ( charcode & m_patternmask ) << 3 ) + ( y & 7 ) );
376               UINT8 colour =  m_vram_space->read_byte( m_colour + ( ( charcode & m_colourmask ) << 3 ) + ( y & 7 ) );
364377               UINT16 fg = (colour >> 4) ? (colour >> 4) : BackColour;
365378               UINT16 bg = (colour & 15) ? (colour & 15) : BackColour;
366379
r15546r15547
383396
384397            for ( int x = TMS9928A_HORZ_DISPLAY_START + 6; x < TMS9928A_HORZ_DISPLAY_START + 246; x+= 6, addr++ )
385398            {
386               UINT16 charcode = ( m_vMem[ addr ] + ( ( y >> 6 ) << 8 ) ) & m_patternmask;
387               UINT8 pattern = m_vMem[ m_pattern + ( charcode << 3 ) + ( y & 7 ) ];
399               UINT16 charcode = (  m_vram_space->read_byte( addr ) + ( ( y >> 6 ) << 8 ) ) & m_patternmask;
400               UINT8 pattern = m_vram_space->read_byte( m_pattern + ( charcode << 3 ) + ( y & 7 ) );
388401
389402               for ( int i = 0; i < 6; pattern <<= 1, i++ )
390403                  p[x+i] = ( pattern & 0x80 ) ? fg : bg;
r15546r15547
403416
404417            for ( int x = TMS9928A_HORZ_DISPLAY_START; x < TMS9928A_HORZ_DISPLAY_START + 256; x+= 8, addr++ )
405418            {
406               UINT8 charcode = m_vMem[ addr ];
407               UINT8 colour = m_vMem[ m_pattern + ( charcode << 3 ) + ( ( y >> 2 ) & 7 ) ];
419               UINT8 charcode =  m_vram_space->read_byte( addr );
420               UINT8 colour =  m_vram_space->read_byte( m_pattern + ( charcode << 3 ) + ( ( y >> 2 ) & 7 ) );
408421               UINT16 fg = (colour >> 4) ? (colour >> 4) : BackColour;
409422               UINT16 bg = (colour & 15) ? (colour & 15) : BackColour;
410423
r15546r15547
443456
444457            for ( int x = TMS9928A_HORZ_DISPLAY_START; x < TMS9928A_HORZ_DISPLAY_START + 256; x+= 8, addr++ )
445458            {
446               UINT8 charcode = m_vMem[ addr ];
447               UINT8 colour = m_vMem[ m_pattern + ( ( ( charcode + ( ( y >> 2 ) & 7 ) + ( ( y >> 6 ) << 8 ) ) & m_patternmask ) << 3 ) ];
459               UINT8 charcode =  m_vram_space->read_byte( addr );
460               UINT8 colour =  m_vram_space->read_byte( m_pattern + ( ( ( charcode + ( ( y >> 2 ) & 7 ) + ( ( y >> 6 ) << 8 ) ) & m_patternmask ) << 3 ) );
448461               UINT16 fg = (colour >> 4) ? (colour >> 4) : BackColour;
449462               UINT16 bg = (colour & 15) ? (colour & 15) : BackColour;
450463
r15546r15547
472485
473486         for ( UINT16 sprattr = 0; sprattr < 128; sprattr += 4 )
474487         {
475            int spr_y = m_vMem[ m_spriteattribute + sprattr + 0 ];
488            int spr_y = m_vram_space->read_byte( m_spriteattribute + sprattr + 0 );
476489
477490            m_FifthSprite = sprattr / 4;
478491
r15546r15547
489502            /* is sprite enabled on this line? */
490503            if ( spr_y <= y && y < spr_y + sprite_height )
491504            {
492               int spr_x = m_vMem[ m_spriteattribute + sprattr + 1 ];
493               UINT8 sprcode = m_vMem[ m_spriteattribute + sprattr + 2 ];
494               UINT8 sprcol = m_vMem[ m_spriteattribute + sprattr + 3 ];
505               int spr_x =  m_vram_space->read_byte( m_spriteattribute + sprattr + 1 );
506               UINT8 sprcode =  m_vram_space->read_byte( m_spriteattribute + sprattr + 2 );
507               UINT8 sprcol =  m_vram_space->read_byte( m_spriteattribute + sprattr + 3 );
495508               UINT16 pataddr = m_spritepattern + ( ( sprite_size == 16 ) ? sprcode & ~0x03 : sprcode ) * 8;
496509
497510               num_sprites++;
r15546r15547
508521               else
509522                  pataddr += ( ( y - spr_y ) & 0x0F );
510523
511               UINT8 pattern = m_vMem[ pataddr ];
524               UINT8 pattern = m_vram_space->read_byte( pataddr );
512525
513526               if ( sprcol & 0x80 )
514527                  spr_x -= 32;
r15546r15547
547560                     }
548561                  }
549562
550                  pattern = m_vMem[ pataddr + 16 ];
563                  pattern = m_vram_space->read_byte( pataddr + 16 );
551564                  spr_x += sprite_mag ? 16 : 8;
552565               }
553566            }
r15546r15547
597610
598611void tms9928a_device::device_start()
599612{
600   assert_always(((m_vram_size == 0x1000) || (m_vram_size == 0x2000) || (m_vram_size == 0x4000)), "4, 8 or 16 kB vram please");
601
602613   m_screen = machine().device<screen_device>( m_screen_tag );
603614   assert( m_screen != NULL );
604615
r15546r15547
607618
608619   m_irq_changed.resolve( m_out_int_line, *this );
609620
610   /* Video RAM */
611   m_vMem = auto_alloc_array_clear(machine(), UINT8, m_vram_size);
621   // Video RAM is allocated as an own address space
622   m_vram_space = space(AS_DATA);
612623
613624   /* back bitmap */
614625   m_tmpbmp.allocate(TMS9928A_TOTAL_HORZ, TMS9928A_TOTAL_VERT_PAL);
r15546r15547
629640   save_item(NAME(m_latch));
630641   save_item(NAME(m_Addr));
631642   save_item(NAME(m_INT));
632   save_pointer(NAME(m_vMem), m_vram_size);
643//  save_pointer(NAME(m_vMem), m_vram_size);
633644   save_item(NAME(m_colour));
634645   save_item(NAME(m_colourmask));
635646   save_item(NAME(m_pattern));
src/emu/video/tms9928a.h
r15546r15547
8282   const char         *m_screen_tag;
8383   int               m_vram_size;   /* 4K, 8K, or 16K. This should be replaced by fetching data from an address space? */
8484   devcb_write_line   m_out_int_line;   /* Callback is called whenever the state of the INT output changes */
85   const char         *m_regionname;      // Alternatively, get the name of the region (if vram size is 0)
8586};
8687
8788
r15546r15547
8990
9091
9192class tms9928a_device :   public device_t,
93                  public device_memory_interface,
9294                  public tms9928a_interface
9395{
9496public:
r15546r15547
113115   virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
114116
115117   // device_memory_interface overrides
116   virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_0) ? &m_space_config : NULL; }
118   virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_DATA) const { return (spacenum == AS_DATA) ? &m_space_config : NULL; }
117119
118120private:
119121   void change_register(UINT8 reg, UINT8 val);
r15546r15547
145147
146148   /* memory */
147149   const address_space_config      m_space_config;
150   address_space*               m_vram_space;
148151
149   UINT8      *m_vMem;
150152   bitmap_ind16 m_tmpbmp;
151153   emu_timer   *m_line_timer;
152154   UINT8      m_mode;
r15546r15547
161163{
162164public:
163165   tms9918_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
164      : tms9928a_device( mconfig, TMS9918, "tms9918", tag, owner, clock, false, false ) { }
166      : tms9928a_device( mconfig, TMS9918, "TMS9918", tag, owner, clock, false, false ) { }
165167};
166168
167169
r15546r15547
169171{
170172public:
171173   tms9918a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
172      : tms9928a_device( mconfig, TMS9918A, "tms9918a", tag, owner, clock, false, true ) { }
174      : tms9928a_device( mconfig, TMS9918A, "TMS9918a", tag, owner, clock, false, true ) { }
173175};
174176
175177
r15546r15547
177179{
178180public:
179181   tms9118_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
180      : tms9928a_device( mconfig, TMS9118, "tms9118", tag, owner, clock, false, true ) { }
182      : tms9928a_device( mconfig, TMS9118, "TMS9118", tag, owner, clock, false, true ) { }
181183};
182184
183185
r15546r15547
185187{
186188public:
187189   tms9128_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
188      : tms9928a_device( mconfig, TMS9128, "tms9128", tag, owner, clock, false, true ) { }
190      : tms9928a_device( mconfig, TMS9128, "TMS9128", tag, owner, clock, false, true ) { }
189191};
190192
191193
r15546r15547
193195{
194196public:
195197   tms9929_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
196      : tms9928a_device( mconfig, TMS9929, "tms9929", tag, owner, clock, true, false ) { }
198      : tms9928a_device( mconfig, TMS9929, "TMS9929", tag, owner, clock, true, false ) { }
197199};
198200
199201
r15546r15547
201203{
202204public:
203205   tms9929a_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
204      : tms9928a_device( mconfig, TMS9929A, "tms9929a", tag, owner, clock, true, true ) { }
206      : tms9928a_device( mconfig, TMS9929A, "TMS9929A", tag, owner, clock, true, true ) { }
205207};
206208
207209
r15546r15547
209211{
210212public:
211213   tms9129_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
212      : tms9928a_device( mconfig, TMS9129, "tms9129", tag, owner, clock, true, true ) { }
214      : tms9928a_device( mconfig, TMS9129, "TMS9129", tag, owner, clock, true, true ) { }
213215};
214216
215217
src/emu/video/v9938.c
r15546r15547
11
22/***************************************************************************
33
4    v9938 / v9958 emulation
4v9938 / v9958 emulation
55
66***************************************************************************/
77
88/*
9 todo:
9todo:
1010
11 - sprite collision
12 - vdp engine -- make run at correct speed
13 - vr/hr/fh flags: double-check all of that
14 - make vdp engine work in exp. ram
11- sprite collision
12- vdp engine -- make run at correct speed
13- vr/hr/fh flags: double-check all of that
14- make vdp engine work in exp. ram
1515*/
1616
1717#include "emu.h"
r15546r15547
2020#define VERBOSE 0
2121#define LOG(x)   do { if (VERBOSE) logerror x; } while (0)
2222
23#define V9938_MODE_TEXT1   (0)
24#define V9938_MODE_MULTI   (1)
25#define V9938_MODE_GRAPHIC1   (2)
26#define V9938_MODE_GRAPHIC2   (3)
27#define V9938_MODE_GRAPHIC3   (4)
28#define V9938_MODE_GRAPHIC4   (5)
29#define V9938_MODE_GRAPHIC5   (6)
30#define V9938_MODE_GRAPHIC6   (7)
31#define V9938_MODE_GRAPHIC7   (8)
32#define V9938_MODE_TEXT2   (9)
33#define V9938_MODE_UNKNOWN   (10)
23enum
24{
25   V9938_MODE_TEXT1 = 0,
26   V9938_MODE_MULTI,
27   V9938_MODE_GRAPHIC1,
28   V9938_MODE_GRAPHIC2,
29   V9938_MODE_GRAPHIC3,
30   V9938_MODE_GRAPHIC4,
31   V9938_MODE_GRAPHIC5,
32   V9938_MODE_GRAPHIC6,
33   V9938_MODE_GRAPHIC7,
34   V9938_MODE_TEXT2,
35   V9938_MODE_UNKNOWN
36};
3437
38#define EXPMEM_OFFSET 0x20000
3539
3640static const char *const v9938_modes[] = {
3741   "TEXT 1", "MULTICOLOR", "GRAPHIC 1", "GRAPHIC 2", "GRAPHIC 3",
r15546r15547
4347//  GLOBAL VARIABLES
4448//**************************************************************************
4549
50/*
51Similar to the TMS9928, the V9938 has an own address space. It can handle
52at most 192 KiB RAM (128 KiB base, 64 KiB expansion).
53*/
54static ADDRESS_MAP_START(memmap, AS_DATA, 8, v99x8_device)
55ADDRESS_MAP_GLOBAL_MASK(0x3ffff)
56AM_RANGE(0x00000, 0x2ffff) AM_RAM
57ADDRESS_MAP_END
58
59
4660// devices
4761const device_type V9938 = &device_creator<v9938_device>;
4862const device_type V9958 = &device_creator<v9958_device>;
4963
5064v99x8_device::v99x8_device(const machine_config &mconfig, device_type type, const char *name, const char *shortname, const char *tag, device_t *owner, UINT32 clock)
51   : device_t(mconfig, type, name, shortname, tag, owner, clock),
52     m_model(0),
53     m_offset_x(0),
54     m_offset_y(0),
55     m_visible_y(0),
56     m_mode(0),
57     m_pal_write_first(0),
58     m_cmd_write_first(0),
59     m_pal_write(0),
60     m_cmd_write(0),
61     m_read_ahead(0),
62     m_address_latch(0),
63     m_vram_exp(NULL),
64     m_vram_size(0),
65     m_int_state(0),
66     m_int_callback_device_name(NULL),
67     m_scanline(0),
68     m_blink(0),
69     m_blink_count(0),
70     m_sprite_limit(0),
71     m_size(0),
72     m_size_old(0),
73     m_size_auto(0),
74     m_size_now(0),
75     m_mx_delta(0),
76     m_my_delta(0),
77     m_button_state(0),
78     m_screen(NULL),
79     m_screen_name(NULL),
80     m_vdp_ops_count(0),
81     m_vdp_engine(NULL)
65:   device_t(mconfig, type, name, shortname, tag, owner, clock),
66   device_memory_interface(mconfig, *this),
67   m_space_config("vram", ENDIANNESS_BIG, 8, 18),
68   m_model(0),
69   m_offset_x(0),
70   m_offset_y(0),
71   m_visible_y(0),
72   m_mode(0),
73   m_pal_write_first(0),
74   m_cmd_write_first(0),
75   m_pal_write(0),
76   m_cmd_write(0),
77   m_read_ahead(0),
78   m_address_latch(0),
79   m_vram_size(0),
80   m_int_state(0),
81   m_int_callback_device_name(NULL),
82   m_scanline(0),
83   m_blink(0),
84   m_blink_count(0),
85   m_sprite_limit(0),
86   m_size(0),
87   m_size_old(0),
88   m_size_auto(0),
89   m_size_now(0),
90   m_mx_delta(0),
91   m_my_delta(0),
92   m_button_state(0),
93   m_screen(NULL),
94   m_screen_name(NULL),
95   m_vdp_ops_count(0),
96   m_vdp_engine(NULL)
8297{
98   static_set_addrmap(*this, AS_DATA, ADDRESS_MAP_NAME(memmap));
8399}
84100
85101v9938_device::v9938_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
86   : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock)
102: v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock)
87103{
88104   m_model = MODEL_V9938;
89105}
90106
91107v9958_device::v9958_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock)
92   : v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock)
108: v99x8_device(mconfig, V9938, "V9938", "v9938", tag, owner, clock)
93109{
94110   m_model = MODEL_V9958;
95111}
r15546r15547
118134   max = (pal) ? 255 : (m_cont_reg[9] & 0x80) ? 234 : 244;
119135   scanline = (m_scanline - scanline_start - m_offset_y);
120136   if ( (scanline >= 0) && (scanline <= max) &&
121      ( ( (scanline + m_cont_reg[23]) & 255) == m_cont_reg[19]) )
137      ( ( (scanline + m_cont_reg[23]) & 255) == m_cont_reg[19]) )
122138   {
123139      m_stat_reg[1] |= 1;
124140      LOG(("V9938: scanline interrupt (%d)\n", scanline));
r15546r15547
131147   // check for start of vblank
132148   if ((pal && (m_scanline == 310)) ||
133149      (!pal && (m_scanline == 259)))
134      interrupt_start_vblank ();
150   interrupt_start_vblank ();
135151
136152   // render the current line
137153   if ((m_scanline >= scanline_start) && (m_scanline < (212 + 28 + scanline_start)))
r15546r15547
196212
197213/***************************************************************************
198214
199    Palette functions
215Palette functions
200216
201217***************************************************************************/
202218
r15546r15547
217233*/
218234
219235/*
220 In screen 8, the colors are encoded as:
236In screen 8, the colors are encoded as:
221237
222 7  6  5  4  3  2  1  0
2387  6  5  4  3  2  1  0
223239+--+--+--+--+--+--+--+--+
224240|g2|g1|g0|r2|r1|r0|b2|b1|
225241+--+--+--+--+--+--+--+--+
r15546r15547
314330}
315331
316332/*
333    so lookups for screen 12 will look like:
317334
318 so lookups for screen 12 will look like:
335  int ind;
319336
320 int ind;
337    ind = (*data & 7) << 11 | (*(data + 1) & 7) << 14 |
338    (*(data + 2) & 7) << 5 | (*(data + 3) & 7) << 8;
321339
322 ind = (*data & 7) << 11 | (*(data + 1) & 7) << 14 |
323       (*(data + 2) & 7) << 5 | (*(data + 3) & 7) << 8;
340    pixel0 = s_pal_indYJK[ind | (*data >> 3) & 31];
341    pixel1 = s_pal_indYJK[ind | (*(data + 1) >> 3) & 31];
342    pixel2 = s_pal_indYJK[ind | (*(data + 2) >> 3) & 31];
343    pixel3 = s_pal_indYJK[ind | (*(data + 3) >> 3) & 31];
324344
325 pixel0 = s_pal_indYJK[ind | (*data >> 3) & 31];
326 pixel1 = s_pal_indYJK[ind | (*(data + 1) >> 3) & 31];
327 pixel2 = s_pal_indYJK[ind | (*(data + 2) >> 3) & 31];
328 pixel3 = s_pal_indYJK[ind | (*(data + 3) >> 3) & 31];
345    and for screen 11:
329346
330and for screen 11:
331
332pixel0 = (*data) & 8 ? pal_ind16[(*data) >> 4] : s_pal_indYJK[ind | (*data >> 3) & 30];
333pixel1 = *(data+1) & 8 ? pal_ind16[*(data+1) >> 4] : s_pal_indYJK[ind | *(data+1) >> 3) & 30];
334pixel2 = *(data+2) & 8 ? pal_ind16[*(data+2) >> 4] : s_pal_indYJK[ind | *(data+2) >> 3) & 30];
335pixel3 = *(data+3) & 8 ? pal_ind16[*(data+3) >> 4] : s_pal_indYJK[ind | *(data+3) >> 3) & 30];
336
347    pixel0 = (*data) & 8 ? pal_ind16[(*data) >> 4] : s_pal_indYJK[ind | (*data >> 3) & 30];
348    pixel1 = *(data+1) & 8 ? pal_ind16[*(data+1) >> 4] : s_pal_indYJK[ind | *(data+1) >> 3) & 30];
349    pixel2 = *(data+2) & 8 ? pal_ind16[*(data+2) >> 4] : s_pal_indYJK[ind | *(data+2) >> 3) & 30];
350    pixel3 = *(data+3) & 8 ? pal_ind16[*(data+3) >> 4] : s_pal_indYJK[ind | *(data+3) >> 3) & 30];
337351*/
338352
339353READ8_MEMBER( v99x8_device::read )
340354{
341355   switch (offset & 3)
342356   {
343      case 0:   return vram_r();
344      case 1:   return status_r();
357   case 0:   return vram_r();
358   case 1:   return status_r();
345359   }
346360   return 0xff;
347361}
r15546r15547
350364{
351365   switch (offset & 3)
352366   {
353      case 0:   vram_w(data);      break;
354      case 1:   command_w(data);   break;
355      case 2:   palette_w(data);   break;
356      case 3:   register_w(data);   break;
367   case 0:   vram_w(data);      break;
368   case 1:   command_w(data);   break;
369   case 2:   palette_w(data);   break;
370   case 3:   register_w(data);   break;
357371   }
358372}
359373
r15546r15547
368382
369383   ret = m_read_ahead;
370384
371   if (m_cont_reg[45] & 0x40)
385   if (m_cont_reg[45] & 0x40)  // Expansion memory
372386   {
373387      if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) )
374388         address >>= 1;   // correct?
375      // correct?
376      if (m_vram_exp && address < 0x10000)
377         m_read_ahead = m_vram_exp[address];
389      // Expansion memory only offers 64 K
390      if (m_vram_size > 0x20000 && ((address & 0x10000)==0))
391         m_read_ahead = m_vram_space->read_byte(address + EXPMEM_OFFSET);
378392      else
379393         m_read_ahead = 0xff;
380394   }
381395   else
382396   {
383      m_read_ahead = vram_read (address);
397      m_read_ahead = vram_read(address);
384398   }
385399
386400   m_address_latch = (m_address_latch + 1) & 0x3fff;
r15546r15547
405419
406420   switch (reg)
407421   {
408      case 0:
409         ret = m_stat_reg[0];
410         m_stat_reg[0] &= 0x1f;
411         break;
412      case 1:
413         ret = m_stat_reg[1];
414         m_stat_reg[1] &= 0xfe;
415         if ((m_cont_reg[8] & 0xc0) == 0x80)
416            // mouse mode: add button state
417            ret |= m_button_state & 0xc0;
418         break;
419      case 2:
420         /*update_command ();*/
421/*
422    WTF is this? Whatever this was intended to do, it is nonsensical.
423    Might as well pick a random number....
424    This was an attempt to emulate H-Blank flag ;)
425            n = cycles_currently_ran ();
426            if ( (n < 28) || (n > 199) ) vdp.statReg[2] |= 0x20;
427            else vdp.statReg[2] &= ~0x20;
428*/
429         if (machine().rand() & 1) m_stat_reg[2] |= 0x20;
430         else m_stat_reg[2] &= ~0x20;
431         ret = m_stat_reg[2];
432         break;
433      case 3:
434         if ((m_cont_reg[8] & 0xc0) == 0x80)
435         {   // mouse mode: return x mouse delta
436            ret = m_mx_delta;
437            m_mx_delta = 0;
438         }
439         else
440            ret = m_stat_reg[3];
441         break;
442      case 5:
443         if ((m_cont_reg[8] & 0xc0) == 0x80)
444         {   // mouse mode: return y mouse delta
445            ret = m_my_delta;
446            m_my_delta = 0;
447         }
448         else
449            ret = m_stat_reg[5];
450         break;
451      case 7:
452         ret = m_stat_reg[7];
453         m_stat_reg[7] = m_cont_reg[44] = vdp_to_cpu () ;
454         break;
455      default:
456         ret = m_stat_reg[reg];
457         break;
422   case 0:
423      ret = m_stat_reg[0];
424      m_stat_reg[0] &= 0x1f;
425      break;
426   case 1:
427      ret = m_stat_reg[1];
428      m_stat_reg[1] &= 0xfe;
429      if ((m_cont_reg[8] & 0xc0) == 0x80)
430         // mouse mode: add button state
431      ret |= m_button_state & 0xc0;
432      break;
433   case 2:
434      /*update_command ();*/
435      /*
436        WTF is this? Whatever this was intended to do, it is nonsensical.
437        Might as well pick a random number....
438        This was an attempt to emulate H-Blank flag ;)
439        n = cycles_currently_ran ();
440        if ( (n < 28) || (n > 199) ) vdp.statReg[2] |= 0x20;
441        else vdp.statReg[2] &= ~0x20;
442        */
443      if (machine().rand() & 1) m_stat_reg[2] |= 0x20;
444      else m_stat_reg[2] &= ~0x20;
445      ret = m_stat_reg[2];
446      break;
447   case 3:
448      if ((m_cont_reg[8] & 0xc0) == 0x80)
449      {   // mouse mode: return x mouse delta
450         ret = m_mx_delta;
451         m_mx_delta = 0;
452      }
453      else
454         ret = m_stat_reg[3];
455      break;
456   case 5:
457      if ((m_cont_reg[8] & 0xc0) == 0x80)
458      {   // mouse mode: return y mouse delta
459         ret = m_my_delta;
460         m_my_delta = 0;
461      }
462      else
463         ret = m_stat_reg[5];
464      break;
465   case 7:
466      ret = m_stat_reg[7];
467      m_stat_reg[7] = m_cont_reg[44] = vdp_to_cpu () ;
468      break;
469   default:
470      ret = m_stat_reg[reg];
471      break;
458472   }
459473
460474   LOG(("V9938: Read %02x from S#%d\n", ret, reg));
r15546r15547
475489      m_pal_reg[indexp*2+1] = data & 0x07;
476490      // update palette
477491      m_pal_ind16[indexp] = (((int)m_pal_write << 2) & 0x01c0)  |
478                        (((int)data << 3) & 0x0038)  |
479                        ((int)m_pal_write & 0x0007);
492      (((int)data << 3) & 0x0038)  |
493      ((int)m_pal_write & 0x0007);
480494
481495      m_cont_reg[0x10] = (m_cont_reg[0x10] + 1) & 15;
482496      m_pal_write_first = 0;
r15546r15547
496510
497511   m_cmd_write_first = 0;
498512
499    address = ((int)m_cont_reg[14] << 14) | m_address_latch;
513   address = ((int)m_cont_reg[14] << 14) | m_address_latch;
500514
501    if (m_cont_reg[45] & 0x40)
502        {
515   if (m_cont_reg[45] & 0x40)
516   {
503517      if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) )
504518         address >>= 1;   // correct?
505        if (m_vram_exp && address < 0x10000)
506            m_vram_exp[address] = data;
507        }
508    else
509        {
510      vram_write (address, data);
511        }
519      if (m_vram_size > 0x20000 && ((address & 0x10000)==0))
520         m_vram_space->write_byte(EXPMEM_OFFSET + address, data);
521   }
522   else
523   {
524      vram_write(address, data);
525   }
512526
513527   m_address_latch = (m_address_latch + 1) & 0x3fff;
514528   if ((!m_address_latch) && (m_cont_reg[0] & 0x0c) ) // correct ???
r15546r15547
524538      if (data & 0x80)
525539      {
526540         if (!(data & 0x40))
527         register_write (data & 0x3f, m_cmd_write);
541            register_write (data & 0x3f, m_cmd_write);
528542      }
529543      else
530544      {
531545         m_address_latch =
532            (((UINT16)data << 8) | m_cmd_write) & 0x3fff;
546         (((UINT16)data << 8) | m_cmd_write) & 0x3fff;
533547         if ( !(data & 0x40) ) vram_r (); // read ahead!
534548      }
535549
r15546r15547
548562
549563   reg = m_cont_reg[17] & 0x3f;
550564   if (reg != 17)
551      register_write (reg, data); // true ?
565      register_write(reg, data); // true ?
552566
553567   if (!(m_cont_reg[17] & 0x80))
554568      m_cont_reg[17] = (m_cont_reg[17] + 1) & 0x3f;
r15546r15547
599613   m_screen->register_screen_bitmap(m_bitmap);
600614   m_size_old = -1;
601615
616   // Video RAM is allocated as an own address space
617   m_vram_space = space(AS_DATA);
618
602619   // allocate VRAM
603620   assert(m_vram_size > 0);
604   memset(m_vram, 0, sizeof(m_vram));
621
605622   if (m_vram_size < 0x20000)
606623   {
607624      // set unavailable RAM to 0xff
608      memset (m_vram + m_vram_size, 0xff, (sizeof(m_vram) - m_vram_size) );
625      for (int addr = m_vram_size; addr < 0x30000; addr++) m_vram_space->write_byte(addr, 0xff);
609626   }
610627
611   // do we have expanded memory?
612   if (m_vram_size > 0x20000)
613      m_vram_exp = auto_alloc_array_clear(machine(), UINT8, 0x10000);
614   else
615      m_vram_exp = NULL;
616
617628   save_item(NAME(m_offset_x));
618629   save_item(NAME(m_offset_y));
619630   save_item(NAME(m_visible_y));
r15546r15547
626637   save_item(NAME(m_stat_reg));
627638   save_item(NAME(m_cont_reg));
628639   save_item(NAME(m_read_ahead));
629   save_item(NAME(m_vram));
630   if ( m_vram_exp != NULL )
631      save_pointer(NAME(m_vram_exp), 0x10000);
640   //  save_item(NAME(m_vram));
641   //  if ( m_vram_exp != NULL )
642   //      save_pointer(NAME(m_vram_exp), 0x10000);
632643   save_item(NAME(m_int_state));
633644   save_item(NAME(m_scanline));
634645   save_item(NAME(m_blink));
r15546r15547
695706}
696707
697708
698
699
700709void v99x8_device::reset_palette ()
701   {
710{
702711   // taken from V9938 Technical Data book, page 148. it's in G-R-B format
703712   static const UINT8 pal16[16*3] = {
704713      0, 0, 0, // 0: black/transparent
r15546r15547
743752
744753/***************************************************************************
745754
746    Memory functions
755Memory functions
747756
748757***************************************************************************/
749758
750void v99x8_device::vram_write (int offset, int data)
759void v99x8_device::vram_write(int offset, int data)
751760{
752761   int newoffset;
753762
754763   if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) )
755764   {
756        newoffset = ((offset & 1) << 16) | (offset >> 1);
765      newoffset = ((offset & 1) << 16) | (offset >> 1);
757766      if (newoffset < m_vram_size)
758           m_vram[newoffset] = data;
767         m_vram_space->write_byte(newoffset, data);
759768   }
760769   else
761770   {
762771      if (offset < m_vram_size)
763         m_vram[offset] = data;
764        }
772         m_vram_space->write_byte(offset, data);
773   }
765774}
766775
767int v99x8_device::vram_read (int offset)
776int v99x8_device::vram_read(int offset)
768777{
769778   if ( (m_mode == V9938_MODE_GRAPHIC6) || (m_mode == V9938_MODE_GRAPHIC7) )
770      return m_vram[((offset & 1) << 16) | (offset >> 1)];
779      return m_vram_space->read_byte(((offset & 1) << 16) | (offset >> 1));
771780   else
772      return m_vram[offset];
781      return m_vram_space->read_byte(offset);
773782}
774783
775void v99x8_device::check_int ()
784void v99x8_device::check_int()
776785{
777786   UINT8 n;
778787
779788   n = ( (m_cont_reg[1] & 0x20) && (m_stat_reg[0] & 0x80) /*&& m_vblank_int*/) ||
780      ( (m_stat_reg[1] & 0x01) && (m_cont_reg[0] & 0x10) );
789   ( (m_stat_reg[1] & 0x01) && (m_cont_reg[0] & 0x10) );
781790
782#if 0
791   #if 0
783792   if(n && m_vblank_int)
784793   {
785794      m_vblank_int = 0;
786795   }
787#endif
796   #endif
788797
789798   if (n != m_int_state)
790799   {
r15546r15547
796805    ** Somehow the IRQ request is going down without cpu_irq_line () being
797806    ** called; because of this Mr. Ghost, Xevious and SD Snatcher don't
798807    ** run. As a patch it's called every scanline
799   */
808    */
800809   m_int_callback (*this, n);
801810}
802811
r15546r15547
832841   /*update_command ();*/
833842
834843   switch (reg) {
835   // registers that affect interrupt and display mode
844      // registers that affect interrupt and display mode
836845   case 0:
837846   case 1:
838847      m_cont_reg[reg] = data;
839      set_mode ();
840      check_int ();
841      LOG(("V9938: mode = %s\n", v9938_modes[m_mode]));
848      set_mode();
849      check_int();
850      LOG(("v9938: mode = %s\n", v9938_modes[m_mode]));
842851      break;
843852
844853   case 18:
r15546r15547
862871      m_pal_write_first = 0;
863872      break;
864873
865   // color burst registers aren't emulated
874      // color burst registers aren't emulated
866875   case 20:
867876   case 21:
868877   case 22:
869      LOG(("V9938: Write %02xh to R#%d; color burst not emulated\n",
870         data, reg));
878      LOG(("v9938: Write %02xh to R#%d; color burst not emulated\n", data, reg));
871879      break;
872880   case 25:
873881   case 26:
874882   case 27:
875883      if (m_model != MODEL_V9958)
876884      {
877         LOG(("V9938: Attempting to write %02xh to V9958 R#%d\n", data, reg));
885         LOG(("v9938: Attempting to write %02xh to V9958 R#%d\n", data, reg));
878886         data = 0;
879887      }
880888      break;
r15546r15547
889897   }
890898
891899   if (reg != 15)
892      LOG(("V9938: Write %02x to R#%d\n", data, reg));
900      LOG(("v9938: Write %02x to R#%d\n", data, reg));
893901
894902   m_cont_reg[reg] = data;
895903}
896904
897905/***************************************************************************
898906
899    Refresh / render function
907Refresh / render function
900908
901909***************************************************************************/
902910
903#define V9938_SECOND_FIELD ( !(((m_cont_reg[9] & 0x04) && !(m_stat_reg[2] & 2)) || m_blink))
911inline bool v99x8_device::v9938_second_field()
912{
913   return !(((m_cont_reg[9] & 0x04) && !(m_stat_reg[2] & 2)) || m_blink);
914}
904915
905916/*
906 * This file is included for a number of different situations:
907 * _Width : can be 512 + 32 or 256 + 16
908 * V9938_BPP : can be 8 or 16
909 */
917* This file is included for a number of different situations:
918* _Width : can be 512 + 32 or 256 + 16
919* V9938_BPP : can be 8 or 16
920*/
910921
911922
912923template<typename _PixelType, int _Width>
r15546r15547
963974{
964975   int pattern, x, xx, name, xxx;
965976   _PixelType fg, bg, pen;
966   UINT8 *nametbl, *patterntbl;
977   int nametbl_addr, patterntbl_addr;
967978
968   patterntbl = m_vram + (m_cont_reg[4] << 11);
969   nametbl = m_vram + (m_cont_reg[2] << 10);
979   patterntbl_addr = m_cont_reg[4] << 11;
980   nametbl_addr = m_cont_reg[2] << 10;
970981
971    fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
972    bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
982   fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
983   bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
973984
974985   name = (line/8)*40;
975986
r15546r15547
982993
983994   for (x=0;x<40;x++)
984995   {
985      pattern = patterntbl[(nametbl[name] * 8) +
986         ((line + m_cont_reg[23]) & 7)];
996      pattern = m_vram_space->read_byte(patterntbl_addr + (m_vram_space->read_byte(nametbl_addr + name) * 8) +
997         ((line + m_cont_reg[23]) & 7));
987998      for (xx=0;xx<6;xx++)
988999      {
9891000         *ln++ = (pattern & 0x80) ? fg : bg;
r15546r15547
10071018{
10081019   int pattern, x, charcode, name, xxx, patternmask, colourmask;
10091020   _PixelType fg, bg, fg0, bg0, pen;
1010   UINT8 *nametbl, *patterntbl, *colourtbl;
1021   int nametbl_addr, patterntbl_addr, colourtbl_addr;
10111022
1012   patterntbl = m_vram + (m_cont_reg[4] << 11);
1013   colourtbl = m_vram + ((m_cont_reg[3] & 0xf8) << 6) + (m_cont_reg[10] << 14);
1014#if 0
1023   patterntbl_addr = m_cont_reg[4] << 11;
1024   colourtbl_addr =  ((m_cont_reg[3] & 0xf8) << 6) + (m_cont_reg[10] << 14);
1025   #if 0
10151026   colourmask = ((m_cont_reg[3] & 7) << 5) | 0x1f; /* cause a bug in Forth+ v1.0 on Geneve */
1016#else
1027   #else
10171028   colourmask = ((m_cont_reg[3] & 7) << 6) | 0x3f; /* verify! */
1018#endif
1019   nametbl = m_vram + ((m_cont_reg[2] & 0xfc) << 10);
1029   #endif
1030   nametbl_addr = ((m_cont_reg[2] & 0xfc) << 10);
10201031   patternmask = ((m_cont_reg[2] & 3) << 10) | 0x3ff; /* seems correct */
10211032
1022    fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
1023    bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
1024    fg0 = pens[m_pal_ind16[m_cont_reg[12] >> 4]];
1025    bg0 = pens[m_pal_ind16[m_cont_reg[12] & 15]];
1033   fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
1034   bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
1035   fg0 = pens[m_pal_ind16[m_cont_reg[12] >> 4]];
1036   bg0 = pens[m_pal_ind16[m_cont_reg[12] & 15]];
10261037
10271038   name = (line/8)*80;
10281039
r15546r15547
10341045
10351046   for (x=0;x<80;x++)
10361047   {
1037      charcode = nametbl[name&patternmask];
1048      charcode = m_vram_space->read_byte(nametbl_addr + (name&patternmask));
10381049      if (m_blink)
10391050      {
1040         pattern = colourtbl[(name/8)&colourmask];
1051         pattern = m_vram_space->read_byte(colourtbl_addr + ((name/8)&colourmask));
10411052         if (pattern & (0x80 >> (name & 7) ) )
10421053         {
1043            pattern = patterntbl[(charcode * 8) +
1044               ((line + m_cont_reg[23]) & 7)];
1054            pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode * 8) +
1055               ((line + m_cont_reg[23]) & 7)));
10451056
10461057            if (_Width > 512)
10471058            {
r15546r15547
10641075         }
10651076      }
10661077
1067      pattern = patterntbl[(charcode * 8) +
1068         ((line + m_cont_reg[23]) & 7)];
1078      pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode * 8) +
1079         ((line + m_cont_reg[23]) & 7)));
10691080
10701081      if (_Width > 512)
10711082      {
r15546r15547
10961107template<typename _PixelType, int _Width>
10971108void v99x8_device::mode_multi(const pen_t *pens, _PixelType *ln, int line)
10981109{
1099   UINT8 *nametbl, *patterntbl, colour;
1110   int nametbl_addr, patterntbl_addr, colour;
11001111   int name, line2, x, xx;
11011112   _PixelType pen, pen_bg;
11021113
1103   nametbl = m_vram + (m_cont_reg[2] << 10);
1104   patterntbl = m_vram + (m_cont_reg[4] << 11);
1114   nametbl_addr = (m_cont_reg[2] << 10);
1115   patterntbl_addr = (m_cont_reg[4] << 11);
11051116
11061117   line2 = (line - m_cont_reg[23]) & 255;
11071118   name = (line2/8)*32;
r15546r15547
11151126
11161127   for (x=0;x<32;x++)
11171128   {
1118      colour = patterntbl[(nametbl[name] * 8) + ((line2/4)&7)];
1129      colour = m_vram_space->read_byte(patterntbl_addr + (m_vram_space->read_byte(nametbl_addr + name) * 8) + ((line2/4)&7));
11191130      pen = pens[m_pal_ind16[colour>>4]];
11201131      /* eight pixels */
11211132      *ln++ = pen;
r15546r15547
11561167void v99x8_device::mode_graphic1(const pen_t *pens, _PixelType *ln, int line)
11571168{
11581169   _PixelType fg, bg, pen;
1159   UINT8 *nametbl, *patterntbl, *colourtbl;
1170   int nametbl_addr, patterntbl_addr, colourtbl_addr;
11601171   int pattern, x, xx, line2, name, charcode, colour, xxx;
11611172
1162   nametbl = m_vram + (m_cont_reg[2] << 10);
1163   colourtbl = m_vram + (m_cont_reg[3] << 6) + (m_cont_reg[10] << 14);
1164   patterntbl = m_vram + (m_cont_reg[4] << 11);
1173   nametbl_addr = (m_cont_reg[2] << 10);
1174   colourtbl_addr = (m_cont_reg[3] << 6) + (m_cont_reg[10] << 14);
1175   patterntbl_addr = (m_cont_reg[4] << 11);
11651176
11661177   line2 = (line - m_cont_reg[23]) & 255;
11671178
r15546r15547
11761187
11771188   for (x=0;x<32;x++)
11781189   {
1179      charcode = nametbl[name];
1180      colour = colourtbl[charcode/8];
1190      charcode = m_vram_space->read_byte(nametbl_addr + name);
1191      colour = m_vram_space->read_byte(colourtbl_addr + charcode/8);
11811192      fg = pens[m_pal_ind16[colour>>4]];
11821193      bg = pens[m_pal_ind16[colour&15]];
1183      pattern = patterntbl[charcode * 8 + (line2 & 7)];
1194      pattern = m_vram_space->read_byte(patterntbl_addr + (charcode * 8 + (line2 & 7)));
11841195
11851196      for (xx=0;xx<8;xx++)
11861197      {
r15546r15547
12031214void v99x8_device::mode_graphic23(const pen_t *pens, _PixelType *ln, int line)
12041215{
12051216   _PixelType fg, bg, pen;
1206   UINT8 *nametbl, *patterntbl, *colourtbl;
1217   int nametbl_addr, patterntbl_addr, colourtbl_addr;
12071218   int pattern, x, xx, line2, name, charcode,
1208      colour, colourmask, patternmask, xxx;
1219   colour, colourmask, patternmask, xxx;
12091220
12101221   colourmask = (m_cont_reg[3] & 0x7f) * 8 | 7;
12111222   patternmask = (m_cont_reg[4] & 0x03) * 256 | (colourmask & 255);
12121223
1213   nametbl = m_vram + (m_cont_reg[2] << 10);
1214   colourtbl = m_vram + ((m_cont_reg[3] & 0x80) << 6) + (m_cont_reg[10] << 14);
1215   patterntbl = m_vram + ((m_cont_reg[4] & 0x3c) << 11);
1224   nametbl_addr =  (m_cont_reg[2] << 10);
1225   colourtbl_addr =  ((m_cont_reg[3] & 0x80) << 6) + (m_cont_reg[10] << 14);
1226   patterntbl_addr = ((m_cont_reg[4] & 0x3c) << 11);
12161227
12171228   line2 = (line + m_cont_reg[23]) & 255;
12181229   name = (line2/8)*32;
r15546r15547
12261237
12271238   for (x=0;x<32;x++)
12281239   {
1229      charcode = nametbl[name] + (line2&0xc0)*4;
1230      colour = colourtbl[(charcode&colourmask)*8+(line2&7)];
1231      pattern = patterntbl[(charcode&patternmask)*8+(line2&7)];
1232        fg = pens[m_pal_ind16[colour>>4]];
1233        bg = pens[m_pal_ind16[colour&15]];
1240      charcode = m_vram_space->read_byte(nametbl_addr + name) + (line2&0xc0)*4;
1241      colour = m_vram_space->read_byte(colourtbl_addr + ((charcode&colourmask)*8+(line2&7)));
1242      pattern = m_vram_space->read_byte(patterntbl_addr + ((charcode&patternmask)*8+(line2&7)));
1243      fg = pens[m_pal_ind16[colour>>4]];
1244      bg = pens[m_pal_ind16[colour&15]];
12341245      for (xx=0;xx<8;xx++)
12351246      {
12361247         *ln++ = (pattern & 0x80) ? fg : bg;
12371248         if (_Width > 512)
12381249            *ln++ = (pattern & 0x80) ? fg : bg;
1239            pattern <<= 1;
1250         pattern <<= 1;
12401251      }
12411252      name++;
12421253   }
r15546r15547
12511262template<typename _PixelType, int _Width>
12521263void v99x8_device::mode_graphic4(const pen_t *pens, _PixelType *ln, int line)
12531264{
1254   UINT8 *nametbl, colour;
1265   int nametbl_addr, colour;
12551266   int line2, linemask, x, xx;
12561267   _PixelType pen, pen_bg;
12571268
r15546r15547
12591270
12601271   line2 = ((line + m_cont_reg[23]) & linemask) & 255;
12611272
1262   nametbl = m_vram + ((m_cont_reg[2] & 0x40) << 10) + line2 * 128;
1263   if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) )
1264      nametbl += 0x8000;
1273   nametbl_addr = ((m_cont_reg[2] & 0x40) << 10) + line2 * 128;
1274   if ( (m_cont_reg[2] & 0x20) && v9938_second_field() )
1275      nametbl_addr += 0x8000;
12651276
12661277   pen_bg = pens[m_pal_ind16[(m_cont_reg[7]&0x0f)]];
12671278   if (_Width < 512)
r15546r15547
12721283
12731284   for (x=0;x<128;x++)
12741285   {
1275      colour = *nametbl++;
1276        pen = pens[m_pal_ind16[colour>>4]];
1286      colour = m_vram_space->read_byte(nametbl_addr++);
1287      pen = pens[m_pal_ind16[colour>>4]];
12771288      *ln++ = pen;
12781289      if (_Width > 512)
12791290         *ln++ = pen;
1280        pen = pens[m_pal_ind16[colour&15]];
1291      pen = pens[m_pal_ind16[colour&15]];
12811292      *ln++ = pen;
12821293      if (_Width > 512)
12831294         *ln++ = pen;
r15546r15547
12931304template<typename _PixelType, int _Width>
12941305void v99x8_device::mode_graphic5(const pen_t *pens, _PixelType *ln, int line)
12951306{
1296   UINT8 *nametbl, colour;
1307   int nametbl_addr, colour;
12971308   int line2, linemask, x, xx;
12981309   _PixelType pen_bg0[4];
12991310   _PixelType pen_bg1[4];
r15546r15547
13021313
13031314   line2 = ((line + m_cont_reg[23]) & linemask) & 255;
13041315
1305   nametbl = m_vram + ((m_cont_reg[2] & 0x40) << 10) + line2 * 128;
1306   if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) )
1307      nametbl += 0x8000;
1316   nametbl_addr = ((m_cont_reg[2] & 0x40) << 10) + line2 * 128;
1317   if ( (m_cont_reg[2] & 0x20) && v9938_second_field() )
1318      nametbl_addr += 0x8000;
13081319
13091320   if (_Width > 512)
13101321   {
r15546r15547
13161327
13171328      x = (m_cont_reg[8] & 0x20) ? 0 : 1;
13181329
1319       for (;x<4;x++)
1330      for (;x<4;x++)
13201331      {
13211332         pen_bg0[x] = pens[m_pal_ind16[x]];
13221333         pen_bg1[x] = pens[m_pal_ind16[x]];
r15546r15547
13241335
13251336      for (x=0;x<128;x++)
13261337      {
1327         colour = *nametbl++;
1338         colour = m_vram_space->read_byte(nametbl_addr++);
13281339
1329           *ln++ = pen_bg0[colour>>6];
1340         *ln++ = pen_bg0[colour>>6];
13301341         *ln++ = pen_bg1[(colour>>4)&3];
1331           *ln++ = pen_bg0[(colour>>2)&3];
1332          *ln++ = pen_bg1[(colour&3)];
1342         *ln++ = pen_bg0[(colour>>2)&3];
1343         *ln++ = pen_bg1[(colour&3)];
13331344      }
13341345
13351346      pen_bg1[0] = pens[m_pal_ind16[(m_cont_reg[7]&0x03)]];
r15546r15547
13431354
13441355      x = (m_cont_reg[8] & 0x20) ? 0 : 1;
13451356
1346       for (;x<4;x++)
1357      for (;x<4;x++)
13471358         pen_bg0[x] = pens[m_pal_ind16[x]];
13481359
13491360      xx = m_offset_x;
r15546r15547
13511362
13521363      for (x=0;x<128;x++)
13531364      {
1354         colour = *nametbl++;
1355           *ln++ = pen_bg0[colour>>6];
1356           *ln++ = pen_bg0[(colour>>2)&3];
1365         colour = m_vram_space->read_byte(nametbl_addr++);
1366         *ln++ = pen_bg0[colour>>6];
1367         *ln++ = pen_bg0[(colour>>2)&3];
13571368      }
13581369
13591370      pen_bg0[0] = pens[m_pal_ind16[((m_cont_reg[7]>>2)&0x03)]];
r15546r15547
13661377template<typename _PixelType, int _Width>
13671378void v99x8_device::mode_graphic6(const pen_t *pens, _PixelType *ln, int line)
13681379{
1369    UINT8 colour;
1370    int line2, linemask, x, xx, nametbl;
1371    _PixelType pen_bg, fg0;
1380   UINT8 colour;
1381   int line2, linemask, x, xx, nametbl_addr;
1382   _PixelType pen_bg, fg0;
13721383   _PixelType fg1;
13731384
1374    linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7;
1385   linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7;
13751386
13761387   line2 = ((line + m_cont_reg[23]) & linemask) & 255;
13771388
1378    nametbl = line2 << 8 ;
1379   if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) )
1380        nametbl += 0x10000;
1389   nametbl_addr = line2 << 8 ;
1390   if ( (m_cont_reg[2] & 0x20) && v9938_second_field() )
1391      nametbl_addr += 0x10000;
13811392
13821393   pen_bg = pens[m_pal_ind16[(m_cont_reg[7]&0x0f)]];
13831394   if (_Width < 512)
r15546r15547
13901401   {
13911402      for (x=0;x<32;x++)
13921403      {
1393         nametbl++;
1394         colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)];
1395           fg0 = pens[m_pal_ind16[colour>>4]];
1404         nametbl_addr++;
1405         colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1));
1406         fg0 = pens[m_pal_ind16[colour>>4]];
13961407         if (_Width < 512)
13971408         {
13981409            *ln++ = fg0; *ln++ = fg0;
r15546r15547
14021413         }
14031414         else
14041415         {
1405              fg1 = pens[m_pal_ind16[colour&15]];
1416            fg1 = pens[m_pal_ind16[colour&15]];
14061417            *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1;
14071418            *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1;
14081419            *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1;
14091420            *ln++ = fg0; *ln++ = fg1; *ln++ = fg0; *ln++ = fg1;
14101421         }
1411         nametbl += 7;
1422         nametbl_addr += 7;
14121423      }
14131424   }
14141425   else
14151426   {
14161427      for (x=0;x<256;x++)
14171428      {
1418         colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)];
1419           *ln++ = pens[m_pal_ind16[colour>>4]];
1429         colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1));
1430         *ln++ = pens[m_pal_ind16[colour>>4]];
14201431         if (_Width > 512)
1421              *ln++ = pens[m_pal_ind16[colour&15]];
1422         nametbl++;
1423        }
1432            *ln++ = pens[m_pal_ind16[colour&15]];
1433         nametbl_addr++;
1434      }
14241435   }
14251436
14261437   xx = 16 - m_offset_x;
r15546r15547
14331444template<typename _PixelType, int _Width>
14341445void v99x8_device::mode_graphic7(const pen_t *pens, _PixelType *ln, int line)
14351446{
1436    UINT8 colour;
1437    int line2, linemask, x, xx, nametbl;
1438    _PixelType pen, pen_bg;
1447   UINT8 colour;
1448   int line2, linemask, x, xx, nametbl_addr;
1449   _PixelType pen, pen_bg;
14391450
14401451   linemask = ((m_cont_reg[2] & 0x1f) << 3) | 7;
14411452
14421453   line2 = ((line + m_cont_reg[23]) & linemask) & 255;
14431454
1444   nametbl = line2 << 8;
1445   if ( (m_cont_reg[2] & 0x20) && (V9938_SECOND_FIELD) )
1446      nametbl += 0x10000;
1455   nametbl_addr = line2 << 8;
1456   if ( (m_cont_reg[2] & 0x20) && v9938_second_field() )
1457      nametbl_addr += 0x10000;
14471458
14481459   pen_bg = pens[m_pal_ind256[m_cont_reg[7]]];
14491460   if (_Width < 512)
r15546r15547
14561467   {
14571468      for (x=0;x<32;x++)
14581469      {
1459         nametbl++;
1460         colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)];
1470         nametbl_addr++;
1471         colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1));
14611472         pen = pens[m_pal_ind256[colour]];
14621473         *ln++ = pen; *ln++ = pen;
14631474         *ln++ = pen; *ln++ = pen;
r15546r15547
14701481            *ln++ = pen; *ln++ = pen;
14711482            *ln++ = pen; *ln++ = pen;
14721483         }
1473         nametbl++;
1484         nametbl_addr++;
14741485      }
14751486   }
14761487   else
14771488   {
14781489      for (x=0;x<256;x++)
1479        {
1480         colour = m_vram[((nametbl&1) << 16) | (nametbl>>1)];
1490      {
1491         colour = m_vram_space->read_byte(((nametbl_addr&1) << 16) | (nametbl_addr>>1));
14811492         pen = pens[m_pal_ind256[colour]];
14821493         *ln++ = pen;
14831494         if (_Width > 512)
14841495            *ln++ = pen;
1485         nametbl++;
1486       }
1496         nametbl_addr++;
1497      }
14871498   }
14881499
14891500   xx = 16 - m_offset_x;
r15546r15547
14991510   _PixelType fg, bg;
15001511   int x;
15011512
1502    fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
1503    bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
1513   fg = pens[m_pal_ind16[m_cont_reg[7] >> 4]];
1514   bg = pens[m_pal_ind16[m_cont_reg[7] & 15]];
15041515
15051516   if (_Width < 512)
15061517   {
r15546r15547
15861597{
15871598   static const UINT16 g7_ind16[16] = {
15881599      0, 2, 192, 194, 48, 50, 240, 242,
1589      482, 7, 448, 455, 56, 63, 504, 511  };
1600   482, 7, 448, 455, 56, 63, 504, 511  };
15901601   int i;
15911602
15921603   if (_Width > 512)
r15546r15547
16151626
16161627void v99x8_device::sprite_mode1 (int line, UINT8 *col)
16171628{
1618   UINT8   *attrtbl, *patterntbl, *patternptr;
1629   int   attrtbl_addr, patterntbl_addr, pattern_addr;
16191630   int x, y, p, height, c, p2, i, n, pattern;
16201631
1621   memset (col, 0, 256);
1632   memset(col, 0, 256);
16221633
16231634   // are sprites disabled?
16241635   if (m_cont_reg[8] & 0x02) return;
16251636
1626   attrtbl = m_vram + (m_cont_reg[5] << 7) + (m_cont_reg[11] << 15);
1627   patterntbl = m_vram + (m_cont_reg[6] << 11);
1637   attrtbl_addr = (m_cont_reg[5] << 7) + (m_cont_reg[11] << 15);
1638   patterntbl_addr = (m_cont_reg[6] << 11);
16281639
16291640   // 16x16 or 8x8 sprites
16301641   height = (m_cont_reg[1] & 2) ? 16 : 8;
r15546r15547
16341645   p2 = p = 0;
16351646   while (1)
16361647   {
1637      y = attrtbl[0];
1648      y = m_vram_space->read_byte(attrtbl_addr);
16381649      if (y == 208) break;
16391650      y = (y - m_cont_reg[23]) & 255;
16401651      if (y > 208)
r15546r15547
16541665            if (m_sprite_limit) break;
16551666         }
16561667         // get x
1657         x = attrtbl[1];
1658         if (attrtbl[3] & 0x80) x -= 32;
1668         x = m_vram_space->read_byte(attrtbl_addr + 1);
1669         if (m_vram_space->read_byte(attrtbl_addr + 3) & 0x80) x -= 32;
16591670
16601671         // get pattern
1661         pattern = attrtbl[2];
1672         pattern = m_vram_space->read_byte(attrtbl_addr + 2);
16621673         if (m_cont_reg[1] & 2)
16631674            pattern &= 0xfc;
16641675         n = line - y;
1665         patternptr = patterntbl + pattern * 8 +
1666            ((m_cont_reg[1] & 1) ? n/2  : n);
1667         pattern = patternptr[0] << 8 | patternptr[16];
1676         pattern_addr = patterntbl_addr + pattern * 8 + ((m_cont_reg[1] & 1) ? n/2  : n);
1677         pattern = (m_vram_space->read_byte(pattern_addr) << 8) | m_vram_space->read_byte(pattern_addr+16);
16681678
16691679         // get colour
1670         c = attrtbl[3] & 0x0f;
1680         c = m_vram_space->read_byte(attrtbl_addr + 3) & 0x0f;
16711681
16721682         // draw left part
16731683         n = 0;
16741684         while (1)
16751685         {
1676            if (n == 0) pattern = patternptr[0];
1677            else if ( (n == 1) && (m_cont_reg[1] & 2) ) pattern = patternptr[16];
1686            if (n == 0) pattern = m_vram_space->read_byte(pattern_addr);
1687            else if ( (n == 1) && (m_cont_reg[1] & 2) ) pattern = m_vram_space->read_byte(pattern_addr + 16);
16781688            else break;
16791689
16801690            n++;
r15546r15547
17031713                     if (m_cont_reg[1] & 1)
17041714                     {
17051715                        if (col[x+1] & 0x40)
1706                               {
1707                                 // we have a collision!
1716                        {
1717                           // we have a collision!
17081718                           if (p2 < 4)
17091719                              m_stat_reg[0] |= 0x20;
1710                               }
1711                              if ( !(col[x+1] & 0x80) )
1712                               {
1713                                 if (c || (m_cont_reg[8] & 0x20) )
1720                        }
1721                        if ( !(col[x+1] & 0x80) )
1722                        {
1723                           if (c || (m_cont_reg[8] & 0x20) )
17141724                              col[x+1] |= 0xc0 | c;
17151725                           else
17161726                              col[x+1] |= 0x80;
1717                               }
1727                        }
17181728                     }
17191729                  }
17201730               }
r15546r15547
17281738
17291739      if (p >= 31) break;
17301740      p++;
1731      attrtbl += 4;
1741      attrtbl_addr += 4;
17321742   }
17331743
17341744   if ( !(m_stat_reg[0] & 0x40) )
r15546r15547
17371747
17381748void v99x8_device::sprite_mode2 (int line, UINT8 *col)
17391749{
1740   int attrtbl, patterntbl, patternptr, colourtbl;
1750   int attrtbl_addr, patterntbl_addr, pattern_addr, colourtbl_addr;
17411751   int x, i, y, p, height, c, p2, n, pattern, colourmask, first_cc_seen;
17421752
1743   memset (col, 0, 256);
1753   memset(col, 0, 256);
17441754
17451755   // are sprites disabled?
17461756   if (m_cont_reg[8] & 0x02) return;
17471757
1748   attrtbl = ( (m_cont_reg[5] & 0xfc) << 7) + (m_cont_reg[11] << 15);
1749   colourtbl =  ( (m_cont_reg[5] & 0xf8) << 7) + (m_cont_reg[11] << 15);
1750   patterntbl = (m_cont_reg[6] << 11);
1758   attrtbl_addr = ( (m_cont_reg[5] & 0xfc) << 7) + (m_cont_reg[11] << 15);
1759   colourtbl_addr =  ( (m_cont_reg[5] & 0xf8) << 7) + (m_cont_reg[11] << 15);
1760   patterntbl_addr = (m_cont_reg[6] << 11);
17511761   colourmask = ( (m_cont_reg[5] & 3) << 3) | 0x7; // check this!
17521762
17531763   // 16x16 or 8x8 sprites
r15546r15547
17581768   p2 = p = first_cc_seen = 0;
17591769   while (1)
17601770   {
1761      y = vram_read (attrtbl);
1771      y = vram_read(attrtbl_addr);
17621772      if (y == 216) break;
17631773      y = (y - m_cont_reg[23]) & 255;
17641774      if (y > 216)
r15546r15547
17801790
17811791         n = line - y; if (m_cont_reg[1] & 1) n /= 2;
17821792         // get colour
1783         c = vram_read (colourtbl + (((p&colourmask)*16) + n));
1793         c = vram_read(colourtbl_addr + (((p&colourmask)*16) + n));
17841794
17851795         // don't draw all sprite with CC set before any sprites
1786            // with CC = 0 are seen on this line
1796         // with CC = 0 are seen on this line
17871797         if (c & 0x40)
17881798         {
17891799            if (!first_cc_seen)
r15546r15547
17931803            first_cc_seen = 1;
17941804
17951805         // get pattern
1796         pattern = vram_read (attrtbl + 2);
1806         pattern = vram_read(attrtbl_addr + 2);
17971807         if (m_cont_reg[1] & 2)
17981808            pattern &= 0xfc;
1799         patternptr = patterntbl + pattern * 8 + n;
1800         pattern = (vram_read (patternptr) << 8) |
1801            vram_read (patternptr + 16);
1809         pattern_addr = patterntbl_addr + pattern * 8 + n;
1810         pattern = (vram_read(pattern_addr) << 8) | vram_read(pattern_addr + 16);
18021811
18031812         // get x
1804         x = vram_read (attrtbl + 1);
1813         x = vram_read(attrtbl_addr + 1);
18051814         if (c & 0x80) x -= 32;
18061815
18071816         n = (m_cont_reg[1] & 2) ? 16 : 8;
r15546r15547
18521861            pattern <<= 1;
18531862         }
18541863
1855skip_first_cc_set:
1864      skip_first_cc_set:
18561865         p2++;
18571866      }
18581867
18591868      if (p >= 31) break;
18601869      p++;
1861      attrtbl += 4;
1870      attrtbl_addr += 4;
18621871   }
18631872
18641873   if ( !(m_stat_reg[0] & 0x40) )
r15546r15547
18761885      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
18771886      NULL,
18781887      NULL,
1879      NULL },
1888   NULL },
18801889   { 0x01,
18811890      &v99x8_device::mode_multi<UINT16, LONG_WIDTH>,
18821891      &v99x8_device::mode_multi<UINT16, SHORT_WIDTH>,
r15546r15547
18841893      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
18851894      &v99x8_device::sprite_mode1,
18861895      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1887      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1896   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
18881897   { 0x00,
18891898      &v99x8_device::mode_graphic1<UINT16, LONG_WIDTH>,
18901899      &v99x8_device::mode_graphic1<UINT16, SHORT_WIDTH>,
r15546r15547
18921901      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
18931902      &v99x8_device::sprite_mode1,
18941903      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1895      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1904   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
18961905   { 0x04,
18971906      &v99x8_device::mode_graphic23<UINT16, LONG_WIDTH>,
18981907      &v99x8_device::mode_graphic23<UINT16, SHORT_WIDTH>,
r15546r15547
19001909      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19011910      &v99x8_device::sprite_mode1,
19021911      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1903      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1912   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
19041913   { 0x08,
19051914      &v99x8_device::mode_graphic23<UINT16, LONG_WIDTH>,
19061915      &v99x8_device::mode_graphic23<UINT16, SHORT_WIDTH>,
r15546r15547
19081917      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19091918      &v99x8_device::sprite_mode2,
19101919      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1911      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1920   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
19121921   { 0x0c,
19131922      &v99x8_device::mode_graphic4<UINT16, LONG_WIDTH>,
19141923      &v99x8_device::mode_graphic4<UINT16, SHORT_WIDTH>,
r15546r15547
19161925      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19171926      &v99x8_device::sprite_mode2,
19181927      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1919      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1928   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
19201929   { 0x10,
19211930      &v99x8_device::mode_graphic5<UINT16, LONG_WIDTH>,
19221931      &v99x8_device::mode_graphic5<UINT16, SHORT_WIDTH>,
r15546r15547
19241933      &v99x8_device::graphic5_border<UINT16, SHORT_WIDTH>,
19251934      &v99x8_device::sprite_mode2,
19261935      &v99x8_device::graphic5_draw_sprite<UINT16, LONG_WIDTH>,
1927      &v99x8_device::graphic5_draw_sprite<UINT16, SHORT_WIDTH> },
1936   &v99x8_device::graphic5_draw_sprite<UINT16, SHORT_WIDTH> },
19281937   { 0x14,
19291938      &v99x8_device::mode_graphic6<UINT16, LONG_WIDTH>,
19301939      &v99x8_device::mode_graphic6<UINT16, SHORT_WIDTH>,
r15546r15547
19321941      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19331942      &v99x8_device::sprite_mode2,
19341943      &v99x8_device::default_draw_sprite<UINT16, LONG_WIDTH>,
1935      &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
1944   &v99x8_device::default_draw_sprite<UINT16, SHORT_WIDTH> },
19361945   { 0x1c,
19371946      &v99x8_device::mode_graphic7<UINT16, LONG_WIDTH>,
19381947      &v99x8_device::mode_graphic7<UINT16, SHORT_WIDTH>,
r15546r15547
19401949      &v99x8_device::graphic7_border<UINT16, SHORT_WIDTH>,
19411950      &v99x8_device::sprite_mode2,
19421951      &v99x8_device::graphic7_draw_sprite<UINT16, LONG_WIDTH>,
1943      &v99x8_device::graphic7_draw_sprite<UINT16, SHORT_WIDTH> },
1952   &v99x8_device::graphic7_draw_sprite<UINT16, SHORT_WIDTH> },
19441953   { 0x0a,
19451954      &v99x8_device::mode_text2<UINT16, LONG_WIDTH>,
19461955      &v99x8_device::mode_text2<UINT16, SHORT_WIDTH>,
r15546r15547
19481957      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19491958      NULL,
19501959      NULL,
1951      NULL },
1960   NULL },
19521961   { 0xff,
19531962      &v99x8_device::mode_unknown<UINT16, LONG_WIDTH>,
19541963      &v99x8_device::mode_unknown<UINT16, SHORT_WIDTH>,
r15546r15547
19561965      &v99x8_device::default_border<UINT16, SHORT_WIDTH>,
19571966      NULL,
19581967      NULL,
1959      NULL },
1968   NULL },
19601969};
19611970
1962void v99x8_device::set_mode ()
1971void v99x8_device::set_mode()
19631972{
19641973   int n,i;
19651974
r15546r15547
19711980   m_mode = i;
19721981}
19731982
1974void v99x8_device::refresh_16 (int line)
1983void v99x8_device::refresh_16(int line)
19751984{
19761985   const pen_t *pens = machine().pens;
19771986   int i, double_lines;
r15546r15547
20312040      memcpy (ln2, ln, (512 + 32) * 2);
20322041}
20332042
2034void v99x8_device::refresh_line (int line)
2043void v99x8_device::refresh_line(int line)
20352044{
20362045   int ind16, ind256;
20372046
r15546r15547
21582167have to test.
21592168*/
21602169
2161void v99x8_device::interrupt_start_vblank ()
2170void v99x8_device::interrupt_start_vblank()
21622171{
2163#if 0
2172   #if 0
21642173   if (machine.input().code_pressed (KEYCODE_D) )
21652174   {
2166      FILE *fp;
2167      int i;
2168
2169      fp = fopen ("vram.dmp", "wb");
2170      if (fp)
2171      {
2172         fwrite (m_vram, 0x10000, 1, fp);
2173         fclose (fp);
2174         popmessage("saved");
2175      }
2176
21772175      for (i=0;i<24;i++) mame_printf_debug ("R#%d = %02x\n", i, m_cont_reg[i]);
21782176   }
2179#endif
2177   #endif
21802178
21812179   // at every frame, vdp switches fields
21822180   m_stat_reg[2] = (m_stat_reg[2] & 0xfd) | (~m_stat_reg[2] & 2);
r15546r15547
22202218
22212219/***************************************************************************
22222220
2223    Command unit
2221Command unit
22242222
22252223***************************************************************************/
22262224
2227#define VDP m_cont_reg
2228#define VDPStatus m_stat_reg
2229#define VRAM m_vram
2230#define VRAM_EXP m_vram_exp
2231#define ScrMode m_mode
2232
22332225/*************************************************************/
22342226/** Completely rewritten by Alex Wulms:                     **/
22352227/**  - VDP Command execution 'in parallel' with CPU         **/
r15546r15547
22482240/** Public release 1.0: 20-04-2000                          **/
22492241/*************************************************************/
22502242
2251#define VDP_VRMP5(MX, X, Y) ((!MX) ? (VRAM + ((Y&1023)<<7) + ((X&255)>>1)) : (VRAM_EXP + ((Y&511)<<7) + ((X&255)>>1)))
2252#define VDP_VRMP6(MX, X, Y) ((!MX) ? (VRAM + ((Y&1023)<<7) + ((X&511)>>2)) : (VRAM_EXP + ((Y&511)<<7) + ((X&511)>>2)))
2253//#define VDP_VRMP7(MX, X, Y) ((!MX) ? (VRAM + ((Y&511)<<8) + ((X&511)>>1)) : (VRAM_EXP + ((Y&255)<<8) + ((X&511)>>1)))
2254#define VDP_VRMP7(MX, X, Y) ((!MX) ? (VRAM + ((X&2)<<15) + ((Y&511)<<7) + ((X&511)>>2)) : (VRAM_EXP + ((Y&511)<<7) + ((X&511)>>2))/*(VRAM_EXP + ((Y&255)<<8) + ((X&511)>>1))*/)
2255//#define VDP_VRMP8(MX, X, Y) ((!MX) ? (VRAM + ((Y&511)<<8) + (X&255)) : (VRAM_EXP + ((Y&255)<<8) + (X&255)))
2256#define VDP_VRMP8(MX, X, Y) ((!MX) ? (VRAM + ((X&1)<<16) + ((Y&511)<<7) + ((X>>1)&127)) : (VRAM_EXP + ((Y&511)<<7) + ((X>>1)&127))/*(VRAM_EXP + ((Y&255)<<8) + (X&255))*/)
2243#define VDP_VRMP5(MX, X, Y) ((!MX) ? (((Y&1023)<<7) + ((X&255)>>1)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&255)>>1)))
2244#define VDP_VRMP6(MX, X, Y) ((!MX) ? (((Y&1023)<<7) + ((X&511)>>2)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&511)>>2)))
2245//#define VDP_VRMP7(MX, X, Y) ((!MX) ? (((Y&511)<<8) + ((X&511)>>1)) : (EXPMEM_OFFSET + ((Y&255)<<8) + ((X&511)>>1)))
2246#define VDP_VRMP7(MX, X, Y) ((!MX) ? (((X&2)<<15) + ((Y&511)<<7) + ((X&511)>>2)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X&511)>>2))/*(EXPMEM_OFFSET + ((Y&255)<<8) + ((X&511)>>1))*/)
2247//#define VDP_VRMP8(MX, X, Y) ((!MX) ? (((Y&511)<<8) + (X&255)) : (EXPMEM_OFFSET + ((Y&255)<<8) + (X&255)))
2248#define VDP_VRMP8(MX, X, Y) ((!MX) ? (((X&1)<<16) + ((Y&511)<<7) + ((X>>1)&127)) : (EXPMEM_OFFSET + ((Y&511)<<7) + ((X>>1)&127))/*(EXPMEM_OFFSET + ((Y&255)<<8) + (X&255))*/)
22572249
22582250#define VDP_VRMP(M, MX, X, Y) VDPVRMP(M, MX, X, Y)
22592251#define VDP_POINT(M, MX, X, Y) VDPpoint(M, MX, X, Y)
r15546r15547
22732265#define CM_YMMM  0xE
22742266#define CM_HMMC  0xF
22752267
2276/*************************************************************/
2277// Many VDP commands are executed in some kind of loop but
2278// essentially, there are only a few basic loop structures
2279// that are re-used. We define the loop structures that are
2280// re-used here so that they have to be entered only once
2281/*************************************************************/
2268/*************************************************************
2269Many VDP commands are executed in some kind of loop but
2270essentially, there are only a few basic loop structures
2271that are re-used. We define the loop structures that are
2272re-used here so that they have to be entered only once
2273*************************************************************/
22822274#define pre_loop \
2283    while ((cnt-=delta) > 0) {
2275while ((cnt-=delta) > 0) {
22842276
2285#define post_loop \
2286    }
2277   #define post_loop \
2278}
22872279
22882280// Loop over DX, DY
22892281#define post__x_y(MX) \
2290    if (!--ANX || ((ADX+=TX)&MX)) { \
2291      if (!(--NY&1023) || (DY+=TY)==-1) \
2282if (!--ANX || ((ADX+=TX)&MX)) { \
2283   if (!(--NY&1023) || (DY+=TY)==-1) \
22922284        break; \
2293      else { \
2285    else { \
22942286        ADX=DX; \
22952287        ANX=NX; \
2296      } \
22972288    } \
2298  post_loop
2289} \
2290post_loop
22992291
23002292// Loop over DX, SY, DY
23012293#define post__xyy(MX) \
2302    if ((ADX+=TX)&MX) { \
2303      if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \
2294if ((ADX+=TX)&MX) { \
2295   if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \
23042296        break; \
2305      else \
2297    else \
23062298        ADX=DX; \
2307    } \
2308  post_loop
2299} \
2300post_loop
23092301
23102302// Loop over SX, DX, SY, DY
23112303#define post_xxyy(MX) \
2312    if (!--ANX || ((ASX+=TX)&MX) || ((ADX+=TX)&MX)) { \
2313      if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \
2304if (!--ANX || ((ASX+=TX)&MX) || ((ADX+=TX)&MX)) { \
2305   if (!(--NY&1023) || (SY+=TY)==-1 || (DY+=TY)==-1) \
23142306        break; \
2315      else { \
2307    else { \
23162308        ASX=SX; \
23172309        ADX=DX; \
23182310        ANX=NX; \
2319      } \
23202311    } \
2321  post_loop
2312} \
2313post_loop
23222314
23232315/*************************************************************/
23242316/** Variables visible only in this module                   **/
r15546r15547
23302322//  SprOn SprOn SprOf SprOf
23312323//  ScrOf ScrOn ScrOf ScrOn
23322324static const int srch_timing[8]={
2333  818, 1025,  818,  830, // ntsc
2334  696,  854,  696,  684  // pal
2325   818, 1025,  818,  830, // ntsc
2326   696,  854,  696,  684  // pal
23352327};
23362328static const int line_timing[8]={
2337  1063, 1259, 1063, 1161,
2338  904,  1026, 904,  953
2329   1063, 1259, 1063, 1161,
2330   904,  1026, 904,  953
23392331};
23402332static const int hmmv_timing[8]={
2341  439,  549,  439,  531,
2342  366,  439,  366,  427
2333   439,  549,  439,  531,
2334   366,  439,  366,  427
23432335};
23442336static const int lmmv_timing[8]={
2345  873,  1135, 873, 1056,
2346  732,  909,  732,  854
2337   873,  1135, 873, 1056,
2338   732,  909,  732,  854
23472339};
23482340static const int ymmm_timing[8]={
2349  586,  952,  586,  610,
2350  488,  720,  488,  500
2341   586,  952,  586,  610,
2342   488,  720,  488,  500
23512343};
23522344static const int hmmm_timing[8]={
2353  818,  1111, 818,  854,
2354  684,  879,  684,  708
2345   818,  1111, 818,  854,
2346   684,  879,  684,  708
23552347};
23562348static const int lmmm_timing[8]={
2357  1160, 1599, 1160, 1172,
2358  964,  1257, 964,  977
2349   1160, 1599, 1160, 1172,
2350   964,  1257, 964,  977
23592351};
23602352
23612353/** VDPVRMP() **********************************************/
23622354/** Calculate addr of a pixel in vram                       **/
23632355/*************************************************************/
2364inline UINT8 *v99x8_device::VDPVRMP(UINT8 M,int MX,int X,int Y)
2356inline int v99x8_device::VDPVRMP(UINT8 M,int MX,int X,int Y)
23652357{
2366  switch(M)
2367  {
2368    case 0: return VDP_VRMP5(MX,X,Y);
2369    case 1: return VDP_VRMP6(MX,X,Y);
2370    case 2: return VDP_VRMP7(MX,X,Y);
2371    case 3: return VDP_VRMP8(MX,X,Y);
2372  }
2358   switch(M)
2359   {
2360   case 0: return VDP_VRMP5(MX,X,Y);
2361   case 1: return VDP_VRMP6(MX,X,Y);
2362   case 2: return VDP_VRMP7(MX,X,Y);
2363   case 3: return VDP_VRMP8(MX,X,Y);
2364   }
23732365
2374  return(VRAM);
2366   return 0;
23752367}
23762368
23772369/** VDPpoint5() ***********************************************/
r15546r15547
23792371/*************************************************************/
23802372inline UINT8 v99x8_device::VDPpoint5(int MXS, int SX, int SY)
23812373{
2382  return (*VDP_VRMP5(MXS, SX, SY) >>
2383          (((~SX)&1)<<2)
2384         )&15;
2374   return (m_vram_space->read_byte(VDP_VRMP5(MXS, SX, SY)) >>
2375      (((~SX)&1)<<2)
2376      )&15;
23852377}
23862378
23872379/** VDPpoint6() ***********************************************/
r15546r15547
23892381/*************************************************************/
23902382inline UINT8 v99x8_device::VDPpoint6(int MXS, int SX, int SY)
23912383{
2392  return (*VDP_VRMP6(MXS, SX, SY) >>
2393          (((~SX)&3)<<1)
2394         )&3;
2384   return (m_vram_space->read_byte(VDP_VRMP6(MXS, SX, SY)) >>
2385      (((~SX)&3)<<1)
2386      )&3;
23952387}
23962388
23972389/** VDPpoint7() ***********************************************/
r15546r15547
23992391/*************************************************************/
24002392inline UINT8 v99x8_device::VDPpoint7(int MXS, int SX, int SY)
24012393{
2402  return (*VDP_VRMP7(MXS, SX, SY) >>
2403          (((~SX)&1)<<2)
2404         )&15;
2394   return (m_vram_space->read_byte(VDP_VRMP7(MXS, SX, SY)) >>
2395      (((~SX)&1)<<2)
2396      )&15;
24052397}
24062398
24072399/** VDPpoint8() ***********************************************/
r15546r15547
24092401/*************************************************************/
24102402inline UINT8 v99x8_device::VDPpoint8(int MXS, int SX, int SY)
24112403{
2412  return *VDP_VRMP8(MXS, SX, SY);
2404   return m_vram_space->read_byte(VDP_VRMP8(MXS, SX, SY));
24132405}
24142406
24152407/** VDPpoint() ************************************************/
r15546r15547
24172409/*************************************************************/
24182410inline UINT8 v99x8_device::VDPpoint(UINT8 SM, int MXS, int SX, int SY)
24192411{
2420  switch(SM)
2421  {
2422    case 0: return VDPpoint5(MXS,SX,SY);
2423    case 1: return VDPpoint6(MXS,SX,SY);
2424    case 2: return VDPpoint7(MXS,SX,SY);
2425    case 3: return VDPpoint8(MXS,SX,SY);
2426  }
2412   switch(SM)
2413   {
2414   case 0: return VDPpoint5(MXS,SX,SY);
2415   case 1: return VDPpoint6(MXS,SX,SY);
2416   case 2: return VDPpoint7(MXS,SX,SY);
2417   case 3: return VDPpoint8(MXS,SX,SY);
2418   }
24272419
2428  return(0);
2420   return(0);
24292421}
24302422
24312423/** VDPpsetlowlevel() ****************************************/
24322424/** Low level function to set a pixel on a screen           **/
24332425/** Make it inline to make it fast                          **/
24342426/*************************************************************/
2435inline void v99x8_device::VDPpsetlowlevel(UINT8 *P, UINT8 CL, UINT8 M, UINT8 OP)
2427inline void v99x8_device::VDPpsetlowlevel(int addr, UINT8 CL, UINT8 M, UINT8 OP)
24362428{
2437  switch (OP)
2438  {
2439    case 0: *P = (*P & M) | CL; break;
2440    case 1: *P = *P & (CL | M); break;
2441    case 2: *P |= CL; break;
2442    case 3: *P ^= CL; break;
2443    case 4: *P = (*P & M) | ~(CL | M); break;
2444    case 8: if (CL) *P = (*P & M) | CL; break;
2445    case 9: if (CL) *P = *P & (CL | M); break;
2446    case 10: if (CL) *P |= CL; break;
2447    case 11:  if (CL) *P ^= CL; break;
2448    case 12:  if (CL) *P = (*P & M) | ~(CL|M); break;
2449  }
2429   // If this turns out to be too slow, get a pointer to the address space
2430   // and work directly on it.
2431   UINT8 val = m_vram_space->read_byte(addr);
2432   switch (OP)
2433   {
2434   case 0: val = (val & M) | CL; break;
2435   case 1: val = val & (CL | M); break;
2436   case 2: val |= CL; break;
2437   case 3: val ^= CL; break;
2438   case 4: val = (val & M) | ~(CL | M); break;
2439   case 8: if (CL) val = (val & M) | CL; break;
2440   case 9: if (CL) val = val & (CL | M); break;
2441   case 10: if (CL) val |= CL; break;
2442   case 11:  if (CL) val ^= CL; break;
2443   case 12:  if (CL) val = (val & M) | ~(CL|M); break;
2444   default:
2445      LOG(("v9938: invalid operation %d in pset\n", OP));
2446   }
2447
2448   m_vram_space->write_byte(addr, val);
24502449}
24512450
24522451/** VDPpset5() ***********************************************/
r15546r15547
24542453/*************************************************************/
24552454inline void v99x8_device::VDPpset5(int MXD, int DX, int DY, UINT8 CL, UINT8 OP)
24562455{
2457  UINT8 SH = ((~DX)&1)<<2;
2458
2459  VDPpsetlowlevel(VDP_VRMP5(MXD, DX, DY),
2460                  CL << SH, ~(15<<SH), OP);
2456   UINT8 SH = ((~DX)&1)<<2;
2457   VDPpsetlowlevel(VDP_VRMP5(MXD, DX, DY), CL << SH, ~(15<<SH), OP);
24612458}
24622459
24632460/** VDPpset6() ***********************************************/
r15546r15547
24652462/*************************************************************/
24662463inline void v99x8_device::VDPpset6(int MXD, int DX, int DY, UINT8 CL, UINT8 OP)
24672464{
2468  UINT8 SH = ((~DX)&3)<<1;
2465   UINT8 SH = ((~DX)&3)<<1;
24692466
2470  VDPpsetlowlevel(VDP_VRMP6(MXD, DX, DY),
2471                  CL << SH, ~(3<<SH), OP);
2467   VDPpsetlowlevel(VDP_VRMP6(MXD, DX, DY), CL << SH, ~(3<<SH), OP);
24722468}
24732469
24742470/** VDPpset7() ***********************************************/
r15546r15547
24762472/*************************************************************/
24772473inline void v99x8_device::VDPpset7(int MXD, int DX, int DY, UINT8 CL, UINT8 OP)
24782474{
2479  UINT8 SH = ((~DX)&1)<<2;
2475   UINT8 SH = ((~DX)&1)<<2;
24802476
2481  VDPpsetlowlevel(VDP_VRMP7(MXD, DX, DY),
2482                  CL << SH, ~(15<<SH), OP);
2477   VDPpsetlowlevel(VDP_VRMP7(MXD, DX, DY), CL << SH, ~(15<<SH), OP);
24832478}
24842479
24852480/** VDPpset8() ***********************************************/
r15546r15547
24872482/*************************************************************/
24882483inline void v99x8_device::VDPpset8(int MXD, int DX, int DY, UINT8 CL, UINT8 OP)
24892484{
2490  VDPpsetlowlevel(VDP_VRMP8(MXD, DX, DY),
2491                  CL, 0, OP);
2485   VDPpsetlowlevel(VDP_VRMP8(MXD, DX, DY), CL, 0, OP);
24922486}
24932487
24942488/** VDPpset() ************************************************/
r15546r15547
24962490/*************************************************************/
24972491inline void v99x8_device::VDPpset(UINT8 SM, int MXD, int DX, int DY, UINT8 CL, UINT8 OP)
24982492{
2499  switch (SM) {
2493   switch (SM) {
25002494    case 0: VDPpset5(MXD, DX, DY, CL, OP); break;
25012495    case 1: VDPpset6(MXD, DX, DY, CL, OP); break;
25022496    case 2: VDPpset7(MXD, DX, DY, CL, OP); break;
25032497    case 3: VDPpset8(MXD, DX, DY, CL, OP); break;
2504  }
2498    }
25052499}
25062500
2507/** GetVdpTimingValue() **************************************/
2501/** get_vdp_timing_value() **************************************/
25082502/** Get timing value for a certain VDP command              **/
25092503/*************************************************************/
2510int v99x8_device::GetVdpTimingValue(const int *timing_values)
2504int v99x8_device::get_vdp_timing_value(const int *timing_values)
25112505{
2512  return(timing_values[((VDP[1]>>6)&1)|(VDP[8]&2)|((VDP[9]<<1)&4)]);
2506   return(timing_values[((m_cont_reg[1]>>6)&1)|(m_cont_reg[8]&2)|((m_cont_reg[9]<<1)&4)]);
25132507}
25142508
25152509/** SrchEgine()** ********************************************/
25162510/** Search a dot                                            **/
25172511/*************************************************************/
2518void v99x8_device::SrchEngine()
2512void v99x8_device::srch_engine()
25192513{
2520  int SX=m_mmc.SX;
2521  int SY=m_mmc.SY;
2522  int TX=m_mmc.TX;
2523  int ANX=m_mmc.ANX;
2524  UINT8 CL=m_mmc.CL;
2525  int MXD = m_mmc.MXD;
2526  int cnt;
2527  int delta;
2514   int SX=m_mmc.SX;
2515   int SY=m_mmc.SY;
2516   int TX=m_mmc.TX;
2517   int ANX=m_mmc.ANX;
2518   UINT8 CL=m_mmc.CL;
2519   int MXD = m_mmc.MXD;
2520   int cnt;
2521   int delta;
25282522
2529  delta = GetVdpTimingValue(srch_timing);
2530  cnt = m_vdp_ops_count;
2523   delta = get_vdp_timing_value(srch_timing);
2524   cnt = m_vdp_ops_count;
25312525
2532#define pre_srch \
2533    pre_loop \
2534      if ((
2535#define post_srch(MX) \
2536           ==CL) ^ANX) { \
2537      VDPStatus[2]|=0x10; /* Border detected */\
2538      break; \
2539    } \
2540    if ((SX+=TX) & MX) { \
2541      VDPStatus[2]&=0xEF; /* Border not detected */\
2542      break; \
2543    } \
2544  post_loop
2526   #define post_srch(MX) \
2527   { m_stat_reg[2]|=0x10; /* Border detected */ break; } \
2528   if ((SX+=TX) & MX) { m_stat_reg[2] &= 0xEF; /* Border not detected */ break; } \
25452529
2546  switch (ScrMode) {
2547    default:
2548    case 5: pre_srch VDPpoint5(MXD, SX, SY) post_srch(256)
2549            break;
2550    case 6: pre_srch VDPpoint6(MXD, SX, SY) post_srch(512)
2551            break;
2552    case 7: pre_srch VDPpoint7(MXD, SX, SY) post_srch(512)
2553            break;
2554    case 8: pre_srch VDPpoint8(MXD, SX, SY) post_srch(256)
2555            break;
2556  }
2530   switch (m_mode) {
2531   default:
2532   case V9938_MODE_GRAPHIC4: pre_loop if ((VDPpoint5(MXD, SX, SY)==CL) ^ANX)  post_srch(256) post_loop
2533         break;
2534   case V9938_MODE_GRAPHIC5: pre_loop if ((VDPpoint6(MXD, SX, SY)==CL) ^ANX)  post_srch(512) post_loop
2535         break;
2536   case V9938_MODE_GRAPHIC6: pre_loop if ((VDPpoint7(MXD, SX, SY)==CL) ^ANX)  post_srch(512) post_loop
2537         break;
2538   case V9938_MODE_GRAPHIC7: pre_loop if ((VDPpoint8(MXD, SX, SY)==CL) ^ANX)  post_srch(256) post_loop
2539         break;
2540   }
25572541
2558  if ((m_vdp_ops_count=cnt)>0) {
2559    // Command execution done
2560    VDPStatus[2]&=0xFE;
2561    m_vdp_engine=0;
2562    // Update SX in VDP registers
2563    VDPStatus[8]=SX&0xFF;
2564    VDPStatus[9]=(SX>>8)|0xFE;
2565  }
2566  else {
2567    m_mmc.SX=SX;
2568  }
2542   if ((m_vdp_ops_count=cnt)>0) {
2543      // Command execution done
2544      m_stat_reg[2] &= 0xFE;
2545      m_vdp_engine = 0;
2546      // Update SX in VDP registers
2547      m_stat_reg[8] = SX & 0xFF;
2548      m_stat_reg[9] = (SX>>8) | 0xFE;
2549   }
2550   else {
2551      m_mmc.SX=SX;
2552   }
25692553}
25702554
25712555/** LineEgine()** ********************************************/
25722556/** Draw a line                                             **/
25732557/*************************************************************/
2574void v99x8_device::LineEngine()
2558void v99x8_device::line_engine()
25752559{
2576  int DX=m_mmc.DX;
2577  int DY=m_mmc.DY;
2578  int TX=m_mmc.TX;
2579  int TY=m_mmc.TY;
2580  int NX=m_mmc.NX;
2581  int NY=m_mmc.NY;
2582  int ASX=m_mmc.ASX;
2583  int ADX=m_mmc.ADX;
2584  UINT8 CL=m_mmc.CL;
2585  UINT8 LO=m_mmc.LO;
2586  int MXD = m_mmc.MXD;
2587  int cnt;
2588  int delta;
2560   int DX=m_mmc.DX;
2561   int DY=m_mmc.DY;
2562   int TX=m_mmc.TX;
2563   int TY=m_mmc.TY;
2564   int NX=m_mmc.NX;
2565   int NY=m_mmc.NY;
2566   int ASX=m_mmc.ASX;
2567   int ADX=m_mmc.ADX;
2568   UINT8 CL=m_mmc.CL;
2569   UINT8 LO=m_mmc.LO;
2570   int MXD = m_mmc.MXD;
2571   int cnt;
2572   int delta;
25892573
2590  delta = GetVdpTimingValue(line_timing);
2591  cnt = m_vdp_ops_count;
2574   delta = get_vdp_timing_value(line_timing);
2575   cnt = m_vdp_ops_count;
25922576
2593#define post_linexmaj(MX) \
2594      DX+=TX; \
2595      if ((ASX-=NY)<0) { \
2596        ASX+=NX; \
2597        DY+=TY; \
2598      } \
2599      ASX&=1023; /* Mask to 10 bits range */\
2600      if (ADX++==NX || (DX&MX)) \
2601        break; \
2602    post_loop
2577   #define post_linexmaj(MX) \
2578   DX+=TX; \
2579   if ((ASX-=NY)<0) { \
2580      ASX+=NX; \
2581      DY+=TY; \
2582   } \
2583   ASX&=1023; /* Mask to 10 bits range */\
2584   if (ADX++==NX || (DX&MX)) \
2585      break; \
2586   post_loop
26032587
2604#define post_lineymaj(MX) \
2605      DY+=TY; \
2606      if ((ASX-=NY)<0) { \
2607        ASX+=NX; \
2608        DX+=TX; \
2609      } \
2610      ASX&=1023; /* Mask to 10 bits range */\
2611      if (ADX++==NX || (DX&MX)) \
2612        break; \
2613    post_loop
2588   #define post_lineymaj(MX) \
2589   DY+=TY; \
2590   if ((ASX-=NY)<0) { \
2591      ASX+=NX; \
2592      DX+=TX; \
2593   } \
2594   ASX&=1023; /* Mask to 10 bits range */\
2595   if (ADX++==NX || (DX&MX)) \
2596      break; \
2597   post_loop
26142598
2615  if ((VDP[45]&0x01)==0)
2616    // X-Axis is major direction
2617    switch (ScrMode) {
2618      default:
2619      case 5: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_linexmaj(256)
2620              break;
2621      case 6: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_linexmaj(512)
2622              break;
2623      case 7: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_linexmaj(512)
2624              break;
2625      case 8: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_linexmaj(256)
2626              break;
2627    }
2628  else
2629    // Y-Axis is major direction
2630    switch (ScrMode) {
2631      default:
2632      case 5: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_lineymaj(256)
2633              break;
2634      case 6: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_lineymaj(512)
2635              break;
2636      case 7: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_lineymaj(512)
2637              break;
2638      case 8: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_lineymaj(256)
2639              break;
2640    }
2599   if ((m_cont_reg[45]&0x01)==0)
2600      // X-Axis is major direction
2601   switch (m_mode) {
2602   default:
2603   case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_linexmaj(256)
2604      break;
2605   case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_linexmaj(512)
2606      break;
2607   case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_linexmaj(512)
2608      break;
2609   case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_linexmaj(256)
2610      break;
2611   }
2612   else
2613      // Y-Axis is major direction
2614   switch (m_mode) {
2615   default:
2616   case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, DX, DY, CL, LO); post_lineymaj(256)
2617      break;
2618   case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, DX, DY, CL, LO); post_lineymaj(512)
2619      break;
2620   case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, DX, DY, CL, LO); post_lineymaj(512)
2621      break;
2622   case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, DX, DY, CL, LO); post_lineymaj(256)
2623      break;
2624   }
26412625
2642  if ((m_vdp_ops_count=cnt)>0) {
2643    // Command execution done
2644    VDPStatus[2]&=0xFE;
2645    m_vdp_engine=0;
2646    VDP[38]=DY & 0xFF;
2647    VDP[39]=(DY>>8) & 0x03;
2648  }
2649  else {
2650    m_mmc.DX=DX;
2651    m_mmc.DY=DY;
2652    m_mmc.ASX=ASX;
2653    m_mmc.ADX=ADX;
2654  }
2626   if ((m_vdp_ops_count=cnt)>0) {
2627      // Command execution done
2628      m_stat_reg[2]&=0xFE;
2629      m_vdp_engine=0;
2630      m_cont_reg[38]=DY & 0xFF;
2631      m_cont_reg[39]=(DY>>8) & 0x03;
2632   }
2633   else {
2634      m_mmc.DX=DX;
2635      m_mmc.DY=DY;
2636      m_mmc.ASX=ASX;
2637      m_mmc.ADX=ADX;
2638   }
26552639}
26562640
2657/** LmmvEngine() *********************************************/
2641/** lmmv_engine() *********************************************/
26582642/** VDP -> Vram                                             **/
26592643/*************************************************************/
2660void v99x8_device::LmmvEngine()
2644void v99x8_device::lmmv_engine()
26612645{
2662  int DX=m_mmc.DX;
2663  int DY=m_mmc.DY;
2664  int TX=m_mmc.TX;
2665  int TY=m_mmc.TY;
2666  int NX=m_mmc.NX;
2667  int NY=m_mmc.NY;
2668  int ADX=m_mmc.ADX;
2669  int ANX=m_mmc.ANX;
2670  UINT8 CL=m_mmc.CL;
2671  UINT8 LO=m_mmc.LO;
2672  int MXD = m_mmc.MXD;
2673  int cnt;
2674  int delta;
2646   int DX=m_mmc.DX;
2647   int DY=m_mmc.DY;
2648   int TX=m_mmc.TX;
2649   int TY=m_mmc.TY;
2650   int NX=m_mmc.NX;
2651   int NY=m_mmc.NY;
2652   int ADX=m_mmc.ADX;
2653   int ANX=m_mmc.ANX;
2654   UINT8 CL=m_mmc.CL;
2655   UINT8 LO=m_mmc.LO;
2656   int MXD = m_mmc.MXD;
2657   int cnt;
2658   int delta;
26752659
2676  delta = GetVdpTimingValue(lmmv_timing);
2677  cnt = m_vdp_ops_count;
2660   delta = get_vdp_timing_value(lmmv_timing);
2661   cnt = m_vdp_ops_count;
26782662
2679  switch (ScrMode) {
2680    default:
2681    case 5: pre_loop VDPpset5(MXD, ADX, DY, CL, LO); post__x_y(256)
2682            break;
2683    case 6: pre_loop VDPpset6(MXD, ADX, DY, CL, LO); post__x_y(512)
2684            break;
2685    case 7: pre_loop VDPpset7(MXD, ADX, DY, CL, LO); post__x_y(512)
2686            break;
2687    case 8: pre_loop VDPpset8(MXD, ADX, DY, CL, LO); post__x_y(256)
2688            break;
2689  }
2663   switch (m_mode) {
2664   default:
2665   case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, ADX, DY, CL, LO); post__x_y(256)
2666      break;
2667   case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, ADX, DY, CL, LO); post__x_y(512)
2668      break;
2669   case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, ADX, DY, CL, LO); post__x_y(512)
2670      break;
2671   case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, ADX, DY, CL, LO); post__x_y(256)
2672      break;
2673   }
26902674
2691  if ((m_vdp_ops_count=cnt)>0) {
2692    // Command execution done
2693    VDPStatus[2]&=0xFE;
2694    m_vdp_engine=0;
2695    if (!NY)
2696      DY+=TY;
2697    VDP[38]=DY & 0xFF;
2698    VDP[39]=(DY>>8) & 0x03;
2699    VDP[42]=NY & 0xFF;
2700    VDP[43]=(NY>>8) & 0x03;
2701  }
2702  else {
2703    m_mmc.DY=DY;
2704    m_mmc.NY=NY;
2705    m_mmc.ANX=ANX;
2706    m_mmc.ADX=ADX;
2707  }
2675   if ((m_vdp_ops_count=cnt)>0) {
2676      // Command execution done
2677      m_stat_reg[2]&=0xFE;
2678      m_vdp_engine=0;
2679      if (!NY)
2680         DY+=TY;
2681      m_cont_reg[38]=DY & 0xFF;
2682      m_cont_reg[39]=(DY>>8) & 0x03;
2683      m_cont_reg[42]=NY & 0xFF;
2684      m_cont_reg[43]=(NY>>8) & 0x03;
2685   }
2686   else {
2687      m_mmc.DY=DY;
2688      m_mmc.NY=NY;
2689      m_mmc.ANX=ANX;
2690      m_mmc.ADX=ADX;
2691   }
27082692}
27092693
2710/** LmmmEngine() *********************************************/
2694/** lmmm_engine() *********************************************/
27112695/** Vram -> Vram                                            **/
27122696/*************************************************************/
2713void v99x8_device::LmmmEngine()
2697void v99x8_device::lmmm_engine()
27142698{
2715  int SX=m_mmc.SX;
2716  int SY=m_mmc.SY;
2717  int DX=m_mmc.DX;
2718  int DY=m_mmc.DY;
2719  int TX=m_mmc.TX;
2720  int TY=m_mmc.TY;
2721  int NX=m_mmc.NX;
2722  int NY=m_mmc.NY;
2723  int ASX=m_mmc.ASX;
2724  int ADX=m_mmc.ADX;
2725  int ANX=m_mmc.ANX;
2726  UINT8 LO=m_mmc.LO;
2727  int MXS = m_mmc.MXS;
2728  int MXD = m_mmc.MXD;
2729  int cnt;
2730  int delta;
2699   int SX=m_mmc.SX;
2700   int SY=m_mmc.SY;
2701   int DX=m_mmc.DX;
2702   int DY=m_mmc.DY;
2703   int TX=m_mmc.TX;
2704   int TY=m_mmc.TY;
2705   int NX=m_mmc.NX;
2706   int NY=m_mmc.NY;
2707   int ASX=m_mmc.ASX;
2708   int ADX=m_mmc.ADX;
2709   int ANX=m_mmc.ANX;
2710   UINT8 LO=m_mmc.LO;
2711   int MXS = m_mmc.MXS;
2712   int MXD = m_mmc.MXD;
2713   int cnt;
2714   int delta;
27312715
2732  delta = GetVdpTimingValue(lmmm_timing);
2733  cnt = m_vdp_ops_count;
2716   delta = get_vdp_timing_value(lmmm_timing);
2717   cnt = m_vdp_ops_count;
27342718
2735  switch (ScrMode) {
2736    default:
2737    case 5: pre_loop VDPpset5(MXD, ADX, DY, VDPpoint5(MXS, ASX, SY), LO); post_xxyy(256)
2738            break;
2739    case 6: pre_loop VDPpset6(MXD, ADX, DY, VDPpoint6(MXS, ASX, SY), LO); post_xxyy(512)
2740            break;
2741    case 7: pre_loop VDPpset7(MXD, ADX, DY, VDPpoint7(MXS, ASX, SY), LO); post_xxyy(512)
2742            break;
2743    case 8: pre_loop VDPpset8(MXD, ADX, DY, VDPpoint8(MXS, ASX, SY), LO); post_xxyy(256)
2744            break;
2745  }
2719   switch (m_mode) {
2720   default:
2721   case V9938_MODE_GRAPHIC4: pre_loop VDPpset5(MXD, ADX, DY, VDPpoint5(MXS, ASX, SY), LO); post_xxyy(256)
2722      break;
2723   case V9938_MODE_GRAPHIC5: pre_loop VDPpset6(MXD, ADX, DY, VDPpoint6(MXS, ASX, SY), LO); post_xxyy(512)
2724      break;
2725   case V9938_MODE_GRAPHIC6: pre_loop VDPpset7(MXD, ADX, DY, VDPpoint7(MXS, ASX, SY), LO); post_xxyy(512)
2726      break;
2727   case V9938_MODE_GRAPHIC7: pre_loop VDPpset8(MXD, ADX, DY, VDPpoint8(MXS, ASX, SY), LO); post_xxyy(256)
2728      break;
2729   }
27462730
2747  if ((m_vdp_ops_count=cnt)>0) {
2748    // Command execution done
2749    VDPStatus[2]&=0xFE;
2750    m_vdp_engine=0;
2751    if (!NY) {
2752      SY+=TY;
2753      DY+=TY;
2754    }
2755    else
2756      if (SY==-1)
2757        DY+=TY;
2758    VDP[42]=NY & 0xFF;
2759    VDP[43]=(NY>>8) & 0x03;
2760    VDP[34]=SY & 0xFF;
2761    VDP[35]=(SY>>8) & 0x03;
2762    VDP[38]=DY & 0xFF;
2763    VDP[39]=(DY>>8) & 0x03;
2764  }
2765  else {
2766    m_mmc.SY=SY;
2767    m_mmc.DY=DY;
2768    m_mmc.NY=NY;
2769    m_mmc.ANX=ANX;
2770    m_mmc.ASX=ASX;
2771    m_mmc.ADX=ADX;
2772  }
2731   if ((m_vdp_ops_count=cnt)>0) {
2732      // Command execution done
2733      m_stat_reg[2]&=0xFE;
2734      m_vdp_engine=0;
2735      if (!NY) {
2736         SY+=TY;
2737         DY+=TY;
2738      }
2739      else
2740         if (SY==-1)
2741         DY+=TY;
2742      m_cont_reg[42]=NY & 0xFF;
2743      m_cont_reg[43]=(NY>>8) & 0x03;
2744      m_cont_reg[34]=SY & 0xFF;
2745      m_cont_reg[35]=(SY>>8) & 0x03;
2746      m_cont_reg[38]=DY & 0xFF;
2747      m_cont_reg[39]=(DY>>8) & 0x03;
2748   }
2749   else {
2750      m_mmc.SY=SY;
2751      m_mmc.DY=DY;
2752      m_mmc.NY=NY;
2753      m_mmc.ANX=ANX;
2754      m_mmc.ASX=ASX;
2755      m_mmc.ADX=ADX;
2756   }
27732757}
27742758
2775/** LmcmEngine() *********************************************/
2759/** lmcm_engine() *********************************************/
27762760/** Vram -> CPU                                             **/
27772761/*************************************************************/
2778void v99x8_device::LmcmEngine()
2762void v99x8_device::lmcm_engine()
27792763{
2780  if ((VDPStatus[2]&0x80)!=0x80) {
2764   if ((m_stat_reg[2]&0x80)!=0x80) {
27812765
2782    VDPStatus[7]=VDP[44]=VDP_POINT(((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0, m_mmc.MXS, m_mmc.ASX, m_mmc.SY);
2783    m_vdp_ops_count-=GetVdpTimingValue(lmmv_timing);
2784    VDPStatus[2]|=0x80;
2766      m_stat_reg[7]=m_cont_reg[44]=VDP_POINT(((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0, m_mmc.MXS, m_mmc.ASX, m_mmc.SY);
2767      m_vdp_ops_count-=get_vdp_timing_value(lmmv_timing);
2768      m_stat_reg[2]|=0x80;
27852769
2786    if (!--m_mmc.ANX || ((m_mmc.ASX+=m_mmc.TX)&m_mmc.MX)) {
2787      if (!(--m_mmc.NY & 1023) || (m_mmc.SY+=m_mmc.TY)==-1) {
2788        VDPStatus[2]&=0xFE;
2789        m_vdp_engine=0;
2790        if (!m_mmc.NY)
2791          m_mmc.DY+=m_mmc.TY;
2792        VDP[42]=m_mmc.NY & 0xFF;
2793        VDP[43]=(m_mmc.NY>>8) & 0x03;
2794        VDP[34]=m_mmc.SY & 0xFF;
2795        VDP[35]=(m_mmc.SY>>8) & 0x03;
2796      }
2797      else {
2798        m_mmc.ASX=m_mmc.SX;
2799        m_mmc.ANX=m_mmc.NX;
2800      }
2801    }
2802  }
2770      if (!--m_mmc.ANX || ((m_mmc.ASX+=m_mmc.TX)&m_mmc.MX)) {
2771         if (!(--m_mmc.NY & 1023) || (m_mmc.SY+=m_mmc.TY)==-1) {
2772            m_stat_reg[2]&=0xFE;
2773            m_vdp_engine=0;
2774            if (!m_mmc.NY)
2775               m_mmc.DY+=m_mmc.TY;
2776            m_cont_reg[42]=m_mmc.NY & 0xFF;
2777            m_cont_reg[43]=(m_mmc.NY>>8) & 0x03;
2778            m_cont_reg[34]=m_mmc.SY & 0xFF;
2779            m_cont_reg[35]=(m_mmc.SY>>8) & 0x03;
2780         }
2781         else {
2782            m_mmc.ASX=m_mmc.SX;
2783            m_mmc.ANX=m_mmc.NX;
2784         }
2785      }
2786   }
28032787}
28042788
2805/** LmmcEngine() *********************************************/
2789/** lmmc_engine() *********************************************/
28062790/** CPU -> Vram                                             **/
28072791/*************************************************************/
2808void v99x8_device::LmmcEngine()
2792void v99x8_device::lmmc_engine()
28092793{
2810  if ((VDPStatus[2]&0x80)!=0x80) {
2811    UINT8 SM=((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0;
2794   if ((m_stat_reg[2]&0x80)!=0x80) {
2795      UINT8 SM=((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0;
28122796
2813    VDPStatus[7]=VDP[44]&=Mask[SM];
2814    VDP_PSET(SM, m_mmc.MXD, m_mmc.ADX, m_mmc.DY, VDP[44], m_mmc.LO);
2815    m_vdp_ops_count-=GetVdpTimingValue(lmmv_timing);
2816    VDPStatus[2]|=0x80;
2797      m_stat_reg[7]=m_cont_reg[44]&=Mask[SM];
2798      VDP_PSET(SM, m_mmc.MXD, m_mmc.ADX, m_mmc.DY, m_cont_reg[44], m_mmc.LO);
2799      m_vdp_ops_count-=get_vdp_timing_value(lmmv_timing);
2800      m_stat_reg[2]|=0x80;
28172801
2818    if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) {
2819      if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) {
2820        VDPStatus[2]&=0xFE;
2821        m_vdp_engine=0;
2822        if (!m_mmc.NY)
2823          m_mmc.DY+=m_mmc.TY;
2824        VDP[42]=m_mmc.NY & 0xFF;
2825        VDP[43]=(m_mmc.NY>>8) & 0x03;
2826        VDP[38]=m_mmc.DY & 0xFF;
2827        VDP[39]=(m_mmc.DY>>8) & 0x03;
2828      }
2829      else {
2830        m_mmc.ADX=m_mmc.DX;
2831        m_mmc.ANX=m_mmc.NX;
2832      }
2833    }
2834  }
2802      if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) {
2803         if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) {
2804            m_stat_reg[2]&=0xFE;
2805            m_vdp_engine=0;
2806            if (!m_mmc.NY)
2807               m_mmc.DY+=m_mmc.TY;
2808            m_cont_reg[42]=m_mmc.NY & 0xFF;
2809            m_cont_reg[43]=(m_mmc.NY>>8) & 0x03;
2810            m_cont_reg[38]=m_mmc.DY & 0xFF;
2811            m_cont_reg[39]=(m_mmc.DY>>8) & 0x03;
2812         }
2813         else {
2814            m_mmc.ADX=m_mmc.DX;
2815            m_mmc.ANX=m_mmc.NX;
2816         }
2817      }
2818   }
28352819}
28362820
2837/** HmmvEngine() *********************************************/
2821/** hmmv_engine() *********************************************/
28382822/** VDP --> Vram                                            **/
28392823/*************************************************************/
2840void v99x8_device::HmmvEngine()
2824void v99x8_device::hmmv_engine()
28412825{
2842  int DX=m_mmc.DX;
2843  int DY=m_mmc.DY;
2844  int TX=m_mmc.TX;
2845  int TY=m_mmc.TY;
2846  int NX=m_mmc.NX;
2847  int NY=m_mmc.NY;
2848  int ADX=m_mmc.ADX;
2849  int ANX=m_mmc.ANX;
2850  UINT8 CL=m_mmc.CL;
2851  int MXD = m_mmc.MXD;
2852  int cnt;
2853  int delta;
2826   int DX=m_mmc.DX;
2827   int DY=m_mmc.DY;
2828   int TX=m_mmc.TX;
2829   int TY=m_mmc.TY;
2830   int NX=m_mmc.NX;
2831   int NY=m_mmc.NY;
2832   int ADX=m_mmc.ADX;
2833   int ANX=m_mmc.ANX;
2834   UINT8 CL=m_mmc.CL;
2835   int MXD = m_mmc.MXD;
2836   int cnt;
2837   int delta;
28542838
2855  delta = GetVdpTimingValue(hmmv_timing);
2856  cnt = m_vdp_ops_count;
2839   delta = get_vdp_timing_value(hmmv_timing);
2840   cnt = m_vdp_ops_count;
28572841
2858  switch (ScrMode) {
2842   switch (m_mode) {
28592843    default:
2860    case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = CL; post__x_y(256)
2861            break;
2862    case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = CL; post__x_y(512)
2863            break;
2864    case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = CL; post__x_y(512)
2865            break;
2866    case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = CL; post__x_y(256)
2867            break;
2868  }
2844    case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), CL); post__x_y(256)
2845       break;
2846    case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), CL); post__x_y(512)
2847       break;
2848    case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), CL); post__x_y(512)
2849       break;
2850    case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), CL); post__x_y(256)
2851       break;
2852    }
28692853
2870  if ((m_vdp_ops_count=cnt)>0) {
2871    // Command execution done
2872    VDPStatus[2]&=0xFE;
2873    m_vdp_engine=0;
2874    if (!NY)
2875      DY+=TY;
2876    VDP[42]=NY & 0xFF;
2877    VDP[43]=(NY>>8) & 0x03;
2878    VDP[38]=DY & 0xFF;
2879    VDP[39]=(DY>>8) & 0x03;
2880  }
2881  else {
2882    m_mmc.DY=DY;
2883    m_mmc.NY=NY;
2884    m_mmc.ANX=ANX;
2885    m_mmc.ADX=ADX;
2886  }
2854    if ((m_vdp_ops_count=cnt)>0) {
2855       // Command execution done
2856       m_stat_reg[2]&=0xFE;
2857       m_vdp_engine=0;
2858       if (!NY)
2859          DY+=TY;
2860       m_cont_reg[42]=NY & 0xFF;
2861       m_cont_reg[43]=(NY>>8) & 0x03;
2862       m_cont_reg[38]=DY & 0xFF;
2863       m_cont_reg[39]=(DY>>8) & 0x03;
2864    }
2865    else {
2866       m_mmc.DY=DY;
2867       m_mmc.NY=NY;
2868       m_mmc.ANX=ANX;
2869       m_mmc.ADX=ADX;
2870    }
28872871}
28882872
2889/** HmmmEngine() *********************************************/
2873/** hmmm_engine() *********************************************/
28902874/** Vram -> Vram                                            **/
28912875/*************************************************************/
2892void v99x8_device::HmmmEngine()
2876void v99x8_device::hmmm_engine()
28932877{
2894  int SX=m_mmc.SX;
2895  int SY=m_mmc.SY;
2896  int DX=m_mmc.DX;
2897  int DY=m_mmc.DY;
2898  int TX=m_mmc.TX;
2899  int TY=m_mmc.TY;
2900  int NX=m_mmc.NX;
2901  int NY=m_mmc.NY;
2902  int ASX=m_mmc.ASX;
2903  int ADX=m_mmc.ADX;
2904  int ANX=m_mmc.ANX;
2905  int MXS = m_mmc.MXS;
2906  int MXD = m_mmc.MXD;
2907  int cnt;
2908  int delta;
2878   int SX=m_mmc.SX;
2879   int SY=m_mmc.SY;
2880   int DX=m_mmc.DX;
2881   int DY=m_mmc.DY;
2882   int TX=m_mmc.TX;
2883   int TY=m_mmc.TY;
2884   int NX=m_mmc.NX;
2885   int NY=m_mmc.NY;
2886   int ASX=m_mmc.ASX;
2887   int ADX=m_mmc.ADX;
2888   int ANX=m_mmc.ANX;
2889   int MXS = m_mmc.MXS;
2890   int MXD = m_mmc.MXD;
2891   int cnt;
2892   int delta;
29092893
2910  delta = GetVdpTimingValue(hmmm_timing);
2911  cnt = m_vdp_ops_count;
2894   delta = get_vdp_timing_value(hmmm_timing);
2895   cnt = m_vdp_ops_count;
29122896
2913  switch (ScrMode) {
2914    default:
2915    case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = *VDP_VRMP5(MXS, ASX, SY); post_xxyy(256)
2916            break;
2917    case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = *VDP_VRMP6(MXS, ASX, SY); post_xxyy(512)
2918            break;
2919    case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = *VDP_VRMP7(MXS, ASX, SY); post_xxyy(512)
2920            break;
2921    case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = *VDP_VRMP8(MXS, ASX, SY); post_xxyy(256)
2922            break;
2923  }
2897   switch (m_mode) {
2898   default:
2899   case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP5(MXS, ASX, SY))); post_xxyy(256)
2900      break;
2901   case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP6(MXS, ASX, SY))); post_xxyy(512)
2902      break;
2903   case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP7(MXS, ASX, SY))); post_xxyy(512)
2904      break;
2905   case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP8(MXS, ASX, SY))); post_xxyy(256)
2906      break;
2907   }
29242908
2925  if ((m_vdp_ops_count=cnt)>0) {
2926    // Command execution done
2927    VDPStatus[2]&=0xFE;
2928    m_vdp_engine=0;
2929    if (!NY) {
2930      SY+=TY;
2931      DY+=TY;
2932    }
2933    else
2934      if (SY==-1)
2935        DY+=TY;
2936    VDP[42]=NY & 0xFF;
2937    VDP[43]=(NY>>8) & 0x03;
2938    VDP[34]=SY & 0xFF;
2939    VDP[35]=(SY>>8) & 0x03;
2940    VDP[38]=DY & 0xFF;
2941    VDP[39]=(DY>>8) & 0x03;
2942  }
2943  else {
2944    m_mmc.SY=SY;
2945    m_mmc.DY=DY;
2946    m_mmc.NY=NY;
2947    m_mmc.ANX=ANX;
2948    m_mmc.ASX=ASX;
2949    m_mmc.ADX=ADX;
2950  }
2909   if ((m_vdp_ops_count=cnt)>0) {
2910      // Command execution done
2911      m_stat_reg[2]&=0xFE;
2912      m_vdp_engine=0;
2913      if (!NY) {
2914         SY+=TY;
2915         DY+=TY;
2916      }
2917      else
2918         if (SY==-1)
2919         DY+=TY;
2920      m_cont_reg[42]=NY & 0xFF;
2921      m_cont_reg[43]=(NY>>8) & 0x03;
2922      m_cont_reg[34]=SY & 0xFF;
2923      m_cont_reg[35]=(SY>>8) & 0x03;
2924      m_cont_reg[38]=DY & 0xFF;
2925      m_cont_reg[39]=(DY>>8) & 0x03;
2926   }
2927   else {
2928      m_mmc.SY=SY;
2929      m_mmc.DY=DY;
2930      m_mmc.NY=NY;
2931      m_mmc.ANX=ANX;
2932      m_mmc.ASX=ASX;
2933      m_mmc.ADX=ADX;
2934   }
29512935}
29522936
2953/** YmmmEngine() *********************************************/
2937/** ymmm_engine() *********************************************/
29542938/** Vram -> Vram                                            **/
29552939/*************************************************************/
2956void v99x8_device::YmmmEngine()
2940
2941void v99x8_device::ymmm_engine()
29572942{
2958  int SY=m_mmc.SY;
2959  int DX=m_mmc.DX;
2960  int DY=m_mmc.DY;
2961  int TX=m_mmc.TX;
2962  int TY=m_mmc.TY;
2963  int NY=m_mmc.NY;
2964  int ADX=m_mmc.ADX;
2965  int MXD = m_mmc.MXD;
2966  int cnt;
2967  int delta;
2943   int SY=m_mmc.SY;
2944   int DX=m_mmc.DX;
2945   int DY=m_mmc.DY;
2946   int TX=m_mmc.TX;
2947   int TY=m_mmc.TY;
2948   int NY=m_mmc.NY;
2949   int ADX=m_mmc.ADX;
2950   int MXD = m_mmc.MXD;
2951   int cnt;
2952   int delta;
29682953
2969  delta = GetVdpTimingValue(ymmm_timing);
2970  cnt = m_vdp_ops_count;
2954   delta = get_vdp_timing_value(ymmm_timing);
2955   cnt = m_vdp_ops_count;
29712956
2972  switch (ScrMode) {
2973    default:
2974    case 5: pre_loop *VDP_VRMP5(MXD, ADX, DY) = *VDP_VRMP5(MXD, ADX, SY); post__xyy(256)
2975            break;
2976    case 6: pre_loop *VDP_VRMP6(MXD, ADX, DY) = *VDP_VRMP6(MXD, ADX, SY); post__xyy(512)
2977            break;
2978    case 7: pre_loop *VDP_VRMP7(MXD, ADX, DY) = *VDP_VRMP7(MXD, ADX, SY); post__xyy(512)
2979            break;
2980    case 8: pre_loop *VDP_VRMP8(MXD, ADX, DY) = *VDP_VRMP8(MXD, ADX, SY); post__xyy(256)
2981            break;
2982  }
2957   switch (m_mode) {
2958   default:
2959   case V9938_MODE_GRAPHIC4: pre_loop m_vram_space->write_byte(VDP_VRMP5(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP5(MXD, ADX, SY))); post__xyy(256)
2960      break;
2961   case V9938_MODE_GRAPHIC5: pre_loop m_vram_space->write_byte(VDP_VRMP6(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP6(MXD, ADX, SY))); post__xyy(512)
2962      break;
2963   case V9938_MODE_GRAPHIC6: pre_loop m_vram_space->write_byte(VDP_VRMP7(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP7(MXD, ADX, SY))); post__xyy(512)
2964      break;
2965   case V9938_MODE_GRAPHIC7: pre_loop m_vram_space->write_byte(VDP_VRMP8(MXD, ADX, DY), m_vram_space->read_byte(VDP_VRMP8(MXD, ADX, SY))); post__xyy(256)
2966      break;
2967   }
29832968
2984  if ((m_vdp_ops_count=cnt)>0) {
2985    // Command execution done
2986    VDPStatus[2]&=0xFE;
2987    m_vdp_engine=0;
2988    if (!NY) {
2989      SY+=TY;
2990      DY+=TY;
2991    }
2992    else
2993      if (SY==-1)
2994        DY+=TY;
2995    VDP[42]=NY & 0xFF;
2996    VDP[43]=(NY>>8) & 0x03;
2997    VDP[34]=SY & 0xFF;
2998    VDP[35]=(SY>>8) & 0x03;
2999    VDP[38]=DY & 0xFF;
3000    VDP[39]=(DY>>8) & 0x03;
3001  }
3002  else {
3003    m_mmc.SY=SY;
3004    m_mmc.DY=DY;
3005    m_mmc.NY=NY;
3006    m_mmc.ADX=ADX;
3007  }
2969   if ((m_vdp_ops_count=cnt)>0) {
2970      // Command execution done
2971      m_stat_reg[2]&=0xFE;
2972      m_vdp_engine=0;
2973      if (!NY) {
2974         SY+=TY;
2975         DY+=TY;
2976      }
2977      else
2978         if (SY==-1)
2979         DY+=TY;
2980      m_cont_reg[42]=NY & 0xFF;
2981      m_cont_reg[43]=(NY>>8) & 0x03;
2982      m_cont_reg[34]=SY & 0xFF;
2983      m_cont_reg[35]=(SY>>8) & 0x03;
2984      m_cont_reg[38]=DY & 0xFF;
2985      m_cont_reg[39]=(DY>>8) & 0x03;
2986   }
2987   else {
2988      m_mmc.SY=SY;
2989      m_mmc.DY=DY;
2990      m_mmc.NY=NY;
2991      m_mmc.ADX=ADX;
2992   }
30082993}
30092994
3010/** HmmcEngine() *********************************************/
2995/** hmmc_engine() *********************************************/
30112996/** CPU -> Vram                                             **/
30122997/*************************************************************/
3013void v99x8_device::HmmcEngine()
2998void v99x8_device::hmmc_engine()
30142999{
3015  if ((VDPStatus[2]&0x80)!=0x80) {
3000   if ((m_stat_reg[2]&0x80)!=0x80) {
30163001
3017    *VDP_VRMP(((ScrMode >= 5) && (ScrMode <= 8)) ? (ScrMode-5) : 0, m_mmc.MXD, m_mmc.ADX, m_mmc.DY)=VDP[44];
3018    m_vdp_ops_count-=GetVdpTimingValue(hmmv_timing);
3019    VDPStatus[2]|=0x80;
3002      m_vram_space->write_byte(VDP_VRMP(((m_mode >= 5) && (m_mode <= 8)) ? (m_mode-5) : 0, m_mmc.MXD, m_mmc.ADX, m_mmc.DY), m_cont_reg[44]);
3003      m_vdp_ops_count -= get_vdp_timing_value(hmmv_timing);
3004      m_stat_reg[2]|=0x80;
30203005
3021    if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) {
3022      if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) {
3023        VDPStatus[2]&=0xFE;
3024        m_vdp_engine=0;
3025        if (!m_mmc.NY)
3026          m_mmc.DY+=m_mmc.TY;
3027        VDP[42]=m_mmc.NY & 0xFF;
3028        VDP[43]=(m_mmc.NY>>8) & 0x03;
3029        VDP[38]=m_mmc.DY & 0xFF;
3030        VDP[39]=(m_mmc.DY>>8) & 0x03;
3031      }
3032      else {
3033        m_mmc.ADX=m_mmc.DX;
3034        m_mmc.ANX=m_mmc.NX;
3035      }
3036    }
3037  }
3006      if (!--m_mmc.ANX || ((m_mmc.ADX+=m_mmc.TX)&m_mmc.MX)) {
3007         if (!(--m_mmc.NY&1023) || (m_mmc.DY+=m_mmc.TY)==-1) {
3008            m_stat_reg[2]&=0xFE;
3009            m_vdp_engine=0;
3010            if (!m_mmc.NY)
3011               m_mmc.DY+=m_mmc.TY;
3012            m_cont_reg[42]=m_mmc.NY & 0xFF;
3013            m_cont_reg[43]=(m_mmc.NY>>8) & 0x03;
3014            m_cont_reg[38]=m_mmc.DY & 0xFF;
3015            m_cont_reg[39]=(m_mmc.DY>>8) & 0x03;
3016         }
3017         else {
3018            m_mmc.ADX=m_mmc.DX;
3019            m_mmc.ANX=m_mmc.NX;
3020         }
3021      }
3022   }
30383023}
30393024
30403025/** VDPWrite() ***********************************************/
30413026/** Use this function to transfer pixel(s) from CPU to m_ **/
30423027/*************************************************************/
3043void v99x8_device::cpu_to_vdp (UINT8 V)
3028void v99x8_device::cpu_to_vdp(UINT8 V)
30443029{
3045  VDPStatus[2]&=0x7F;
3046  VDPStatus[7]=VDP[44]=V;
3047  if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3030   m_stat_reg[2]&=0x7F;
3031   m_stat_reg[7]=m_cont_reg[44]=V;
3032   if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
30483033}
30493034
30503035/** VDPRead() ************************************************/
30513036/** Use this function to transfer pixel(s) from VDP to CPU. **/
30523037/*************************************************************/
3053UINT8 v99x8_device::vdp_to_cpu ()
3038UINT8 v99x8_device::vdp_to_cpu()
30543039{
3055  VDPStatus[2]&=0x7F;
3056  if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3057  return(VDP[44]);
3040   m_stat_reg[2]&=0x7F;
3041   if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3042   return(m_cont_reg[44]);
30583043}
30593044
3060/** ReportVdpCommand() ***************************************/
3045/** report_vdp_command() ***************************************/
30613046/** Report VDP Command to be executed                       **/
30623047/*************************************************************/
3063void v99x8_device::ReportVdpCommand(UINT8 Op)
3048void v99x8_device::report_vdp_command(UINT8 Op)
30643049{
30653050   static const char *const Ops[16] =
30663051   {
r15546r15547
30773062   int SX,SY, DX,DY, NX,NY;
30783063
30793064   // Fetch arguments
3080   CL = VDP[44];
3081   SX = (VDP[32]+((int)VDP[33]<<8)) & 511;
3082   SY = (VDP[34]+((int)VDP[35]<<8)) & 1023;
3083   DX = (VDP[36]+((int)VDP[37]<<8)) & 511;
3084   DY = (VDP[38]+((int)VDP[39]<<8)) & 1023;
3085   NX = (VDP[40]+((int)VDP[41]<<8)) & 1023;
3086   NY = (VDP[42]+((int)VDP[43]<<8)) & 1023;
3065   CL = m_cont_reg[44];
3066   SX = (m_cont_reg[32]+((int)m_cont_reg[33]<<8)) & 511;
3067   SY = (m_cont_reg[34]+((int)m_cont_reg[35]<<8)) & 1023;
3068   DX = (m_cont_reg[36]+((int)m_cont_reg[37]<<8)) & 511;
3069   DY = (m_cont_reg[38]+((int)m_cont_reg[39]<<8)) & 1023;
3070   NX = (m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023;
3071   NY = (m_cont_reg[42]+((int)m_cont_reg[43]<<8)) & 1023;
30873072   CM = Op>>4;
30883073   LO = Op&0x0F;
30893074
30903075   LOG(("V9938: Opcode %02Xh %s-%s (%d,%d)->(%d,%d),%d [%d,%d]%s\n",
3091         Op, Commands[CM], Ops[LO],
3092         SX,SY, DX,DY, CL, VDP[45]&0x04? -NX:NX,
3093         VDP[45]&0x08? -NY:NY,
3094         VDP[45]&0x70? " on ExtVRAM":""
3076      Op, Commands[CM], Ops[LO],
3077      SX,SY, DX,DY, CL, m_cont_reg[45]&0x04? -NX:NX,
3078      m_cont_reg[45]&0x08? -NY:NY,
3079      m_cont_reg[45]&0x70? " on ExtVRAM":""
30953080      ));
30963081}
30973082
30983083/** VDPDraw() ************************************************/
30993084/** Perform a given V9938 operation Op.                     **/
31003085/*************************************************************/
3101UINT8 v99x8_device::command_unit_w (UINT8 Op)
3086UINT8 v99x8_device::command_unit_w(UINT8 Op)
31023087{
3103  int SM;
3088   int SM;
31043089
3105  // V9938 ops only work in SCREENs 5-8
3106  if (ScrMode<5)
3107    return(0);
3090   // V9938 ops only work in SCREENs 5-8
3091   if (m_mode<5)
3092      return(0);
31083093
3109  SM = ScrMode-5;         // Screen mode index 0..3
3094   SM = m_mode-5;         // Screen mode index 0..3
31103095
3111  m_mmc.CM = Op>>4;
3112  if ((m_mmc.CM & 0x0C) != 0x0C && m_mmc.CM != 0)
3113    // Dot operation: use only relevant bits of color
3114    VDPStatus[7]=(VDP[44]&=Mask[SM]);
3096   m_mmc.CM = Op>>4;
3097   if ((m_mmc.CM & 0x0C) != 0x0C && m_mmc.CM != 0)
3098      // Dot operation: use only relevant bits of color
3099   m_stat_reg[7]=(m_cont_reg[44]&=Mask[SM]);
31153100
3116//  if(Verbose&0x02)
3117    ReportVdpCommand(Op);
3101   //  if(Verbose&0x02)
3102   report_vdp_command(Op);
31183103
3119  switch(Op>>4) {
3120    case CM_ABRT:
3121      VDPStatus[2]&=0xFE;
3122      m_vdp_engine=0;
3123      return 1;
3124    case CM_POINT:
3125      VDPStatus[2]&=0xFE;
3126      m_vdp_engine=0;
3127      VDPStatus[7]=VDP[44]=
3128                   VDP_POINT(SM, (VDP[45] & 0x10) != 0,
3129                                 VDP[32]+((int)VDP[33]<<8),
3130                                 VDP[34]+((int)VDP[35]<<8));
3131      return 1;
3132    case CM_PSET:
3133      VDPStatus[2]&=0xFE;
3134      m_vdp_engine=0;
3135      VDP_PSET(SM, (VDP[45] & 0x20) != 0,
3136               VDP[36]+((int)VDP[37]<<8),
3137               VDP[38]+((int)VDP[39]<<8),
3138               VDP[44],
3139               Op&0x0F);
3140      return 1;
3141    case CM_SRCH:
3142      m_vdp_engine=&v99x8_device::SrchEngine;
3143      break;
3144    case CM_LINE:
3145      m_vdp_engine=&v99x8_device::LineEngine;
3146      break;
3147    case CM_LMMV:
3148      m_vdp_engine=&v99x8_device::LmmvEngine;
3149      break;
3150    case CM_LMMM:
3151      m_vdp_engine=&v99x8_device::LmmmEngine;
3152      break;
3153    case CM_LMCM:
3154      m_vdp_engine=&v99x8_device::LmcmEngine;
3155      break;
3156    case CM_LMMC:
3157      m_vdp_engine=&v99x8_device::LmmcEngine;
3158      break;
3159    case CM_HMMV:
3160      m_vdp_engine=&v99x8_device::HmmvEngine;
3161      break;
3162    case CM_HMMM:
3163      m_vdp_engine=&v99x8_device::HmmmEngine;
3164      break;
3165    case CM_YMMM:
3166      m_vdp_engine=&v99x8_device::YmmmEngine;
3167      break;
3168    case CM_HMMC:
3169      m_vdp_engine=&v99x8_device::HmmcEngine;
3170      break;
3171    default:
3172      LOG(("V9938: Unrecognized opcode %02Xh\n",Op));
3173        return(0);
3174  }
3104   switch(Op>>4) {
3105   case CM_ABRT:
3106      m_stat_reg[2]&=0xFE;
3107      m_vdp_engine=0;
3108      return 1;
3109   case CM_POINT:
3110      m_stat_reg[2]&=0xFE;
3111      m_vdp_engine=0;
3112      m_stat_reg[7]=m_cont_reg[44]=
3113      VDP_POINT(SM, (m_cont_reg[45] & 0x10) != 0,
3114         m_cont_reg[32]+((int)m_cont_reg[33]<<8),
3115         m_cont_reg[34]+((int)m_cont_reg[35]<<8));
3116      return 1;
3117   case CM_PSET:
3118      m_stat_reg[2]&=0xFE;
3119      m_vdp_engine=0;
3120      VDP_PSET(SM, (m_cont_reg[45] & 0x20) != 0,
3121         m_cont_reg[36]+((int)m_cont_reg[37]<<8),
3122         m_cont_reg[38]+((int)m_cont_reg[39]<<8),
3123         m_cont_reg[44],
3124         Op&0x0F);
3125      return 1;
3126   case CM_SRCH:
3127      m_vdp_engine=&v99x8_device::srch_engine;
3128      break;
3129   case CM_LINE:
3130      m_vdp_engine=&v99x8_device::line_engine;
3131      break;
3132   case CM_LMMV:
3133      m_vdp_engine=&v99x8_device::lmmv_engine;
3134      break;
3135   case CM_LMMM:
3136      m_vdp_engine=&v99x8_device::lmmm_engine;
3137      break;
3138   case CM_LMCM:
3139      m_vdp_engine=&v99x8_device::lmcm_engine;
3140      break;
3141   case CM_LMMC:
3142      m_vdp_engine=&v99x8_device::lmmc_engine;
3143      break;
3144   case CM_HMMV:
3145      m_vdp_engine=&v99x8_device::hmmv_engine;
3146      break;
3147   case CM_HMMM:
3148      m_vdp_engine=&v99x8_device::hmmm_engine;
3149      break;
3150   case CM_YMMM:
3151      m_vdp_engine=&v99x8_device::ymmm_engine;
3152      break;
3153   case CM_HMMC:
3154      m_vdp_engine=&v99x8_device::hmmc_engine;
3155      break;
3156   default:
3157      LOG(("V9938: Unrecognized opcode %02Xh\n",Op));
3158      return(0);
3159   }
31753160
3176  // Fetch unconditional arguments
3177  m_mmc.SX = (VDP[32]+((int)VDP[33]<<8)) & 511;
3178  m_mmc.SY = (VDP[34]+((int)VDP[35]<<8)) & 1023;
3179  m_mmc.DX = (VDP[36]+((int)VDP[37]<<8)) & 511;
3180  m_mmc.DY = (VDP[38]+((int)VDP[39]<<8)) & 1023;
3181  m_mmc.NY = (VDP[42]+((int)VDP[43]<<8)) & 1023;
3182  m_mmc.TY = VDP[45]&0x08? -1:1;
3183  m_mmc.MX = PPL[SM];
3184  m_mmc.CL = VDP[44];
3185  m_mmc.LO = Op&0x0F;
3186  m_mmc.MXS = (VDP[45] & 0x10) != 0;
3187  m_mmc.MXD = (VDP[45] & 0x20) != 0;
3161   // Fetch unconditional arguments
3162   m_mmc.SX = (m_cont_reg[32]+((int)m_cont_reg[33]<<8)) & 511;
3163   m_mmc.SY = (m_cont_reg[34]+((int)m_cont_reg[35]<<8)) & 1023;
3164   m_mmc.DX = (m_cont_reg[36]+((int)m_cont_reg[37]<<8)) & 511;
3165   m_mmc.DY = (m_cont_reg[38]+((int)m_cont_reg[39]<<8)) & 1023;
3166   m_mmc.NY = (m_cont_reg[42]+((int)m_cont_reg[43]<<8)) & 1023;
3167   m_mmc.TY = m_cont_reg[45]&0x08? -1:1;
3168   m_mmc.MX = PPL[SM];
3169   m_mmc.CL = m_cont_reg[44];
3170   m_mmc.LO = Op&0x0F;
3171   m_mmc.MXS = (m_cont_reg[45] & 0x10) != 0;
3172   m_mmc.MXD = (m_cont_reg[45] & 0x20) != 0;
31883173
3189  // Argument depends on UINT8 or dot operation
3190  if ((m_mmc.CM & 0x0C) == 0x0C) {
3191    m_mmc.TX = VDP[45]&0x04? -PPB[SM]:PPB[SM];
3192    m_mmc.NX = ((VDP[40]+((int)VDP[41]<<8)) & 1023)/PPB[SM];
3193  }
3194  else {
3195    m_mmc.TX = VDP[45]&0x04? -1:1;
3196    m_mmc.NX = (VDP[40]+((int)VDP[41]<<8)) & 1023;
3197  }
3174   // Argument depends on UINT8 or dot operation
3175   if ((m_mmc.CM & 0x0C) == 0x0C) {
3176      m_mmc.TX = m_cont_reg[45]&0x04? -PPB[SM]:PPB[SM];
3177      m_mmc.NX = ((m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023)/PPB[SM];
3178   }
3179   else {
3180      m_mmc.TX = m_cont_reg[45]&0x04? -1:1;
3181      m_mmc.NX = (m_cont_reg[40]+((int)m_cont_reg[41]<<8)) & 1023;
3182   }
31983183
3199  // X loop variables are treated specially for LINE command
3200  if (m_mmc.CM == CM_LINE) {
3201    m_mmc.ASX=((m_mmc.NX-1)>>1);
3202    m_mmc.ADX=0;
3203  }
3204  else {
3205    m_mmc.ASX = m_mmc.SX;
3206    m_mmc.ADX = m_mmc.DX;
3207  }
3184   // X loop variables are treated specially for LINE command
3185   if (m_mmc.CM == CM_LINE) {
3186      m_mmc.ASX=((m_mmc.NX-1)>>1);
3187      m_mmc.ADX=0;
3188   }
3189   else {
3190      m_mmc.ASX = m_mmc.SX;
3191      m_mmc.ADX = m_mmc.DX;
3192   }
32083193
3209  // NX loop variable is treated specially for SRCH command
3210  if (m_mmc.CM == CM_SRCH)
3211    m_mmc.ANX=(VDP[45]&0x02)!=0; // Do we look for "==" or "!="?
3212  else
3213    m_mmc.ANX = m_mmc.NX;
3194   // NX loop variable is treated specially for SRCH command
3195   if (m_mmc.CM == CM_SRCH)
3196      m_mmc.ANX=(m_cont_reg[45]&0x02)!=0; // Do we look for "==" or "!="?
3197   else
3198      m_mmc.ANX = m_mmc.NX;
32143199
3215  // Command execution started
3216  VDPStatus[2]|=0x01;
3200   // Command execution started
3201   m_stat_reg[2]|=0x01;
32173202
3218  // Start execution if we still have time slices
3219  if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3203   // Start execution if we still have time slices
3204   if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
32203205
3221  // Operation successfull initiated
3222  return(1);
3206   // Operation successfull initiated
3207   return(1);
32233208}
32243209
3225/** LoopVDP() ************************************************/
3226/** Run X steps of active VDP command                       **/
3227/*************************************************************/
3228void v99x8_device::update_command ()
3210/** LoopVDP() ************************************************
3211Run X steps of active VDP command
3212*************************************************************/
3213void v99x8_device::update_command()
32293214{
3230  if(m_vdp_ops_count<=0)
3231  {
3232    m_vdp_ops_count+=13662;
3233    if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3234  }
3235  else
3236  {
3237    m_vdp_ops_count=13662;
3238    if(m_vdp_engine) (this->*m_vdp_engine)();
3239  }
3215   if(m_vdp_ops_count<=0)
3216   {
3217      m_vdp_ops_count+=13662;
3218      if(m_vdp_engine&&(m_vdp_ops_count>0)) (this->*m_vdp_engine)();
3219   }
3220   else
3221   {
3222      m_vdp_ops_count=13662;
3223      if(m_vdp_engine) (this->*m_vdp_engine)();
3224   }
32403225}
32413226
src/emu/video/v9938.h
r15546r15547
6464
6565// ======================> v99x8_device
6666
67class v99x8_device : public device_t
67class v99x8_device : public device_t, public device_memory_interface
6868{
6969   friend PALETTE_INIT( v9958 );
7070
r15546r15547
9797   static void static_set_interrupt_callback(device_t &device, v99x8_interrupt_delegate callback, const char *device_name);
9898
9999protected:
100   const address_space_config      m_space_config;
101   address_space*               m_vram_space;
102
100103   int m_model;
101104
102105   // device overrides
103106   virtual void device_start();
104107   virtual void device_reset();
105108
109   // device_memory_interface overrides
110   virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_DATA) const { return (spacenum == AS_DATA) ? &m_space_config : NULL; }
111
106112private:
107113   // internal helpers
108   void reset_palette ();
109   void vram_write (int offset, int data);
110   int vram_read (int offset);
111   void check_int ();
112   void register_write (int reg, int data);
114   void reset_palette();
115   void vram_write(int offset, int data);
116   int vram_read(int offset);
117   void check_int();
118   void register_write(int reg, int data);
113119
114120   template<typename _PixelType, int _Width> void default_border(const pen_t *pens, _PixelType *ln);
115121   template<typename _PixelType, int _Width> void graphic7_border(const pen_t *pens, _PixelType *ln);
r15546r15547
128134   template<typename _PixelType, int _Width> void graphic5_draw_sprite(const pen_t *pens, _PixelType *ln, UINT8 *col);
129135   template<typename _PixelType, int _Width> void graphic7_draw_sprite(const pen_t *pens, _PixelType *ln, UINT8 *col);
130136
131   void sprite_mode1 (int line, UINT8 *col);
132   void sprite_mode2 (int line, UINT8 *col);
133   void set_mode ();
134   void refresh_16 (int line);
135   void refresh_line (int line);
137   void sprite_mode1(int line, UINT8 *col);
138   void sprite_mode2(int line, UINT8 *col);
139   void set_mode();
140   void refresh_16(int line);
141   void refresh_line(int line);
136142
137   void interrupt_start_vblank ();
143   void interrupt_start_vblank();
138144
139   UINT8 *VDPVRMP(UINT8 M, int MX, int X, int Y);
145   int VDPVRMP(UINT8 M, int MX, int X, int Y);
140146
141147   UINT8 VDPpoint5(int MXS, int SX, int SY);
142148   UINT8 VDPpoint6(int MXS, int SX, int SY);
r15546r15547
145151
146152   UINT8 VDPpoint(UINT8 SM, int MXS, int SX, int SY);
147153
148   void VDPpsetlowlevel(UINT8 *P, UINT8 CL, UINT8 M, UINT8 OP);
154   void VDPpsetlowlevel(int addr, UINT8 CL, UINT8 M, UINT8 OP);
149155
150156   void VDPpset5(int MXD, int DX, int DY, UINT8 CL, UINT8 OP);
151157   void VDPpset6(int MXD, int DX, int DY, UINT8 CL, UINT8 OP);
r15546r15547
154160
155161   void VDPpset(UINT8 SM, int MXD, int DX, int DY, UINT8 CL, UINT8 OP);
156162
157   int GetVdpTimingValue(const int *);
163   int get_vdp_timing_value(const int *);
158164
159   void SrchEngine();
160   void LineEngine();
161   void LmmvEngine();
162   void LmmmEngine();
163   void LmcmEngine();
164   void LmmcEngine();
165   void HmmvEngine();
166   void HmmmEngine();
167   void YmmmEngine();
168   void HmmcEngine();
165   void srch_engine();
166   void line_engine();
167   void lmmv_engine();
168   void lmmm_engine();
169   void lmcm_engine();
170   void lmmc_engine();
171   void hmmv_engine();
172   void hmmm_engine();
173   void ymmm_engine();
174   void hmmc_engine();
169175
170   void cpu_to_vdp (UINT8 V);
171   UINT8 vdp_to_cpu ();
172   void ReportVdpCommand(UINT8 Op);
173   UINT8 command_unit_w (UINT8 Op);
174   void update_command ();
176   inline bool v9938_second_field();
175177
178   void cpu_to_vdp(UINT8 V);
179   UINT8 vdp_to_cpu();
180   void report_vdp_command(UINT8 Op);
181   UINT8 command_unit_w(UINT8 Op);
182   void update_command();
183
176184   // general
177185   int m_offset_x, m_offset_y, m_visible_y, m_mode;
178186   // palette
179187   int   m_pal_write_first, m_cmd_write_first;
180188   UINT8 m_pal_write, m_cmd_write;
181189   UINT8 m_pal_reg[32], m_stat_reg[10], m_cont_reg[48], m_read_ahead;
190
182191   // memory
183192   UINT16 m_address_latch;
184   UINT8 *m_vram_exp;
185193   int m_vram_size;
194
186195    // interrupt
187196    UINT8 m_int_state;
188197    v99x8_interrupt_delegate m_int_callback;
r15546r15547
222231   int  m_vdp_ops_count;
223232   void (v99x8_device::*m_vdp_engine)();
224233
225   UINT8 m_vram[0x20000];
226
227234   struct v99x8_mode
228235   {
229236      UINT8 m;

Previous 15994 Revisions Next


© 1998-2018 The MESS Team