src/mess/machine/s3c44b0.c
| r13242 | r13243 | |
| 1 | | /*******************************************************************************
|
| 2 | | |
| 3 | | Samsung S3C44B0
|
| 4 | | |
| 5 | | (c) 2011 Tim Schuerewegen
|
| 6 | | |
| 7 | | *******************************************************************************/
|
| 8 | | |
| 9 | | #include "emu.h"
|
| 10 | | #include "cpu/arm7/arm7.h"
|
| 11 | | #include "cpu/arm7/arm7core.h"
|
| 12 | | #include "machine/s3c44b0.h"
|
| 13 | | #include "sound/dac.h"
|
| 14 | | #include "coreutil.h"
|
| 15 | | |
| 16 | | #define VERBOSE_LEVEL ( 0 )
|
| 17 | | |
| 18 | | INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ...)
|
| 19 | | {
|
| 20 | | if (VERBOSE_LEVEL >= n_level)
|
| 21 | | {
|
| 22 | | va_list v;
|
| 23 | | char buf[32768];
|
| 24 | | va_start( v, s_fmt);
|
| 25 | | vsprintf( buf, s_fmt, v);
|
| 26 | | va_end( v);
|
| 27 | | logerror( "%s: %s", machine.describe_context(), buf);
|
| 28 | | }
|
| 29 | | }
|
| 30 | | |
| 31 | | /*******************************************************************************
|
| 32 | | MACROS & CONSTANTS
|
| 33 | | *******************************************************************************/
|
| 34 | | |
| 35 | | #define UART_PRINTF
|
| 36 | | |
| 37 | | #define CLOCK_MULTIPLIER 1
|
| 38 | | |
| 39 | | #define BIT(x,n) (((x)>>(n))&1)
|
| 40 | | #define BITS(x,m,n) (((x)>>(n))&(((UINT32)1<<((m)-(n)+1))-1))
|
| 41 | | #define CLR_BITS(x,m,n) ((x) & ~((((UINT32)1 << ((m) - (n) + 1)) - 1) << n))
|
| 42 | | |
| 43 | | /***************************************************************************
|
| 44 | | PROTOTYPES
|
| 45 | | ***************************************************************************/
|
| 46 | | |
| 47 | | static UINT32 s3c44b0_get_mclk( device_t *device);
|
| 48 | | |
| 49 | | static void s3c44b0_bdma_request_iis( device_t *device);
|
| 50 | | //static void s3c44b0_dma_request_pwm( device_t *device);
|
| 51 | | |
| 52 | | /***************************************************************************
|
| 53 | | INLINE FUNCTIONS
|
| 54 | | ***************************************************************************/
|
| 55 | | |
| 56 | | INLINE s3c44b0_t *get_token( device_t *device)
|
| 57 | | {
|
| 58 | | assert(device != NULL);
|
| 59 | | return (s3c44b0_t *)downcast<legacy_device_base *>(device)->token();
|
| 60 | | }
|
| 61 | | |
| 62 | | /***************************************************************************
|
| 63 | | IMPLEMENTATION
|
| 64 | | ***************************************************************************/
|
| 65 | | |
| 66 | | /* ... */
|
| 67 | | |
| 68 | | static void s3c44b0_reset( device_t *device)
|
| 69 | | {
|
| 70 | | fatalerror( "s3c44b0_reset\n");
|
| 71 | | }
|
| 72 | | |
| 73 | | /* LCD Controller */
|
| 74 | | |
| 75 | | static rgb_t s3c44b0_get_color_stn_04( device_t *device, UINT8 data)
|
| 76 | | {
|
| 77 | | UINT8 r, g, b;
|
| 78 | | r = g = b = BITS( data, 3, 0) << 4;
|
| 79 | | return MAKE_RGB( r, g, b);
|
| 80 | | }
|
| 81 | | |
| 82 | | static UINT8 s3c44b0_get_color_stn_08_r( device_t *device, UINT8 data)
|
| 83 | | {
|
| 84 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 85 | | return ((lcd->regs.redlut >> (BITS( data, 7, 5) << 2)) & 0xF) << 4;
|
| 86 | | }
|
| 87 | | |
| 88 | | static UINT8 s3c44b0_get_color_stn_08_g( device_t *device, UINT8 data)
|
| 89 | | {
|
| 90 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 91 | | return ((lcd->regs.greenlut >> (BITS( data, 4, 2) << 2)) & 0xF) << 4;
|
| 92 | | }
|
| 93 | | |
| 94 | | static UINT8 s3c44b0_get_color_stn_08_b( device_t *device, UINT8 data)
|
| 95 | | {
|
| 96 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 97 | | return ((lcd->regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4;
|
| 98 | | }
|
| 99 | | |
| 100 | | static void s3c44b0_lcd_dma_reload( device_t *device)
|
| 101 | | {
|
| 102 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 103 | | int lcdbank, lcdbaseu, lcdbasel;
|
| 104 | | lcdbank = BITS( lcd->regs.lcdsaddr1, 26, 21);
|
| 105 | | lcdbaseu = BITS( lcd->regs.lcdsaddr1, 20, 0);
|
| 106 | | lcdbasel = BITS( lcd->regs.lcdsaddr2, 20, 0);
|
| 107 | | lcd->vramaddr_cur = (lcdbank << 22) | (lcdbaseu << 1);
|
| 108 | | lcd->vramaddr_max = (lcdbank << 22) | (lcdbasel << 1);
|
| 109 | | if (lcdbasel == 0) lcd->vramaddr_max += 1 << 22;
|
| 110 | | lcd->offsize = BITS( lcd->regs.lcdsaddr3, 19, 9);
|
| 111 | | lcd->pagewidth_cur = 0;
|
| 112 | | lcd->pagewidth_max = BITS( lcd->regs.lcdsaddr3, 8, 0);
|
| 113 | | lcd->bswp = BIT( lcd->regs.lcdsaddr2, 29); // note: juicebox changes bswp when video playback starts
|
| 114 | | // verboselog( device->machine(), 3, "LCD - vramaddr %08X %08X offsize %08X pagewidth %08X\n", lcd->vramaddr_cur, lcd->vramaddr_max, lcd->offsize, lcd->pagewidth_max);
|
| 115 | | }
|
| 116 | | |
| 117 | | static void s3c44b0_lcd_dma_init( device_t *device)
|
| 118 | | {
|
| 119 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 120 | | lcd->modesel = BITS( lcd->regs.lcdsaddr1, 28, 27);
|
| 121 | | // verboselog( device->machine(), 3, "LCD - modesel %d bswp %d\n", lcd->modesel, lcd->bswp);
|
| 122 | | s3c44b0_lcd_dma_reload( device);
|
| 123 | | }
|
| 124 | | |
| 125 | | static void s3c44b0_lcd_dma_read( device_t *device, int count, UINT8 *data)
|
| 126 | | {
|
| 127 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 128 | | s3c44b0_lcd_t *lcd = &s3c44b0->lcd;
|
| 129 | | UINT8 *vram;
|
| 130 | | vram = (UINT8 *)s3c44b0->space->get_read_ptr( lcd->vramaddr_cur);
|
| 131 | | for (int i = 0; i < count / 2; i++)
|
| 132 | | {
|
| 133 | | if (lcd->bswp == 0)
|
| 134 | | {
|
| 135 | | if ((lcd->vramaddr_cur & 2) == 0)
|
| 136 | | {
|
| 137 | | data[0] = *(vram + 3);
|
| 138 | | data[1] = *(vram + 2);
|
| 139 | | }
|
| 140 | | else
|
| 141 | | {
|
| 142 | | data[0] = *(vram - 1);
|
| 143 | | data[1] = *(vram - 2);
|
| 144 | | }
|
| 145 | | }
|
| 146 | | else
|
| 147 | | {
|
| 148 | | data[0] = *(vram + 0);
|
| 149 | | data[1] = *(vram + 1);
|
| 150 | | }
|
| 151 | | lcd->vramaddr_cur += 2;
|
| 152 | | lcd->pagewidth_cur++;
|
| 153 | | if (lcd->pagewidth_cur >= lcd->pagewidth_max)
|
| 154 | | {
|
| 155 | | lcd->vramaddr_cur += lcd->offsize << 1;
|
| 156 | | if (lcd->vramaddr_cur >= lcd->vramaddr_max)
|
| 157 | | {
|
| 158 | | s3c44b0_lcd_dma_reload( device);
|
| 159 | | }
|
| 160 | | lcd->pagewidth_cur = 0;
|
| 161 | | vram = (UINT8 *)s3c44b0->space->get_read_ptr( lcd->vramaddr_cur);
|
| 162 | | }
|
| 163 | | else
|
| 164 | | {
|
| 165 | | vram += 2;
|
| 166 | | }
|
| 167 | | data += 2;
|
| 168 | | }
|
| 169 | | }
|
| 170 | | |
| 171 | | static void s3c44b0_lcd_render_stn_04( device_t *device)
|
| 172 | | {
|
| 173 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 174 | | UINT8 *bitmap = lcd->bitmap + ((lcd->vpos - lcd->vpos_min) * (lcd->hpos_max - lcd->hpos_min + 1)) + (lcd->hpos - lcd->hpos_min);
|
| 175 | | UINT8 data[16];
|
| 176 | | s3c44b0_lcd_dma_read( device, 16, data);
|
| 177 | | for (int i = 0; i < 16; i++)
|
| 178 | | {
|
| 179 | | for (int j = 0; j < 2; j++)
|
| 180 | | {
|
| 181 | | *bitmap++ = s3c44b0_get_color_stn_04( device, (data[i] >> 4) & 0x0F);
|
| 182 | | data[i] = data[i] << 4;
|
| 183 | | lcd->hpos++;
|
| 184 | | if (lcd->hpos >= lcd->hpos_min + (lcd->pagewidth_max << 2))
|
| 185 | | {
|
| 186 | | lcd->vpos++;
|
| 187 | | if (lcd->vpos > lcd->vpos_max)
|
| 188 | | {
|
| 189 | | lcd->vpos = lcd->vpos_min;
|
| 190 | | bitmap = lcd->bitmap;
|
| 191 | | }
|
| 192 | | lcd->hpos = lcd->hpos_min;
|
| 193 | | }
|
| 194 | | }
|
| 195 | | }
|
| 196 | | }
|
| 197 | | |
| 198 | | static void s3c44b0_lcd_render_stn_08( device_t *device)
|
| 199 | | {
|
| 200 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 201 | | UINT8 *bitmap = lcd->bitmap + ((lcd->vpos - lcd->vpos_min) * (lcd->hpos_max - lcd->hpos_min + 1)) + (lcd->hpos - lcd->hpos_min);
|
| 202 | | UINT8 data[16];
|
| 203 | | s3c44b0_lcd_dma_read( device, 16, data);
|
| 204 | | for (int i = 0; i < 16; i++)
|
| 205 | | {
|
| 206 | | UINT8 xxx[3];
|
| 207 | | xxx[0] = s3c44b0_get_color_stn_08_r( device, data[i]);
|
| 208 | | xxx[1] = s3c44b0_get_color_stn_08_g( device, data[i]);
|
| 209 | | xxx[2] = s3c44b0_get_color_stn_08_b( device, data[i]);
|
| 210 | | for (int j = 0; j < 3; j++)
|
| 211 | | {
|
| 212 | | *bitmap++ = xxx[j];
|
| 213 | | lcd->hpos++;
|
| 214 | | if (lcd->hpos >= lcd->hpos_min + (lcd->pagewidth_max * 6))
|
| 215 | | {
|
| 216 | | lcd->vpos++;
|
| 217 | | if (lcd->vpos > lcd->vpos_max)
|
| 218 | | {
|
| 219 | | lcd->vpos = lcd->vpos_min;
|
| 220 | | bitmap = lcd->bitmap;
|
| 221 | | }
|
| 222 | | lcd->hpos = lcd->hpos_min;
|
| 223 | | }
|
| 224 | | }
|
| 225 | | }
|
| 226 | | }
|
| 227 | | |
| 228 | | static attotime s3c44b0_time_until_pos( device_t *device, int vpos, int hpos)
|
| 229 | | {
|
| 230 | | running_machine &machine = device->machine();
|
| 231 | | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd);
|
| 232 | | attoseconds_t time1, time2;
|
| 233 | | attotime retval;
|
| 234 | | verboselog( device->machine(), 3, "s3c44b0_time_until_pos - vpos %d hpos %d\n", vpos, hpos);
|
| 235 | | time1 = (attoseconds_t)vpos * lcd->scantime + (attoseconds_t)hpos * lcd->pixeltime;
|
| 236 | | time2 = (machine.time() - lcd->frame_time).as_attoseconds();
|
| 237 | | verboselog( device->machine(), 3, "machine %f frametime %f time1 %f time2 %f\n", machine.time().as_double(), lcd->frame_time.as_double(), attotime( 0, time1).as_double(), attotime( 0, time2).as_double());
|
| 238 | | while (time1 <= time2) time1 += lcd->frame_period;
|
| 239 | | retval = attotime( 0, time1 - time2);
|
| 240 | | verboselog( device->machine(), 3, "result %f\n", retval.as_double());
|
| 241 | | return retval;
|
| 242 | | }
|
| 243 | | |
| 244 | | static int s3c44b0_lcd_get_vpos( device_t *device)
|
| 245 | | {
|
| 246 | | running_machine &machine = device->machine();
|
| 247 | | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd);
|
| 248 | | attoseconds_t delta;
|
| 249 | | int vpos;
|
| 250 | | delta = (machine.time() - lcd->frame_time).as_attoseconds();
|
| 251 | | delta = delta + (lcd->pixeltime / 2);
|
| 252 | | vpos = delta / lcd->scantime;
|
| 253 | | return (lcd->vpos_min + vpos) % lcd->vpos_end;
|
| 254 | | }
|
| 255 | | |
| 256 | | static int s3c44b0_lcd_get_hpos( device_t *device)
|
| 257 | | {
|
| 258 | | running_machine &machine = device->machine();
|
| 259 | | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd);
|
| 260 | | attoseconds_t delta;
|
| 261 | | int vpos;
|
| 262 | | delta = (machine.time() - lcd->frame_time).as_attoseconds();
|
| 263 | | delta = delta + (lcd->pixeltime / 2);
|
| 264 | | vpos = delta / lcd->scantime;
|
| 265 | | delta = delta - (vpos * lcd->scantime);
|
| 266 | | return delta / lcd->pixeltime;
|
| 267 | | }
|
| 268 | | |
| 269 | | static TIMER_CALLBACK( s3c44b0_lcd_timer_exp )
|
| 270 | | {
|
| 271 | | device_t *device = (device_t *)ptr;
|
| 272 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 273 | | int vpos = lcd->vpos;
|
| 274 | | verboselog( machine, 2, "LCD timer callback (%f)\n", machine.time().as_double());
|
| 275 | | verboselog( machine, 3, "LCD - (1) vramaddr %08X vpos %d hpos %d\n", lcd->vramaddr_cur, lcd->vpos, lcd->hpos);
|
| 276 | | switch (lcd->modesel)
|
| 277 | | {
|
| 278 | | case S3C44B0_MODESEL_04 : s3c44b0_lcd_render_stn_04( device); break;
|
| 279 | | case S3C44B0_MODESEL_08 : s3c44b0_lcd_render_stn_08( device); break;
|
| 280 | | default : verboselog( machine, 0, "s3c44b0_lcd_timer_exp: modesel %d not supported\n", lcd->modesel); break;
|
| 281 | | }
|
| 282 | | verboselog( machine, 3, "LCD - (2) vramaddr %08X vpos %d hpos %d\n", lcd->vramaddr_cur, lcd->vpos, lcd->hpos);
|
| 283 | | if (lcd->vpos < vpos)
|
| 284 | | {
|
| 285 | | // verboselog( machine, 3, "LCD - (1) frame_time %f\n", attotime_to_double( lcd->frame_time));
|
| 286 | | lcd->frame_time = machine.time() + s3c44b0_time_until_pos( device, lcd->vpos_min, lcd->hpos_min);
|
| 287 | | // verboselog( machine, 3, "LCD - (2) frame_time %f\n", attotime_to_double( lcd->frame_time));
|
| 288 | | }
|
| 289 | | lcd->timer->adjust( s3c44b0_time_until_pos( device, lcd->vpos, lcd->hpos), 0);
|
| 290 | | }
|
| 291 | | |
| 292 | | static void s3c44b0_video_start( device_t *device, running_machine &machine)
|
| 293 | | {
|
| 294 | | // do nothing
|
| 295 | | }
|
| 296 | | |
| 297 | | static UINT32 s3c44b0_video_update( device_t *device, screen_device *screen, bitmap_t *bitmap, const rectangle *cliprect)
|
| 298 | | {
|
| 299 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 300 | | if (lcd->regs.lcdcon1 & (1 << 0))
|
| 301 | | {
|
| 302 | | if (lcd->bitmap)
|
| 303 | | {
|
| 304 | | for (int y = 0; y < screen->height(); y++)
|
| 305 | | {
|
| 306 | | UINT32 *scanline = BITMAP_ADDR32( bitmap, y, 0);
|
| 307 | | UINT8 *vram = lcd->bitmap + y * (lcd->hpos_max - lcd->hpos_min + 1);
|
| 308 | | for (int x = 0; x < screen->width(); x++)
|
| 309 | | {
|
| 310 | | *scanline++ = MAKE_RGB( vram[0], vram[1], vram[2]);
|
| 311 | | vram += 3;
|
| 312 | | }
|
| 313 | | }
|
| 314 | | }
|
| 315 | | }
|
| 316 | | else
|
| 317 | | {
|
| 318 | | for (int y = 0; y < screen->height(); y++)
|
| 319 | | {
|
| 320 | | UINT32 *scanline = BITMAP_ADDR32( bitmap, y, 0);
|
| 321 | | memset( scanline, 0, screen->width() * 4);
|
| 322 | | }
|
| 323 | | }
|
| 324 | | return 0;
|
| 325 | | }
|
| 326 | | |
| 327 | | static READ32_DEVICE_HANDLER( s3c44b0_lcd_r )
|
| 328 | | {
|
| 329 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 330 | | UINT32 data = ((UINT32*)&lcd->regs)[offset];
|
| 331 | | switch (offset)
|
| 332 | | {
|
| 333 | | case S3C44B0_LCDCON1 :
|
| 334 | | {
|
| 335 | | int vpos = 0;
|
| 336 | | // make sure line counter is going
|
| 337 | | if (lcd->regs.lcdcon1 & (1 << 0))
|
| 338 | | {
|
| 339 | | vpos = s3c44b0_lcd_get_vpos( device);
|
| 340 | | int hpos = s3c44b0_lcd_get_hpos( device);
|
| 341 | | if (hpos < lcd->hpos_min) vpos = vpos - 1;
|
| 342 | | if ((vpos < lcd->vpos_min) || (vpos > lcd->vpos_max)) vpos = lcd->vpos_max;
|
| 343 | | vpos = lcd->vpos_max - vpos;
|
| 344 | | }
|
| 345 | | data = (data & ~0xFFC00000) | (vpos << 22);
|
| 346 | | }
|
| 347 | | break;
|
| 348 | | }
|
| 349 | | // verboselog( device->machine(), 9, "(LCD) %08X -> %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
|
| 350 | | return data;
|
| 351 | | }
|
| 352 | | |
| 353 | | static void s3c44b0_lcd_configure( device_t *device)
|
| 354 | | {
|
| 355 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 356 | | screen_device *screen = device->machine().primary_screen;
|
| 357 | | int dismode, clkval, lineval, wdly, hozval, lineblank, wlh, mclk;
|
| 358 | | double vclk, framerate;
|
| 359 | | int width, height;
|
| 360 | | verboselog( device->machine(), 5, "s3c44b0_lcd_configure\n");
|
| 361 | | dismode = BITS( lcd->regs.lcdcon1, 6, 5);
|
| 362 | | clkval = BITS( lcd->regs.lcdcon1, 21, 12);
|
| 363 | | lineval = BITS( lcd->regs.lcdcon2, 9, 0);
|
| 364 | | wdly = BITS( lcd->regs.lcdcon1, 9, 8);
|
| 365 | | hozval = BITS( lcd->regs.lcdcon2, 20, 10);
|
| 366 | | lineblank = BITS( lcd->regs.lcdcon2, 31, 21);
|
| 367 | | wlh = BITS( lcd->regs.lcdcon1, 11, 10);
|
| 368 | | mclk = s3c44b0_get_mclk( device);
|
| 369 | | verboselog( device->machine(), 3, "LCD - dismode %d clkval %d lineval %d wdly %d hozval %d lineblank %d wlh %d mclk %d\n", dismode, clkval, lineval, wdly, hozval, lineblank, wlh, mclk);
|
| 370 | | vclk = (double)(mclk / (clkval * 2));
|
| 371 | | verboselog( device->machine(), 3, "LCD - vclk %f\n", vclk);
|
| 372 | | framerate = 1 / (((1 / vclk) * (hozval + 1) + (1 / mclk) * (wlh + wdly + lineblank)) * (lineval + 1));
|
| 373 | | framerate = framerate / 3; // ???
|
| 374 | | verboselog( device->machine(), 3, "LCD - framerate %f\n", framerate);
|
| 375 | | switch (dismode)
|
| 376 | | {
|
| 377 | | case S3C44B0_PNRMODE_STN_04_SS : width = ((hozval + 1) * 4); break;
|
| 378 | | case S3C44B0_PNRMODE_STN_04_DS : width = ((hozval + 1) * 4); break;
|
| 379 | | case S3C44B0_PNRMODE_STN_08_SS : width = ((hozval + 1) * 8); break;
|
| 380 | | default : fatalerror( "invalid display mode (%d)", dismode); break;
|
| 381 | | }
|
| 382 | | height = lineval + 1;
|
| 383 | | lcd->framerate = framerate;
|
| 384 | | verboselog( device->machine(), 3, "video_screen_configure %d %d %f\n", width, height, lcd->framerate);
|
| 385 | | screen->configure( screen->width(), screen->height(), screen->visible_area(), HZ_TO_ATTOSECONDS( lcd->framerate));
|
| 386 | | lcd->hpos_min = 25;
|
| 387 | | lcd->hpos_max = 25 + width - 1;
|
| 388 | | lcd->hpos_end = 25 + width - 1 + 25;
|
| 389 | | lcd->vpos_min = 25;
|
| 390 | | lcd->vpos_max = 25 + height - 1;
|
| 391 | | lcd->vpos_end = 25 + height - 1 + 25;
|
| 392 | | verboselog( device->machine(), 3, "LCD - min_x %d min_y %d max_x %d max_y %d\n", lcd->hpos_min, lcd->vpos_min, lcd->hpos_max, lcd->vpos_max);
|
| 393 | | if (lcd->bitmap)
|
| 394 | | {
|
| 395 | | auto_free( device->machine(), lcd->bitmap);
|
| 396 | | }
|
| 397 | | lcd->bitmap = auto_alloc_array( device->machine(), UINT8, (lcd->hpos_max - lcd->hpos_min + 1) * (lcd->vpos_max - lcd->vpos_min + 1) * 3);
|
| 398 | | lcd->frame_period = HZ_TO_ATTOSECONDS( lcd->framerate);
|
| 399 | | lcd->scantime = lcd->frame_period / lcd->vpos_end;
|
| 400 | | lcd->pixeltime = lcd->frame_period / (lcd->vpos_end * lcd->hpos_end);
|
| 401 | | // printf( "frame_period %f\n", attotime( 0, lcd->frame_period).as_double());
|
| 402 | | // printf( "scantime %f\n", attotime( 0, lcd->scantime).as_double());
|
| 403 | | // printf( "pixeltime %f\n", attotime( 0, lcd->pixeltime).as_double());
|
| 404 | | }
|
| 405 | | |
| 406 | | static void s3c44b0_lcd_start( device_t *device)
|
| 407 | | {
|
| 408 | | running_machine &machine = device->machine();
|
| 409 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 410 | | screen_device *screen = device->machine().primary_screen;
|
| 411 | | verboselog( device->machine(), 1, "LCD start\n");
|
| 412 | | s3c44b0_lcd_configure( device);
|
| 413 | | s3c44b0_lcd_dma_init( device);
|
| 414 | | lcd->vpos = lcd->vpos_min;
|
| 415 | | lcd->hpos = lcd->hpos_min;
|
| 416 | | lcd->frame_time = screen->time_until_pos( 0, 0);
|
| 417 | | lcd->timer->adjust( lcd->frame_time, 0);
|
| 418 | | lcd->frame_time = machine.time() + lcd->frame_time;
|
| 419 | | }
|
| 420 | | |
| 421 | | static void s3c44b0_lcd_stop( device_t *device)
|
| 422 | | {
|
| 423 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 424 | | verboselog( device->machine(), 1, "LCD stop\n");
|
| 425 | | lcd->timer->adjust( attotime::never, 0);
|
| 426 | | }
|
| 427 | | |
| 428 | | static void s3c44b0_lcd_recalc( device_t *device)
|
| 429 | | {
|
| 430 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 431 | | if (lcd->regs.lcdcon1 & (1 << 0))
|
| 432 | | {
|
| 433 | | s3c44b0_lcd_start( device);
|
| 434 | | }
|
| 435 | | else
|
| 436 | | {
|
| 437 | | s3c44b0_lcd_stop( device);
|
| 438 | | }
|
| 439 | | }
|
| 440 | | |
| 441 | | static WRITE32_DEVICE_HANDLER( s3c44b0_lcd_w )
|
| 442 | | {
|
| 443 | | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd);
|
| 444 | | UINT32 old_value = ((UINT32*)&lcd->regs)[offset];
|
| 445 | | // verboselog( device->machine(), 9, "(LCD) %08X <- %08X\n", S3C44B0_BASE_LCD + (offset << 2), data);
|
| 446 | | COMBINE_DATA(&((UINT32*)&lcd->regs)[offset]);
|
| 447 | | switch (offset)
|
| 448 | | {
|
| 449 | | case S3C44B0_LCDCON1 :
|
| 450 | | {
|
| 451 | | if ((old_value & (1 << 0)) != (data & (1 << 0)))
|
| 452 | | {
|
| 453 | | s3c44b0_lcd_recalc( device);
|
| 454 | | }
|
| 455 | | }
|
| 456 | | break;
|
| 457 | | }
|
| 458 | | }
|
| 459 | | |
| 460 | | /* Clock & Power Management */
|
| 461 | | |
| 462 | | static UINT32 s3c44b0_get_mclk( device_t *device)
|
| 463 | | {
|
| 464 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 465 | | UINT32 data, mdiv, pdiv, sdiv;
|
| 466 | | data = s3c44b0->clkpow.regs.pllcon;
|
| 467 | | mdiv = BITS( data, 19, 12);
|
| 468 | | pdiv = BITS( data, 9, 4);
|
| 469 | | sdiv = BITS( data, 1, 0);
|
| 470 | | return (UINT32)((double)((mdiv + 8) * device->clock()) / (double)((pdiv + 2) * (1 << sdiv)));
|
| 471 | | }
|
| 472 | | |
| 473 | | static READ32_DEVICE_HANDLER( s3c44b0_clkpow_r )
|
| 474 | | {
|
| 475 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 476 | | UINT32 data = ((UINT32*)&s3c44b0->clkpow.regs)[offset];
|
| 477 | | verboselog( device->machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
|
| 478 | | return data;
|
| 479 | | }
|
| 480 | | |
| 481 | | static WRITE32_DEVICE_HANDLER( s3c44b0_clkpow_w )
|
| 482 | | {
|
| 483 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 484 | | verboselog( device->machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data);
|
| 485 | | COMBINE_DATA(&((UINT32*)&s3c44b0->clkpow.regs)[offset]);
|
| 486 | | switch (offset)
|
| 487 | | {
|
| 488 | | case S3C44B0_PLLCON :
|
| 489 | | {
|
| 490 | | verboselog( device->machine(), 5, "CLKPOW - mclk %d\n", s3c44b0_get_mclk( device));
|
| 491 | | s3c44b0->cpu->set_unscaled_clock( s3c44b0_get_mclk( device) * CLOCK_MULTIPLIER);
|
| 492 | | }
|
| 493 | | break;
|
| 494 | | case S3C44B0_CLKCON :
|
| 495 | | {
|
| 496 | | if (data & (1 << 2))
|
| 497 | | {
|
| 498 | | s3c44b0->cpu->spin_until_interrupt();
|
| 499 | | }
|
| 500 | | }
|
| 501 | | break;
|
| 502 | | }
|
| 503 | | }
|
| 504 | | |
| 505 | | /* Interrupt Controller */
|
| 506 | | |
| 507 | | static void s3c44b0_check_pending_irq( device_t *device)
|
| 508 | | {
|
| 509 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 510 | | UINT32 temp;
|
| 511 | | // normal irq
|
| 512 | | temp = (s3c44b0->irq.regs.intpnd & ~s3c44b0->irq.regs.intmsk) & ~s3c44b0->irq.regs.intmod;
|
| 513 | | if (temp != 0)
|
| 514 | | {
|
| 515 | | UINT32 int_type = 0;
|
| 516 | | while ((temp & 1) == 0)
|
| 517 | | {
|
| 518 | | int_type++;
|
| 519 | | temp = temp >> 1;
|
| 520 | | }
|
| 521 | | s3c44b0->irq.regs.i_ispr |= (1 << int_type);
|
| 522 | | if (s3c44b0->irq.line_irq != ASSERT_LINE)
|
| 523 | | {
|
| 524 | | s3c44b0->cpu->set_input_line( ARM7_IRQ_LINE, ASSERT_LINE);
|
| 525 | | s3c44b0->irq.line_irq = ASSERT_LINE;
|
| 526 | | }
|
| 527 | | }
|
| 528 | | else
|
| 529 | | {
|
| 530 | | if (s3c44b0->irq.line_irq != CLEAR_LINE)
|
| 531 | | {
|
| 532 | | s3c44b0->cpu->set_input_line( ARM7_IRQ_LINE, CLEAR_LINE);
|
| 533 | | s3c44b0->irq.line_irq = CLEAR_LINE;
|
| 534 | | }
|
| 535 | | }
|
| 536 | | // fast irq
|
| 537 | | temp = (s3c44b0->irq.regs.intpnd & ~s3c44b0->irq.regs.intmsk) & s3c44b0->irq.regs.intmod;
|
| 538 | | if (temp != 0)
|
| 539 | | {
|
| 540 | | UINT32 int_type = 0;
|
| 541 | | while ((temp & 1) == 0)
|
| 542 | | {
|
| 543 | | int_type++;
|
| 544 | | temp = temp >> 1;
|
| 545 | | }
|
| 546 | | if (s3c44b0->irq.line_fiq != ASSERT_LINE)
|
| 547 | | {
|
| 548 | | s3c44b0->cpu->set_input_line( ARM7_FIRQ_LINE, ASSERT_LINE);
|
| 549 | | s3c44b0->irq.line_fiq = ASSERT_LINE;
|
| 550 | | }
|
| 551 | | }
|
| 552 | | else
|
| 553 | | {
|
| 554 | | if (s3c44b0->irq.line_fiq != CLEAR_LINE)
|
| 555 | | {
|
| 556 | | s3c44b0->cpu->set_input_line( ARM7_FIRQ_LINE, CLEAR_LINE);
|
| 557 | | s3c44b0->irq.line_fiq = CLEAR_LINE;
|
| 558 | | }
|
| 559 | | }
|
| 560 | | }
|
| 561 | | |
| 562 | | static void s3c44b0_request_irq( device_t *device, UINT32 int_type)
|
| 563 | | {
|
| 564 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 565 | | verboselog( device->machine(), 5, "request irq %d\n", int_type);
|
| 566 | | s3c44b0->irq.regs.intpnd |= (1 << int_type);
|
| 567 | | s3c44b0_check_pending_irq( device);
|
| 568 | | }
|
| 569 | | |
| 570 | | static void s3c44b0_check_pending_eint( device_t *device)
|
| 571 | | {
|
| 572 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 573 | | UINT32 temp = s3c44b0->gpio.regs.extintpnd;
|
| 574 | | if (temp != 0)
|
| 575 | | {
|
| 576 | | UINT32 int_type = 0;
|
| 577 | | while ((temp & 1) == 0)
|
| 578 | | {
|
| 579 | | int_type++;
|
| 580 | | temp = temp >> 1;
|
| 581 | | }
|
| 582 | | s3c44b0_request_irq( device, S3C44B0_INT_EINT4_7);
|
| 583 | | }
|
| 584 | | }
|
| 585 | | |
| 586 | | void s3c44b0_request_eint( device_t *device, UINT32 number)
|
| 587 | | {
|
| 588 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 589 | | verboselog( device->machine(), 5, "request external interrupt %d\n", number);
|
| 590 | | if (number < 4)
|
| 591 | | {
|
| 592 | | s3c44b0_request_irq( device, S3C44B0_INT_EINT0 + number);
|
| 593 | | }
|
| 594 | | else
|
| 595 | | {
|
| 596 | | s3c44b0->gpio.regs.extintpnd |= (1 << (number - 4));
|
| 597 | | s3c44b0_check_pending_eint( device);
|
| 598 | | }
|
| 599 | | }
|
| 600 | | |
| 601 | | static READ32_DEVICE_HANDLER( s3c44b0_irq_r )
|
| 602 | | {
|
| 603 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 604 | | UINT32 data = ((UINT32*)&s3c44b0->irq.regs)[offset];
|
| 605 | | verboselog( device->machine(), 9, "(IRQ) %08X -> %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
|
| 606 | | return data;
|
| 607 | | }
|
| 608 | | |
| 609 | | static WRITE32_DEVICE_HANDLER( s3c44b0_irq_w )
|
| 610 | | {
|
| 611 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 612 | | verboselog( device->machine(), 9, "(IRQ) %08X <- %08X\n", S3C44B0_BASE_INT + (offset << 2), data);
|
| 613 | | COMBINE_DATA(&((UINT32*)&s3c44b0->irq.regs)[offset]);
|
| 614 | | switch (offset)
|
| 615 | | {
|
| 616 | | case S3C44B0_INTMSK :
|
| 617 | | {
|
| 618 | | s3c44b0_check_pending_irq( device);
|
| 619 | | }
|
| 620 | | break;
|
| 621 | | case S3C44B0_I_ISPC :
|
| 622 | | {
|
| 623 | | s3c44b0->irq.regs.intpnd = (s3c44b0->irq.regs.intpnd & ~data); // The bit of INTPND bit is cleared to zero by writing '1' on I_ISPC/F_ISPC
|
| 624 | | s3c44b0->irq.regs.i_ispr = (s3c44b0->irq.regs.i_ispr & ~data); // The pending bit in I_ISPR register should be cleared by writing I_ISPC register.
|
| 625 | | s3c44b0_check_pending_irq( device);
|
| 626 | | }
|
| 627 | | break;
|
| 628 | | case S3C44B0_F_ISPC :
|
| 629 | | {
|
| 630 | | s3c44b0->irq.regs.intpnd = (s3c44b0->irq.regs.intpnd & ~data); // The bit of INTPND bit is cleared to zero by writing '1' on I_ISPC/F_ISPC
|
| 631 | | s3c44b0_check_pending_irq( device);
|
| 632 | | }
|
| 633 | | break;
|
| 634 | | }
|
| 635 | | }
|
| 636 | | |
| 637 | | /* PWM Timer */
|
| 638 | | |
| 639 | | static UINT16 s3c44b0_pwm_calc_observation( device_t *device, int ch)
|
| 640 | | {
|
| 641 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 642 | | double timeleft, x1, x2;
|
| 643 | | UINT32 cnto;
|
| 644 | | timeleft = (s3c44b0->pwm.timer[ch]->remaining()).as_double();
|
| 645 | | // printf( "timeleft %f freq %d cntb %d cmpb %d\n", timeleft, s3c44b0->pwm.freq[ch], s3c44b0->pwm.cnt[ch], s3c44b0->pwm.cmp[ch]);
|
| 646 | | x1 = 1 / ((double)s3c44b0->pwm.freq[ch] / (s3c44b0->pwm.cnt[ch]- s3c44b0->pwm.cmp[ch] + 1));
|
| 647 | | x2 = x1 / timeleft;
|
| 648 | | // printf( "x1 %f\n", x1);
|
| 649 | | cnto = s3c44b0->pwm.cmp[ch] + ((s3c44b0->pwm.cnt[ch]- s3c44b0->pwm.cmp[ch]) / x2);
|
| 650 | | // printf( "cnto %d\n", cnto);
|
| 651 | | return cnto;
|
| 652 | | }
|
| 653 | | |
| 654 | | static READ32_DEVICE_HANDLER( s3c44b0_pwm_r )
|
| 655 | | {
|
| 656 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 657 | | UINT32 data = ((UINT32*)&s3c44b0->pwm.regs)[offset];
|
| 658 | | switch (offset)
|
| 659 | | {
|
| 660 | | case S3C44B0_TCNTO0 :
|
| 661 | | {
|
| 662 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 0);
|
| 663 | | }
|
| 664 | | break;
|
| 665 | | case S3C44B0_TCNTO1 :
|
| 666 | | {
|
| 667 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 1);
|
| 668 | | }
|
| 669 | | break;
|
| 670 | | case S3C44B0_TCNTO2 :
|
| 671 | | {
|
| 672 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 2);
|
| 673 | | }
|
| 674 | | break;
|
| 675 | | case S3C44B0_TCNTO3 :
|
| 676 | | {
|
| 677 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 3);
|
| 678 | | }
|
| 679 | | break;
|
| 680 | | case S3C44B0_TCNTO4 :
|
| 681 | | {
|
| 682 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 4);
|
| 683 | | }
|
| 684 | | break;
|
| 685 | | case S3C44B0_TCNTO5 :
|
| 686 | | {
|
| 687 | | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 5);
|
| 688 | | }
|
| 689 | | break;
|
| 690 | | }
|
| 691 | | verboselog( device->machine(), 9, "(PWM) %08X -> %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
|
| 692 | | return data;
|
| 693 | | }
|
| 694 | | |
| 695 | | static void s3c44b0_pwm_start( device_t *device, int timer)
|
| 696 | | {
|
| 697 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 698 | | const int mux_table[] = { 2, 4, 8, 16};
|
| 699 | | const int prescaler_shift[] = { 0, 0, 8, 8, 16, 16};
|
| 700 | | const int mux_shift[] = { 0, 4, 8, 12, 16, 20};
|
| 701 | | UINT32 mclk, prescaler, mux, cnt, cmp, auto_reload;
|
| 702 | | double freq, hz;
|
| 703 | | verboselog( device->machine(), 1, "PWM %d start\n", timer);
|
| 704 | | mclk = s3c44b0_get_mclk( device);
|
| 705 | | prescaler = (s3c44b0->pwm.regs.tcfg0 >> prescaler_shift[timer]) & 0xFF;
|
| 706 | | mux = (s3c44b0->pwm.regs.tcfg1 >> mux_shift[timer]) & 0x0F;
|
| 707 | | if (mux < 4)
|
| 708 | | {
|
| 709 | | freq = (double)mclk / (prescaler + 1) / mux_table[mux];
|
| 710 | | }
|
| 711 | | else
|
| 712 | | {
|
| 713 | | // todo
|
| 714 | | freq = (double)mclk / (prescaler + 1) / 1;
|
| 715 | | }
|
| 716 | | switch (timer)
|
| 717 | | {
|
| 718 | | case 0 :
|
| 719 | | {
|
| 720 | | cnt = BITS( s3c44b0->pwm.regs.tcntb0, 15, 0);
|
| 721 | | cmp = BITS( s3c44b0->pwm.regs.tcmpb0, 15, 0);
|
| 722 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 3);
|
| 723 | | }
|
| 724 | | break;
|
| 725 | | case 1 :
|
| 726 | | {
|
| 727 | | cnt = BITS( s3c44b0->pwm.regs.tcntb1, 15, 0);
|
| 728 | | cmp = BITS( s3c44b0->pwm.regs.tcmpb1, 15, 0);
|
| 729 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 11);
|
| 730 | | }
|
| 731 | | break;
|
| 732 | | case 2 :
|
| 733 | | {
|
| 734 | | cnt = BITS( s3c44b0->pwm.regs.tcntb2, 15, 0);
|
| 735 | | cmp = BITS( s3c44b0->pwm.regs.tcmpb2, 15, 0);
|
| 736 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 15);
|
| 737 | | }
|
| 738 | | break;
|
| 739 | | case 3 :
|
| 740 | | {
|
| 741 | | cnt = BITS( s3c44b0->pwm.regs.tcntb3, 15, 0);
|
| 742 | | cmp = BITS( s3c44b0->pwm.regs.tcmpb3, 15, 0);
|
| 743 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 19);
|
| 744 | | }
|
| 745 | | break;
|
| 746 | | case 4 :
|
| 747 | | {
|
| 748 | | cnt = BITS( s3c44b0->pwm.regs.tcntb4, 15, 0);
|
| 749 | | cmp = BITS( s3c44b0->pwm.regs.tcmpb4, 15, 0);
|
| 750 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 23);
|
| 751 | | }
|
| 752 | | break;
|
| 753 | | case 5 :
|
| 754 | | {
|
| 755 | | cnt = BITS( s3c44b0->pwm.regs.tcntb5, 15, 0);
|
| 756 | | cmp = 0;
|
| 757 | | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 26);
|
| 758 | | }
|
| 759 | | break;
|
| 760 | | default :
|
| 761 | | {
|
| 762 | | cnt = cmp = auto_reload = 0;
|
| 763 | | }
|
| 764 | | break;
|
| 765 | | }
|
| 766 | | // hz = freq / (cnt - cmp + 1);
|
| 767 | | if (cnt < 2)
|
| 768 | | {
|
| 769 | | hz = freq;
|
| 770 | | }
|
| 771 | | else
|
| 772 | | {
|
| 773 | | hz = freq / cnt;
|
| 774 | | }
|
| 775 | | verboselog( device->machine(), 5, "PWM %d - mclk=%d prescaler=%d div=%d freq=%f cnt=%d cmp=%d auto_reload=%d hz=%f\n", timer, mclk, prescaler, mux_table[mux], freq, cnt, cmp, auto_reload, hz);
|
| 776 | | s3c44b0->pwm.cnt[timer] = cnt;
|
| 777 | | s3c44b0->pwm.cmp[timer] = cmp;
|
| 778 | | s3c44b0->pwm.freq[timer] = freq;
|
| 779 | | if (cnt == 0)
|
| 780 | | {
|
| 781 | | s3c44b0->pwm.timer[timer]->adjust( attotime::never, 0);
|
| 782 | | }
|
| 783 | | else
|
| 784 | | {
|
| 785 | | if (auto_reload)
|
| 786 | | {
|
| 787 | | s3c44b0->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer, attotime::from_hz( hz));
|
| 788 | | }
|
| 789 | | else
|
| 790 | | {
|
| 791 | | s3c44b0->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer);
|
| 792 | | }
|
| 793 | | }
|
| 794 | | }
|
| 795 | | |
| 796 | | static void s3c44b0_pwm_stop( device_t *device, int timer)
|
| 797 | | {
|
| 798 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 799 | | verboselog( device->machine(), 1, "PWM %d stop\n", timer);
|
| 800 | | s3c44b0->pwm.timer[timer]->adjust( attotime::never, 0);
|
| 801 | | }
|
| 802 | | |
| 803 | | static void s3c44b0_pwm_recalc( device_t *device, int timer)
|
| 804 | | {
|
| 805 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 806 | | const int tcon_shift[] = { 0, 8, 12, 16, 20, 24};
|
| 807 | | if (s3c44b0->pwm.regs.tcon & (1 << tcon_shift[timer]))
|
| 808 | | {
|
| 809 | | s3c44b0_pwm_start( device, timer);
|
| 810 | | }
|
| 811 | | else
|
| 812 | | {
|
| 813 | | s3c44b0_pwm_stop( device, timer);
|
| 814 | | }
|
| 815 | | }
|
| 816 | | |
| 817 | | static WRITE32_DEVICE_HANDLER( s3c44b0_pwm_w )
|
| 818 | | {
|
| 819 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 820 | | UINT32 old_value = ((UINT32*)&s3c44b0->pwm.regs)[offset];
|
| 821 | | verboselog( device->machine(), 9, "(PWM) %08X <- %08X\n", S3C44B0_BASE_PWM + (offset << 2), data);
|
| 822 | | COMBINE_DATA(&((UINT32*)&s3c44b0->pwm.regs)[offset]);
|
| 823 | | switch (offset)
|
| 824 | | {
|
| 825 | | case S3C44B0_TCON :
|
| 826 | | {
|
| 827 | | if ((data & (1 << 0)) != (old_value & (1 << 0)))
|
| 828 | | {
|
| 829 | | s3c44b0_pwm_recalc( device, 0);
|
| 830 | | }
|
| 831 | | if ((data & (1 << 8)) != (old_value & (1 << 8)))
|
| 832 | | {
|
| 833 | | s3c44b0_pwm_recalc( device, 1);
|
| 834 | | }
|
| 835 | | if ((data & (1 << 12)) != (old_value & (1 << 12)))
|
| 836 | | {
|
| 837 | | s3c44b0_pwm_recalc( device, 2);
|
| 838 | | }
|
| 839 | | if ((data & (1 << 16)) != (old_value & (1 << 16)))
|
| 840 | | {
|
| 841 | | s3c44b0_pwm_recalc( device, 3);
|
| 842 | | }
|
| 843 | | if ((data & (1 << 20)) != (old_value & (1 << 20)))
|
| 844 | | {
|
| 845 | | s3c44b0_pwm_recalc( device, 4);
|
| 846 | | }
|
| 847 | | if ((data & (1 << 24)) != (old_value & (1 << 24)))
|
| 848 | | {
|
| 849 | | s3c44b0_pwm_recalc( device, 5);
|
| 850 | | }
|
| 851 | | }
|
| 852 | | break;
|
| 853 | | }
|
| 854 | | }
|
| 855 | | |
| 856 | | static TIMER_CALLBACK( s3c44b0_pwm_timer_exp )
|
| 857 | | {
|
| 858 | | device_t *device = (device_t *)ptr;
|
| 859 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 860 | | int ch = param;
|
| 861 | | const int ch_int[] = { S3C44B0_INT_TIMER0, S3C44B0_INT_TIMER1, S3C44B0_INT_TIMER2, S3C44B0_INT_TIMER3, S3C44B0_INT_TIMER4, S3C44B0_INT_TIMER5 };
|
| 862 | | verboselog( machine, 2, "PWM %d timer callback\n", ch);
|
| 863 | | if (BITS( s3c44b0->pwm.regs.tcfg1, 27, 24) == (ch + 1))
|
| 864 | | {
|
| 865 | | fatalerror( "s3c44b0_dma_request_pwm( device);");
|
| 866 | | }
|
| 867 | | else
|
| 868 | | {
|
| 869 | | s3c44b0_request_irq( device, ch_int[ch]);
|
| 870 | | }
|
| 871 | | }
|
| 872 | | |
| 873 | | /* IIC */
|
| 874 | | |
| 875 | | INLINE void iface_i2c_scl_w( device_t *device, int state)
|
| 876 | | {
|
| 877 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 878 | | if (s3c44b0->iface->i2c.scl_w)
|
| 879 | | {
|
| 880 | | (s3c44b0->iface->i2c.scl_w)( device, state);
|
| 881 | | }
|
| 882 | | }
|
| 883 | | |
| 884 | | INLINE void iface_i2c_sda_w( device_t *device, int state)
|
| 885 | | {
|
| 886 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 887 | | if (s3c44b0->iface->i2c.sda_w)
|
| 888 | | {
|
| 889 | | (s3c44b0->iface->i2c.sda_w)( device, state);
|
| 890 | | }
|
| 891 | | }
|
| 892 | | |
| 893 | | INLINE int iface_i2c_sda_r( device_t *device)
|
| 894 | | {
|
| 895 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 896 | | if (s3c44b0->iface->i2c.sda_r)
|
| 897 | | {
|
| 898 | | return (s3c44b0->iface->i2c.sda_r)( device);
|
| 899 | | }
|
| 900 | | else
|
| 901 | | {
|
| 902 | | return 0;
|
| 903 | | }
|
| 904 | | }
|
| 905 | | |
| 906 | | static void i2c_send_start( device_t *device)
|
| 907 | | {
|
| 908 | | verboselog( device->machine(), 5, "i2c_send_start\n");
|
| 909 | | iface_i2c_sda_w( device, 1);
|
| 910 | | iface_i2c_scl_w( device, 1);
|
| 911 | | iface_i2c_sda_w( device, 0);
|
| 912 | | iface_i2c_scl_w( device, 0);
|
| 913 | | }
|
| 914 | | |
| 915 | | static void i2c_send_stop( device_t *device)
|
| 916 | | {
|
| 917 | | verboselog( device->machine(), 5, "i2c_send_stop\n");
|
| 918 | | iface_i2c_sda_w( device, 0);
|
| 919 | | iface_i2c_scl_w( device, 1);
|
| 920 | | iface_i2c_sda_w( device, 1);
|
| 921 | | iface_i2c_scl_w( device, 0);
|
| 922 | | }
|
| 923 | | |
| 924 | | static UINT8 i2c_receive_byte( device_t *device, int ack)
|
| 925 | | {
|
| 926 | | UINT8 data = 0;
|
| 927 | | verboselog( device->machine(), 5, "i2c_receive_byte ...\n");
|
| 928 | | iface_i2c_sda_w( device, 1);
|
| 929 | | for (int i = 0; i < 8; i++)
|
| 930 | | {
|
| 931 | | iface_i2c_scl_w( device, 1);
|
| 932 | | data = (data << 1) + (iface_i2c_sda_r( device) ? 1 : 0);
|
| 933 | | iface_i2c_scl_w( device, 0);
|
| 934 | | }
|
| 935 | | verboselog( device->machine(), 5, "recv data %02X\n", data);
|
| 936 | | verboselog( device->machine(), 5, "send ack %d\n", ack);
|
| 937 | | iface_i2c_sda_w( device, ack ? 0 : 1);
|
| 938 | | iface_i2c_scl_w( device, 1);
|
| 939 | | iface_i2c_scl_w( device, 0);
|
| 940 | | return data;
|
| 941 | | }
|
| 942 | | |
| 943 | | static int i2c_send_byte( device_t *device, UINT8 data)
|
| 944 | | {
|
| 945 | | int ack;
|
| 946 | | verboselog( device->machine(), 5, "i2c_send_byte ...\n");
|
| 947 | | verboselog( device->machine(), 5, "send data %02X\n", data);
|
| 948 | | for (int i = 0; i < 8; i++)
|
| 949 | | {
|
| 950 | | iface_i2c_sda_w( device, (data & 0x80) ? 1 : 0);
|
| 951 | | data = data << 1;
|
| 952 | | iface_i2c_scl_w( device, 1);
|
| 953 | | iface_i2c_scl_w( device, 0);
|
| 954 | | }
|
| 955 | | iface_i2c_sda_w( device, 1); // ack bit
|
| 956 | | iface_i2c_scl_w( device, 1);
|
| 957 | | ack = iface_i2c_sda_r( device);
|
| 958 | | verboselog( device->machine(), 5, "recv ack %d\n", ack);
|
| 959 | | iface_i2c_scl_w( device, 0);
|
| 960 | | return ack;
|
| 961 | | }
|
| 962 | | |
| 963 | | static void iic_start( device_t *device)
|
| 964 | | {
|
| 965 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 966 | | int mode_selection;
|
| 967 | | verboselog( device->machine(), 1, "IIC start\n");
|
| 968 | | i2c_send_start( device);
|
| 969 | | mode_selection = BITS( s3c44b0->iic.regs.iicstat, 7, 6);
|
| 970 | | switch (mode_selection)
|
| 971 | | {
|
| 972 | | case 2 : i2c_send_byte( device, s3c44b0->iic.regs.iicds | 0x01); break;
|
| 973 | | case 3 : i2c_send_byte( device, s3c44b0->iic.regs.iicds & 0xFE); break;
|
| 974 | | }
|
| 975 | | s3c44b0->iic.timer->adjust( attotime::from_usec( 1), 0);
|
| 976 | | }
|
| 977 | | |
| 978 | | static void iic_stop( device_t *device)
|
| 979 | | {
|
| 980 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 981 | | verboselog( device->machine(), 1, "IIC stop\n");
|
| 982 | | i2c_send_stop( device);
|
| 983 | | s3c44b0->iic.timer->adjust( attotime::never, 0);
|
| 984 | | }
|
| 985 | | |
| 986 | | static void iic_resume( device_t *device)
|
| 987 | | {
|
| 988 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 989 | | int mode_selection;
|
| 990 | | verboselog( device->machine(), 1, "IIC resume\n");
|
| 991 | | mode_selection = BITS( s3c44b0->iic.regs.iicstat, 7, 6);
|
| 992 | | switch (mode_selection)
|
| 993 | | {
|
| 994 | | case 2 : s3c44b0->iic.regs.iicds = i2c_receive_byte( device, BIT( s3c44b0->iic.regs.iiccon, 7)); break;
|
| 995 | | case 3 : i2c_send_byte( device, s3c44b0->iic.regs.iicds & 0xFF); break;
|
| 996 | | }
|
| 997 | | s3c44b0->iic.timer->adjust( attotime::from_usec( 1), 0);
|
| 998 | | }
|
| 999 | | |
| 1000 | | static READ32_DEVICE_HANDLER( s3c44b0_iic_r )
|
| 1001 | | {
|
| 1002 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1003 | | UINT32 data = ((UINT32*)&s3c44b0->iic.regs)[offset];
|
| 1004 | | switch (offset)
|
| 1005 | | {
|
| 1006 | | case S3C44B0_IICSTAT :
|
| 1007 | | {
|
| 1008 | | data = data & ~0x0000000F;
|
| 1009 | | }
|
| 1010 | | break;
|
| 1011 | | }
|
| 1012 | | verboselog( device->machine(), 9, "(IIC) %08X -> %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
|
| 1013 | | return data;
|
| 1014 | | }
|
| 1015 | | |
| 1016 | | static WRITE32_DEVICE_HANDLER( s3c44b0_iic_w )
|
| 1017 | | {
|
| 1018 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1019 | | UINT32 old_value = ((UINT32*)&s3c44b0->iic.regs)[offset];
|
| 1020 | | verboselog( device->machine(), 9, "(IIC) %08X <- %08X\n", S3C44B0_BASE_IIC + (offset << 2), data);
|
| 1021 | | COMBINE_DATA(&((UINT32*)&s3c44b0->iic.regs)[offset]);
|
| 1022 | | switch (offset)
|
| 1023 | | {
|
| 1024 | | case S3C44B0_IICCON :
|
| 1025 | | {
|
| 1026 | | int interrupt_pending_flag;
|
| 1027 | | #if 0
|
| 1028 | | const int div_table[] = { 16, 512};
|
| 1029 | | int enable_interrupt, transmit_clock_value, tx_clock_source_selection
|
| 1030 | | double clock;
|
| 1031 | | transmit_clock_value = (data >> 0) & 0xF;
|
| 1032 | | tx_clock_source_selection = (data >> 6) & 1;
|
| 1033 | | enable_interrupt = (data >> 5) & 1;
|
| 1034 | | clock = (double)s3c24xx_get_pclk( device) / div_table[tx_clock_source_selection] / (transmit_clock_value + 1);
|
| 1035 | | #endif
|
| 1036 | | interrupt_pending_flag = BIT( old_value, 4);
|
| 1037 | | if (interrupt_pending_flag != 0)
|
| 1038 | | {
|
| 1039 | | interrupt_pending_flag = BIT( data, 4);
|
| 1040 | | if (interrupt_pending_flag == 0)
|
| 1041 | | {
|
| 1042 | | int start_stop_condition;
|
| 1043 | | start_stop_condition = BIT( s3c44b0->iic.regs.iicstat, 5);
|
| 1044 | | if (start_stop_condition != 0)
|
| 1045 | | {
|
| 1046 | | if (s3c44b0->iic.count == 0)
|
| 1047 | | {
|
| 1048 | | iic_start( device);
|
| 1049 | | |
| 1050 | | }
|
| 1051 | | else
|
| 1052 | | {
|
| 1053 | | iic_resume( device);
|
| 1054 | | }
|
| 1055 | | }
|
| 1056 | | else
|
| 1057 | | {
|
| 1058 | | iic_stop( device);
|
| 1059 | | }
|
| 1060 | | }
|
| 1061 | | }
|
| 1062 | | }
|
| 1063 | | break;
|
| 1064 | | case S3C44B0_IICSTAT :
|
| 1065 | | {
|
| 1066 | | int interrupt_pending_flag;
|
| 1067 | | s3c44b0->iic.count = 0;
|
| 1068 | | interrupt_pending_flag = BIT( s3c44b0->iic.regs.iiccon, 4);
|
| 1069 | | if (interrupt_pending_flag == 0)
|
| 1070 | | {
|
| 1071 | | int start_stop_condition;
|
| 1072 | | start_stop_condition = BIT( data, 5);
|
| 1073 | | if (start_stop_condition != 0)
|
| 1074 | | {
|
| 1075 | | if (s3c44b0->iic.count == 0)
|
| 1076 | | {
|
| 1077 | | iic_start( device);
|
| 1078 | | |
| 1079 | | }
|
| 1080 | | else
|
| 1081 | | {
|
| 1082 | | iic_resume( device);
|
| 1083 | | }
|
| 1084 | | }
|
| 1085 | | else
|
| 1086 | | {
|
| 1087 | | iic_stop( device);
|
| 1088 | | }
|
| 1089 | | }
|
| 1090 | | }
|
| 1091 | | break;
|
| 1092 | | }
|
| 1093 | | }
|
| 1094 | | |
| 1095 | | static TIMER_CALLBACK( s3c44b0_iic_timer_exp )
|
| 1096 | | {
|
| 1097 | | device_t *device = (device_t *)ptr;
|
| 1098 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1099 | | int enable_interrupt;
|
| 1100 | | verboselog( machine, 2, "IIC timer callback\n");
|
| 1101 | | s3c44b0->iic.count++;
|
| 1102 | | enable_interrupt = BIT( s3c44b0->iic.regs.iiccon, 5);
|
| 1103 | | |
| 1104 | | s3c44b0->iic.regs.iicds = 0xFF; // TEST
|
| 1105 | | |
| 1106 | | if (enable_interrupt)
|
| 1107 | | {
|
| 1108 | | s3c44b0->iic.regs.iiccon |= (1 << 4); // [bit 4] interrupt is pending
|
| 1109 | | s3c44b0_request_irq( device, S3C44B0_INT_IIC);
|
| 1110 | | }
|
| 1111 | | }
|
| 1112 | | |
| 1113 | | /* I/O Port */
|
| 1114 | | |
| 1115 | | INLINE UINT32 iface_gpio_port_r( device_t *device, int port)
|
| 1116 | | {
|
| 1117 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1118 | | if (s3c44b0->iface->gpio.port_r)
|
| 1119 | | {
|
| 1120 | | return (s3c44b0->iface->gpio.port_r)( device, port);
|
| 1121 | | }
|
| 1122 | | else
|
| 1123 | | {
|
| 1124 | | return 0;
|
| 1125 | | }
|
| 1126 | | }
|
| 1127 | | |
| 1128 | | INLINE void iface_gpio_port_w( device_t *device, int port, UINT32 data)
|
| 1129 | | {
|
| 1130 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1131 | | if (s3c44b0->iface->gpio.port_w)
|
| 1132 | | {
|
| 1133 | | (s3c44b0->iface->gpio.port_w)( device, port, data);
|
| 1134 | | }
|
| 1135 | | }
|
| 1136 | | |
| 1137 | | static READ32_DEVICE_HANDLER( s3c44b0_gpio_r )
|
| 1138 | | {
|
| 1139 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1140 | | UINT32 data = ((UINT32*)&s3c44b0->gpio.regs)[offset];
|
| 1141 | | switch (offset)
|
| 1142 | | {
|
| 1143 | | case S3C44B0_GPADAT :
|
| 1144 | | {
|
| 1145 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_A) & S3C44B0_GPADAT_MASK;
|
| 1146 | | }
|
| 1147 | | break;
|
| 1148 | | case S3C44B0_GPBDAT :
|
| 1149 | | {
|
| 1150 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_B) & S3C44B0_GPBDAT_MASK;
|
| 1151 | | }
|
| 1152 | | break;
|
| 1153 | | case S3C44B0_GPCDAT :
|
| 1154 | | {
|
| 1155 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_C) & S3C44B0_GPCDAT_MASK;
|
| 1156 | | }
|
| 1157 | | break;
|
| 1158 | | case S3C44B0_GPDDAT :
|
| 1159 | | {
|
| 1160 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_D) & S3C44B0_GPDDAT_MASK;
|
| 1161 | | }
|
| 1162 | | break;
|
| 1163 | | case S3C44B0_GPEDAT :
|
| 1164 | | {
|
| 1165 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_E) & S3C44B0_GPEDAT_MASK;
|
| 1166 | | }
|
| 1167 | | break;
|
| 1168 | | case S3C44B0_GPFDAT :
|
| 1169 | | {
|
| 1170 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_F) & S3C44B0_GPFDAT_MASK;
|
| 1171 | | }
|
| 1172 | | break;
|
| 1173 | | case S3C44B0_GPGDAT :
|
| 1174 | | {
|
| 1175 | | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_G) & S3C44B0_GPGDAT_MASK;
|
| 1176 | | }
|
| 1177 | | break;
|
| 1178 | | }
|
| 1179 | | verboselog( device->machine(), 9, "(GPIO) %08X -> %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
|
| 1180 | | return data;
|
| 1181 | | }
|
| 1182 | | |
| 1183 | | static WRITE32_DEVICE_HANDLER( s3c44b0_gpio_w )
|
| 1184 | | {
|
| 1185 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1186 | | UINT32 old_value = ((UINT32*)&s3c44b0->gpio.regs)[offset];
|
| 1187 | | verboselog( device->machine(), 9, "(GPIO) %08X <- %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data);
|
| 1188 | | COMBINE_DATA(&((UINT32*)&s3c44b0->gpio.regs)[offset]);
|
| 1189 | | switch (offset)
|
| 1190 | | {
|
| 1191 | | case S3C44B0_GPADAT :
|
| 1192 | | {
|
| 1193 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_A, data & S3C44B0_GPADAT_MASK);
|
| 1194 | | }
|
| 1195 | | break;
|
| 1196 | | case S3C44B0_GPBDAT :
|
| 1197 | | {
|
| 1198 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_B, data & S3C44B0_GPBDAT_MASK);
|
| 1199 | | }
|
| 1200 | | break;
|
| 1201 | | case S3C44B0_GPCDAT :
|
| 1202 | | {
|
| 1203 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_C, data & S3C44B0_GPCDAT_MASK);
|
| 1204 | | }
|
| 1205 | | break;
|
| 1206 | | case S3C44B0_GPDDAT :
|
| 1207 | | {
|
| 1208 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_D, data & S3C44B0_GPDDAT_MASK);
|
| 1209 | | }
|
| 1210 | | break;
|
| 1211 | | case S3C44B0_GPEDAT :
|
| 1212 | | {
|
| 1213 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_E, data & S3C44B0_GPEDAT_MASK);
|
| 1214 | | }
|
| 1215 | | break;
|
| 1216 | | case S3C44B0_GPFDAT :
|
| 1217 | | {
|
| 1218 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_F, data & S3C44B0_GPFDAT_MASK);
|
| 1219 | | }
|
| 1220 | | break;
|
| 1221 | | case S3C44B0_GPGDAT :
|
| 1222 | | {
|
| 1223 | | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_G, data & S3C44B0_GPGDAT_MASK);
|
| 1224 | | }
|
| 1225 | | break;
|
| 1226 | | case S3C44B0_EXTINTPND :
|
| 1227 | | {
|
| 1228 | | s3c44b0->gpio.regs.extintpnd = (old_value & ~data);
|
| 1229 | | s3c44b0_check_pending_eint( device);
|
| 1230 | | }
|
| 1231 | | break;
|
| 1232 | | }
|
| 1233 | | }
|
| 1234 | | |
| 1235 | | /* UART */
|
| 1236 | | |
| 1237 | | static UINT32 s3c44b0_uart_r( device_t *device, int ch, UINT32 offset)
|
| 1238 | | {
|
| 1239 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1240 | | UINT32 data = ((UINT32*)&s3c44b0->uart[ch].regs)[offset];
|
| 1241 | | switch (offset)
|
| 1242 | | {
|
| 1243 | | case S3C44B0_UTRSTAT :
|
| 1244 | | {
|
| 1245 | | data = (data & ~0x00000006) | 0x00000004 | 0x00000002; // [bit 2] Transmitter empty / [bit 1] Transmit buffer empty
|
| 1246 | | }
|
| 1247 | | break;
|
| 1248 | | case S3C44B0_URXH :
|
| 1249 | | {
|
| 1250 | | UINT8 rxdata = data & 0xFF;
|
| 1251 | | verboselog( device->machine(), 5, "UART %d read %02X (%c)\n", ch, rxdata, ((rxdata >= 32) && (rxdata < 128)) ? (char)rxdata : '?');
|
| 1252 | | s3c44b0->uart[ch].regs.utrstat &= ~1; // [bit 0] Receive buffer data ready
|
| 1253 | | }
|
| 1254 | | break;
|
| 1255 | | }
|
| 1256 | | return data;
|
| 1257 | | }
|
| 1258 | | |
| 1259 | | static void s3c44b0_uart_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask)
|
| 1260 | | {
|
| 1261 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1262 | | COMBINE_DATA(&((UINT32*)&s3c44b0->uart[ch].regs)[offset]);
|
| 1263 | | s3c44b0_uart_t *uart = &s3c44b0->uart[ch];
|
| 1264 | | switch (offset)
|
| 1265 | | {
|
| 1266 | | case S3C44B0_UTXH :
|
| 1267 | | {
|
| 1268 | | UINT8 txdata = data & 0xFF;
|
| 1269 | | verboselog( device->machine(), 5, "UART %d write %02X (%c)\n", ch, txdata, ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?');
|
| 1270 | | #ifdef UART_PRINTF
|
| 1271 | | printf( "%c", ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?');
|
| 1272 | | #endif
|
| 1273 | | }
|
| 1274 | | break;
|
| 1275 | | case S3C44B0_UBRDIV :
|
| 1276 | | {
|
| 1277 | | UINT32 mclk, hz;
|
| 1278 | | mclk = s3c44b0_get_mclk( device);
|
| 1279 | | hz = (mclk / (uart->regs.ubrdiv + 1)) / 16;
|
| 1280 | | verboselog( device->machine(), 5, "UART %d - mclk %08X hz %08X\n", ch, mclk, hz);
|
| 1281 | | uart->timer->adjust( attotime::from_hz( hz), ch, attotime::from_hz( hz));
|
| 1282 | | }
|
| 1283 | | break;
|
| 1284 | | }
|
| 1285 | | }
|
| 1286 | | |
| 1287 | | static READ32_DEVICE_HANDLER( s3c44b0_uart_0_r )
|
| 1288 | | {
|
| 1289 | | UINT32 data = s3c44b0_uart_r( device, 0, offset);
|
| 1290 | | // verboselog( device->machine(), 9, "(UART 0) %08X -> %08X\n", S3C44B0_BASE_UART_0 + (offset << 2), data);
|
| 1291 | | return data;
|
| 1292 | | }
|
| 1293 | | |
| 1294 | | static READ32_DEVICE_HANDLER( s3c44b0_uart_1_r )
|
| 1295 | | {
|
| 1296 | | UINT32 data = s3c44b0_uart_r( device, 1, offset);
|
| 1297 | | // verboselog( device->machine(), 9, "(UART 1) %08X -> %08X\n", S3C44B0_BASE_UART_1 + (offset << 2), data);
|
| 1298 | | return data;
|
| 1299 | | }
|
| 1300 | | |
| 1301 | | static WRITE32_DEVICE_HANDLER( s3c44b0_uart_0_w )
|
| 1302 | | {
|
| 1303 | | verboselog( device->machine(), 9, "(UART 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_0 + (offset << 2), data, mem_mask);
|
| 1304 | | s3c44b0_uart_w( device, 0, offset, data, mem_mask);
|
| 1305 | | }
|
| 1306 | | |
| 1307 | | static WRITE32_DEVICE_HANDLER( s3c44b0_uart_1_w )
|
| 1308 | | {
|
| 1309 | | verboselog( device->machine(), 9, "(UART 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_1 + (offset << 2), data, mem_mask);
|
| 1310 | | s3c44b0_uart_w( device, 1, offset, data, mem_mask);
|
| 1311 | | }
|
| 1312 | | |
| 1313 | | void s3c44b0_uart_fifo_w( device_t *device, int uart, UINT8 data)
|
| 1314 | | {
|
| 1315 | | // printf( "s3c44b0_uart_fifo_w (%c)\n", data);
|
| 1316 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1317 | | s3c44b0->uart[uart].regs.urxh = data;
|
| 1318 | | s3c44b0->uart[uart].regs.utrstat |= 1; // [bit 0] Receive buffer data ready
|
| 1319 | | }
|
| 1320 | | |
| 1321 | | static TIMER_CALLBACK( s3c44b0_uart_timer_exp )
|
| 1322 | | {
|
| 1323 | | device_t *device = (device_t *)ptr;
|
| 1324 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1325 | | int ch = param;
|
| 1326 | | s3c44b0_uart_t *uart = &s3c44b0->uart[ch];
|
| 1327 | | verboselog( machine, 2, "UART %d timer callback\n", ch);
|
| 1328 | | if ((uart->regs.ucon & (1 << 9)) != 0)
|
| 1329 | | {
|
| 1330 | | const int ch_int[] = { S3C44B0_INT_UTXD0, S3C44B0_INT_UTXD1 };
|
| 1331 | | s3c44b0_request_irq( device, ch_int[ch]);
|
| 1332 | | }
|
| 1333 | | }
|
| 1334 | | |
| 1335 | | /* Watchdog Timer */
|
| 1336 | | |
| 1337 | | static UINT16 s3c44b0_wdt_calc_current_count( device_t *device)
|
| 1338 | | {
|
| 1339 | | return 0;
|
| 1340 | | }
|
| 1341 | | |
| 1342 | | static READ32_DEVICE_HANDLER( s3c44b0_wdt_r )
|
| 1343 | | {
|
| 1344 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1345 | | UINT32 data = ((UINT32*)&s3c44b0->wdt.regs)[offset];
|
| 1346 | | switch (offset)
|
| 1347 | | {
|
| 1348 | | case S3C44B0_WTCNT :
|
| 1349 | | {
|
| 1350 | | // is wdt active?
|
| 1351 | | if ((s3c44b0->wdt.regs.wtcon & (1 << 5)) != 0)
|
| 1352 | | {
|
| 1353 | | data = s3c44b0_wdt_calc_current_count( device);
|
| 1354 | | }
|
| 1355 | | }
|
| 1356 | | break;
|
| 1357 | | }
|
| 1358 | | verboselog( device->machine(), 9, "(WDT) %08X -> %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
|
| 1359 | | return data;
|
| 1360 | | }
|
| 1361 | | |
| 1362 | | static void s3c44b0_wdt_start( device_t *device)
|
| 1363 | | {
|
| 1364 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1365 | | UINT32 mclk, prescaler, clock;
|
| 1366 | | double freq, hz;
|
| 1367 | | verboselog( device->machine(), 1, "WDT start\n");
|
| 1368 | | mclk = s3c44b0_get_mclk( device);
|
| 1369 | | prescaler = BITS( s3c44b0->wdt.regs.wtcon, 15, 8);
|
| 1370 | | clock = 16 << BITS( s3c44b0->wdt.regs.wtcon, 4, 3);
|
| 1371 | | freq = (double)mclk / (prescaler + 1) / clock;
|
| 1372 | | hz = freq / s3c44b0->wdt.regs.wtcnt;
|
| 1373 | | verboselog( device->machine(), 5, "WDT mclk %d prescaler %d clock %d freq %f hz %f\n", mclk, prescaler, clock, freq, hz);
|
| 1374 | | s3c44b0->wdt.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz));
|
| 1375 | | }
|
| 1376 | | |
| 1377 | | static void s3c44b0_wdt_stop( device_t *device)
|
| 1378 | | {
|
| 1379 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1380 | | verboselog( device->machine(), 1, "WDT stop\n");
|
| 1381 | | s3c44b0->wdt.regs.wtcnt = s3c44b0_wdt_calc_current_count( device);
|
| 1382 | | s3c44b0->wdt.timer->adjust( attotime::never, 0);
|
| 1383 | | }
|
| 1384 | | |
| 1385 | | static void s3c44b0_wdt_recalc( device_t *device)
|
| 1386 | | {
|
| 1387 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1388 | | if ((s3c44b0->wdt.regs.wtcon & (1 << 5)) != 0)
|
| 1389 | | {
|
| 1390 | | s3c44b0_wdt_start( device);
|
| 1391 | | }
|
| 1392 | | else
|
| 1393 | | {
|
| 1394 | | s3c44b0_wdt_stop( device);
|
| 1395 | | }
|
| 1396 | | }
|
| 1397 | | |
| 1398 | | static WRITE32_DEVICE_HANDLER( s3c44b0_wdt_w )
|
| 1399 | | {
|
| 1400 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1401 | | UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset];
|
| 1402 | | verboselog( device->machine(), 9, "(WDT) %08X <- %08X\n", S3C44B0_BASE_WDT + (offset << 2), data);
|
| 1403 | | COMBINE_DATA(&((UINT32*)&s3c44b0->wdt.regs)[offset]);
|
| 1404 | | switch (offset)
|
| 1405 | | {
|
| 1406 | | case S3C44B0_WTCON :
|
| 1407 | | {
|
| 1408 | | if ((data & (1 << 5)) != (old_value & (1 << 5)))
|
| 1409 | | {
|
| 1410 | | s3c44b0_wdt_recalc( device);
|
| 1411 | | }
|
| 1412 | | }
|
| 1413 | | break;
|
| 1414 | | }
|
| 1415 | | }
|
| 1416 | | |
| 1417 | | static TIMER_CALLBACK( s3c44b0_wdt_timer_exp )
|
| 1418 | | {
|
| 1419 | | device_t *device = (device_t *)ptr;
|
| 1420 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1421 | | verboselog( machine, 2, "WDT timer callback\n");
|
| 1422 | | if ((s3c44b0->wdt.regs.wtcon & (1 << 2)) != 0)
|
| 1423 | | {
|
| 1424 | | s3c44b0_request_irq( device, S3C44B0_INT_WDT);
|
| 1425 | | }
|
| 1426 | | if ((s3c44b0->wdt.regs.wtcon & (1 << 0)) != 0)
|
| 1427 | | {
|
| 1428 | | s3c44b0_reset( device);
|
| 1429 | | }
|
| 1430 | | }
|
| 1431 | | |
| 1432 | | /* CPU Wrapper */
|
| 1433 | | |
| 1434 | | static READ32_DEVICE_HANDLER( s3c44b0_cpuwrap_r )
|
| 1435 | | {
|
| 1436 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1437 | | UINT32 data = ((UINT32*)&s3c44b0->cpuwrap.regs)[offset];
|
| 1438 | | verboselog( device->machine(), 9, "(CPUWRAP) %08X -> %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
|
| 1439 | | return data;
|
| 1440 | | }
|
| 1441 | | |
| 1442 | | static WRITE32_DEVICE_HANDLER( s3c44b0_cpuwrap_w )
|
| 1443 | | {
|
| 1444 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1445 | | verboselog( device->machine(), 9, "(CPUWRAP) %08X <- %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data);
|
| 1446 | | COMBINE_DATA(&((UINT32*)&s3c44b0->cpuwrap.regs)[offset]);
|
| 1447 | | }
|
| 1448 | | |
| 1449 | | /* A/D Converter */
|
| 1450 | | |
| 1451 | | static READ32_DEVICE_HANDLER( s3c44b0_adc_r )
|
| 1452 | | {
|
| 1453 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1454 | | UINT32 data = ((UINT32*)&s3c44b0->adc.regs)[offset];
|
| 1455 | | verboselog( device->machine(), 9, "(ADC) %08X -> %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
|
| 1456 | | return data;
|
| 1457 | | }
|
| 1458 | | |
| 1459 | | static void s3c44b0_adc_start( device_t *device)
|
| 1460 | | {
|
| 1461 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1462 | | UINT32 mclk, prescaler;
|
| 1463 | | double freq, hz;
|
| 1464 | | verboselog( device->machine(), 1, "ADC start\n");
|
| 1465 | | mclk = s3c44b0_get_mclk( device);
|
| 1466 | | prescaler = BITS( s3c44b0->adc.regs.adcpsr, 7, 0);
|
| 1467 | | freq = (double)mclk / (2 * (prescaler + 1)) / 16;
|
| 1468 | | hz = freq / 1; //s3c44b0->wdt.regs.wtcnt;
|
| 1469 | | verboselog( device->machine(), 5, "ADC mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz);
|
| 1470 | | s3c44b0->adc.timer->adjust( attotime::from_hz( hz), 0);
|
| 1471 | | }
|
| 1472 | | |
| 1473 | | static void s3c44b0_adc_stop( device_t *device)
|
| 1474 | | {
|
| 1475 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1476 | | verboselog( device->machine(), 1, "ADC stop\n");
|
| 1477 | | s3c44b0->adc.timer->adjust( attotime::never, 0);
|
| 1478 | | }
|
| 1479 | | |
| 1480 | | static void s3c44b0_adc_recalc( device_t *device)
|
| 1481 | | {
|
| 1482 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1483 | | if ((s3c44b0->adc.regs.adccon & (1 << 0)) != 0)
|
| 1484 | | {
|
| 1485 | | s3c44b0_adc_start( device);
|
| 1486 | | }
|
| 1487 | | else
|
| 1488 | | {
|
| 1489 | | s3c44b0_adc_stop( device);
|
| 1490 | | }
|
| 1491 | | }
|
| 1492 | | |
| 1493 | | static WRITE32_DEVICE_HANDLER( s3c44b0_adc_w )
|
| 1494 | | {
|
| 1495 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1496 | | UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset];
|
| 1497 | | verboselog( device->machine(), 9, "(ADC) %08X <- %08X\n", S3C44B0_BASE_ADC + (offset << 2), data);
|
| 1498 | | COMBINE_DATA(&((UINT32*)&s3c44b0->adc.regs)[offset]);
|
| 1499 | | switch (offset)
|
| 1500 | | {
|
| 1501 | | case S3C44B0_ADCCON :
|
| 1502 | | {
|
| 1503 | | if ((data & (1 << 0)) != (old_value & (1 << 0)))
|
| 1504 | | {
|
| 1505 | | s3c44b0_adc_recalc( device);
|
| 1506 | | }
|
| 1507 | | s3c44b0->adc.regs.adccon &= ~(1 << 0); // "this bit is cleared after the start-up"
|
| 1508 | | }
|
| 1509 | | break;
|
| 1510 | | }
|
| 1511 | | }
|
| 1512 | | |
| 1513 | | static TIMER_CALLBACK( s3c44b0_adc_timer_exp )
|
| 1514 | | {
|
| 1515 | | device_t *device = (device_t *)ptr;
|
| 1516 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1517 | | verboselog( machine, 2, "ADC timer callback\n");
|
| 1518 | | s3c44b0->adc.regs.adccon |= (1 << 6);
|
| 1519 | | s3c44b0_request_irq( device, S3C44B0_INT_ADC);
|
| 1520 | | }
|
| 1521 | | |
| 1522 | | /* SIO */
|
| 1523 | | |
| 1524 | | static READ32_DEVICE_HANDLER( s3c44b0_sio_r )
|
| 1525 | | {
|
| 1526 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1527 | | UINT32 data = ((UINT32*)&s3c44b0->sio.regs)[offset];
|
| 1528 | | verboselog( device->machine(), 9, "(SIO) %08X -> %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
|
| 1529 | | return data;
|
| 1530 | | }
|
| 1531 | | |
| 1532 | | static void s3c44b0_sio_start( device_t *device)
|
| 1533 | | {
|
| 1534 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1535 | | UINT32 mclk, prescaler;
|
| 1536 | | double freq, hz;
|
| 1537 | | verboselog( device->machine(), 1, "SIO start\n");
|
| 1538 | | mclk = s3c44b0_get_mclk( device);
|
| 1539 | | prescaler = BITS( s3c44b0->sio.regs.sbrdr, 11, 0);
|
| 1540 | | freq = (double)mclk / 2 / (prescaler + 1);
|
| 1541 | | hz = freq / 1; //s3c44b0->wdt.regs.wtcnt;
|
| 1542 | | verboselog( device->machine(), 5, "SIO mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz);
|
| 1543 | | s3c44b0->sio.timer->adjust( attotime::from_hz( hz), 0);
|
| 1544 | | // printf( "SIO transmit %02X (%c)\n", s3c44b0->sio.regs.siodat, ((s3c44b0->sio.regs.siodat >= 32) && (s3c44b0->sio.regs.siodat < 128)) ? (char)s3c44b0->sio.regs.siodat : '?');
|
| 1545 | | }
|
| 1546 | | |
| 1547 | | static void s3c44b0_sio_stop( device_t *device)
|
| 1548 | | {
|
| 1549 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1550 | | verboselog( device->machine(), 1, "SIO stop\n");
|
| 1551 | | // s3c44b0->wdt.regs.wtcnt = s3c44b0_wdt_calc_current_count( device);
|
| 1552 | | s3c44b0->sio.timer->adjust( attotime::never, 0);
|
| 1553 | | }
|
| 1554 | | |
| 1555 | | static void s3c44b0_sio_recalc( device_t *device)
|
| 1556 | | {
|
| 1557 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1558 | | if ((s3c44b0->sio.regs.siocon & (1 << 3)) != 0)
|
| 1559 | | {
|
| 1560 | | s3c44b0_sio_start( device);
|
| 1561 | | }
|
| 1562 | | else
|
| 1563 | | {
|
| 1564 | | s3c44b0_sio_stop( device);
|
| 1565 | | }
|
| 1566 | | }
|
| 1567 | | |
| 1568 | | static WRITE32_DEVICE_HANDLER( s3c44b0_sio_w )
|
| 1569 | | {
|
| 1570 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1571 | | UINT32 old_value = ((UINT32*)&s3c44b0->sio.regs)[offset];
|
| 1572 | | verboselog( device->machine(), 9, "(SIO) %08X <- %08X\n", S3C44B0_BASE_SIO + (offset << 2), data);
|
| 1573 | | COMBINE_DATA(&((UINT32*)&s3c44b0->sio.regs)[offset]);
|
| 1574 | | switch (offset)
|
| 1575 | | {
|
| 1576 | | case S3C44B0_SIOCON :
|
| 1577 | | {
|
| 1578 | | if ((old_value & (1 << 3)) != (data & (1 << 3)))
|
| 1579 | | {
|
| 1580 | | s3c44b0_sio_recalc( device);
|
| 1581 | | }
|
| 1582 | | s3c44b0->sio.regs.siocon &= ~(1 << 3); // "This bit is cleared just after writing this bit as 1."
|
| 1583 | | }
|
| 1584 | | break;
|
| 1585 | | }
|
| 1586 | | }
|
| 1587 | | |
| 1588 | | static TIMER_CALLBACK( s3c44b0_sio_timer_exp )
|
| 1589 | | {
|
| 1590 | | device_t *device = (device_t *)ptr;
|
| 1591 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1592 | | verboselog( machine, 2, "SIO timer callback\n");
|
| 1593 | | |
| 1594 | | s3c44b0->sio.regs.siodat = 0x00; // TEST
|
| 1595 | | |
| 1596 | | if ((s3c44b0->sio.regs.siocon & (1 << 0)) != 0)
|
| 1597 | | {
|
| 1598 | | s3c44b0_request_irq( device, S3C44B0_INT_SIO);
|
| 1599 | | }
|
| 1600 | | }
|
| 1601 | | |
| 1602 | | /* IIS */
|
| 1603 | | |
| 1604 | | INLINE void iface_i2s_data_w( device_t *device, int ch, UINT16 data)
|
| 1605 | | {
|
| 1606 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1607 | | if (s3c44b0->iface->i2s.data_w)
|
| 1608 | | {
|
| 1609 | | (s3c44b0->iface->i2s.data_w)( device, ch, data, 0);
|
| 1610 | | }
|
| 1611 | | }
|
| 1612 | | |
| 1613 | | static void s3c44b0_iis_start( device_t *device)
|
| 1614 | | {
|
| 1615 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1616 | | UINT32 mclk;
|
| 1617 | | int prescaler;
|
| 1618 | | double freq, hz;
|
| 1619 | | const int div[] = { 2, 4, 6, 8, 10, 12, 14, 16, 1, 0, 3, 0, 5, 0, 7, 0 };
|
| 1620 | | verboselog( device->machine(), 1, "IIS start\n");
|
| 1621 | | mclk = s3c44b0_get_mclk( device);
|
| 1622 | | prescaler = BITS( s3c44b0->iis.regs.iispsr, 3, 0);
|
| 1623 | | freq = (double)mclk / div[prescaler];
|
| 1624 | | hz = freq / 256 * 2;
|
| 1625 | | verboselog( device->machine(), 5, "IIS mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz);
|
| 1626 | | s3c44b0->iis.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz));
|
| 1627 | | }
|
| 1628 | | |
| 1629 | | static void s3c44b0_iis_stop( device_t *device)
|
| 1630 | | {
|
| 1631 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1632 | | verboselog( device->machine(), 1, "IIS stop\n");
|
| 1633 | | s3c44b0->iis.timer->adjust( attotime::never, 0);
|
| 1634 | | }
|
| 1635 | | |
| 1636 | | static READ32_DEVICE_HANDLER( s3c44b0_iis_r )
|
| 1637 | | {
|
| 1638 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1639 | | UINT32 data = ((UINT32*)&s3c44b0->iis.regs)[offset];
|
| 1640 | | verboselog( device->machine(), 9, "(IIS) %08X -> %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
|
| 1641 | | return data;
|
| 1642 | | }
|
| 1643 | | |
| 1644 | | static WRITE32_DEVICE_HANDLER( s3c44b0_iis_w )
|
| 1645 | | {
|
| 1646 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1647 | | UINT32 old_value = ((UINT32*)&s3c44b0->iis.regs)[offset];
|
| 1648 | | verboselog( device->machine(), 9, "(IIS) %08X <- %08X\n", S3C44B0_BASE_IIS + (offset << 2), data);
|
| 1649 | | COMBINE_DATA(&((UINT32*)&s3c44b0->iis.regs)[offset]);
|
| 1650 | | switch (offset)
|
| 1651 | | {
|
| 1652 | | case S3C44B0_IISCON :
|
| 1653 | | {
|
| 1654 | | if ((old_value & (1 << 0)) != (data & (1 << 0)))
|
| 1655 | | {
|
| 1656 | | if ((data & (1 << 0)) != 0)
|
| 1657 | | {
|
| 1658 | | s3c44b0_iis_start( device);
|
| 1659 | | }
|
| 1660 | | else
|
| 1661 | | {
|
| 1662 | | s3c44b0_iis_stop( device);
|
| 1663 | | }
|
| 1664 | | }
|
| 1665 | | }
|
| 1666 | | break;
|
| 1667 | | case S3C44B0_IISFIFO :
|
| 1668 | | {
|
| 1669 | | if (ACCESSING_BITS_16_31)
|
| 1670 | | {
|
| 1671 | | s3c44b0->iis.fifo[s3c44b0->iis.fifo_index++] = BITS( data, 31, 16);
|
| 1672 | | }
|
| 1673 | | if (ACCESSING_BITS_0_15)
|
| 1674 | | {
|
| 1675 | | s3c44b0->iis.fifo[s3c44b0->iis.fifo_index++] = BITS( data, 15, 0);
|
| 1676 | | }
|
| 1677 | | if (s3c44b0->iis.fifo_index == 2)
|
| 1678 | | {
|
| 1679 | | s3c44b0->iis.fifo_index = 0;
|
| 1680 | | iface_i2s_data_w( device, 0, s3c44b0->iis.fifo[0]);
|
| 1681 | | iface_i2s_data_w( device, 1, s3c44b0->iis.fifo[1]);
|
| 1682 | | }
|
| 1683 | | }
|
| 1684 | | break;
|
| 1685 | | }
|
| 1686 | | }
|
| 1687 | | |
| 1688 | | static TIMER_CALLBACK( s3c44b0_iis_timer_exp )
|
| 1689 | | {
|
| 1690 | | device_t *device = (device_t *)ptr;
|
| 1691 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1692 | | s3c44b0_iis_t *iis = &s3c44b0->iis;
|
| 1693 | | verboselog( machine, 2, "IIS timer callback\n");
|
| 1694 | | if ((iis->regs.iiscon & (1 << 5)) != 0)
|
| 1695 | | {
|
| 1696 | | s3c44b0_bdma_request_iis( device);
|
| 1697 | | }
|
| 1698 | | }
|
| 1699 | | |
| 1700 | | /* ZDMA */
|
| 1701 | | |
| 1702 | | static void s3c44b0_zdma_trigger( device_t *device, int ch)
|
| 1703 | | {
|
| 1704 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1705 | | s3c44b0_dma_t *dma = &s3c44b0->zdma[ch];
|
| 1706 | | UINT32 saddr, daddr;
|
| 1707 | | int dal, dst, opt, das, cnt;
|
| 1708 | | verboselog( device->machine(), 5, "s3c44b0_zdma_trigger %d\n", ch);
|
| 1709 | | dst = BITS( dma->regs.dcsrc, 31, 30);
|
| 1710 | | dal = BITS( dma->regs.dcsrc, 29, 28);
|
| 1711 | | saddr = BITS( dma->regs.dcsrc, 27, 0);
|
| 1712 | | verboselog( device->machine(), 5, "dst %d dal %d saddr %08X\n", dst, dal, saddr);
|
| 1713 | | opt = BITS( dma->regs.dcdst, 31, 30);
|
| 1714 | | das = BITS( dma->regs.dcdst, 29, 28);
|
| 1715 | | daddr = BITS( dma->regs.dcdst, 27, 0);
|
| 1716 | | verboselog( device->machine(), 5, "opt %d das %d daddr %08X\n", opt, das, daddr);
|
| 1717 | | cnt = BITS( dma->regs.dccnt, 19, 0);
|
| 1718 | | verboselog( device->machine(), 5, "icnt %08X\n", cnt);
|
| 1719 | | while (cnt > 0)
|
| 1720 | | {
|
| 1721 | | verboselog( device->machine(), 9, "[%08X] -> [%08X]\n", saddr, daddr);
|
| 1722 | | switch (dst)
|
| 1723 | | {
|
| 1724 | | case 0 : s3c44b0->space->write_byte( daddr, s3c44b0->space->read_byte( saddr)); break;
|
| 1725 | | case 1 : s3c44b0->space->write_word( daddr, s3c44b0->space->read_word( saddr)); break;
|
| 1726 | | case 2 : s3c44b0->space->write_dword( daddr, s3c44b0->space->read_dword( saddr)); break;
|
| 1727 | | }
|
| 1728 | | switch (dal)
|
| 1729 | | {
|
| 1730 | | case 1 : saddr += (1 << dst); break;
|
| 1731 | | case 2 : saddr -= (1 << dst); break;
|
| 1732 | | }
|
| 1733 | | switch (das)
|
| 1734 | | {
|
| 1735 | | case 1 : daddr += (1 << dst); break;
|
| 1736 | | case 2 : daddr -= (1 << dst); break;
|
| 1737 | | }
|
| 1738 | | cnt -= (1 << dst);
|
| 1739 | | }
|
| 1740 | | dma->regs.dcsrc = CLR_BITS( dma->regs.dcsrc, 27, 0) | saddr;
|
| 1741 | | dma->regs.dcdst = CLR_BITS( dma->regs.dcdst, 27, 0) | daddr;
|
| 1742 | | dma->regs.dccnt = CLR_BITS( dma->regs.dcdst, 19, 0) | cnt;
|
| 1743 | | if (cnt == 0)
|
| 1744 | | {
|
| 1745 | | if ((dma->regs.dccnt & (1 << 23)) != 0)
|
| 1746 | | {
|
| 1747 | | const int ch_int[] = { S3C44B0_INT_ZDMA0, S3C44B0_INT_ZDMA1 };
|
| 1748 | | s3c44b0_request_irq( device, ch_int[ch]);
|
| 1749 | | }
|
| 1750 | | }
|
| 1751 | | }
|
| 1752 | | |
| 1753 | | static void s3c44b0_zdma_start( device_t *device, int ch)
|
| 1754 | | {
|
| 1755 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1756 | | s3c44b0_dma_t *dma = &s3c44b0->zdma[ch];
|
| 1757 | | verboselog( device->machine(), 5, "ZDMA %d start\n", ch);
|
| 1758 | | dma->regs.dcsrc = dma->regs.disrc;
|
| 1759 | | dma->regs.dcdst = dma->regs.didst;
|
| 1760 | | dma->regs.dccnt = dma->regs.dicnt;
|
| 1761 | | s3c44b0_zdma_trigger( device, ch);
|
| 1762 | | }
|
| 1763 | | |
| 1764 | | static UINT32 s3c44b0_zdma_r( device_t *device, int ch, UINT32 offset)
|
| 1765 | | {
|
| 1766 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1767 | | UINT32 data = ((UINT32*)&s3c44b0->zdma[ch].regs)[offset];
|
| 1768 | | return data;
|
| 1769 | | }
|
| 1770 | | |
| 1771 | | static void s3c44b0_zdma_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask)
|
| 1772 | | {
|
| 1773 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1774 | | UINT32 old_value = ((UINT32*)&s3c44b0->zdma[ch].regs)[offset];
|
| 1775 | | COMBINE_DATA(&((UINT32*)&s3c44b0->zdma[ch].regs)[offset]);
|
| 1776 | | switch (offset)
|
| 1777 | | {
|
| 1778 | | case S3C44B0_DCON :
|
| 1779 | | {
|
| 1780 | | if ((old_value & 3) != (data & 3))
|
| 1781 | | {
|
| 1782 | | switch (data & 3)
|
| 1783 | | {
|
| 1784 | | case 1 : s3c44b0_zdma_start( device, ch); break;
|
| 1785 | | }
|
| 1786 | | }
|
| 1787 | | s3c44b0->zdma[ch].regs.dcon &= ~3; // "After writing 01,10,11, CMD bit is cleared automatically"
|
| 1788 | | }
|
| 1789 | | break;
|
| 1790 | | }
|
| 1791 | | }
|
| 1792 | | |
| 1793 | | static READ32_DEVICE_HANDLER( s3c44b0_zdma_0_r )
|
| 1794 | | {
|
| 1795 | | UINT32 data = s3c44b0_zdma_r( device, 0, offset);
|
| 1796 | | verboselog( device->machine(), 9, "(ZDMA 0) %08X -> %08X\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data);
|
| 1797 | | return data;
|
| 1798 | | }
|
| 1799 | | |
| 1800 | | static READ32_DEVICE_HANDLER( s3c44b0_zdma_1_r )
|
| 1801 | | {
|
| 1802 | | UINT32 data = s3c44b0_zdma_r( device, 1, offset);
|
| 1803 | | verboselog( device->machine(), 9, "(ZDMA 1) %08X -> %08X\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data);
|
| 1804 | | return data;
|
| 1805 | | }
|
| 1806 | | |
| 1807 | | static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_0_w )
|
| 1808 | | {
|
| 1809 | | verboselog( device->machine(), 9, "(ZDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data, mem_mask);
|
| 1810 | | s3c44b0_zdma_w( device, 0, offset, data, mem_mask);
|
| 1811 | | }
|
| 1812 | | |
| 1813 | | static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_1_w )
|
| 1814 | | {
|
| 1815 | | verboselog( device->machine(), 9, "(ZDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data, mem_mask);
|
| 1816 | | s3c44b0_zdma_w( device, 1, offset, data, mem_mask);
|
| 1817 | | }
|
| 1818 | | |
| 1819 | | static TIMER_CALLBACK( s3c44b0_zdma_timer_exp )
|
| 1820 | | {
|
| 1821 | | int ch = param;
|
| 1822 | | verboselog( machine, 2, "ZDMA %d timer callback\n", ch);
|
| 1823 | | }
|
| 1824 | | |
| 1825 | | /* BDMA */
|
| 1826 | | |
| 1827 | | static void s3c44b0_bdma_trigger( device_t *device, int ch)
|
| 1828 | | {
|
| 1829 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1830 | | s3c44b0_dma_t *dma = &s3c44b0->bdma[ch];
|
| 1831 | | UINT32 saddr, daddr;
|
| 1832 | | int dal, dst, tdm, das, cnt;
|
| 1833 | | verboselog( device->machine(), 5, "s3c44b0_bdma_trigger %d\n", ch);
|
| 1834 | | dst = BITS( dma->regs.dcsrc, 31, 30);
|
| 1835 | | dal = BITS( dma->regs.dcsrc, 29, 28);
|
| 1836 | | saddr = BITS( dma->regs.dcsrc, 27, 0);
|
| 1837 | | verboselog( device->machine(), 5, "dst %d dal %d saddr %08X\n", dst, dal, saddr);
|
| 1838 | | tdm = BITS( dma->regs.dcdst, 31, 30);
|
| 1839 | | das = BITS( dma->regs.dcdst, 29, 28);
|
| 1840 | | daddr = BITS( dma->regs.dcdst, 27, 0);
|
| 1841 | | verboselog( device->machine(), 5, "tdm %d das %d daddr %08X\n", tdm, das, daddr);
|
| 1842 | | cnt = BITS( dma->regs.dccnt, 19, 0);
|
| 1843 | | verboselog( device->machine(), 5, "icnt %08X\n", cnt);
|
| 1844 | | verboselog( device->machine(), 9, "[%08X] -> [%08X]\n", saddr, daddr);
|
| 1845 | | switch (dst)
|
| 1846 | | {
|
| 1847 | | case 0 : s3c44b0->space->write_byte( daddr, s3c44b0->space->read_byte( saddr)); break;
|
| 1848 | | case 1 : s3c44b0->space->write_word( daddr, s3c44b0->space->read_word( saddr)); break;
|
| 1849 | | case 2 : s3c44b0->space->write_dword( daddr, s3c44b0->space->read_dword( saddr)); break;
|
| 1850 | | }
|
| 1851 | | switch (dal)
|
| 1852 | | {
|
| 1853 | | case 1 : saddr += (1 << dst); break;
|
| 1854 | | case 2 : saddr -= (1 << dst); break;
|
| 1855 | | }
|
| 1856 | | switch (das)
|
| 1857 | | {
|
| 1858 | | case 1 : daddr += (1 << dst); break;
|
| 1859 | | case 2 : daddr -= (1 << dst); break;
|
| 1860 | | }
|
| 1861 | | cnt -= (1 << dst);
|
| 1862 | | dma->regs.dcsrc = CLR_BITS( dma->regs.dcsrc, 27, 0) | saddr;
|
| 1863 | | dma->regs.dcdst = CLR_BITS( dma->regs.dcdst, 27, 0) | daddr;
|
| 1864 | | dma->regs.dccnt = CLR_BITS( dma->regs.dcdst, 19, 0) | cnt;
|
| 1865 | | if (cnt == 0)
|
| 1866 | | {
|
| 1867 | | if ((dma->regs.dccnt & (1 << 23)) != 0)
|
| 1868 | | {
|
| 1869 | | const int ch_int[] = { S3C44B0_INT_BDMA0, S3C44B0_INT_BDMA1 };
|
| 1870 | | s3c44b0_request_irq( device, ch_int[ch]);
|
| 1871 | | }
|
| 1872 | | }
|
| 1873 | | }
|
| 1874 | | |
| 1875 | | static void s3c44b0_bdma_request_iis( device_t *device)
|
| 1876 | | {
|
| 1877 | | // s3c44b0_t *s3c44b0 = get_token( device);
|
| 1878 | | // s3c44b0_dma_regs_t *regs = &s3c24xx->bdma[0].regs;
|
| 1879 | | verboselog( device->machine(), 5, "s3c44b0_bdma_request_iis\n");
|
| 1880 | | s3c44b0_bdma_trigger( device, 0);
|
| 1881 | | }
|
| 1882 | | |
| 1883 | | static UINT32 s3c44b0_bdma_r( device_t *device, int ch, UINT32 offset)
|
| 1884 | | {
|
| 1885 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1886 | | UINT32 data = ((UINT32*)&s3c44b0->bdma[ch].regs)[offset];
|
| 1887 | | return data;
|
| 1888 | | }
|
| 1889 | | |
| 1890 | | static void s3c44b0_bdma_start( device_t *device, int ch)
|
| 1891 | | {
|
| 1892 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1893 | | s3c44b0_dma_t *dma = &s3c44b0->bdma[ch];
|
| 1894 | | int qsc;
|
| 1895 | | verboselog( device->machine(), 5, "BDMA %d start\n", ch);
|
| 1896 | | qsc = BITS( dma->regs.dicnt, 31, 30);
|
| 1897 | | if ((ch == 0) && (qsc == 1))
|
| 1898 | | {
|
| 1899 | | // IIS
|
| 1900 | | }
|
| 1901 | | else
|
| 1902 | | {
|
| 1903 | | printf( "s3c44b0_bdma_start - todo\n");
|
| 1904 | | }
|
| 1905 | | dma->regs.dcsrc = dma->regs.disrc;
|
| 1906 | | dma->regs.dcdst = dma->regs.didst;
|
| 1907 | | dma->regs.dccnt = dma->regs.dicnt;
|
| 1908 | | }
|
| 1909 | | |
| 1910 | | static void s3c44b0_bdma_stop( device_t *device, int ch)
|
| 1911 | | {
|
| 1912 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1913 | | verboselog( device->machine(), 5, "BDMA %d stop\n", ch);
|
| 1914 | | s3c44b0->bdma[ch].timer->adjust( attotime::never, ch);
|
| 1915 | | }
|
| 1916 | | |
| 1917 | | static void s3c44b0_bdma_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask)
|
| 1918 | | {
|
| 1919 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1920 | | UINT32 old_value = ((UINT32*)&s3c44b0->bdma[ch].regs)[offset];
|
| 1921 | | COMBINE_DATA(&((UINT32*)&s3c44b0->bdma[ch].regs)[offset]);
|
| 1922 | | switch (offset)
|
| 1923 | | {
|
| 1924 | | case S3C44B0_DICNT :
|
| 1925 | | {
|
| 1926 | | if ((old_value & (1 << 20)) != (data & (1 << 20)))
|
| 1927 | | {
|
| 1928 | | if ((data & (1 << 20)) != 0)
|
| 1929 | | {
|
| 1930 | | s3c44b0_bdma_start( device, ch);
|
| 1931 | | }
|
| 1932 | | else
|
| 1933 | | {
|
| 1934 | | s3c44b0_bdma_stop( device, ch);
|
| 1935 | | }
|
| 1936 | | }
|
| 1937 | | }
|
| 1938 | | break;
|
| 1939 | | }
|
| 1940 | | }
|
| 1941 | | |
| 1942 | | static READ32_DEVICE_HANDLER( s3c44b0_bdma_0_r )
|
| 1943 | | {
|
| 1944 | | UINT32 data = s3c44b0_bdma_r( device, 0, offset);
|
| 1945 | | verboselog( device->machine(), 9, "(BDMA 0) %08X -> %08X\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data);
|
| 1946 | | return data;
|
| 1947 | | }
|
| 1948 | | |
| 1949 | | static READ32_DEVICE_HANDLER( s3c44b0_bdma_1_r )
|
| 1950 | | {
|
| 1951 | | UINT32 data = s3c44b0_bdma_r( device, 1, offset);
|
| 1952 | | verboselog( device->machine(), 9, "(BDMA 1) %08X -> %08X\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data);
|
| 1953 | | return data;
|
| 1954 | | }
|
| 1955 | | |
| 1956 | | static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_0_w )
|
| 1957 | | {
|
| 1958 | | verboselog( device->machine(), 9, "(BDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data, mem_mask);
|
| 1959 | | s3c44b0_bdma_w( device, 0, offset, data, mem_mask);
|
| 1960 | | }
|
| 1961 | | |
| 1962 | | static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_1_w )
|
| 1963 | | {
|
| 1964 | | verboselog( device->machine(), 9, "(BDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data, mem_mask);
|
| 1965 | | s3c44b0_bdma_w( device, 1, offset, data, mem_mask);
|
| 1966 | | }
|
| 1967 | | |
| 1968 | | static TIMER_CALLBACK( s3c44b0_bdma_timer_exp )
|
| 1969 | | {
|
| 1970 | | // device_t *device = (device_t *)ptr;
|
| 1971 | | // s3c44b0_t *s3c44b0 = get_token( device);
|
| 1972 | | int ch = param;
|
| 1973 | | verboselog( machine, 2, "BDMA %d timer callback\n", ch);
|
| 1974 | | }
|
| 1975 | | |
| 1976 | | // ...
|
| 1977 | | |
| 1978 | | static DEVICE_RESET( s3c44b0 )
|
| 1979 | | {
|
| 1980 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 1981 | | s3c44b0->iis.fifo_index = 0;
|
| 1982 | | // s3c44b0->iic.data_index = 0;
|
| 1983 | | #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440)
|
| 1984 | | s3c44b0->gpio.regs.gstatus2 = 0x00000001; // Boot is caused by power on reset
|
| 1985 | | #endif
|
| 1986 | | s3c44b0->irq.line_irq = s3c44b0->irq.line_fiq = CLEAR_LINE;
|
| 1987 | | }
|
| 1988 | | |
| 1989 | | VIDEO_START( s3c44b0 )
|
| 1990 | | {
|
| 1991 | | device_t *device = machine.device( S3C44B0_TAG);
|
| 1992 | | s3c44b0_video_start( device, machine);
|
| 1993 | | }
|
| 1994 | | |
| 1995 | | SCREEN_UPDATE( s3c44b0 )
|
| 1996 | | {
|
| 1997 | | device_t *device = screen->machine().device( S3C44B0_TAG);
|
| 1998 | | return s3c44b0_video_update( device, screen, bitmap, cliprect);
|
| 1999 | | }
|
| 2000 | | |
| 2001 | | DEVICE_START( s3c44b0 )
|
| 2002 | | {
|
| 2003 | | running_machine &machine = device->machine();
|
| 2004 | | address_space *space = machine.device( "maincpu")->memory().space( AS_PROGRAM);
|
| 2005 | | s3c44b0_t *s3c44b0 = get_token( device);
|
| 2006 | | s3c44b0->iface = (const s3c44b0_interface *)device->static_config();
|
| 2007 | | s3c44b0->space = space;
|
| 2008 | | s3c44b0->cpu = downcast<cpu_device *>(device->machine().device( "maincpu"));
|
| 2009 | | for (int i = 0; i < 6; i++) s3c44b0->pwm.timer[i] = machine.scheduler().timer_alloc(FUNC(s3c44b0_pwm_timer_exp), (void*)device);
|
| 2010 | | for (int i = 0; i < 2; i++) s3c44b0->uart[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_uart_timer_exp), (void*)device);
|
| 2011 | | for (int i = 0; i < 2; i++) s3c44b0->zdma[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_zdma_timer_exp), (void*)device);
|
| 2012 | | for (int i = 0; i < 2; i++) s3c44b0->bdma[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_bdma_timer_exp), (void*)device);
|
| 2013 | | s3c44b0->lcd.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_lcd_timer_exp), (void*)device);
|
| 2014 | | s3c44b0->wdt.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_wdt_timer_exp), (void*)device);
|
| 2015 | | s3c44b0->sio.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_sio_timer_exp), (void*)device);
|
| 2016 | | s3c44b0->adc.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_adc_timer_exp), (void*)device);
|
| 2017 | | s3c44b0->iic.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_iic_timer_exp), (void*)device);
|
| 2018 | | s3c44b0->iis.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_iis_timer_exp), (void*)device);
|
| 2019 | | space->install_legacy_readwrite_handler( *device, 0x01c00000, 0x01c0000b, 0, 0, FUNC(s3c44b0_cpuwrap_r), FUNC(s3c44b0_cpuwrap_w));
|
| 2020 | | space->install_legacy_readwrite_handler( *device, 0x01d00000, 0x01d0002b, 0, 0, FUNC(s3c44b0_uart_0_r), FUNC(s3c44b0_uart_0_w));
|
| 2021 | | space->install_legacy_readwrite_handler( *device, 0x01d04000, 0x01d0402b, 0, 0, FUNC(s3c44b0_uart_1_r), FUNC(s3c44b0_uart_1_w));
|
| 2022 | | space->install_legacy_readwrite_handler( *device, 0x01d14000, 0x01d14013, 0, 0, FUNC(s3c44b0_sio_r), FUNC(s3c44b0_sio_w));
|
| 2023 | | space->install_legacy_readwrite_handler( *device, 0x01d18000, 0x01d18013, 0, 0, FUNC(s3c44b0_iis_r), FUNC(s3c44b0_iis_w));
|
| 2024 | | space->install_legacy_readwrite_handler( *device, 0x01d20000, 0x01d20057, 0, 0, FUNC(s3c44b0_gpio_r), FUNC(s3c44b0_gpio_w));
|
| 2025 | | space->install_legacy_readwrite_handler( *device, 0x01d30000, 0x01d3000b, 0, 0, FUNC(s3c44b0_wdt_r), FUNC(s3c44b0_wdt_w));
|
| 2026 | | space->install_legacy_readwrite_handler( *device, 0x01d40000, 0x01d4000b, 0, 0, FUNC(s3c44b0_adc_r), FUNC(s3c44b0_adc_w));
|
| 2027 | | space->install_legacy_readwrite_handler( *device, 0x01d50000, 0x01d5004f, 0, 0, FUNC(s3c44b0_pwm_r), FUNC(s3c44b0_pwm_w));
|
| 2028 | | space->install_legacy_readwrite_handler( *device, 0x01d60000, 0x01d6000f, 0, 0, FUNC(s3c44b0_iic_r), FUNC(s3c44b0_iic_w));
|
| 2029 | | space->install_legacy_readwrite_handler( *device, 0x01d80000, 0x01d8000f, 0, 0, FUNC(s3c44b0_clkpow_r), FUNC(s3c44b0_clkpow_w));
|
| 2030 | | space->install_legacy_readwrite_handler( *device, 0x01e00000, 0x01e0003f, 0, 0, FUNC(s3c44b0_irq_r), FUNC(s3c44b0_irq_w));
|
| 2031 | | space->install_legacy_readwrite_handler( *device, 0x01e80000, 0x01e8001b, 0, 0, FUNC(s3c44b0_zdma_0_r), FUNC(s3c44b0_zdma_0_w));
|
| 2032 | | space->install_legacy_readwrite_handler( *device, 0x01e80020, 0x01e8003b, 0, 0, FUNC(s3c44b0_zdma_1_r), FUNC(s3c44b0_zdma_1_w));
|
| 2033 | | space->install_legacy_readwrite_handler( *device, 0x01f00000, 0x01f00047, 0, 0, FUNC(s3c44b0_lcd_r), FUNC(s3c44b0_lcd_w));
|
| 2034 | | space->install_legacy_readwrite_handler( *device, 0x01f80000, 0x01f8001b, 0, 0, FUNC(s3c44b0_bdma_0_r), FUNC(s3c44b0_bdma_0_w));
|
| 2035 | | space->install_legacy_readwrite_handler( *device, 0x01f80020, 0x01f8003b, 0, 0, FUNC(s3c44b0_bdma_1_r), FUNC(s3c44b0_bdma_1_w));
|
| 2036 | | }
|
| 2037 | | |
| 2038 | | DEVICE_GET_INFO( s3c44b0 )
|
| 2039 | | {
|
| 2040 | | switch ( state )
|
| 2041 | | {
|
| 2042 | | /* --- the following bits of info are returned as 64-bit signed integers --- */
|
| 2043 | | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(s3c44b0_t); break;
|
| 2044 | | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break;
|
| 2045 | | // case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break;
|
| 2046 | | /* --- the following bits of info are returned as pointers to data or functions --- */
|
| 2047 | | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(s3c44b0); break;
|
| 2048 | | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(s3c44b0); break;
|
| 2049 | | /* --- the following bits of info are returned as NULL-terminated strings --- */
|
| 2050 | | case DEVINFO_STR_FAMILY: strcpy(info->s, "S3C44B0"); break;
|
| 2051 | | case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break;
|
| 2052 | | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break;
|
| 2053 | | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break;
|
| 2054 | | case DEVINFO_STR_NAME: strcpy(info->s, "Samsung S3C44B0"); break;
|
| 2055 | | }
|
| 2056 | | }
|
| 2057 | | |
| 2058 | | DEFINE_LEGACY_DEVICE(S3C44B0, s3c44b0);
|
| 1 | /******************************************************************************* |
| 2 | |
| 3 | Samsung S3C44B0 |
| 4 | |
| 5 | (c) 2011 Tim Schuerewegen |
| 6 | |
| 7 | *******************************************************************************/ |
| 8 | |
| 9 | #include "emu.h" |
| 10 | #include "cpu/arm7/arm7.h" |
| 11 | #include "cpu/arm7/arm7core.h" |
| 12 | #include "machine/s3c44b0.h" |
| 13 | #include "sound/dac.h" |
| 14 | #include "coreutil.h" |
| 15 | |
| 16 | #define VERBOSE_LEVEL ( 0 ) |
| 17 | |
| 18 | INLINE void ATTR_PRINTF(3,4) verboselog( running_machine &machine, int n_level, const char *s_fmt, ...) |
| 19 | { |
| 20 | if (VERBOSE_LEVEL >= n_level) |
| 21 | { |
| 22 | va_list v; |
| 23 | char buf[32768]; |
| 24 | va_start( v, s_fmt); |
| 25 | vsprintf( buf, s_fmt, v); |
| 26 | va_end( v); |
| 27 | logerror( "%s: %s", machine.describe_context(), buf); |
| 28 | } |
| 29 | } |
| 30 | |
| 31 | /******************************************************************************* |
| 32 | MACROS & CONSTANTS |
| 33 | *******************************************************************************/ |
| 34 | |
| 35 | #define UART_PRINTF |
| 36 | |
| 37 | #define CLOCK_MULTIPLIER 1 |
| 38 | |
| 39 | #define BIT(x,n) (((x)>>(n))&1) |
| 40 | #define BITS(x,m,n) (((x)>>(n))&(((UINT32)1<<((m)-(n)+1))-1)) |
| 41 | #define CLR_BITS(x,m,n) ((x) & ~((((UINT32)1 << ((m) - (n) + 1)) - 1) << n)) |
| 42 | |
| 43 | /*************************************************************************** |
| 44 | PROTOTYPES |
| 45 | ***************************************************************************/ |
| 46 | |
| 47 | static UINT32 s3c44b0_get_mclk( device_t *device); |
| 48 | |
| 49 | static void s3c44b0_bdma_request_iis( device_t *device); |
| 50 | //static void s3c44b0_dma_request_pwm( device_t *device); |
| 51 | |
| 52 | /*************************************************************************** |
| 53 | INLINE FUNCTIONS |
| 54 | ***************************************************************************/ |
| 55 | |
| 56 | INLINE s3c44b0_t *get_token( device_t *device) |
| 57 | { |
| 58 | assert(device != NULL); |
| 59 | return (s3c44b0_t *)downcast<legacy_device_base *>(device)->token(); |
| 60 | } |
| 61 | |
| 62 | /*************************************************************************** |
| 63 | IMPLEMENTATION |
| 64 | ***************************************************************************/ |
| 65 | |
| 66 | /* ... */ |
| 67 | |
| 68 | static void s3c44b0_reset( device_t *device) |
| 69 | { |
| 70 | fatalerror( "s3c44b0_reset\n"); |
| 71 | } |
| 72 | |
| 73 | /* LCD Controller */ |
| 74 | |
| 75 | static rgb_t s3c44b0_get_color_stn_04( device_t *device, UINT8 data) |
| 76 | { |
| 77 | UINT8 r, g, b; |
| 78 | r = g = b = BITS( data, 3, 0) << 4; |
| 79 | return MAKE_RGB( r, g, b); |
| 80 | } |
| 81 | |
| 82 | static UINT8 s3c44b0_get_color_stn_08_r( device_t *device, UINT8 data) |
| 83 | { |
| 84 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 85 | return ((lcd->regs.redlut >> (BITS( data, 7, 5) << 2)) & 0xF) << 4; |
| 86 | } |
| 87 | |
| 88 | static UINT8 s3c44b0_get_color_stn_08_g( device_t *device, UINT8 data) |
| 89 | { |
| 90 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 91 | return ((lcd->regs.greenlut >> (BITS( data, 4, 2) << 2)) & 0xF) << 4; |
| 92 | } |
| 93 | |
| 94 | static UINT8 s3c44b0_get_color_stn_08_b( device_t *device, UINT8 data) |
| 95 | { |
| 96 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 97 | return ((lcd->regs.bluelut >> (BITS( data, 1, 0) << 2)) & 0xF) << 4; |
| 98 | } |
| 99 | |
| 100 | static void s3c44b0_lcd_dma_reload( device_t *device) |
| 101 | { |
| 102 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 103 | int lcdbank, lcdbaseu, lcdbasel; |
| 104 | lcdbank = BITS( lcd->regs.lcdsaddr1, 26, 21); |
| 105 | lcdbaseu = BITS( lcd->regs.lcdsaddr1, 20, 0); |
| 106 | lcdbasel = BITS( lcd->regs.lcdsaddr2, 20, 0); |
| 107 | lcd->vramaddr_cur = (lcdbank << 22) | (lcdbaseu << 1); |
| 108 | lcd->vramaddr_max = (lcdbank << 22) | (lcdbasel << 1); |
| 109 | if (lcdbasel == 0) lcd->vramaddr_max += 1 << 22; |
| 110 | lcd->offsize = BITS( lcd->regs.lcdsaddr3, 19, 9); |
| 111 | lcd->pagewidth_cur = 0; |
| 112 | lcd->pagewidth_max = BITS( lcd->regs.lcdsaddr3, 8, 0); |
| 113 | lcd->bswp = BIT( lcd->regs.lcdsaddr2, 29); // note: juicebox changes bswp when video playback starts |
| 114 | // verboselog( device->machine(), 3, "LCD - vramaddr %08X %08X offsize %08X pagewidth %08X\n", lcd->vramaddr_cur, lcd->vramaddr_max, lcd->offsize, lcd->pagewidth_max); |
| 115 | } |
| 116 | |
| 117 | static void s3c44b0_lcd_dma_init( device_t *device) |
| 118 | { |
| 119 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 120 | lcd->modesel = BITS( lcd->regs.lcdsaddr1, 28, 27); |
| 121 | // verboselog( device->machine(), 3, "LCD - modesel %d bswp %d\n", lcd->modesel, lcd->bswp); |
| 122 | s3c44b0_lcd_dma_reload( device); |
| 123 | } |
| 124 | |
| 125 | static void s3c44b0_lcd_dma_read( device_t *device, int count, UINT8 *data) |
| 126 | { |
| 127 | s3c44b0_t *s3c44b0 = get_token( device); |
| 128 | s3c44b0_lcd_t *lcd = &s3c44b0->lcd; |
| 129 | UINT8 *vram; |
| 130 | vram = (UINT8 *)s3c44b0->space->get_read_ptr( lcd->vramaddr_cur); |
| 131 | for (int i = 0; i < count / 2; i++) |
| 132 | { |
| 133 | if (lcd->bswp == 0) |
| 134 | { |
| 135 | if ((lcd->vramaddr_cur & 2) == 0) |
| 136 | { |
| 137 | data[0] = *(vram + 3); |
| 138 | data[1] = *(vram + 2); |
| 139 | } |
| 140 | else |
| 141 | { |
| 142 | data[0] = *(vram - 1); |
| 143 | data[1] = *(vram - 2); |
| 144 | } |
| 145 | } |
| 146 | else |
| 147 | { |
| 148 | data[0] = *(vram + 0); |
| 149 | data[1] = *(vram + 1); |
| 150 | } |
| 151 | lcd->vramaddr_cur += 2; |
| 152 | lcd->pagewidth_cur++; |
| 153 | if (lcd->pagewidth_cur >= lcd->pagewidth_max) |
| 154 | { |
| 155 | lcd->vramaddr_cur += lcd->offsize << 1; |
| 156 | if (lcd->vramaddr_cur >= lcd->vramaddr_max) |
| 157 | { |
| 158 | s3c44b0_lcd_dma_reload( device); |
| 159 | } |
| 160 | lcd->pagewidth_cur = 0; |
| 161 | vram = (UINT8 *)s3c44b0->space->get_read_ptr( lcd->vramaddr_cur); |
| 162 | } |
| 163 | else |
| 164 | { |
| 165 | vram += 2; |
| 166 | } |
| 167 | data += 2; |
| 168 | } |
| 169 | } |
| 170 | |
| 171 | static void s3c44b0_lcd_render_stn_04( device_t *device) |
| 172 | { |
| 173 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 174 | UINT8 *bitmap = lcd->bitmap + ((lcd->vpos - lcd->vpos_min) * (lcd->hpos_max - lcd->hpos_min + 1)) + (lcd->hpos - lcd->hpos_min); |
| 175 | UINT8 data[16]; |
| 176 | s3c44b0_lcd_dma_read( device, 16, data); |
| 177 | for (int i = 0; i < 16; i++) |
| 178 | { |
| 179 | for (int j = 0; j < 2; j++) |
| 180 | { |
| 181 | *bitmap++ = s3c44b0_get_color_stn_04( device, (data[i] >> 4) & 0x0F); |
| 182 | data[i] = data[i] << 4; |
| 183 | lcd->hpos++; |
| 184 | if (lcd->hpos >= lcd->hpos_min + (lcd->pagewidth_max << 2)) |
| 185 | { |
| 186 | lcd->vpos++; |
| 187 | if (lcd->vpos > lcd->vpos_max) |
| 188 | { |
| 189 | lcd->vpos = lcd->vpos_min; |
| 190 | bitmap = lcd->bitmap; |
| 191 | } |
| 192 | lcd->hpos = lcd->hpos_min; |
| 193 | } |
| 194 | } |
| 195 | } |
| 196 | } |
| 197 | |
| 198 | static void s3c44b0_lcd_render_stn_08( device_t *device) |
| 199 | { |
| 200 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 201 | UINT8 *bitmap = lcd->bitmap + ((lcd->vpos - lcd->vpos_min) * (lcd->hpos_max - lcd->hpos_min + 1)) + (lcd->hpos - lcd->hpos_min); |
| 202 | UINT8 data[16]; |
| 203 | s3c44b0_lcd_dma_read( device, 16, data); |
| 204 | for (int i = 0; i < 16; i++) |
| 205 | { |
| 206 | UINT8 xxx[3]; |
| 207 | xxx[0] = s3c44b0_get_color_stn_08_r( device, data[i]); |
| 208 | xxx[1] = s3c44b0_get_color_stn_08_g( device, data[i]); |
| 209 | xxx[2] = s3c44b0_get_color_stn_08_b( device, data[i]); |
| 210 | for (int j = 0; j < 3; j++) |
| 211 | { |
| 212 | *bitmap++ = xxx[j]; |
| 213 | lcd->hpos++; |
| 214 | if (lcd->hpos >= lcd->hpos_min + (lcd->pagewidth_max * 6)) |
| 215 | { |
| 216 | lcd->vpos++; |
| 217 | if (lcd->vpos > lcd->vpos_max) |
| 218 | { |
| 219 | lcd->vpos = lcd->vpos_min; |
| 220 | bitmap = lcd->bitmap; |
| 221 | } |
| 222 | lcd->hpos = lcd->hpos_min; |
| 223 | } |
| 224 | } |
| 225 | } |
| 226 | } |
| 227 | |
| 228 | static attotime s3c44b0_time_until_pos( device_t *device, int vpos, int hpos) |
| 229 | { |
| 230 | running_machine &machine = device->machine(); |
| 231 | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd); |
| 232 | attoseconds_t time1, time2; |
| 233 | attotime retval; |
| 234 | verboselog( device->machine(), 3, "s3c44b0_time_until_pos - vpos %d hpos %d\n", vpos, hpos); |
| 235 | time1 = (attoseconds_t)vpos * lcd->scantime + (attoseconds_t)hpos * lcd->pixeltime; |
| 236 | time2 = (machine.time() - lcd->frame_time).as_attoseconds(); |
| 237 | verboselog( device->machine(), 3, "machine %f frametime %f time1 %f time2 %f\n", machine.time().as_double(), lcd->frame_time.as_double(), attotime( 0, time1).as_double(), attotime( 0, time2).as_double()); |
| 238 | while (time1 <= time2) time1 += lcd->frame_period; |
| 239 | retval = attotime( 0, time1 - time2); |
| 240 | verboselog( device->machine(), 3, "result %f\n", retval.as_double()); |
| 241 | return retval; |
| 242 | } |
| 243 | |
| 244 | static int s3c44b0_lcd_get_vpos( device_t *device) |
| 245 | { |
| 246 | running_machine &machine = device->machine(); |
| 247 | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd); |
| 248 | attoseconds_t delta; |
| 249 | int vpos; |
| 250 | delta = (machine.time() - lcd->frame_time).as_attoseconds(); |
| 251 | delta = delta + (lcd->pixeltime / 2); |
| 252 | vpos = delta / lcd->scantime; |
| 253 | return (lcd->vpos_min + vpos) % lcd->vpos_end; |
| 254 | } |
| 255 | |
| 256 | static int s3c44b0_lcd_get_hpos( device_t *device) |
| 257 | { |
| 258 | running_machine &machine = device->machine(); |
| 259 | s3c44b0_lcd_t *lcd = (s3c44b0_lcd_t *)&(get_token( device)->lcd); |
| 260 | attoseconds_t delta; |
| 261 | int vpos; |
| 262 | delta = (machine.time() - lcd->frame_time).as_attoseconds(); |
| 263 | delta = delta + (lcd->pixeltime / 2); |
| 264 | vpos = delta / lcd->scantime; |
| 265 | delta = delta - (vpos * lcd->scantime); |
| 266 | return delta / lcd->pixeltime; |
| 267 | } |
| 268 | |
| 269 | static TIMER_CALLBACK( s3c44b0_lcd_timer_exp ) |
| 270 | { |
| 271 | device_t *device = (device_t *)ptr; |
| 272 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 273 | int vpos = lcd->vpos; |
| 274 | verboselog( machine, 2, "LCD timer callback (%f)\n", machine.time().as_double()); |
| 275 | verboselog( machine, 3, "LCD - (1) vramaddr %08X vpos %d hpos %d\n", lcd->vramaddr_cur, lcd->vpos, lcd->hpos); |
| 276 | switch (lcd->modesel) |
| 277 | { |
| 278 | case S3C44B0_MODESEL_04 : s3c44b0_lcd_render_stn_04( device); break; |
| 279 | case S3C44B0_MODESEL_08 : s3c44b0_lcd_render_stn_08( device); break; |
| 280 | default : verboselog( machine, 0, "s3c44b0_lcd_timer_exp: modesel %d not supported\n", lcd->modesel); break; |
| 281 | } |
| 282 | verboselog( machine, 3, "LCD - (2) vramaddr %08X vpos %d hpos %d\n", lcd->vramaddr_cur, lcd->vpos, lcd->hpos); |
| 283 | if (lcd->vpos < vpos) |
| 284 | { |
| 285 | // verboselog( machine, 3, "LCD - (1) frame_time %f\n", attotime_to_double( lcd->frame_time)); |
| 286 | lcd->frame_time = machine.time() + s3c44b0_time_until_pos( device, lcd->vpos_min, lcd->hpos_min); |
| 287 | // verboselog( machine, 3, "LCD - (2) frame_time %f\n", attotime_to_double( lcd->frame_time)); |
| 288 | } |
| 289 | lcd->timer->adjust( s3c44b0_time_until_pos( device, lcd->vpos, lcd->hpos), 0); |
| 290 | } |
| 291 | |
| 292 | static void s3c44b0_video_start( device_t *device, running_machine &machine) |
| 293 | { |
| 294 | // do nothing |
| 295 | } |
| 296 | |
| 297 | static UINT32 s3c44b0_video_update( device_t *device, screen_device *screen, bitmap_t *bitmap, const rectangle *cliprect) |
| 298 | { |
| 299 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 300 | if (lcd->regs.lcdcon1 & (1 << 0)) |
| 301 | { |
| 302 | if (lcd->bitmap) |
| 303 | { |
| 304 | for (int y = 0; y < screen->height(); y++) |
| 305 | { |
| 306 | UINT32 *scanline = BITMAP_ADDR32( bitmap, y, 0); |
| 307 | UINT8 *vram = lcd->bitmap + y * (lcd->hpos_max - lcd->hpos_min + 1); |
| 308 | for (int x = 0; x < screen->width(); x++) |
| 309 | { |
| 310 | *scanline++ = MAKE_RGB( vram[0], vram[1], vram[2]); |
| 311 | vram += 3; |
| 312 | } |
| 313 | } |
| 314 | } |
| 315 | } |
| 316 | else |
| 317 | { |
| 318 | for (int y = 0; y < screen->height(); y++) |
| 319 | { |
| 320 | UINT32 *scanline = BITMAP_ADDR32( bitmap, y, 0); |
| 321 | memset( scanline, 0, screen->width() * 4); |
| 322 | } |
| 323 | } |
| 324 | return 0; |
| 325 | } |
| 326 | |
| 327 | static READ32_DEVICE_HANDLER( s3c44b0_lcd_r ) |
| 328 | { |
| 329 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 330 | UINT32 data = ((UINT32*)&lcd->regs)[offset]; |
| 331 | switch (offset) |
| 332 | { |
| 333 | case S3C44B0_LCDCON1 : |
| 334 | { |
| 335 | int vpos = 0; |
| 336 | // make sure line counter is going |
| 337 | if (lcd->regs.lcdcon1 & (1 << 0)) |
| 338 | { |
| 339 | vpos = s3c44b0_lcd_get_vpos( device); |
| 340 | int hpos = s3c44b0_lcd_get_hpos( device); |
| 341 | if (hpos < lcd->hpos_min) vpos = vpos - 1; |
| 342 | if ((vpos < lcd->vpos_min) || (vpos > lcd->vpos_max)) vpos = lcd->vpos_max; |
| 343 | vpos = lcd->vpos_max - vpos; |
| 344 | } |
| 345 | data = (data & ~0xFFC00000) | (vpos << 22); |
| 346 | } |
| 347 | break; |
| 348 | } |
| 349 | // verboselog( device->machine(), 9, "(LCD) %08X -> %08X\n", S3C44B0_BASE_LCD + (offset << 2), data); |
| 350 | return data; |
| 351 | } |
| 352 | |
| 353 | static void s3c44b0_lcd_configure( device_t *device) |
| 354 | { |
| 355 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 356 | screen_device *screen = device->machine().primary_screen; |
| 357 | int dismode, clkval, lineval, wdly, hozval, lineblank, wlh, mclk; |
| 358 | double vclk, framerate; |
| 359 | int width, height; |
| 360 | verboselog( device->machine(), 5, "s3c44b0_lcd_configure\n"); |
| 361 | dismode = BITS( lcd->regs.lcdcon1, 6, 5); |
| 362 | clkval = BITS( lcd->regs.lcdcon1, 21, 12); |
| 363 | lineval = BITS( lcd->regs.lcdcon2, 9, 0); |
| 364 | wdly = BITS( lcd->regs.lcdcon1, 9, 8); |
| 365 | hozval = BITS( lcd->regs.lcdcon2, 20, 10); |
| 366 | lineblank = BITS( lcd->regs.lcdcon2, 31, 21); |
| 367 | wlh = BITS( lcd->regs.lcdcon1, 11, 10); |
| 368 | mclk = s3c44b0_get_mclk( device); |
| 369 | verboselog( device->machine(), 3, "LCD - dismode %d clkval %d lineval %d wdly %d hozval %d lineblank %d wlh %d mclk %d\n", dismode, clkval, lineval, wdly, hozval, lineblank, wlh, mclk); |
| 370 | vclk = (double)(mclk / (clkval * 2)); |
| 371 | verboselog( device->machine(), 3, "LCD - vclk %f\n", vclk); |
| 372 | framerate = 1 / (((1 / vclk) * (hozval + 1) + (1 / mclk) * (wlh + wdly + lineblank)) * (lineval + 1)); |
| 373 | framerate = framerate / 3; // ??? |
| 374 | verboselog( device->machine(), 3, "LCD - framerate %f\n", framerate); |
| 375 | switch (dismode) |
| 376 | { |
| 377 | case S3C44B0_PNRMODE_STN_04_SS : width = ((hozval + 1) * 4); break; |
| 378 | case S3C44B0_PNRMODE_STN_04_DS : width = ((hozval + 1) * 4); break; |
| 379 | case S3C44B0_PNRMODE_STN_08_SS : width = ((hozval + 1) * 8); break; |
| 380 | default : fatalerror( "invalid display mode (%d)", dismode); break; |
| 381 | } |
| 382 | height = lineval + 1; |
| 383 | lcd->framerate = framerate; |
| 384 | verboselog( device->machine(), 3, "video_screen_configure %d %d %f\n", width, height, lcd->framerate); |
| 385 | screen->configure( screen->width(), screen->height(), screen->visible_area(), HZ_TO_ATTOSECONDS( lcd->framerate)); |
| 386 | lcd->hpos_min = 25; |
| 387 | lcd->hpos_max = 25 + width - 1; |
| 388 | lcd->hpos_end = 25 + width - 1 + 25; |
| 389 | lcd->vpos_min = 25; |
| 390 | lcd->vpos_max = 25 + height - 1; |
| 391 | lcd->vpos_end = 25 + height - 1 + 25; |
| 392 | verboselog( device->machine(), 3, "LCD - min_x %d min_y %d max_x %d max_y %d\n", lcd->hpos_min, lcd->vpos_min, lcd->hpos_max, lcd->vpos_max); |
| 393 | if (lcd->bitmap) |
| 394 | { |
| 395 | auto_free( device->machine(), lcd->bitmap); |
| 396 | } |
| 397 | lcd->bitmap = auto_alloc_array( device->machine(), UINT8, (lcd->hpos_max - lcd->hpos_min + 1) * (lcd->vpos_max - lcd->vpos_min + 1) * 3); |
| 398 | lcd->frame_period = HZ_TO_ATTOSECONDS( lcd->framerate); |
| 399 | lcd->scantime = lcd->frame_period / lcd->vpos_end; |
| 400 | lcd->pixeltime = lcd->frame_period / (lcd->vpos_end * lcd->hpos_end); |
| 401 | // printf( "frame_period %f\n", attotime( 0, lcd->frame_period).as_double()); |
| 402 | // printf( "scantime %f\n", attotime( 0, lcd->scantime).as_double()); |
| 403 | // printf( "pixeltime %f\n", attotime( 0, lcd->pixeltime).as_double()); |
| 404 | } |
| 405 | |
| 406 | static void s3c44b0_lcd_start( device_t *device) |
| 407 | { |
| 408 | running_machine &machine = device->machine(); |
| 409 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 410 | screen_device *screen = device->machine().primary_screen; |
| 411 | verboselog( device->machine(), 1, "LCD start\n"); |
| 412 | s3c44b0_lcd_configure( device); |
| 413 | s3c44b0_lcd_dma_init( device); |
| 414 | lcd->vpos = lcd->vpos_min; |
| 415 | lcd->hpos = lcd->hpos_min; |
| 416 | lcd->frame_time = screen->time_until_pos( 0, 0); |
| 417 | lcd->timer->adjust( lcd->frame_time, 0); |
| 418 | lcd->frame_time = machine.time() + lcd->frame_time; |
| 419 | } |
| 420 | |
| 421 | static void s3c44b0_lcd_stop( device_t *device) |
| 422 | { |
| 423 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 424 | verboselog( device->machine(), 1, "LCD stop\n"); |
| 425 | lcd->timer->adjust( attotime::never, 0); |
| 426 | } |
| 427 | |
| 428 | static void s3c44b0_lcd_recalc( device_t *device) |
| 429 | { |
| 430 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 431 | if (lcd->regs.lcdcon1 & (1 << 0)) |
| 432 | { |
| 433 | s3c44b0_lcd_start( device); |
| 434 | } |
| 435 | else |
| 436 | { |
| 437 | s3c44b0_lcd_stop( device); |
| 438 | } |
| 439 | } |
| 440 | |
| 441 | static WRITE32_DEVICE_HANDLER( s3c44b0_lcd_w ) |
| 442 | { |
| 443 | s3c44b0_lcd_t *lcd = &(get_token( device)->lcd); |
| 444 | UINT32 old_value = ((UINT32*)&lcd->regs)[offset]; |
| 445 | // verboselog( device->machine(), 9, "(LCD) %08X <- %08X\n", S3C44B0_BASE_LCD + (offset << 2), data); |
| 446 | COMBINE_DATA(&((UINT32*)&lcd->regs)[offset]); |
| 447 | switch (offset) |
| 448 | { |
| 449 | case S3C44B0_LCDCON1 : |
| 450 | { |
| 451 | if ((old_value & (1 << 0)) != (data & (1 << 0))) |
| 452 | { |
| 453 | s3c44b0_lcd_recalc( device); |
| 454 | } |
| 455 | } |
| 456 | break; |
| 457 | } |
| 458 | } |
| 459 | |
| 460 | /* Clock & Power Management */ |
| 461 | |
| 462 | static UINT32 s3c44b0_get_mclk( device_t *device) |
| 463 | { |
| 464 | s3c44b0_t *s3c44b0 = get_token( device); |
| 465 | UINT32 data, mdiv, pdiv, sdiv; |
| 466 | data = s3c44b0->clkpow.regs.pllcon; |
| 467 | mdiv = BITS( data, 19, 12); |
| 468 | pdiv = BITS( data, 9, 4); |
| 469 | sdiv = BITS( data, 1, 0); |
| 470 | return (UINT32)((double)((mdiv + 8) * device->clock()) / (double)((pdiv + 2) * (1 << sdiv))); |
| 471 | } |
| 472 | |
| 473 | static READ32_DEVICE_HANDLER( s3c44b0_clkpow_r ) |
| 474 | { |
| 475 | s3c44b0_t *s3c44b0 = get_token( device); |
| 476 | UINT32 data = ((UINT32*)&s3c44b0->clkpow.regs)[offset]; |
| 477 | verboselog( device->machine(), 9, "(CLKPOW) %08X -> %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data); |
| 478 | return data; |
| 479 | } |
| 480 | |
| 481 | static WRITE32_DEVICE_HANDLER( s3c44b0_clkpow_w ) |
| 482 | { |
| 483 | s3c44b0_t *s3c44b0 = get_token( device); |
| 484 | verboselog( device->machine(), 9, "(CLKPOW) %08X <- %08X\n", S3C44B0_BASE_CLKPOW + (offset << 2), data); |
| 485 | COMBINE_DATA(&((UINT32*)&s3c44b0->clkpow.regs)[offset]); |
| 486 | switch (offset) |
| 487 | { |
| 488 | case S3C44B0_PLLCON : |
| 489 | { |
| 490 | verboselog( device->machine(), 5, "CLKPOW - mclk %d\n", s3c44b0_get_mclk( device)); |
| 491 | s3c44b0->cpu->set_unscaled_clock( s3c44b0_get_mclk( device) * CLOCK_MULTIPLIER); |
| 492 | } |
| 493 | break; |
| 494 | case S3C44B0_CLKCON : |
| 495 | { |
| 496 | if (data & (1 << 2)) |
| 497 | { |
| 498 | s3c44b0->cpu->spin_until_interrupt(); |
| 499 | } |
| 500 | } |
| 501 | break; |
| 502 | } |
| 503 | } |
| 504 | |
| 505 | /* Interrupt Controller */ |
| 506 | |
| 507 | static void s3c44b0_check_pending_irq( device_t *device) |
| 508 | { |
| 509 | s3c44b0_t *s3c44b0 = get_token( device); |
| 510 | UINT32 temp; |
| 511 | // normal irq |
| 512 | temp = (s3c44b0->irq.regs.intpnd & ~s3c44b0->irq.regs.intmsk) & ~s3c44b0->irq.regs.intmod; |
| 513 | if (temp != 0) |
| 514 | { |
| 515 | UINT32 int_type = 0; |
| 516 | while ((temp & 1) == 0) |
| 517 | { |
| 518 | int_type++; |
| 519 | temp = temp >> 1; |
| 520 | } |
| 521 | s3c44b0->irq.regs.i_ispr |= (1 << int_type); |
| 522 | if (s3c44b0->irq.line_irq != ASSERT_LINE) |
| 523 | { |
| 524 | s3c44b0->cpu->set_input_line( ARM7_IRQ_LINE, ASSERT_LINE); |
| 525 | s3c44b0->irq.line_irq = ASSERT_LINE; |
| 526 | } |
| 527 | } |
| 528 | else |
| 529 | { |
| 530 | if (s3c44b0->irq.line_irq != CLEAR_LINE) |
| 531 | { |
| 532 | s3c44b0->cpu->set_input_line( ARM7_IRQ_LINE, CLEAR_LINE); |
| 533 | s3c44b0->irq.line_irq = CLEAR_LINE; |
| 534 | } |
| 535 | } |
| 536 | // fast irq |
| 537 | temp = (s3c44b0->irq.regs.intpnd & ~s3c44b0->irq.regs.intmsk) & s3c44b0->irq.regs.intmod; |
| 538 | if (temp != 0) |
| 539 | { |
| 540 | UINT32 int_type = 0; |
| 541 | while ((temp & 1) == 0) |
| 542 | { |
| 543 | int_type++; |
| 544 | temp = temp >> 1; |
| 545 | } |
| 546 | if (s3c44b0->irq.line_fiq != ASSERT_LINE) |
| 547 | { |
| 548 | s3c44b0->cpu->set_input_line( ARM7_FIRQ_LINE, ASSERT_LINE); |
| 549 | s3c44b0->irq.line_fiq = ASSERT_LINE; |
| 550 | } |
| 551 | } |
| 552 | else |
| 553 | { |
| 554 | if (s3c44b0->irq.line_fiq != CLEAR_LINE) |
| 555 | { |
| 556 | s3c44b0->cpu->set_input_line( ARM7_FIRQ_LINE, CLEAR_LINE); |
| 557 | s3c44b0->irq.line_fiq = CLEAR_LINE; |
| 558 | } |
| 559 | } |
| 560 | } |
| 561 | |
| 562 | static void s3c44b0_request_irq( device_t *device, UINT32 int_type) |
| 563 | { |
| 564 | s3c44b0_t *s3c44b0 = get_token( device); |
| 565 | verboselog( device->machine(), 5, "request irq %d\n", int_type); |
| 566 | s3c44b0->irq.regs.intpnd |= (1 << int_type); |
| 567 | s3c44b0_check_pending_irq( device); |
| 568 | } |
| 569 | |
| 570 | static void s3c44b0_check_pending_eint( device_t *device) |
| 571 | { |
| 572 | s3c44b0_t *s3c44b0 = get_token( device); |
| 573 | UINT32 temp = s3c44b0->gpio.regs.extintpnd; |
| 574 | if (temp != 0) |
| 575 | { |
| 576 | UINT32 int_type = 0; |
| 577 | while ((temp & 1) == 0) |
| 578 | { |
| 579 | int_type++; |
| 580 | temp = temp >> 1; |
| 581 | } |
| 582 | s3c44b0_request_irq( device, S3C44B0_INT_EINT4_7); |
| 583 | } |
| 584 | } |
| 585 | |
| 586 | void s3c44b0_request_eint( device_t *device, UINT32 number) |
| 587 | { |
| 588 | s3c44b0_t *s3c44b0 = get_token( device); |
| 589 | verboselog( device->machine(), 5, "request external interrupt %d\n", number); |
| 590 | if (number < 4) |
| 591 | { |
| 592 | s3c44b0_request_irq( device, S3C44B0_INT_EINT0 + number); |
| 593 | } |
| 594 | else |
| 595 | { |
| 596 | s3c44b0->gpio.regs.extintpnd |= (1 << (number - 4)); |
| 597 | s3c44b0_check_pending_eint( device); |
| 598 | } |
| 599 | } |
| 600 | |
| 601 | static READ32_DEVICE_HANDLER( s3c44b0_irq_r ) |
| 602 | { |
| 603 | s3c44b0_t *s3c44b0 = get_token( device); |
| 604 | UINT32 data = ((UINT32*)&s3c44b0->irq.regs)[offset]; |
| 605 | verboselog( device->machine(), 9, "(IRQ) %08X -> %08X\n", S3C44B0_BASE_INT + (offset << 2), data); |
| 606 | return data; |
| 607 | } |
| 608 | |
| 609 | static WRITE32_DEVICE_HANDLER( s3c44b0_irq_w ) |
| 610 | { |
| 611 | s3c44b0_t *s3c44b0 = get_token( device); |
| 612 | verboselog( device->machine(), 9, "(IRQ) %08X <- %08X\n", S3C44B0_BASE_INT + (offset << 2), data); |
| 613 | COMBINE_DATA(&((UINT32*)&s3c44b0->irq.regs)[offset]); |
| 614 | switch (offset) |
| 615 | { |
| 616 | case S3C44B0_INTMSK : |
| 617 | { |
| 618 | s3c44b0_check_pending_irq( device); |
| 619 | } |
| 620 | break; |
| 621 | case S3C44B0_I_ISPC : |
| 622 | { |
| 623 | s3c44b0->irq.regs.intpnd = (s3c44b0->irq.regs.intpnd & ~data); // The bit of INTPND bit is cleared to zero by writing '1' on I_ISPC/F_ISPC |
| 624 | s3c44b0->irq.regs.i_ispr = (s3c44b0->irq.regs.i_ispr & ~data); // The pending bit in I_ISPR register should be cleared by writing I_ISPC register. |
| 625 | s3c44b0_check_pending_irq( device); |
| 626 | } |
| 627 | break; |
| 628 | case S3C44B0_F_ISPC : |
| 629 | { |
| 630 | s3c44b0->irq.regs.intpnd = (s3c44b0->irq.regs.intpnd & ~data); // The bit of INTPND bit is cleared to zero by writing '1' on I_ISPC/F_ISPC |
| 631 | s3c44b0_check_pending_irq( device); |
| 632 | } |
| 633 | break; |
| 634 | } |
| 635 | } |
| 636 | |
| 637 | /* PWM Timer */ |
| 638 | |
| 639 | static UINT16 s3c44b0_pwm_calc_observation( device_t *device, int ch) |
| 640 | { |
| 641 | s3c44b0_t *s3c44b0 = get_token( device); |
| 642 | double timeleft, x1, x2; |
| 643 | UINT32 cnto; |
| 644 | timeleft = (s3c44b0->pwm.timer[ch]->remaining()).as_double(); |
| 645 | // printf( "timeleft %f freq %d cntb %d cmpb %d\n", timeleft, s3c44b0->pwm.freq[ch], s3c44b0->pwm.cnt[ch], s3c44b0->pwm.cmp[ch]); |
| 646 | x1 = 1 / ((double)s3c44b0->pwm.freq[ch] / (s3c44b0->pwm.cnt[ch]- s3c44b0->pwm.cmp[ch] + 1)); |
| 647 | x2 = x1 / timeleft; |
| 648 | // printf( "x1 %f\n", x1); |
| 649 | cnto = s3c44b0->pwm.cmp[ch] + ((s3c44b0->pwm.cnt[ch]- s3c44b0->pwm.cmp[ch]) / x2); |
| 650 | // printf( "cnto %d\n", cnto); |
| 651 | return cnto; |
| 652 | } |
| 653 | |
| 654 | static READ32_DEVICE_HANDLER( s3c44b0_pwm_r ) |
| 655 | { |
| 656 | s3c44b0_t *s3c44b0 = get_token( device); |
| 657 | UINT32 data = ((UINT32*)&s3c44b0->pwm.regs)[offset]; |
| 658 | switch (offset) |
| 659 | { |
| 660 | case S3C44B0_TCNTO0 : |
| 661 | { |
| 662 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 0); |
| 663 | } |
| 664 | break; |
| 665 | case S3C44B0_TCNTO1 : |
| 666 | { |
| 667 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 1); |
| 668 | } |
| 669 | break; |
| 670 | case S3C44B0_TCNTO2 : |
| 671 | { |
| 672 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 2); |
| 673 | } |
| 674 | break; |
| 675 | case S3C44B0_TCNTO3 : |
| 676 | { |
| 677 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 3); |
| 678 | } |
| 679 | break; |
| 680 | case S3C44B0_TCNTO4 : |
| 681 | { |
| 682 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 4); |
| 683 | } |
| 684 | break; |
| 685 | case S3C44B0_TCNTO5 : |
| 686 | { |
| 687 | data = (data & ~0x0000FFFF) | s3c44b0_pwm_calc_observation( device, 5); |
| 688 | } |
| 689 | break; |
| 690 | } |
| 691 | verboselog( device->machine(), 9, "(PWM) %08X -> %08X\n", S3C44B0_BASE_PWM + (offset << 2), data); |
| 692 | return data; |
| 693 | } |
| 694 | |
| 695 | static void s3c44b0_pwm_start( device_t *device, int timer) |
| 696 | { |
| 697 | s3c44b0_t *s3c44b0 = get_token( device); |
| 698 | const int mux_table[] = { 2, 4, 8, 16}; |
| 699 | const int prescaler_shift[] = { 0, 0, 8, 8, 16, 16}; |
| 700 | const int mux_shift[] = { 0, 4, 8, 12, 16, 20}; |
| 701 | UINT32 mclk, prescaler, mux, cnt, cmp, auto_reload; |
| 702 | double freq, hz; |
| 703 | verboselog( device->machine(), 1, "PWM %d start\n", timer); |
| 704 | mclk = s3c44b0_get_mclk( device); |
| 705 | prescaler = (s3c44b0->pwm.regs.tcfg0 >> prescaler_shift[timer]) & 0xFF; |
| 706 | mux = (s3c44b0->pwm.regs.tcfg1 >> mux_shift[timer]) & 0x0F; |
| 707 | if (mux < 4) |
| 708 | { |
| 709 | freq = (double)mclk / (prescaler + 1) / mux_table[mux]; |
| 710 | } |
| 711 | else |
| 712 | { |
| 713 | // todo |
| 714 | freq = (double)mclk / (prescaler + 1) / 1; |
| 715 | } |
| 716 | switch (timer) |
| 717 | { |
| 718 | case 0 : |
| 719 | { |
| 720 | cnt = BITS( s3c44b0->pwm.regs.tcntb0, 15, 0); |
| 721 | cmp = BITS( s3c44b0->pwm.regs.tcmpb0, 15, 0); |
| 722 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 3); |
| 723 | } |
| 724 | break; |
| 725 | case 1 : |
| 726 | { |
| 727 | cnt = BITS( s3c44b0->pwm.regs.tcntb1, 15, 0); |
| 728 | cmp = BITS( s3c44b0->pwm.regs.tcmpb1, 15, 0); |
| 729 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 11); |
| 730 | } |
| 731 | break; |
| 732 | case 2 : |
| 733 | { |
| 734 | cnt = BITS( s3c44b0->pwm.regs.tcntb2, 15, 0); |
| 735 | cmp = BITS( s3c44b0->pwm.regs.tcmpb2, 15, 0); |
| 736 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 15); |
| 737 | } |
| 738 | break; |
| 739 | case 3 : |
| 740 | { |
| 741 | cnt = BITS( s3c44b0->pwm.regs.tcntb3, 15, 0); |
| 742 | cmp = BITS( s3c44b0->pwm.regs.tcmpb3, 15, 0); |
| 743 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 19); |
| 744 | } |
| 745 | break; |
| 746 | case 4 : |
| 747 | { |
| 748 | cnt = BITS( s3c44b0->pwm.regs.tcntb4, 15, 0); |
| 749 | cmp = BITS( s3c44b0->pwm.regs.tcmpb4, 15, 0); |
| 750 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 23); |
| 751 | } |
| 752 | break; |
| 753 | case 5 : |
| 754 | { |
| 755 | cnt = BITS( s3c44b0->pwm.regs.tcntb5, 15, 0); |
| 756 | cmp = 0; |
| 757 | auto_reload = BIT( s3c44b0->pwm.regs.tcon, 26); |
| 758 | } |
| 759 | break; |
| 760 | default : |
| 761 | { |
| 762 | cnt = cmp = auto_reload = 0; |
| 763 | } |
| 764 | break; |
| 765 | } |
| 766 | // hz = freq / (cnt - cmp + 1); |
| 767 | if (cnt < 2) |
| 768 | { |
| 769 | hz = freq; |
| 770 | } |
| 771 | else |
| 772 | { |
| 773 | hz = freq / cnt; |
| 774 | } |
| 775 | verboselog( device->machine(), 5, "PWM %d - mclk=%d prescaler=%d div=%d freq=%f cnt=%d cmp=%d auto_reload=%d hz=%f\n", timer, mclk, prescaler, mux_table[mux], freq, cnt, cmp, auto_reload, hz); |
| 776 | s3c44b0->pwm.cnt[timer] = cnt; |
| 777 | s3c44b0->pwm.cmp[timer] = cmp; |
| 778 | s3c44b0->pwm.freq[timer] = freq; |
| 779 | if (cnt == 0) |
| 780 | { |
| 781 | s3c44b0->pwm.timer[timer]->adjust( attotime::never, 0); |
| 782 | } |
| 783 | else |
| 784 | { |
| 785 | if (auto_reload) |
| 786 | { |
| 787 | s3c44b0->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer, attotime::from_hz( hz)); |
| 788 | } |
| 789 | else |
| 790 | { |
| 791 | s3c44b0->pwm.timer[timer]->adjust( attotime::from_hz( hz), timer); |
| 792 | } |
| 793 | } |
| 794 | } |
| 795 | |
| 796 | static void s3c44b0_pwm_stop( device_t *device, int timer) |
| 797 | { |
| 798 | s3c44b0_t *s3c44b0 = get_token( device); |
| 799 | verboselog( device->machine(), 1, "PWM %d stop\n", timer); |
| 800 | s3c44b0->pwm.timer[timer]->adjust( attotime::never, 0); |
| 801 | } |
| 802 | |
| 803 | static void s3c44b0_pwm_recalc( device_t *device, int timer) |
| 804 | { |
| 805 | s3c44b0_t *s3c44b0 = get_token( device); |
| 806 | const int tcon_shift[] = { 0, 8, 12, 16, 20, 24}; |
| 807 | if (s3c44b0->pwm.regs.tcon & (1 << tcon_shift[timer])) |
| 808 | { |
| 809 | s3c44b0_pwm_start( device, timer); |
| 810 | } |
| 811 | else |
| 812 | { |
| 813 | s3c44b0_pwm_stop( device, timer); |
| 814 | } |
| 815 | } |
| 816 | |
| 817 | static WRITE32_DEVICE_HANDLER( s3c44b0_pwm_w ) |
| 818 | { |
| 819 | s3c44b0_t *s3c44b0 = get_token( device); |
| 820 | UINT32 old_value = ((UINT32*)&s3c44b0->pwm.regs)[offset]; |
| 821 | verboselog( device->machine(), 9, "(PWM) %08X <- %08X\n", S3C44B0_BASE_PWM + (offset << 2), data); |
| 822 | COMBINE_DATA(&((UINT32*)&s3c44b0->pwm.regs)[offset]); |
| 823 | switch (offset) |
| 824 | { |
| 825 | case S3C44B0_TCON : |
| 826 | { |
| 827 | if ((data & (1 << 0)) != (old_value & (1 << 0))) |
| 828 | { |
| 829 | s3c44b0_pwm_recalc( device, 0); |
| 830 | } |
| 831 | if ((data & (1 << 8)) != (old_value & (1 << 8))) |
| 832 | { |
| 833 | s3c44b0_pwm_recalc( device, 1); |
| 834 | } |
| 835 | if ((data & (1 << 12)) != (old_value & (1 << 12))) |
| 836 | { |
| 837 | s3c44b0_pwm_recalc( device, 2); |
| 838 | } |
| 839 | if ((data & (1 << 16)) != (old_value & (1 << 16))) |
| 840 | { |
| 841 | s3c44b0_pwm_recalc( device, 3); |
| 842 | } |
| 843 | if ((data & (1 << 20)) != (old_value & (1 << 20))) |
| 844 | { |
| 845 | s3c44b0_pwm_recalc( device, 4); |
| 846 | } |
| 847 | if ((data & (1 << 24)) != (old_value & (1 << 24))) |
| 848 | { |
| 849 | s3c44b0_pwm_recalc( device, 5); |
| 850 | } |
| 851 | } |
| 852 | break; |
| 853 | } |
| 854 | } |
| 855 | |
| 856 | static TIMER_CALLBACK( s3c44b0_pwm_timer_exp ) |
| 857 | { |
| 858 | device_t *device = (device_t *)ptr; |
| 859 | s3c44b0_t *s3c44b0 = get_token( device); |
| 860 | int ch = param; |
| 861 | const int ch_int[] = { S3C44B0_INT_TIMER0, S3C44B0_INT_TIMER1, S3C44B0_INT_TIMER2, S3C44B0_INT_TIMER3, S3C44B0_INT_TIMER4, S3C44B0_INT_TIMER5 }; |
| 862 | verboselog( machine, 2, "PWM %d timer callback\n", ch); |
| 863 | if (BITS( s3c44b0->pwm.regs.tcfg1, 27, 24) == (ch + 1)) |
| 864 | { |
| 865 | fatalerror( "s3c44b0_dma_request_pwm( device);"); |
| 866 | } |
| 867 | else |
| 868 | { |
| 869 | s3c44b0_request_irq( device, ch_int[ch]); |
| 870 | } |
| 871 | } |
| 872 | |
| 873 | /* IIC */ |
| 874 | |
| 875 | INLINE void iface_i2c_scl_w( device_t *device, int state) |
| 876 | { |
| 877 | s3c44b0_t *s3c44b0 = get_token( device); |
| 878 | if (s3c44b0->iface->i2c.scl_w) |
| 879 | { |
| 880 | (s3c44b0->iface->i2c.scl_w)( device, state); |
| 881 | } |
| 882 | } |
| 883 | |
| 884 | INLINE void iface_i2c_sda_w( device_t *device, int state) |
| 885 | { |
| 886 | s3c44b0_t *s3c44b0 = get_token( device); |
| 887 | if (s3c44b0->iface->i2c.sda_w) |
| 888 | { |
| 889 | (s3c44b0->iface->i2c.sda_w)( device, state); |
| 890 | } |
| 891 | } |
| 892 | |
| 893 | INLINE int iface_i2c_sda_r( device_t *device) |
| 894 | { |
| 895 | s3c44b0_t *s3c44b0 = get_token( device); |
| 896 | if (s3c44b0->iface->i2c.sda_r) |
| 897 | { |
| 898 | return (s3c44b0->iface->i2c.sda_r)( device); |
| 899 | } |
| 900 | else |
| 901 | { |
| 902 | return 0; |
| 903 | } |
| 904 | } |
| 905 | |
| 906 | static void i2c_send_start( device_t *device) |
| 907 | { |
| 908 | verboselog( device->machine(), 5, "i2c_send_start\n"); |
| 909 | iface_i2c_sda_w( device, 1); |
| 910 | iface_i2c_scl_w( device, 1); |
| 911 | iface_i2c_sda_w( device, 0); |
| 912 | iface_i2c_scl_w( device, 0); |
| 913 | } |
| 914 | |
| 915 | static void i2c_send_stop( device_t *device) |
| 916 | { |
| 917 | verboselog( device->machine(), 5, "i2c_send_stop\n"); |
| 918 | iface_i2c_sda_w( device, 0); |
| 919 | iface_i2c_scl_w( device, 1); |
| 920 | iface_i2c_sda_w( device, 1); |
| 921 | iface_i2c_scl_w( device, 0); |
| 922 | } |
| 923 | |
| 924 | static UINT8 i2c_receive_byte( device_t *device, int ack) |
| 925 | { |
| 926 | UINT8 data = 0; |
| 927 | verboselog( device->machine(), 5, "i2c_receive_byte ...\n"); |
| 928 | iface_i2c_sda_w( device, 1); |
| 929 | for (int i = 0; i < 8; i++) |
| 930 | { |
| 931 | iface_i2c_scl_w( device, 1); |
| 932 | data = (data << 1) + (iface_i2c_sda_r( device) ? 1 : 0); |
| 933 | iface_i2c_scl_w( device, 0); |
| 934 | } |
| 935 | verboselog( device->machine(), 5, "recv data %02X\n", data); |
| 936 | verboselog( device->machine(), 5, "send ack %d\n", ack); |
| 937 | iface_i2c_sda_w( device, ack ? 0 : 1); |
| 938 | iface_i2c_scl_w( device, 1); |
| 939 | iface_i2c_scl_w( device, 0); |
| 940 | return data; |
| 941 | } |
| 942 | |
| 943 | static int i2c_send_byte( device_t *device, UINT8 data) |
| 944 | { |
| 945 | int ack; |
| 946 | verboselog( device->machine(), 5, "i2c_send_byte ...\n"); |
| 947 | verboselog( device->machine(), 5, "send data %02X\n", data); |
| 948 | for (int i = 0; i < 8; i++) |
| 949 | { |
| 950 | iface_i2c_sda_w( device, (data & 0x80) ? 1 : 0); |
| 951 | data = data << 1; |
| 952 | iface_i2c_scl_w( device, 1); |
| 953 | iface_i2c_scl_w( device, 0); |
| 954 | } |
| 955 | iface_i2c_sda_w( device, 1); // ack bit |
| 956 | iface_i2c_scl_w( device, 1); |
| 957 | ack = iface_i2c_sda_r( device); |
| 958 | verboselog( device->machine(), 5, "recv ack %d\n", ack); |
| 959 | iface_i2c_scl_w( device, 0); |
| 960 | return ack; |
| 961 | } |
| 962 | |
| 963 | static void iic_start( device_t *device) |
| 964 | { |
| 965 | s3c44b0_t *s3c44b0 = get_token( device); |
| 966 | int mode_selection; |
| 967 | verboselog( device->machine(), 1, "IIC start\n"); |
| 968 | i2c_send_start( device); |
| 969 | mode_selection = BITS( s3c44b0->iic.regs.iicstat, 7, 6); |
| 970 | switch (mode_selection) |
| 971 | { |
| 972 | case 2 : i2c_send_byte( device, s3c44b0->iic.regs.iicds | 0x01); break; |
| 973 | case 3 : i2c_send_byte( device, s3c44b0->iic.regs.iicds & 0xFE); break; |
| 974 | } |
| 975 | s3c44b0->iic.timer->adjust( attotime::from_usec( 1), 0); |
| 976 | } |
| 977 | |
| 978 | static void iic_stop( device_t *device) |
| 979 | { |
| 980 | s3c44b0_t *s3c44b0 = get_token( device); |
| 981 | verboselog( device->machine(), 1, "IIC stop\n"); |
| 982 | i2c_send_stop( device); |
| 983 | s3c44b0->iic.timer->adjust( attotime::never, 0); |
| 984 | } |
| 985 | |
| 986 | static void iic_resume( device_t *device) |
| 987 | { |
| 988 | s3c44b0_t *s3c44b0 = get_token( device); |
| 989 | int mode_selection; |
| 990 | verboselog( device->machine(), 1, "IIC resume\n"); |
| 991 | mode_selection = BITS( s3c44b0->iic.regs.iicstat, 7, 6); |
| 992 | switch (mode_selection) |
| 993 | { |
| 994 | case 2 : s3c44b0->iic.regs.iicds = i2c_receive_byte( device, BIT( s3c44b0->iic.regs.iiccon, 7)); break; |
| 995 | case 3 : i2c_send_byte( device, s3c44b0->iic.regs.iicds & 0xFF); break; |
| 996 | } |
| 997 | s3c44b0->iic.timer->adjust( attotime::from_usec( 1), 0); |
| 998 | } |
| 999 | |
| 1000 | static READ32_DEVICE_HANDLER( s3c44b0_iic_r ) |
| 1001 | { |
| 1002 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1003 | UINT32 data = ((UINT32*)&s3c44b0->iic.regs)[offset]; |
| 1004 | switch (offset) |
| 1005 | { |
| 1006 | case S3C44B0_IICSTAT : |
| 1007 | { |
| 1008 | data = data & ~0x0000000F; |
| 1009 | } |
| 1010 | break; |
| 1011 | } |
| 1012 | verboselog( device->machine(), 9, "(IIC) %08X -> %08X\n", S3C44B0_BASE_IIC + (offset << 2), data); |
| 1013 | return data; |
| 1014 | } |
| 1015 | |
| 1016 | static WRITE32_DEVICE_HANDLER( s3c44b0_iic_w ) |
| 1017 | { |
| 1018 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1019 | UINT32 old_value = ((UINT32*)&s3c44b0->iic.regs)[offset]; |
| 1020 | verboselog( device->machine(), 9, "(IIC) %08X <- %08X\n", S3C44B0_BASE_IIC + (offset << 2), data); |
| 1021 | COMBINE_DATA(&((UINT32*)&s3c44b0->iic.regs)[offset]); |
| 1022 | switch (offset) |
| 1023 | { |
| 1024 | case S3C44B0_IICCON : |
| 1025 | { |
| 1026 | int interrupt_pending_flag; |
| 1027 | #if 0 |
| 1028 | const int div_table[] = { 16, 512}; |
| 1029 | int enable_interrupt, transmit_clock_value, tx_clock_source_selection |
| 1030 | double clock; |
| 1031 | transmit_clock_value = (data >> 0) & 0xF; |
| 1032 | tx_clock_source_selection = (data >> 6) & 1; |
| 1033 | enable_interrupt = (data >> 5) & 1; |
| 1034 | clock = (double)s3c24xx_get_pclk( device) / div_table[tx_clock_source_selection] / (transmit_clock_value + 1); |
| 1035 | #endif |
| 1036 | interrupt_pending_flag = BIT( old_value, 4); |
| 1037 | if (interrupt_pending_flag != 0) |
| 1038 | { |
| 1039 | interrupt_pending_flag = BIT( data, 4); |
| 1040 | if (interrupt_pending_flag == 0) |
| 1041 | { |
| 1042 | int start_stop_condition; |
| 1043 | start_stop_condition = BIT( s3c44b0->iic.regs.iicstat, 5); |
| 1044 | if (start_stop_condition != 0) |
| 1045 | { |
| 1046 | if (s3c44b0->iic.count == 0) |
| 1047 | { |
| 1048 | iic_start( device); |
| 1049 | |
| 1050 | } |
| 1051 | else |
| 1052 | { |
| 1053 | iic_resume( device); |
| 1054 | } |
| 1055 | } |
| 1056 | else |
| 1057 | { |
| 1058 | iic_stop( device); |
| 1059 | } |
| 1060 | } |
| 1061 | } |
| 1062 | } |
| 1063 | break; |
| 1064 | case S3C44B0_IICSTAT : |
| 1065 | { |
| 1066 | int interrupt_pending_flag; |
| 1067 | s3c44b0->iic.count = 0; |
| 1068 | interrupt_pending_flag = BIT( s3c44b0->iic.regs.iiccon, 4); |
| 1069 | if (interrupt_pending_flag == 0) |
| 1070 | { |
| 1071 | int start_stop_condition; |
| 1072 | start_stop_condition = BIT( data, 5); |
| 1073 | if (start_stop_condition != 0) |
| 1074 | { |
| 1075 | if (s3c44b0->iic.count == 0) |
| 1076 | { |
| 1077 | iic_start( device); |
| 1078 | |
| 1079 | } |
| 1080 | else |
| 1081 | { |
| 1082 | iic_resume( device); |
| 1083 | } |
| 1084 | } |
| 1085 | else |
| 1086 | { |
| 1087 | iic_stop( device); |
| 1088 | } |
| 1089 | } |
| 1090 | } |
| 1091 | break; |
| 1092 | } |
| 1093 | } |
| 1094 | |
| 1095 | static TIMER_CALLBACK( s3c44b0_iic_timer_exp ) |
| 1096 | { |
| 1097 | device_t *device = (device_t *)ptr; |
| 1098 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1099 | int enable_interrupt; |
| 1100 | verboselog( machine, 2, "IIC timer callback\n"); |
| 1101 | s3c44b0->iic.count++; |
| 1102 | enable_interrupt = BIT( s3c44b0->iic.regs.iiccon, 5); |
| 1103 | |
| 1104 | s3c44b0->iic.regs.iicds = 0xFF; // TEST |
| 1105 | |
| 1106 | if (enable_interrupt) |
| 1107 | { |
| 1108 | s3c44b0->iic.regs.iiccon |= (1 << 4); // [bit 4] interrupt is pending |
| 1109 | s3c44b0_request_irq( device, S3C44B0_INT_IIC); |
| 1110 | } |
| 1111 | } |
| 1112 | |
| 1113 | /* I/O Port */ |
| 1114 | |
| 1115 | INLINE UINT32 iface_gpio_port_r( device_t *device, int port) |
| 1116 | { |
| 1117 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1118 | if (s3c44b0->iface->gpio.port_r) |
| 1119 | { |
| 1120 | return (s3c44b0->iface->gpio.port_r)( device, port); |
| 1121 | } |
| 1122 | else |
| 1123 | { |
| 1124 | return 0; |
| 1125 | } |
| 1126 | } |
| 1127 | |
| 1128 | INLINE void iface_gpio_port_w( device_t *device, int port, UINT32 data) |
| 1129 | { |
| 1130 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1131 | if (s3c44b0->iface->gpio.port_w) |
| 1132 | { |
| 1133 | (s3c44b0->iface->gpio.port_w)( device, port, data); |
| 1134 | } |
| 1135 | } |
| 1136 | |
| 1137 | static READ32_DEVICE_HANDLER( s3c44b0_gpio_r ) |
| 1138 | { |
| 1139 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1140 | UINT32 data = ((UINT32*)&s3c44b0->gpio.regs)[offset]; |
| 1141 | switch (offset) |
| 1142 | { |
| 1143 | case S3C44B0_GPADAT : |
| 1144 | { |
| 1145 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_A) & S3C44B0_GPADAT_MASK; |
| 1146 | } |
| 1147 | break; |
| 1148 | case S3C44B0_GPBDAT : |
| 1149 | { |
| 1150 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_B) & S3C44B0_GPBDAT_MASK; |
| 1151 | } |
| 1152 | break; |
| 1153 | case S3C44B0_GPCDAT : |
| 1154 | { |
| 1155 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_C) & S3C44B0_GPCDAT_MASK; |
| 1156 | } |
| 1157 | break; |
| 1158 | case S3C44B0_GPDDAT : |
| 1159 | { |
| 1160 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_D) & S3C44B0_GPDDAT_MASK; |
| 1161 | } |
| 1162 | break; |
| 1163 | case S3C44B0_GPEDAT : |
| 1164 | { |
| 1165 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_E) & S3C44B0_GPEDAT_MASK; |
| 1166 | } |
| 1167 | break; |
| 1168 | case S3C44B0_GPFDAT : |
| 1169 | { |
| 1170 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_F) & S3C44B0_GPFDAT_MASK; |
| 1171 | } |
| 1172 | break; |
| 1173 | case S3C44B0_GPGDAT : |
| 1174 | { |
| 1175 | data = iface_gpio_port_r( device, S3C44B0_GPIO_PORT_G) & S3C44B0_GPGDAT_MASK; |
| 1176 | } |
| 1177 | break; |
| 1178 | } |
| 1179 | verboselog( device->machine(), 9, "(GPIO) %08X -> %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data); |
| 1180 | return data; |
| 1181 | } |
| 1182 | |
| 1183 | static WRITE32_DEVICE_HANDLER( s3c44b0_gpio_w ) |
| 1184 | { |
| 1185 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1186 | UINT32 old_value = ((UINT32*)&s3c44b0->gpio.regs)[offset]; |
| 1187 | verboselog( device->machine(), 9, "(GPIO) %08X <- %08X\n", S3C44B0_BASE_GPIO + (offset << 2), data); |
| 1188 | COMBINE_DATA(&((UINT32*)&s3c44b0->gpio.regs)[offset]); |
| 1189 | switch (offset) |
| 1190 | { |
| 1191 | case S3C44B0_GPADAT : |
| 1192 | { |
| 1193 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_A, data & S3C44B0_GPADAT_MASK); |
| 1194 | } |
| 1195 | break; |
| 1196 | case S3C44B0_GPBDAT : |
| 1197 | { |
| 1198 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_B, data & S3C44B0_GPBDAT_MASK); |
| 1199 | } |
| 1200 | break; |
| 1201 | case S3C44B0_GPCDAT : |
| 1202 | { |
| 1203 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_C, data & S3C44B0_GPCDAT_MASK); |
| 1204 | } |
| 1205 | break; |
| 1206 | case S3C44B0_GPDDAT : |
| 1207 | { |
| 1208 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_D, data & S3C44B0_GPDDAT_MASK); |
| 1209 | } |
| 1210 | break; |
| 1211 | case S3C44B0_GPEDAT : |
| 1212 | { |
| 1213 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_E, data & S3C44B0_GPEDAT_MASK); |
| 1214 | } |
| 1215 | break; |
| 1216 | case S3C44B0_GPFDAT : |
| 1217 | { |
| 1218 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_F, data & S3C44B0_GPFDAT_MASK); |
| 1219 | } |
| 1220 | break; |
| 1221 | case S3C44B0_GPGDAT : |
| 1222 | { |
| 1223 | iface_gpio_port_w( device, S3C44B0_GPIO_PORT_G, data & S3C44B0_GPGDAT_MASK); |
| 1224 | } |
| 1225 | break; |
| 1226 | case S3C44B0_EXTINTPND : |
| 1227 | { |
| 1228 | s3c44b0->gpio.regs.extintpnd = (old_value & ~data); |
| 1229 | s3c44b0_check_pending_eint( device); |
| 1230 | } |
| 1231 | break; |
| 1232 | } |
| 1233 | } |
| 1234 | |
| 1235 | /* UART */ |
| 1236 | |
| 1237 | static UINT32 s3c44b0_uart_r( device_t *device, int ch, UINT32 offset) |
| 1238 | { |
| 1239 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1240 | UINT32 data = ((UINT32*)&s3c44b0->uart[ch].regs)[offset]; |
| 1241 | switch (offset) |
| 1242 | { |
| 1243 | case S3C44B0_UTRSTAT : |
| 1244 | { |
| 1245 | data = (data & ~0x00000006) | 0x00000004 | 0x00000002; // [bit 2] Transmitter empty / [bit 1] Transmit buffer empty |
| 1246 | } |
| 1247 | break; |
| 1248 | case S3C44B0_URXH : |
| 1249 | { |
| 1250 | UINT8 rxdata = data & 0xFF; |
| 1251 | verboselog( device->machine(), 5, "UART %d read %02X (%c)\n", ch, rxdata, ((rxdata >= 32) && (rxdata < 128)) ? (char)rxdata : '?'); |
| 1252 | s3c44b0->uart[ch].regs.utrstat &= ~1; // [bit 0] Receive buffer data ready |
| 1253 | } |
| 1254 | break; |
| 1255 | } |
| 1256 | return data; |
| 1257 | } |
| 1258 | |
| 1259 | static void s3c44b0_uart_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask) |
| 1260 | { |
| 1261 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1262 | COMBINE_DATA(&((UINT32*)&s3c44b0->uart[ch].regs)[offset]); |
| 1263 | s3c44b0_uart_t *uart = &s3c44b0->uart[ch]; |
| 1264 | switch (offset) |
| 1265 | { |
| 1266 | case S3C44B0_UTXH : |
| 1267 | { |
| 1268 | UINT8 txdata = data & 0xFF; |
| 1269 | verboselog( device->machine(), 5, "UART %d write %02X (%c)\n", ch, txdata, ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?'); |
| 1270 | #ifdef UART_PRINTF |
| 1271 | printf( "%c", ((txdata >= 32) && (txdata < 128)) ? (char)txdata : '?'); |
| 1272 | #endif |
| 1273 | } |
| 1274 | break; |
| 1275 | case S3C44B0_UBRDIV : |
| 1276 | { |
| 1277 | UINT32 mclk, hz; |
| 1278 | mclk = s3c44b0_get_mclk( device); |
| 1279 | hz = (mclk / (uart->regs.ubrdiv + 1)) / 16; |
| 1280 | verboselog( device->machine(), 5, "UART %d - mclk %08X hz %08X\n", ch, mclk, hz); |
| 1281 | uart->timer->adjust( attotime::from_hz( hz), ch, attotime::from_hz( hz)); |
| 1282 | } |
| 1283 | break; |
| 1284 | } |
| 1285 | } |
| 1286 | |
| 1287 | static READ32_DEVICE_HANDLER( s3c44b0_uart_0_r ) |
| 1288 | { |
| 1289 | UINT32 data = s3c44b0_uart_r( device, 0, offset); |
| 1290 | // verboselog( device->machine(), 9, "(UART 0) %08X -> %08X\n", S3C44B0_BASE_UART_0 + (offset << 2), data); |
| 1291 | return data; |
| 1292 | } |
| 1293 | |
| 1294 | static READ32_DEVICE_HANDLER( s3c44b0_uart_1_r ) |
| 1295 | { |
| 1296 | UINT32 data = s3c44b0_uart_r( device, 1, offset); |
| 1297 | // verboselog( device->machine(), 9, "(UART 1) %08X -> %08X\n", S3C44B0_BASE_UART_1 + (offset << 2), data); |
| 1298 | return data; |
| 1299 | } |
| 1300 | |
| 1301 | static WRITE32_DEVICE_HANDLER( s3c44b0_uart_0_w ) |
| 1302 | { |
| 1303 | verboselog( device->machine(), 9, "(UART 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_0 + (offset << 2), data, mem_mask); |
| 1304 | s3c44b0_uart_w( device, 0, offset, data, mem_mask); |
| 1305 | } |
| 1306 | |
| 1307 | static WRITE32_DEVICE_HANDLER( s3c44b0_uart_1_w ) |
| 1308 | { |
| 1309 | verboselog( device->machine(), 9, "(UART 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_UART_1 + (offset << 2), data, mem_mask); |
| 1310 | s3c44b0_uart_w( device, 1, offset, data, mem_mask); |
| 1311 | } |
| 1312 | |
| 1313 | void s3c44b0_uart_fifo_w( device_t *device, int uart, UINT8 data) |
| 1314 | { |
| 1315 | // printf( "s3c44b0_uart_fifo_w (%c)\n", data); |
| 1316 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1317 | s3c44b0->uart[uart].regs.urxh = data; |
| 1318 | s3c44b0->uart[uart].regs.utrstat |= 1; // [bit 0] Receive buffer data ready |
| 1319 | } |
| 1320 | |
| 1321 | static TIMER_CALLBACK( s3c44b0_uart_timer_exp ) |
| 1322 | { |
| 1323 | device_t *device = (device_t *)ptr; |
| 1324 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1325 | int ch = param; |
| 1326 | s3c44b0_uart_t *uart = &s3c44b0->uart[ch]; |
| 1327 | verboselog( machine, 2, "UART %d timer callback\n", ch); |
| 1328 | if ((uart->regs.ucon & (1 << 9)) != 0) |
| 1329 | { |
| 1330 | const int ch_int[] = { S3C44B0_INT_UTXD0, S3C44B0_INT_UTXD1 }; |
| 1331 | s3c44b0_request_irq( device, ch_int[ch]); |
| 1332 | } |
| 1333 | } |
| 1334 | |
| 1335 | /* Watchdog Timer */ |
| 1336 | |
| 1337 | static UINT16 s3c44b0_wdt_calc_current_count( device_t *device) |
| 1338 | { |
| 1339 | return 0; |
| 1340 | } |
| 1341 | |
| 1342 | static READ32_DEVICE_HANDLER( s3c44b0_wdt_r ) |
| 1343 | { |
| 1344 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1345 | UINT32 data = ((UINT32*)&s3c44b0->wdt.regs)[offset]; |
| 1346 | switch (offset) |
| 1347 | { |
| 1348 | case S3C44B0_WTCNT : |
| 1349 | { |
| 1350 | // is wdt active? |
| 1351 | if ((s3c44b0->wdt.regs.wtcon & (1 << 5)) != 0) |
| 1352 | { |
| 1353 | data = s3c44b0_wdt_calc_current_count( device); |
| 1354 | } |
| 1355 | } |
| 1356 | break; |
| 1357 | } |
| 1358 | verboselog( device->machine(), 9, "(WDT) %08X -> %08X\n", S3C44B0_BASE_WDT + (offset << 2), data); |
| 1359 | return data; |
| 1360 | } |
| 1361 | |
| 1362 | static void s3c44b0_wdt_start( device_t *device) |
| 1363 | { |
| 1364 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1365 | UINT32 mclk, prescaler, clock; |
| 1366 | double freq, hz; |
| 1367 | verboselog( device->machine(), 1, "WDT start\n"); |
| 1368 | mclk = s3c44b0_get_mclk( device); |
| 1369 | prescaler = BITS( s3c44b0->wdt.regs.wtcon, 15, 8); |
| 1370 | clock = 16 << BITS( s3c44b0->wdt.regs.wtcon, 4, 3); |
| 1371 | freq = (double)mclk / (prescaler + 1) / clock; |
| 1372 | hz = freq / s3c44b0->wdt.regs.wtcnt; |
| 1373 | verboselog( device->machine(), 5, "WDT mclk %d prescaler %d clock %d freq %f hz %f\n", mclk, prescaler, clock, freq, hz); |
| 1374 | s3c44b0->wdt.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz)); |
| 1375 | } |
| 1376 | |
| 1377 | static void s3c44b0_wdt_stop( device_t *device) |
| 1378 | { |
| 1379 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1380 | verboselog( device->machine(), 1, "WDT stop\n"); |
| 1381 | s3c44b0->wdt.regs.wtcnt = s3c44b0_wdt_calc_current_count( device); |
| 1382 | s3c44b0->wdt.timer->adjust( attotime::never, 0); |
| 1383 | } |
| 1384 | |
| 1385 | static void s3c44b0_wdt_recalc( device_t *device) |
| 1386 | { |
| 1387 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1388 | if ((s3c44b0->wdt.regs.wtcon & (1 << 5)) != 0) |
| 1389 | { |
| 1390 | s3c44b0_wdt_start( device); |
| 1391 | } |
| 1392 | else |
| 1393 | { |
| 1394 | s3c44b0_wdt_stop( device); |
| 1395 | } |
| 1396 | } |
| 1397 | |
| 1398 | static WRITE32_DEVICE_HANDLER( s3c44b0_wdt_w ) |
| 1399 | { |
| 1400 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1401 | UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset]; |
| 1402 | verboselog( device->machine(), 9, "(WDT) %08X <- %08X\n", S3C44B0_BASE_WDT + (offset << 2), data); |
| 1403 | COMBINE_DATA(&((UINT32*)&s3c44b0->wdt.regs)[offset]); |
| 1404 | switch (offset) |
| 1405 | { |
| 1406 | case S3C44B0_WTCON : |
| 1407 | { |
| 1408 | if ((data & (1 << 5)) != (old_value & (1 << 5))) |
| 1409 | { |
| 1410 | s3c44b0_wdt_recalc( device); |
| 1411 | } |
| 1412 | } |
| 1413 | break; |
| 1414 | } |
| 1415 | } |
| 1416 | |
| 1417 | static TIMER_CALLBACK( s3c44b0_wdt_timer_exp ) |
| 1418 | { |
| 1419 | device_t *device = (device_t *)ptr; |
| 1420 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1421 | verboselog( machine, 2, "WDT timer callback\n"); |
| 1422 | if ((s3c44b0->wdt.regs.wtcon & (1 << 2)) != 0) |
| 1423 | { |
| 1424 | s3c44b0_request_irq( device, S3C44B0_INT_WDT); |
| 1425 | } |
| 1426 | if ((s3c44b0->wdt.regs.wtcon & (1 << 0)) != 0) |
| 1427 | { |
| 1428 | s3c44b0_reset( device); |
| 1429 | } |
| 1430 | } |
| 1431 | |
| 1432 | /* CPU Wrapper */ |
| 1433 | |
| 1434 | static READ32_DEVICE_HANDLER( s3c44b0_cpuwrap_r ) |
| 1435 | { |
| 1436 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1437 | UINT32 data = ((UINT32*)&s3c44b0->cpuwrap.regs)[offset]; |
| 1438 | verboselog( device->machine(), 9, "(CPUWRAP) %08X -> %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data); |
| 1439 | return data; |
| 1440 | } |
| 1441 | |
| 1442 | static WRITE32_DEVICE_HANDLER( s3c44b0_cpuwrap_w ) |
| 1443 | { |
| 1444 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1445 | verboselog( device->machine(), 9, "(CPUWRAP) %08X <- %08X\n", S3C44B0_BASE_CPU_WRAPPER + (offset << 2), data); |
| 1446 | COMBINE_DATA(&((UINT32*)&s3c44b0->cpuwrap.regs)[offset]); |
| 1447 | } |
| 1448 | |
| 1449 | /* A/D Converter */ |
| 1450 | |
| 1451 | static READ32_DEVICE_HANDLER( s3c44b0_adc_r ) |
| 1452 | { |
| 1453 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1454 | UINT32 data = ((UINT32*)&s3c44b0->adc.regs)[offset]; |
| 1455 | verboselog( device->machine(), 9, "(ADC) %08X -> %08X\n", S3C44B0_BASE_ADC + (offset << 2), data); |
| 1456 | return data; |
| 1457 | } |
| 1458 | |
| 1459 | static void s3c44b0_adc_start( device_t *device) |
| 1460 | { |
| 1461 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1462 | UINT32 mclk, prescaler; |
| 1463 | double freq, hz; |
| 1464 | verboselog( device->machine(), 1, "ADC start\n"); |
| 1465 | mclk = s3c44b0_get_mclk( device); |
| 1466 | prescaler = BITS( s3c44b0->adc.regs.adcpsr, 7, 0); |
| 1467 | freq = (double)mclk / (2 * (prescaler + 1)) / 16; |
| 1468 | hz = freq / 1; //s3c44b0->wdt.regs.wtcnt; |
| 1469 | verboselog( device->machine(), 5, "ADC mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz); |
| 1470 | s3c44b0->adc.timer->adjust( attotime::from_hz( hz), 0); |
| 1471 | } |
| 1472 | |
| 1473 | static void s3c44b0_adc_stop( device_t *device) |
| 1474 | { |
| 1475 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1476 | verboselog( device->machine(), 1, "ADC stop\n"); |
| 1477 | s3c44b0->adc.timer->adjust( attotime::never, 0); |
| 1478 | } |
| 1479 | |
| 1480 | static void s3c44b0_adc_recalc( device_t *device) |
| 1481 | { |
| 1482 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1483 | if ((s3c44b0->adc.regs.adccon & (1 << 0)) != 0) |
| 1484 | { |
| 1485 | s3c44b0_adc_start( device); |
| 1486 | } |
| 1487 | else |
| 1488 | { |
| 1489 | s3c44b0_adc_stop( device); |
| 1490 | } |
| 1491 | } |
| 1492 | |
| 1493 | static WRITE32_DEVICE_HANDLER( s3c44b0_adc_w ) |
| 1494 | { |
| 1495 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1496 | UINT32 old_value = ((UINT32*)&s3c44b0->wdt.regs)[offset]; |
| 1497 | verboselog( device->machine(), 9, "(ADC) %08X <- %08X\n", S3C44B0_BASE_ADC + (offset << 2), data); |
| 1498 | COMBINE_DATA(&((UINT32*)&s3c44b0->adc.regs)[offset]); |
| 1499 | switch (offset) |
| 1500 | { |
| 1501 | case S3C44B0_ADCCON : |
| 1502 | { |
| 1503 | if ((data & (1 << 0)) != (old_value & (1 << 0))) |
| 1504 | { |
| 1505 | s3c44b0_adc_recalc( device); |
| 1506 | } |
| 1507 | s3c44b0->adc.regs.adccon &= ~(1 << 0); // "this bit is cleared after the start-up" |
| 1508 | } |
| 1509 | break; |
| 1510 | } |
| 1511 | } |
| 1512 | |
| 1513 | static TIMER_CALLBACK( s3c44b0_adc_timer_exp ) |
| 1514 | { |
| 1515 | device_t *device = (device_t *)ptr; |
| 1516 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1517 | verboselog( machine, 2, "ADC timer callback\n"); |
| 1518 | s3c44b0->adc.regs.adccon |= (1 << 6); |
| 1519 | s3c44b0_request_irq( device, S3C44B0_INT_ADC); |
| 1520 | } |
| 1521 | |
| 1522 | /* SIO */ |
| 1523 | |
| 1524 | static READ32_DEVICE_HANDLER( s3c44b0_sio_r ) |
| 1525 | { |
| 1526 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1527 | UINT32 data = ((UINT32*)&s3c44b0->sio.regs)[offset]; |
| 1528 | verboselog( device->machine(), 9, "(SIO) %08X -> %08X\n", S3C44B0_BASE_SIO + (offset << 2), data); |
| 1529 | return data; |
| 1530 | } |
| 1531 | |
| 1532 | static void s3c44b0_sio_start( device_t *device) |
| 1533 | { |
| 1534 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1535 | UINT32 mclk, prescaler; |
| 1536 | double freq, hz; |
| 1537 | verboselog( device->machine(), 1, "SIO start\n"); |
| 1538 | mclk = s3c44b0_get_mclk( device); |
| 1539 | prescaler = BITS( s3c44b0->sio.regs.sbrdr, 11, 0); |
| 1540 | freq = (double)mclk / 2 / (prescaler + 1); |
| 1541 | hz = freq / 1; //s3c44b0->wdt.regs.wtcnt; |
| 1542 | verboselog( device->machine(), 5, "SIO mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz); |
| 1543 | s3c44b0->sio.timer->adjust( attotime::from_hz( hz), 0); |
| 1544 | // printf( "SIO transmit %02X (%c)\n", s3c44b0->sio.regs.siodat, ((s3c44b0->sio.regs.siodat >= 32) && (s3c44b0->sio.regs.siodat < 128)) ? (char)s3c44b0->sio.regs.siodat : '?'); |
| 1545 | } |
| 1546 | |
| 1547 | static void s3c44b0_sio_stop( device_t *device) |
| 1548 | { |
| 1549 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1550 | verboselog( device->machine(), 1, "SIO stop\n"); |
| 1551 | // s3c44b0->wdt.regs.wtcnt = s3c44b0_wdt_calc_current_count( device); |
| 1552 | s3c44b0->sio.timer->adjust( attotime::never, 0); |
| 1553 | } |
| 1554 | |
| 1555 | static void s3c44b0_sio_recalc( device_t *device) |
| 1556 | { |
| 1557 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1558 | if ((s3c44b0->sio.regs.siocon & (1 << 3)) != 0) |
| 1559 | { |
| 1560 | s3c44b0_sio_start( device); |
| 1561 | } |
| 1562 | else |
| 1563 | { |
| 1564 | s3c44b0_sio_stop( device); |
| 1565 | } |
| 1566 | } |
| 1567 | |
| 1568 | static WRITE32_DEVICE_HANDLER( s3c44b0_sio_w ) |
| 1569 | { |
| 1570 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1571 | UINT32 old_value = ((UINT32*)&s3c44b0->sio.regs)[offset]; |
| 1572 | verboselog( device->machine(), 9, "(SIO) %08X <- %08X\n", S3C44B0_BASE_SIO + (offset << 2), data); |
| 1573 | COMBINE_DATA(&((UINT32*)&s3c44b0->sio.regs)[offset]); |
| 1574 | switch (offset) |
| 1575 | { |
| 1576 | case S3C44B0_SIOCON : |
| 1577 | { |
| 1578 | if ((old_value & (1 << 3)) != (data & (1 << 3))) |
| 1579 | { |
| 1580 | s3c44b0_sio_recalc( device); |
| 1581 | } |
| 1582 | s3c44b0->sio.regs.siocon &= ~(1 << 3); // "This bit is cleared just after writing this bit as 1." |
| 1583 | } |
| 1584 | break; |
| 1585 | } |
| 1586 | } |
| 1587 | |
| 1588 | static TIMER_CALLBACK( s3c44b0_sio_timer_exp ) |
| 1589 | { |
| 1590 | device_t *device = (device_t *)ptr; |
| 1591 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1592 | verboselog( machine, 2, "SIO timer callback\n"); |
| 1593 | |
| 1594 | s3c44b0->sio.regs.siodat = 0x00; // TEST |
| 1595 | |
| 1596 | if ((s3c44b0->sio.regs.siocon & (1 << 0)) != 0) |
| 1597 | { |
| 1598 | s3c44b0_request_irq( device, S3C44B0_INT_SIO); |
| 1599 | } |
| 1600 | } |
| 1601 | |
| 1602 | /* IIS */ |
| 1603 | |
| 1604 | INLINE void iface_i2s_data_w( device_t *device, int ch, UINT16 data) |
| 1605 | { |
| 1606 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1607 | if (s3c44b0->iface->i2s.data_w) |
| 1608 | { |
| 1609 | (s3c44b0->iface->i2s.data_w)( device, ch, data, 0); |
| 1610 | } |
| 1611 | } |
| 1612 | |
| 1613 | static void s3c44b0_iis_start( device_t *device) |
| 1614 | { |
| 1615 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1616 | UINT32 mclk; |
| 1617 | int prescaler; |
| 1618 | double freq, hz; |
| 1619 | const int div[] = { 2, 4, 6, 8, 10, 12, 14, 16, 1, 0, 3, 0, 5, 0, 7, 0 }; |
| 1620 | verboselog( device->machine(), 1, "IIS start\n"); |
| 1621 | mclk = s3c44b0_get_mclk( device); |
| 1622 | prescaler = BITS( s3c44b0->iis.regs.iispsr, 3, 0); |
| 1623 | freq = (double)mclk / div[prescaler]; |
| 1624 | hz = freq / 256 * 2; |
| 1625 | verboselog( device->machine(), 5, "IIS mclk %d prescaler %d freq %f hz %f\n", mclk, prescaler, freq, hz); |
| 1626 | s3c44b0->iis.timer->adjust( attotime::from_hz( hz), 0, attotime::from_hz( hz)); |
| 1627 | } |
| 1628 | |
| 1629 | static void s3c44b0_iis_stop( device_t *device) |
| 1630 | { |
| 1631 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1632 | verboselog( device->machine(), 1, "IIS stop\n"); |
| 1633 | s3c44b0->iis.timer->adjust( attotime::never, 0); |
| 1634 | } |
| 1635 | |
| 1636 | static READ32_DEVICE_HANDLER( s3c44b0_iis_r ) |
| 1637 | { |
| 1638 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1639 | UINT32 data = ((UINT32*)&s3c44b0->iis.regs)[offset]; |
| 1640 | verboselog( device->machine(), 9, "(IIS) %08X -> %08X\n", S3C44B0_BASE_IIS + (offset << 2), data); |
| 1641 | return data; |
| 1642 | } |
| 1643 | |
| 1644 | static WRITE32_DEVICE_HANDLER( s3c44b0_iis_w ) |
| 1645 | { |
| 1646 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1647 | UINT32 old_value = ((UINT32*)&s3c44b0->iis.regs)[offset]; |
| 1648 | verboselog( device->machine(), 9, "(IIS) %08X <- %08X\n", S3C44B0_BASE_IIS + (offset << 2), data); |
| 1649 | COMBINE_DATA(&((UINT32*)&s3c44b0->iis.regs)[offset]); |
| 1650 | switch (offset) |
| 1651 | { |
| 1652 | case S3C44B0_IISCON : |
| 1653 | { |
| 1654 | if ((old_value & (1 << 0)) != (data & (1 << 0))) |
| 1655 | { |
| 1656 | if ((data & (1 << 0)) != 0) |
| 1657 | { |
| 1658 | s3c44b0_iis_start( device); |
| 1659 | } |
| 1660 | else |
| 1661 | { |
| 1662 | s3c44b0_iis_stop( device); |
| 1663 | } |
| 1664 | } |
| 1665 | } |
| 1666 | break; |
| 1667 | case S3C44B0_IISFIFO : |
| 1668 | { |
| 1669 | if (ACCESSING_BITS_16_31) |
| 1670 | { |
| 1671 | s3c44b0->iis.fifo[s3c44b0->iis.fifo_index++] = BITS( data, 31, 16); |
| 1672 | } |
| 1673 | if (ACCESSING_BITS_0_15) |
| 1674 | { |
| 1675 | s3c44b0->iis.fifo[s3c44b0->iis.fifo_index++] = BITS( data, 15, 0); |
| 1676 | } |
| 1677 | if (s3c44b0->iis.fifo_index == 2) |
| 1678 | { |
| 1679 | s3c44b0->iis.fifo_index = 0; |
| 1680 | iface_i2s_data_w( device, 0, s3c44b0->iis.fifo[0]); |
| 1681 | iface_i2s_data_w( device, 1, s3c44b0->iis.fifo[1]); |
| 1682 | } |
| 1683 | } |
| 1684 | break; |
| 1685 | } |
| 1686 | } |
| 1687 | |
| 1688 | static TIMER_CALLBACK( s3c44b0_iis_timer_exp ) |
| 1689 | { |
| 1690 | device_t *device = (device_t *)ptr; |
| 1691 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1692 | s3c44b0_iis_t *iis = &s3c44b0->iis; |
| 1693 | verboselog( machine, 2, "IIS timer callback\n"); |
| 1694 | if ((iis->regs.iiscon & (1 << 5)) != 0) |
| 1695 | { |
| 1696 | s3c44b0_bdma_request_iis( device); |
| 1697 | } |
| 1698 | } |
| 1699 | |
| 1700 | /* ZDMA */ |
| 1701 | |
| 1702 | static void s3c44b0_zdma_trigger( device_t *device, int ch) |
| 1703 | { |
| 1704 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1705 | s3c44b0_dma_t *dma = &s3c44b0->zdma[ch]; |
| 1706 | UINT32 saddr, daddr; |
| 1707 | int dal, dst, opt, das, cnt; |
| 1708 | verboselog( device->machine(), 5, "s3c44b0_zdma_trigger %d\n", ch); |
| 1709 | dst = BITS( dma->regs.dcsrc, 31, 30); |
| 1710 | dal = BITS( dma->regs.dcsrc, 29, 28); |
| 1711 | saddr = BITS( dma->regs.dcsrc, 27, 0); |
| 1712 | verboselog( device->machine(), 5, "dst %d dal %d saddr %08X\n", dst, dal, saddr); |
| 1713 | opt = BITS( dma->regs.dcdst, 31, 30); |
| 1714 | das = BITS( dma->regs.dcdst, 29, 28); |
| 1715 | daddr = BITS( dma->regs.dcdst, 27, 0); |
| 1716 | verboselog( device->machine(), 5, "opt %d das %d daddr %08X\n", opt, das, daddr); |
| 1717 | cnt = BITS( dma->regs.dccnt, 19, 0); |
| 1718 | verboselog( device->machine(), 5, "icnt %08X\n", cnt); |
| 1719 | while (cnt > 0) |
| 1720 | { |
| 1721 | verboselog( device->machine(), 9, "[%08X] -> [%08X]\n", saddr, daddr); |
| 1722 | switch (dst) |
| 1723 | { |
| 1724 | case 0 : s3c44b0->space->write_byte( daddr, s3c44b0->space->read_byte( saddr)); break; |
| 1725 | case 1 : s3c44b0->space->write_word( daddr, s3c44b0->space->read_word( saddr)); break; |
| 1726 | case 2 : s3c44b0->space->write_dword( daddr, s3c44b0->space->read_dword( saddr)); break; |
| 1727 | } |
| 1728 | switch (dal) |
| 1729 | { |
| 1730 | case 1 : saddr += (1 << dst); break; |
| 1731 | case 2 : saddr -= (1 << dst); break; |
| 1732 | } |
| 1733 | switch (das) |
| 1734 | { |
| 1735 | case 1 : daddr += (1 << dst); break; |
| 1736 | case 2 : daddr -= (1 << dst); break; |
| 1737 | } |
| 1738 | cnt -= (1 << dst); |
| 1739 | } |
| 1740 | dma->regs.dcsrc = CLR_BITS( dma->regs.dcsrc, 27, 0) | saddr; |
| 1741 | dma->regs.dcdst = CLR_BITS( dma->regs.dcdst, 27, 0) | daddr; |
| 1742 | dma->regs.dccnt = CLR_BITS( dma->regs.dcdst, 19, 0) | cnt; |
| 1743 | if (cnt == 0) |
| 1744 | { |
| 1745 | if ((dma->regs.dccnt & (1 << 23)) != 0) |
| 1746 | { |
| 1747 | const int ch_int[] = { S3C44B0_INT_ZDMA0, S3C44B0_INT_ZDMA1 }; |
| 1748 | s3c44b0_request_irq( device, ch_int[ch]); |
| 1749 | } |
| 1750 | } |
| 1751 | } |
| 1752 | |
| 1753 | static void s3c44b0_zdma_start( device_t *device, int ch) |
| 1754 | { |
| 1755 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1756 | s3c44b0_dma_t *dma = &s3c44b0->zdma[ch]; |
| 1757 | verboselog( device->machine(), 5, "ZDMA %d start\n", ch); |
| 1758 | dma->regs.dcsrc = dma->regs.disrc; |
| 1759 | dma->regs.dcdst = dma->regs.didst; |
| 1760 | dma->regs.dccnt = dma->regs.dicnt; |
| 1761 | s3c44b0_zdma_trigger( device, ch); |
| 1762 | } |
| 1763 | |
| 1764 | static UINT32 s3c44b0_zdma_r( device_t *device, int ch, UINT32 offset) |
| 1765 | { |
| 1766 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1767 | UINT32 data = ((UINT32*)&s3c44b0->zdma[ch].regs)[offset]; |
| 1768 | return data; |
| 1769 | } |
| 1770 | |
| 1771 | static void s3c44b0_zdma_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask) |
| 1772 | { |
| 1773 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1774 | UINT32 old_value = ((UINT32*)&s3c44b0->zdma[ch].regs)[offset]; |
| 1775 | COMBINE_DATA(&((UINT32*)&s3c44b0->zdma[ch].regs)[offset]); |
| 1776 | switch (offset) |
| 1777 | { |
| 1778 | case S3C44B0_DCON : |
| 1779 | { |
| 1780 | if ((old_value & 3) != (data & 3)) |
| 1781 | { |
| 1782 | switch (data & 3) |
| 1783 | { |
| 1784 | case 1 : s3c44b0_zdma_start( device, ch); break; |
| 1785 | } |
| 1786 | } |
| 1787 | s3c44b0->zdma[ch].regs.dcon &= ~3; // "After writing 01,10,11, CMD bit is cleared automatically" |
| 1788 | } |
| 1789 | break; |
| 1790 | } |
| 1791 | } |
| 1792 | |
| 1793 | static READ32_DEVICE_HANDLER( s3c44b0_zdma_0_r ) |
| 1794 | { |
| 1795 | UINT32 data = s3c44b0_zdma_r( device, 0, offset); |
| 1796 | verboselog( device->machine(), 9, "(ZDMA 0) %08X -> %08X\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data); |
| 1797 | return data; |
| 1798 | } |
| 1799 | |
| 1800 | static READ32_DEVICE_HANDLER( s3c44b0_zdma_1_r ) |
| 1801 | { |
| 1802 | UINT32 data = s3c44b0_zdma_r( device, 1, offset); |
| 1803 | verboselog( device->machine(), 9, "(ZDMA 1) %08X -> %08X\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data); |
| 1804 | return data; |
| 1805 | } |
| 1806 | |
| 1807 | static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_0_w ) |
| 1808 | { |
| 1809 | verboselog( device->machine(), 9, "(ZDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_0 + (offset << 2), data, mem_mask); |
| 1810 | s3c44b0_zdma_w( device, 0, offset, data, mem_mask); |
| 1811 | } |
| 1812 | |
| 1813 | static WRITE32_DEVICE_HANDLER( s3c44b0_zdma_1_w ) |
| 1814 | { |
| 1815 | verboselog( device->machine(), 9, "(ZDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_ZDMA_1 + (offset << 2), data, mem_mask); |
| 1816 | s3c44b0_zdma_w( device, 1, offset, data, mem_mask); |
| 1817 | } |
| 1818 | |
| 1819 | static TIMER_CALLBACK( s3c44b0_zdma_timer_exp ) |
| 1820 | { |
| 1821 | int ch = param; |
| 1822 | verboselog( machine, 2, "ZDMA %d timer callback\n", ch); |
| 1823 | } |
| 1824 | |
| 1825 | /* BDMA */ |
| 1826 | |
| 1827 | static void s3c44b0_bdma_trigger( device_t *device, int ch) |
| 1828 | { |
| 1829 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1830 | s3c44b0_dma_t *dma = &s3c44b0->bdma[ch]; |
| 1831 | UINT32 saddr, daddr; |
| 1832 | int dal, dst, tdm, das, cnt; |
| 1833 | verboselog( device->machine(), 5, "s3c44b0_bdma_trigger %d\n", ch); |
| 1834 | dst = BITS( dma->regs.dcsrc, 31, 30); |
| 1835 | dal = BITS( dma->regs.dcsrc, 29, 28); |
| 1836 | saddr = BITS( dma->regs.dcsrc, 27, 0); |
| 1837 | verboselog( device->machine(), 5, "dst %d dal %d saddr %08X\n", dst, dal, saddr); |
| 1838 | tdm = BITS( dma->regs.dcdst, 31, 30); |
| 1839 | das = BITS( dma->regs.dcdst, 29, 28); |
| 1840 | daddr = BITS( dma->regs.dcdst, 27, 0); |
| 1841 | verboselog( device->machine(), 5, "tdm %d das %d daddr %08X\n", tdm, das, daddr); |
| 1842 | cnt = BITS( dma->regs.dccnt, 19, 0); |
| 1843 | verboselog( device->machine(), 5, "icnt %08X\n", cnt); |
| 1844 | verboselog( device->machine(), 9, "[%08X] -> [%08X]\n", saddr, daddr); |
| 1845 | switch (dst) |
| 1846 | { |
| 1847 | case 0 : s3c44b0->space->write_byte( daddr, s3c44b0->space->read_byte( saddr)); break; |
| 1848 | case 1 : s3c44b0->space->write_word( daddr, s3c44b0->space->read_word( saddr)); break; |
| 1849 | case 2 : s3c44b0->space->write_dword( daddr, s3c44b0->space->read_dword( saddr)); break; |
| 1850 | } |
| 1851 | switch (dal) |
| 1852 | { |
| 1853 | case 1 : saddr += (1 << dst); break; |
| 1854 | case 2 : saddr -= (1 << dst); break; |
| 1855 | } |
| 1856 | switch (das) |
| 1857 | { |
| 1858 | case 1 : daddr += (1 << dst); break; |
| 1859 | case 2 : daddr -= (1 << dst); break; |
| 1860 | } |
| 1861 | cnt -= (1 << dst); |
| 1862 | dma->regs.dcsrc = CLR_BITS( dma->regs.dcsrc, 27, 0) | saddr; |
| 1863 | dma->regs.dcdst = CLR_BITS( dma->regs.dcdst, 27, 0) | daddr; |
| 1864 | dma->regs.dccnt = CLR_BITS( dma->regs.dcdst, 19, 0) | cnt; |
| 1865 | if (cnt == 0) |
| 1866 | { |
| 1867 | if ((dma->regs.dccnt & (1 << 23)) != 0) |
| 1868 | { |
| 1869 | const int ch_int[] = { S3C44B0_INT_BDMA0, S3C44B0_INT_BDMA1 }; |
| 1870 | s3c44b0_request_irq( device, ch_int[ch]); |
| 1871 | } |
| 1872 | } |
| 1873 | } |
| 1874 | |
| 1875 | static void s3c44b0_bdma_request_iis( device_t *device) |
| 1876 | { |
| 1877 | // s3c44b0_t *s3c44b0 = get_token( device); |
| 1878 | // s3c44b0_dma_regs_t *regs = &s3c24xx->bdma[0].regs; |
| 1879 | verboselog( device->machine(), 5, "s3c44b0_bdma_request_iis\n"); |
| 1880 | s3c44b0_bdma_trigger( device, 0); |
| 1881 | } |
| 1882 | |
| 1883 | static UINT32 s3c44b0_bdma_r( device_t *device, int ch, UINT32 offset) |
| 1884 | { |
| 1885 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1886 | UINT32 data = ((UINT32*)&s3c44b0->bdma[ch].regs)[offset]; |
| 1887 | return data; |
| 1888 | } |
| 1889 | |
| 1890 | static void s3c44b0_bdma_start( device_t *device, int ch) |
| 1891 | { |
| 1892 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1893 | s3c44b0_dma_t *dma = &s3c44b0->bdma[ch]; |
| 1894 | int qsc; |
| 1895 | verboselog( device->machine(), 5, "BDMA %d start\n", ch); |
| 1896 | qsc = BITS( dma->regs.dicnt, 31, 30); |
| 1897 | if ((ch == 0) && (qsc == 1)) |
| 1898 | { |
| 1899 | // IIS |
| 1900 | } |
| 1901 | else |
| 1902 | { |
| 1903 | printf( "s3c44b0_bdma_start - todo\n"); |
| 1904 | } |
| 1905 | dma->regs.dcsrc = dma->regs.disrc; |
| 1906 | dma->regs.dcdst = dma->regs.didst; |
| 1907 | dma->regs.dccnt = dma->regs.dicnt; |
| 1908 | } |
| 1909 | |
| 1910 | static void s3c44b0_bdma_stop( device_t *device, int ch) |
| 1911 | { |
| 1912 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1913 | verboselog( device->machine(), 5, "BDMA %d stop\n", ch); |
| 1914 | s3c44b0->bdma[ch].timer->adjust( attotime::never, ch); |
| 1915 | } |
| 1916 | |
| 1917 | static void s3c44b0_bdma_w( device_t *device, int ch, UINT32 offset, UINT32 data, UINT32 mem_mask) |
| 1918 | { |
| 1919 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1920 | UINT32 old_value = ((UINT32*)&s3c44b0->bdma[ch].regs)[offset]; |
| 1921 | COMBINE_DATA(&((UINT32*)&s3c44b0->bdma[ch].regs)[offset]); |
| 1922 | switch (offset) |
| 1923 | { |
| 1924 | case S3C44B0_DICNT : |
| 1925 | { |
| 1926 | if ((old_value & (1 << 20)) != (data & (1 << 20))) |
| 1927 | { |
| 1928 | if ((data & (1 << 20)) != 0) |
| 1929 | { |
| 1930 | s3c44b0_bdma_start( device, ch); |
| 1931 | } |
| 1932 | else |
| 1933 | { |
| 1934 | s3c44b0_bdma_stop( device, ch); |
| 1935 | } |
| 1936 | } |
| 1937 | } |
| 1938 | break; |
| 1939 | } |
| 1940 | } |
| 1941 | |
| 1942 | static READ32_DEVICE_HANDLER( s3c44b0_bdma_0_r ) |
| 1943 | { |
| 1944 | UINT32 data = s3c44b0_bdma_r( device, 0, offset); |
| 1945 | verboselog( device->machine(), 9, "(BDMA 0) %08X -> %08X\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data); |
| 1946 | return data; |
| 1947 | } |
| 1948 | |
| 1949 | static READ32_DEVICE_HANDLER( s3c44b0_bdma_1_r ) |
| 1950 | { |
| 1951 | UINT32 data = s3c44b0_bdma_r( device, 1, offset); |
| 1952 | verboselog( device->machine(), 9, "(BDMA 1) %08X -> %08X\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data); |
| 1953 | return data; |
| 1954 | } |
| 1955 | |
| 1956 | static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_0_w ) |
| 1957 | { |
| 1958 | verboselog( device->machine(), 9, "(BDMA 0) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_0 + (offset << 2), data, mem_mask); |
| 1959 | s3c44b0_bdma_w( device, 0, offset, data, mem_mask); |
| 1960 | } |
| 1961 | |
| 1962 | static WRITE32_DEVICE_HANDLER( s3c44b0_bdma_1_w ) |
| 1963 | { |
| 1964 | verboselog( device->machine(), 9, "(BDMA 1) %08X <- %08X (%08X)\n", S3C44B0_BASE_BDMA_1 + (offset << 2), data, mem_mask); |
| 1965 | s3c44b0_bdma_w( device, 1, offset, data, mem_mask); |
| 1966 | } |
| 1967 | |
| 1968 | static TIMER_CALLBACK( s3c44b0_bdma_timer_exp ) |
| 1969 | { |
| 1970 | // device_t *device = (device_t *)ptr; |
| 1971 | // s3c44b0_t *s3c44b0 = get_token( device); |
| 1972 | int ch = param; |
| 1973 | verboselog( machine, 2, "BDMA %d timer callback\n", ch); |
| 1974 | } |
| 1975 | |
| 1976 | // ... |
| 1977 | |
| 1978 | static DEVICE_RESET( s3c44b0 ) |
| 1979 | { |
| 1980 | s3c44b0_t *s3c44b0 = get_token( device); |
| 1981 | s3c44b0->iis.fifo_index = 0; |
| 1982 | // s3c44b0->iic.data_index = 0; |
| 1983 | #if defined(DEVICE_S3C2410) || defined(DEVICE_S3C2440) |
| 1984 | s3c44b0->gpio.regs.gstatus2 = 0x00000001; // Boot is caused by power on reset |
| 1985 | #endif |
| 1986 | s3c44b0->irq.line_irq = s3c44b0->irq.line_fiq = CLEAR_LINE; |
| 1987 | } |
| 1988 | |
| 1989 | VIDEO_START( s3c44b0 ) |
| 1990 | { |
| 1991 | device_t *device = machine.device( S3C44B0_TAG); |
| 1992 | s3c44b0_video_start( device, machine); |
| 1993 | } |
| 1994 | |
| 1995 | SCREEN_UPDATE( s3c44b0 ) |
| 1996 | { |
| 1997 | device_t *device = screen->machine().device( S3C44B0_TAG); |
| 1998 | return s3c44b0_video_update( device, screen, bitmap, cliprect); |
| 1999 | } |
| 2000 | |
| 2001 | DEVICE_START( s3c44b0 ) |
| 2002 | { |
| 2003 | running_machine &machine = device->machine(); |
| 2004 | address_space *space = machine.device( "maincpu")->memory().space( AS_PROGRAM); |
| 2005 | s3c44b0_t *s3c44b0 = get_token( device); |
| 2006 | s3c44b0->iface = (const s3c44b0_interface *)device->static_config(); |
| 2007 | s3c44b0->space = space; |
| 2008 | s3c44b0->cpu = downcast<cpu_device *>(device->machine().device( "maincpu")); |
| 2009 | for (int i = 0; i < 6; i++) s3c44b0->pwm.timer[i] = machine.scheduler().timer_alloc(FUNC(s3c44b0_pwm_timer_exp), (void*)device); |
| 2010 | for (int i = 0; i < 2; i++) s3c44b0->uart[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_uart_timer_exp), (void*)device); |
| 2011 | for (int i = 0; i < 2; i++) s3c44b0->zdma[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_zdma_timer_exp), (void*)device); |
| 2012 | for (int i = 0; i < 2; i++) s3c44b0->bdma[i].timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_bdma_timer_exp), (void*)device); |
| 2013 | s3c44b0->lcd.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_lcd_timer_exp), (void*)device); |
| 2014 | s3c44b0->wdt.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_wdt_timer_exp), (void*)device); |
| 2015 | s3c44b0->sio.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_sio_timer_exp), (void*)device); |
| 2016 | s3c44b0->adc.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_adc_timer_exp), (void*)device); |
| 2017 | s3c44b0->iic.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_iic_timer_exp), (void*)device); |
| 2018 | s3c44b0->iis.timer = machine.scheduler().timer_alloc(FUNC(s3c44b0_iis_timer_exp), (void*)device); |
| 2019 | space->install_legacy_readwrite_handler( *device, 0x01c00000, 0x01c0000b, 0, 0, FUNC(s3c44b0_cpuwrap_r), FUNC(s3c44b0_cpuwrap_w)); |
| 2020 | space->install_legacy_readwrite_handler( *device, 0x01d00000, 0x01d0002b, 0, 0, FUNC(s3c44b0_uart_0_r), FUNC(s3c44b0_uart_0_w)); |
| 2021 | space->install_legacy_readwrite_handler( *device, 0x01d04000, 0x01d0402b, 0, 0, FUNC(s3c44b0_uart_1_r), FUNC(s3c44b0_uart_1_w)); |
| 2022 | space->install_legacy_readwrite_handler( *device, 0x01d14000, 0x01d14013, 0, 0, FUNC(s3c44b0_sio_r), FUNC(s3c44b0_sio_w)); |
| 2023 | space->install_legacy_readwrite_handler( *device, 0x01d18000, 0x01d18013, 0, 0, FUNC(s3c44b0_iis_r), FUNC(s3c44b0_iis_w)); |
| 2024 | space->install_legacy_readwrite_handler( *device, 0x01d20000, 0x01d20057, 0, 0, FUNC(s3c44b0_gpio_r), FUNC(s3c44b0_gpio_w)); |
| 2025 | space->install_legacy_readwrite_handler( *device, 0x01d30000, 0x01d3000b, 0, 0, FUNC(s3c44b0_wdt_r), FUNC(s3c44b0_wdt_w)); |
| 2026 | space->install_legacy_readwrite_handler( *device, 0x01d40000, 0x01d4000b, 0, 0, FUNC(s3c44b0_adc_r), FUNC(s3c44b0_adc_w)); |
| 2027 | space->install_legacy_readwrite_handler( *device, 0x01d50000, 0x01d5004f, 0, 0, FUNC(s3c44b0_pwm_r), FUNC(s3c44b0_pwm_w)); |
| 2028 | space->install_legacy_readwrite_handler( *device, 0x01d60000, 0x01d6000f, 0, 0, FUNC(s3c44b0_iic_r), FUNC(s3c44b0_iic_w)); |
| 2029 | space->install_legacy_readwrite_handler( *device, 0x01d80000, 0x01d8000f, 0, 0, FUNC(s3c44b0_clkpow_r), FUNC(s3c44b0_clkpow_w)); |
| 2030 | space->install_legacy_readwrite_handler( *device, 0x01e00000, 0x01e0003f, 0, 0, FUNC(s3c44b0_irq_r), FUNC(s3c44b0_irq_w)); |
| 2031 | space->install_legacy_readwrite_handler( *device, 0x01e80000, 0x01e8001b, 0, 0, FUNC(s3c44b0_zdma_0_r), FUNC(s3c44b0_zdma_0_w)); |
| 2032 | space->install_legacy_readwrite_handler( *device, 0x01e80020, 0x01e8003b, 0, 0, FUNC(s3c44b0_zdma_1_r), FUNC(s3c44b0_zdma_1_w)); |
| 2033 | space->install_legacy_readwrite_handler( *device, 0x01f00000, 0x01f00047, 0, 0, FUNC(s3c44b0_lcd_r), FUNC(s3c44b0_lcd_w)); |
| 2034 | space->install_legacy_readwrite_handler( *device, 0x01f80000, 0x01f8001b, 0, 0, FUNC(s3c44b0_bdma_0_r), FUNC(s3c44b0_bdma_0_w)); |
| 2035 | space->install_legacy_readwrite_handler( *device, 0x01f80020, 0x01f8003b, 0, 0, FUNC(s3c44b0_bdma_1_r), FUNC(s3c44b0_bdma_1_w)); |
| 2036 | } |
| 2037 | |
| 2038 | DEVICE_GET_INFO( s3c44b0 ) |
| 2039 | { |
| 2040 | switch ( state ) |
| 2041 | { |
| 2042 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 2043 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(s3c44b0_t); break; |
| 2044 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = 0; break; |
| 2045 | // case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; |
| 2046 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 2047 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(s3c44b0); break; |
| 2048 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(s3c44b0); break; |
| 2049 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 2050 | case DEVINFO_STR_FAMILY: strcpy(info->s, "S3C44B0"); break; |
| 2051 | case DEVINFO_STR_VERSION: strcpy(info->s, "1.00"); break; |
| 2052 | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 2053 | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright the MESS Team"); break; |
| 2054 | case DEVINFO_STR_NAME: strcpy(info->s, "Samsung S3C44B0"); break; |
| 2055 | } |
| 2056 | } |
| 2057 | |
| 2058 | DEFINE_LEGACY_DEVICE(S3C44B0, s3c44b0); |
src/mess/drivers/mmodular.c
| r13242 | r13243 | |
| 1 | | /******************************************************************************
|
| 2 | | Mephisto Chess Computers using plugin modules
|
| 3 | | |
| 4 | | Vancouver Chess Computer 68000 (driver recalled) by R. Schaefer (2010)
|
| 5 | | |
| 6 | | (most of the magnetic sensor versions with 680x0 family modules)
|
| 7 | | |
| 8 | | Almeria 68000 12Mhz
|
| 9 | | Almeria 68020 12Mhz
|
| 10 | | Lyon 68000 12Mhz
|
| 11 | | Lyon 68020 12Mhz
|
| 12 | | Vancouver 68000 12Mhz
|
| 13 | | Vancouver 68020 12Mhz
|
| 14 | | Genius 68030 V4.00 33.333 Mhz
|
| 15 | | Genius 68030 V4.01 33.333 Mhz
|
| 16 | | Genius 68030 V4.01 33.333x2 Mhz (custom MESS overclocked version for higher ELO)
|
| 17 | | Berlin Pro 68020 24.576 Mhz (not modular board, but otherwise close to milano)
|
| 18 | | Berlin Pro (London) 68020 24.576 Mhz (not modular board, but otherwise close to milano)
|
| 19 | | London 68030 V5.00k 33.333 Mhz (probably the Genius 3/4 update ROM)
|
| 20 | | |
| 21 | | note: The Almeria 68000 is the 'parent' of all these, but Vancouver 68000 is used as parent in the driver.
|
| 22 | | It was the first to have 'Bavaria' sensors, and will make the other drivers easier when inheriting this
|
| 23 | | feature later
|
| 24 | | |
| 25 | | |
| 26 | | misc non-modular/non-68K boards
|
| 27 | | |
| 28 | | RISC 2500 (Skeleton, does not work, and not sure the same internal chessboard connections are used)
|
| 29 | | Final Chess Card by TASC (this is not Mephisto at all, but wanted to make sure it didn't get lost)
|
| 30 | | Academy 65C02 4.9152mhz
|
| 31 | | Monte Carlo IV, Mega IV and any others not listed above have correct ROM/RAM and maybe LCD, not much else for now
|
| 32 | | |
| 33 | | Novag boards: (should go in different .c eventually)
|
| 34 | | Super Forte and Super Expert are the same, except one is touch board, other is magnetic.
|
| 35 | | The Diablo 68000 is Super Expert board but 68K based
|
| 36 | | |
| 37 | | Notes by Cowering (2011)
|
| 38 | | |
| 39 | | TODO: add Bavaria sensor support (unknown1,2,3 handlers in current driver)
|
| 40 | | proper 'bezel' for all games/cpuspeeds so 'Vancouver' does not say 'Almeria', etc
|
| 41 | | custom handler to read/write the Battery RAM so 68000 can share files with 020/030 (real modular machine can do this)
|
| 42 | | find a timing to let the player see the flashing LEDs on the 68030 versions (might be fixed with waitstates in core)
|
| 43 | | add the missing machines.. including all Portorose and the very rare overclocked 'TM' Tournament Machines
|
| 44 | | match I/S= diag speed test with real hardware (good test for proper waitstates)
|
| 45 | | load LCD rom inside the LCD driver
|
| 46 | | |
| 47 | | TODO2: (these worked before .140 core)
|
| 48 | | LCD off by a couple of pixels in artwork now
|
| 49 | | no longer see the custom white hand when selecting chess pieces
|
| 50 | | parent/clone for artwork so there are not multiple copies of chessboard+pieces
|
| 51 | | |
| 52 | | |
| 53 | | TODO3: Oct 2011 - commented out all ACIA functions until they are ported to new device
|
| 54 | | |
| 55 | | Undocumented buttons: holding ENTER and LEFT cursor on cold boot runs diagnostics on modular 680x0 boards
|
| 56 | | holding UP and RIGHT cursor will clear the Battery Backed RAM on modular 680x0 boards
|
| 57 | | holding CLEAR clears Battery Backed RAM on the Berlin (Pro) 68020
|
| 58 | | ******************************************************************************/
|
| 59 | | |
| 60 | | /******************************************************************************
|
| 61 | | Mephisto Polgar & Milano
|
| 62 | | 2010 Dirk V., Ralf Schafer, Cowering
|
| 63 | | |
| 64 | | ******************************************************************************/
|
| 65 | | |
| 66 | | /*
|
| 67 | | |
| 68 | | CPU 65C02 P4 4.9152 MHz
|
| 69 | | |
| 70 | | // lese Tastatur von 2c00 - 2c07,
|
| 71 | | 2c00 Trn
|
| 72 | | 2c01 Info
|
| 73 | | 2c02 Mem
|
| 74 | | 2c03 Pos
|
| 75 | | 2c04 Lev
|
| 76 | | 2c05 Fct
|
| 77 | | 2c06 Ent
|
| 78 | | 2c07 CL
|
| 79 | | |
| 80 | | $1ff0
|
| 81 | | Bit 0 LCD Command/Data 0/1
|
| 82 | | Bit 1 LCD Enable (signals Data is valid)
|
| 83 | | Bit 2 Beeper
|
| 84 | | Bit 3 Beeper
|
| 85 | | Bit 4+7 LED A-H enable
|
| 86 | | Bit 5+6 LED 1-8 enable
|
| 87 | | */
|
| 88 | | |
| 89 | | #include "emu.h"
|
| 90 | | #include "cpu/m68000/m68000.h"
|
| 91 | | #include "cpu/m6502/m6502.h"
|
| 92 | | #include "cpu/arm/arm.h"
|
| 93 | | #include "sound/beep.h"
|
| 94 | | //#include "machine/6551acia.h"
|
| 95 | | #include "video/hd44780.h"
|
| 96 | | |
| 97 | | #include "rendlay.h"
|
| 98 | | |
| 99 | | #include "machine/mboard.h"
|
| 100 | | #include "machine/nvram.h"
|
| 101 | | |
| 102 | | //static UINT16 unknown2_data = 0;
|
| 103 | | static UINT16 *save_ram;
|
| 104 | | static UINT32 *save_ram32;
|
| 105 | | |
| 106 | | // Berlin Pro 68020
|
| 107 | | static UINT32 BPL32latch_data = 0;
|
| 108 | | |
| 109 | | // Final Chess Card
|
| 110 | | static UINT8 FCH_latch_data = 0;
|
| 111 | | |
| 112 | | |
| 113 | | // Mephisto Academy
|
| 114 | | static UINT8 academyallowNMI = 0;
|
| 115 | | |
| 116 | | //Monte Carlo IV key/board selects
|
| 117 | | |
| 118 | | static UINT8 monteciv_select[2] = { 0xff,0xff };
|
| 119 | | static UINT8 montecivtop = 0, montecivbot = 0;
|
| 120 | | static UINT8 montecivtopnew = 0, montecivbotnew = 0;
|
| 121 | | |
| 122 | | //Mephisto Mega IV latch
|
| 123 | | UINT8 latch2400 = 0;
|
| 124 | | |
| 125 | | UINT8 diablo68_3c0000 = 0;
|
| 126 | | |
| 127 | | UINT8 sfortea_latch = 0;
|
| 128 | | |
| 129 | | |
| 130 | | INPUT_PORTS_EXTERN( chessboard );
|
| 131 | | |
| 132 | | UINT8 lcd32_char;
|
| 133 | | |
| 134 | | class polgar_state : public driver_device
|
| 135 | | {
|
| 136 | | public:
|
| 137 | | polgar_state(const machine_config &mconfig, device_type type, const char *tag)
|
| 138 | | : driver_device(mconfig, type, tag) { }
|
| 139 | | |
| 140 | | UINT8 led_status;
|
| 141 | | UINT8 lcd_char;
|
| 142 | | //UINT8 led7;
|
| 143 | | UINT8 latch_data;
|
| 144 | | };
|
| 145 | | |
| 146 | | static const hd44780_interface chess_display =
|
| 147 | | {
|
| 148 | | 2, // number of lines
|
| 149 | | 16, // chars for line
|
| 150 | | NULL // custom display layout
|
| 151 | | };
|
| 152 | | |
| 153 | | static UINT8 convert_imputmask(UINT8 input)
|
| 154 | | {
|
| 155 | | input^=0xff;
|
| 156 | | switch (input) {
|
| 157 | | case 0x01:
|
| 158 | | return 0x80;
|
| 159 | | case 0x02:
|
| 160 | | return 0x40;
|
| 161 | | case 0x04:
|
| 162 | | return 0x20;
|
| 163 | | case 0x08:
|
| 164 | | return 0x10;
|
| 165 | | case 0x10:
|
| 166 | | return 0x08;
|
| 167 | | case 0x20:
|
| 168 | | return 0x04;
|
| 169 | | case 0x40:
|
| 170 | | return 0x02;
|
| 171 | | case 0x80:
|
| 172 | | return 0x01;
|
| 173 | | default:
|
| 174 | | return 0x00;
|
| 175 | | }
|
| 176 | | }
|
| 177 | | |
| 178 | | static int get_first_cleared_bit(UINT8 data)
|
| 179 | | {
|
| 180 | | int i;
|
| 181 | | |
| 182 | | for (i = 0; i < 8; i++)
|
| 183 | | if (!BIT(data, i))
|
| 184 | | return i;
|
| 185 | | |
| 186 | | return NOT_VALID;
|
| 187 | | }
|
| 188 | | |
| 189 | | static WRITE8_HANDLER ( write_polgar_IO )
|
| 190 | | {
|
| 191 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 192 | | int i;
|
| 193 | | |
| 194 | | if (BIT(data,1)) {
|
| 195 | | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780");
|
| 196 | | if (BIT(data,0)) {
|
| 197 | | hd44780->data_write(*space, 128, state->lcd_char);
|
| 198 | | } else {
|
| 199 | | hd44780->control_write(*space, 128, state->lcd_char);
|
| 200 | | }
|
| 201 | | }
|
| 202 | | |
| 203 | | if (BIT(data,2) || BIT(data,3)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0);
|
| 204 | | |
| 205 | | if (BIT(data,7) && BIT(data, 4)) {
|
| 206 | | for (i = 0;i < 8;i++)
|
| 207 | | output_set_led_value(i,!BIT(state->latch_data,i));
|
| 208 | | }
|
| 209 | | else if (BIT(data,6) && BIT(data,5)) {
|
| 210 | | for (i = 0;i < 8;i++)
|
| 211 | | output_set_led_value(10+i,!BIT(state->latch_data,7-i));
|
| 212 | | }
|
| 213 | | else if (!data && (!strcmp(space->machine().system().name,"milano"))) {
|
| 214 | | for (i=0;i<8;i++) {
|
| 215 | | output_set_led_value(i,!BIT(state->latch_data,i));
|
| 216 | | output_set_led_value(10+i,!BIT(state->latch_data,7-i));
|
| 217 | | }
|
| 218 | | }
|
| 219 | | |
| 220 | | |
| 221 | | //logerror("LCD Status Data = %d\n",data);
|
| 222 | | |
| 223 | | }
|
| 224 | | |
| 225 | | |
| 226 | | static WRITE8_HANDLER ( write_LCD_polgar )
|
| 227 | | {
|
| 228 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 229 | | |
| 230 | | state->lcd_char = data;
|
| 231 | | |
| 232 | | logerror("LCD Data = %d %02x [%c]\n",data,data,(data&0xff));
|
| 233 | | |
| 234 | | }
|
| 235 | | |
| 236 | | static READ8_HANDLER ( read_1ff1_sfortea )
|
| 237 | | {
|
| 238 | | UINT8 data;
|
| 239 | | data = input_port_read(space->machine(), "BUTTONS_SFOR1");
|
| 240 | | logerror("1ff0 data %02x\n",data);
|
| 241 | | return 0;
|
| 242 | | // return data;
|
| 243 | | }
|
| 244 | | |
| 245 | | static READ8_HANDLER ( read_1ff0_sfortea )
|
| 246 | | {
|
| 247 | | UINT8 data;
|
| 248 | | data = input_port_read(space->machine(), "BUTTONS_SFOR2");
|
| 249 | | logerror("1ff0 data %02x\n",data);
|
| 250 | | return 0;
|
| 251 | | // return data;
|
| 252 | | |
| 253 | | // static UINT8 temp = 0;
|
| 254 | | // temp++;
|
| 255 | | // logerror("read 1ff0 %02x\n",temp);
|
| 256 | | // printf("read 1ff0 %02x\n",temp);
|
| 257 | | |
| 258 | | // return (0x00);
|
| 259 | | }
|
| 260 | | |
| 261 | | |
| 262 | | |
| 263 | | static WRITE8_HANDLER ( write_latch_sfortea )
|
| 264 | | {
|
| 265 | | sfortea_latch = data;
|
| 266 | | logerror("latch data %02x\n",data);
|
| 267 | | // printf("latch data %02x\n",data);
|
| 268 | | |
| 269 | | }
|
| 270 | | |
| 271 | | static WRITE8_HANDLER ( write_lcd_IO_sfortea )
|
| 272 | | {
|
| 273 | | /* bits
|
| 274 | | 7
|
| 275 | | 6 paired with 5
|
| 276 | | 5
|
| 277 | | 4
|
| 278 | | 3 irq on off?
|
| 279 | | 2 select HD44780
|
| 280 | | 1
|
| 281 | | 0 LCD command/data select
|
| 282 | | */
|
| 283 | | |
| 284 | | |
| 285 | | if (BIT(sfortea_latch,2))
|
| 286 | | {
|
| 287 | | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780");
|
| 288 | | if(BIT(sfortea_latch,0)) {
|
| 289 | | hd44780->data_write(*space, 128, data);
|
| 290 | | logerror("LCD DTA = %02x\n",data);
|
| 291 | | } else {
|
| 292 | | if (BIT(data,7)) {
|
| 293 | | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8
|
| 294 | | }
|
| 295 | | hd44780->control_write(*space, 128, data);
|
| 296 | | logerror("LCD CMD = %02x\n",data);
|
| 297 | | }
|
| 298 | | }
|
| 299 | | }
|
| 300 | | |
| 301 | | static WRITE8_HANDLER ( write_LCD_academy )
|
| 302 | | {
|
| 303 | | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780");
|
| 304 | | |
| 305 | | if (offset) {
|
| 306 | | hd44780->data_write(*space, 128, data);
|
| 307 | | } else {
|
| 308 | | hd44780->control_write(*space, 128, data);
|
| 309 | | }
|
| 310 | | }
|
| 311 | | |
| 312 | | // AM_RANGE( 0x3a0000,0x3a0000 ) AM_READ(diablo68_write_LCD)
|
| 313 | | // AM_RANGE( 0x3c0000,0x3c0000 ) AM_READ(diablo68_reg_select)
|
| 314 | | |
| 315 | | /*static WRITE16_HANDLER ( diablo68_aciawrite )
|
| 316 | | {
|
| 317 | | // device_t *acia = space->machine().device("acia65c51");
|
| 318 | | // acia_6551_w(acia, offset & 0x03, data >> 8);
|
| 319 | | // printf("ACIA write data %04x offset %02x\n",data,offset);
|
| 320 | | logerror("ACIA write data %04x offset %02x\n",data,offset);
|
| 321 | | }
|
| 322 | | |
| 323 | | static READ16_HANDLER ( diablo68_aciaread )
|
| 324 | | {
|
| 325 | | // device_t *acia = space->machine().device("acia65c51");
|
| 326 | | UINT16 result;
|
| 327 | | // result = acia_6551_r(acia, offset & 0x03);
|
| 328 | | // logerror("ACIA read offset %02x\n",offset);
|
| 329 | | // printf("ACIA read offset %02x\n",offset);
|
| 330 | | |
| 331 | | result <<= 8;
|
| 332 | | |
| 333 | | return result;
|
| 334 | | }
|
| 335 | | */
|
| 336 | | |
| 337 | | static WRITE16_HANDLER ( diablo68_reg_select )
|
| 338 | | {
|
| 339 | | diablo68_3c0000 = data >> 8;
|
| 340 | | //printf("3c0000 = %04x\n",data>>8);
|
| 341 | | logerror("3c0000 = %04x\n",data>>8);
|
| 342 | | |
| 343 | | }
|
| 344 | | |
| 345 | | |
| 346 | | static WRITE16_HANDLER ( diablo68_write_LCD )
|
| 347 | | {
|
| 348 | | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780");
|
| 349 | | data >>= 8;
|
| 350 | | if (!(diablo68_3c0000 & 0x02)) {
|
| 351 | | if (BIT(data,7)) {
|
| 352 | | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8
|
| 353 | | }
|
| 354 | | hd44780->control_write(*space, 128, data);
|
| 355 | | // logerror("Control %02x\n", data);
|
| 356 | | // printf("Control %02x\n", data);
|
| 357 | | } else {
|
| 358 | | hd44780->data_write(*space, 128, data);
|
| 359 | | // printf("LCDdata %04x [%c]\n", data,data);
|
| 360 | | // logerror("LCDdata %04x [%c]\n", data,data);
|
| 361 | | }
|
| 362 | | |
| 363 | | //logerror("LCD Status Data = %d\n",data);
|
| 364 | | |
| 365 | | }
|
| 366 | | |
| 367 | | static WRITE8_HANDLER ( milano_write_LED )
|
| 368 | | {
|
| 369 | | UINT8 LED_offset = 100;
|
| 370 | | if (data == 0xff) output_set_led_value(LED_offset+offset,1);
|
| 371 | | else output_set_led_value(LED_offset+offset,0);
|
| 372 | | |
| 373 | | //logerror("LEDs Offset = %d Data = %d\n",offset,data);
|
| 374 | | }
|
| 375 | | |
| 376 | | static WRITE8_HANDLER ( megaiv_write_LED )
|
| 377 | | {
|
| 378 | | if (BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0);
|
| 379 | | output_set_led_value(102,BIT(data,1)?1:0);
|
| 380 | | output_set_led_value(107,BIT(data,6)?1:0);
|
| 381 | | |
| 382 | | // logerror("LEDs FUNC = %02x found = %d\n",data,found);
|
| 383 | | logerror("LED mask %d\n",data);
|
| 384 | | // printf("LED mask %d\n",data);
|
| 385 | | |
| 386 | | }
|
| 387 | | |
| 388 | | |
| 389 | | static WRITE8_HANDLER ( academy_write_LED )
|
| 390 | | {
|
| 391 | | int found = 0;
|
| 392 | | |
| 393 | | // LED mask debugging, please don't delete
|
| 394 | | /*static int r[4] = { 0,0,0,0 };
|
| 395 | | static int pr[4] = { -1,-1,-1,-1 };
|
| 396 | | static int new1 = 0,start = 0,z = 0,i2;
|
| 397 | | if (data == 0xf8) {
|
| 398 | | if (start == 0) {
|
| 399 | | start = 1;
|
| 400 | | z = 0;
|
| 401 | | }
|
| 402 | | }
|
| 403 | | if (start == 1) {
|
| 404 | | new1 = 0;
|
| 405 | | pr[z] = r[z];
|
| 406 | | r[z] = data;
|
| 407 | | for (i2 = 0; i2 < 4; i2++) if(pr[i2] != r[i2]) new1 = 1;
|
| 408 | | z++;
|
| 409 | | if(z == 4) z = 0;
|
| 410 | | if (new1) printf("[%02x] [%02x] [%02x] [%02x]\n",r[0],r[1],r[2],r[3]);
|
| 411 | | }
|
| 412 | | */
|
| 413 | | |
| 414 | | if ((data & 0x68) == 0x68) {
|
| 415 | | output_set_led_value(103,BIT(data,4)?0:1); // POS
|
| 416 | | output_set_led_value(107,BIT(data,7)?0:1); // white
|
| 417 | | found = 1;
|
| 418 | | }
|
| 419 | | |
| 420 | | if ((data & 0x64) == 0x64) {
|
| 421 | | output_set_led_value(102,BIT(data,4)?0:1); // MEM
|
| 422 | | output_set_led_value(106,BIT(data,7)?0:1); // black
|
| 423 | | found = 1;
|
| 424 | | }
|
| 425 | | |
| 426 | | if ((data & 0xa2) == 0xa2) {
|
| 427 | | output_set_led_value(101,BIT(data,4)?0:1); // INFO
|
| 428 | | output_set_led_value(105,BIT(data,6)?0:1); // FUNC
|
| 429 | | found = 1;
|
| 430 | | }
|
| 431 | | |
| 432 | | if ((data & 0xa1) == 0xa1) {
|
| 433 | | output_set_led_value(100,BIT(data,4)?0:1); // TRN
|
| 434 | | output_set_led_value(104,BIT(data,6)?0:1); // LVL
|
| 435 | | found = 1;
|
| 436 | | }
|
| 437 | | |
| 438 | | if (BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0);
|
| 439 | | if (BIT(data,1)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0);
|
| 440 | | // logerror("LEDs FUNC = %02x found = %d\n",data,found);
|
| 441 | | if (!found) {
|
| 442 | | logerror("unknown LED mask %d\n",data);
|
| 443 | | // printf("unknown LED mask %d\n",data);
|
| 444 | | }
|
| 445 | | }
|
| 446 | | |
| 447 | | |
| 448 | | static WRITE8_HANDLER ( academy_inhibitNMI )
|
| 449 | | {
|
| 450 | | academyallowNMI = data;
|
| 451 | | |
| 452 | | }
|
| 453 | | |
| 454 | | |
| 455 | | static WRITE32_HANDLER ( write_LED_BPL32 )
|
| 456 | | {
|
| 457 | | int i;
|
| 458 | | |
| 459 | | data >>= 24;
|
| 460 | | for (i=0;i<8;i++) {
|
| 461 | | output_set_led_value(i,BIT(data,i));
|
| 462 | | output_set_led_value(10+i,!BIT(BPL32latch_data,7-i));
|
| 463 | | }
|
| 464 | | |
| 465 | | logerror("LEDs Offset = %d Data = %08x Latch = %08x\n",offset,data,BPL32latch_data);
|
| 466 | | |
| 467 | | }
|
| 468 | | |
| 469 | | |
| 470 | | static WRITE8_HANDLER ( polgar_write_LED )
|
| 471 | | {
|
| 472 | | #define LED_offset 100
|
| 473 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 474 | | |
| 475 | | data &= 0x80;
|
| 476 | | |
| 477 | | if (data == 0) {
|
| 478 | | state->led_status &= 255-(1<<offset);
|
| 479 | | } else {
|
| 480 | | state->led_status|=1<<offset;
|
| 481 | | }
|
| 482 | | |
| 483 | | if (offset < 6) output_set_led_value(LED_offset+offset, state->led_status&1<<offset?1:0);
|
| 484 | | logerror("LEDs Offset = %d Data = %d\n",offset,data);
|
| 485 | | }
|
| 486 | | |
| 487 | | static UINT8 convertMCIV2LED(UINT8 codedchar)
|
| 488 | | {
|
| 489 | | UINT8 data = 0;
|
| 490 | | if (BIT(codedchar,0)) data |= 0x80;
|
| 491 | | if (BIT(codedchar,1)) data |= 0x01;
|
| 492 | | if (BIT(codedchar,2)) data |= 0x20;
|
| 493 | | if (BIT(codedchar,3)) data |= 0x40;
|
| 494 | | if (BIT(codedchar,4)) data |= 0x02;
|
| 495 | | if (BIT(codedchar,5)) data |= 0x04;
|
| 496 | | if (BIT(codedchar,6)) data |= 0x08;
|
| 497 | | if (BIT(codedchar,7)) data |= 0x10;
|
| 498 | | return data;
|
| 499 | | }
|
| 500 | | |
| 501 | | static WRITE8_HANDLER ( monteciv_write_LCD )
|
| 502 | | // first write == 00 (start) then 8 writes (to 74595) x 4 chars, then ff to finish
|
| 503 | | {
|
| 504 | | static UINT8 charstodisplay[4] = { 0,0,0,0 };
|
| 505 | | static UINT8 tempchar = 0,shift = 0, whichchar = 0;
|
| 506 | | |
| 507 | | if ((montecivtop == 0) && (montecivbot == 0)) { // if both are 0 then no screen chosen
|
| 508 | | montecivbotnew = 1;
|
| 509 | | montecivtopnew = 1;
|
| 510 | | logerror("no screen!\n");
|
| 511 | | //printf("no screen! %02x\n",1/(montecivtopnew-1));
|
| 512 | | return;
|
| 513 | | }
|
| 514 | | if (montecivtop == 0xff) {
|
| 515 | | if (montecivtopnew) {
|
| 516 | | montecivtopnew = 0; // skip start bit reset pointer for new chars
|
| 517 | | tempchar = 0;
|
| 518 | | shift = 1;
|
| 519 | | whichchar = 0;
|
| 520 | | return;
|
| 521 | | }
|
| 522 | | tempchar |= BIT(data,7);
|
| 523 | | tempchar <<= 1;
|
| 524 | | shift++;
|
| 525 | | if (shift == 8) {
|
| 526 | | shift = 0;
|
| 527 | | charstodisplay[whichchar] = convertMCIV2LED(tempchar);
|
| 528 | | whichchar++;
|
| 529 | | tempchar = 0;
|
| 530 | | }
|
| 531 | | if (whichchar == 4) {
|
| 532 | | output_set_digit_value(0,charstodisplay[0]);
|
| 533 | | output_set_digit_value(1,charstodisplay[1]);
|
| 534 | | output_set_digit_value(2,charstodisplay[2]);
|
| 535 | | output_set_digit_value(3,charstodisplay[3]);
|
| 536 | | whichchar = 0;
|
| 537 | | }
|
| 538 | | }
|
| 539 | | if (montecivbot == 0xff) {
|
| 540 | | if (montecivbotnew) {
|
| 541 | | montecivbotnew = 0; // skip start bit reset pointer for new chars
|
| 542 | | tempchar = 0;
|
| 543 | | shift = 1;
|
| 544 | | whichchar = 0;
|
| 545 | | return;
|
| 546 | | }
|
| 547 | | tempchar |= BIT(data,7);
|
| 548 | | tempchar <<= 1;
|
| 549 | | shift++;
|
| 550 | | if (shift == 8) {
|
| 551 | | shift = 0;
|
| 552 | | charstodisplay[whichchar] = convertMCIV2LED(tempchar);
|
| 553 | | whichchar++;
|
| 554 | | tempchar = 0;
|
| 555 | | }
|
| 556 | | if (whichchar == 4) {
|
| 557 | | output_set_digit_value(4+0,charstodisplay[0]);
|
| 558 | | output_set_digit_value(4+1,charstodisplay[1]);
|
| 559 | | output_set_digit_value(4+2,charstodisplay[2]);
|
| 560 | | output_set_digit_value(4+3,charstodisplay[3]);
|
| 561 | | whichchar = 0;
|
| 562 | | }
|
| 563 | | }
|
| 564 | | // logerror("$3004 %02x\n",data);
|
| 565 | | // printf("$3004 %02x %02x \n",data,tempchar);
|
| 566 | | }
|
| 567 | | |
| 568 | | static WRITE8_HANDLER ( monteciv_3007 )
|
| 569 | | {
|
| 570 | | // logerror("$3007 SELECTTOP %02x\n",data);
|
| 571 | | // printf("$3007 SELECTTOP %02x\n",data);
|
| 572 | | montecivtop = data;
|
| 573 | | montecivtopnew = 1;
|
| 574 | | }
|
| 575 | | |
| 576 | | static WRITE8_HANDLER ( monteciv_3005 )
|
| 577 | | {
|
| 578 | | // logerror("$3005 SELECTBOT %02x\n",data);
|
| 579 | | // printf("$3005 SELECTBOT %02x\n",data);
|
| 580 | | montecivbot = data;
|
| 581 | | montecivbotnew = 1;
|
| 582 | | }
|
| 583 | | |
| 584 | | static WRITE8_HANDLER ( monteciv_3006 )
|
| 585 | | {
|
| 586 | | logerror("$3006 CLK %02x\n",data);
|
| 587 | | // printf("$3006 CLK %02x\n",data);
|
| 588 | | }
|
| 589 | | |
| 590 | | |
| 591 | | static WRITE8_HANDLER ( academy_write_board )
|
| 592 | | {
|
| 593 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 594 | | |
| 595 | | state->latch_data = data;
|
| 596 | | // logerror("acad_write_latch %02x\n",data);
|
| 597 | | if (data != 0xff) mboard_write_board_8(space,0, data);
|
| 598 | | }
|
| 599 | | |
| 600 | | static WRITE8_HANDLER ( milano_write_board )
|
| 601 | | {
|
| 602 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 603 | | |
| 604 | | state->latch_data = data;
|
| 605 | | }
|
| 606 | | |
| 607 | | static READ8_HANDLER(milano_read_board)
|
| 608 | | {
|
| 609 | | int line;
|
| 610 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 611 | | static const char *const board_lines[8] =
|
| 612 | | { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" };
|
| 613 | | |
| 614 | | UINT8 data = 0x00;
|
| 615 | | UINT8 tmp; // = 0xff;
|
| 616 | | |
| 617 | | if (state->latch_data)
|
| 618 | | {
|
| 619 | | line = get_first_cleared_bit(state->latch_data);
|
| 620 | | tmp = input_port_read(space->machine(), board_lines[line]);
|
| 621 | | |
| 622 | | if (tmp != 0xff)
|
| 623 | | data = convert_imputmask(tmp);
|
| 624 | | |
| 625 | | }
|
| 626 | | |
| 627 | | return data;
|
| 628 | | |
| 629 | | }
|
| 630 | | |
| 631 | | static READ8_HANDLER(read_keys)
|
| 632 | | {
|
| 633 | | UINT8 data;
|
| 634 | | static const char *const keynames[1][8] =
|
| 635 | | {
|
| 636 | | { "KEY1_0", "KEY1_1", "KEY1_2", "KEY1_3", "KEY1_4", "KEY1_5", "KEY1_6", "KEY1_7" }
|
| 637 | | };
|
| 638 | | |
| 639 | | data = input_port_read(space->machine(), keynames[0][offset]);
|
| 640 | | // logerror("Keyboard Port = %s Data = %d\n ", ((led_status & 0x80) == 0x00) ? keynames[0][offset] : keynames[1][offset], data);
|
| 641 | | return data | 0x7f;
|
| 642 | | }
|
| 643 | | |
| 644 | | static READ8_HANDLER(read_keys_megaiv)
|
| 645 | | {
|
| 646 | | UINT8 data;
|
| 647 | | static const char *const keynames[1][8] =
|
| 648 | | {
|
| 649 | | { "KEY1_0", "KEY1_1", "KEY1_2", "KEY1_3", "KEY1_4", "KEY1_5", "KEY1_6", "KEY1_7" }
|
| 650 | | };
|
| 651 | | |
| 652 | | data = input_port_read(space->machine(), keynames[0][offset]);
|
| 653 | | logerror("Keyboard Port = %s Data = %d\n ", keynames[0][offset] , data);
|
| 654 | | return data | 0x7f;
|
| 655 | | }
|
| 656 | | |
| 657 | | |
| 658 | | static READ32_HANDLER(read_keys_BPL32)
|
| 659 | | {
|
| 660 | | UINT32 data = 0;
|
| 661 | | UINT8 tmp = 0xff, line = 0;
|
| 662 | | static const char *const board_lines[8] =
|
| 663 | | { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" };
|
| 664 | | |
| 665 | | if (BPL32latch_data == 0xff) {
|
| 666 | | tmp = input_port_read(space->machine(), "BUTTONS_BPL");
|
| 667 | | logerror("Keyboard Port Offset = %d tmp %d\n", offset,tmp);
|
| 668 | | |
| 669 | | data = tmp << 24;
|
| 670 | | } else {
|
| 671 | | if (BPL32latch_data & 0x7f) {
|
| 672 | | logerror("ReadingBoard %02x\n",BPL32latch_data);
|
| 673 | | line = get_first_cleared_bit(BPL32latch_data);
|
| 674 | | tmp = input_port_read(space->machine(), board_lines[line]);
|
| 675 | | |
| 676 | | if (tmp != 0xff)
|
| 677 | | data = convert_imputmask(tmp) << 24;
|
| 678 | | }
|
| 679 | | }
|
| 680 | | |
| 681 | | // logerror("Keyboard Port = %s Data = %d Offset = %d tmp %d line %02x\n", keynames[0][line], data, offset,tmp,line);
|
| 682 | | return data;
|
| 683 | | }
|
| 684 | | |
| 685 | | static WRITE8_HANDLER(beep_academy)
|
| 686 | | {
|
| 687 | | if (!BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0);
|
| 688 | | }
|
| 689 | | |
| 690 | | static WRITE8_HANDLER(megaiv_IO)
|
| 691 | | {
|
| 692 | | // if (BIT(data,0)) beep_set_state(space->machine->device("beep"),1); else beep_set_state(space->machine->device("beep"),0);
|
| 693 | | logerror("$2400 = %02x\n",data);
|
| 694 | | latch2400 = data;
|
| 695 | | }
|
| 696 | | |
| 697 | | |
| 698 | | static WRITE8_HANDLER( monteciv_select_line )
|
| 699 | | {
|
| 700 | | monteciv_select[offset] = data;
|
| 701 | | }
|
| 702 | | |
| 703 | | // FIXME : unlike polgar, academy shares port IO for keys and board, and i just can't seem to get the board latched right (H7 and H8 are always flashing) -- Cow
|
| 704 | | static READ8_HANDLER(read_keys_board_monteciv)
|
| 705 | | {
|
| 706 | | UINT8 data = 0;
|
| 707 | | |
| 708 | | if (monteciv_select[0] == 0xff && monteciv_select[1] == 0xff) {
|
| 709 | | data = mboard_read_board_8(space,0);
|
| 710 | | } else {
|
| 711 | | if (monteciv_select[0] == 0x0) {
|
| 712 | | data = input_port_read(space->machine(), "BUTTONS_MONTE2");
|
| 713 | | #if 0
|
| 714 | | if (data) {
|
| 715 | | output_set_digit_value(0,64);
|
| 716 | | output_set_digit_value(1,113+128);
|
| 717 | | output_set_digit_value(2,190);
|
| 718 | | output_set_digit_value(3,64);
|
| 719 | | |
| 720 | | output_set_digit_value(4,246-128);
|
| 721 | | output_set_digit_value(5,247-128);
|
| 722 | | output_set_digit_value(6,219-128);
|
| 723 | | output_set_digit_value(7,249-128);
|
| 724 | | }
|
| 725 | | #endif
|
| 726 | | } else {
|
| 727 | | data = input_port_read(space->machine(), "BUTTONS_MONTE1");
|
| 728 | | }
|
| 729 | | }
|
| 730 | | return data;
|
| 731 | | }
|
| 732 | | |
| 733 | | |
| 734 | | // FIXME : unlike polgar, academy shares port IO for keys and board, and I just can't seem to get the board latched right (H7 and H8 are always flashing) -- Cow
|
| 735 | | static READ8_HANDLER(read_keys_board_academy)
|
| 736 | | {
|
| 737 | | // static int startup = 0;
|
| 738 | | polgar_state *state = space->machine().driver_data<polgar_state>();
|
| 739 | | UINT8 data = 0;
|
| 740 | | // UINT8 tmp = 0xff, line = 0;
|
| 741 | | // static const char *const board_lines[8] =
|
| 742 | | // { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" };
|
| 743 | | |
| 744 | | if (state->latch_data == 0xff) {
|
| 745 | | data = input_port_read(space->machine(), "BUTTONS_ACAD");
|
| 746 | | } else {
|
| 747 | | // if (state->latch_data & 0x7f) {
|
| 748 | | data = mboard_read_board_8(space,0);
|
| 749 | | // data = milano_read_board(space,0);
|
| 750 | | |
| 751 | | // logerror("ReadingBoard %02x\n",state->latch_data);
|
| 752 | | // line = get_first_cleared_bit(state->latch_data);
|
| 753 | | // tmp = input_port_read(space->machine, board_lines[line]);
|
| 754 | | // mboard_write_board_8(space,0, state->latch_data);
|
| 755 | | // data = mboard_read_board_8(space,0);
|
| 756 | | // logerror("BoardRead Port Offset = %d data %02x Latch %02x\n", offset,data,state->latch_data);
|
| 757 | | // printf ("BoardRead Port Offset = %d data %02x Latch %02x\n", offset,data,state->latch_data);
|
| 758 | | // } else {
|
| 759 | | // logerror("no keys or board\n");
|
| 760 | | // }
|
| 761 | | }
|
| 762 | | // logerror("Keyboard Port Offset = %d tmp %d Latch %d\n", offset,tmp,state->latch_data);
|
| 763 | | // logerror("Keyboard Port = %s Data = %d Offset = %d tmp %d line %02x\n", keynames[0][line], data, offset,tmp,line);
|
| 764 | | return data;
|
| 765 | | }
|
| 766 | | |
| 767 | | static TIMER_DEVICE_CALLBACK( cause_nmi )
|
| 768 | | {
|
| 769 | | cputag_set_input_line(timer.machine(), "maincpu", INPUT_LINE_NMI,PULSE_LINE);
|
| 770 | | }
|
| 771 | | |
| 772 | | static TIMER_DEVICE_CALLBACK( cause_M6502_irq )
|
| 773 | | {
|
| 774 | | cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, ASSERT_LINE);
|
| 775 | | cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, CLEAR_LINE);
|
| 776 | | |
| 777 | | }
|
| 778 | | |
| 779 | | |
| 780 | | static WRITE32_HANDLER( write_board_BPL32 )
|
| 781 | | {
|
| 782 | | BPL32latch_data = data >> 24;
|
| 783 | | logerror("Write BPL32 board Data Latch %08x Offset: %08x\n",BPL32latch_data,offset);
|
| 784 | | |
| 785 | | }
|
| 786 | | |
| 787 | | static READ32_HANDLER( read_buttons_gen32 )
|
| 788 | | {
|
| 789 | | UINT32 data;
|
| 790 | | static const char *const keynames[4] = { "BUTTON_1", "BUTTON_2", "", "BUTTON_3" };
|
| 791 | | |
| 792 | | data = input_port_read(space->machine(), keynames[offset]);
|
| 793 | | |
| 794 | | data = data|data<<8|data<<16|data<<24; // this might not be needed if MAME does handle odd alignment over 32bit boundaries right
|
| 795 | | logerror("Read from Buttons: %08x %08x\n",offset,data);
|
| 796 | | return data;
|
| 797 | | }
|
| 798 | | |
| 799 | | static READ32_HANDLER( read_buttons_van32 )
|
| 800 | | {
|
| 801 | | UINT32 data;
|
| 802 | | static const char *const keynames[4] = { "BUTTON_1", "", "BUTTON_2", "BUTTON_3" };
|
| 803 | | |
| 804 | | |
| 805 | | data = input_port_read(space->machine(), keynames[offset]);
|
| 806 | | |
| 807 | | data = data << 8;
|
| 808 | | logerror("Read from Buttons: %08x %08x\n",offset,data);
|
| 809 | | return data;
|
| 810 | | }
|
| 811 | | |
| 812 | | static READ16_HANDLER( read_buttons_van16 )
|
| 813 | | {
|
| 814 | | UINT16 data;
|
| 815 | | static const char *const keynames[3] = { "BUTTON_1", "BUTTON_2", "BUTTON_3" };
|
| 816 | | |
| 817 | | |
| 818 | | data = input_port_read(space->machine(), keynames[offset>>1]) << 8;
|
| 819 | | |
| 820 | | logerror("Read from %06x offset: %x %04x\n",0xf00000,offset,data);
|
| 821 | | return data;
|
| 822 | | }
|
| 823 | | |
| 824 | | static WRITE32_HANDLER( write_LCD_data_32 )
|
| 825 | | {
|
| 826 | | |
| 827 | | // printf("Write LCD Data Latch %08x o: %08x\n",data,offset);
|
| 828 | | logerror("Write LCD Data Latch %08x o: %08x\n",data,offset);
|
| 829 | | lcd32_char = data>>24;
|
| 830 | | // cpu_adjust_icount(space->cpu,-5000);
|
| 831 | | |
| 832 | | }
|
| 833 | | |
| 834 | | static WRITE16_HANDLER( write_LCD_data )
|
| 835 | | {
|
| 836 | | |
| 837 | | lcd32_char = data>>8;
|
| 838 | | |
| 839 | | }
|
| 840 | | |
| 841 | | static void write_IOenable(unsigned char data,address_space *space) {
|
| 842 | | |
| 843 | | hd44780_device * hd44780 = space->machine().device<hd44780_device>("hd44780");
|
| 844 | | device_t *speaker = space->machine().device("beep");
|
| 845 | | |
| 846 | | if (BIT(data,5) && BIT(data,4)) {
|
| 847 | | if (BIT(data,1)) {
|
| 848 | | // delay until LCD is ready
|
| 849 | | // (this is now patched on a per ROM basis)
|
| 850 | | // ROMs have a very specific delay loop to avoid a busy spin while checking moves in the background
|
| 851 | | // 48 tst.l (a4)+ instuctions need to be > ~42us (for 33.33mhz 030) (a4 is pointing at ROM)
|
| 852 | | // MAME core does not appear to have this opcode timed right.
|
| 853 | | // This also allows 'fake' clocks to test ELO at impossibly high speeds on real hardware
|
| 854 | | // The original programmer says RAM is 2x as fast as the ROM on the 030 machines, maybe waitstates can be put in MAME core someday
|
| 855 | | // cpu_spinuntil_time(space->cpu, ATTOTIME_IN_USEC(50));
|
| 856 | | if (BIT(data,0)) {
|
| 857 | | logerror("Write LCD_DATA [%02x] [%c]\n",lcd32_char,lcd32_char);
|
| 858 | | // printf("Write LCD_DATA [%02x] [%c]\n",lcd32_char,lcd32_char);
|
| 859 | | hd44780->data_write(*space, 128, lcd32_char);
|
| 860 | | } else {
|
| 861 | | logerror("Write LCD_CTRL [%02x] [%c]\n",lcd32_char,lcd32_char);
|
| 862 | | // printf("Write LCD_CTRL [%02x] [%c]\n",lcd32_char,lcd32_char);
|
| 863 | | hd44780->control_write(*space, 128, lcd32_char);
|
| 864 | | }
|
| 865 | | }
|
| 866 | | |
| 867 | | logerror("Write to IOENBL data: %08x\n",data);
|
| 868 | | |
| 869 | | if (BIT(data,2) || BIT(data,3)) beep_set_state(speaker,1); else beep_set_state(speaker,0);
|
| 870 | | }
|
| 871 | | |
| 872 | | }
|
| 873 | | |
| 874 | | static WRITE32_HANDLER( write_IOenables_32 ) {
|
| 875 | | |
| 876 | | write_IOenable(data>>24,space);
|
| 877 | | }
|
| 878 | | |
| 879 | | static WRITE16_HANDLER( write_IOenables )
|
| 880 | | {
|
| 881 | | write_IOenable(data>>8,space);
|
| 882 | | }
|
| 883 | | |
| 884 | | /* Unknown read/write */
|
| 885 | | |
| 886 | | static READ32_HANDLER( read_unknown1_32 )
|
| 887 | | {
|
| 888 | | logerror("Read from unknown1 offset: %x\n",offset);
|
| 889 | | return 0xff00ff00;
|
| 890 | | }
|
| 891 | | |
| 892 | | static READ16_HANDLER( read_unknown1 )
|
| 893 | | {
|
| 894 | | logerror("Read from %06x offset: %x\n",0xe80002,offset);
|
| 895 | | return 0xff00;
|
| 896 | | }
|
| 897 | | |
| 898 | | static WRITE32_HANDLER( write_unknown2_32 )
|
| 899 | | {
|
| 900 | | //unknown2_data = data;
|
| 901 | | logerror("Write to unknown2 data: %04x\n",data);
|
| 902 | | }
|
| 903 | | |
| 904 | | static WRITE16_HANDLER( write_unknown2 )
|
| 905 | | {
|
| 906 | | //unknown2_data = data;
|
| 907 | | logerror("Write from %06x data: %04x\n",0xe80004,data);
|
| 908 | | }
|
| 909 | | |
| 910 | | static READ32_HANDLER( read_unknown3_32 )
|
| 911 | | {
|
| 912 | | logerror("Read from unknown3 offset: %x %08x\n",offset,(unsigned int) cpu_get_reg(space->machine().device("maincpu"), M68K_PC));
|
| 913 | | return 0xffffffff;
|
| 914 | | //return unknown2_data|unknown2_data<<24;
|
| 915 | | |
| 916 | | }
|
| 917 | | |
| 918 | | static READ16_HANDLER( read_unknown3 )
|
| 919 | | {
|
| 920 | | logerror("Read from %06x offset: %x\n",0xe80006,offset);
|
| 921 | | return 0xffff;
|
| 922 | | //return unknown2_data;
|
| 923 | | |
| 924 | | }
|
| 925 | | |
| 926 | | static READ32_HANDLER( read_1800000 )
|
| 927 | | {
|
| 928 | | logerror("Read from RISC2500 1800000\n");
|
| 929 | | return 0;
|
| 930 | | }
|
| 931 | | |
| 932 | | static WRITE32_HANDLER( write_1000000 )
|
| 933 | | {
|
| 934 | | logerror("Write to RISC2500 1000000\n");
|
| 935 | | }
|
| 936 | | |
| 937 | | static WRITE8_HANDLER( io7ff8_write )
|
| 938 | | {
|
| 939 | | FCH_latch_data = data;
|
| 940 | | }
|
| 941 | | |
| 942 | | static READ8_HANDLER( io7ff8_read )
|
| 943 | | {
|
| 944 | | static unsigned char table[] = { 0xff, 0xfd, 0xfe };
|
| 945 | | static int i = -1;
|
| 946 | | i++;
|
| 947 | | if (i == 3) i = 0;
|
| 948 | | return table[i]; // exercise the NMI handler for now with known commands
|
| 949 | | }
|
| 950 | | |
| 951 | | static READ8_HANDLER( io6000_read )
|
| 952 | | {
|
| 953 | | return 0x55;
|
| 954 | | }
|
| 955 | | |
| 956 | | static WRITE8_HANDLER( io6000_write )
|
| 957 | | {
|
| 958 | | FCH_latch_data = data;
|
| 959 | | }
|
| 960 | | |
| 961 | | static TIMER_DEVICE_CALLBACK( timer_update_irq6 )
|
| 962 | | {
|
| 963 | | cputag_set_input_line(timer.machine(), "maincpu", 6, HOLD_LINE);
|
| 964 | | }
|
| 965 | | |
| 966 | | static TIMER_DEVICE_CALLBACK( timer_update_irq2 )
|
| 967 | | {
|
| 968 | | cputag_set_input_line(timer.machine(), "maincpu", 2, HOLD_LINE);
|
| 969 | | }
|
| 970 | | |
| 971 | | |
| 972 | | static TIMER_DEVICE_CALLBACK( timer_update_irq_academy )
|
| 973 | | {
|
| 974 | | if (academyallowNMI) {
|
| 975 | | cputag_set_input_line(timer.machine(), "maincpu", 6, HOLD_LINE);
|
| 976 | | }
|
| 977 | | }
|
| 978 | | |
| 979 | | |
| 980 | | static MACHINE_START( van32 )
|
| 981 | | {
|
| 982 | | // patch LCD delay loop on the 68030 machines until waitstates and/or opcode timings are fixed in MAME core
|
| 983 | | // patches gen32 gen32_41 gen32_oc lond030
|
| 984 | | |
| 985 | | UINT8 *rom = machine.region("maincpu")->base();
|
| 986 | | |
| 987 | | if(rom[0x870] == 0x0c && rom[0x871] == 0x78) {
|
| 988 | | if (!strcmp(machine.system().name,"gen32_oc")) {
|
| 989 | | rom[0x870] = 0x6c;
|
| 990 | | } else {
|
| 991 | | rom[0x870] = 0x38;
|
| 992 | | }
|
| 993 | | }
|
| 994 | | |
| 995 | | machine.device<nvram_device>("nvram")->set_base(save_ram32, 0x8000);
|
| 996 | | |
| 997 | | }
|
| 998 | | |
| 999 | | |
| 1000 | | static MACHINE_START( risc )
|
| 1001 | | {
|
| 1002 | | |
| 1003 | | }
|
| 1004 | | |
| 1005 | | |
| 1006 | | static void common_chess_start(void)
|
| 1007 | | {
|
| 1008 | | mboard_set_border_pieces();
|
| 1009 | | mboard_set_board();
|
| 1010 | | }
|
| 1011 | | |
| 1012 | | static MACHINE_START( polgar )
|
| 1013 | | {
|
| 1014 | | common_chess_start();
|
| 1015 | | mboard_savestate_register(machine);
|
| 1016 | | }
|
| 1017 | | |
| 1018 | | static MACHINE_START( sfortea )
|
| 1019 | | {
|
| 1020 | | common_chess_start();
|
| 1021 | | mboard_savestate_register(machine);
|
| 1022 | | }
|
| 1023 | | |
| 1024 | | static MACHINE_START( finalchs )
|
| 1025 | | {
|
| 1026 | | // timer_pulse(machine, ATTOTIME_IN_HZ(1), NULL, 0, cause_M6502_irq);
|
| 1027 | | }
|
| 1028 | | |
| 1029 | | static MACHINE_START( diablo68 )
|
| 1030 | | {
|
| 1031 | | |
| 1032 | | common_chess_start();
|
| 1033 | | |
| 1034 | | }
|
| 1035 | | |
| 1036 | | static MACHINE_START( van16 )
|
| 1037 | | {
|
| 1038 | | |
| 1039 | | mboard_savestate_register(machine);
|
| 1040 | | machine.device<nvram_device>("nvram")->set_base(save_ram, 0x4000);
|
| 1041 | | |
| 1042 | | }
|
| 1043 | | |
| 1044 | | static MACHINE_RESET( van16 )
|
| 1045 | | {
|
| 1046 | | common_chess_start();
|
| 1047 | | |
| 1048 | | }
|
| 1049 | | |
| 1050 | | static MACHINE_RESET( polgar )
|
| 1051 | | {
|
| 1052 | | common_chess_start();
|
| 1053 | | |
| 1054 | | }
|
| 1055 | | |
| 1056 | | static MACHINE_RESET( sfortea )
|
| 1057 | | {
|
| 1058 | | common_chess_start();
|
| 1059 | | |
| 1060 | | }
|
| 1061 | | |
| 1062 | | static MACHINE_RESET( monteciv )
|
| 1063 | | {
|
| 1064 | | montecivtop = 0;
|
| 1065 | | montecivbot = 0;
|
| 1066 | | monteciv_select[0] = 0;
|
| 1067 | | monteciv_select[1] = 0;
|
| 1068 | | academyallowNMI = 0;
|
| 1069 | | common_chess_start();
|
| 1070 | | }
|
| 1071 | | |
| 1072 | | |
| 1073 | | static MACHINE_RESET( academy )
|
| 1074 | | {
|
| 1075 | | academyallowNMI = 0;
|
| 1076 | | common_chess_start();
|
| 1077 | | }
|
| 1078 | | |
| 1079 | | SCREEN_UPDATE( chess_lcd )
|
| 1080 | | {
|
| 1081 | | hd44780_device * hd44780 = screen->machine().device<hd44780_device>("hd44780");
|
| 1082 | | return hd44780->video_update(bitmap, cliprect );
|
| 1083 | | }
|
| 1084 | | |
| 1085 | | static PALETTE_INIT( chess_lcd )
|
| 1086 | | {
|
| 1087 | | // palette_set_color(machine, 0, MAKE_RGB(138, 146, 148)); // some think this is closer, but slightly less readable
|
| 1088 | | palette_set_color(machine, 0, MAKE_RGB(255, 255, 255));
|
| 1089 | | palette_set_color(machine, 1, MAKE_RGB(0, 0, 0));
|
| 1090 | | }
|
| 1091 | | |
| 1092 | | static const gfx_layout chess_charlayout =
|
| 1093 | | {
|
| 1094 | | 5, 8, /* 5 x 8 characters */
|
| 1095 | | 224, /* 224 characters */
|
| 1096 | | 1, /* 1 bits per pixel */
|
| 1097 | | { 0 }, /* no bitplanes */
|
| 1098 | | { 3, 4, 5, 6, 7},
|
| 1099 | | { 0, 8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8},
|
| 1100 | | 8*8 /* 8 bytes */
|
| 1101 | | };
|
| 1102 | | |
| 1103 | | static GFXDECODE_START( chess_lcd )
|
| 1104 | | GFXDECODE_ENTRY( "hd44780", 0x0000, chess_charlayout, 0, 1 )
|
| 1105 | | GFXDECODE_END
|
| 1106 | | |
| 1107 | | static ADDRESS_MAP_START(polgar_mem , AS_PROGRAM, 8)
|
| 1108 | | AM_RANGE( 0x0000, 0x1fff ) AM_RAM
|
| 1109 | | AM_RANGE( 0x2400, 0x2400 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard
|
| 1110 | | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( mboard_write_board_8) // Chessboard
|
| 1111 | | AM_RANGE( 0x3000, 0x3000 ) AM_READ ( mboard_read_board_8 ) // Chessboard
|
| 1112 | | AM_RANGE( 0x3400, 0x3405 ) AM_WRITE( polgar_write_LED) // Function LEDs
|
| 1113 | | AM_RANGE( 0x2c00, 0x2c07 ) AM_READ ( read_keys)
|
| 1114 | | AM_RANGE( 0x2004, 0x2004 ) AM_WRITE ( write_polgar_IO ) // LCD Instr. Reg + Beeper
|
| 1115 | | AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( write_LCD_polgar ) // LCD Char Reg.
|
| 1116 | | AM_RANGE( 0x4000, 0xffff ) AM_ROM
|
| 1117 | | ADDRESS_MAP_END
|
| 1118 | | |
| 1119 | | static ADDRESS_MAP_START(sfortea_mem , AS_PROGRAM, 8)
|
| 1120 | | AM_RANGE( 0x0000, 0x1fef ) AM_RAM
|
| 1121 | | AM_RANGE( 0x1ff6, 0x1ff6 ) AM_WRITE ( write_latch_sfortea) // IO control
|
| 1122 | | AM_RANGE( 0x1ff7, 0x1ff7 ) AM_WRITE ( write_lcd_IO_sfortea) // LCD Char Reg.
|
| 1123 | | // AM_RANGE( 0x1ffc, 0x1fff ) AM_DEVREADWRITE("acia65c51", acia_6551_r,acia_6551_w)
|
| 1124 | | AM_RANGE( 0x1ff1, 0x1ff1 ) AM_READ ( read_1ff1_sfortea )
|
| 1125 | | AM_RANGE( 0x1ff0, 0x1ff0 ) AM_READ ( read_1ff0_sfortea )
|
| 1126 | | AM_RANGE( 0x2000, 0xffff ) AM_ROM
|
| 1127 | | ADDRESS_MAP_END
|
| 1128 | | |
| 1129 | | |
| 1130 | | static ADDRESS_MAP_START(gen32_mem, AS_PROGRAM, 32)
|
| 1131 | | |
| 1132 | | AM_RANGE( 0x00000000, 0x0003ffff ) AM_ROM
|
| 1133 | | |
| 1134 | | AM_RANGE( 0xc0000000 , 0xc0000003 ) AM_READ ( mboard_read_board_32 )
|
| 1135 | | AM_RANGE( 0xc8000000 , 0xc8000003 ) AM_WRITE ( mboard_write_board_32 )
|
| 1136 | | AM_RANGE( 0xc8000004 , 0xc8000007 ) AM_WRITE ( mboard_write_board_32 )
|
| 1137 | | AM_RANGE( 0xd0000000 , 0xd0000003 ) AM_WRITE ( mboard_write_LED_32 )
|
| 1138 | | AM_RANGE( 0xd0000004 , 0xd0000007 ) AM_WRITE ( mboard_write_LED_32 )
|
| 1139 | | AM_RANGE( 0xf0000004 , 0xf0000013 ) AM_READ ( read_buttons_gen32 )
|
| 1140 | | AM_RANGE( 0xe0000000 , 0xe0000003 ) AM_WRITE ( write_LCD_data_32 )
|
| 1141 | | AM_RANGE( 0xe0000010 , 0xe0000013 ) AM_WRITE ( write_IOenables_32 )
|
| 1142 | | AM_RANGE( 0xd8000008 , 0xd800000b ) AM_WRITE ( write_unknown2_32 )
|
| 1143 | | AM_RANGE( 0xd8000004 , 0xd8000007 ) AM_READ ( read_unknown1_32 )
|
| 1144 | | AM_RANGE( 0xd800000c , 0xd800000f ) AM_READ ( read_unknown3_32 )
|
| 1145 | | |
| 1146 | | AM_RANGE( 0x40000000, 0x4007ffff ) AM_RAM /* 512KB */
|
| 1147 | | AM_RANGE( 0x80000000, 0x8003ffff ) AM_RAM /* 256KB */
|
| 1148 | | AM_RANGE( 0xe8000000, 0xe8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram")
|
| 1149 | | |
| 1150 | | ADDRESS_MAP_END
|
| 1151 | | |
| 1152 | | static ADDRESS_MAP_START(bpl32_mem, AS_PROGRAM, 32)
|
| 1153 | | |
| 1154 | | AM_RANGE( 0x000000, 0x03ffff ) AM_ROM
|
| 1155 | | AM_RANGE( 0x800000 , 0x800003 ) AM_READ ( read_keys_BPL32 )
|
| 1156 | | AM_RANGE( 0x900000 , 0x900003 ) AM_WRITE ( write_board_BPL32 )
|
| 1157 | | AM_RANGE( 0xa00000 , 0xa00003 ) AM_WRITE ( write_LED_BPL32 )
|
| 1158 | | AM_RANGE( 0xc00000 , 0xc00003 ) AM_WRITE ( write_LCD_data_32 )
|
| 1159 | | AM_RANGE( 0xb00000 , 0xb00003 ) AM_WRITE ( write_IOenables_32 )
|
| 1160 | | AM_RANGE( 0x400000 , 0x4fffff ) AM_RAM /* 1024KB */
|
| 1161 | | AM_RANGE( 0xd00000 , 0xd07fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram")
|
| 1162 | | |
| 1163 | | ADDRESS_MAP_END
|
| 1164 | | |
| 1165 | | static ADDRESS_MAP_START(van32_mem, AS_PROGRAM, 32)
|
| 1166 | | |
| 1167 | | AM_RANGE( 0x00000000, 0x0003ffff ) AM_ROM
|
| 1168 | | |
| 1169 | | AM_RANGE( 0x800000fc , 0x800000ff ) AM_READ ( mboard_read_board_32 )
|
| 1170 | | AM_RANGE( 0x88000000 , 0x88000007 ) AM_WRITE ( mboard_write_board_32 )
|
| 1171 | | AM_RANGE( 0x90000000 , 0x90000007 ) AM_WRITE ( mboard_write_LED_32 )
|
| 1172 | | AM_RANGE( 0x800000ec , 0x800000ff ) AM_READ ( read_buttons_van32 )
|
| 1173 | | AM_RANGE( 0xa0000000 , 0xa0000003 ) AM_WRITE ( write_LCD_data_32 )
|
| 1174 | | AM_RANGE( 0xa0000010 , 0xa0000013 ) AM_WRITE ( write_IOenables_32 )
|
| 1175 | | AM_RANGE( 0x98000008 , 0x9800000b ) AM_WRITE ( write_unknown2_32 )
|
| 1176 | | AM_RANGE( 0x98000004 , 0x98000007 ) AM_READ ( read_unknown1_32 )
|
| 1177 | | AM_RANGE( 0x9800000c , 0x9800000f ) AM_READ ( read_unknown3_32 )
|
| 1178 | | |
| 1179 | | AM_RANGE( 0x40000000, 0x400fffff ) AM_RAM /* 1024KB */
|
| 1180 | | AM_RANGE( 0xa8000000, 0xa8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram")
|
| 1181 | | |
| 1182 | | ADDRESS_MAP_END
|
| 1183 | | |
| 1184 | | |
| 1185 | | static ADDRESS_MAP_START(alm32_mem, AS_PROGRAM, 32)
|
| 1186 | | |
| 1187 | | AM_RANGE( 0x00000000, 0x0001ffff ) AM_ROM
|
| 1188 | | |
| 1189 | | AM_RANGE( 0x800000fc , 0x800000ff ) AM_READ ( mboard_read_board_32 )
|
| 1190 | | AM_RANGE( 0x88000000 , 0x88000007 ) AM_WRITE ( mboard_write_board_32 )
|
| 1191 | | AM_RANGE( 0x90000000 , 0x90000007 ) AM_WRITE ( mboard_write_LED_32 )
|
| 1192 | | AM_RANGE( 0x800000ec , 0x800000ff ) AM_READ ( read_buttons_van32 )
|
| 1193 | | AM_RANGE( 0xa0000000 , 0xa0000003 ) AM_WRITE ( write_LCD_data_32 )
|
| 1194 | | AM_RANGE( 0xa0000010 , 0xa0000013 ) AM_WRITE ( write_IOenables_32 )
|
| 1195 | | AM_RANGE( 0x98000008 , 0x9800000b ) AM_WRITE ( write_unknown2_32 )
|
| 1196 | | AM_RANGE( 0x98000004 , 0x98000007 ) AM_READ ( read_unknown1_32 )
|
| 1197 | | AM_RANGE( 0x9800000c , 0x9800000f ) AM_READ ( read_unknown3_32 )
|
| 1198 | | |
| 1199 | | AM_RANGE( 0x40000000, 0x400fffff ) AM_RAM
|
| 1200 | | AM_RANGE( 0xa8000000, 0xa8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram")
|
| 1201 | | |
| 1202 | | ADDRESS_MAP_END
|
| 1203 | | |
| 1204 | | static ADDRESS_MAP_START(risc_mem, AS_PROGRAM, 32)
|
| 1205 | | |
| 1206 | | AM_RANGE( 0x02000000, 0x0201ffff ) AM_ROM AM_REGION("maincpu", 0) // AM_MIRROR(0x2000000)
|
| 1207 | | AM_RANGE( 0x01000000, 0x01000003 ) AM_WRITE ( write_1000000 )
|
| 1208 | | AM_RANGE( 0x01800000, 0x01800003 ) AM_READ ( read_1800000 )
|
| 1209 | | AM_RANGE( 0x00000000, 0x0001ffff ) AM_RAM
|
| 1210 | | |
| 1211 | | ADDRESS_MAP_END
|
| 1212 | | |
| 1213 | | static ADDRESS_MAP_START(van16_mem, AS_PROGRAM, 16)
|
| 1214 | | |
| 1215 | | AM_RANGE( 0x000000, 0x03ffff ) AM_ROM
|
| 1216 | | |
| 1217 | | AM_RANGE( 0xc00000 , 0xc00001 ) AM_READ ( mboard_read_board_16 )
|
| 1218 | | AM_RANGE( 0xc80000 , 0xc80001 ) AM_WRITE ( mboard_write_board_16 )
|
| 1219 | | AM_RANGE( 0xd00000 , 0xd00001 ) AM_WRITE ( mboard_write_LED_16 )
|
| 1220 | | AM_RANGE( 0xf00000 , 0xf00009 ) AM_READ ( read_buttons_van16 )
|
| 1221 | | AM_RANGE( 0xd80000 , 0xd80001 ) AM_WRITE ( write_LCD_data )
|
| 1222 | | AM_RANGE( 0xd80008 , 0xd80009 ) AM_WRITE ( write_IOenables )
|
| 1223 | | AM_RANGE( 0xe80004 , 0xe80005 ) AM_WRITE ( write_unknown2 )
|
| 1224 | | AM_RANGE( 0xe80002 , 0xe80003 ) AM_READ ( read_unknown1 )
|
| 1225 | | AM_RANGE( 0xe80006 , 0xe80007 ) AM_READ ( read_unknown3 )
|
| 1226 | | |
| 1227 | | AM_RANGE( 0x400000, 0x47ffff ) AM_RAM /* 512KB */
|
| 1228 | | AM_RANGE( 0x800000, 0x803fff ) AM_RAM AM_BASE(&save_ram) AM_SHARE("nvram")
|
| 1229 | | |
| 1230 | | ADDRESS_MAP_END
|
| 1231 | | |
| 1232 | | static ADDRESS_MAP_START(alm16_mem, AS_PROGRAM, 16)
|
| 1233 | | |
| 1234 | | AM_RANGE( 0x000000, 0x01ffff ) AM_ROM
|
| 1235 | | |
| 1236 | | AM_RANGE( 0xc00000 , 0xc00001 ) AM_READ ( mboard_read_board_16 )
|
| 1237 | | AM_RANGE( 0xc80000 , 0xc80001 ) AM_WRITE ( mboard_write_board_16 )
|
| 1238 | | AM_RANGE( 0xd00000 , 0xd00001 ) AM_WRITE ( mboard_write_LED_16 )
|
| 1239 | | AM_RANGE( 0xf00000 , 0xf00009 ) AM_READ ( read_buttons_van16 )
|
| 1240 | | AM_RANGE( 0xd80000 , 0xd80001 ) AM_WRITE ( write_LCD_data )
|
| 1241 | | AM_RANGE( 0xd80008 , 0xd80009 ) AM_WRITE ( write_IOenables )
|
| 1242 | | // AM_RANGE( 0xe80004 , 0xe80005 ) AM_WRITE ( write_unknown2 )
|
| 1243 | | // AM_RANGE( 0xe80002 , 0xe80003 ) AM_READ ( read_unknown1 )
|
| 1244 | | // AM_RANGE( 0xe80006 , 0xe80007 ) AM_READ ( read_unknown3 )
|
| 1245 | | |
| 1246 | | |
| 1247 | | AM_RANGE( 0x400000, 0x47ffff ) AM_RAM /* 512KB */
|
| 1248 | | AM_RANGE( 0x800000, 0x803fff ) AM_RAM AM_BASE(&save_ram) AM_SHARE("nvram")
|
| 1249 | | ADDRESS_MAP_END
|
| 1250 | | |
| 1251 | | |
| 1252 | | static ADDRESS_MAP_START(milano_mem , AS_PROGRAM, 8)
|
| 1253 | | AM_RANGE( 0x0000, 0x1f9f ) AM_RAM
|
| 1254 | | AM_RANGE( 0x1fd0, 0x1fd0 ) AM_WRITE ( milano_write_board ) // Chessboard
|
| 1255 | | AM_RANGE( 0x1fe0, 0x1fe0 ) AM_READ ( milano_read_board ) // Chessboard
|
| 1256 | | AM_RANGE( 0x1fe8, 0x1fed ) AM_WRITE ( milano_write_LED ) // Function LEDs
|
| 1257 | | AM_RANGE( 0x1fd8, 0x1fdf ) AM_READ ( read_keys)
|
| 1258 | | AM_RANGE( 0x1ff0, 0x1ff0 ) AM_WRITE ( write_polgar_IO) // IO control
|
| 1259 | | AM_RANGE( 0x1fc0, 0x1fc0 ) AM_WRITE ( write_LCD_polgar) // LCD Char Reg. (latched)
|
| 1260 | | AM_RANGE( 0x2000, 0xffff ) AM_ROM
|
| 1261 | | ADDRESS_MAP_END
|
| 1262 | | |
| 1263 | | |
| 1264 | | static ADDRESS_MAP_START(finalchs_mem , AS_PROGRAM, 8)
|
| 1265 | | AM_RANGE( 0x0000, 0x1fff ) AM_RAM
|
| 1266 | | AM_RANGE( 0x7ff8, 0x7ff8 ) AM_READ(io7ff8_read)
|
| 1267 | | AM_RANGE( 0x7ff8, 0x7ff8 ) AM_WRITE(io7ff8_write)
|
| 1268 | | AM_RANGE( 0x6000, 0x6000 ) AM_READ(io6000_read)
|
| 1269 | | AM_RANGE( 0x6000, 0x6000 ) AM_WRITE(io6000_write)
|
| 1270 | | AM_RANGE( 0x8000, 0xffff ) AM_ROM
|
| 1271 | | ADDRESS_MAP_END
|
| 1272 | | |
| 1273 | | static ADDRESS_MAP_START(academy_mem , AS_PROGRAM, 8)
|
| 1274 | | AM_RANGE( 0x0000, 0x1fff ) AM_RAM
|
| 1275 | | AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_academy )
|
| 1276 | | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( academy_write_board ) // Chessboard
|
| 1277 | | AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard
|
| 1278 | | AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy )
|
| 1279 | | AM_RANGE( 0x3001, 0x3001 ) AM_WRITE ( academy_inhibitNMI )
|
| 1280 | | AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED )
|
| 1281 | | AM_RANGE( 0x3800, 0x3801 ) AM_WRITE ( write_LCD_academy )
|
| 1282 | | AM_RANGE( 0x4000, 0xffff ) AM_ROM
|
| 1283 | | ADDRESS_MAP_END
|
| 1284 | | |
| 1285 | | static ADDRESS_MAP_START(monteciv_mem , AS_PROGRAM, 8)
|
| 1286 | | AM_RANGE( 0x0000, 0x1fff ) AM_RAM
|
| 1287 | | AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_monteciv )
|
| 1288 | | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( academy_write_board ) // Chessboard
|
| 1289 | | AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard
|
| 1290 | | AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED ) // Status LEDs
|
| 1291 | | AM_RANGE( 0x3000, 0x3001 ) AM_WRITE ( monteciv_select_line ) // Select Keyline
|
| 1292 | | AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy )
|
| 1293 | | AM_RANGE( 0x3004, 0x3004 ) AM_WRITE ( monteciv_write_LCD )
|
| 1294 | | AM_RANGE( 0x3005, 0x3005 ) AM_WRITE ( monteciv_3005 )
|
| 1295 | | AM_RANGE( 0x3007, 0x3007 ) AM_WRITE ( monteciv_3007 )
|
| 1296 | | AM_RANGE( 0x3006, 0x3006 ) AM_WRITE ( monteciv_3006 )
|
| 1297 | | AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( academy_inhibitNMI )
|
| 1298 | | AM_RANGE( 0x8000, 0xffff ) AM_ROM
|
| 1299 | | ADDRESS_MAP_END
|
| 1300 | | |
| 1301 | | static ADDRESS_MAP_START(megaiv_mem , AS_PROGRAM, 8)
|
| 1302 | | AM_RANGE( 0x0000, 0x1fff ) AM_RAM
|
| 1303 | | /// AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_monteciv )
|
| 1304 | | AM_RANGE( 0x6800, 0x6800 ) AM_WRITE ( academy_write_board ) // 2800 // Chessboard
|
| 1305 | | /// AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard
|
| 1306 | | /// AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED ) // Status LEDs
|
| 1307 | | AM_RANGE( 0x4400, 0x4400 ) AM_WRITE ( megaiv_write_LED ) // 2400 // Select Keyline
|
| 1308 | | AM_RANGE( 0x7000, 0x7001 ) AM_WRITE ( megaiv_IO ) // Select Keyline
|
| 1309 | | /// AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy )
|
| 1310 | | AM_RANGE( 0x4000, 0x4007 ) AM_READ ( read_keys_megaiv ) // 3000-7 fixio
|
| 1311 | | AM_RANGE( 0x2c04, 0x2c04 ) AM_WRITE ( monteciv_write_LCD ) // 2c04
|
| 1312 | | AM_RANGE( 0x2c05, 0x2c05 ) AM_WRITE ( monteciv_3005 ) // 2c05
|
| 1313 | | AM_RANGE( 0x2c07, 0x2c07 ) AM_WRITE ( monteciv_3007 ) // 2c07
|
| 1314 | | AM_RANGE( 0x2c06, 0x2c06 ) AM_WRITE ( monteciv_3006 ) // 2c06
|
| 1315 | | /// AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( academy_inhibitNMI )
|
| 1316 | | AM_RANGE( 0x8000, 0xffff ) AM_ROM
|
| 1317 | | ADDRESS_MAP_END
|
| 1318 | | |
| 1319 | | static ADDRESS_MAP_START(diablo68_mem , AS_PROGRAM, 16)
|
| 1320 | | AM_RANGE( 0x00000000, 0x0000ffff ) AM_ROM // OS
|
| 1321 | | // AM_RANGE( 0x00200000, 0x0020ffff ) AM_ROM AM_REGION("maincpu", 0)
|
| 1322 | | AM_RANGE( 0x00ff0000, 0x00ff7fff ) AM_ROM AM_REGION("maincpu",10000) // Opening Book
|
| 1323 | | // AM_RANGE( 0x00300000, 0x00300007 ) AM_READ(diablo68_aciaread)
|
| 1324 | | // AM_RANGE( 0x00300000, 0x00300007 ) AM_READ(diablo68_aciawrite)
|
| 1325 | | // AM_RANGE( 0x00300002, 0x00300003 ) AM_READ(diablo68_flags)
|
| 1326 | | AM_RANGE( 0x003a0000, 0x003a0001 ) AM_WRITE(diablo68_write_LCD)
|
| 1327 | | AM_RANGE( 0x003c0000, 0x003c0001 ) AM_WRITE(diablo68_reg_select)
|
| 1328 | | AM_RANGE( 0x00280000, 0x0028ffff ) AM_RAM // hash tables
|
| 1329 | | AM_RANGE( 0x00ff8000, 0x00ffffff ) AM_RAM
|
| 1330 | | ADDRESS_MAP_END
|
| 1331 | | |
| 1332 | | |
| 1333 | | /* Input ports */
|
| 1334 | | |
| 1335 | | static INPUT_PORTS_START( polgar )
|
| 1336 | | |
| 1337 | | PORT_START("KEY1_0") //Port $2c00
|
| 1338 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1)
|
| 1339 | | PORT_START("KEY1_1") //Port $2c01
|
| 1340 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2)
|
| 1341 | | PORT_START("KEY1_2") //Port $2c02
|
| 1342 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3)
|
| 1343 | | PORT_START("KEY1_3") //Port $2c03
|
| 1344 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4)
|
| 1345 | | PORT_START("KEY1_4") //Port $2c04
|
| 1346 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5)
|
| 1347 | | PORT_START("KEY1_5") //Port $2c05
|
| 1348 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6)
|
| 1349 | | PORT_START("KEY1_6") //Port $2c06
|
| 1350 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7)
|
| 1351 | | PORT_START("KEY1_7") //Port $2c07
|
| 1352 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8)
|
| 1353 | | // PORT_START("KEY1_8")
|
| 1354 | | // PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" A") PORT_CODE(KEYCODE_1)
|
| 1355 | | |
| 1356 | | PORT_INCLUDE( chessboard )
|
| 1357 | | |
| 1358 | | INPUT_PORTS_END
|
| 1359 | | |
| 1360 | | static INPUT_PORTS_START( sfortea )
|
| 1361 | | PORT_START("BUTTONS_SFOR1")
|
| 1362 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_1)
|
| 1363 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_2)
|
| 1364 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_3)
|
| 1365 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_4)
|
| 1366 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_5)
|
| 1367 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_6)
|
| 1368 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7)
|
| 1369 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_8)
|
| 1370 | | |
| 1371 | | PORT_START("BUTTONS_SFOR2")
|
| 1372 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_F1)
|
| 1373 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_F2)
|
| 1374 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_F3)
|
| 1375 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_F4)
|
| 1376 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_F5)
|
| 1377 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_F6)
|
| 1378 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_F7)
|
| 1379 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_F8)
|
| 1380 | | |
| 1381 | | /* PORT_START("BUTTONS_SFOR3")
|
| 1382 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_1)
|
| 1383 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_2)
|
| 1384 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_3)
|
| 1385 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_4)
|
| 1386 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_5)
|
| 1387 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_6)
|
| 1388 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7)
|
| 1389 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_8)
|
| 1390 | | */
|
| 1391 | | |
| 1392 | | PORT_INCLUDE( chessboard )
|
| 1393 | | INPUT_PORTS_END
|
| 1394 | | |
| 1395 | | static INPUT_PORTS_START( academy )
|
| 1396 | | PORT_START("BUTTONS_ACAD")
|
| 1397 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1)
|
| 1398 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2)
|
| 1399 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3)
|
| 1400 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4)
|
| 1401 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5)
|
| 1402 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6)
|
| 1403 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7)
|
| 1404 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8)
|
| 1405 | | |
| 1406 | | PORT_INCLUDE( chessboard )
|
| 1407 | | INPUT_PORTS_END
|
| 1408 | | |
| 1409 | | static INPUT_PORTS_START( megaiv )
|
| 1410 | | |
| 1411 | | PORT_START("KEY1_0") //Port $2c00
|
| 1412 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1)
|
| 1413 | | PORT_START("KEY1_1") //Port $2c01
|
| 1414 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2) // mem
|
| 1415 | | PORT_START("KEY1_2") //Port $2c02
|
| 1416 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3)
|
| 1417 | | PORT_START("KEY1_3") //Port $2c03
|
| 1418 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4)
|
| 1419 | | PORT_START("KEY1_4") //Port $2c04
|
| 1420 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5)
|
| 1421 | | PORT_START("KEY1_5") //Port $2c05
|
| 1422 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6)
|
| 1423 | | PORT_START("KEY1_6") //Port $2c06
|
| 1424 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7)
|
| 1425 | | PORT_START("KEY1_7") //Port $2c07
|
| 1426 | | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8)
|
| 1427 | | // PORT_START("KEY1_8")
|
| 1428 | | // PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" A") PORT_CODE(KEYCODE_1)
|
| 1429 | | |
| 1430 | | PORT_INCLUDE( chessboard )
|
| 1431 | | |
| 1432 | | INPUT_PORTS_END
|
| 1433 | | |
| 1434 | | |
| 1435 | | static INPUT_PORTS_START( monteciv )
|
| 1436 | | PORT_START("BUTTONS_MONTE1")
|
| 1437 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 1 Pawn") PORT_CODE(KEYCODE_F1)
|
| 1438 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 2 Knight") PORT_CODE(KEYCODE_F2)
|
| 1439 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 3 Bishop") PORT_CODE(KEYCODE_F3)
|
| 1440 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 4 Rook") PORT_CODE(KEYCODE_F4)
|
| 1441 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 5 Queen") PORT_CODE(KEYCODE_F5)
|
| 1442 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 6 King") PORT_CODE(KEYCODE_F6)
|
| 1443 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 7 Black") PORT_CODE(KEYCODE_F7)
|
| 1444 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 8 White") PORT_CODE(KEYCODE_F8)
|
| 1445 | | |
| 1446 | | PORT_START("BUTTONS_MONTE2")
|
| 1447 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("9 Book") PORT_CODE(KEYCODE_1)
|
| 1448 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0 Pos") PORT_CODE(KEYCODE_2)
|
| 1449 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Mem") PORT_CODE(KEYCODE_3)
|
| 1450 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Info") PORT_CODE(KEYCODE_4)
|
| 1451 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Clear") PORT_CODE(KEYCODE_5)
|
| 1452 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Level") PORT_CODE(KEYCODE_6)
|
| 1453 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Enter") PORT_CODE(KEYCODE_7)
|
| 1454 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Reset") PORT_CODE(KEYCODE_8)
|
| 1455 | | |
| 1456 | | |
| 1457 | | PORT_INCLUDE( chessboard )
|
| 1458 | | INPUT_PORTS_END
|
| 1459 | | |
| 1460 | | |
| 1461 | | static INPUT_PORTS_START( gen32 )
|
| 1462 | | |
| 1463 | | PORT_START("BUTTON_1")
|
| 1464 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT)
|
| 1465 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER)
|
| 1466 | | |
| 1467 | | PORT_START("BUTTON_2")
|
| 1468 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN)
|
| 1469 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP)
|
| 1470 | | |
| 1471 | | PORT_START("BUTTON_3")
|
| 1472 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT)
|
| 1473 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH)
|
| 1474 | | |
| 1475 | | PORT_INCLUDE( chessboard )
|
| 1476 | | |
| 1477 | | INPUT_PORTS_END
|
| 1478 | | |
| 1479 | | static INPUT_PORTS_START( bpl32 )
|
| 1480 | | PORT_START("BUTTONS_BPL")
|
| 1481 | | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7)
|
| 1482 | | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_6)
|
| 1483 | | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT)
|
| 1484 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER)
|
| 1485 | | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN)
|
| 1486 | | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP)
|
| 1487 | | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT)
|
| 1488 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH)
|
| 1489 | | |
| 1490 | | PORT_INCLUDE( chessboard )
|
| 1491 | | INPUT_PORTS_END
|
| 1492 | | |
| 1493 | | |
| 1494 | | |
| 1495 | | static INPUT_PORTS_START( van32 )
|
| 1496 | | |
| 1497 | | PORT_START("BUTTON_3")
|
| 1498 | | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT)
|
| 1499 | | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER)
|
| 1500 | | |
| 1501 | | PORT_START("BUTTON_2")
|
| 1502 | | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN)
|
| 1503 | | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP)
|
| 1504 | | |
| 1505 | | PORT_START("BUTTON_1")
|
| 1506 | | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT)
|
| 1507 | | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH)
|
| 1508 | | |
| 1509 | | PORT_INCLUDE( chessboard )
|
| 1510 | | |
| 1511 | | INPUT_PORTS_END
|
| 1512 | | |
| 1513 | | static INPUT_PORTS_START( van16 )
|
| 1514 | | |
| 1515 | | PORT_START("BUTTON_1")
|
| 1516 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT)
|
| 1517 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER)
|
| 1518 | | |
| 1519 | | PORT_START("BUTTON_2")
|
| 1520 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT)
|
| 1521 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP)
|
| 1522 | | |
| 1523 | | PORT_START("BUTTON_3")
|
| 1524 | | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN)
|
| 1525 | | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH)
|
| 1526 | | |
| 1527 | | PORT_INCLUDE( chessboard )
|
| 1528 | | |
| 1529 | | INPUT_PORTS_END
|
| 1530 | | |
| 1531 | | static MACHINE_CONFIG_FRAGMENT ( chess_common )
|
| 1532 | | |
| 1533 | | /* video hardware */
|
| 1534 | | |
| 1535 | | MCFG_SCREEN_ADD("screen", RASTER)
|
| 1536 | | MCFG_SCREEN_REFRESH_RATE(50)
|
| 1537 | | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 1538 | | MCFG_SCREEN_SIZE(100, 22)
|
| 1539 | | MCFG_SCREEN_VISIBLE_AREA(0, 100-1, 0, 22-3)
|
| 1540 | | MCFG_SCREEN_UPDATE(chess_lcd)
|
| 1541 | | MCFG_PALETTE_LENGTH(2)
|
| 1542 | | MCFG_PALETTE_INIT(chess_lcd)
|
| 1543 | | MCFG_QUANTUM_TIME(attotime::from_hz(60))
|
| 1544 | | MCFG_GFXDECODE(chess_lcd)
|
| 1545 | | |
| 1546 | | MCFG_HD44780_ADD("hd44780", chess_display)
|
| 1547 | | |
| 1548 | | MCFG_DEFAULT_LAYOUT(layout_lcd)
|
| 1549 | | |
| 1550 | | /* sound hardware */
|
| 1551 | | MCFG_SPEAKER_STANDARD_MONO("mono")
|
| 1552 | | MCFG_SOUND_ADD("beep", BEEP, 0)
|
| 1553 | | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
|
| 1554 | | |
| 1555 | | MACHINE_CONFIG_END
|
| 1556 | | |
| 1557 | | static MACHINE_CONFIG_START( polgar, polgar_state )
|
| 1558 | | MCFG_CPU_ADD("maincpu",M65C02,4915200)
|
| 1559 | | MCFG_CPU_PROGRAM_MAP(polgar_mem)
|
| 1560 | | MCFG_QUANTUM_TIME(attotime::from_hz(60))
|
| 1561 | | MCFG_MACHINE_START( polgar )
|
| 1562 | | MCFG_MACHINE_RESET( polgar )
|
| 1563 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1564 | | |
| 1565 | | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_nmi, attotime::from_hz(600))
|
| 1566 | | MCFG_TIMER_START_DELAY(attotime::from_hz(60))
|
| 1567 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100))
|
| 1568 | | |
| 1569 | | MACHINE_CONFIG_END
|
| 1570 | | |
| 1571 | | static MACHINE_CONFIG_START( sfortea, driver_device )
|
| 1572 | | MCFG_CPU_ADD("maincpu",M65C02,5000000)
|
| 1573 | | MCFG_CPU_PROGRAM_MAP(sfortea_mem)
|
| 1574 | | MCFG_QUANTUM_TIME(attotime::from_hz(60))
|
| 1575 | | MCFG_MACHINE_START( sfortea )
|
| 1576 | | MCFG_MACHINE_RESET( sfortea )
|
| 1577 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1578 | | |
| 1579 | | /* acia */
|
| 1580 | | // MCFG_ACIA6551_ADD("acia65c51")
|
| 1581 | | |
| 1582 | | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_M6502_irq, attotime::from_hz(600))
|
| 1583 | | MCFG_TIMER_START_DELAY(attotime::from_hz(60))
|
| 1584 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100))
|
| 1585 | | MACHINE_CONFIG_END
|
| 1586 | | |
| 1587 | | static MACHINE_CONFIG_START( alm32, driver_device )
|
| 1588 | | MCFG_CPU_ADD("maincpu", M68020, XTAL_12MHz)
|
| 1589 | | MCFG_CPU_PROGRAM_MAP(alm32_mem)
|
| 1590 | | MCFG_MACHINE_START(van32)
|
| 1591 | | MCFG_MACHINE_RESET(van16)
|
| 1592 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750))
|
| 1593 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1594 | | |
| 1595 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1596 | | MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1597 | | |
| 1598 | | MACHINE_CONFIG_END
|
| 1599 | | |
| 1600 | | static MACHINE_CONFIG_DERIVED( academy, polgar )
|
| 1601 | | MCFG_CPU_MODIFY("maincpu")
|
| 1602 | | MCFG_CPU_PROGRAM_MAP(academy_mem)
|
| 1603 | | MCFG_MACHINE_RESET( academy )
|
| 1604 | | MCFG_DEVICE_REMOVE("int_timer")
|
| 1605 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq_academy, attotime::from_hz(600))
|
| 1606 | | |
| 1607 | | MACHINE_CONFIG_END
|
| 1608 | | |
| 1609 | | static MACHINE_CONFIG_START( finalchs, driver_device )
|
| 1610 | | MCFG_CPU_ADD("maincpu",M65C02,5000000)
|
| 1611 | | MCFG_CPU_PROGRAM_MAP(finalchs_mem)
|
| 1612 | | MCFG_MACHINE_START(finalchs)
|
| 1613 | | MCFG_SCREEN_ADD("screen", RASTER)
|
| 1614 | | MCFG_SCREEN_REFRESH_RATE(50)
|
| 1615 | | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16)
|
| 1616 | | MCFG_SCREEN_SIZE(6*16, 9*2)
|
| 1617 | | MCFG_SCREEN_VISIBLE_AREA(0, 6*16-1, 0, 9*2-1)
|
| 1618 | | MCFG_PALETTE_LENGTH(2)
|
| 1619 | | MCFG_PALETTE_INIT(chess_lcd)
|
| 1620 | | |
| 1621 | | MACHINE_CONFIG_END
|
| 1622 | | |
| 1623 | | static MACHINE_CONFIG_DERIVED( milano, polgar )
|
| 1624 | | MCFG_CPU_MODIFY("maincpu")
|
| 1625 | | MCFG_CPU_PROGRAM_MAP(milano_mem)
|
| 1626 | | MACHINE_CONFIG_END
|
| 1627 | | |
| 1628 | | |
| 1629 | | static MACHINE_CONFIG_START( monteciv, driver_device )
|
| 1630 | | MCFG_CPU_ADD("maincpu",M65C02,8000000)
|
| 1631 | | MCFG_CPU_PROGRAM_MAP( monteciv_mem )
|
| 1632 | | MCFG_MACHINE_START( polgar )
|
| 1633 | | MCFG_MACHINE_RESET( monteciv )
|
| 1634 | | MCFG_SPEAKER_STANDARD_MONO("mono")
|
| 1635 | | MCFG_SOUND_ADD("beep", BEEP, 0)
|
| 1636 | | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0)
|
| 1637 | | |
| 1638 | | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_nmi, attotime::from_hz(600))
|
| 1639 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100))
|
| 1640 | | |
| 1641 | | MACHINE_CONFIG_END
|
| 1642 | | |
| 1643 | | static MACHINE_CONFIG_DERIVED( megaiv, monteciv )
|
| 1644 | | MCFG_CPU_MODIFY("maincpu")
|
| 1645 | | MCFG_CPU_CLOCK( 4915200 )
|
| 1646 | | MCFG_CPU_PROGRAM_MAP(megaiv_mem)
|
| 1647 | | MACHINE_CONFIG_END
|
| 1648 | | |
| 1649 | | static MACHINE_CONFIG_START( diablo68, driver_device )
|
| 1650 | | MCFG_CPU_ADD("maincpu", M68000, XTAL_16MHz)
|
| 1651 | | MCFG_CPU_PROGRAM_MAP(diablo68_mem)
|
| 1652 | | MCFG_MACHINE_START(diablo68)
|
| 1653 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1654 | | |
| 1655 | | /* acia */
|
| 1656 | | // MCFG_ACIA6551_ADD("acia65c51")
|
| 1657 | | |
| 1658 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq2, attotime::from_hz(60))
|
| 1659 | | MCFG_TIMER_START_DELAY(attotime::from_hz(30))
|
| 1660 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1661 | | |
| 1662 | | |
| 1663 | | MACHINE_CONFIG_END
|
| 1664 | | |
| 1665 | | static MACHINE_CONFIG_START( van16, driver_device )
|
| 1666 | | MCFG_CPU_ADD("maincpu", M68000, XTAL_12MHz)
|
| 1667 | | MCFG_CPU_PROGRAM_MAP(van16_mem)
|
| 1668 | | MCFG_MACHINE_START(van16)
|
| 1669 | | MCFG_MACHINE_RESET(van16)
|
| 1670 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(600)) // chess clock right, diags wrong
|
| 1671 | | // MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(587)) // vv
|
| 1672 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1673 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1674 | | MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1675 | | |
| 1676 | | MACHINE_CONFIG_END
|
| 1677 | | |
| 1678 | | static MACHINE_CONFIG_DERIVED( alm16, van16 )
|
| 1679 | | MCFG_CPU_MODIFY("maincpu")
|
| 1680 | | MCFG_CPU_PROGRAM_MAP(alm16_mem)
|
| 1681 | | MACHINE_CONFIG_END
|
| 1682 | | |
| 1683 | | static MACHINE_CONFIG_START( van32, driver_device )
|
| 1684 | | MCFG_CPU_ADD("maincpu", M68020, XTAL_12MHz)
|
| 1685 | | MCFG_CPU_PROGRAM_MAP(van32_mem)
|
| 1686 | | MCFG_MACHINE_START(van32)
|
| 1687 | | MCFG_MACHINE_RESET(van16)
|
| 1688 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750))
|
| 1689 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1690 | | |
| 1691 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1692 | | MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1693 | | |
| 1694 | | MACHINE_CONFIG_END
|
| 1695 | | |
| 1696 | | static MACHINE_CONFIG_START( risc, driver_device )
|
| 1697 | | MCFG_CPU_ADD("maincpu", ARM, 14000000)
|
| 1698 | | MCFG_CPU_PROGRAM_MAP(risc_mem)
|
| 1699 | | MCFG_MACHINE_START(risc)
|
| 1700 | | MCFG_MACHINE_RESET(van16)
|
| 1701 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1702 | | |
| 1703 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1704 | | // MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1705 | | |
| 1706 | | MACHINE_CONFIG_END
|
| 1707 | | |
| 1708 | | static MACHINE_CONFIG_START( gen32, driver_device )
|
| 1709 | | MCFG_CPU_ADD("maincpu", M68030, XTAL_33_333MHz)
|
| 1710 | | MCFG_CPU_PROGRAM_MAP(gen32_mem)
|
| 1711 | | MCFG_MACHINE_START(van32)
|
| 1712 | | MCFG_MACHINE_RESET(van16)
|
| 1713 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(375))
|
| 1714 | | // MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(368.64))
|
| 1715 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120))
|
| 1716 | | |
| 1717 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1718 | | MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1719 | | |
| 1720 | | |
| 1721 | | MACHINE_CONFIG_END
|
| 1722 | | |
| 1723 | | static MACHINE_CONFIG_DERIVED( gen32_oc, gen32 )
|
| 1724 | | MCFG_CPU_MODIFY("maincpu")
|
| 1725 | | MCFG_CPU_CLOCK( XTAL_33_333MHz * 2 )
|
| 1726 | | MCFG_DEVICE_REMOVE("int_timer")
|
| 1727 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(500))
|
| 1728 | | |
| 1729 | | |
| 1730 | | MACHINE_CONFIG_END
|
| 1731 | | |
| 1732 | | static MACHINE_CONFIG_START( bpl32, driver_device )
|
| 1733 | | MCFG_CPU_ADD("maincpu", M68020, XTAL_24_576MHz)
|
| 1734 | | MCFG_CPU_PROGRAM_MAP(bpl32_mem)
|
| 1735 | | MCFG_MACHINE_START(van32)
|
| 1736 | | MCFG_MACHINE_RESET(van16)
|
| 1737 | | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750))
|
| 1738 | | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100))
|
| 1739 | | |
| 1740 | | MCFG_FRAGMENT_ADD( chess_common )
|
| 1741 | | MCFG_NVRAM_ADD_0FILL("nvram")
|
| 1742 | | |
| 1743 | | MACHINE_CONFIG_END
|
| 1744 | | |
| 1745 | | |
| 1746 | | /* ROM definitions */
|
| 1747 | | |
| 1748 | | |
| 1749 | | |
| 1750 | | ROM_START(polgar)
|
| 1751 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1752 | | ROM_LOAD("polgar.bin", 0x0000, 0x10000, CRC(88d55c0f) SHA1(e86d088ec3ac68deaf90f6b3b97e3e31b1515913))
|
| 1753 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1754 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1755 | | ROM_END
|
| 1756 | | |
| 1757 | | ROM_START(sfortea)
|
| 1758 | | ROM_REGION(0x18000,"maincpu",0)
|
| 1759 | | ROM_LOAD("sfalo.bin", 0x0000, 0x8000, CRC(86e0230a) SHA1(0d6e18a17e636b8c7292c8f331349d361892d1a8))
|
| 1760 | | ROM_LOAD("sfahi.bin", 0x8000, 0x8000, CRC(81c02746) SHA1(0bf68b68ade5a3263bead88da0a8965fc71483c1))
|
| 1761 | | ROM_LOAD("sfabook.bin", 0x10000, 0x8000, CRC(3e42cf7c) SHA1(b2faa36a127e08e5755167a25ed4a07f12d62957))
|
| 1762 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1763 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1764 | | ROM_END
|
| 1765 | | |
| 1766 | | ROM_START( alm16 )
|
| 1767 | | ROM_REGION16_BE( 0x20000, "maincpu", 0 )
|
| 1768 | | ROM_LOAD16_BYTE("alm16eve.bin", 0x00000, 0x10000,CRC(EE5B6EC4) SHA1(30920C1B9E16FFAE576DA5AFA0B56DA59ADA3DBB))
|
| 1769 | | ROM_LOAD16_BYTE("alm16odd.bin" , 0x00001, 0x10000,CRC(D0BE4EE4) SHA1(D36C074802D2C9099CD44E75F9DE3FC7D1FD9908))
|
| 1770 | | |
| 1771 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1772 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1773 | | |
| 1774 | | ROM_END
|
| 1775 | | |
| 1776 | | ROM_START( alm32 )
|
| 1777 | | ROM_REGION32_BE( 0x20000, "maincpu", 0 )
|
| 1778 | | ROM_LOAD("alm32.bin", 0x00000, 0x20000,CRC(38F4B305) SHA1(43459A057FF29248C74D656A036AC325202B9C15))
|
| 1779 | | |
| 1780 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1781 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1782 | | |
| 1783 | | ROM_END
|
| 1784 | | |
| 1785 | | ROM_START(sforteb)
|
| 1786 | | ROM_REGION(0x18000,"maincpu",0)
|
| 1787 | | ROM_LOAD("forte_b.lo", 0x0000, 0x8000, CRC(48bfe5d6) SHA1(323642686b6d2fb8db2b7d50c6cd431058078ce1))
|
| 1788 | | ROM_LOAD("forte_b.hi1", 0x8000, 0x8000, CRC(9778ca2c) SHA1(d8b88b9768a1a9171c68cbb0892b817d68d78351))
|
| 1789 | | ROM_LOAD("forte_b.hi0", 0x10000, 0x8000, CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6))
|
| 1790 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1791 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1792 | | ROM_END
|
| 1793 | | |
| 1794 | | ROM_START(sforteba)
|
| 1795 | | ROM_REGION(0x18000,"maincpu",0)
|
| 1796 | | ROM_LOAD("forte b_l.bin", 0x0000, 0x8000, CRC(e3d194a1) SHA1(80457580d7c57e07895fd14bfdaf14b30952afca))
|
| 1797 | | ROM_LOAD("forte b_h.bin", 0x8000, 0x8000, CRC(dd824be8) SHA1(cd8666b6b525887f9fc48a730b71ceabcf07f3b9))
|
| 1798 | | ROM_LOAD("forte_b.hi0", 0x10000, 0x8000, BAD_DUMP CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6))
|
| 1799 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1800 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1801 | | ROM_END
|
| 1802 | | |
| 1803 | | ROM_START(sexpertb)
|
| 1804 | | ROM_REGION(0x18000,"maincpu",0)
|
| 1805 | | ROM_LOAD("seb69u3.bin", 0x0000, 0x8000, CRC(92002eb6) SHA1(ed8ca16701e00b48fa55c856fa4a8c6613079c02))
|
| 1806 | | ROM_LOAD("seb69u1.bin", 0x8000, 0x8000, CRC(814b4420) SHA1(c553e6a8c048dcc1cf48d410111a86e06b99d356))
|
| 1807 | | ROM_LOAD("seb605u2.bin", 0x10000, 0x8000, CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6))
|
| 1808 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1809 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1810 | | ROM_END
|
| 1811 | | |
| 1812 | | ROM_START(academy)
|
| 1813 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1814 | | ROM_LOAD("acad8000.bin", 0x8000, 0x8000, CRC(A967922B) SHA1(1327903FF89BF96D72C930C400F367AE19E3EC68))
|
| 1815 | | ROM_LOAD("acad4000.bin", 0x4000, 0x4000, CRC(EE1222B5) SHA1(98541D87755A7186B69B9723CC4ADBD07F20F0E2))
|
| 1816 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1817 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1818 | | ROM_END
|
| 1819 | | |
| 1820 | | ROM_START(finalchs)
|
| 1821 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1822 | | ROM_LOAD("finalchs.bin", 0x8000, 0x8000, CRC(c8e72dff) SHA1(f422b19a806cef4fadd580caefaaf8c32b644098))
|
| 1823 | | ROM_END
|
| 1824 | | |
| 1825 | | ROM_START(megaiv)
|
| 1826 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1827 | | ROM_LOAD("megaiv.bin", 0x8000, 0x8000, CRC(dee355d2) SHA1(6bc79c0fb169020f017412f5f9696b9ecafbf99f))
|
| 1828 | | |
| 1829 | | ROM_END
|
| 1830 | | |
| 1831 | | ROM_START(milano)
|
| 1832 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1833 | | ROM_LOAD("milano.bin", 0x0000, 0x10000, CRC(0e9c8fe1) SHA1(e9176f42d86fe57e382185c703c7eff7e63ca711))
|
| 1834 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1835 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1836 | | ROM_END
|
| 1837 | | |
| 1838 | | |
| 1839 | | ROM_START(sfortec)
|
| 1840 | | ROM_REGION(0x18000,"maincpu",0)
|
| 1841 | | ROM_LOAD("sfclow.bin", 0x0000, 0x8000, CRC(f040cf30) SHA1(1fc1220b8ed67cdffa3866d230ce001721cf684f))
|
| 1842 | | ROM_LOAD("sfchi.bin", 0x8000, 0x8000, CRC(0f926b32) SHA1(9c7270ecb3f41dd9172a9a7928e6e04e64b2a340))
|
| 1843 | | ROM_LOAD("sfcbook.bin", 0x10000, 0x8000, CRC(c6a1419a) SHA1(017a0ffa9aa59438c879624a7ddea2071d1524b8))
|
| 1844 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1845 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1846 | | ROM_END
|
| 1847 | | |
| 1848 | | |
| 1849 | | ROM_START(sexpertc)
|
| 1850 | | ROM_REGION(0x18000,"maincpu",0) // Version 3.6 of firmware
|
| 1851 | | ROM_LOAD("seclow.bin", 0x0000, 0x8000, CRC(5a29105e) SHA1(be37bb29b530dbba847a5e8d27d81b36525e47f7))
|
| 1852 | | ROM_LOAD("sechi.bin", 0x8000, 0x8000, CRC(0085c2c4) SHA1(d84bf4afb022575db09dd9dc12e9b330acce35fa))
|
| 1853 | | ROM_LOAD("secbook.bin", 0x10000, 0x8000, CRC(2d085064) SHA1(76162322aa7d23a5c07e8356d0bbbb33816419af))
|
| 1854 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1855 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1856 | | ROM_END
|
| 1857 | | |
| 1858 | | ROM_START( lyon16 )
|
| 1859 | | ROM_REGION16_BE( 0x20000, "maincpu", 0 )
|
| 1860 | | ROM_LOAD16_BYTE("lyon16ev.bin", 0x00000, 0x10000,CRC(497BD41A) SHA1(3FFEFEEAC694F49997C10D248EC6A7AA932898A4))
|
| 1861 | | ROM_LOAD16_BYTE("lyon16od.bin" , 0x00001, 0x10000,CRC(F9DE3F54) SHA1(4060E29566D2F40122CCDE3C1F84C94A9C1ED54F))
|
| 1862 | | |
| 1863 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1864 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1865 | | |
| 1866 | | ROM_END
|
| 1867 | | |
| 1868 | | ROM_START( lyon32 )
|
| 1869 | | ROM_REGION32_BE( 0x20000, "maincpu", 0 )
|
| 1870 | | ROM_LOAD("lyon32.bin", 0x00000, 0x20000, CRC(5C128B06) SHA1(954C8F0D3FAE29900CB1E9C14A41A9A07A8E185F))
|
| 1871 | | |
| 1872 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1873 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1874 | | |
| 1875 | | ROM_END
|
| 1876 | | |
| 1877 | | |
| 1878 | | ROM_START(monteciv)
|
| 1879 | | ROM_REGION(0x10000,"maincpu",0)
|
| 1880 | | ROM_LOAD("mciv.bin", 0x8000, 0x8000, CRC(C4887694) SHA1(7f482d2a40fcb3125266e7a5407da315b4f9b49c))
|
| 1881 | | |
| 1882 | | ROM_END
|
| 1883 | | |
| 1884 | | ROM_START( diablo68 )
|
| 1885 | | ROM_REGION16_BE( 0x20000, "maincpu", 0 )
|
| 1886 | | ROM_LOAD16_BYTE("evenurom.bin", 0x00000, 0x8000,CRC(03477746) SHA1(8bffcb159a61e59bfc45411e319aea6501ebe2f9))
|
| 1887 | | ROM_LOAD16_BYTE("oddlrom.bin", 0x00001, 0x8000,CRC(e182dbdd) SHA1(24dacbef2173fa737636e4729ff22ec1e6623ca5))
|
| 1888 | | ROM_LOAD16_BYTE("book.bin", 0x10000, 0x8000,CRC(553a5c8c) SHA1(ccb5460ff10766a5ca8008ae2cffcff794318108))
|
| 1889 | | |
| 1890 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1891 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1892 | | |
| 1893 | | ROM_END
|
| 1894 | | |
| 1895 | | ROM_START( van16 )
|
| 1896 | | ROM_REGION16_BE( 0x40000, "maincpu", 0 )
|
| 1897 | | ROM_LOAD16_BYTE("va16even.bin", 0x00000, 0x20000,CRC(E87602D5) SHA1(90CB2767B4AE9E1B265951EB2569B9956B9F7F44))
|
| 1898 | | ROM_LOAD16_BYTE("va16odd.bin" , 0x00001, 0x20000,CRC(585F3BDD) SHA1(90BB94A12D3153A91E3760020E1EA2A9EAA7EC0A))
|
| 1899 | | |
| 1900 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1901 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1902 | | |
| 1903 | | ROM_END
|
| 1904 | | |
| 1905 | | |
| 1906 | | ROM_START( van32 )
|
| 1907 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1908 | | ROM_LOAD("vanc32.bin", 0x00000, 0x40000,CRC(F872BEB5) SHA1(9919F207264F74E2B634B723B048AE9CA2CEFBC7))
|
| 1909 | | |
| 1910 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1911 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1912 | | |
| 1913 | | ROM_END
|
| 1914 | | |
| 1915 | | |
| 1916 | | ROM_START( risc )
|
| 1917 | | ROM_REGION( 0x20000, "maincpu", 0 )
|
| 1918 | | ROM_LOAD("s2500.bin", 0x000000, 0x20000, CRC(7a707e82) SHA1(87187fa58117a442f3abd30092cfcc2a4d7c7efc))
|
| 1919 | | |
| 1920 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1921 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1922 | | |
| 1923 | | ROM_END
|
| 1924 | | |
| 1925 | | ROM_START( gen32 )
|
| 1926 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1927 | | ROM_LOAD("gen32_4.bin", 0x00000, 0x40000,CRC(6CC4DA88) SHA1(EA72ACF9C67ED17C6AC8DE56A165784AA629C4A1))
|
| 1928 | | |
| 1929 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1930 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1931 | | |
| 1932 | | ROM_END
|
| 1933 | | |
| 1934 | | ROM_START( gen32_41 )
|
| 1935 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1936 | | ROM_LOAD("gen32_41.bin", 0x00000, 0x40000,CRC(ea9938c0) SHA1(645cf0b5b831b48104ad6cec8d78c63dbb6a588c))
|
| 1937 | | |
| 1938 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1939 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1940 | | |
| 1941 | | ROM_END
|
| 1942 | | |
| 1943 | | ROM_START( gen32_oc )
|
| 1944 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1945 | | ROM_LOAD("gen32_41.bin", 0x00000, 0x40000,CRC(ea9938c0) SHA1(645cf0b5b831b48104ad6cec8d78c63dbb6a588c))
|
| 1946 | | |
| 1947 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1948 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1949 | | |
| 1950 | | ROM_END
|
| 1951 | | |
| 1952 | | ROM_START( berlinp )
|
| 1953 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1954 | | ROM_LOAD("berlinp.bin", 0x00000, 0x40000,CRC(82FBAF6E) SHA1(729B7CEF3DFAECC4594A6178FC4BA6015AFA6202))
|
| 1955 | | |
| 1956 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1957 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1958 | | |
| 1959 | | ROM_END
|
| 1960 | | |
| 1961 | | ROM_START( bpl32 )
|
| 1962 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1963 | | ROM_LOAD("bpl32.bin", 0x00000, 0x40000,CRC(D75E170F) SHA1(AC0EBDAA114ABD4FEF87361A03DF56928768B1AE))
|
| 1964 | | |
| 1965 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1966 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1967 | | |
| 1968 | | ROM_END
|
| 1969 | | |
| 1970 | | ROM_START( lond020 )
|
| 1971 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1972 | | ROM_LOAD("lond020.bin", 0x00000, 0x40000,CRC(3225B8DA) SHA1(FD8F6F4E9C03B6CDC86D8405E856C26041BFAD12))
|
| 1973 | | |
| 1974 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1975 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1976 | | |
| 1977 | | ROM_END
|
| 1978 | | |
| 1979 | | ROM_START( lond030 )
|
| 1980 | | ROM_REGION32_BE( 0x40000, "maincpu", 0 )
|
| 1981 | | ROM_LOAD("lond030.bin", 0x00000, 0x40000,CRC(853BAA4E) SHA1(946951081D4E91E5BDD9E93D0769568A7FE79BAD))
|
| 1982 | | |
| 1983 | | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE )
|
| 1984 | | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d))
|
| 1985 | | |
| 1986 | | ROM_END
|
| 1987 | | |
| 1988 | | static DRIVER_INIT( polgar )
|
| 1989 | | {
|
| 1990 | | polgar_state *state = machine.driver_data<polgar_state>();
|
| 1991 | | state->led_status=0;
|
| 1992 | | }
|
| 1993 | | |
| 1994 | | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */
|
| 1995 | | CONS( 1986, polgar, 0, 0, polgar, polgar, polgar,"Hegener & Glaser", "Mephisto Polgar Schachcomputer", GAME_REQUIRES_ARTWORK)
|
| 1996 | | CONS( 1987, sfortea, 0, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte A Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 1997 | | CONS( 1988, alm16, van16, 0, alm16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Almeria 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 1998 | | CONS( 1988, alm32, van16, 0, alm32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Alimera 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 1999 | | CONS( 1988, sforteb, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte B Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2000 | | CONS( 1988, sforteba, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte B Chess Computer (ALT)",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2001 | | CONS( 1988, sexpertb, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Expert B Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2002 | | CONS( 1989, academy, 0, 0, academy, academy, 0, "Hegener & Glaser", "Mephisto Academy Schachcomputer",GAME_REQUIRES_ARTWORK|GAME_NOT_WORKING )
|
| 2003 | | CONS( 1989, finalchs,0, 0,finalchs, 0, 0,"TASC", "The Final Chess Card",GAME_NOT_WORKING|GAME_NO_SOUND )
|
| 2004 | | CONS( 1989, megaiv, 0, 0, megaiv, megaiv, 0, "Hegener & Glaser", "Mephisto Mega IV Schachcomputer",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK )
|
| 2005 | | CONS( 1989, milano, polgar, 0, milano, polgar, polgar, "Hegener & Glaser", "Mephisto Milano Schachcomputer",GAME_REQUIRES_ARTWORK )
|
| 2006 | | //CONS( 1989, montec4, 0, 0, monteciv, monteciv, 0, "Hegener & Glaser", "Mephisto Monte Carlo IV",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK )
|
| 2007 | | CONS( 1989, sfortec, sfortea, 0, sfortea, sfortea, 0, "Novag", "Novag Super Forte C Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2008 | | CONS( 1989, sexpertc, sfortea, 0, sfortea, sfortea, 0, "Novag", "Novag Super Expert C Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2009 | | CONS( 1990, lyon16,van16, 0, alm16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Lyon 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2010 | | CONS( 1990, lyon32, van16, 0, alm32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Lyon 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2011 | | CONS( 1990, monteciv, 0, 0, monteciv, monteciv, 0, "Hegener & Glaser", "Mephisto Monte Carlo IV LE Schachcomputer",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK )
|
| 2012 | | CONS( 1991, diablo68, 0, 0, diablo68, sfortea, 0, "Novag", "Novag Diablo 68000 Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING )
|
| 2013 | | CONS( 1991, van16, 0, 0, van16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Vancouver 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2014 | | CONS( 1991, van32, van16, 0, van32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Vancouver 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2015 | | CONS( 1992, risc,0, 0, risc, van16, 0, "Saitek", "RISC2500",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK|GAME_NOT_WORKING )
|
| 2016 | | CONS( 1993, gen32, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2017 | | CONS( 1993, gen32_41, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.01",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2018 | | CONS( 1993, gen32_oc, van16, 0, gen32_oc, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.01OC",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK|GAME_UNOFFICIAL )
|
| 2019 | | CONS( 1994, berlinp, van16, 0, bpl32, bpl32, 0, "Hegener & Glaser Muenchen", "Mephisto Berlin Pro 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2020 | | CONS( 1996, bpl32, van16, 0, bpl32, bpl32, 0, "Hegener & Glaser Muenchen", "Mephisto Berlin Pro London Upgrade V5.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2021 | | CONS( 1996, lond020, van16, 0, van32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto London 68020 32 Bit",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 2022 | | CONS( 1996, lond030, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 London Upgrade V5.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK )
|
| 1 | /****************************************************************************** |
| 2 | Mephisto Chess Computers using plugin modules |
| 3 | |
| 4 | Vancouver Chess Computer 68000 (driver recalled) by R. Schaefer (2010) |
| 5 | |
| 6 | (most of the magnetic sensor versions with 680x0 family modules) |
| 7 | |
| 8 | Almeria 68000 12Mhz |
| 9 | Almeria 68020 12Mhz |
| 10 | Lyon 68000 12Mhz |
| 11 | Lyon 68020 12Mhz |
| 12 | Vancouver 68000 12Mhz |
| 13 | Vancouver 68020 12Mhz |
| 14 | Genius 68030 V4.00 33.333 Mhz |
| 15 | Genius 68030 V4.01 33.333 Mhz |
| 16 | Genius 68030 V4.01 33.333x2 Mhz (custom MESS overclocked version for higher ELO) |
| 17 | Berlin Pro 68020 24.576 Mhz (not modular board, but otherwise close to milano) |
| 18 | Berlin Pro (London) 68020 24.576 Mhz (not modular board, but otherwise close to milano) |
| 19 | London 68030 V5.00k 33.333 Mhz (probably the Genius 3/4 update ROM) |
| 20 | |
| 21 | note: The Almeria 68000 is the 'parent' of all these, but Vancouver 68000 is used as parent in the driver. |
| 22 | It was the first to have 'Bavaria' sensors, and will make the other drivers easier when inheriting this |
| 23 | feature later |
| 24 | |
| 25 | |
| 26 | misc non-modular/non-68K boards |
| 27 | |
| 28 | RISC 2500 (Skeleton, does not work, and not sure the same internal chessboard connections are used) |
| 29 | Final Chess Card by TASC (this is not Mephisto at all, but wanted to make sure it didn't get lost) |
| 30 | Academy 65C02 4.9152mhz |
| 31 | Monte Carlo IV, Mega IV and any others not listed above have correct ROM/RAM and maybe LCD, not much else for now |
| 32 | |
| 33 | Novag boards: (should go in different .c eventually) |
| 34 | Super Forte and Super Expert are the same, except one is touch board, other is magnetic. |
| 35 | The Diablo 68000 is Super Expert board but 68K based |
| 36 | |
| 37 | Notes by Cowering (2011) |
| 38 | |
| 39 | TODO: add Bavaria sensor support (unknown1,2,3 handlers in current driver) |
| 40 | proper 'bezel' for all games/cpuspeeds so 'Vancouver' does not say 'Almeria', etc |
| 41 | custom handler to read/write the Battery RAM so 68000 can share files with 020/030 (real modular machine can do this) |
| 42 | find a timing to let the player see the flashing LEDs on the 68030 versions (might be fixed with waitstates in core) |
| 43 | add the missing machines.. including all Portorose and the very rare overclocked 'TM' Tournament Machines |
| 44 | match I/S= diag speed test with real hardware (good test for proper waitstates) |
| 45 | load LCD rom inside the LCD driver |
| 46 | |
| 47 | TODO2: (these worked before .140 core) |
| 48 | LCD off by a couple of pixels in artwork now |
| 49 | no longer see the custom white hand when selecting chess pieces |
| 50 | parent/clone for artwork so there are not multiple copies of chessboard+pieces |
| 51 | |
| 52 | |
| 53 | TODO3: Oct 2011 - commented out all ACIA functions until they are ported to new device |
| 54 | |
| 55 | Undocumented buttons: holding ENTER and LEFT cursor on cold boot runs diagnostics on modular 680x0 boards |
| 56 | holding UP and RIGHT cursor will clear the Battery Backed RAM on modular 680x0 boards |
| 57 | holding CLEAR clears Battery Backed RAM on the Berlin (Pro) 68020 |
| 58 | ******************************************************************************/ |
| 59 | |
| 60 | /****************************************************************************** |
| 61 | Mephisto Polgar & Milano |
| 62 | 2010 Dirk V., Ralf Schafer, Cowering |
| 63 | |
| 64 | ******************************************************************************/ |
| 65 | |
| 66 | /* |
| 67 | |
| 68 | CPU 65C02 P4 4.9152 MHz |
| 69 | |
| 70 | // lese Tastatur von 2c00 - 2c07, |
| 71 | 2c00 Trn |
| 72 | 2c01 Info |
| 73 | 2c02 Mem |
| 74 | 2c03 Pos |
| 75 | 2c04 Lev |
| 76 | 2c05 Fct |
| 77 | 2c06 Ent |
| 78 | 2c07 CL |
| 79 | |
| 80 | $1ff0 |
| 81 | Bit 0 LCD Command/Data 0/1 |
| 82 | Bit 1 LCD Enable (signals Data is valid) |
| 83 | Bit 2 Beeper |
| 84 | Bit 3 Beeper |
| 85 | Bit 4+7 LED A-H enable |
| 86 | Bit 5+6 LED 1-8 enable |
| 87 | */ |
| 88 | |
| 89 | #include "emu.h" |
| 90 | #include "cpu/m68000/m68000.h" |
| 91 | #include "cpu/m6502/m6502.h" |
| 92 | #include "cpu/arm/arm.h" |
| 93 | #include "sound/beep.h" |
| 94 | //#include "machine/6551acia.h" |
| 95 | #include "video/hd44780.h" |
| 96 | |
| 97 | #include "rendlay.h" |
| 98 | |
| 99 | #include "machine/mboard.h" |
| 100 | #include "machine/nvram.h" |
| 101 | |
| 102 | //static UINT16 unknown2_data = 0; |
| 103 | static UINT16 *save_ram; |
| 104 | static UINT32 *save_ram32; |
| 105 | |
| 106 | // Berlin Pro 68020 |
| 107 | static UINT32 BPL32latch_data = 0; |
| 108 | |
| 109 | // Final Chess Card |
| 110 | static UINT8 FCH_latch_data = 0; |
| 111 | |
| 112 | |
| 113 | // Mephisto Academy |
| 114 | static UINT8 academyallowNMI = 0; |
| 115 | |
| 116 | //Monte Carlo IV key/board selects |
| 117 | |
| 118 | static UINT8 monteciv_select[2] = { 0xff,0xff }; |
| 119 | static UINT8 montecivtop = 0, montecivbot = 0; |
| 120 | static UINT8 montecivtopnew = 0, montecivbotnew = 0; |
| 121 | |
| 122 | //Mephisto Mega IV latch |
| 123 | UINT8 latch2400 = 0; |
| 124 | |
| 125 | UINT8 diablo68_3c0000 = 0; |
| 126 | |
| 127 | UINT8 sfortea_latch = 0; |
| 128 | |
| 129 | |
| 130 | INPUT_PORTS_EXTERN( chessboard ); |
| 131 | |
| 132 | UINT8 lcd32_char; |
| 133 | |
| 134 | class polgar_state : public driver_device |
| 135 | { |
| 136 | public: |
| 137 | polgar_state(const machine_config &mconfig, device_type type, const char *tag) |
| 138 | : driver_device(mconfig, type, tag) { } |
| 139 | |
| 140 | UINT8 led_status; |
| 141 | UINT8 lcd_char; |
| 142 | //UINT8 led7; |
| 143 | UINT8 latch_data; |
| 144 | }; |
| 145 | |
| 146 | static const hd44780_interface chess_display = |
| 147 | { |
| 148 | 2, // number of lines |
| 149 | 16, // chars for line |
| 150 | NULL // custom display layout |
| 151 | }; |
| 152 | |
| 153 | static UINT8 convert_imputmask(UINT8 input) |
| 154 | { |
| 155 | input^=0xff; |
| 156 | switch (input) { |
| 157 | case 0x01: |
| 158 | return 0x80; |
| 159 | case 0x02: |
| 160 | return 0x40; |
| 161 | case 0x04: |
| 162 | return 0x20; |
| 163 | case 0x08: |
| 164 | return 0x10; |
| 165 | case 0x10: |
| 166 | return 0x08; |
| 167 | case 0x20: |
| 168 | return 0x04; |
| 169 | case 0x40: |
| 170 | return 0x02; |
| 171 | case 0x80: |
| 172 | return 0x01; |
| 173 | default: |
| 174 | return 0x00; |
| 175 | } |
| 176 | } |
| 177 | |
| 178 | static int get_first_cleared_bit(UINT8 data) |
| 179 | { |
| 180 | int i; |
| 181 | |
| 182 | for (i = 0; i < 8; i++) |
| 183 | if (!BIT(data, i)) |
| 184 | return i; |
| 185 | |
| 186 | return NOT_VALID; |
| 187 | } |
| 188 | |
| 189 | static WRITE8_HANDLER ( write_polgar_IO ) |
| 190 | { |
| 191 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 192 | int i; |
| 193 | |
| 194 | if (BIT(data,1)) { |
| 195 | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780"); |
| 196 | if (BIT(data,0)) { |
| 197 | hd44780->data_write(*space, 128, state->lcd_char); |
| 198 | } else { |
| 199 | hd44780->control_write(*space, 128, state->lcd_char); |
| 200 | } |
| 201 | } |
| 202 | |
| 203 | if (BIT(data,2) || BIT(data,3)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0); |
| 204 | |
| 205 | if (BIT(data,7) && BIT(data, 4)) { |
| 206 | for (i = 0;i < 8;i++) |
| 207 | output_set_led_value(i,!BIT(state->latch_data,i)); |
| 208 | } |
| 209 | else if (BIT(data,6) && BIT(data,5)) { |
| 210 | for (i = 0;i < 8;i++) |
| 211 | output_set_led_value(10+i,!BIT(state->latch_data,7-i)); |
| 212 | } |
| 213 | else if (!data && (!strcmp(space->machine().system().name,"milano"))) { |
| 214 | for (i=0;i<8;i++) { |
| 215 | output_set_led_value(i,!BIT(state->latch_data,i)); |
| 216 | output_set_led_value(10+i,!BIT(state->latch_data,7-i)); |
| 217 | } |
| 218 | } |
| 219 | |
| 220 | |
| 221 | //logerror("LCD Status Data = %d\n",data); |
| 222 | |
| 223 | } |
| 224 | |
| 225 | |
| 226 | static WRITE8_HANDLER ( write_LCD_polgar ) |
| 227 | { |
| 228 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 229 | |
| 230 | state->lcd_char = data; |
| 231 | |
| 232 | logerror("LCD Data = %d %02x [%c]\n",data,data,(data&0xff)); |
| 233 | |
| 234 | } |
| 235 | |
| 236 | static READ8_HANDLER ( read_1ff1_sfortea ) |
| 237 | { |
| 238 | UINT8 data; |
| 239 | data = input_port_read(space->machine(), "BUTTONS_SFOR1"); |
| 240 | logerror("1ff0 data %02x\n",data); |
| 241 | return 0; |
| 242 | // return data; |
| 243 | } |
| 244 | |
| 245 | static READ8_HANDLER ( read_1ff0_sfortea ) |
| 246 | { |
| 247 | UINT8 data; |
| 248 | data = input_port_read(space->machine(), "BUTTONS_SFOR2"); |
| 249 | logerror("1ff0 data %02x\n",data); |
| 250 | return 0; |
| 251 | // return data; |
| 252 | |
| 253 | // static UINT8 temp = 0; |
| 254 | // temp++; |
| 255 | // logerror("read 1ff0 %02x\n",temp); |
| 256 | // printf("read 1ff0 %02x\n",temp); |
| 257 | |
| 258 | // return (0x00); |
| 259 | } |
| 260 | |
| 261 | |
| 262 | |
| 263 | static WRITE8_HANDLER ( write_latch_sfortea ) |
| 264 | { |
| 265 | sfortea_latch = data; |
| 266 | logerror("latch data %02x\n",data); |
| 267 | // printf("latch data %02x\n",data); |
| 268 | |
| 269 | } |
| 270 | |
| 271 | static WRITE8_HANDLER ( write_lcd_IO_sfortea ) |
| 272 | { |
| 273 | /* bits |
| 274 | 7 |
| 275 | 6 paired with 5 |
| 276 | 5 |
| 277 | 4 |
| 278 | 3 irq on off? |
| 279 | 2 select HD44780 |
| 280 | 1 |
| 281 | 0 LCD command/data select |
| 282 | */ |
| 283 | |
| 284 | |
| 285 | if (BIT(sfortea_latch,2)) |
| 286 | { |
| 287 | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780"); |
| 288 | if(BIT(sfortea_latch,0)) { |
| 289 | hd44780->data_write(*space, 128, data); |
| 290 | logerror("LCD DTA = %02x\n",data); |
| 291 | } else { |
| 292 | if (BIT(data,7)) { |
| 293 | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8 |
| 294 | } |
| 295 | hd44780->control_write(*space, 128, data); |
| 296 | logerror("LCD CMD = %02x\n",data); |
| 297 | } |
| 298 | } |
| 299 | } |
| 300 | |
| 301 | static WRITE8_HANDLER ( write_LCD_academy ) |
| 302 | { |
| 303 | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780"); |
| 304 | |
| 305 | if (offset) { |
| 306 | hd44780->data_write(*space, 128, data); |
| 307 | } else { |
| 308 | hd44780->control_write(*space, 128, data); |
| 309 | } |
| 310 | } |
| 311 | |
| 312 | // AM_RANGE( 0x3a0000,0x3a0000 ) AM_READ(diablo68_write_LCD) |
| 313 | // AM_RANGE( 0x3c0000,0x3c0000 ) AM_READ(diablo68_reg_select) |
| 314 | |
| 315 | /*static WRITE16_HANDLER ( diablo68_aciawrite ) |
| 316 | { |
| 317 | // device_t *acia = space->machine().device("acia65c51"); |
| 318 | // acia_6551_w(acia, offset & 0x03, data >> 8); |
| 319 | // printf("ACIA write data %04x offset %02x\n",data,offset); |
| 320 | logerror("ACIA write data %04x offset %02x\n",data,offset); |
| 321 | } |
| 322 | |
| 323 | static READ16_HANDLER ( diablo68_aciaread ) |
| 324 | { |
| 325 | // device_t *acia = space->machine().device("acia65c51"); |
| 326 | UINT16 result; |
| 327 | // result = acia_6551_r(acia, offset & 0x03); |
| 328 | // logerror("ACIA read offset %02x\n",offset); |
| 329 | // printf("ACIA read offset %02x\n",offset); |
| 330 | |
| 331 | result <<= 8; |
| 332 | |
| 333 | return result; |
| 334 | } |
| 335 | */ |
| 336 | |
| 337 | static WRITE16_HANDLER ( diablo68_reg_select ) |
| 338 | { |
| 339 | diablo68_3c0000 = data >> 8; |
| 340 | //printf("3c0000 = %04x\n",data>>8); |
| 341 | logerror("3c0000 = %04x\n",data>>8); |
| 342 | |
| 343 | } |
| 344 | |
| 345 | |
| 346 | static WRITE16_HANDLER ( diablo68_write_LCD ) |
| 347 | { |
| 348 | hd44780_device *hd44780 = space->machine().device<hd44780_device>("hd44780"); |
| 349 | data >>= 8; |
| 350 | if (!(diablo68_3c0000 & 0x02)) { |
| 351 | if (BIT(data,7)) { |
| 352 | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8 |
| 353 | } |
| 354 | hd44780->control_write(*space, 128, data); |
| 355 | // logerror("Control %02x\n", data); |
| 356 | // printf("Control %02x\n", data); |
| 357 | } else { |
| 358 | hd44780->data_write(*space, 128, data); |
| 359 | // printf("LCDdata %04x [%c]\n", data,data); |
| 360 | // logerror("LCDdata %04x [%c]\n", data,data); |
| 361 | } |
| 362 | |
| 363 | //logerror("LCD Status Data = %d\n",data); |
| 364 | |
| 365 | } |
| 366 | |
| 367 | static WRITE8_HANDLER ( milano_write_LED ) |
| 368 | { |
| 369 | UINT8 LED_offset = 100; |
| 370 | if (data == 0xff) output_set_led_value(LED_offset+offset,1); |
| 371 | else output_set_led_value(LED_offset+offset,0); |
| 372 | |
| 373 | //logerror("LEDs Offset = %d Data = %d\n",offset,data); |
| 374 | } |
| 375 | |
| 376 | static WRITE8_HANDLER ( megaiv_write_LED ) |
| 377 | { |
| 378 | if (BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0); |
| 379 | output_set_led_value(102,BIT(data,1)?1:0); |
| 380 | output_set_led_value(107,BIT(data,6)?1:0); |
| 381 | |
| 382 | // logerror("LEDs FUNC = %02x found = %d\n",data,found); |
| 383 | logerror("LED mask %d\n",data); |
| 384 | // printf("LED mask %d\n",data); |
| 385 | |
| 386 | } |
| 387 | |
| 388 | |
| 389 | static WRITE8_HANDLER ( academy_write_LED ) |
| 390 | { |
| 391 | int found = 0; |
| 392 | |
| 393 | // LED mask debugging, please don't delete |
| 394 | /*static int r[4] = { 0,0,0,0 }; |
| 395 | static int pr[4] = { -1,-1,-1,-1 }; |
| 396 | static int new1 = 0,start = 0,z = 0,i2; |
| 397 | if (data == 0xf8) { |
| 398 | if (start == 0) { |
| 399 | start = 1; |
| 400 | z = 0; |
| 401 | } |
| 402 | } |
| 403 | if (start == 1) { |
| 404 | new1 = 0; |
| 405 | pr[z] = r[z]; |
| 406 | r[z] = data; |
| 407 | for (i2 = 0; i2 < 4; i2++) if(pr[i2] != r[i2]) new1 = 1; |
| 408 | z++; |
| 409 | if(z == 4) z = 0; |
| 410 | if (new1) printf("[%02x] [%02x] [%02x] [%02x]\n",r[0],r[1],r[2],r[3]); |
| 411 | } |
| 412 | */ |
| 413 | |
| 414 | if ((data & 0x68) == 0x68) { |
| 415 | output_set_led_value(103,BIT(data,4)?0:1); // POS |
| 416 | output_set_led_value(107,BIT(data,7)?0:1); // white |
| 417 | found = 1; |
| 418 | } |
| 419 | |
| 420 | if ((data & 0x64) == 0x64) { |
| 421 | output_set_led_value(102,BIT(data,4)?0:1); // MEM |
| 422 | output_set_led_value(106,BIT(data,7)?0:1); // black |
| 423 | found = 1; |
| 424 | } |
| 425 | |
| 426 | if ((data & 0xa2) == 0xa2) { |
| 427 | output_set_led_value(101,BIT(data,4)?0:1); // INFO |
| 428 | output_set_led_value(105,BIT(data,6)?0:1); // FUNC |
| 429 | found = 1; |
| 430 | } |
| 431 | |
| 432 | if ((data & 0xa1) == 0xa1) { |
| 433 | output_set_led_value(100,BIT(data,4)?0:1); // TRN |
| 434 | output_set_led_value(104,BIT(data,6)?0:1); // LVL |
| 435 | found = 1; |
| 436 | } |
| 437 | |
| 438 | if (BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0); |
| 439 | if (BIT(data,1)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0); |
| 440 | // logerror("LEDs FUNC = %02x found = %d\n",data,found); |
| 441 | if (!found) { |
| 442 | logerror("unknown LED mask %d\n",data); |
| 443 | // printf("unknown LED mask %d\n",data); |
| 444 | } |
| 445 | } |
| 446 | |
| 447 | |
| 448 | static WRITE8_HANDLER ( academy_inhibitNMI ) |
| 449 | { |
| 450 | academyallowNMI = data; |
| 451 | |
| 452 | } |
| 453 | |
| 454 | |
| 455 | static WRITE32_HANDLER ( write_LED_BPL32 ) |
| 456 | { |
| 457 | int i; |
| 458 | |
| 459 | data >>= 24; |
| 460 | for (i=0;i<8;i++) { |
| 461 | output_set_led_value(i,BIT(data,i)); |
| 462 | output_set_led_value(10+i,!BIT(BPL32latch_data,7-i)); |
| 463 | } |
| 464 | |
| 465 | logerror("LEDs Offset = %d Data = %08x Latch = %08x\n",offset,data,BPL32latch_data); |
| 466 | |
| 467 | } |
| 468 | |
| 469 | |
| 470 | static WRITE8_HANDLER ( polgar_write_LED ) |
| 471 | { |
| 472 | #define LED_offset 100 |
| 473 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 474 | |
| 475 | data &= 0x80; |
| 476 | |
| 477 | if (data == 0) { |
| 478 | state->led_status &= 255-(1<<offset); |
| 479 | } else { |
| 480 | state->led_status|=1<<offset; |
| 481 | } |
| 482 | |
| 483 | if (offset < 6) output_set_led_value(LED_offset+offset, state->led_status&1<<offset?1:0); |
| 484 | logerror("LEDs Offset = %d Data = %d\n",offset,data); |
| 485 | } |
| 486 | |
| 487 | static UINT8 convertMCIV2LED(UINT8 codedchar) |
| 488 | { |
| 489 | UINT8 data = 0; |
| 490 | if (BIT(codedchar,0)) data |= 0x80; |
| 491 | if (BIT(codedchar,1)) data |= 0x01; |
| 492 | if (BIT(codedchar,2)) data |= 0x20; |
| 493 | if (BIT(codedchar,3)) data |= 0x40; |
| 494 | if (BIT(codedchar,4)) data |= 0x02; |
| 495 | if (BIT(codedchar,5)) data |= 0x04; |
| 496 | if (BIT(codedchar,6)) data |= 0x08; |
| 497 | if (BIT(codedchar,7)) data |= 0x10; |
| 498 | return data; |
| 499 | } |
| 500 | |
| 501 | static WRITE8_HANDLER ( monteciv_write_LCD ) |
| 502 | // first write == 00 (start) then 8 writes (to 74595) x 4 chars, then ff to finish |
| 503 | { |
| 504 | static UINT8 charstodisplay[4] = { 0,0,0,0 }; |
| 505 | static UINT8 tempchar = 0,shift = 0, whichchar = 0; |
| 506 | |
| 507 | if ((montecivtop == 0) && (montecivbot == 0)) { // if both are 0 then no screen chosen |
| 508 | montecivbotnew = 1; |
| 509 | montecivtopnew = 1; |
| 510 | logerror("no screen!\n"); |
| 511 | //printf("no screen! %02x\n",1/(montecivtopnew-1)); |
| 512 | return; |
| 513 | } |
| 514 | if (montecivtop == 0xff) { |
| 515 | if (montecivtopnew) { |
| 516 | montecivtopnew = 0; // skip start bit reset pointer for new chars |
| 517 | tempchar = 0; |
| 518 | shift = 1; |
| 519 | whichchar = 0; |
| 520 | return; |
| 521 | } |
| 522 | tempchar |= BIT(data,7); |
| 523 | tempchar <<= 1; |
| 524 | shift++; |
| 525 | if (shift == 8) { |
| 526 | shift = 0; |
| 527 | charstodisplay[whichchar] = convertMCIV2LED(tempchar); |
| 528 | whichchar++; |
| 529 | tempchar = 0; |
| 530 | } |
| 531 | if (whichchar == 4) { |
| 532 | output_set_digit_value(0,charstodisplay[0]); |
| 533 | output_set_digit_value(1,charstodisplay[1]); |
| 534 | output_set_digit_value(2,charstodisplay[2]); |
| 535 | output_set_digit_value(3,charstodisplay[3]); |
| 536 | whichchar = 0; |
| 537 | } |
| 538 | } |
| 539 | if (montecivbot == 0xff) { |
| 540 | if (montecivbotnew) { |
| 541 | montecivbotnew = 0; // skip start bit reset pointer for new chars |
| 542 | tempchar = 0; |
| 543 | shift = 1; |
| 544 | whichchar = 0; |
| 545 | return; |
| 546 | } |
| 547 | tempchar |= BIT(data,7); |
| 548 | tempchar <<= 1; |
| 549 | shift++; |
| 550 | if (shift == 8) { |
| 551 | shift = 0; |
| 552 | charstodisplay[whichchar] = convertMCIV2LED(tempchar); |
| 553 | whichchar++; |
| 554 | tempchar = 0; |
| 555 | } |
| 556 | if (whichchar == 4) { |
| 557 | output_set_digit_value(4+0,charstodisplay[0]); |
| 558 | output_set_digit_value(4+1,charstodisplay[1]); |
| 559 | output_set_digit_value(4+2,charstodisplay[2]); |
| 560 | output_set_digit_value(4+3,charstodisplay[3]); |
| 561 | whichchar = 0; |
| 562 | } |
| 563 | } |
| 564 | // logerror("$3004 %02x\n",data); |
| 565 | // printf("$3004 %02x %02x \n",data,tempchar); |
| 566 | } |
| 567 | |
| 568 | static WRITE8_HANDLER ( monteciv_3007 ) |
| 569 | { |
| 570 | // logerror("$3007 SELECTTOP %02x\n",data); |
| 571 | // printf("$3007 SELECTTOP %02x\n",data); |
| 572 | montecivtop = data; |
| 573 | montecivtopnew = 1; |
| 574 | } |
| 575 | |
| 576 | static WRITE8_HANDLER ( monteciv_3005 ) |
| 577 | { |
| 578 | // logerror("$3005 SELECTBOT %02x\n",data); |
| 579 | // printf("$3005 SELECTBOT %02x\n",data); |
| 580 | montecivbot = data; |
| 581 | montecivbotnew = 1; |
| 582 | } |
| 583 | |
| 584 | static WRITE8_HANDLER ( monteciv_3006 ) |
| 585 | { |
| 586 | logerror("$3006 CLK %02x\n",data); |
| 587 | // printf("$3006 CLK %02x\n",data); |
| 588 | } |
| 589 | |
| 590 | |
| 591 | static WRITE8_HANDLER ( academy_write_board ) |
| 592 | { |
| 593 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 594 | |
| 595 | state->latch_data = data; |
| 596 | // logerror("acad_write_latch %02x\n",data); |
| 597 | if (data != 0xff) mboard_write_board_8(space,0, data); |
| 598 | } |
| 599 | |
| 600 | static WRITE8_HANDLER ( milano_write_board ) |
| 601 | { |
| 602 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 603 | |
| 604 | state->latch_data = data; |
| 605 | } |
| 606 | |
| 607 | static READ8_HANDLER(milano_read_board) |
| 608 | { |
| 609 | int line; |
| 610 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 611 | static const char *const board_lines[8] = |
| 612 | { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" }; |
| 613 | |
| 614 | UINT8 data = 0x00; |
| 615 | UINT8 tmp; // = 0xff; |
| 616 | |
| 617 | if (state->latch_data) |
| 618 | { |
| 619 | line = get_first_cleared_bit(state->latch_data); |
| 620 | tmp = input_port_read(space->machine(), board_lines[line]); |
| 621 | |
| 622 | if (tmp != 0xff) |
| 623 | data = convert_imputmask(tmp); |
| 624 | |
| 625 | } |
| 626 | |
| 627 | return data; |
| 628 | |
| 629 | } |
| 630 | |
| 631 | static READ8_HANDLER(read_keys) |
| 632 | { |
| 633 | UINT8 data; |
| 634 | static const char *const keynames[1][8] = |
| 635 | { |
| 636 | { "KEY1_0", "KEY1_1", "KEY1_2", "KEY1_3", "KEY1_4", "KEY1_5", "KEY1_6", "KEY1_7" } |
| 637 | }; |
| 638 | |
| 639 | data = input_port_read(space->machine(), keynames[0][offset]); |
| 640 | // logerror("Keyboard Port = %s Data = %d\n ", ((led_status & 0x80) == 0x00) ? keynames[0][offset] : keynames[1][offset], data); |
| 641 | return data | 0x7f; |
| 642 | } |
| 643 | |
| 644 | static READ8_HANDLER(read_keys_megaiv) |
| 645 | { |
| 646 | UINT8 data; |
| 647 | static const char *const keynames[1][8] = |
| 648 | { |
| 649 | { "KEY1_0", "KEY1_1", "KEY1_2", "KEY1_3", "KEY1_4", "KEY1_5", "KEY1_6", "KEY1_7" } |
| 650 | }; |
| 651 | |
| 652 | data = input_port_read(space->machine(), keynames[0][offset]); |
| 653 | logerror("Keyboard Port = %s Data = %d\n ", keynames[0][offset] , data); |
| 654 | return data | 0x7f; |
| 655 | } |
| 656 | |
| 657 | |
| 658 | static READ32_HANDLER(read_keys_BPL32) |
| 659 | { |
| 660 | UINT32 data = 0; |
| 661 | UINT8 tmp = 0xff, line = 0; |
| 662 | static const char *const board_lines[8] = |
| 663 | { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" }; |
| 664 | |
| 665 | if (BPL32latch_data == 0xff) { |
| 666 | tmp = input_port_read(space->machine(), "BUTTONS_BPL"); |
| 667 | logerror("Keyboard Port Offset = %d tmp %d\n", offset,tmp); |
| 668 | |
| 669 | data = tmp << 24; |
| 670 | } else { |
| 671 | if (BPL32latch_data & 0x7f) { |
| 672 | logerror("ReadingBoard %02x\n",BPL32latch_data); |
| 673 | line = get_first_cleared_bit(BPL32latch_data); |
| 674 | tmp = input_port_read(space->machine(), board_lines[line]); |
| 675 | |
| 676 | if (tmp != 0xff) |
| 677 | data = convert_imputmask(tmp) << 24; |
| 678 | } |
| 679 | } |
| 680 | |
| 681 | // logerror("Keyboard Port = %s Data = %d Offset = %d tmp %d line %02x\n", keynames[0][line], data, offset,tmp,line); |
| 682 | return data; |
| 683 | } |
| 684 | |
| 685 | static WRITE8_HANDLER(beep_academy) |
| 686 | { |
| 687 | if (!BIT(data,7)) beep_set_state(space->machine().device("beep"),1); else beep_set_state(space->machine().device("beep"),0); |
| 688 | } |
| 689 | |
| 690 | static WRITE8_HANDLER(megaiv_IO) |
| 691 | { |
| 692 | // if (BIT(data,0)) beep_set_state(space->machine->device("beep"),1); else beep_set_state(space->machine->device("beep"),0); |
| 693 | logerror("$2400 = %02x\n",data); |
| 694 | latch2400 = data; |
| 695 | } |
| 696 | |
| 697 | |
| 698 | static WRITE8_HANDLER( monteciv_select_line ) |
| 699 | { |
| 700 | monteciv_select[offset] = data; |
| 701 | } |
| 702 | |
| 703 | // FIXME : unlike polgar, academy shares port IO for keys and board, and i just can't seem to get the board latched right (H7 and H8 are always flashing) -- Cow |
| 704 | static READ8_HANDLER(read_keys_board_monteciv) |
| 705 | { |
| 706 | UINT8 data = 0; |
| 707 | |
| 708 | if (monteciv_select[0] == 0xff && monteciv_select[1] == 0xff) { |
| 709 | data = mboard_read_board_8(space,0); |
| 710 | } else { |
| 711 | if (monteciv_select[0] == 0x0) { |
| 712 | data = input_port_read(space->machine(), "BUTTONS_MONTE2"); |
| 713 | #if 0 |
| 714 | if (data) { |
| 715 | output_set_digit_value(0,64); |
| 716 | output_set_digit_value(1,113+128); |
| 717 | output_set_digit_value(2,190); |
| 718 | output_set_digit_value(3,64); |
| 719 | |
| 720 | output_set_digit_value(4,246-128); |
| 721 | output_set_digit_value(5,247-128); |
| 722 | output_set_digit_value(6,219-128); |
| 723 | output_set_digit_value(7,249-128); |
| 724 | } |
| 725 | #endif |
| 726 | } else { |
| 727 | data = input_port_read(space->machine(), "BUTTONS_MONTE1"); |
| 728 | } |
| 729 | } |
| 730 | return data; |
| 731 | } |
| 732 | |
| 733 | |
| 734 | // FIXME : unlike polgar, academy shares port IO for keys and board, and I just can't seem to get the board latched right (H7 and H8 are always flashing) -- Cow |
| 735 | static READ8_HANDLER(read_keys_board_academy) |
| 736 | { |
| 737 | // static int startup = 0; |
| 738 | polgar_state *state = space->machine().driver_data<polgar_state>(); |
| 739 | UINT8 data = 0; |
| 740 | // UINT8 tmp = 0xff, line = 0; |
| 741 | // static const char *const board_lines[8] = |
| 742 | // { "LINE2", "LINE3", "LINE4", "LINE5", "LINE6", "LINE7", "LINE8", "LINE9" }; |
| 743 | |
| 744 | if (state->latch_data == 0xff) { |
| 745 | data = input_port_read(space->machine(), "BUTTONS_ACAD"); |
| 746 | } else { |
| 747 | // if (state->latch_data & 0x7f) { |
| 748 | data = mboard_read_board_8(space,0); |
| 749 | // data = milano_read_board(space,0); |
| 750 | |
| 751 | // logerror("ReadingBoard %02x\n",state->latch_data); |
| 752 | // line = get_first_cleared_bit(state->latch_data); |
| 753 | // tmp = input_port_read(space->machine, board_lines[line]); |
| 754 | // mboard_write_board_8(space,0, state->latch_data); |
| 755 | // data = mboard_read_board_8(space,0); |
| 756 | // logerror("BoardRead Port Offset = %d data %02x Latch %02x\n", offset,data,state->latch_data); |
| 757 | // printf ("BoardRead Port Offset = %d data %02x Latch %02x\n", offset,data,state->latch_data); |
| 758 | // } else { |
| 759 | // logerror("no keys or board\n"); |
| 760 | // } |
| 761 | } |
| 762 | // logerror("Keyboard Port Offset = %d tmp %d Latch %d\n", offset,tmp,state->latch_data); |
| 763 | // logerror("Keyboard Port = %s Data = %d Offset = %d tmp %d line %02x\n", keynames[0][line], data, offset,tmp,line); |
| 764 | return data; |
| 765 | } |
| 766 | |
| 767 | static TIMER_DEVICE_CALLBACK( cause_nmi ) |
| 768 | { |
| 769 | cputag_set_input_line(timer.machine(), "maincpu", INPUT_LINE_NMI,PULSE_LINE); |
| 770 | } |
| 771 | |
| 772 | static TIMER_DEVICE_CALLBACK( cause_M6502_irq ) |
| 773 | { |
| 774 | cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, ASSERT_LINE); |
| 775 | cputag_set_input_line(timer.machine(), "maincpu", M6502_IRQ_LINE, CLEAR_LINE); |
| 776 | |
| 777 | } |
| 778 | |
| 779 | |
| 780 | static WRITE32_HANDLER( write_board_BPL32 ) |
| 781 | { |
| 782 | BPL32latch_data = data >> 24; |
| 783 | logerror("Write BPL32 board Data Latch %08x Offset: %08x\n",BPL32latch_data,offset); |
| 784 | |
| 785 | } |
| 786 | |
| 787 | static READ32_HANDLER( read_buttons_gen32 ) |
| 788 | { |
| 789 | UINT32 data; |
| 790 | static const char *const keynames[4] = { "BUTTON_1", "BUTTON_2", "", "BUTTON_3" }; |
| 791 | |
| 792 | data = input_port_read(space->machine(), keynames[offset]); |
| 793 | |
| 794 | data = data|data<<8|data<<16|data<<24; // this might not be needed if MAME does handle odd alignment over 32bit boundaries right |
| 795 | logerror("Read from Buttons: %08x %08x\n",offset,data); |
| 796 | return data; |
| 797 | } |
| 798 | |
| 799 | static READ32_HANDLER( read_buttons_van32 ) |
| 800 | { |
| 801 | UINT32 data; |
| 802 | static const char *const keynames[4] = { "BUTTON_1", "", "BUTTON_2", "BUTTON_3" }; |
| 803 | |
| 804 | |
| 805 | data = input_port_read(space->machine(), keynames[offset]); |
| 806 | |
| 807 | data = data << 8; |
| 808 | logerror("Read from Buttons: %08x %08x\n",offset,data); |
| 809 | return data; |
| 810 | } |
| 811 | |
| 812 | static READ16_HANDLER( read_buttons_van16 ) |
| 813 | { |
| 814 | UINT16 data; |
| 815 | static const char *const keynames[3] = { "BUTTON_1", "BUTTON_2", "BUTTON_3" }; |
| 816 | |
| 817 | |
| 818 | data = input_port_read(space->machine(), keynames[offset>>1]) << 8; |
| 819 | |
| 820 | logerror("Read from %06x offset: %x %04x\n",0xf00000,offset,data); |
| 821 | return data; |
| 822 | } |
| 823 | |
| 824 | static WRITE32_HANDLER( write_LCD_data_32 ) |
| 825 | { |
| 826 | |
| 827 | // printf("Write LCD Data Latch %08x o: %08x\n",data,offset); |
| 828 | logerror("Write LCD Data Latch %08x o: %08x\n",data,offset); |
| 829 | lcd32_char = data>>24; |
| 830 | // cpu_adjust_icount(space->cpu,-5000); |
| 831 | |
| 832 | } |
| 833 | |
| 834 | static WRITE16_HANDLER( write_LCD_data ) |
| 835 | { |
| 836 | |
| 837 | lcd32_char = data>>8; |
| 838 | |
| 839 | } |
| 840 | |
| 841 | static void write_IOenable(unsigned char data,address_space *space) { |
| 842 | |
| 843 | hd44780_device * hd44780 = space->machine().device<hd44780_device>("hd44780"); |
| 844 | device_t *speaker = space->machine().device("beep"); |
| 845 | |
| 846 | if (BIT(data,5) && BIT(data,4)) { |
| 847 | if (BIT(data,1)) { |
| 848 | // delay until LCD is ready |
| 849 | // (this is now patched on a per ROM basis) |
| 850 | // ROMs have a very specific delay loop to avoid a busy spin while checking moves in the background |
| 851 | // 48 tst.l (a4)+ instuctions need to be > ~42us (for 33.33mhz 030) (a4 is pointing at ROM) |
| 852 | // MAME core does not appear to have this opcode timed right. |
| 853 | // This also allows 'fake' clocks to test ELO at impossibly high speeds on real hardware |
| 854 | // The original programmer says RAM is 2x as fast as the ROM on the 030 machines, maybe waitstates can be put in MAME core someday |
| 855 | // cpu_spinuntil_time(space->cpu, ATTOTIME_IN_USEC(50)); |
| 856 | if (BIT(data,0)) { |
| 857 | logerror("Write LCD_DATA [%02x] [%c]\n",lcd32_char,lcd32_char); |
| 858 | // printf("Write LCD_DATA [%02x] [%c]\n",lcd32_char,lcd32_char); |
| 859 | hd44780->data_write(*space, 128, lcd32_char); |
| 860 | } else { |
| 861 | logerror("Write LCD_CTRL [%02x] [%c]\n",lcd32_char,lcd32_char); |
| 862 | // printf("Write LCD_CTRL [%02x] [%c]\n",lcd32_char,lcd32_char); |
| 863 | hd44780->control_write(*space, 128, lcd32_char); |
| 864 | } |
| 865 | } |
| 866 | |
| 867 | logerror("Write to IOENBL data: %08x\n",data); |
| 868 | |
| 869 | if (BIT(data,2) || BIT(data,3)) beep_set_state(speaker,1); else beep_set_state(speaker,0); |
| 870 | } |
| 871 | |
| 872 | } |
| 873 | |
| 874 | static WRITE32_HANDLER( write_IOenables_32 ) { |
| 875 | |
| 876 | write_IOenable(data>>24,space); |
| 877 | } |
| 878 | |
| 879 | static WRITE16_HANDLER( write_IOenables ) |
| 880 | { |
| 881 | write_IOenable(data>>8,space); |
| 882 | } |
| 883 | |
| 884 | /* Unknown read/write */ |
| 885 | |
| 886 | static READ32_HANDLER( read_unknown1_32 ) |
| 887 | { |
| 888 | logerror("Read from unknown1 offset: %x\n",offset); |
| 889 | return 0xff00ff00; |
| 890 | } |
| 891 | |
| 892 | static READ16_HANDLER( read_unknown1 ) |
| 893 | { |
| 894 | logerror("Read from %06x offset: %x\n",0xe80002,offset); |
| 895 | return 0xff00; |
| 896 | } |
| 897 | |
| 898 | static WRITE32_HANDLER( write_unknown2_32 ) |
| 899 | { |
| 900 | //unknown2_data = data; |
| 901 | logerror("Write to unknown2 data: %04x\n",data); |
| 902 | } |
| 903 | |
| 904 | static WRITE16_HANDLER( write_unknown2 ) |
| 905 | { |
| 906 | //unknown2_data = data; |
| 907 | logerror("Write from %06x data: %04x\n",0xe80004,data); |
| 908 | } |
| 909 | |
| 910 | static READ32_HANDLER( read_unknown3_32 ) |
| 911 | { |
| 912 | logerror("Read from unknown3 offset: %x %08x\n",offset,(unsigned int) cpu_get_reg(space->machine().device("maincpu"), M68K_PC)); |
| 913 | return 0xffffffff; |
| 914 | //return unknown2_data|unknown2_data<<24; |
| 915 | |
| 916 | } |
| 917 | |
| 918 | static READ16_HANDLER( read_unknown3 ) |
| 919 | { |
| 920 | logerror("Read from %06x offset: %x\n",0xe80006,offset); |
| 921 | return 0xffff; |
| 922 | //return unknown2_data; |
| 923 | |
| 924 | } |
| 925 | |
| 926 | static READ32_HANDLER( read_1800000 ) |
| 927 | { |
| 928 | logerror("Read from RISC2500 1800000\n"); |
| 929 | return 0; |
| 930 | } |
| 931 | |
| 932 | static WRITE32_HANDLER( write_1000000 ) |
| 933 | { |
| 934 | logerror("Write to RISC2500 1000000\n"); |
| 935 | } |
| 936 | |
| 937 | static WRITE8_HANDLER( io7ff8_write ) |
| 938 | { |
| 939 | FCH_latch_data = data; |
| 940 | } |
| 941 | |
| 942 | static READ8_HANDLER( io7ff8_read ) |
| 943 | { |
| 944 | static unsigned char table[] = { 0xff, 0xfd, 0xfe }; |
| 945 | static int i = -1; |
| 946 | i++; |
| 947 | if (i == 3) i = 0; |
| 948 | return table[i]; // exercise the NMI handler for now with known commands |
| 949 | } |
| 950 | |
| 951 | static READ8_HANDLER( io6000_read ) |
| 952 | { |
| 953 | return 0x55; |
| 954 | } |
| 955 | |
| 956 | static WRITE8_HANDLER( io6000_write ) |
| 957 | { |
| 958 | FCH_latch_data = data; |
| 959 | } |
| 960 | |
| 961 | static TIMER_DEVICE_CALLBACK( timer_update_irq6 ) |
| 962 | { |
| 963 | cputag_set_input_line(timer.machine(), "maincpu", 6, HOLD_LINE); |
| 964 | } |
| 965 | |
| 966 | static TIMER_DEVICE_CALLBACK( timer_update_irq2 ) |
| 967 | { |
| 968 | cputag_set_input_line(timer.machine(), "maincpu", 2, HOLD_LINE); |
| 969 | } |
| 970 | |
| 971 | |
| 972 | static TIMER_DEVICE_CALLBACK( timer_update_irq_academy ) |
| 973 | { |
| 974 | if (academyallowNMI) { |
| 975 | cputag_set_input_line(timer.machine(), "maincpu", 6, HOLD_LINE); |
| 976 | } |
| 977 | } |
| 978 | |
| 979 | |
| 980 | static MACHINE_START( van32 ) |
| 981 | { |
| 982 | // patch LCD delay loop on the 68030 machines until waitstates and/or opcode timings are fixed in MAME core |
| 983 | // patches gen32 gen32_41 gen32_oc lond030 |
| 984 | |
| 985 | UINT8 *rom = machine.region("maincpu")->base(); |
| 986 | |
| 987 | if(rom[0x870] == 0x0c && rom[0x871] == 0x78) { |
| 988 | if (!strcmp(machine.system().name,"gen32_oc")) { |
| 989 | rom[0x870] = 0x6c; |
| 990 | } else { |
| 991 | rom[0x870] = 0x38; |
| 992 | } |
| 993 | } |
| 994 | |
| 995 | machine.device<nvram_device>("nvram")->set_base(save_ram32, 0x8000); |
| 996 | |
| 997 | } |
| 998 | |
| 999 | |
| 1000 | static MACHINE_START( risc ) |
| 1001 | { |
| 1002 | |
| 1003 | } |
| 1004 | |
| 1005 | |
| 1006 | static void common_chess_start(void) |
| 1007 | { |
| 1008 | mboard_set_border_pieces(); |
| 1009 | mboard_set_board(); |
| 1010 | } |
| 1011 | |
| 1012 | static MACHINE_START( polgar ) |
| 1013 | { |
| 1014 | common_chess_start(); |
| 1015 | mboard_savestate_register(machine); |
| 1016 | } |
| 1017 | |
| 1018 | static MACHINE_START( sfortea ) |
| 1019 | { |
| 1020 | common_chess_start(); |
| 1021 | mboard_savestate_register(machine); |
| 1022 | } |
| 1023 | |
| 1024 | static MACHINE_START( finalchs ) |
| 1025 | { |
| 1026 | // timer_pulse(machine, ATTOTIME_IN_HZ(1), NULL, 0, cause_M6502_irq); |
| 1027 | } |
| 1028 | |
| 1029 | static MACHINE_START( diablo68 ) |
| 1030 | { |
| 1031 | |
| 1032 | common_chess_start(); |
| 1033 | |
| 1034 | } |
| 1035 | |
| 1036 | static MACHINE_START( van16 ) |
| 1037 | { |
| 1038 | |
| 1039 | mboard_savestate_register(machine); |
| 1040 | machine.device<nvram_device>("nvram")->set_base(save_ram, 0x4000); |
| 1041 | |
| 1042 | } |
| 1043 | |
| 1044 | static MACHINE_RESET( van16 ) |
| 1045 | { |
| 1046 | common_chess_start(); |
| 1047 | |
| 1048 | } |
| 1049 | |
| 1050 | static MACHINE_RESET( polgar ) |
| 1051 | { |
| 1052 | common_chess_start(); |
| 1053 | |
| 1054 | } |
| 1055 | |
| 1056 | static MACHINE_RESET( sfortea ) |
| 1057 | { |
| 1058 | common_chess_start(); |
| 1059 | |
| 1060 | } |
| 1061 | |
| 1062 | static MACHINE_RESET( monteciv ) |
| 1063 | { |
| 1064 | montecivtop = 0; |
| 1065 | montecivbot = 0; |
| 1066 | monteciv_select[0] = 0; |
| 1067 | monteciv_select[1] = 0; |
| 1068 | academyallowNMI = 0; |
| 1069 | common_chess_start(); |
| 1070 | } |
| 1071 | |
| 1072 | |
| 1073 | static MACHINE_RESET( academy ) |
| 1074 | { |
| 1075 | academyallowNMI = 0; |
| 1076 | common_chess_start(); |
| 1077 | } |
| 1078 | |
| 1079 | SCREEN_UPDATE( chess_lcd ) |
| 1080 | { |
| 1081 | hd44780_device * hd44780 = screen->machine().device<hd44780_device>("hd44780"); |
| 1082 | return hd44780->video_update(bitmap, cliprect ); |
| 1083 | } |
| 1084 | |
| 1085 | static PALETTE_INIT( chess_lcd ) |
| 1086 | { |
| 1087 | // palette_set_color(machine, 0, MAKE_RGB(138, 146, 148)); // some think this is closer, but slightly less readable |
| 1088 | palette_set_color(machine, 0, MAKE_RGB(255, 255, 255)); |
| 1089 | palette_set_color(machine, 1, MAKE_RGB(0, 0, 0)); |
| 1090 | } |
| 1091 | |
| 1092 | static const gfx_layout chess_charlayout = |
| 1093 | { |
| 1094 | 5, 8, /* 5 x 8 characters */ |
| 1095 | 224, /* 224 characters */ |
| 1096 | 1, /* 1 bits per pixel */ |
| 1097 | { 0 }, /* no bitplanes */ |
| 1098 | { 3, 4, 5, 6, 7}, |
| 1099 | { 0, 8, 2*8, 3*8, 4*8, 5*8, 6*8, 7*8}, |
| 1100 | 8*8 /* 8 bytes */ |
| 1101 | }; |
| 1102 | |
| 1103 | static GFXDECODE_START( chess_lcd ) |
| 1104 | GFXDECODE_ENTRY( "hd44780", 0x0000, chess_charlayout, 0, 1 ) |
| 1105 | GFXDECODE_END |
| 1106 | |
| 1107 | static ADDRESS_MAP_START(polgar_mem , AS_PROGRAM, 8) |
| 1108 | AM_RANGE( 0x0000, 0x1fff ) AM_RAM |
| 1109 | AM_RANGE( 0x2400, 0x2400 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard |
| 1110 | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( mboard_write_board_8) // Chessboard |
| 1111 | AM_RANGE( 0x3000, 0x3000 ) AM_READ ( mboard_read_board_8 ) // Chessboard |
| 1112 | AM_RANGE( 0x3400, 0x3405 ) AM_WRITE( polgar_write_LED) // Function LEDs |
| 1113 | AM_RANGE( 0x2c00, 0x2c07 ) AM_READ ( read_keys) |
| 1114 | AM_RANGE( 0x2004, 0x2004 ) AM_WRITE ( write_polgar_IO ) // LCD Instr. Reg + Beeper |
| 1115 | AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( write_LCD_polgar ) // LCD Char Reg. |
| 1116 | AM_RANGE( 0x4000, 0xffff ) AM_ROM |
| 1117 | ADDRESS_MAP_END |
| 1118 | |
| 1119 | static ADDRESS_MAP_START(sfortea_mem , AS_PROGRAM, 8) |
| 1120 | AM_RANGE( 0x0000, 0x1fef ) AM_RAM |
| 1121 | AM_RANGE( 0x1ff6, 0x1ff6 ) AM_WRITE ( write_latch_sfortea) // IO control |
| 1122 | AM_RANGE( 0x1ff7, 0x1ff7 ) AM_WRITE ( write_lcd_IO_sfortea) // LCD Char Reg. |
| 1123 | // AM_RANGE( 0x1ffc, 0x1fff ) AM_DEVREADWRITE("acia65c51", acia_6551_r,acia_6551_w) |
| 1124 | AM_RANGE( 0x1ff1, 0x1ff1 ) AM_READ ( read_1ff1_sfortea ) |
| 1125 | AM_RANGE( 0x1ff0, 0x1ff0 ) AM_READ ( read_1ff0_sfortea ) |
| 1126 | AM_RANGE( 0x2000, 0xffff ) AM_ROM |
| 1127 | ADDRESS_MAP_END |
| 1128 | |
| 1129 | |
| 1130 | static ADDRESS_MAP_START(gen32_mem, AS_PROGRAM, 32) |
| 1131 | |
| 1132 | AM_RANGE( 0x00000000, 0x0003ffff ) AM_ROM |
| 1133 | |
| 1134 | AM_RANGE( 0xc0000000 , 0xc0000003 ) AM_READ ( mboard_read_board_32 ) |
| 1135 | AM_RANGE( 0xc8000000 , 0xc8000003 ) AM_WRITE ( mboard_write_board_32 ) |
| 1136 | AM_RANGE( 0xc8000004 , 0xc8000007 ) AM_WRITE ( mboard_write_board_32 ) |
| 1137 | AM_RANGE( 0xd0000000 , 0xd0000003 ) AM_WRITE ( mboard_write_LED_32 ) |
| 1138 | AM_RANGE( 0xd0000004 , 0xd0000007 ) AM_WRITE ( mboard_write_LED_32 ) |
| 1139 | AM_RANGE( 0xf0000004 , 0xf0000013 ) AM_READ ( read_buttons_gen32 ) |
| 1140 | AM_RANGE( 0xe0000000 , 0xe0000003 ) AM_WRITE ( write_LCD_data_32 ) |
| 1141 | AM_RANGE( 0xe0000010 , 0xe0000013 ) AM_WRITE ( write_IOenables_32 ) |
| 1142 | AM_RANGE( 0xd8000008 , 0xd800000b ) AM_WRITE ( write_unknown2_32 ) |
| 1143 | AM_RANGE( 0xd8000004 , 0xd8000007 ) AM_READ ( read_unknown1_32 ) |
| 1144 | AM_RANGE( 0xd800000c , 0xd800000f ) AM_READ ( read_unknown3_32 ) |
| 1145 | |
| 1146 | AM_RANGE( 0x40000000, 0x4007ffff ) AM_RAM /* 512KB */ |
| 1147 | AM_RANGE( 0x80000000, 0x8003ffff ) AM_RAM /* 256KB */ |
| 1148 | AM_RANGE( 0xe8000000, 0xe8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram") |
| 1149 | |
| 1150 | ADDRESS_MAP_END |
| 1151 | |
| 1152 | static ADDRESS_MAP_START(bpl32_mem, AS_PROGRAM, 32) |
| 1153 | |
| 1154 | AM_RANGE( 0x000000, 0x03ffff ) AM_ROM |
| 1155 | AM_RANGE( 0x800000 , 0x800003 ) AM_READ ( read_keys_BPL32 ) |
| 1156 | AM_RANGE( 0x900000 , 0x900003 ) AM_WRITE ( write_board_BPL32 ) |
| 1157 | AM_RANGE( 0xa00000 , 0xa00003 ) AM_WRITE ( write_LED_BPL32 ) |
| 1158 | AM_RANGE( 0xc00000 , 0xc00003 ) AM_WRITE ( write_LCD_data_32 ) |
| 1159 | AM_RANGE( 0xb00000 , 0xb00003 ) AM_WRITE ( write_IOenables_32 ) |
| 1160 | AM_RANGE( 0x400000 , 0x4fffff ) AM_RAM /* 1024KB */ |
| 1161 | AM_RANGE( 0xd00000 , 0xd07fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram") |
| 1162 | |
| 1163 | ADDRESS_MAP_END |
| 1164 | |
| 1165 | static ADDRESS_MAP_START(van32_mem, AS_PROGRAM, 32) |
| 1166 | |
| 1167 | AM_RANGE( 0x00000000, 0x0003ffff ) AM_ROM |
| 1168 | |
| 1169 | AM_RANGE( 0x800000fc , 0x800000ff ) AM_READ ( mboard_read_board_32 ) |
| 1170 | AM_RANGE( 0x88000000 , 0x88000007 ) AM_WRITE ( mboard_write_board_32 ) |
| 1171 | AM_RANGE( 0x90000000 , 0x90000007 ) AM_WRITE ( mboard_write_LED_32 ) |
| 1172 | AM_RANGE( 0x800000ec , 0x800000ff ) AM_READ ( read_buttons_van32 ) |
| 1173 | AM_RANGE( 0xa0000000 , 0xa0000003 ) AM_WRITE ( write_LCD_data_32 ) |
| 1174 | AM_RANGE( 0xa0000010 , 0xa0000013 ) AM_WRITE ( write_IOenables_32 ) |
| 1175 | AM_RANGE( 0x98000008 , 0x9800000b ) AM_WRITE ( write_unknown2_32 ) |
| 1176 | AM_RANGE( 0x98000004 , 0x98000007 ) AM_READ ( read_unknown1_32 ) |
| 1177 | AM_RANGE( 0x9800000c , 0x9800000f ) AM_READ ( read_unknown3_32 ) |
| 1178 | |
| 1179 | AM_RANGE( 0x40000000, 0x400fffff ) AM_RAM /* 1024KB */ |
| 1180 | AM_RANGE( 0xa8000000, 0xa8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram") |
| 1181 | |
| 1182 | ADDRESS_MAP_END |
| 1183 | |
| 1184 | |
| 1185 | static ADDRESS_MAP_START(alm32_mem, AS_PROGRAM, 32) |
| 1186 | |
| 1187 | AM_RANGE( 0x00000000, 0x0001ffff ) AM_ROM |
| 1188 | |
| 1189 | AM_RANGE( 0x800000fc , 0x800000ff ) AM_READ ( mboard_read_board_32 ) |
| 1190 | AM_RANGE( 0x88000000 , 0x88000007 ) AM_WRITE ( mboard_write_board_32 ) |
| 1191 | AM_RANGE( 0x90000000 , 0x90000007 ) AM_WRITE ( mboard_write_LED_32 ) |
| 1192 | AM_RANGE( 0x800000ec , 0x800000ff ) AM_READ ( read_buttons_van32 ) |
| 1193 | AM_RANGE( 0xa0000000 , 0xa0000003 ) AM_WRITE ( write_LCD_data_32 ) |
| 1194 | AM_RANGE( 0xa0000010 , 0xa0000013 ) AM_WRITE ( write_IOenables_32 ) |
| 1195 | AM_RANGE( 0x98000008 , 0x9800000b ) AM_WRITE ( write_unknown2_32 ) |
| 1196 | AM_RANGE( 0x98000004 , 0x98000007 ) AM_READ ( read_unknown1_32 ) |
| 1197 | AM_RANGE( 0x9800000c , 0x9800000f ) AM_READ ( read_unknown3_32 ) |
| 1198 | |
| 1199 | AM_RANGE( 0x40000000, 0x400fffff ) AM_RAM |
| 1200 | AM_RANGE( 0xa8000000, 0xa8007fff ) AM_RAM AM_BASE(&save_ram32) AM_SHARE("nvram") |
| 1201 | |
| 1202 | ADDRESS_MAP_END |
| 1203 | |
| 1204 | static ADDRESS_MAP_START(risc_mem, AS_PROGRAM, 32) |
| 1205 | |
| 1206 | AM_RANGE( 0x02000000, 0x0201ffff ) AM_ROM AM_REGION("maincpu", 0) // AM_MIRROR(0x2000000) |
| 1207 | AM_RANGE( 0x01000000, 0x01000003 ) AM_WRITE ( write_1000000 ) |
| 1208 | AM_RANGE( 0x01800000, 0x01800003 ) AM_READ ( read_1800000 ) |
| 1209 | AM_RANGE( 0x00000000, 0x0001ffff ) AM_RAM |
| 1210 | |
| 1211 | ADDRESS_MAP_END |
| 1212 | |
| 1213 | static ADDRESS_MAP_START(van16_mem, AS_PROGRAM, 16) |
| 1214 | |
| 1215 | AM_RANGE( 0x000000, 0x03ffff ) AM_ROM |
| 1216 | |
| 1217 | AM_RANGE( 0xc00000 , 0xc00001 ) AM_READ ( mboard_read_board_16 ) |
| 1218 | AM_RANGE( 0xc80000 , 0xc80001 ) AM_WRITE ( mboard_write_board_16 ) |
| 1219 | AM_RANGE( 0xd00000 , 0xd00001 ) AM_WRITE ( mboard_write_LED_16 ) |
| 1220 | AM_RANGE( 0xf00000 , 0xf00009 ) AM_READ ( read_buttons_van16 ) |
| 1221 | AM_RANGE( 0xd80000 , 0xd80001 ) AM_WRITE ( write_LCD_data ) |
| 1222 | AM_RANGE( 0xd80008 , 0xd80009 ) AM_WRITE ( write_IOenables ) |
| 1223 | AM_RANGE( 0xe80004 , 0xe80005 ) AM_WRITE ( write_unknown2 ) |
| 1224 | AM_RANGE( 0xe80002 , 0xe80003 ) AM_READ ( read_unknown1 ) |
| 1225 | AM_RANGE( 0xe80006 , 0xe80007 ) AM_READ ( read_unknown3 ) |
| 1226 | |
| 1227 | AM_RANGE( 0x400000, 0x47ffff ) AM_RAM /* 512KB */ |
| 1228 | AM_RANGE( 0x800000, 0x803fff ) AM_RAM AM_BASE(&save_ram) AM_SHARE("nvram") |
| 1229 | |
| 1230 | ADDRESS_MAP_END |
| 1231 | |
| 1232 | static ADDRESS_MAP_START(alm16_mem, AS_PROGRAM, 16) |
| 1233 | |
| 1234 | AM_RANGE( 0x000000, 0x01ffff ) AM_ROM |
| 1235 | |
| 1236 | AM_RANGE( 0xc00000 , 0xc00001 ) AM_READ ( mboard_read_board_16 ) |
| 1237 | AM_RANGE( 0xc80000 , 0xc80001 ) AM_WRITE ( mboard_write_board_16 ) |
| 1238 | AM_RANGE( 0xd00000 , 0xd00001 ) AM_WRITE ( mboard_write_LED_16 ) |
| 1239 | AM_RANGE( 0xf00000 , 0xf00009 ) AM_READ ( read_buttons_van16 ) |
| 1240 | AM_RANGE( 0xd80000 , 0xd80001 ) AM_WRITE ( write_LCD_data ) |
| 1241 | AM_RANGE( 0xd80008 , 0xd80009 ) AM_WRITE ( write_IOenables ) |
| 1242 | // AM_RANGE( 0xe80004 , 0xe80005 ) AM_WRITE ( write_unknown2 ) |
| 1243 | // AM_RANGE( 0xe80002 , 0xe80003 ) AM_READ ( read_unknown1 ) |
| 1244 | // AM_RANGE( 0xe80006 , 0xe80007 ) AM_READ ( read_unknown3 ) |
| 1245 | |
| 1246 | |
| 1247 | AM_RANGE( 0x400000, 0x47ffff ) AM_RAM /* 512KB */ |
| 1248 | AM_RANGE( 0x800000, 0x803fff ) AM_RAM AM_BASE(&save_ram) AM_SHARE("nvram") |
| 1249 | ADDRESS_MAP_END |
| 1250 | |
| 1251 | |
| 1252 | static ADDRESS_MAP_START(milano_mem , AS_PROGRAM, 8) |
| 1253 | AM_RANGE( 0x0000, 0x1f9f ) AM_RAM |
| 1254 | AM_RANGE( 0x1fd0, 0x1fd0 ) AM_WRITE ( milano_write_board ) // Chessboard |
| 1255 | AM_RANGE( 0x1fe0, 0x1fe0 ) AM_READ ( milano_read_board ) // Chessboard |
| 1256 | AM_RANGE( 0x1fe8, 0x1fed ) AM_WRITE ( milano_write_LED ) // Function LEDs |
| 1257 | AM_RANGE( 0x1fd8, 0x1fdf ) AM_READ ( read_keys) |
| 1258 | AM_RANGE( 0x1ff0, 0x1ff0 ) AM_WRITE ( write_polgar_IO) // IO control |
| 1259 | AM_RANGE( 0x1fc0, 0x1fc0 ) AM_WRITE ( write_LCD_polgar) // LCD Char Reg. (latched) |
| 1260 | AM_RANGE( 0x2000, 0xffff ) AM_ROM |
| 1261 | ADDRESS_MAP_END |
| 1262 | |
| 1263 | |
| 1264 | static ADDRESS_MAP_START(finalchs_mem , AS_PROGRAM, 8) |
| 1265 | AM_RANGE( 0x0000, 0x1fff ) AM_RAM |
| 1266 | AM_RANGE( 0x7ff8, 0x7ff8 ) AM_READ(io7ff8_read) |
| 1267 | AM_RANGE( 0x7ff8, 0x7ff8 ) AM_WRITE(io7ff8_write) |
| 1268 | AM_RANGE( 0x6000, 0x6000 ) AM_READ(io6000_read) |
| 1269 | AM_RANGE( 0x6000, 0x6000 ) AM_WRITE(io6000_write) |
| 1270 | AM_RANGE( 0x8000, 0xffff ) AM_ROM |
| 1271 | ADDRESS_MAP_END |
| 1272 | |
| 1273 | static ADDRESS_MAP_START(academy_mem , AS_PROGRAM, 8) |
| 1274 | AM_RANGE( 0x0000, 0x1fff ) AM_RAM |
| 1275 | AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_academy ) |
| 1276 | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( academy_write_board ) // Chessboard |
| 1277 | AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard |
| 1278 | AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy ) |
| 1279 | AM_RANGE( 0x3001, 0x3001 ) AM_WRITE ( academy_inhibitNMI ) |
| 1280 | AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED ) |
| 1281 | AM_RANGE( 0x3800, 0x3801 ) AM_WRITE ( write_LCD_academy ) |
| 1282 | AM_RANGE( 0x4000, 0xffff ) AM_ROM |
| 1283 | ADDRESS_MAP_END |
| 1284 | |
| 1285 | static ADDRESS_MAP_START(monteciv_mem , AS_PROGRAM, 8) |
| 1286 | AM_RANGE( 0x0000, 0x1fff ) AM_RAM |
| 1287 | AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_monteciv ) |
| 1288 | AM_RANGE( 0x2800, 0x2800 ) AM_WRITE ( academy_write_board ) // Chessboard |
| 1289 | AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard |
| 1290 | AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED ) // Status LEDs |
| 1291 | AM_RANGE( 0x3000, 0x3001 ) AM_WRITE ( monteciv_select_line ) // Select Keyline |
| 1292 | AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy ) |
| 1293 | AM_RANGE( 0x3004, 0x3004 ) AM_WRITE ( monteciv_write_LCD ) |
| 1294 | AM_RANGE( 0x3005, 0x3005 ) AM_WRITE ( monteciv_3005 ) |
| 1295 | AM_RANGE( 0x3007, 0x3007 ) AM_WRITE ( monteciv_3007 ) |
| 1296 | AM_RANGE( 0x3006, 0x3006 ) AM_WRITE ( monteciv_3006 ) |
| 1297 | AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( academy_inhibitNMI ) |
| 1298 | AM_RANGE( 0x8000, 0xffff ) AM_ROM |
| 1299 | ADDRESS_MAP_END |
| 1300 | |
| 1301 | static ADDRESS_MAP_START(megaiv_mem , AS_PROGRAM, 8) |
| 1302 | AM_RANGE( 0x0000, 0x1fff ) AM_RAM |
| 1303 | /// AM_RANGE( 0x2400, 0x2400 ) AM_READ ( read_keys_board_monteciv ) |
| 1304 | AM_RANGE( 0x6800, 0x6800 ) AM_WRITE ( academy_write_board ) // 2800 // Chessboard |
| 1305 | /// AM_RANGE( 0x2c00, 0x2c00 ) AM_WRITE ( mboard_write_LED_8 ) // Chessboard |
| 1306 | /// AM_RANGE( 0x3400, 0x3400 ) AM_WRITE ( academy_write_LED ) // Status LEDs |
| 1307 | AM_RANGE( 0x4400, 0x4400 ) AM_WRITE ( megaiv_write_LED ) // 2400 // Select Keyline |
| 1308 | AM_RANGE( 0x7000, 0x7001 ) AM_WRITE ( megaiv_IO ) // Select Keyline |
| 1309 | /// AM_RANGE( 0x3002, 0x3002 ) AM_WRITE ( beep_academy ) |
| 1310 | AM_RANGE( 0x4000, 0x4007 ) AM_READ ( read_keys_megaiv ) // 3000-7 fixio |
| 1311 | AM_RANGE( 0x2c04, 0x2c04 ) AM_WRITE ( monteciv_write_LCD ) // 2c04 |
| 1312 | AM_RANGE( 0x2c05, 0x2c05 ) AM_WRITE ( monteciv_3005 ) // 2c05 |
| 1313 | AM_RANGE( 0x2c07, 0x2c07 ) AM_WRITE ( monteciv_3007 ) // 2c07 |
| 1314 | AM_RANGE( 0x2c06, 0x2c06 ) AM_WRITE ( monteciv_3006 ) // 2c06 |
| 1315 | /// AM_RANGE( 0x2000, 0x2000 ) AM_WRITE ( academy_inhibitNMI ) |
| 1316 | AM_RANGE( 0x8000, 0xffff ) AM_ROM |
| 1317 | ADDRESS_MAP_END |
| 1318 | |
| 1319 | static ADDRESS_MAP_START(diablo68_mem , AS_PROGRAM, 16) |
| 1320 | AM_RANGE( 0x00000000, 0x0000ffff ) AM_ROM // OS |
| 1321 | // AM_RANGE( 0x00200000, 0x0020ffff ) AM_ROM AM_REGION("maincpu", 0) |
| 1322 | AM_RANGE( 0x00ff0000, 0x00ff7fff ) AM_ROM AM_REGION("maincpu",10000) // Opening Book |
| 1323 | // AM_RANGE( 0x00300000, 0x00300007 ) AM_READ(diablo68_aciaread) |
| 1324 | // AM_RANGE( 0x00300000, 0x00300007 ) AM_READ(diablo68_aciawrite) |
| 1325 | // AM_RANGE( 0x00300002, 0x00300003 ) AM_READ(diablo68_flags) |
| 1326 | AM_RANGE( 0x003a0000, 0x003a0001 ) AM_WRITE(diablo68_write_LCD) |
| 1327 | AM_RANGE( 0x003c0000, 0x003c0001 ) AM_WRITE(diablo68_reg_select) |
| 1328 | AM_RANGE( 0x00280000, 0x0028ffff ) AM_RAM // hash tables |
| 1329 | AM_RANGE( 0x00ff8000, 0x00ffffff ) AM_RAM |
| 1330 | ADDRESS_MAP_END |
| 1331 | |
| 1332 | |
| 1333 | /* Input ports */ |
| 1334 | |
| 1335 | static INPUT_PORTS_START( polgar ) |
| 1336 | |
| 1337 | PORT_START("KEY1_0") //Port $2c00 |
| 1338 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1) |
| 1339 | PORT_START("KEY1_1") //Port $2c01 |
| 1340 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2) |
| 1341 | PORT_START("KEY1_2") //Port $2c02 |
| 1342 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3) |
| 1343 | PORT_START("KEY1_3") //Port $2c03 |
| 1344 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4) |
| 1345 | PORT_START("KEY1_4") //Port $2c04 |
| 1346 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5) |
| 1347 | PORT_START("KEY1_5") //Port $2c05 |
| 1348 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6) |
| 1349 | PORT_START("KEY1_6") //Port $2c06 |
| 1350 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7) |
| 1351 | PORT_START("KEY1_7") //Port $2c07 |
| 1352 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8) |
| 1353 | // PORT_START("KEY1_8") |
| 1354 | // PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" A") PORT_CODE(KEYCODE_1) |
| 1355 | |
| 1356 | PORT_INCLUDE( chessboard ) |
| 1357 | |
| 1358 | INPUT_PORTS_END |
| 1359 | |
| 1360 | static INPUT_PORTS_START( sfortea ) |
| 1361 | PORT_START("BUTTONS_SFOR1") |
| 1362 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_1) |
| 1363 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_2) |
| 1364 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_3) |
| 1365 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_4) |
| 1366 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_5) |
| 1367 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_6) |
| 1368 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7) |
| 1369 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_8) |
| 1370 | |
| 1371 | PORT_START("BUTTONS_SFOR2") |
| 1372 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_F1) |
| 1373 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_F2) |
| 1374 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_F3) |
| 1375 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_F4) |
| 1376 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_F5) |
| 1377 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_F6) |
| 1378 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_F7) |
| 1379 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_F8) |
| 1380 | |
| 1381 | /* PORT_START("BUTTONS_SFOR3") |
| 1382 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_1) |
| 1383 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_2) |
| 1384 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_3) |
| 1385 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_4) |
| 1386 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_5) |
| 1387 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_6) |
| 1388 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7) |
| 1389 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_8) |
| 1390 | */ |
| 1391 | |
| 1392 | PORT_INCLUDE( chessboard ) |
| 1393 | INPUT_PORTS_END |
| 1394 | |
| 1395 | static INPUT_PORTS_START( academy ) |
| 1396 | PORT_START("BUTTONS_ACAD") |
| 1397 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1) |
| 1398 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2) |
| 1399 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3) |
| 1400 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4) |
| 1401 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5) |
| 1402 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6) |
| 1403 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7) |
| 1404 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8) |
| 1405 | |
| 1406 | PORT_INCLUDE( chessboard ) |
| 1407 | INPUT_PORTS_END |
| 1408 | |
| 1409 | static INPUT_PORTS_START( megaiv ) |
| 1410 | |
| 1411 | PORT_START("KEY1_0") //Port $2c00 |
| 1412 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Trn") PORT_CODE(KEYCODE_F1) |
| 1413 | PORT_START("KEY1_1") //Port $2c01 |
| 1414 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Info") PORT_CODE(KEYCODE_F2) // mem |
| 1415 | PORT_START("KEY1_2") //Port $2c02 |
| 1416 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Mem") PORT_CODE(KEYCODE_F3) |
| 1417 | PORT_START("KEY1_3") //Port $2c03 |
| 1418 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" Pos") PORT_CODE(KEYCODE_F4) |
| 1419 | PORT_START("KEY1_4") //Port $2c04 |
| 1420 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" LEV") PORT_CODE(KEYCODE_F5) |
| 1421 | PORT_START("KEY1_5") //Port $2c05 |
| 1422 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" FCT") PORT_CODE(KEYCODE_F6) |
| 1423 | PORT_START("KEY1_6") //Port $2c06 |
| 1424 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" ENT") PORT_CODE(KEYCODE_F7) |
| 1425 | PORT_START("KEY1_7") //Port $2c07 |
| 1426 | PORT_BIT(0x080, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME(" CL") PORT_CODE(KEYCODE_F8) |
| 1427 | // PORT_START("KEY1_8") |
| 1428 | // PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" A") PORT_CODE(KEYCODE_1) |
| 1429 | |
| 1430 | PORT_INCLUDE( chessboard ) |
| 1431 | |
| 1432 | INPUT_PORTS_END |
| 1433 | |
| 1434 | |
| 1435 | static INPUT_PORTS_START( monteciv ) |
| 1436 | PORT_START("BUTTONS_MONTE1") |
| 1437 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 1 Pawn") PORT_CODE(KEYCODE_F1) |
| 1438 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 2 Knight") PORT_CODE(KEYCODE_F2) |
| 1439 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 3 Bishop") PORT_CODE(KEYCODE_F3) |
| 1440 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 4 Rook") PORT_CODE(KEYCODE_F4) |
| 1441 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 5 Queen") PORT_CODE(KEYCODE_F5) |
| 1442 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 6 King") PORT_CODE(KEYCODE_F6) |
| 1443 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 7 Black") PORT_CODE(KEYCODE_F7) |
| 1444 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME(" 8 White") PORT_CODE(KEYCODE_F8) |
| 1445 | |
| 1446 | PORT_START("BUTTONS_MONTE2") |
| 1447 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("9 Book") PORT_CODE(KEYCODE_1) |
| 1448 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("0 Pos") PORT_CODE(KEYCODE_2) |
| 1449 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Mem") PORT_CODE(KEYCODE_3) |
| 1450 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Info") PORT_CODE(KEYCODE_4) |
| 1451 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Clear") PORT_CODE(KEYCODE_5) |
| 1452 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Level") PORT_CODE(KEYCODE_6) |
| 1453 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Enter") PORT_CODE(KEYCODE_7) |
| 1454 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("Reset") PORT_CODE(KEYCODE_8) |
| 1455 | |
| 1456 | |
| 1457 | PORT_INCLUDE( chessboard ) |
| 1458 | INPUT_PORTS_END |
| 1459 | |
| 1460 | |
| 1461 | static INPUT_PORTS_START( gen32 ) |
| 1462 | |
| 1463 | PORT_START("BUTTON_1") |
| 1464 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT) |
| 1465 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER) |
| 1466 | |
| 1467 | PORT_START("BUTTON_2") |
| 1468 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN) |
| 1469 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP) |
| 1470 | |
| 1471 | PORT_START("BUTTON_3") |
| 1472 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT) |
| 1473 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH) |
| 1474 | |
| 1475 | PORT_INCLUDE( chessboard ) |
| 1476 | |
| 1477 | INPUT_PORTS_END |
| 1478 | |
| 1479 | static INPUT_PORTS_START( bpl32 ) |
| 1480 | PORT_START("BUTTONS_BPL") |
| 1481 | PORT_BIT(0x40, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST1") PORT_CODE(KEYCODE_7) |
| 1482 | PORT_BIT(0x80, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RST2") PORT_CODE(KEYCODE_6) |
| 1483 | PORT_BIT(0x10, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT) |
| 1484 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER) |
| 1485 | PORT_BIT(0x08, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN) |
| 1486 | PORT_BIT(0x04, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP) |
| 1487 | PORT_BIT(0x20, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT) |
| 1488 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH) |
| 1489 | |
| 1490 | PORT_INCLUDE( chessboard ) |
| 1491 | INPUT_PORTS_END |
| 1492 | |
| 1493 | |
| 1494 | |
| 1495 | static INPUT_PORTS_START( van32 ) |
| 1496 | |
| 1497 | PORT_START("BUTTON_3") |
| 1498 | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT) |
| 1499 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER) |
| 1500 | |
| 1501 | PORT_START("BUTTON_2") |
| 1502 | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN) |
| 1503 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP) |
| 1504 | |
| 1505 | PORT_START("BUTTON_1") |
| 1506 | PORT_BIT(0x40, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT) |
| 1507 | PORT_BIT(0x80, IP_ACTIVE_LOW, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH) |
| 1508 | |
| 1509 | PORT_INCLUDE( chessboard ) |
| 1510 | |
| 1511 | INPUT_PORTS_END |
| 1512 | |
| 1513 | static INPUT_PORTS_START( van16 ) |
| 1514 | |
| 1515 | PORT_START("BUTTON_1") |
| 1516 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("LEFT") PORT_CODE(KEYCODE_LEFT) |
| 1517 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("ENT") PORT_CODE(KEYCODE_ENTER) |
| 1518 | |
| 1519 | PORT_START("BUTTON_2") |
| 1520 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("RIGHT") PORT_CODE(KEYCODE_RIGHT) |
| 1521 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("UP") PORT_CODE(KEYCODE_UP) |
| 1522 | |
| 1523 | PORT_START("BUTTON_3") |
| 1524 | PORT_BIT(0x01, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("DOWN") PORT_CODE(KEYCODE_DOWN) |
| 1525 | PORT_BIT(0x02, IP_ACTIVE_HIGH, IPT_KEYBOARD) PORT_NAME("CL") PORT_CODE(KEYCODE_BACKSLASH) |
| 1526 | |
| 1527 | PORT_INCLUDE( chessboard ) |
| 1528 | |
| 1529 | INPUT_PORTS_END |
| 1530 | |
| 1531 | static MACHINE_CONFIG_FRAGMENT ( chess_common ) |
| 1532 | |
| 1533 | /* video hardware */ |
| 1534 | |
| 1535 | MCFG_SCREEN_ADD("screen", RASTER) |
| 1536 | MCFG_SCREEN_REFRESH_RATE(50) |
| 1537 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 1538 | MCFG_SCREEN_SIZE(100, 22) |
| 1539 | MCFG_SCREEN_VISIBLE_AREA(0, 100-1, 0, 22-3) |
| 1540 | MCFG_SCREEN_UPDATE(chess_lcd) |
| 1541 | MCFG_PALETTE_LENGTH(2) |
| 1542 | MCFG_PALETTE_INIT(chess_lcd) |
| 1543 | MCFG_QUANTUM_TIME(attotime::from_hz(60)) |
| 1544 | MCFG_GFXDECODE(chess_lcd) |
| 1545 | |
| 1546 | MCFG_HD44780_ADD("hd44780", chess_display) |
| 1547 | |
| 1548 | MCFG_DEFAULT_LAYOUT(layout_lcd) |
| 1549 | |
| 1550 | /* sound hardware */ |
| 1551 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 1552 | MCFG_SOUND_ADD("beep", BEEP, 0) |
| 1553 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0) |
| 1554 | |
| 1555 | MACHINE_CONFIG_END |
| 1556 | |
| 1557 | static MACHINE_CONFIG_START( polgar, polgar_state ) |
| 1558 | MCFG_CPU_ADD("maincpu",M65C02,4915200) |
| 1559 | MCFG_CPU_PROGRAM_MAP(polgar_mem) |
| 1560 | MCFG_QUANTUM_TIME(attotime::from_hz(60)) |
| 1561 | MCFG_MACHINE_START( polgar ) |
| 1562 | MCFG_MACHINE_RESET( polgar ) |
| 1563 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1564 | |
| 1565 | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_nmi, attotime::from_hz(600)) |
| 1566 | MCFG_TIMER_START_DELAY(attotime::from_hz(60)) |
| 1567 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100)) |
| 1568 | |
| 1569 | MACHINE_CONFIG_END |
| 1570 | |
| 1571 | static MACHINE_CONFIG_START( sfortea, driver_device ) |
| 1572 | MCFG_CPU_ADD("maincpu",M65C02,5000000) |
| 1573 | MCFG_CPU_PROGRAM_MAP(sfortea_mem) |
| 1574 | MCFG_QUANTUM_TIME(attotime::from_hz(60)) |
| 1575 | MCFG_MACHINE_START( sfortea ) |
| 1576 | MCFG_MACHINE_RESET( sfortea ) |
| 1577 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1578 | |
| 1579 | /* acia */ |
| 1580 | // MCFG_ACIA6551_ADD("acia65c51") |
| 1581 | |
| 1582 | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_M6502_irq, attotime::from_hz(600)) |
| 1583 | MCFG_TIMER_START_DELAY(attotime::from_hz(60)) |
| 1584 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100)) |
| 1585 | MACHINE_CONFIG_END |
| 1586 | |
| 1587 | static MACHINE_CONFIG_START( alm32, driver_device ) |
| 1588 | MCFG_CPU_ADD("maincpu", M68020, XTAL_12MHz) |
| 1589 | MCFG_CPU_PROGRAM_MAP(alm32_mem) |
| 1590 | MCFG_MACHINE_START(van32) |
| 1591 | MCFG_MACHINE_RESET(van16) |
| 1592 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750)) |
| 1593 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1594 | |
| 1595 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1596 | MCFG_NVRAM_ADD_0FILL("nvram") |
| 1597 | |
| 1598 | MACHINE_CONFIG_END |
| 1599 | |
| 1600 | static MACHINE_CONFIG_DERIVED( academy, polgar ) |
| 1601 | MCFG_CPU_MODIFY("maincpu") |
| 1602 | MCFG_CPU_PROGRAM_MAP(academy_mem) |
| 1603 | MCFG_MACHINE_RESET( academy ) |
| 1604 | MCFG_DEVICE_REMOVE("int_timer") |
| 1605 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq_academy, attotime::from_hz(600)) |
| 1606 | |
| 1607 | MACHINE_CONFIG_END |
| 1608 | |
| 1609 | static MACHINE_CONFIG_START( finalchs, driver_device ) |
| 1610 | MCFG_CPU_ADD("maincpu",M65C02,5000000) |
| 1611 | MCFG_CPU_PROGRAM_MAP(finalchs_mem) |
| 1612 | MCFG_MACHINE_START(finalchs) |
| 1613 | MCFG_SCREEN_ADD("screen", RASTER) |
| 1614 | MCFG_SCREEN_REFRESH_RATE(50) |
| 1615 | MCFG_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 1616 | MCFG_SCREEN_SIZE(6*16, 9*2) |
| 1617 | MCFG_SCREEN_VISIBLE_AREA(0, 6*16-1, 0, 9*2-1) |
| 1618 | MCFG_PALETTE_LENGTH(2) |
| 1619 | MCFG_PALETTE_INIT(chess_lcd) |
| 1620 | |
| 1621 | MACHINE_CONFIG_END |
| 1622 | |
| 1623 | static MACHINE_CONFIG_DERIVED( milano, polgar ) |
| 1624 | MCFG_CPU_MODIFY("maincpu") |
| 1625 | MCFG_CPU_PROGRAM_MAP(milano_mem) |
| 1626 | MACHINE_CONFIG_END |
| 1627 | |
| 1628 | |
| 1629 | static MACHINE_CONFIG_START( monteciv, driver_device ) |
| 1630 | MCFG_CPU_ADD("maincpu",M65C02,8000000) |
| 1631 | MCFG_CPU_PROGRAM_MAP( monteciv_mem ) |
| 1632 | MCFG_MACHINE_START( polgar ) |
| 1633 | MCFG_MACHINE_RESET( monteciv ) |
| 1634 | MCFG_SPEAKER_STANDARD_MONO("mono") |
| 1635 | MCFG_SOUND_ADD("beep", BEEP, 0) |
| 1636 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 1.0) |
| 1637 | |
| 1638 | MCFG_TIMER_ADD_PERIODIC("irq_timer", cause_nmi, attotime::from_hz(600)) |
| 1639 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100)) |
| 1640 | |
| 1641 | MACHINE_CONFIG_END |
| 1642 | |
| 1643 | static MACHINE_CONFIG_DERIVED( megaiv, monteciv ) |
| 1644 | MCFG_CPU_MODIFY("maincpu") |
| 1645 | MCFG_CPU_CLOCK( 4915200 ) |
| 1646 | MCFG_CPU_PROGRAM_MAP(megaiv_mem) |
| 1647 | MACHINE_CONFIG_END |
| 1648 | |
| 1649 | static MACHINE_CONFIG_START( diablo68, driver_device ) |
| 1650 | MCFG_CPU_ADD("maincpu", M68000, XTAL_16MHz) |
| 1651 | MCFG_CPU_PROGRAM_MAP(diablo68_mem) |
| 1652 | MCFG_MACHINE_START(diablo68) |
| 1653 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1654 | |
| 1655 | /* acia */ |
| 1656 | // MCFG_ACIA6551_ADD("acia65c51") |
| 1657 | |
| 1658 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq2, attotime::from_hz(60)) |
| 1659 | MCFG_TIMER_START_DELAY(attotime::from_hz(30)) |
| 1660 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1661 | |
| 1662 | |
| 1663 | MACHINE_CONFIG_END |
| 1664 | |
| 1665 | static MACHINE_CONFIG_START( van16, driver_device ) |
| 1666 | MCFG_CPU_ADD("maincpu", M68000, XTAL_12MHz) |
| 1667 | MCFG_CPU_PROGRAM_MAP(van16_mem) |
| 1668 | MCFG_MACHINE_START(van16) |
| 1669 | MCFG_MACHINE_RESET(van16) |
| 1670 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(600)) // chess clock right, diags wrong |
| 1671 | // MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(587)) // vv |
| 1672 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1673 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1674 | MCFG_NVRAM_ADD_0FILL("nvram") |
| 1675 | |
| 1676 | MACHINE_CONFIG_END |
| 1677 | |
| 1678 | static MACHINE_CONFIG_DERIVED( alm16, van16 ) |
| 1679 | MCFG_CPU_MODIFY("maincpu") |
| 1680 | MCFG_CPU_PROGRAM_MAP(alm16_mem) |
| 1681 | MACHINE_CONFIG_END |
| 1682 | |
| 1683 | static MACHINE_CONFIG_START( van32, driver_device ) |
| 1684 | MCFG_CPU_ADD("maincpu", M68020, XTAL_12MHz) |
| 1685 | MCFG_CPU_PROGRAM_MAP(van32_mem) |
| 1686 | MCFG_MACHINE_START(van32) |
| 1687 | MCFG_MACHINE_RESET(van16) |
| 1688 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750)) |
| 1689 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1690 | |
| 1691 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1692 | MCFG_NVRAM_ADD_0FILL("nvram") |
| 1693 | |
| 1694 | MACHINE_CONFIG_END |
| 1695 | |
| 1696 | static MACHINE_CONFIG_START( risc, driver_device ) |
| 1697 | MCFG_CPU_ADD("maincpu", ARM, 14000000) |
| 1698 | MCFG_CPU_PROGRAM_MAP(risc_mem) |
| 1699 | MCFG_MACHINE_START(risc) |
| 1700 | MCFG_MACHINE_RESET(van16) |
| 1701 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1702 | |
| 1703 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1704 | // MCFG_NVRAM_ADD_0FILL("nvram") |
| 1705 | |
| 1706 | MACHINE_CONFIG_END |
| 1707 | |
| 1708 | static MACHINE_CONFIG_START( gen32, driver_device ) |
| 1709 | MCFG_CPU_ADD("maincpu", M68030, XTAL_33_333MHz) |
| 1710 | MCFG_CPU_PROGRAM_MAP(gen32_mem) |
| 1711 | MCFG_MACHINE_START(van32) |
| 1712 | MCFG_MACHINE_RESET(van16) |
| 1713 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(375)) |
| 1714 | // MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(368.64)) |
| 1715 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(120)) |
| 1716 | |
| 1717 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1718 | MCFG_NVRAM_ADD_0FILL("nvram") |
| 1719 | |
| 1720 | |
| 1721 | MACHINE_CONFIG_END |
| 1722 | |
| 1723 | static MACHINE_CONFIG_DERIVED( gen32_oc, gen32 ) |
| 1724 | MCFG_CPU_MODIFY("maincpu") |
| 1725 | MCFG_CPU_CLOCK( XTAL_33_333MHz * 2 ) |
| 1726 | MCFG_DEVICE_REMOVE("int_timer") |
| 1727 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(500)) |
| 1728 | |
| 1729 | |
| 1730 | MACHINE_CONFIG_END |
| 1731 | |
| 1732 | static MACHINE_CONFIG_START( bpl32, driver_device ) |
| 1733 | MCFG_CPU_ADD("maincpu", M68020, XTAL_24_576MHz) |
| 1734 | MCFG_CPU_PROGRAM_MAP(bpl32_mem) |
| 1735 | MCFG_MACHINE_START(van32) |
| 1736 | MCFG_MACHINE_RESET(van16) |
| 1737 | MCFG_TIMER_ADD_PERIODIC("int_timer", timer_update_irq6, attotime::from_hz(750)) |
| 1738 | MCFG_TIMER_ADD_PERIODIC("artwork_timer", mboard_update_artwork, attotime::from_hz(100)) |
| 1739 | |
| 1740 | MCFG_FRAGMENT_ADD( chess_common ) |
| 1741 | MCFG_NVRAM_ADD_0FILL("nvram") |
| 1742 | |
| 1743 | MACHINE_CONFIG_END |
| 1744 | |
| 1745 | |
| 1746 | /* ROM definitions */ |
| 1747 | |
| 1748 | |
| 1749 | |
| 1750 | ROM_START(polgar) |
| 1751 | ROM_REGION(0x10000,"maincpu",0) |
| 1752 | ROM_LOAD("polgar.bin", 0x0000, 0x10000, CRC(88d55c0f) SHA1(e86d088ec3ac68deaf90f6b3b97e3e31b1515913)) |
| 1753 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1754 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1755 | ROM_END |
| 1756 | |
| 1757 | ROM_START(sfortea) |
| 1758 | ROM_REGION(0x18000,"maincpu",0) |
| 1759 | ROM_LOAD("sfalo.bin", 0x0000, 0x8000, CRC(86e0230a) SHA1(0d6e18a17e636b8c7292c8f331349d361892d1a8)) |
| 1760 | ROM_LOAD("sfahi.bin", 0x8000, 0x8000, CRC(81c02746) SHA1(0bf68b68ade5a3263bead88da0a8965fc71483c1)) |
| 1761 | ROM_LOAD("sfabook.bin", 0x10000, 0x8000, CRC(3e42cf7c) SHA1(b2faa36a127e08e5755167a25ed4a07f12d62957)) |
| 1762 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1763 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1764 | ROM_END |
| 1765 | |
| 1766 | ROM_START( alm16 ) |
| 1767 | ROM_REGION16_BE( 0x20000, "maincpu", 0 ) |
| 1768 | ROM_LOAD16_BYTE("alm16eve.bin", 0x00000, 0x10000,CRC(EE5B6EC4) SHA1(30920C1B9E16FFAE576DA5AFA0B56DA59ADA3DBB)) |
| 1769 | ROM_LOAD16_BYTE("alm16odd.bin" , 0x00001, 0x10000,CRC(D0BE4EE4) SHA1(D36C074802D2C9099CD44E75F9DE3FC7D1FD9908)) |
| 1770 | |
| 1771 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1772 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1773 | |
| 1774 | ROM_END |
| 1775 | |
| 1776 | ROM_START( alm32 ) |
| 1777 | ROM_REGION32_BE( 0x20000, "maincpu", 0 ) |
| 1778 | ROM_LOAD("alm32.bin", 0x00000, 0x20000,CRC(38F4B305) SHA1(43459A057FF29248C74D656A036AC325202B9C15)) |
| 1779 | |
| 1780 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1781 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1782 | |
| 1783 | ROM_END |
| 1784 | |
| 1785 | ROM_START(sforteb) |
| 1786 | ROM_REGION(0x18000,"maincpu",0) |
| 1787 | ROM_LOAD("forte_b.lo", 0x0000, 0x8000, CRC(48bfe5d6) SHA1(323642686b6d2fb8db2b7d50c6cd431058078ce1)) |
| 1788 | ROM_LOAD("forte_b.hi1", 0x8000, 0x8000, CRC(9778ca2c) SHA1(d8b88b9768a1a9171c68cbb0892b817d68d78351)) |
| 1789 | ROM_LOAD("forte_b.hi0", 0x10000, 0x8000, CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6)) |
| 1790 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1791 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1792 | ROM_END |
| 1793 | |
| 1794 | ROM_START(sforteba) |
| 1795 | ROM_REGION(0x18000,"maincpu",0) |
| 1796 | ROM_LOAD("forte b_l.bin", 0x0000, 0x8000, CRC(e3d194a1) SHA1(80457580d7c57e07895fd14bfdaf14b30952afca)) |
| 1797 | ROM_LOAD("forte b_h.bin", 0x8000, 0x8000, CRC(dd824be8) SHA1(cd8666b6b525887f9fc48a730b71ceabcf07f3b9)) |
| 1798 | ROM_LOAD("forte_b.hi0", 0x10000, 0x8000, BAD_DUMP CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6)) |
| 1799 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1800 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1801 | ROM_END |
| 1802 | |
| 1803 | ROM_START(sexpertb) |
| 1804 | ROM_REGION(0x18000,"maincpu",0) |
| 1805 | ROM_LOAD("seb69u3.bin", 0x0000, 0x8000, CRC(92002eb6) SHA1(ed8ca16701e00b48fa55c856fa4a8c6613079c02)) |
| 1806 | ROM_LOAD("seb69u1.bin", 0x8000, 0x8000, CRC(814b4420) SHA1(c553e6a8c048dcc1cf48d410111a86e06b99d356)) |
| 1807 | ROM_LOAD("seb605u2.bin", 0x10000, 0x8000, CRC(bb07ad52) SHA1(30cf9005021ab2d7b03facdf2d3588bc94dc68a6)) |
| 1808 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1809 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1810 | ROM_END |
| 1811 | |
| 1812 | ROM_START(academy) |
| 1813 | ROM_REGION(0x10000,"maincpu",0) |
| 1814 | ROM_LOAD("acad8000.bin", 0x8000, 0x8000, CRC(A967922B) SHA1(1327903FF89BF96D72C930C400F367AE19E3EC68)) |
| 1815 | ROM_LOAD("acad4000.bin", 0x4000, 0x4000, CRC(EE1222B5) SHA1(98541D87755A7186B69B9723CC4ADBD07F20F0E2)) |
| 1816 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1817 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1818 | ROM_END |
| 1819 | |
| 1820 | ROM_START(finalchs) |
| 1821 | ROM_REGION(0x10000,"maincpu",0) |
| 1822 | ROM_LOAD("finalchs.bin", 0x8000, 0x8000, CRC(c8e72dff) SHA1(f422b19a806cef4fadd580caefaaf8c32b644098)) |
| 1823 | ROM_END |
| 1824 | |
| 1825 | ROM_START(megaiv) |
| 1826 | ROM_REGION(0x10000,"maincpu",0) |
| 1827 | ROM_LOAD("megaiv.bin", 0x8000, 0x8000, CRC(dee355d2) SHA1(6bc79c0fb169020f017412f5f9696b9ecafbf99f)) |
| 1828 | |
| 1829 | ROM_END |
| 1830 | |
| 1831 | ROM_START(milano) |
| 1832 | ROM_REGION(0x10000,"maincpu",0) |
| 1833 | ROM_LOAD("milano.bin", 0x0000, 0x10000, CRC(0e9c8fe1) SHA1(e9176f42d86fe57e382185c703c7eff7e63ca711)) |
| 1834 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1835 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1836 | ROM_END |
| 1837 | |
| 1838 | |
| 1839 | ROM_START(sfortec) |
| 1840 | ROM_REGION(0x18000,"maincpu",0) |
| 1841 | ROM_LOAD("sfclow.bin", 0x0000, 0x8000, CRC(f040cf30) SHA1(1fc1220b8ed67cdffa3866d230ce001721cf684f)) |
| 1842 | ROM_LOAD("sfchi.bin", 0x8000, 0x8000, CRC(0f926b32) SHA1(9c7270ecb3f41dd9172a9a7928e6e04e64b2a340)) |
| 1843 | ROM_LOAD("sfcbook.bin", 0x10000, 0x8000, CRC(c6a1419a) SHA1(017a0ffa9aa59438c879624a7ddea2071d1524b8)) |
| 1844 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1845 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1846 | ROM_END |
| 1847 | |
| 1848 | |
| 1849 | ROM_START(sexpertc) |
| 1850 | ROM_REGION(0x18000,"maincpu",0) // Version 3.6 of firmware |
| 1851 | ROM_LOAD("seclow.bin", 0x0000, 0x8000, CRC(5a29105e) SHA1(be37bb29b530dbba847a5e8d27d81b36525e47f7)) |
| 1852 | ROM_LOAD("sechi.bin", 0x8000, 0x8000, CRC(0085c2c4) SHA1(d84bf4afb022575db09dd9dc12e9b330acce35fa)) |
| 1853 | ROM_LOAD("secbook.bin", 0x10000, 0x8000, CRC(2d085064) SHA1(76162322aa7d23a5c07e8356d0bbbb33816419af)) |
| 1854 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1855 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1856 | ROM_END |
| 1857 | |
| 1858 | ROM_START( lyon16 ) |
| 1859 | ROM_REGION16_BE( 0x20000, "maincpu", 0 ) |
| 1860 | ROM_LOAD16_BYTE("lyon16ev.bin", 0x00000, 0x10000,CRC(497BD41A) SHA1(3FFEFEEAC694F49997C10D248EC6A7AA932898A4)) |
| 1861 | ROM_LOAD16_BYTE("lyon16od.bin" , 0x00001, 0x10000,CRC(F9DE3F54) SHA1(4060E29566D2F40122CCDE3C1F84C94A9C1ED54F)) |
| 1862 | |
| 1863 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1864 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1865 | |
| 1866 | ROM_END |
| 1867 | |
| 1868 | ROM_START( lyon32 ) |
| 1869 | ROM_REGION32_BE( 0x20000, "maincpu", 0 ) |
| 1870 | ROM_LOAD("lyon32.bin", 0x00000, 0x20000, CRC(5C128B06) SHA1(954C8F0D3FAE29900CB1E9C14A41A9A07A8E185F)) |
| 1871 | |
| 1872 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1873 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1874 | |
| 1875 | ROM_END |
| 1876 | |
| 1877 | |
| 1878 | ROM_START(monteciv) |
| 1879 | ROM_REGION(0x10000,"maincpu",0) |
| 1880 | ROM_LOAD("mciv.bin", 0x8000, 0x8000, CRC(C4887694) SHA1(7f482d2a40fcb3125266e7a5407da315b4f9b49c)) |
| 1881 | |
| 1882 | ROM_END |
| 1883 | |
| 1884 | ROM_START( diablo68 ) |
| 1885 | ROM_REGION16_BE( 0x20000, "maincpu", 0 ) |
| 1886 | ROM_LOAD16_BYTE("evenurom.bin", 0x00000, 0x8000,CRC(03477746) SHA1(8bffcb159a61e59bfc45411e319aea6501ebe2f9)) |
| 1887 | ROM_LOAD16_BYTE("oddlrom.bin", 0x00001, 0x8000,CRC(e182dbdd) SHA1(24dacbef2173fa737636e4729ff22ec1e6623ca5)) |
| 1888 | ROM_LOAD16_BYTE("book.bin", 0x10000, 0x8000,CRC(553a5c8c) SHA1(ccb5460ff10766a5ca8008ae2cffcff794318108)) |
| 1889 | |
| 1890 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1891 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1892 | |
| 1893 | ROM_END |
| 1894 | |
| 1895 | ROM_START( van16 ) |
| 1896 | ROM_REGION16_BE( 0x40000, "maincpu", 0 ) |
| 1897 | ROM_LOAD16_BYTE("va16even.bin", 0x00000, 0x20000,CRC(E87602D5) SHA1(90CB2767B4AE9E1B265951EB2569B9956B9F7F44)) |
| 1898 | ROM_LOAD16_BYTE("va16odd.bin" , 0x00001, 0x20000,CRC(585F3BDD) SHA1(90BB94A12D3153A91E3760020E1EA2A9EAA7EC0A)) |
| 1899 | |
| 1900 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1901 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1902 | |
| 1903 | ROM_END |
| 1904 | |
| 1905 | |
| 1906 | ROM_START( van32 ) |
| 1907 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1908 | ROM_LOAD("vanc32.bin", 0x00000, 0x40000,CRC(F872BEB5) SHA1(9919F207264F74E2B634B723B048AE9CA2CEFBC7)) |
| 1909 | |
| 1910 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1911 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1912 | |
| 1913 | ROM_END |
| 1914 | |
| 1915 | |
| 1916 | ROM_START( risc ) |
| 1917 | ROM_REGION( 0x20000, "maincpu", 0 ) |
| 1918 | ROM_LOAD("s2500.bin", 0x000000, 0x20000, CRC(7a707e82) SHA1(87187fa58117a442f3abd30092cfcc2a4d7c7efc)) |
| 1919 | |
| 1920 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1921 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1922 | |
| 1923 | ROM_END |
| 1924 | |
| 1925 | ROM_START( gen32 ) |
| 1926 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1927 | ROM_LOAD("gen32_4.bin", 0x00000, 0x40000,CRC(6CC4DA88) SHA1(EA72ACF9C67ED17C6AC8DE56A165784AA629C4A1)) |
| 1928 | |
| 1929 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1930 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1931 | |
| 1932 | ROM_END |
| 1933 | |
| 1934 | ROM_START( gen32_41 ) |
| 1935 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1936 | ROM_LOAD("gen32_41.bin", 0x00000, 0x40000,CRC(ea9938c0) SHA1(645cf0b5b831b48104ad6cec8d78c63dbb6a588c)) |
| 1937 | |
| 1938 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1939 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1940 | |
| 1941 | ROM_END |
| 1942 | |
| 1943 | ROM_START( gen32_oc ) |
| 1944 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1945 | ROM_LOAD("gen32_41.bin", 0x00000, 0x40000,CRC(ea9938c0) SHA1(645cf0b5b831b48104ad6cec8d78c63dbb6a588c)) |
| 1946 | |
| 1947 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1948 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1949 | |
| 1950 | ROM_END |
| 1951 | |
| 1952 | ROM_START( berlinp ) |
| 1953 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1954 | ROM_LOAD("berlinp.bin", 0x00000, 0x40000,CRC(82FBAF6E) SHA1(729B7CEF3DFAECC4594A6178FC4BA6015AFA6202)) |
| 1955 | |
| 1956 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1957 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1958 | |
| 1959 | ROM_END |
| 1960 | |
| 1961 | ROM_START( bpl32 ) |
| 1962 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1963 | ROM_LOAD("bpl32.bin", 0x00000, 0x40000,CRC(D75E170F) SHA1(AC0EBDAA114ABD4FEF87361A03DF56928768B1AE)) |
| 1964 | |
| 1965 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1966 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1967 | |
| 1968 | ROM_END |
| 1969 | |
| 1970 | ROM_START( lond020 ) |
| 1971 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1972 | ROM_LOAD("lond020.bin", 0x00000, 0x40000,CRC(3225B8DA) SHA1(FD8F6F4E9C03B6CDC86D8405E856C26041BFAD12)) |
| 1973 | |
| 1974 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1975 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1976 | |
| 1977 | ROM_END |
| 1978 | |
| 1979 | ROM_START( lond030 ) |
| 1980 | ROM_REGION32_BE( 0x40000, "maincpu", 0 ) |
| 1981 | ROM_LOAD("lond030.bin", 0x00000, 0x40000,CRC(853BAA4E) SHA1(946951081D4E91E5BDD9E93D0769568A7FE79BAD)) |
| 1982 | |
| 1983 | ROM_REGION( 0x0860, "hd44780", ROMREGION_ERASE ) |
| 1984 | ROM_LOAD( "44780a00.bin", 0x0000, 0x0860, BAD_DUMP CRC(3a89024c) SHA1(5a87b68422a916d1b37b5be1f7ad0b3fb3af5a8d)) |
| 1985 | |
| 1986 | ROM_END |
| 1987 | |
| 1988 | static DRIVER_INIT( polgar ) |
| 1989 | { |
| 1990 | polgar_state *state = machine.driver_data<polgar_state>(); |
| 1991 | state->led_status=0; |
| 1992 | } |
| 1993 | |
| 1994 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME FLAGS */ |
| 1995 | CONS( 1986, polgar, 0, 0, polgar, polgar, polgar,"Hegener & Glaser", "Mephisto Polgar Schachcomputer", GAME_REQUIRES_ARTWORK) |
| 1996 | CONS( 1987, sfortea, 0, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte A Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 1997 | CONS( 1988, alm16, van16, 0, alm16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Almeria 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 1998 | CONS( 1988, alm32, van16, 0, alm32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Alimera 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 1999 | CONS( 1988, sforteb, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte B Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2000 | CONS( 1988, sforteba, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Super Forte B Chess Computer (ALT)",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2001 | CONS( 1988, sexpertb, sfortea, 0, sfortea, sfortea, 0,"Novag", "Novag Expert B Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2002 | CONS( 1989, academy, 0, 0, academy, academy, 0, "Hegener & Glaser", "Mephisto Academy Schachcomputer",GAME_REQUIRES_ARTWORK|GAME_NOT_WORKING ) |
| 2003 | CONS( 1989, finalchs,0, 0,finalchs, 0, 0,"TASC", "The Final Chess Card",GAME_NOT_WORKING|GAME_NO_SOUND ) |
| 2004 | CONS( 1989, megaiv, 0, 0, megaiv, megaiv, 0, "Hegener & Glaser", "Mephisto Mega IV Schachcomputer",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK ) |
| 2005 | CONS( 1989, milano, polgar, 0, milano, polgar, polgar, "Hegener & Glaser", "Mephisto Milano Schachcomputer",GAME_REQUIRES_ARTWORK ) |
| 2006 | //CONS( 1989, montec4, 0, 0, monteciv, monteciv, 0, "Hegener & Glaser", "Mephisto Monte Carlo IV",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK ) |
| 2007 | CONS( 1989, sfortec, sfortea, 0, sfortea, sfortea, 0, "Novag", "Novag Super Forte C Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2008 | CONS( 1989, sexpertc, sfortea, 0, sfortea, sfortea, 0, "Novag", "Novag Super Expert C Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2009 | CONS( 1990, lyon16,van16, 0, alm16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Lyon 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2010 | CONS( 1990, lyon32, van16, 0, alm32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Lyon 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2011 | CONS( 1990, monteciv, 0, 0, monteciv, monteciv, 0, "Hegener & Glaser", "Mephisto Monte Carlo IV LE Schachcomputer",GAME_SUPPORTS_SAVE|GAME_NOT_WORKING|GAME_REQUIRES_ARTWORK ) |
| 2012 | CONS( 1991, diablo68, 0, 0, diablo68, sfortea, 0, "Novag", "Novag Diablo 68000 Chess Computer",GAME_NO_SOUND|GAME_SUPPORTS_SAVE|GAME_NOT_WORKING ) |
| 2013 | CONS( 1991, van16, 0, 0, van16, van16, 0, "Hegener & Glaser Muenchen", "Mephisto Vancouver 68000",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2014 | CONS( 1991, van32, van16, 0, van32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto Vancouver 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2015 | CONS( 1992, risc,0, 0, risc, van16, 0, "Saitek", "RISC2500",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK|GAME_NOT_WORKING ) |
| 2016 | CONS( 1993, gen32, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2017 | CONS( 1993, gen32_41, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.01",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2018 | CONS( 1993, gen32_oc, van16, 0, gen32_oc, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 V4.01OC",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK|GAME_UNOFFICIAL ) |
| 2019 | CONS( 1994, berlinp, van16, 0, bpl32, bpl32, 0, "Hegener & Glaser Muenchen", "Mephisto Berlin Pro 68020",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2020 | CONS( 1996, bpl32, van16, 0, bpl32, bpl32, 0, "Hegener & Glaser Muenchen", "Mephisto Berlin Pro London Upgrade V5.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2021 | CONS( 1996, lond020, van16, 0, van32, van32, 0, "Hegener & Glaser Muenchen", "Mephisto London 68020 32 Bit",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |
| 2022 | CONS( 1996, lond030, van16, 0, gen32, gen32, 0, "Hegener & Glaser Muenchen", "Mephisto Genius030 London Upgrade V5.00",GAME_SUPPORTS_SAVE|GAME_REQUIRES_ARTWORK ) |