Previous 15994 Revisions Next

r11050 Sunday 3rd April, 2011 at 07:23:21 UTC by Robbbert
[ARGO, BCS3, BEEHIVE, DIM68K, MES, PEGASUS, PHUNSY, PTCSOL, VTA2000, ZRT80] Modernised and/or code cleaned.
[src/mess/drivers]argo.c bcs3.c beehive.c dim68k.c mes.c pegasus.c phunsy.c ptcsol.c vta2000.c zrt80.c

src/mess/drivers/beehive.c
r11049r11050
1010    for the moment.
1111
1212****************************************************************************/
13#define ADDRESS_MAP_MODERN
1314
1415#include "emu.h"
1516#include "cpu/i8085/i8085.h"
1617
18#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
19#define VIDEO_START_MEMBER(name) void name::video_start()
20#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
1721
1822class beehive_state : public driver_device
1923{
2024public:
2125   beehive_state(running_machine &machine, const driver_device_config_base &config)
22      : driver_device(machine, config) { }
26      : driver_device(machine, config),
27   m_maincpu(*this, "maincpu")
28   { }
2329
24   const UINT8 *m_FNT;
25   const UINT8 *m_videoram;
30   required_device<cpu_device> m_maincpu;
31   const UINT8 *m_p_chargen;
32   const UINT8 *m_p_videoram;
33   virtual void machine_reset();
34   virtual void video_start();
35   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
2636};
2737
2838
2939
30static ADDRESS_MAP_START(beehive_mem, AS_PROGRAM, 8)
40static ADDRESS_MAP_START(beehive_mem, AS_PROGRAM, 8, beehive_state)
3141   ADDRESS_MAP_UNMAP_HIGH
3242   AM_RANGE( 0x0000, 0x17ff ) AM_ROM
3343   AM_RANGE( 0x1800, 0xffff ) AM_RAM AM_REGION("maincpu", 0x1800)
3444ADDRESS_MAP_END
3545
36static ADDRESS_MAP_START( beehive_io, AS_IO, 8)
46static ADDRESS_MAP_START( beehive_io, AS_IO, 8, beehive_state)
47   ADDRESS_MAP_GLOBAL_MASK(0xff)
3748   ADDRESS_MAP_UNMAP_HIGH
3849ADDRESS_MAP_END
3950
r11049r11050
4253INPUT_PORTS_END
4354
4455
45static MACHINE_RESET(beehive)
56MACHINE_RESET_MEMBER(beehive_state)
4657{
4758}
4859
49static VIDEO_START( beehive )
60VIDEO_START_MEMBER( beehive_state )
5061{
51   beehive_state *state = machine.driver_data<beehive_state>();
52   state->m_FNT = machine.region("chargen")->base();
53   state->m_videoram = machine.region("maincpu")->base()+0x81fa;
62   m_p_chargen = m_machine.region("chargen")->base();
63   m_p_videoram = m_machine.region("maincpu")->base()+0x81fa;
5464}
5565
5666/* This system appears to have inline attribute bytes of unknown meaning.
5767    Currently they are ignored. */
58static SCREEN_UPDATE( beehive )
68SCREEN_UPDATE_MEMBER( beehive_state )
5969{
60   beehive_state *state = screen->machine().driver_data<beehive_state>();
6170   //static UINT8 framecnt=0;
6271   UINT8 y,ra,chr,gfx;
6372   UINT16 sy=0,ma=0,x,xx;
r11049r11050
6877   {
6978      for (ra = 0; ra < 10; ra++)
7079      {
71         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
80         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
7281
7382         xx = ma;
7483         for (x = ma; x < ma + 80; x++)
r11049r11050
7685            gfx = 0;
7786            if (ra < 9)
7887            {
79               chr = state->m_videoram[xx++];
88               chr = m_p_videoram[xx++];
8089
8190            //  /* Take care of flashing characters */
8291            //  if ((chr < 0x80) && (framecnt & 0x08))
r11049r11050
8695                  x--;
8796               else
8897               {
89                  gfx = state->m_FNT[(chr<<4) | ra ];
98                  gfx = m_p_chargen[(chr<<4) | ra ];
9099
91100                  /* Display a scanline of a character */
92                  *p++ = ( gfx & 0x80 ) ? 1 : 0;
93                  *p++ = ( gfx & 0x40 ) ? 1 : 0;
94                  *p++ = ( gfx & 0x20 ) ? 1 : 0;
95                  *p++ = ( gfx & 0x10 ) ? 1 : 0;
96                  *p++ = ( gfx & 0x08 ) ? 1 : 0;
97                  *p++ = ( gfx & 0x04 ) ? 1 : 0;
98                  *p++ = ( gfx & 0x02 ) ? 1 : 0;
99                  *p++ = ( gfx & 0x01 ) ? 1 : 0;
101                  *p++ = BIT(gfx, 7);
102                  *p++ = BIT(gfx, 6);
103                  *p++ = BIT(gfx, 5);
104                  *p++ = BIT(gfx, 4);
105                  *p++ = BIT(gfx, 3);
106                  *p++ = BIT(gfx, 2);
107                  *p++ = BIT(gfx, 1);
108                  *p++ = BIT(gfx, 0);
100109               }
101110            }
102111         }
r11049r11050
112121    MCFG_CPU_PROGRAM_MAP(beehive_mem)
113122    MCFG_CPU_IO_MAP(beehive_io)
114123
115    MCFG_MACHINE_RESET(beehive)
116
117124    /* video hardware */
118125    MCFG_SCREEN_ADD("screen", RASTER)
119126    MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
121128    MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
122129    MCFG_SCREEN_SIZE(640, 250)
123130    MCFG_SCREEN_VISIBLE_AREA(0, 639, 0, 249)
124    MCFG_SCREEN_UPDATE(beehive)
125
126131    MCFG_PALETTE_LENGTH(2)
127132    MCFG_PALETTE_INIT(black_and_white)
128
129    MCFG_VIDEO_START(beehive)
130133MACHINE_CONFIG_END
131134
132135/* ROM definition */
r11049r11050
144147/* Driver */
145148
146149/*    YEAR  NAME    PARENT  COMPAT   MACHINE    INPUT    INIT    COMPANY   FULLNAME       FLAGS */
147COMP( 19??, beehive,  0,       0,   beehive,   beehive,    0,  "BeeHive",   "DM3270",      GAME_NOT_WORKING | GAME_NO_SOUND)
150COMP( 19??, beehive,  0,       0,   beehive,   beehive,    0,  "BeeHive",   "DM3270", GAME_NOT_WORKING | GAME_NO_SOUND)
148151
src/mess/drivers/bcs3.c
r11049r11050
1212    Note: The $ key makes a square symbol.
1313
1414****************************************************************************/
15#define ADDRESS_MAP_MODERN
1516
1617#include "emu.h"
1718#include "cpu/z80/z80.h"
1819
20#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
21#define VIDEO_START_MEMBER(name) void name::video_start()
22
1923class bcs3_state : public driver_device
2024{
2125public:
2226   bcs3_state(running_machine &machine, const driver_device_config_base &config)
23      : driver_device(machine, config) { }
27      : driver_device(machine, config),
28   m_maincpu(*this, "maincpu")
29   { }
2430
25   const UINT8 *m_fnt;
26   UINT8 *m_videoram;
31   required_device<cpu_device> m_maincpu;
32   const UINT8 *m_p_chargen;
33   const UINT8 *m_p_videoram;
34   DECLARE_READ8_MEMBER(bcs3_keyboard_r);
35   virtual void machine_reset();
36   virtual void video_start();
2737};
2838
29static READ8_HANDLER( bcs3_videoram_r )
39READ8_MEMBER( bcs3_state::bcs3_keyboard_r )
3040{
31   bcs3_state *state = space->machine().driver_data<bcs3_state>();
32
33   return state->m_videoram[offset];
34}
35
36static WRITE8_HANDLER( bcs3_videoram_w )
37{
38   bcs3_state *state = space->machine().driver_data<bcs3_state>();
39
40   state->m_videoram[offset] = data;
41}
42
43static READ8_HANDLER( bcs3_keyboard_r )
44{
4541   UINT8 data = 0;
4642
4743   if (~offset & 0x01)
48      data |= input_port_read(space->machine(), "LINE0");
44      data |= input_port_read(machine(), "LINE0");
4945   if (~offset & 0x02)
50      data |= input_port_read(space->machine(), "LINE1");
46      data |= input_port_read(machine(), "LINE1");
5147   if (~offset & 0x04)
52      data |= input_port_read(space->machine(), "LINE2");
48      data |= input_port_read(machine(), "LINE2");
5349   if (~offset & 0x08)
54      data |= input_port_read(space->machine(), "LINE3");
50      data |= input_port_read(machine(), "LINE3");
5551   if (~offset & 0x10)
56      data |= input_port_read(space->machine(), "LINE4");
52      data |= input_port_read(machine(), "LINE4");
5753   if (~offset & 0x20)
58      data |= input_port_read(space->machine(), "LINE5");
54      data |= input_port_read(machine(), "LINE5");
5955   if (~offset & 0x40)
60      data |= input_port_read(space->machine(), "LINE6");
56      data |= input_port_read(machine(), "LINE6");
6157   if (~offset & 0x80)
62      data |= input_port_read(space->machine(), "LINE7");
58      data |= input_port_read(machine(), "LINE7");
6359   if (~offset & 0x100)
64      data |= input_port_read(space->machine(), "LINE8");
60      data |= input_port_read(machine(), "LINE8");
6561
6662   return data;
6763}
6864
69static ADDRESS_MAP_START(bcs3_mem, AS_PROGRAM, 8)
65static ADDRESS_MAP_START(bcs3_mem, AS_PROGRAM, 8, bcs3_state)
7066   ADDRESS_MAP_UNMAP_HIGH
7167   AM_RANGE( 0x0000, 0x0fff ) AM_ROM
7268   AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9")
7369   AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r)
7470   AM_RANGE( 0x3c00, 0xffff ) AM_RAM
75   AM_RANGE( 0x3c50, 0x3d9f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram)
71   AM_RANGE( 0x3c50, 0x3d9f ) AM_RAM AM_BASE(m_p_videoram)
7672ADDRESS_MAP_END
7773
78static ADDRESS_MAP_START(bcs3a_mem, AS_PROGRAM, 8)
74static ADDRESS_MAP_START(bcs3a_mem, AS_PROGRAM, 8, bcs3_state)
7975   ADDRESS_MAP_UNMAP_HIGH
8076   AM_RANGE( 0x0000, 0x0fff ) AM_ROM
8177   AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9")
8278   AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r)
8379   AM_RANGE( 0x3c00, 0xefff ) AM_RAM
84   AM_RANGE( 0x3c00, 0x5a7f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram)
80   AM_RANGE( 0x3c00, 0x5a7f ) AM_RAM AM_BASE(m_p_videoram)
8581   AM_RANGE( 0xf000, 0xf3ff ) AM_ROM
8682ADDRESS_MAP_END
8783
88static ADDRESS_MAP_START(bcs3b_mem, AS_PROGRAM, 8)
84static ADDRESS_MAP_START(bcs3b_mem, AS_PROGRAM, 8, bcs3_state)
8985   ADDRESS_MAP_UNMAP_HIGH
9086   AM_RANGE( 0x0000, 0x0fff ) AM_ROM
9187   AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9")
9288   AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r)
9389   AM_RANGE( 0x3c00, 0xefff ) AM_RAM
94   AM_RANGE( 0x3c00, 0x657f ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram)
90   AM_RANGE( 0x3c00, 0x657f ) AM_RAM AM_BASE(m_p_videoram)
9591   AM_RANGE( 0xf000, 0xf3ff ) AM_ROM
9692ADDRESS_MAP_END
9793
98static ADDRESS_MAP_START(bcs3c_mem, AS_PROGRAM, 8)
94static ADDRESS_MAP_START(bcs3c_mem, AS_PROGRAM, 8, bcs3_state)
9995   ADDRESS_MAP_UNMAP_HIGH
10096   AM_RANGE( 0x0000, 0x0fff ) AM_ROM
10197   AM_RANGE( 0x1000, 0x11ff ) AM_READ_PORT("LINE9")
10298   AM_RANGE( 0x1200, 0x13ff ) AM_READ(bcs3_keyboard_r)
10399   AM_RANGE( 0x3c00, 0xffff ) AM_RAM
104   AM_RANGE( 0x3c00, 0x5ab3 ) AM_READWRITE(bcs3_videoram_r,bcs3_videoram_w) AM_BASE_MEMBER(bcs3_state,m_videoram)
100   AM_RANGE( 0x3c00, 0x5ab3 ) AM_RAM AM_BASE(m_p_videoram)
105101ADDRESS_MAP_END
106102
107static ADDRESS_MAP_START( bcs3_io, AS_IO, 8)
103static ADDRESS_MAP_START( bcs3_io, AS_IO, 8, bcs3_state)
108104   ADDRESS_MAP_UNMAP_HIGH
109105   ADDRESS_MAP_GLOBAL_MASK(0xff)
110106//  AM_RANGE( 0xf8, 0xfb ) AM_DEVREADWRITE(Z80CTC,"z80ctc",z80ctc_r,z80ctc_w)
r11049r11050
214210INPUT_PORTS_END
215211
216212
217static MACHINE_RESET(bcs3)
213MACHINE_RESET_MEMBER(bcs3_state)
218214{
219215}
220216
221static VIDEO_START( bcs3 )
217VIDEO_START_MEMBER( bcs3_state )
222218{
223   bcs3_state *state = machine.driver_data<bcs3_state>();
224
225   state->m_fnt = machine.region("gfx1")->base();
219   m_p_chargen = m_machine.region("chargen")->base();
226220}
227221
228222static SCREEN_UPDATE( bcs3 )
r11049r11050
235229   {
236230      for (ra = 0; ra < 10; ra++)
237231      {
238         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
232         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
239233         rat = (ra + 1) & 7;
240234
241235         for (x = ma; x < ma + 28; x++)
242236         {
243237            if (ra < 8)
244238            {
245               chr = state->m_videoram[x] & 0x7f;
239               chr = state->m_p_videoram[x] & 0x7f;
246240
247241               /* get pattern of pixels for that character scanline */
248               gfx = state->m_fnt[(chr<<3) | rat ];
242               gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff;
249243            }
250244            else
251               gfx = 0;
245               gfx = 0xff;
252246
253247            /* Display a scanline of a character (8 pixels) */
254            *p++ = ( gfx & 0x80 ) ? 0 : 1;
255            *p++ = ( gfx & 0x40 ) ? 0 : 1;
256            *p++ = ( gfx & 0x20 ) ? 0 : 1;
257            *p++ = ( gfx & 0x10 ) ? 0 : 1;
258            *p++ = ( gfx & 0x08 ) ? 0 : 1;
259            *p++ = ( gfx & 0x04 ) ? 0 : 1;
260            *p++ = ( gfx & 0x02 ) ? 0 : 1;
261            *p++ = ( gfx & 0x01 ) ? 0 : 1;
248            *p++ = BIT(gfx, 7);
249            *p++ = BIT(gfx, 6);
250            *p++ = BIT(gfx, 5);
251            *p++ = BIT(gfx, 4);
252            *p++ = BIT(gfx, 3);
253            *p++ = BIT(gfx, 2);
254            *p++ = BIT(gfx, 1);
255            *p++ = BIT(gfx, 0);
262256         }
263257      }
264258      ma+=28;
r11049r11050
273267   bcs3_state *state = screen->machine().driver_data<bcs3_state>();
274268   UINT8 y,ra,chr,gfx,rat;
275269   UINT16 sy=0,ma=128,x;
276   UINT16 cursor = (state->m_videoram[0x7a] | (state->m_videoram[0x7b] << 8)) - 0x3c80;   // get cursor relative position
270   UINT16 cursor = (state->m_p_videoram[0x7a] | (state->m_p_videoram[0x7b] << 8)) - 0x3c80;   // get cursor relative position
277271   rat = cursor / 30;
278272   if (rat > 11) ma = (rat-11) * 30 + 128;
279273
r11049r11050
281275   {
282276      for (ra = 0; ra < 10; ra++)
283277      {
284         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
278         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
285279         rat = (ra + 1) & 7;
286280
287281         for (x = ma; x < ma + 29; x++)
288282         {
289283            if (ra < 8)
290284            {
291               chr = state->m_videoram[x] & 0x7f;
285               chr = state->m_p_videoram[x] & 0x7f;
292286
293287               /* get pattern of pixels for that character scanline */
294               gfx = state->m_fnt[(chr<<3) | rat ];
288               gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff;
295289            }
296290            else
297               gfx = 0;
291               gfx = 0xff;
298292
299293            /* Display a scanline of a character (8 pixels) */
300            *p++ = ( gfx & 0x80 ) ? 0 : 1;
301            *p++ = ( gfx & 0x40 ) ? 0 : 1;
302            *p++ = ( gfx & 0x20 ) ? 0 : 1;
303            *p++ = ( gfx & 0x10 ) ? 0 : 1;
304            *p++ = ( gfx & 0x08 ) ? 0 : 1;
305            *p++ = ( gfx & 0x04 ) ? 0 : 1;
306            *p++ = ( gfx & 0x02 ) ? 0 : 1;
307            *p++ = ( gfx & 0x01 ) ? 0 : 1;
294            *p++ = BIT(gfx, 7);
295            *p++ = BIT(gfx, 6);
296            *p++ = BIT(gfx, 5);
297            *p++ = BIT(gfx, 4);
298            *p++ = BIT(gfx, 3);
299            *p++ = BIT(gfx, 2);
300            *p++ = BIT(gfx, 1);
301            *p++ = BIT(gfx, 0);
308302         }
309303      }
310304      ma+=30;
r11049r11050
317311   bcs3_state *state = screen->machine().driver_data<bcs3_state>();
318312   UINT8 y,ra,chr,gfx,rat;
319313   UINT16 sy=0,ma=128,x;
320   UINT16 cursor = (state->m_videoram[0x7a] | (state->m_videoram[0x7b] << 8)) - 0x3c80;   // get cursor relative position
314   UINT16 cursor = (state->m_p_videoram[0x7a] | (state->m_p_videoram[0x7b] << 8)) - 0x3c80;   // get cursor relative position
321315   rat = cursor / 41;
322316   if (rat > 23) ma = (rat-23) * 41 + 128;
323317
r11049r11050
325319   {
326320      for (ra = 0; ra < 10; ra++)
327321      {
328         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
322         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
329323         rat = (ra + 1) & 7;
330324
331325         for (x = ma; x < ma + 40; x++)
332326         {
333327            if (ra < 8)
334328            {
335               chr = state->m_videoram[x] & 0x7f;
329               chr = state->m_p_videoram[x] & 0x7f;
336330
337331               /* get pattern of pixels for that character scanline */
338               gfx = state->m_fnt[(chr<<3) | rat ];
332               gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff;
339333            }
340334            else
341               gfx = 0;
335               gfx = 0xff;
342336
343337            /* Display a scanline of a character (8 pixels) */
344            *p++ = ( gfx & 0x80 ) ? 0 : 1;
345            *p++ = ( gfx & 0x40 ) ? 0 : 1;
346            *p++ = ( gfx & 0x20 ) ? 0 : 1;
347            *p++ = ( gfx & 0x10 ) ? 0 : 1;
348            *p++ = ( gfx & 0x08 ) ? 0 : 1;
349            *p++ = ( gfx & 0x04 ) ? 0 : 1;
350            *p++ = ( gfx & 0x02 ) ? 0 : 1;
351            *p++ = ( gfx & 0x01 ) ? 0 : 1;
338            *p++ = BIT(gfx, 7);
339            *p++ = BIT(gfx, 6);
340            *p++ = BIT(gfx, 5);
341            *p++ = BIT(gfx, 4);
342            *p++ = BIT(gfx, 3);
343            *p++ = BIT(gfx, 2);
344            *p++ = BIT(gfx, 1);
345            *p++ = BIT(gfx, 0);
352346         }
353347      }
354348      ma+=41;
r11049r11050
361355   bcs3_state *state = screen->machine().driver_data<bcs3_state>();
362356   UINT8 y,ra,chr,gfx,rat;
363357   UINT16 sy=0,ma=0xb4,x;
364   UINT16 cursor = (state->m_videoram[0x08] | (state->m_videoram[0x09] << 8)) - 0x3c80;   // get cursor relative position
358   UINT16 cursor = (state->m_p_videoram[0x08] | (state->m_p_videoram[0x09] << 8)) - 0x3c80;   // get cursor relative position
365359   rat = cursor / 30;
366360   if (rat > 11) ma = (rat-11) * 30 + 0xb4;
367361
r11049r11050
369363   {
370364      for (ra = 0; ra < 10; ra++)
371365      {
372         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
366         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
373367         rat = (ra + 1) & 7;
374368
375369         for (x = ma; x < ma + 29; x++)
376370         {
377371            if (ra < 8)
378372            {
379               chr = state->m_videoram[x] & 0x7f;
373               chr = state->m_p_videoram[x] & 0x7f;
380374
381375               /* get pattern of pixels for that character scanline */
382               gfx = state->m_fnt[(chr<<3) | rat ];
376               gfx = state->m_p_chargen[(chr<<3) | rat ] ^ 0xff;
383377            }
384378            else
385               gfx = 0;
379               gfx = 0xff;
386380
387381            /* Display a scanline of a character (8 pixels) */
388            *p++ = ( gfx & 0x80 ) ? 0 : 1;
389            *p++ = ( gfx & 0x40 ) ? 0 : 1;
390            *p++ = ( gfx & 0x20 ) ? 0 : 1;
391            *p++ = ( gfx & 0x10 ) ? 0 : 1;
392            *p++ = ( gfx & 0x08 ) ? 0 : 1;
393            *p++ = ( gfx & 0x04 ) ? 0 : 1;
394            *p++ = ( gfx & 0x02 ) ? 0 : 1;
395            *p++ = ( gfx & 0x01 ) ? 0 : 1;
382            *p++ = BIT(gfx, 7);
383            *p++ = BIT(gfx, 6);
384            *p++ = BIT(gfx, 5);
385            *p++ = BIT(gfx, 4);
386            *p++ = BIT(gfx, 3);
387            *p++ = BIT(gfx, 2);
388            *p++ = BIT(gfx, 1);
389            *p++ = BIT(gfx, 0);
396390         }
397391      }
398392      ma+=30;
r11049r11050
415409};
416410
417411static GFXDECODE_START( bcs3 )
418   GFXDECODE_ENTRY( "gfx1", 0x0000, bcs3_charlayout, 0, 1 )
412   GFXDECODE_ENTRY( "chargen", 0x0000, bcs3_charlayout, 0, 1 )
419413GFXDECODE_END
420414
421415
r11049r11050
426420   MCFG_CPU_PROGRAM_MAP(bcs3_mem)
427421   MCFG_CPU_IO_MAP(bcs3_io)
428422
429   MCFG_MACHINE_RESET(bcs3)
430
431423   /* video hardware */
432424   MCFG_SCREEN_ADD("screen", RASTER)
433425   MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
436428   MCFG_SCREEN_SIZE(28*8, 12*10)
437429   MCFG_SCREEN_VISIBLE_AREA(0,28*8-1,0,12*10-1)
438430   MCFG_SCREEN_UPDATE(bcs3)
439
440431   MCFG_GFXDECODE(bcs3)
441432   MCFG_PALETTE_LENGTH(2)
442433   MCFG_PALETTE_INIT(black_and_white)
443
444   MCFG_VIDEO_START(bcs3)
445434MACHINE_CONFIG_END
446435
447436static MACHINE_CONFIG_DERIVED( bcs3a, bcs3 )
r11049r11050
482471   ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF )
483472   ROM_LOAD( "se24.bin", 0x0000, 0x0800, CRC(268de5ee) SHA1(78784945956c1b0282a4e82ad55e7c3a77389e50))
484473
485   ROM_REGION( 0x0400, "gfx1", 0 )
474   ROM_REGION( 0x0400, "chargen", 0 )
486475   ROM_LOAD( "se24font.bin", 0x0000, 0x0400, CRC(eaed9d84) SHA1(7023a6187cd6bd0c6489d76ff662453f14e5b636))
487476ROM_END
488477
r11049r11050
491480   ROM_LOAD( "se31_29.bin", 0x0000, 0x1000, CRC(e9b55544) SHA1(82bae68c4bcaecf66632f5b43913b50a1acba316))
492481   ROM_LOAD( "se31mceditor.bin", 0xf000, 0x0400, CRC(8eac92ec) SHA1(8950a3ef05d02abf34269bfce002c46d273ce113))
493482
494   ROM_REGION( 0x0400, "gfx1", 0 )
483   ROM_REGION( 0x0400, "chargen", 0 )
495484   ROM_LOAD( "se31font.bin", 0x0000, 0x0400, CRC(a20c93c9) SHA1(b2be1c0d98b7ac05713349b099b392975968be1d))
496485ROM_END
497486
r11049r11050
500489   ROM_LOAD( "se31_40.bin", 0x0000, 0x1000, CRC(4e993152) SHA1(6bb01ff5779627fa2eb2df432fffcfccc1e33231))
501490   ROM_LOAD( "se31mceditor.bin", 0xf000, 0x0400, CRC(8eac92ec) SHA1(8950a3ef05d02abf34269bfce002c46d273ce113))
502491
503   ROM_REGION( 0x0400, "gfx1", 0 )
492   ROM_REGION( 0x0400, "chargen", 0 )
504493   ROM_LOAD( "se31font.bin", 0x0000, 0x0400, CRC(a20c93c9) SHA1(b2be1c0d98b7ac05713349b099b392975968be1d))
505494ROM_END
506495
r11049r11050
508497   ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF )
509498   ROM_LOAD( "sp33_29.bin", 0x0000, 0x1000, CRC(1c851eb2) SHA1(4f8bb5274ea1861a35a840e8f3482bdc693047c4))
510499
511   ROM_REGION( 0x0400, "gfx1", 0 )
500   ROM_REGION( 0x0400, "chargen", 0 )
512501   ROM_LOAD( "sp33font.bin", 0x0000, 0x0400, CRC(b27f1c07) SHA1(61c80c585f198370ba5e856839c12b15acdc58ee))
513502ROM_END
514503
src/mess/drivers/phunsy.c
r11049r11050
1212#include "machine/terminal.h"
1313#include "sound/speaker.h"
1414
15#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
16#define VIDEO_START_MEMBER(name) void name::video_start()
17#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
1518
1619#define LOG   1
1720
r11049r11050
3538   DECLARE_WRITE8_MEMBER( phunsy_ctrl_w );
3639   DECLARE_WRITE8_MEMBER( phunsy_data_w );
3740   DECLARE_WRITE8_MEMBER( phunsy_kbd_put );
38   UINT8      *m_videoram;
39   UINT8      *m_FNT;
41   const UINT8   *m_p_videoram;
42   const UINT8   *m_p_chargen;
4043   UINT8      m_data_out;
4144   UINT8      m_keyboard_input;
4245   UINT8      m_q_bank;
4346   UINT8      m_u_bank;
4447   UINT8      m_ram_1800[0x800];
48   virtual void machine_reset();
49   virtual void video_start();
50   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
4551};
4652
4753
r11049r11050
5662   ADDRESS_MAP_UNMAP_HIGH
5763   AM_RANGE( 0x0000, 0x07ff) AM_ROM
5864   AM_RANGE( 0x0800, 0x0fff) AM_RAM
59   AM_RANGE( 0x1000, 0x17ff) AM_RAM AM_BASE( m_videoram ) // Video RAM
65   AM_RANGE( 0x1000, 0x17ff) AM_RAM AM_BASE( m_p_videoram ) // Video RAM
6066   AM_RANGE( 0x1800, 0x1fff) AM_RAM_WRITE( phunsy_1800_w ) AM_ROMBANK("bank1")   // Banked RAM/ROM
6167   AM_RANGE( 0x4000, 0xffff) AM_RAMBANK("bank2") // Banked RAM
6268ADDRESS_MAP_END
r11049r11050
176182};
177183
178184
179static DRIVER_INIT( phunsy )
185MACHINE_RESET_MEMBER(phunsy_state)
180186{
181}
187   memory_set_bankptr( m_machine, "bank1", m_ram_1800 );
188   memory_set_bankptr( m_machine, "bank2", m_machine.region("ram_4000")->base() );
182189
183
184static MACHINE_RESET(phunsy)
185{
186   phunsy_state *state = machine.driver_data<phunsy_state>();
187
188   memory_set_bankptr( machine, "bank1", state->m_ram_1800 );
189   memory_set_bankptr( machine, "bank2", machine.region("ram_4000")->base() );
190
191   state->m_u_bank = 0;
192   state->m_q_bank = 0;
193   state->m_keyboard_input = 0xFF;
190   m_u_bank = 0;
191   m_q_bank = 0;
192   m_keyboard_input = 0xFF;
194193}
195194
196195
r11049r11050
205204}
206205
207206
208static VIDEO_START( phunsy )
207VIDEO_START_MEMBER( phunsy_state )
209208{
210   phunsy_state *state = machine.driver_data<phunsy_state>();
211   state->m_FNT = machine.region( "chargen" )->base();
209   m_p_chargen = m_machine.region( "chargen" )->base();
212210}
213211
214212
215static SCREEN_UPDATE( phunsy )
213SCREEN_UPDATE_MEMBER( phunsy_state )
216214{
217   phunsy_state *state = screen->machine().driver_data<phunsy_state>();
218215   UINT8 y,ra,chr,gfx,col;
219216   UINT16 sy=0,ma=0,x;
220217
r11049r11050
222219   {
223220      for (ra = 0; ra < 8; ra++)
224221      {
225         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
222         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
226223
227224         for (x = ma; x < ma+64; x++)
228225         {
229            chr = state->m_videoram[x];
226            chr = m_p_videoram[x];
230227
231228            if (BIT(chr, 7))
232229            {
r11049r11050
241238            else
242239            {
243240               /* ASCII mode */
244               gfx = state->m_FNT[(chr<<3) | ra];
241               gfx = m_p_chargen[(chr<<3) | ra];
245242               col = 7;
246243            }
247244
248245            /* Display a scanline of a character (6 pixels) */
249            *p++ = ( gfx & 0x20 ) ? col : 0;
250            *p++ = ( gfx & 0x10 ) ? col : 0;
251            *p++ = ( gfx & 0x08 ) ? col : 0;
252            *p++ = ( gfx & 0x04 ) ? col : 0;
253            *p++ = ( gfx & 0x02 ) ? col : 0;
254            *p++ = ( gfx & 0x01 ) ? col : 0;
246            *p++ = BIT( gfx, 5 ) ? col : 0;
247            *p++ = BIT( gfx, 4 ) ? col : 0;
248            *p++ = BIT( gfx, 3 ) ? col : 0;
249            *p++ = BIT( gfx, 2 ) ? col : 0;
250            *p++ = BIT( gfx, 1 ) ? col : 0;
251            *p++ = BIT( gfx, 0 ) ? col : 0;
255252         }
256253      }
257254      ma+=64;
r11049r11050
284281   MCFG_CPU_PROGRAM_MAP(phunsy_mem)
285282   MCFG_CPU_IO_MAP(phunsy_io)
286283
287   MCFG_MACHINE_RESET(phunsy)
288
289284   /* video hardware */
290285   MCFG_SCREEN_ADD("screen", RASTER)
291286   /* Display (page 12 of pdf)
r11049r11050
299294   MCFG_GFXDECODE(phunsy)
300295   MCFG_PALETTE_LENGTH(8)
301296   MCFG_PALETTE_INIT(phunsy)
302   MCFG_SCREEN_UPDATE(phunsy)
303297
304   MCFG_VIDEO_START(phunsy)
305
306298   /* sound hardware */
307299   MCFG_SPEAKER_STANDARD_MONO("mono")
308300   //MCFG_SOUND_WAVE_ADD("wave", "cassette")
r11049r11050
310302   MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0)
311303   MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
312304
305   /* Devices */
313306   MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG,phunsy_terminal_intf)
314307MACHINE_CONFIG_END
315308
r11049r11050
335328/* Driver */
336329
337330/*    YEAR  NAME    PARENT  COMPAT   MACHINE    INPUT    INIT    COMPANY   FULLNAME       FLAGS */
338COMP( 1980, phunsy,  0,       0,   phunsy,    phunsy,     phunsy, "J.F.P. Philipse",   "PHUNSY", GAME_NOT_WORKING )
331COMP( 1980, phunsy,  0,       0,     phunsy,    phunsy, 0, "J.F.P. Philipse",   "PHUNSY", GAME_NOT_WORKING )
339332
src/mess/drivers/mes.c
r11049r11050
55        30/08/2010 Skeleton driver
66
77****************************************************************************/
8#define ADDRESS_MAP_MODERN
89
910#include "emu.h"
1011#include "cpu/z80/z80.h"
1112
13#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
14#define VIDEO_START_MEMBER(name) void name::video_start()
15#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
1216
1317class mes_state : public driver_device
1418{
1519public:
1620   mes_state(running_machine &machine, const driver_device_config_base &config)
17      : driver_device(machine, config) { }
21      : driver_device(machine, config),
22   m_maincpu(*this, "maincpu")
23   { }
1824
19   const UINT8 *m_FNT;
20   const UINT8 *m_videoram;
25   required_device<cpu_device> m_maincpu;
26   const UINT8 *m_p_chargen;
27   const UINT8 *m_p_videoram;
28   virtual void machine_reset();
29   virtual void video_start();
30   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
2131};
2232
2333
2434
25static ADDRESS_MAP_START(mes_mem, AS_PROGRAM, 8)
35static ADDRESS_MAP_START(mes_mem, AS_PROGRAM, 8, mes_state)
2636   ADDRESS_MAP_UNMAP_HIGH
2737   AM_RANGE(0x0000, 0x0fff) AM_ROM
28   AM_RANGE(0x1000, 0xffff) AM_RAM AM_REGION("maincpu", 0x1000)
38   AM_RANGE(0x1000, 0xefff) AM_RAM
39   AM_RANGE(0xf000, 0xffff) AM_RAM AM_BASE(m_p_videoram)
2940ADDRESS_MAP_END
3041
31static ADDRESS_MAP_START( mes_io, AS_IO, 8 )
42static ADDRESS_MAP_START( mes_io, AS_IO, 8, mes_state)
3243   ADDRESS_MAP_GLOBAL_MASK(0xff)
3344ADDRESS_MAP_END
3445
r11049r11050
3647static INPUT_PORTS_START( mes )
3748INPUT_PORTS_END
3849
39static MACHINE_RESET(mes)
50MACHINE_RESET_MEMBER(mes_state)
4051{
4152}
4253
43static VIDEO_START( mes )
54VIDEO_START_MEMBER( mes_state )
4455{
45   mes_state *state = machine.driver_data<mes_state>();
46   state->m_FNT = machine.region("chargen")->base();
47   state->m_videoram = machine.region("maincpu")->base()+0xf000;
56   m_p_chargen = m_machine.region("chargen")->base();
4857}
4958
5059/* This system appears to have 2 screens. Not implemented.
5160    Also the screen dimensions are a guess. */
52static SCREEN_UPDATE( mes )
61SCREEN_UPDATE_MEMBER( mes_state )
5362{
54   mes_state *state = screen->machine().driver_data<mes_state>();
5563   //static UINT8 framecnt=0;
5664   UINT8 y,ra,chr,gfx;
5765   UINT16 sy=0,ma=0,x,xx;
r11049r11050
6270   {
6371      for (ra = 0; ra < 10; ra++)
6472      {
65         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
73         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
6674
6775         xx = ma;
6876         for (x = ma; x < ma + 80; x++)
r11049r11050
7078            gfx = 0;
7179            if (ra < 9)
7280            {
73               chr = state->m_videoram[xx++];
81               chr = m_p_videoram[xx++];
7482
7583            //  /* Take care of flashing characters */
7684            //  if ((chr < 0x80) && (framecnt & 0x08))
r11049r11050
8088                  x--;
8189               else
8290               {
83                  gfx = state->m_FNT[(chr<<4) | ra ];
91                  gfx = m_p_chargen[(chr<<4) | ra ];
8492
8593                  /* Display a scanline of a character */
86                  *p++ = ( gfx & 0x80 ) ? 1 : 0;
87                  *p++ = ( gfx & 0x40 ) ? 1 : 0;
88                  *p++ = ( gfx & 0x20 ) ? 1 : 0;
89                  *p++ = ( gfx & 0x10 ) ? 1 : 0;
90                  *p++ = ( gfx & 0x08 ) ? 1 : 0;
91                  *p++ = ( gfx & 0x04 ) ? 1 : 0;
92                  *p++ = ( gfx & 0x02 ) ? 1 : 0;
93                  *p++ = ( gfx & 0x01 ) ? 1 : 0;
94                  *p++ = BIT(gfx, 7);
95                  *p++ = BIT(gfx, 6);
96                  *p++ = BIT(gfx, 5);
97                  *p++ = BIT(gfx, 4);
98                  *p++ = BIT(gfx, 3);
99                  *p++ = BIT(gfx, 2);
100                  *p++ = BIT(gfx, 1);
101                  *p++ = BIT(gfx, 0);
94102               }
95103            }
96104         }
r11049r11050
101109}
102110
103111static MACHINE_CONFIG_START( mes, mes_state )
104    /* basic machine hardware */
105    MCFG_CPU_ADD("maincpu", Z80, XTAL_16MHz / 4)
106    MCFG_CPU_PROGRAM_MAP(mes_mem)
112   /* basic machine hardware */
113   MCFG_CPU_ADD("maincpu", Z80, XTAL_16MHz / 4)
114   MCFG_CPU_PROGRAM_MAP(mes_mem)
107115   MCFG_CPU_IO_MAP(mes_io)
108116
109    MCFG_MACHINE_RESET(mes)
110
111    /* video hardware */
117   /* video hardware */
112118   MCFG_SCREEN_ADD("screen", RASTER)
113119   MCFG_SCREEN_REFRESH_RATE(60)
114120   MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
115121   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
116122   MCFG_SCREEN_SIZE(640, 250)
117123   MCFG_SCREEN_VISIBLE_AREA(0, 639, 0, 249)
118    MCFG_SCREEN_UPDATE(mes)
119
120    MCFG_PALETTE_LENGTH(2)
121    MCFG_PALETTE_INIT(black_and_white)
122
123    MCFG_VIDEO_START(mes)
124   MCFG_PALETTE_LENGTH(2)
125   MCFG_PALETTE_INIT(black_and_white)
124126MACHINE_CONFIG_END
125127
126128
127129/* ROM definition */
128130ROM_START( mes )
129    ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF )
131   ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF )
130132   ROM_LOAD( "mescpu.bin",   0x0000, 0x1000, CRC(b6d90cf4) SHA1(19e608af5bdaabb00a134e1106b151b00e2a0b04))
131    ROM_REGION( 0x10000, "xebec", ROMREGION_ERASEFF )
133
134   ROM_REGION( 0x10000, "xebec", ROMREGION_ERASEFF )
132135   ROM_LOAD( "mesxebec.bin", 0x0000, 0x2000, CRC(061b7212) SHA1(c5d600116fb7563c69ebd909eb9613269b2ada0f))
133136
134137   /* character generator not dumped, using the one from 'c10' for now */
r11049r11050
139142/* Driver */
140143
141144/*   YEAR  NAME    PARENT  COMPAT   MACHINE  INPUT  INIT        COMPANY   FULLNAME       FLAGS */
142COMP( 198?, mes,  0,       0,   mes,   mes,    0,      "Schleicher",   "MES",      GAME_NOT_WORKING | GAME_NO_SOUND)
145COMP( 198?, mes,  0,       0,   mes,   mes,    0,      "Schleicher",   "MES", GAME_NOT_WORKING | GAME_NO_SOUND)
src/mess/drivers/dim68k.c
r11049r11050
3737#include "sound/speaker.h"
3838#include "video/mc6845.h"
3939
40#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
41#define VIDEO_START_MEMBER(name) void name::video_start()
42#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
43
4044class dim68k_state : public driver_device
4145{
4246public:
r11049r11050
6468   DECLARE_WRITE16_MEMBER( dim68k_video_high_w );
6569   DECLARE_WRITE16_MEMBER( dim68k_video_reset_w );
6670   UINT16* m_ram;
67   UINT8 *m_FNT;
68   UINT8 m_speaker_bit;
71   const UINT8 *m_p_chargen;
72   bool m_speaker_bit;
6973   UINT8 m_video_control;
74   virtual void machine_reset();
75   virtual void video_start();
76   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
7077};
7178
7279READ16_MEMBER( dim68k_state::dim68k_duart_r )
r11049r11050
195202INPUT_PORTS_END
196203
197204
198static MACHINE_RESET(dim68k)
205MACHINE_RESET_MEMBER(dim68k_state)
199206{
200   dim68k_state *state = machine.driver_data<dim68k_state>();
201   UINT8* ROM = machine.region("bootrom")->base();
207   UINT8* ROM = m_machine.region("bootrom")->base();
202208
203   memcpy((UINT8*)state->m_ram, ROM, 0x2000);
209   memcpy((UINT8*)m_ram, ROM, 0x2000);
204210
205   machine.device("maincpu")->reset();
211   m_machine.device("maincpu")->reset();
206212}
207213
208static VIDEO_START( dim68k )
214VIDEO_START_MEMBER( dim68k_state )
209215{
210   dim68k_state *state = machine.driver_data<dim68k_state>();
211   state->m_FNT = machine.region("chargen")->base();
216   m_p_chargen = m_machine.region("chargen")->base();
212217}
213218
214static SCREEN_UPDATE( dim68k )
219SCREEN_UPDATE_MEMBER( dim68k_state )
215220{
216   dim68k_state *state = screen->machine().driver_data<dim68k_state>();
217   mc6845_update(state->m_crtc, bitmap, cliprect);
221   mc6845_update(m_crtc, &bitmap, &cliprect);
218222   return 0;
219223}
220224
r11049r11050
243247      xx++;
244248
245249      chr = chr16>>8;
246      gfx = state->m_FNT[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0);
247      *p++ = ( gfx & 0x80 ) ? 1 : 0;
248      *p++ = ( gfx & 0x40 ) ? 1 : 0;
249      *p++ = ( gfx & 0x20 ) ? 1 : 0;
250      *p++ = ( gfx & 0x10 ) ? 1 : 0;
251      *p++ = ( gfx & 0x08 ) ? 1 : 0;
252      *p++ = ( gfx & 0x04 ) ? 1 : 0;
253      *p++ = ( gfx & 0x02 ) ? 1 : 0;
254      if (dot8) *p++ = ( gfx & 0x01 ) ? 1 : 0;
250      gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0);
251      *p++ = BIT(gfx, 7);
252      *p++ = BIT(gfx, 6);
253      *p++ = BIT(gfx, 5);
254      *p++ = BIT(gfx, 4);
255      *p++ = BIT(gfx, 3);
256      *p++ = BIT(gfx, 2);
257      *p++ = BIT(gfx, 1);
258      if (dot8) *p++ = BIT(gfx, 1);
255259
256260      inv = 0;
257261      if (xx == cursor_x) inv=0xff;
258262      xx++;
259263
260264      chr = chr16;
261      gfx = state->m_FNT[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0);
262      *p++ = ( gfx & 0x80 ) ? 1 : 0;
263      *p++ = ( gfx & 0x40 ) ? 1 : 0;
264      *p++ = ( gfx & 0x20 ) ? 1 : 0;
265      *p++ = ( gfx & 0x10 ) ? 1 : 0;
266      *p++ = ( gfx & 0x08 ) ? 1 : 0;
267      *p++ = ( gfx & 0x04 ) ? 1 : 0;
268      *p++ = ( gfx & 0x02 ) ? 1 : 0;
269      if (dot8) *p++ = ( gfx & 0x01 ) ? 1 : 0;
265      gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv ^ ((chr & 0x80) ? 0xff : 0);
266      *p++ = BIT(gfx, 7);
267      *p++ = BIT(gfx, 6);
268      *p++ = BIT(gfx, 5);
269      *p++ = BIT(gfx, 4);
270      *p++ = BIT(gfx, 3);
271      *p++ = BIT(gfx, 2);
272      *p++ = BIT(gfx, 1);
273      if (dot8) *p++ = BIT(gfx, 1);
270274   }
271275}
272276
r11049r11050
306310   MCFG_CPU_ADD("maincpu", M68000, XTAL_10MHz)
307311   MCFG_CPU_PROGRAM_MAP(dim68k_mem)
308312
309   MCFG_MACHINE_RESET(dim68k)
310
311313   /* video hardware */
312314   MCFG_SCREEN_ADD("screen", RASTER)
313315   MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
315317   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
316318   MCFG_SCREEN_SIZE(640, 480)
317319   MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 250-1)
318   MCFG_SCREEN_UPDATE(dim68k)
319
320320   MCFG_PALETTE_LENGTH(2)
321321   MCFG_PALETTE_INIT(black_and_white)
322322   MCFG_GFXDECODE(dim68k)
323323
324   MCFG_VIDEO_START(dim68k)
325   MCFG_MC6845_ADD("crtc", MC6845, 1790000, dim68k_crtc)
326
327324   /* sound hardware */
328325   MCFG_SPEAKER_STANDARD_MONO("mono")
329326   MCFG_SOUND_ADD("speaker", SPEAKER_SOUND, 0)
330327   MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
328
329   /* Devices */
330   MCFG_MC6845_ADD("crtc", MC6845, 1790000, dim68k_crtc)
331331MACHINE_CONFIG_END
332332
333333/*
src/mess/drivers/pegasus.c
r11049r11050
4343#include "imagedev/cartslot.h"
4444#include "imagedev/cassette.h"
4545
46#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
47#define MACHINE_START_MEMBER(name) void name::machine_start()
48#define VIDEO_START_MEMBER(name) void name::video_start()
49#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
50
4651class pegasus_state : public driver_device
4752{
4853public:
r11049r11050
6974   DECLARE_WRITE_LINE_MEMBER( pegasus_cassette_w );
7075   DECLARE_WRITE_LINE_MEMBER( pegasus_firq_clr );
7176   UINT8 m_kbd_row;
72   UINT8 m_kbd_irq;
73   UINT8 *m_pcgram;
74   UINT8 *m_videoram;
75   UINT8 *m_FNT;
77   bool m_kbd_irq;
78   UINT8 *m_p_pcgram;
79   const UINT8 *m_p_videoram;
80   const UINT8 *m_p_chargen;
7681   UINT8 m_control_bits;
82   virtual void machine_reset();
83   virtual void machine_start();
84   virtual void video_start();
85   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
7786};
7887
7988static TIMER_DEVICE_CALLBACK( pegasus_firq )
r11049r11050
133142
134143READ8_MEMBER( pegasus_state::pegasus_pcg_r )
135144{
136   UINT8 code = m_videoram[offset] & 0x7f;
137   return m_pcgram[(code << 4) | (~m_kbd_row & 15)];
145   UINT8 code = m_p_videoram[offset] & 0x7f;
146   return m_p_pcgram[(code << 4) | (~m_kbd_row & 15)];
138147}
139148
140149WRITE8_MEMBER( pegasus_state::pegasus_pcg_w )
141150{
142//  if (state->m_control_bits & 2)
151//  if (m_control_bits & 2)
143152   {
144      UINT8 code = m_videoram[offset] & 0x7f;
145      m_pcgram[(code << 4) | (~m_kbd_row & 15)] = data;
153      UINT8 code = m_p_videoram[offset] & 0x7f;
154      m_p_pcgram[(code << 4) | (~m_kbd_row & 15)] = data;
146155   }
147156}
148157
r11049r11050
158167   ADDRESS_MAP_UNMAP_HIGH
159168   AM_RANGE(0x0000, 0x2fff) AM_ROM
160169   AM_RANGE(0xb000, 0xbdff) AM_RAM
161   AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_videoram)
170   AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_p_videoram)
162171   AM_RANGE(0xc000, 0xdfff) AM_ROM AM_WRITENOP
163172   AM_RANGE(0xe000, 0xe1ff) AM_READ(pegasus_protection_r)
164173   AM_RANGE(0xe200, 0xe3ff) AM_READWRITE(pegasus_pcg_r,pegasus_pcg_w)
r11049r11050
171180   ADDRESS_MAP_UNMAP_HIGH
172181   AM_RANGE(0x0000, 0x2fff) AM_ROM
173182   AM_RANGE(0x5000, 0xbdff) AM_RAM
174   AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_videoram)
183   AM_RANGE(0xbe00, 0xbfff) AM_RAM AM_BASE(m_p_videoram)
175184   AM_RANGE(0xc000, 0xdfff) AM_ROM AM_WRITENOP
176185   AM_RANGE(0xe000, 0xe1ff) AM_READ(pegasus_protection_r)
177186   AM_RANGE(0xe200, 0xe3ff) AM_READWRITE(pegasus_pcg_r,pegasus_pcg_w)
r11049r11050
306315};
307316
308317
309static VIDEO_START( pegasus )
318VIDEO_START_MEMBER( pegasus_state )
310319{
311   pegasus_state *state = machine.driver_data<pegasus_state>();
312   state->m_FNT = machine.region("chargen")->base();
320   m_p_chargen = m_machine.region("chargen")->base();
313321}
314322
315323static const UINT8 mcm6571a_shift[] =
r11049r11050
325333};
326334
327335
328static SCREEN_UPDATE( pegasus )
336SCREEN_UPDATE_MEMBER( pegasus_state )
329337{
330   pegasus_state *state = screen->machine().driver_data<pegasus_state>();
331338   UINT8 y,ra,chr,gfx,inv;
332339   UINT16 sy=0,ma=0,x;
333   UINT8 pcg_mode = state->m_control_bits & 2;
340   UINT8 pcg_mode = m_control_bits & 2;
334341
335342   for(y = 0; y < 16; y++ )
336343   {
337344      for(ra = 0; ra < 16; ra++ )
338345      {
339         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
346         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
340347
341348         for(x = ma; x < ma + 32; x++ )
342349         {
343350            inv = 0xff;
344351            gfx = 0;
345            chr = state->m_videoram[x];
352            chr = m_p_videoram[x];
346353
347354            if (BIT(chr, 7))
348355            {
r11049r11050
352359
353360            if (pcg_mode)
354361            {
355               gfx = state->m_pcgram[(chr << 4) | ra] ^ inv;
362               gfx = m_p_pcgram[(chr << 4) | ra] ^ inv;
356363            }
357364            else
358365            if (mcm6571a_shift[chr])
r11049r11050
360367               if (ra < 3)
361368                  gfx = inv;
362369               else
363                  gfx = state->m_FNT[(chr<<4) | (ra-3) ] ^ inv;
370                  gfx = m_p_chargen[(chr<<4) | (ra-3) ] ^ inv;
364371            }
365372            else
366373            {
367374               if (ra < 10)
368                  gfx = state->m_FNT[(chr<<4) | ra ] ^ inv;
375                  gfx = m_p_chargen[(chr<<4) | ra ] ^ inv;
369376               else
370377                  gfx = inv;
371378            }
372379
373380            /* Display a scanline of a character */
374            *p++ = BIT(gfx, 7) ? 1 : 0;
375            *p++ = BIT(gfx, 6) ? 1 : 0;
376            *p++ = BIT(gfx, 5) ? 1 : 0;
377            *p++ = BIT(gfx, 4) ? 1 : 0;
378            *p++ = BIT(gfx, 3) ? 1 : 0;
379            *p++ = BIT(gfx, 2) ? 1 : 0;
380            *p++ = BIT(gfx, 1) ? 1 : 0;
381            *p++ = BIT(gfx, 0) ? 1 : 0;
381            *p++ = BIT(gfx, 7);
382            *p++ = BIT(gfx, 6);
383            *p++ = BIT(gfx, 5);
384            *p++ = BIT(gfx, 4);
385            *p++ = BIT(gfx, 3);
386            *p++ = BIT(gfx, 2);
387            *p++ = BIT(gfx, 1);
388            *p++ = BIT(gfx, 0);
382389         }
383390      }
384391      ma+=32;
r11049r11050
467474   return IMAGE_INIT_PASS;
468475}
469476
470static MACHINE_START( pegasus )
477MACHINE_START_MEMBER( pegasus_state )
471478{
472   pegasus_state *state = machine.driver_data<pegasus_state>();
473   state->m_pcgram = machine.region("pcg")->base();
479   m_p_pcgram = m_machine.region("pcg")->base();
474480}
475481
476static MACHINE_RESET( pegasus )
482MACHINE_RESET_MEMBER( pegasus_state )
477483{
478   pegasus_state *state = machine.driver_data<pegasus_state>();
479   state->m_kbd_row = 0;
480   state->m_kbd_irq = 1;
481   state->m_control_bits = 0;
484   m_kbd_row = 0;
485   m_kbd_irq = 1;
486   m_control_bits = 0;
482487}
483488
484489static DRIVER_INIT( pegasus )
r11049r11050
492497   MCFG_CPU_PROGRAM_MAP(pegasus_mem)
493498
494499   MCFG_TIMER_ADD_PERIODIC("pegasus_firq", pegasus_firq, attotime::from_hz(400))   // controls accuracy of the clock (ctrl-P)
495   MCFG_MACHINE_START(pegasus)
496   MCFG_MACHINE_RESET(pegasus)
500
497501   /* video hardware */
498502   MCFG_SCREEN_ADD("screen", RASTER)
499503   MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
501505   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
502506   MCFG_SCREEN_SIZE(32*8, 16*16)
503507   MCFG_SCREEN_VISIBLE_AREA(0, 32*8-1, 0, 16*16-1)
504   MCFG_SCREEN_UPDATE(pegasus)
505   
506508   MCFG_GFXDECODE(pegasus)
507509   MCFG_PALETTE_LENGTH(2)
508510   MCFG_PALETTE_INIT(black_and_white)
509   MCFG_VIDEO_START(pegasus)
510511   
511512   /* devices */
512513   MCFG_PIA6821_ADD( "pia_s", pegasus_pia_s_intf )
src/mess/drivers/zrt80.c
r11049r11050
2222#include "machine/terminal.h"
2323#include "sound/beep.h"
2424
25#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
26#define VIDEO_START_MEMBER(name) void name::video_start()
27#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
2528
2629class zrt80_state : public driver_device
2730{
r11049r11050
4548   DECLARE_WRITE8_MEMBER( zrt80_38_w );
4649   DECLARE_WRITE8_MEMBER( zrt80_kbd_put );
4750   UINT8 m_term_data;
48   UINT8 *m_videoram;
49   UINT8 *m_FNT;
51   const UINT8 *m_p_videoram;
52   const UINT8 *m_p_chargen;
53   virtual void machine_reset();
54   virtual void video_start();
55   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
5056};
5157
5258READ8_MEMBER( zrt80_state::zrt80_10_r )
r11049r11050
8086   AM_RANGE(0x1000, 0x1fff) AM_ROM // Z24 - Expansion
8187   AM_RANGE(0x4000, 0x43ff) AM_RAM   // Board RAM
8288   // Normally video RAM is 0x800 but could be expanded up to 8K
83   AM_RANGE(0xc000, 0xdfff) AM_RAM   AM_BASE(m_videoram) // Video RAM
89   AM_RANGE(0xc000, 0xdfff) AM_RAM   AM_BASE(m_p_videoram) // Video RAM
8490
8591ADDRESS_MAP_END
8692
r11049r11050
180186INPUT_PORTS_END
181187
182188
183static MACHINE_RESET(zrt80)
189MACHINE_RESET_MEMBER(zrt80_state)
184190{
185   zrt80_state *state = machine.driver_data<zrt80_state>();
186   beep_set_frequency(state->m_beep, 800);
191   beep_set_frequency(m_beep, 800);
187192}
188193
189static VIDEO_START( zrt80 )
194VIDEO_START_MEMBER( zrt80_state )
190195{
191   zrt80_state *state = machine.driver_data<zrt80_state>();
192   state->m_FNT = machine.region("chargen")->base();
196   m_p_chargen = m_machine.region("chargen")->base();
193197}
194198
195static SCREEN_UPDATE( zrt80 )
199SCREEN_UPDATE_MEMBER( zrt80_state )
196200{
197   device_t *mc6845 = screen->machine().device("crtc");
198   mc6845_update(mc6845, bitmap, cliprect);
201   mc6845_update(m_crtc, &bitmap, &cliprect);
199202   return 0;
200203}
201204
202205static MC6845_UPDATE_ROW( zrt80_update_row )
203206{
204207   zrt80_state *state = device->machine().driver_data<zrt80_state>();
205   UINT8 chr,gfx,inv,i;
208   UINT8 chr,gfx,inv;
206209   UINT16 mem,x;
207210   UINT16 *p = BITMAP_ADDR16(bitmap, y, 0);
208211   UINT8 polarity = input_port_read(device->machine(), "DIPSW1") & 4 ? 0xff : 0;
r11049r11050
212215      inv = polarity;
213216      if (x == cursor_x) inv ^= 0xff;
214217      mem = (ma + x) & 0x1fff;
215      chr = state->m_videoram[mem];
218      chr = state->m_p_videoram[mem];
216219
217220      if BIT(chr, 7)
218221      {
r11049r11050
220223         chr &= 0x7f;
221224      }
222225
223      gfx = state->m_FNT[(chr<<4) | ra] ^ inv;
226      gfx = state->m_p_chargen[(chr<<4) | ra] ^ inv;
224227
225228      /* Display a scanline of a character */
226      for (i = 0; i < 8; i++)
227         *p++ = BIT(gfx, 7-i);
229      *p++ = BIT(gfx, 7);
230      *p++ = BIT(gfx, 6);
231      *p++ = BIT(gfx, 5);
232      *p++ = BIT(gfx, 4);
233      *p++ = BIT(gfx, 3);
234      *p++ = BIT(gfx, 2);
235      *p++ = BIT(gfx, 1);
236      *p++ = BIT(gfx, 0);
228237   }
229238}
230239
r11049r11050
244253
245254static INS8250_INTERRUPT( zrt80_com_interrupt )
246255{
247   logerror("com int\r\n");
248256   cputag_set_input_line(device->machine(), "maincpu", INPUT_LINE_IRQ0, state);
249257}
250258
r11049r11050
293301   MCFG_CPU_PROGRAM_MAP(zrt80_mem)
294302   MCFG_CPU_IO_MAP(zrt80_io)
295303
296   MCFG_MACHINE_RESET(zrt80)
297
298304   /* video hardware */
299305   MCFG_SCREEN_ADD("screen", RASTER)
300306   MCFG_SCREEN_REFRESH_RATE(60)
r11049r11050
302308   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
303309   MCFG_SCREEN_SIZE(640, 200)
304310   MCFG_SCREEN_VISIBLE_AREA(0, 640 - 1, 0, 200 - 1)
305   MCFG_SCREEN_UPDATE(zrt80)
306
307311   MCFG_GFXDECODE(zrt80)
308312   MCFG_PALETTE_LENGTH(2)
309313   MCFG_PALETTE_INIT(black_and_white)
310314
311   MCFG_MC6845_ADD("crtc", MC6845, XTAL_20MHz / 8, zrt80_crtc6845_interface)
312
313   MCFG_VIDEO_START(zrt80)
314
315   MCFG_INS8250_ADD( "ins8250", zrt80_com_interface )
316   MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, zrt80_terminal_intf)
317
318315   /* sound hardware */
319316   MCFG_SPEAKER_STANDARD_MONO("mono")
320317   MCFG_SOUND_ADD("beep", BEEP, 0)
321318   MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.50)
319
320   /* Devices */
321   MCFG_MC6845_ADD("crtc", MC6845, XTAL_20MHz / 8, zrt80_crtc6845_interface)
322   MCFG_INS8250_ADD( "ins8250", zrt80_com_interface )
323   MCFG_GENERIC_TERMINAL_ADD(TERMINAL_TAG, zrt80_terminal_intf)
322324MACHINE_CONFIG_END
323325
324326/* ROM definition */
325327ROM_START( zrt80 )
326328   ROM_REGION( 0x10000, "maincpu", ROMREGION_ERASEFF )
327   ROM_LOAD( "zrt80mon.z25", 0x0000, 0x1000, CRC(e6ea96dc) SHA1(e3075e30bb2b85f9288d0b8b8cdf1d2b4f7586fd))
329   ROM_LOAD("zrt80mon.z25", 0x0000, 0x1000, CRC(e6ea96dc) SHA1(e3075e30bb2b85f9288d0b8b8cdf1d2b4f7586fd) )
328330   //z24 is 2nd chip, used as expansion
329331
330332   ROM_REGION( 0x0800, "chargen", 0 )
331   ROM_LOAD( "zrt80chr.z30", 0x0000, 0x0800, CRC(4dbdc60f) SHA1(20e393f7207a8440029c8290cdf2f121d317a37e))
333   ROM_LOAD("zrt80chr.z30", 0x0000, 0x0800, CRC(4dbdc60f) SHA1(20e393f7207a8440029c8290cdf2f121d317a37e) )
332334ROM_END
333335
334336/* Driver */
src/mess/drivers/vta2000.c
r11049r11050
99        29/11/2010 Skeleton driver.
1010
1111****************************************************************************/
12#define ADDRESS_MAP_MODERN
1213
1314#include "emu.h"
1415#include "cpu/i8085/i8085.h"
r11049r11050
1718{
1819public:
1920   vta2000_state(running_machine &machine, const driver_device_config_base &config)
20      : driver_device(machine, config) { }
21      : driver_device(machine, config),
22   m_maincpu(*this, "maincpu")
23   { }
2124
22   const UINT8 *m_FNT;
23   const UINT8 *m_videoram;
25   required_device<cpu_device> m_maincpu;
26   const UINT8 *m_p_chargen;
27   const UINT8 *m_p_videoram;
2428};
2529
26static ADDRESS_MAP_START(vta2000_mem, AS_PROGRAM, 8)
30static ADDRESS_MAP_START(vta2000_mem, AS_PROGRAM, 8, vta2000_state)
2731   ADDRESS_MAP_UNMAP_HIGH
2832   AM_RANGE( 0x0000, 0x5fff ) AM_ROM
2933   AM_RANGE( 0x8000, 0xffff ) AM_RAM AM_REGION("maincpu", 0x8000)
3034ADDRESS_MAP_END
3135
32static ADDRESS_MAP_START(vta2000_io, AS_IO, 8)
36static ADDRESS_MAP_START(vta2000_io, AS_IO, 8, vta2000_state)
37   ADDRESS_MAP_GLOBAL_MASK(0xff)
3338   ADDRESS_MAP_UNMAP_HIGH
3439ADDRESS_MAP_END
3540
r11049r11050
4550static VIDEO_START( vta2000 )
4651{
4752   vta2000_state *state = machine.driver_data<vta2000_state>();
48   state->m_FNT = machine.region("chargen")->base();
49   state->m_videoram = machine.region("maincpu")->base()+0x80a0;
53   state->m_p_chargen = machine.region("chargen")->base();
54   state->m_p_videoram = machine.region("maincpu")->base()+0x80a0;
5055}
5156
5257static SCREEN_UPDATE( vta2000 )
r11049r11050
6974   {
7075      for (ra = 0; ra < 12; ra++)
7176      {
72         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
77         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
7378
7479         xx = ma << 1;
7580         for (x = ma; x < ma + 80; x++)
7681         {
77            chr = state->m_videoram[xx++];
78            attr = state->m_videoram[xx++];
82            chr = state->m_p_videoram[xx++];
83            attr = state->m_p_videoram[xx++];
7984
8085            if ((chr & 0x60)==0x60)
8186               chr+=256;
8287
83            gfx = state->m_FNT[(chr<<4) | ra ];
88            gfx = state->m_p_chargen[(chr<<4) | ra ];
8489
8590            /* Display a scanline of a character */
86            *p++ = ( gfx & 0x80 ) ? 1 : 0;
87            *p++ = ( gfx & 0x40 ) ? 1 : 0;
88            *p++ = ( gfx & 0x20 ) ? 1 : 0;
89            *p++ = ( gfx & 0x10 ) ? 1 : 0;
90            *p++ = ( gfx & 0x08 ) ? 1 : 0;
91            *p++ = ( gfx & 0x04 ) ? 1 : 0;
92            *p++ = ( gfx & 0x02 ) ? 1 : 0;
93            *p++ = ( gfx & 0x01 ) ? 1 : 0;
91            *p++ = BIT(gfx, 7);
92            *p++ = BIT(gfx, 6);
93            *p++ = BIT(gfx, 5);
94            *p++ = BIT(gfx, 4);
95            *p++ = BIT(gfx, 3);
96            *p++ = BIT(gfx, 2);
97            *p++ = BIT(gfx, 1);
98            *p++ = BIT(gfx, 0);
9499         }
95100      }
96101      ma+=132;
r11049r11050
156161/* Driver */
157162
158163/*    YEAR  NAME    PARENT  COMPAT   MACHINE    INPUT    INIT     COMPANY   FULLNAME       FLAGS */
159COMP( ????, vta2000,  0,       0,   vta2000,   vta2000,    0,      "<unknown>",   "VTA-2000",      GAME_NOT_WORKING | GAME_NO_SOUND)
164COMP( ????, vta2000,  0,       0,   vta2000,   vta2000,    0,      "<unknown>",   "VTA-2000", GAME_NOT_WORKING | GAME_NO_SOUND)
160165
src/mess/drivers/ptcsol.c
r11049r11050
8989#include "imagedev/cassette.h"
9090#include "machine/ay31015.h"
9191
92#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
93#define MACHINE_START_MEMBER(name) void name::machine_start()
94#define VIDEO_START_MEMBER(name) void name::video_start()
95#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
96
9297typedef struct {
9398   struct {
9499      int length;      /* time cassette level is at input.level */
r11049r11050
137142   UINT8 m_sol20_fa;
138143   UINT8 m_sol20_fc;
139144   UINT8 m_sol20_fe;
140   const UINT8 *m_FNT;
141   const UINT8 *m_videoram;
145   const UINT8 *m_p_chargen;
146   const UINT8 *m_p_videoram;
142147   UINT8 m_framecnt;
143148   emu_timer *m_cassette_timer;
144149   cass_data_t m_cass_data;
150   virtual void machine_reset();
151   virtual void machine_start();
152   virtual void video_start();
153   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
145154};
146155
147156
r11049r11050
361370   AM_RANGE(0X0800, 0Xbfff) AM_RAM   // optional s100 ram
362371   AM_RANGE(0xc000, 0xc7ff) AM_ROM
363372   AM_RANGE(0Xc800, 0Xcbff) AM_RAM   // system ram
364   AM_RANGE(0Xcc00, 0Xcfff) AM_RAM   AM_BASE(m_videoram)
373   AM_RANGE(0Xcc00, 0Xcfff) AM_RAM   AM_BASE(m_p_videoram)
365374   AM_RANGE(0Xd000, 0Xffff) AM_RAM   // optional s100 ram
366375ADDRESS_MAP_END
367376
r11049r11050
489498   memory_set_bank(machine, "boot", 0);
490499}
491500
492static MACHINE_START( sol20 )
501MACHINE_START_MEMBER( sol20_state )
493502{
494   sol20_state *state = machine.driver_data<sol20_state>();
495   state->m_cassette_timer = machine.scheduler().timer_alloc(FUNC(sol20_cassette_tc));
503   m_cassette_timer = m_machine.scheduler().timer_alloc(FUNC(sol20_cassette_tc));
496504}
497505
498static MACHINE_RESET( sol20 )
506MACHINE_RESET_MEMBER( sol20_state )
499507{
500   sol20_state *state = machine.driver_data<sol20_state>();
501508   UINT8 data = 0, s_count = 0;
502509   int s_clock;
503510   const UINT16 s_bauds[8]={ 75, 110, 180, 300, 600, 1200, 2400, 4800 };
504   state->m_sol20_fe=0;
505   state->m_sol20_fa=1;
511   m_sol20_fe=0;
512   m_sol20_fa=1;
506513
507514   // set hard-wired uart pins
508   ay31015_set_input_pin( state->m_uart, AY31015_CS, 0 );
509   ay31015_set_input_pin( state->m_uart, AY31015_NB1, 1);
510   ay31015_set_input_pin( state->m_uart, AY31015_NB2, 1);
511   ay31015_set_input_pin( state->m_uart, AY31015_TSB, 1);
512   ay31015_set_input_pin( state->m_uart, AY31015_EPS, 1);
513   ay31015_set_input_pin( state->m_uart, AY31015_NP,  1);
514   ay31015_set_input_pin( state->m_uart, AY31015_CS, 1 );
515   ay31015_set_input_pin( m_uart, AY31015_CS, 0 );
516   ay31015_set_input_pin( m_uart, AY31015_NB1, 1);
517   ay31015_set_input_pin( m_uart, AY31015_NB2, 1);
518   ay31015_set_input_pin( m_uart, AY31015_TSB, 1);
519   ay31015_set_input_pin( m_uart, AY31015_EPS, 1);
520   ay31015_set_input_pin( m_uart, AY31015_NP,  1);
521   ay31015_set_input_pin( m_uart, AY31015_CS, 1 );
515522
516523   // set switched uart pins
517   data = input_port_read(machine, "S4");
518   ay31015_set_input_pin( state->m_uart_s, AY31015_CS, 0 );
519   ay31015_set_input_pin( state->m_uart_s, AY31015_NB1, BIT(data, 1) ? 1 : 0);
520   ay31015_set_input_pin( state->m_uart_s, AY31015_NB2, BIT(data, 2) ? 1 : 0);
521   ay31015_set_input_pin( state->m_uart_s, AY31015_TSB, BIT(data, 3) ? 1 : 0);
522   ay31015_set_input_pin( state->m_uart_s, AY31015_EPS, BIT(data, 0) ? 1 : 0);
523   ay31015_set_input_pin( state->m_uart_s, AY31015_NP, BIT(data, 4) ? 1 : 0);
524   ay31015_set_input_pin( state->m_uart_s, AY31015_CS, 1 );
524   data = input_port_read(m_machine, "S4");
525   ay31015_set_input_pin( m_uart_s, AY31015_CS, 0 );
526   ay31015_set_input_pin( m_uart_s, AY31015_NB1, BIT(data, 1) ? 1 : 0);
527   ay31015_set_input_pin( m_uart_s, AY31015_NB2, BIT(data, 2) ? 1 : 0);
528   ay31015_set_input_pin( m_uart_s, AY31015_TSB, BIT(data, 3) ? 1 : 0);
529   ay31015_set_input_pin( m_uart_s, AY31015_EPS, BIT(data, 0) ? 1 : 0);
530   ay31015_set_input_pin( m_uart_s, AY31015_NP, BIT(data, 4) ? 1 : 0);
531   ay31015_set_input_pin( m_uart_s, AY31015_CS, 1 );
525532
526533   // set rs232 baud rate
527   data = input_port_read(machine, "S3");
534   data = input_port_read(m_machine, "S3");
528535
529536   if (data > 1)
530537      do
r11049r11050
534541      }
535542      while (!(data & 1) && (s_count < 7)); // find which switch is used
536543
537   if ((s_count == 7) && (input_port_read(machine, "CONFIG")&1)) // if highest, look at jumper
544   if ((s_count == 7) && (input_port_read(m_machine, "CONFIG")&1)) // if highest, look at jumper
538545      s_clock = 9600 << 4;
539546   else
540547      s_clock = s_bauds[s_count] << 4;
541548
542549   // these lines could be commented out for now if you want better performance
543   ay31015_set_receiver_clock( state->m_uart_s, s_clock);
544   ay31015_set_transmitter_clock( state->m_uart_s, s_clock);
550   ay31015_set_receiver_clock( m_uart_s, s_clock);
551   ay31015_set_transmitter_clock( m_uart_s, s_clock);
545552
546553   // boot-bank
547   memory_set_bank(machine, "boot", 1);
548   machine.scheduler().timer_set(attotime::from_usec(9), FUNC(sol20_boot));
554   memory_set_bank(m_machine, "boot", 1);
555   m_machine.scheduler().timer_set(attotime::from_usec(9), FUNC(sol20_boot));
549556}
550557
551558static DRIVER_INIT( sol20 )
r11049r11050
554561   memory_configure_bank(machine, "boot", 0, 2, &RAM[0x0000], 0xc000);
555562}
556563
557static VIDEO_START( sol20 )
564VIDEO_START_MEMBER( sol20_state )
558565{
559   sol20_state *state = machine.driver_data<sol20_state>();
560   state->m_FNT = machine.region("chargen")->base();
566   m_p_chargen = m_machine.region("chargen")->base();
561567}
562568
563static SCREEN_UPDATE( sol20 )
569SCREEN_UPDATE_MEMBER( sol20_state )
564570{
565571// Visible screen is 64 x 16, with start position controlled by scroll register.
566572// Each character is 9 pixels wide (blank ones at the right) and 13 lines deep.
567573// Note on blinking characters:
568574// any character with bit 7 set will blink. With DPMON, do DA C000 C2FF to see what happens
569   UINT8 s1 = input_port_read(screen->machine(), "S1");
570   UINT16 which = (input_port_read(screen->machine(), "CONFIG") & 2) << 10;
571   sol20_state *state = screen->machine().driver_data<sol20_state>();
575   UINT8 s1 = input_port_read(machine(), "S1");
576   UINT16 which = (input_port_read(machine(), "CONFIG") & 2) << 10;
572577   UINT8 y,ra,chr,gfx;
573578   UINT16 sy=0,ma,x,inv;
574579   UINT8 polarity = (s1 & 8) ? 0xff : 0;
575580
576581   UINT8 cursor_inv = FALSE;
577   if (((s1 & 0x30) == 0x20) || (((s1 & 0x30) == 0x10) && (state->m_framecnt & 0x08)))
582   if (((s1 & 0x30) == 0x20) || (((s1 & 0x30) == 0x10) && (m_framecnt & 0x08)))
578583      cursor_inv = TRUE;
579584
580   state->m_framecnt++;
585   m_framecnt++;
581586
582   ma = state->m_sol20_fe << 6; // scroll register
587   ma = m_sol20_fe << 6; // scroll register
583588
584589   for (y = 0; y < 16; y++)
585590   {
586591      for (ra = 0; ra < 13; ra++)
587592      {
588         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
593         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
589594
590595         for (x = ma; x < ma + 64; x++)
591596         {
592597            inv = polarity;
593            chr = state->m_videoram[x & 0x3ff];
598            chr = m_p_videoram[x & 0x3ff];
594599
595600            // cursor
596601            if (BIT(chr, 7) && cursor_inv)
r11049r11050
606611               if (ra < 4)
607612                  gfx = inv;
608613               else
609                  gfx = state->m_FNT[which | (chr<<4) | (ra-4) ] ^ inv;
614                  gfx = m_p_chargen[which | (chr<<4) | (ra-4) ] ^ inv;
610615            }
611616            else
612617            {
613618               if (ra < 10)
614                  gfx = state->m_FNT[which | (chr<<4) | (ra-1) ] ^ inv;
619                  gfx = m_p_chargen[which | (chr<<4) | (ra-1) ] ^ inv;
615620               else
616621                  gfx = inv;
617622            }
618623
619624            /* Display a scanline of a character */
620            *p++ = ( gfx & 0x80 ) ? 1 : 0;
621            *p++ = ( gfx & 0x40 ) ? 1 : 0;
622            *p++ = ( gfx & 0x20 ) ? 1 : 0;
623            *p++ = ( gfx & 0x10 ) ? 1 : 0;
624            *p++ = ( gfx & 0x08 ) ? 1 : 0;
625            *p++ = ( gfx & 0x04 ) ? 1 : 0;
626            *p++ = ( gfx & 0x02 ) ? 1 : 0;
627            *p++ = ( gfx & 0x01 ) ? 1 : 0;
625            *p++ = BIT(gfx, 7);
626            *p++ = BIT(gfx, 6);
627            *p++ = BIT(gfx, 5);
628            *p++ = BIT(gfx, 4);
629            *p++ = BIT(gfx, 3);
630            *p++ = BIT(gfx, 2);
631            *p++ = BIT(gfx, 1);
632            *p++ = BIT(gfx, 0);
628633            *p++ = (inv) ? 1 : 0;
629634         }
630635      }
r11049r11050
668673   MCFG_CPU_PROGRAM_MAP(sol20_mem)
669674   MCFG_CPU_IO_MAP(sol20_io)
670675
671   MCFG_MACHINE_START(sol20)
672   MCFG_MACHINE_RESET(sol20)
673
674676   /* video hardware */
675677   MCFG_SCREEN_ADD("screen", RASTER)
676678   MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
678680   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
679681   MCFG_SCREEN_SIZE(576, 208)
680682   MCFG_SCREEN_VISIBLE_AREA(0, 575, 0, 207)
681   MCFG_SCREEN_UPDATE(sol20)
682
683683   MCFG_GFXDECODE(sol20)
684684   MCFG_PALETTE_LENGTH(2)
685685   MCFG_PALETTE_INIT(black_and_white)
686686
687   MCFG_VIDEO_START(sol20)
688
689687   /* sound hardware */
690688   MCFG_SPEAKER_STANDARD_MONO("mono")
691689   MCFG_SOUND_WAVE_ADD("wave.1", "cassette1")
src/mess/drivers/argo.c
r11049r11050
1212#include "emu.h"
1313#include "cpu/z80/z80.h"
1414
15#define MACHINE_RESET_MEMBER(name) void name::machine_reset()
16#define VIDEO_START_MEMBER(name) void name::video_start()
17#define SCREEN_UPDATE_MEMBER(name) bool name::screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect)
1518
1619class argo_state : public driver_device
1720{
r11049r11050
2225   { }
2326
2427   required_device<cpu_device> m_maincpu;
25   UINT8* m_videoram;
26   const UINT8 *m_FNT;
28   const UINT8 *m_p_videoram;
29   const UINT8 *m_p_chargen;
2730   UINT8 m_framecnt;
31   virtual void machine_reset();
32   virtual void video_start();
33   virtual bool screen_update(screen_device &screen, bitmap_t &bitmap, const rectangle &cliprect);
2834};
2935
3036
r11049r11050
3238   ADDRESS_MAP_UNMAP_HIGH
3339   AM_RANGE(0x0000, 0x07ff) AM_RAMBANK("boot")
3440   AM_RANGE(0x0800, 0xf7af) AM_RAM
35   AM_RANGE(0xf7b0, 0xf7ff) AM_RAM AM_BASE(m_videoram)
41   AM_RANGE(0xf7b0, 0xf7ff) AM_RAM AM_BASE(m_p_videoram)
3642   AM_RANGE(0xf800, 0xffff) AM_ROM
3743ADDRESS_MAP_END
3844
r11049r11050
5258   memory_set_bank(machine, "boot", 0);
5359}
5460
55static MACHINE_RESET(argo)
61MACHINE_RESET_MEMBER(argo_state)
5662{
57   memory_set_bank(machine, "boot", 1);
58   machine.scheduler().timer_set(attotime::from_usec(5), FUNC(argo_boot));
63   memory_set_bank(m_machine, "boot", 1);
64   m_machine.scheduler().timer_set(attotime::from_usec(5), FUNC(argo_boot));
5965}
6066
6167DRIVER_INIT( argo )
r11049r11050
6470   memory_configure_bank(machine, "boot", 0, 2, &RAM[0x0000], 0xf800);
6571}
6672
67static VIDEO_START( argo )
73VIDEO_START_MEMBER( argo_state )
6874{
69   argo_state *state = machine.driver_data<argo_state>();
70   state->m_FNT = machine.region("chargen")->base();
75   m_p_chargen = m_machine.region("chargen")->base();
7176}
7277
73static SCREEN_UPDATE( argo )
78SCREEN_UPDATE_MEMBER( argo_state )
7479{
75   argo_state *state = screen->machine().driver_data<argo_state>();
76   UINT8 y,ra,chr,gfx,i;
80   UINT8 y,ra,chr,gfx;
7781   UINT16 sy=0,ma=0,x;
7882
79   state->m_framecnt++;
83   m_framecnt++;
8084
8185   for (y = 0; y < 5; y++)
8286   {
8387      for (ra = 0; ra < 10; ra++)
8488      {
85         UINT16 *p = BITMAP_ADDR16(bitmap, sy++, 0);
89         UINT16 *p = BITMAP_ADDR16(&bitmap, sy++, 0);
8690
8791         for (x = ma; x < ma + 16; x++)
8892         {
r11049r11050
9094
9195            if (ra < 9)
9296            {
93               chr = state->m_videoram[x];
97               chr = m_p_videoram[x];
9498
9599               /* Take care of flashing characters */
96               if ((chr & 0x80) && (state->m_framecnt & 0x08))
100               if ((chr & 0x80) && (m_framecnt & 0x08))
97101                  chr = 0x20;
98102
99103               chr &= 0x7f;
100104
101               gfx = state->m_FNT[(chr<<4) | ra ];
105               gfx = m_p_chargen[(chr<<4) | ra ];
102106            }
103107
104108            /* Display a scanline of a character */
105            for (i = 0; i < 8; i++)
106               *p++ = BIT(gfx, 7-i);
109            *p++ = BIT(gfx, 7);
110            *p++ = BIT(gfx, 6);
111            *p++ = BIT(gfx, 5);
112            *p++ = BIT(gfx, 4);
113            *p++ = BIT(gfx, 3);
114            *p++ = BIT(gfx, 2);
115            *p++ = BIT(gfx, 1);
116            *p++ = BIT(gfx, 0);
107117         }
108118      }
109119      ma+=16;
r11049r11050
117127   MCFG_CPU_PROGRAM_MAP(argo_mem)
118128   MCFG_CPU_IO_MAP(argo_io)
119129
120   MCFG_MACHINE_RESET(argo)
121
122130   /* video hardware */
123131   MCFG_SCREEN_ADD("screen", RASTER)
124132   MCFG_SCREEN_REFRESH_RATE(50)
r11049r11050
126134   MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
127135   MCFG_SCREEN_SIZE(128, 50)
128136   MCFG_SCREEN_VISIBLE_AREA(0, 128-1, 0, 50-1)
129   MCFG_SCREEN_UPDATE(argo)
130
131137   MCFG_PALETTE_LENGTH(2)
132138   MCFG_PALETTE_INIT(black_and_white)
133
134   MCFG_VIDEO_START(argo)
135139MACHINE_CONFIG_END
136140
137141/* ROM definition */

Previous 15994 Revisions Next


© 1998-2018 The MESS Team