← Back to branch summary

~ubuntu-branches/ubuntu/raring/mame/raring-proposed

« back to all changes in this revision

Viewing changes to mess/src/mess/drivers/apricotf.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Jordi Mallach, Emmanuel Kasper
  • Date: 2011-12-19 22:56:27 UTC
  • mfrom: (0.1.2)
  • Revision ID: package-import@ubuntu.com-20111219225627-ub5oga1oys4ogqzm
Tags: 0.144-1
http://bugs.debian.org/651538
[ Jordi Mallach ]
* Fix syntax errors in DEP5 copyright file (lintian).
* Use a versioned copyright Format specification field.
* Update Vcs-* URLs.
* Move transitional packages to the new metapackages section, and make
  them priority extra.
* Remove references to GNU/Linux and MESS sources from copyright.
* Add build variables for s390x.
* Use .xz tarballs as it cuts 4MB for the upstream sources.
* Add nplayers.ini as a patch. Update copyright file to add CC-BY-SA-3.0.

[ Emmanuel Kasper ]
* New upstream release. Closes: #651538.
* Add Free Desktop compliant png icons of various sizes taken from
  the hydroxygen iconset
* Mess is now built from a new source package, to avoid possible source
  incompatibilities between mame and the mess overlay.
* Mame-tools are not built from the mame source package anymore, but
  from the mess source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
mess/src/mess/drivers/apricotf.c
1
 
/***************************************************************************
2
 
 
3
 
    ACT Apricot F1 series
4
 
 
5
 
    preliminary driver by Angelo Salese
6
 
 
7
 
****************************************************************************/
8
 
 
9
 
#include "emu.h"
10
 
#include "cpu/i86/i86.h"
11
 
#include "machine/wd17xx.h"
12
 
#include "imagedev/flopdrv.h"
13
 
#include "cpu/z80/z80daisy.h"
14
 
#include "machine/z80ctc.h"
15
 
#include "imagedev/flopdrv.h"
16
 
#include "formats/basicdsk.h"
17
 
 
18
 
class act_state : public driver_device
19
 
{
20
 
public:
21
 
        act_state(const machine_config &mconfig, device_type type, const char *tag)
22
 
                : driver_device(mconfig, type, tag) { }
23
 
 
24
 
        UINT16 *m_paletteram;
25
 
        UINT16 *m_vram;
26
 
        UINT16 *m_scrollram;
27
 
 
28
 
        UINT8 m_fdrv_num;
29
 
};
30
 
 
31
 
static VIDEO_START( act_f1 )
32
 
{
33
 
}
34
 
 
35
 
static SCREEN_UPDATE( act_f1 )
36
 
{
37
 
        act_state *state = screen->machine().driver_data<act_state>();
38
 
        int x,y,i;
39
 
        int x_count;
40
 
 
41
 
        {
42
 
                for(y=0;y<256;y++)
43
 
                {
44
 
                        x_count = 0;
45
 
                        for(x=0;x<640;x+=8)
46
 
                        {
47
 
                                int pen[2],color;
48
 
 
49
 
                                for (i=0;i<8;i++)
50
 
                                {
51
 
                                        pen[0] = (state->m_vram[state->m_scrollram[y]+x_count])>>(7-i) & 1;
52
 
                                        pen[1] = (state->m_vram[state->m_scrollram[y]+x_count])>>(15-i) & 1;
53
 
 
54
 
                                        color = pen[0]|pen[1]<<1;
55
 
 
56
 
                                        const rectangle &visarea = screen->visible_area();
57
 
                                        if((x+i)<=visarea.max_x && ((y)+0)<visarea.max_y)
58
 
                                                *BITMAP_ADDR16(bitmap, y, x+i) = screen->machine().pens[color];
59
 
                                }
60
 
 
61
 
                                x_count++;
62
 
                        }
63
 
                }
64
 
        }
65
 
 
66
 
        return 0;
67
 
}
68
 
 
69
 
//static UINT8 fdc_irq_flag;
70
 
//static UINT8 fdc_drq_flag;
71
 
//static UINT8 fdc_side;
72
 
//static UINT8 fdc_drive;
73
 
 
74
 
static READ8_HANDLER( act_fdc_r )
75
 
{
76
 
        act_state *state = space->machine().driver_data<act_state>();
77
 
        device_t* dev = space->machine().device("fdc");
78
 
 
79
 
//  printf("%02x\n",offset);
80
 
 
81
 
        floppy_mon_w(floppy_get_device(space->machine(), state->m_fdrv_num), CLEAR_LINE);
82
 
        floppy_drive_set_ready_state(floppy_get_device(space->machine(), state->m_fdrv_num), 1,0);
83
 
 
84
 
        switch(offset)
85
 
        {
86
 
                case 0:
87
 
                        return wd17xx_status_r(dev,offset);
88
 
                case 1:
89
 
                        return wd17xx_track_r(dev,offset);
90
 
                case 2:
91
 
                        return wd17xx_sector_r(dev,offset);
92
 
                case 3:
93
 
                        return wd17xx_data_r(dev,offset);
94
 
                default:
95
 
                        logerror("FDC: read from %04x\n",offset);
96
 
                        return 0xff;
97
 
        }
98
 
 
99
 
        return 0x00;
100
 
}
101
 
 
102
 
static WRITE8_HANDLER( act_fdc_w )
103
 
{
104
 
        act_state *state = space->machine().driver_data<act_state>();
105
 
        device_t* dev = space->machine().device("fdc");
106
 
 
107
 
//  printf("%02x %02x\n",offset,data);
108
 
 
109
 
        floppy_mon_w(floppy_get_device(space->machine(), state->m_fdrv_num), CLEAR_LINE);
110
 
        floppy_drive_set_ready_state(floppy_get_device(space->machine(), state->m_fdrv_num), 1,0);
111
 
 
112
 
        switch(offset)
113
 
        {
114
 
                case 0:
115
 
                        wd17xx_command_w(dev,offset,data);
116
 
                        break;
117
 
                case 1:
118
 
                        wd17xx_track_w(dev,offset,data);
119
 
                        break;
120
 
                case 2:
121
 
                        wd17xx_sector_w(dev,offset,data);
122
 
                        break;
123
 
                case 3:
124
 
                        wd17xx_data_w(dev,offset,data);
125
 
                        break;
126
 
                default:
127
 
                        logerror("FDC: write to %04x = %02x\n",offset,data);
128
 
                        break;
129
 
        }
130
 
}
131
 
 
132
 
static READ16_HANDLER( act_pal_r )
133
 
{
134
 
        act_state *state = space->machine().driver_data<act_state>();
135
 
 
136
 
        return state->m_paletteram[offset];
137
 
}
138
 
 
139
 
static WRITE16_HANDLER( act_pal_w )
140
 
{
141
 
        act_state *state = space->machine().driver_data<act_state>();
142
 
        UINT8 i,r,g,b;
143
 
        COMBINE_DATA(&state->m_paletteram[offset]);
144
 
 
145
 
        if(ACCESSING_BITS_0_7 && offset) //TODO: offset 0 looks bogus
146
 
        {
147
 
                i = state->m_paletteram[offset] & 1;
148
 
                r = ((state->m_paletteram[offset] & 2)>>0) | i;
149
 
                g = ((state->m_paletteram[offset] & 4)>>1) | i;
150
 
                b = ((state->m_paletteram[offset] & 8)>>2) | i;
151
 
 
152
 
                palette_set_color_rgb(space->machine(), offset, pal2bit(r), pal2bit(g), pal2bit(b));
153
 
        }
154
 
}
155
 
 
156
 
static ADDRESS_MAP_START(act_f1_mem, AS_PROGRAM, 16)
157
 
        ADDRESS_MAP_UNMAP_HIGH
158
 
        AM_RANGE(0x01e00,0x01fff) AM_RAM AM_BASE_MEMBER(act_state,m_scrollram)
159
 
        AM_RANGE(0xe0000,0xe001f) AM_READWRITE(act_pal_r,act_pal_w) AM_BASE_MEMBER(act_state,m_paletteram)
160
 
        AM_RANGE(0x00000,0xeffff) AM_RAM AM_BASE_MEMBER(act_state,m_vram)
161
 
        AM_RANGE(0xf0000,0xf7fff) AM_RAM
162
 
        AM_RANGE(0xf8000,0xfffff) AM_ROM
163
 
ADDRESS_MAP_END
164
 
 
165
 
static WRITE8_HANDLER( actf1_sys_w )
166
 
{
167
 
//  static UINT8 cur_fdrv;
168
 
//  device_t* dev = space->machine().device("fdc");
169
 
 
170
 
        switch(offset)
171
 
        {
172
 
                case 0:
173
 
//          cur_fdrv = ~data & 1;
174
 
//          wd17xx_set_drive(dev,cur_fdrv);
175
 
                        break;
176
 
                case 1:
177
 
//          wd17xx_set_side(dev,data ? 1 : 0);
178
 
                        break;
179
 
                case 2:
180
 
//          floppy_drive_set_motor_state(floppy_get_device(space->machine(), cur_fdrv), data);
181
 
//          floppy_drive_set_ready_state(floppy_get_device(space->machine(), cur_fdrv), data,0);
182
 
                        break;
183
 
                case 3:
184
 
//          data ? 256 : 200 line mode
185
 
//          data ? 50 : 60 Hz
186
 
                        break;
187
 
                case 4:
188
 
//          data ? 80 : 40 columns mode
189
 
//          data ? 14 Mhz : 7 Mhz Pixel clock
190
 
                        break;
191
 
                case 5:
192
 
//          caps lock LED
193
 
                        break;
194
 
                case 6:
195
 
//          stop LED
196
 
                        break;
197
 
        }
198
 
}
199
 
 
200
 
static ADDRESS_MAP_START( act_f1_io , AS_IO, 16)
201
 
        ADDRESS_MAP_UNMAP_HIGH
202
 
        AM_RANGE(0x0000, 0x000f) AM_WRITE8(actf1_sys_w,0x00ff)
203
 
        AM_RANGE(0x0010, 0x0017) AM_DEVREADWRITE8("ctc",z80ctc_r,z80ctc_w,0x00ff)
204
 
//  AM_RANGE(0x0020, 0x0027) z80 sio (!)
205
 
//  AM_RANGE(0x0030, 0x0031) AM_WRITE8(ctc_ack_w,0x00ff)
206
 
        AM_RANGE(0x0040, 0x0047) AM_READWRITE8(act_fdc_r, act_fdc_w,0x00ff)
207
 
//  AM_RANGE(0x01e0, 0x01ff) winchester
208
 
ADDRESS_MAP_END
209
 
 
210
 
/* Input ports */
211
 
static INPUT_PORTS_START( act )
212
 
INPUT_PORTS_END
213
 
 
214
 
 
215
 
static MACHINE_RESET(act)
216
 
{
217
 
}
218
 
 
219
 
 
220
 
static const gfx_layout charset_8x8 =
221
 
{
222
 
        8,8,
223
 
        RGN_FRAC(1,1),
224
 
        1,
225
 
        { 0 },
226
 
        { 0, 1, 2, 3, 4, 5, 6, 7 },
227
 
        { 0*8, 1*8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8 },
228
 
        8*8
229
 
};
230
 
 
231
 
static GFXDECODE_START( act_f1 )
232
 
        GFXDECODE_ENTRY( "gfx",   0x00000, charset_8x8,    0x000, 1 )
233
 
GFXDECODE_END
234
 
 
235
 
static Z80CTC_INTERFACE( ctc_intf )
236
 
{
237
 
        0,                                      // timer disables
238
 
        DEVCB_NULL,             // interrupt handler
239
 
        DEVCB_NULL,             // ZC/TO0 callback
240
 
        DEVCB_NULL,             // ZC/TO1 callback
241
 
        DEVCB_NULL,             // ZC/TO2 callback
242
 
};
243
 
 
244
 
#if 0
245
 
 
246
 
static const z80sio_interface sio_intf =
247
 
{
248
 
        0,                                      /* interrupt handler */
249
 
        0,                                      /* DTR changed handler */
250
 
        0,                                      /* RTS changed handler */
251
 
        0,                                      /* BREAK changed handler */
252
 
        0,                                      /* transmit handler */
253
 
        0                                       /* receive handler */
254
 
};
255
 
#endif
256
 
 
257
 
#if 0
258
 
static const z80_daisy_config x1_daisy[] =
259
 
{
260
 
        { "ctc" },
261
 
        { NULL }
262
 
};
263
 
#endif
264
 
 
265
 
static INTERRUPT_GEN( act_f1_irq )
266
 
{
267
 
        //if(device->machine().input().code_pressed(KEYCODE_C))
268
 
        //  device_set_input_line_and_vector(device,0,HOLD_LINE,0x60);
269
 
}
270
 
 
271
 
static FLOPPY_OPTIONS_START( act )
272
 
        FLOPPY_OPTION( img2hd, "dsk", "2HD disk image", basicdsk_identify_default, basicdsk_construct_default, NULL,
273
 
                HEADS([2])
274
 
                TRACKS([80])
275
 
                SECTORS([16])
276
 
                SECTOR_LENGTH([256])
277
 
                FIRST_SECTOR_ID([1]))
278
 
FLOPPY_OPTIONS_END
279
 
 
280
 
static const floppy_interface act_floppy_interface =
281
 
{
282
 
        DEVCB_NULL,
283
 
        DEVCB_NULL,
284
 
        DEVCB_NULL,
285
 
        DEVCB_NULL,
286
 
        DEVCB_NULL,
287
 
        FLOPPY_STANDARD_5_25_DSHD,
288
 
        FLOPPY_OPTIONS_NAME(act),
289
 
        NULL,
290
 
        NULL
291
 
};
292
 
 
293
 
static MACHINE_CONFIG_START( act_f1, act_state )
294
 
 
295
 
        /* basic machine hardware */
296
 
        MCFG_CPU_ADD("maincpu", I8086, 4670000)
297
 
        MCFG_CPU_PROGRAM_MAP(act_f1_mem)
298
 
        MCFG_CPU_IO_MAP(act_f1_io)
299
 
        MCFG_CPU_VBLANK_INT("screen",act_f1_irq )
300
 
//  MCFG_CPU_CONFIG(x1_daisy)
301
 
 
302
 
        MCFG_Z80CTC_ADD( "ctc", 4670000 , ctc_intf )
303
 
 
304
 
        MCFG_MACHINE_RESET(act)
305
 
 
306
 
        /* video hardware */
307
 
        MCFG_SCREEN_ADD("screen", RASTER)
308
 
        MCFG_SCREEN_REFRESH_RATE(50)
309
 
        MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2500)) /* not accurate */
310
 
        MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
311
 
        MCFG_SCREEN_SIZE(640, 256)
312
 
        MCFG_SCREEN_VISIBLE_AREA(0, 640-1, 0, 256-1)
313
 
        MCFG_SCREEN_UPDATE(act_f1)
314
 
 
315
 
        MCFG_PALETTE_LENGTH(16)
316
 
//  MCFG_PALETTE_INIT(black_and_white)
317
 
 
318
 
        MCFG_WD2793_ADD("fdc", default_wd17xx_interface_2_drives )
319
 
 
320
 
        MCFG_GFXDECODE(act_f1)
321
 
 
322
 
        MCFG_VIDEO_START(act_f1)
323
 
 
324
 
        MCFG_FLOPPY_2_DRIVES_ADD(act_floppy_interface)
325
 
MACHINE_CONFIG_END
326
 
 
327
 
/* ROM definition */
328
 
ROM_START( aprif1 )
329
 
        ROM_REGION( 0x100000, "maincpu", ROMREGION_ERASEFF )
330
 
        ROM_LOAD16_BYTE( "lo_f1_1.6.8f",  0xf8000, 0x4000, CRC(be018be2) SHA1(80b97f5b2111daf112c69b3f58d1541a4ba69da0) )       // Labelled F1 - LO Vr. 1.6
331
 
        ROM_LOAD16_BYTE( "hi_f1_1.6.10f", 0xf8001, 0x4000, CRC(bbba77e2) SHA1(e62bed409eb3198f4848f85fccd171cd0745c7c0) )       // Labelled F1 - HI Vr. 1.6
332
 
 
333
 
        ROM_REGION( 0x00800, "gfx", ROMREGION_ERASEFF )
334
 
        ROM_COPY( "maincpu", 0xf8800, 0x00000, 0x00800 )
335
 
ROM_END
336
 
 
337
 
ROM_START( aprif10 )
338
 
        ROM_REGION( 0x100000, "maincpu", ROMREGION_ERASEFF )
339
 
        ROM_LOAD16_BYTE( "lo_f10_3.1.1.8f",  0xf8000, 0x4000, CRC(bfd46ada) SHA1(0a36ef379fa9af7af9744b40c167ce6e12093485) )    // Labelled LO-FRange Vr3.1.1
340
 
        ROM_LOAD16_BYTE( "hi_f10_3.1.1.10f", 0xf8001, 0x4000, CRC(67ad5b3a) SHA1(a5ececb87476a30167cf2a4eb35c03aeb6766601) )    // Labelled HI-FRange Vr3.1.1
341
 
 
342
 
        ROM_REGION( 0x00800, "gfx", ROMREGION_ERASEFF )
343
 
        ROM_COPY( "maincpu", 0xf8800, 0x00000, 0x00800 )
344
 
ROM_END
345
 
 
346
 
ROM_START( aprifp )
347
 
        ROM_REGION( 0x100000, "maincpu", ROMREGION_ERASEFF )
348
 
        ROM_LOAD16_BYTE( "lo_fp_3.1.ic20", 0xf8000, 0x4000, CRC(0572add2) SHA1(c7ab0e5ced477802e37f9232b5673f276b8f5623) )      // Labelled 11212721 F97E PORT LO VR 3.1
349
 
        ROM_LOAD16_BYTE( "hi_fp_3.1.ic9",  0xf8001, 0x4000, CRC(3903674b) SHA1(8418682dcc0c52416d7d851760fea44a3cf2f914) )      // Labelled 11212721 BD2D PORT HI VR 3.1
350
 
 
351
 
        ROM_REGION( 0x00800, "gfx", ROMREGION_ERASEFF )
352
 
        ROM_COPY( "maincpu", 0xf8800, 0x00000, 0x00800 )
353
 
ROM_END
354
 
 
355
 
/* Driver */
356
 
 
357
 
/*    YEAR  NAME    PARENT  COMPAT MACHINE INPUT   INIT   COMPANY  FULLNAME                 FLAGS */
358
 
COMP( 1984, aprif1,    0,    0,     act_f1,    act,    0, "ACT",   "Apricot F1",            GAME_NOT_WORKING | GAME_NO_SOUND )
359
 
COMP( 1985, aprif10,   0,    0,     act_f1,    act,    0, "ACT",   "Apricot F10",           GAME_NOT_WORKING | GAME_NO_SOUND )
360
 
COMP( 1984, aprifp,    0,    0,     act_f1,    act,    0, "ACT",   "Apricot Portable / FP", GAME_NOT_WORKING | GAME_NO_SOUND )