src/mess/video/atarist.c
| r811 | r812 | |
| 1 | | /*
|
| 2 | | |
| 3 | | TODO:
|
| 4 | | |
| 5 | | - lineofs
|
| 6 | | - pixelofs
|
| 7 | | - monochrome mode
|
| 8 | | - change screen modes on the fly
|
| 9 | | - blitter
|
| 10 | | |
| 11 | | */
|
| 12 | | |
| 13 | | #include "driver.h"
|
| 14 | | #include "video/generic.h"
|
| 15 | | #include "cpu/m68000/m68k.h"
|
| 16 | | #include "cpu/m68000/m68000.h"
|
| 17 | | #include "machine/68901mfp.h"
|
| 18 | | #include "video/atarist.h"
|
| 19 | | |
| 20 | | static struct SHIFTER
|
| 21 | | {
|
| 22 | | UINT32 base;
|
| 23 | | UINT32 ofs;
|
| 24 | | UINT8 sync;
|
| 25 | | UINT8 mode;
|
| 26 | | UINT16 palette[16];
|
| 27 | | UINT8 lineofs; // STe
|
| 28 | | UINT8 pixelofs; // STe
|
| 29 | | UINT16 rr[4];
|
| 30 | | UINT16 ir[4];
|
| 31 | | int vcount;
|
| 32 | | int hcount;
|
| 33 | | int bitplane;
|
| 34 | | int shift;
|
| 35 | | int h, v;
|
| 36 | | } shifter;
|
| 37 | | |
| 38 | | static mame_timer *atarist_glue_timer;
|
| 39 | | static mame_timer *atarist_shifter_timer;
|
| 40 | | static mame_bitmap *atarist_bitmap;
|
| 41 | | |
| 42 | | static TIMER_CALLBACK(atarist_shifter_tick)
|
| 43 | | {
|
| 44 | | int y = video_screen_get_vpos(0);
|
| 45 | | int x = video_screen_get_hpos(0);
|
| 46 | | int color;
|
| 47 | | |
| 48 | | switch (shifter.mode)
|
| 49 | | {
|
| 50 | | case 0: // 320 x 200, 4 Plane
|
| 51 | | color = (BIT(shifter.rr[3], 15) << 3) | (BIT(shifter.rr[2], 15) << 2) | (BIT(shifter.rr[1], 15) << 1) | BIT(shifter.rr[0], 15);
|
| 52 | | |
| 53 | | //logerror("y %u x %u color %u mode %u de %u h %u v %u hc %u\n", y, x, color, shifter.mode, shifter.h&&shifter.v, shifter.h, shifter.v, shifter.hcount);
|
| 54 | | |
| 55 | | *BITMAP_ADDR16(atarist_bitmap, y, x) = Machine->pens[color];
|
| 56 | | |
| 57 | | shifter.rr[0] <<= 1;
|
| 58 | | shifter.rr[1] <<= 1;
|
| 59 | | shifter.rr[2] <<= 1;
|
| 60 | | shifter.rr[3] <<= 1;
|
| 61 | | |
| 62 | | break;
|
| 63 | | |
| 64 | | case 1: // 640 x 200, 2 Plane
|
| 65 | | color = (BIT(shifter.rr[1], 15) << 1) | BIT(shifter.rr[0], 15);
|
| 66 | | |
| 67 | | *BITMAP_ADDR16(atarist_bitmap, y, x) = Machine->pens[color];
|
| 68 | | |
| 69 | | shifter.rr[0] <<= 1;
|
| 70 | | shifter.rr[1] <<= 1;
|
| 71 | | shifter.shift++;
|
| 72 | | |
| 73 | | if (shifter.shift == 15)
|
| 74 | | {
|
| 75 | | shifter.rr[0] = shifter.rr[2];
|
| 76 | | shifter.rr[1] = shifter.rr[3];
|
| 77 | | shifter.rr[2] = shifter.rr[3] = 0;
|
| 78 | | shifter.shift = 0;
|
| 79 | | }
|
| 80 | | break;
|
| 81 | | |
| 82 | | case 2: // 640 x 400, 1 Plane
|
| 83 | | // unimplemented
|
| 84 | | break;
|
| 85 | | }
|
| 86 | | }
|
| 87 | | |
| 88 | | static TIMER_CALLBACK(atarist_glue_tick)
|
| 89 | | {
|
| 90 | | int de;
|
| 91 | | UINT8 *RAM = memory_region(REGION_CPU1) + shifter.base + shifter.ofs;
|
| 92 | | |
| 93 | | shifter.hcount = video_screen_get_hpos(0) / 4;
|
| 94 | | shifter.vcount = video_screen_get_vpos(0);
|
| 95 | | |
| 96 | | if (shifter.sync & 0x02)
|
| 97 | | {
|
| 98 | | // 50 Hz
|
| 99 | | |
| 100 | | switch (shifter.hcount)
|
| 101 | | {
|
| 102 | | case ATARIST_HBDEND_PAL:
|
| 103 | | shifter.h = ASSERT_LINE;
|
| 104 | | break;
|
| 105 | | case ATARIST_HBDSTART_PAL:
|
| 106 | | shifter.h = CLEAR_LINE;
|
| 107 | | break;
|
| 108 | | case 128:
|
| 109 | | cpunum_set_input_line(0, MC68000_IRQ_2, ASSERT_LINE);
|
| 110 | | break;
|
| 111 | | }
|
| 112 | | |
| 113 | | switch (shifter.vcount)
|
| 114 | | {
|
| 115 | | case ATARIST_VBDEND_PAL:
|
| 116 | | shifter.v = ASSERT_LINE;
|
| 117 | | break;
|
| 118 | | case ATARIST_VBDSTART_PAL:
|
| 119 | | shifter.v = CLEAR_LINE;
|
| 120 | | break;
|
| 121 | | case ATARIST_VBSTART_PAL:
|
| 122 | | cpunum_set_input_line(0, MC68000_IRQ_4, ASSERT_LINE);
|
| 123 | | shifter.ofs = 0;
|
| 124 | | break;
|
| 125 | | }
|
| 126 | | }
|
| 127 | | else
|
| 128 | | {
|
| 129 | | // 60 Hz
|
| 130 | | switch (shifter.hcount)
|
| 131 | | {
|
| 132 | | case ATARIST_HBDEND_NTSC:
|
| 133 | | shifter.h = ASSERT_LINE;
|
| 134 | | break;
|
| 135 | | case ATARIST_HBDSTART_NTSC:
|
| 136 | | shifter.h = CLEAR_LINE;
|
| 137 | | break;
|
| 138 | | case 127:
|
| 139 | | cpunum_set_input_line(0, MC68000_IRQ_2, ASSERT_LINE);
|
| 140 | | break;
|
| 141 | | }
|
| 142 | | |
| 143 | | switch (shifter.vcount)
|
| 144 | | {
|
| 145 | | case ATARIST_VBDEND_NTSC:
|
| 146 | | shifter.v = ASSERT_LINE;
|
| 147 | | break;
|
| 148 | | case ATARIST_VBDSTART_NTSC:
|
| 149 | | shifter.v = CLEAR_LINE;
|
| 150 | | break;
|
| 151 | | case ATARIST_VBSTART_NTSC:
|
| 152 | | cpunum_set_input_line(0, MC68000_IRQ_4, ASSERT_LINE);
|
| 153 | | shifter.ofs = 0;
|
| 154 | | break;
|
| 155 | | }
|
| 156 | | }
|
| 157 | | |
| 158 | | de = shifter.h && shifter.v;
|
| 159 | | |
| 160 | | mfp68901_tbi_w(0, de);
|
| 161 | |
|
| 162 | | if (de)
|
| 163 | | {
|
| 164 | | shifter.ir[shifter.bitplane] = (RAM[0] << 8) | RAM[1];
|
| 165 | | shifter.ofs += 2;
|
| 166 | | shifter.bitplane++;
|
| 167 | | |
| 168 | | if (shifter.bitplane == 4)
|
| 169 | | {
|
| 170 | | shifter.bitplane = 0;
|
| 171 | |
|
| 172 | | shifter.rr[0] = shifter.ir[0];
|
| 173 | | shifter.rr[1] = shifter.ir[1];
|
| 174 | | shifter.rr[2] = shifter.ir[2];
|
| 175 | | shifter.rr[3] = shifter.ir[3];
|
| 176 | | |
| 177 | | shifter.ir[0] = shifter.ir[1] = shifter.ir[2] = shifter.ir[3] = 0;
|
| 178 | | }
|
| 179 | | }
|
| 180 | | }
|
| 181 | | |
| 182 | | READ16_HANDLER( atarist_shifter_r )
|
| 183 | | {
|
| 184 | | switch (offset)
|
| 185 | | {
|
| 186 | | case 0x00:
|
| 187 | | return (shifter.base >> 16) & 0xff;
|
| 188 | | case 0x02:
|
| 189 | | return (shifter.base >> 8) & 0xff;
|
| 190 | | |
| 191 | | case 0x04:
|
| 192 | | return (shifter.ofs >> 16) & 0xff;
|
| 193 | | case 0x06:
|
| 194 | | return (shifter.ofs >> 8) & 0xff;
|
| 195 | | case 0x08:
|
| 196 | | return shifter.ofs & 0xff;
|
| 197 | | |
| 198 | | case 0x0a:
|
| 199 | | return shifter.sync;
|
| 200 | | case 0x60:
|
| 201 | | return shifter.mode << 8;
|
| 202 | | |
| 203 | | default:
|
| 204 | | if ((offset & 0xe0) == 0x40)
|
| 205 | | {
|
| 206 | | return shifter.palette[offset & 0x1f];
|
| 207 | | }
|
| 208 | | }
|
| 209 | | |
| 210 | | return 0;
|
| 211 | | }
|
| 212 | | |
| 213 | | WRITE16_HANDLER( atarist_shifter_w )
|
| 214 | | {
|
| 215 | | switch (offset)
|
| 216 | | {
|
| 217 | | case 0x00:
|
| 218 | | shifter.base = (shifter.base & 0x00ff00) | (data & 0x3f) << 16;
|
| 219 | | logerror("shifter base %x\n", shifter.base);
|
| 220 | | break;
|
| 221 | | case 0x02:
|
| 222 | | shifter.base = (shifter.base & 0xff0000) | (data & 0xff) << 8;
|
| 223 | | logerror("shifter base %x\n", shifter.base);
|
| 224 | | break;
|
| 225 | | |
| 226 | | case 0x0a:
|
| 227 | | shifter.sync = data >> 8;
|
| 228 | | logerror("shifter sync %x\n", shifter.sync);
|
| 229 | | break;
|
| 230 | | |
| 231 | | case 0x60:
|
| 232 | | shifter.mode = data >> 8;
|
| 233 | | logerror("shifter mode %x\n", shifter.mode);
|
| 234 | | break;
|
| 235 | | |
| 236 | | default:
|
| 237 | | if ((offset & 0xe0) == 0x40)
|
| 238 | | {
|
| 239 | | int i = offset & 0x1f;
|
| 240 | | shifter.palette[i] = data;
|
| 241 | | logerror("shifter base %x\n", shifter.palette[i]);
|
| 242 | | palette_set_color_rgb(Machine, offset, pal3bit(data >> 8), pal3bit(data >> 4), pal2bit(data >> 0));
|
| 243 | | }
|
| 244 | | }
|
| 245 | | }
|
| 246 | | |
| 247 | | READ16_HANDLER( atariste_shifter_r )
|
| 248 | | {
|
| 249 | | switch (offset)
|
| 250 | | {
|
| 251 | | case 0x00:
|
| 252 | | return (shifter.base >> 16) & 0x3f;
|
| 253 | | case 0x02:
|
| 254 | | return (shifter.base >> 8) & 0xff;
|
| 255 | | case 0x0c:
|
| 256 | | return shifter.base & 0xfe;
|
| 257 | | |
| 258 | | case 0x04:
|
| 259 | | return (shifter.ofs >> 16) & 0x3f;
|
| 260 | | case 0x06:
|
| 261 | | return (shifter.ofs >> 8) & 0xff;
|
| 262 | | case 0x08:
|
| 263 | | return shifter.ofs & 0xfe;
|
| 264 | | |
| 265 | | case 0x0a:
|
| 266 | | return shifter.sync << 8;
|
| 267 | | case 0x60:
|
| 268 | | return shifter.mode << 8;
|
| 269 | | |
| 270 | | case 0x0e:
|
| 271 | | return shifter.lineofs << 8;
|
| 272 | | case 0x64:
|
| 273 | | return shifter.pixelofs << 8;
|
| 274 | | |
| 275 | | default:
|
| 276 | | if ((offset & 0xe0) == 0x40)
|
| 277 | | {
|
| 278 | | return shifter.palette[offset & 0x1f];
|
| 279 | | }
|
| 280 | | }
|
| 281 | | |
| 282 | | return 0;
|
| 283 | | }
|
| 284 | | |
| 285 | | WRITE16_HANDLER( atariste_shifter_w )
|
| 286 | | {
|
| 287 | | switch (offset)
|
| 288 | | {
|
| 289 | | case 0x00:
|
| 290 | | shifter.base = (shifter.base & 0x00ff00) | (data & 0x3f) << 16;
|
| 291 | | break;
|
| 292 | | case 0x02:
|
| 293 | | shifter.base = (shifter.base & 0xff0000) | (data & 0xff) << 8;
|
| 294 | | break;
|
| 295 | | case 0x0c:
|
| 296 | | shifter.base = (shifter.base & 0xffff00) | (data & 0xfe) << 8;
|
| 297 | | break;
|
| 298 | | |
| 299 | | case 0x04:
|
| 300 | | shifter.ofs = (shifter.ofs & 0x00ffff) | (data & 0x3f) << 16;
|
| 301 | | break;
|
| 302 | | case 0x06:
|
| 303 | | shifter.ofs = (shifter.ofs & 0xff00ff) | (data & 0xff) << 8;
|
| 304 | | break;
|
| 305 | | case 0x08:
|
| 306 | | shifter.ofs = (shifter.ofs & 0xffff00) | (data & 0xfe);
|
| 307 | | break;
|
| 308 | | |
| 309 | | case 0x0a:
|
| 310 | | shifter.sync = data >> 8;
|
| 311 | | break;
|
| 312 | | case 0x60:
|
| 313 | | shifter.mode = data >> 8;
|
| 314 | | break;
|
| 315 | | |
| 316 | | case 0x0e:
|
| 317 | | shifter.lineofs = data & 0xff;
|
| 318 | | break;
|
| 319 | | case 0x64:
|
| 320 | | shifter.pixelofs = data & 0x0f;
|
| 321 | | break;
|
| 322 | | |
| 323 | | default:
|
| 324 | | if ((offset & 0xe0) == 0x40)
|
| 325 | | {
|
| 326 | | int i = offset & 0x1f;
|
| 327 | | int r = ((data >> 7) & 0x0e) | ((data >> 11) & 0x01);
|
| 328 | | int g = ((data >> 3) & 0x0e) | ((data >> 4) & 0x01);
|
| 329 | | int b = ((data << 1) & 0x0e) | ((data >> 3) & 0x01);
|
| 330 | | shifter.palette[i] = data;
|
| 331 | | palette_set_color_rgb(Machine, i, r, g, b);
|
| 332 | | }
|
| 333 | | }
|
| 334 | | }
|
| 335 | | |
| 336 | | VIDEO_START( atarist )
|
| 337 | | {
|
| 338 | | atarist_shifter_timer = mame_timer_alloc(atarist_shifter_tick);
|
| 339 | | atarist_glue_timer = mame_timer_alloc(atarist_glue_tick);
|
| 340 | | |
| 341 | | mame_timer_adjust(atarist_glue_timer, video_screen_get_time_until_pos(0,0,0), 0, MAME_TIME_IN_HZ(Y2/16)); // 500 ns
|
| 342 | | mame_timer_adjust(atarist_shifter_timer, video_screen_get_time_until_pos(0,0,0), 0, MAME_TIME_IN_HZ(Y2/4)); // 125 ns
|
| 343 | | |
| 344 | | atarist_bitmap = auto_bitmap_alloc(Machine->screen[0].width, Machine->screen[0].height, Machine->screen[0].format);
|
| 345 | | |
| 346 | | memset(&shifter, 0, sizeof(shifter));
|
| 347 | | }
|
| 348 | | |
| 349 | | VIDEO_UPDATE( atarist )
|
| 350 | | {
|
| 351 | | copybitmap(bitmap, atarist_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0);
|
| 352 | | |
| 353 | | return 0;
|
| 354 | | }
|
| 1 | /* |
| 2 | |
| 3 | TODO: |
| 4 | |
| 5 | - lineofs |
| 6 | - pixelofs |
| 7 | - monochrome mode |
| 8 | - change screen modes on the fly |
| 9 | - blitter |
| 10 | |
| 11 | */ |
| 12 | |
| 13 | #include "driver.h" |
| 14 | #include "video/generic.h" |
| 15 | #include "cpu/m68000/m68k.h" |
| 16 | #include "cpu/m68000/m68000.h" |
| 17 | #include "machine/68901mfp.h" |
| 18 | #include "video/atarist.h" |
| 19 | |
| 20 | static struct SHIFTER |
| 21 | { |
| 22 | UINT32 base; |
| 23 | UINT32 ofs; |
| 24 | UINT8 sync; |
| 25 | UINT8 mode; |
| 26 | UINT16 palette[16]; |
| 27 | UINT8 lineofs; // STe |
| 28 | UINT8 pixelofs; // STe |
| 29 | UINT16 rr[4]; |
| 30 | UINT16 ir[4]; |
| 31 | int vcount; |
| 32 | int hcount; |
| 33 | int bitplane; |
| 34 | int shift; |
| 35 | int h, v; |
| 36 | } shifter; |
| 37 | |
| 38 | static mame_timer *atarist_glue_timer; |
| 39 | static mame_timer *atarist_shifter_timer; |
| 40 | static mame_bitmap *atarist_bitmap; |
| 41 | |
| 42 | static TIMER_CALLBACK(atarist_shifter_tick) |
| 43 | { |
| 44 | int y = video_screen_get_vpos(0); |
| 45 | int x = video_screen_get_hpos(0); |
| 46 | int color; |
| 47 | |
| 48 | switch (shifter.mode) |
| 49 | { |
| 50 | case 0: // 320 x 200, 4 Plane |
| 51 | color = (BIT(shifter.rr[3], 15) << 3) | (BIT(shifter.rr[2], 15) << 2) | (BIT(shifter.rr[1], 15) << 1) | BIT(shifter.rr[0], 15); |
| 52 | |
| 53 | //logerror("y %u x %u color %u mode %u de %u h %u v %u hc %u\n", y, x, color, shifter.mode, shifter.h&&shifter.v, shifter.h, shifter.v, shifter.hcount); |
| 54 | |
| 55 | *BITMAP_ADDR16(atarist_bitmap, y, x) = Machine->pens[color]; |
| 56 | |
| 57 | shifter.rr[0] <<= 1; |
| 58 | shifter.rr[1] <<= 1; |
| 59 | shifter.rr[2] <<= 1; |
| 60 | shifter.rr[3] <<= 1; |
| 61 | |
| 62 | break; |
| 63 | |
| 64 | case 1: // 640 x 200, 2 Plane |
| 65 | color = (BIT(shifter.rr[1], 15) << 1) | BIT(shifter.rr[0], 15); |
| 66 | |
| 67 | *BITMAP_ADDR16(atarist_bitmap, y, x) = Machine->pens[color]; |
| 68 | |
| 69 | shifter.rr[0] <<= 1; |
| 70 | shifter.rr[1] <<= 1; |
| 71 | shifter.shift++; |
| 72 | |
| 73 | if (shifter.shift == 15) |
| 74 | { |
| 75 | shifter.rr[0] = shifter.rr[2]; |
| 76 | shifter.rr[1] = shifter.rr[3]; |
| 77 | shifter.rr[2] = shifter.rr[3] = 0; |
| 78 | shifter.shift = 0; |
| 79 | } |
| 80 | break; |
| 81 | |
| 82 | case 2: // 640 x 400, 1 Plane |
| 83 | // unimplemented |
| 84 | break; |
| 85 | } |
| 86 | } |
| 87 | |
| 88 | static TIMER_CALLBACK(atarist_glue_tick) |
| 89 | { |
| 90 | int de; |
| 91 | UINT8 *RAM = memory_region(REGION_CPU1) + shifter.base + shifter.ofs; |
| 92 | |
| 93 | shifter.hcount = video_screen_get_hpos(0) / 4; |
| 94 | shifter.vcount = video_screen_get_vpos(0); |
| 95 | |
| 96 | if (shifter.sync & 0x02) |
| 97 | { |
| 98 | // 50 Hz |
| 99 | |
| 100 | switch (shifter.hcount) |
| 101 | { |
| 102 | case ATARIST_HBDEND_PAL: |
| 103 | shifter.h = ASSERT_LINE; |
| 104 | break; |
| 105 | case ATARIST_HBDSTART_PAL: |
| 106 | shifter.h = CLEAR_LINE; |
| 107 | break; |
| 108 | case 128: |
| 109 | cpunum_set_input_line(0, MC68000_IRQ_2, ASSERT_LINE); |
| 110 | break; |
| 111 | } |
| 112 | |
| 113 | switch (shifter.vcount) |
| 114 | { |
| 115 | case ATARIST_VBDEND_PAL: |
| 116 | shifter.v = ASSERT_LINE; |
| 117 | break; |
| 118 | case ATARIST_VBDSTART_PAL: |
| 119 | shifter.v = CLEAR_LINE; |
| 120 | break; |
| 121 | case ATARIST_VBSTART_PAL: |
| 122 | cpunum_set_input_line(0, MC68000_IRQ_4, ASSERT_LINE); |
| 123 | shifter.ofs = 0; |
| 124 | break; |
| 125 | } |
| 126 | } |
| 127 | else |
| 128 | { |
| 129 | // 60 Hz |
| 130 | switch (shifter.hcount) |
| 131 | { |
| 132 | case ATARIST_HBDEND_NTSC: |
| 133 | shifter.h = ASSERT_LINE; |
| 134 | break; |
| 135 | case ATARIST_HBDSTART_NTSC: |
| 136 | shifter.h = CLEAR_LINE; |
| 137 | break; |
| 138 | case 127: |
| 139 | cpunum_set_input_line(0, MC68000_IRQ_2, ASSERT_LINE); |
| 140 | break; |
| 141 | } |
| 142 | |
| 143 | switch (shifter.vcount) |
| 144 | { |
| 145 | case ATARIST_VBDEND_NTSC: |
| 146 | shifter.v = ASSERT_LINE; |
| 147 | break; |
| 148 | case ATARIST_VBDSTART_NTSC: |
| 149 | shifter.v = CLEAR_LINE; |
| 150 | break; |
| 151 | case ATARIST_VBSTART_NTSC: |
| 152 | cpunum_set_input_line(0, MC68000_IRQ_4, ASSERT_LINE); |
| 153 | shifter.ofs = 0; |
| 154 | break; |
| 155 | } |
| 156 | } |
| 157 | |
| 158 | de = shifter.h && shifter.v; |
| 159 | |
| 160 | mfp68901_tbi_w(0, de); |
| 161 | |
| 162 | if (de) |
| 163 | { |
| 164 | shifter.ir[shifter.bitplane] = (RAM[0] << 8) | RAM[1]; |
| 165 | shifter.ofs += 2; |
| 166 | shifter.bitplane++; |
| 167 | |
| 168 | if (shifter.bitplane == 4) |
| 169 | { |
| 170 | shifter.bitplane = 0; |
| 171 | |
| 172 | shifter.rr[0] = shifter.ir[0]; |
| 173 | shifter.rr[1] = shifter.ir[1]; |
| 174 | shifter.rr[2] = shifter.ir[2]; |
| 175 | shifter.rr[3] = shifter.ir[3]; |
| 176 | |
| 177 | shifter.ir[0] = shifter.ir[1] = shifter.ir[2] = shifter.ir[3] = 0; |
| 178 | } |
| 179 | } |
| 180 | } |
| 181 | |
| 182 | READ16_HANDLER( atarist_shifter_r ) |
| 183 | { |
| 184 | switch (offset) |
| 185 | { |
| 186 | case 0x00: |
| 187 | return (shifter.base >> 16) & 0xff; |
| 188 | case 0x02: |
| 189 | return (shifter.base >> 8) & 0xff; |
| 190 | |
| 191 | case 0x04: |
| 192 | return (shifter.ofs >> 16) & 0xff; |
| 193 | case 0x06: |
| 194 | return (shifter.ofs >> 8) & 0xff; |
| 195 | case 0x08: |
| 196 | return shifter.ofs & 0xff; |
| 197 | |
| 198 | case 0x0a: |
| 199 | return shifter.sync; |
| 200 | case 0x60: |
| 201 | return shifter.mode << 8; |
| 202 | |
| 203 | default: |
| 204 | if ((offset & 0xe0) == 0x40) |
| 205 | { |
| 206 | return shifter.palette[offset & 0x1f]; |
| 207 | } |
| 208 | } |
| 209 | |
| 210 | return 0; |
| 211 | } |
| 212 | |
| 213 | WRITE16_HANDLER( atarist_shifter_w ) |
| 214 | { |
| 215 | switch (offset) |
| 216 | { |
| 217 | case 0x00: |
| 218 | shifter.base = (shifter.base & 0x00ff00) | (data & 0x3f) << 16; |
| 219 | logerror("shifter base %x\n", shifter.base); |
| 220 | break; |
| 221 | case 0x02: |
| 222 | shifter.base = (shifter.base & 0xff0000) | (data & 0xff) << 8; |
| 223 | logerror("shifter base %x\n", shifter.base); |
| 224 | break; |
| 225 | |
| 226 | case 0x0a: |
| 227 | shifter.sync = data >> 8; |
| 228 | logerror("shifter sync %x\n", shifter.sync); |
| 229 | break; |
| 230 | |
| 231 | case 0x60: |
| 232 | shifter.mode = data >> 8; |
| 233 | logerror("shifter mode %x\n", shifter.mode); |
| 234 | break; |
| 235 | |
| 236 | default: |
| 237 | if ((offset & 0xe0) == 0x40) |
| 238 | { |
| 239 | int i = offset & 0x1f; |
| 240 | shifter.palette[i] = data; |
| 241 | logerror("shifter base %x\n", shifter.palette[i]); |
| 242 | palette_set_color_rgb(Machine, offset, pal3bit(data >> 8), pal3bit(data >> 4), pal2bit(data >> 0)); |
| 243 | } |
| 244 | } |
| 245 | } |
| 246 | |
| 247 | READ16_HANDLER( atariste_shifter_r ) |
| 248 | { |
| 249 | switch (offset) |
| 250 | { |
| 251 | case 0x00: |
| 252 | return (shifter.base >> 16) & 0x3f; |
| 253 | case 0x02: |
| 254 | return (shifter.base >> 8) & 0xff; |
| 255 | case 0x0c: |
| 256 | return shifter.base & 0xfe; |
| 257 | |
| 258 | case 0x04: |
| 259 | return (shifter.ofs >> 16) & 0x3f; |
| 260 | case 0x06: |
| 261 | return (shifter.ofs >> 8) & 0xff; |
| 262 | case 0x08: |
| 263 | return shifter.ofs & 0xfe; |
| 264 | |
| 265 | case 0x0a: |
| 266 | return shifter.sync << 8; |
| 267 | case 0x60: |
| 268 | return shifter.mode << 8; |
| 269 | |
| 270 | case 0x0e: |
| 271 | return shifter.lineofs << 8; |
| 272 | case 0x64: |
| 273 | return shifter.pixelofs << 8; |
| 274 | |
| 275 | default: |
| 276 | if ((offset & 0xe0) == 0x40) |
| 277 | { |
| 278 | return shifter.palette[offset & 0x1f]; |
| 279 | } |
| 280 | } |
| 281 | |
| 282 | return 0; |
| 283 | } |
| 284 | |
| 285 | WRITE16_HANDLER( atariste_shifter_w ) |
| 286 | { |
| 287 | switch (offset) |
| 288 | { |
| 289 | case 0x00: |
| 290 | shifter.base = (shifter.base & 0x00ff00) | (data & 0x3f) << 16; |
| 291 | break; |
| 292 | case 0x02: |
| 293 | shifter.base = (shifter.base & 0xff0000) | (data & 0xff) << 8; |
| 294 | break; |
| 295 | case 0x0c: |
| 296 | shifter.base = (shifter.base & 0xffff00) | (data & 0xfe) << 8; |
| 297 | break; |
| 298 | |
| 299 | case 0x04: |
| 300 | shifter.ofs = (shifter.ofs & 0x00ffff) | (data & 0x3f) << 16; |
| 301 | break; |
| 302 | case 0x06: |
| 303 | shifter.ofs = (shifter.ofs & 0xff00ff) | (data & 0xff) << 8; |
| 304 | break; |
| 305 | case 0x08: |
| 306 | shifter.ofs = (shifter.ofs & 0xffff00) | (data & 0xfe); |
| 307 | break; |
| 308 | |
| 309 | case 0x0a: |
| 310 | shifter.sync = data >> 8; |
| 311 | break; |
| 312 | case 0x60: |
| 313 | shifter.mode = data >> 8; |
| 314 | break; |
| 315 | |
| 316 | case 0x0e: |
| 317 | shifter.lineofs = data & 0xff; |
| 318 | break; |
| 319 | case 0x64: |
| 320 | shifter.pixelofs = data & 0x0f; |
| 321 | break; |
| 322 | |
| 323 | default: |
| 324 | if ((offset & 0xe0) == 0x40) |
| 325 | { |
| 326 | int i = offset & 0x1f; |
| 327 | int r = ((data >> 7) & 0x0e) | ((data >> 11) & 0x01); |
| 328 | int g = ((data >> 3) & 0x0e) | ((data >> 4) & 0x01); |
| 329 | int b = ((data << 1) & 0x0e) | ((data >> 3) & 0x01); |
| 330 | shifter.palette[i] = data; |
| 331 | palette_set_color_rgb(Machine, i, r, g, b); |
| 332 | } |
| 333 | } |
| 334 | } |
| 335 | |
| 336 | VIDEO_START( atarist ) |
| 337 | { |
| 338 | atarist_shifter_timer = mame_timer_alloc(atarist_shifter_tick); |
| 339 | atarist_glue_timer = mame_timer_alloc(atarist_glue_tick); |
| 340 | |
| 341 | mame_timer_adjust(atarist_glue_timer, video_screen_get_time_until_pos(0,0,0), 0, MAME_TIME_IN_HZ(Y2/16)); // 500 ns |
| 342 | mame_timer_adjust(atarist_shifter_timer, video_screen_get_time_until_pos(0,0,0), 0, MAME_TIME_IN_HZ(Y2/4)); // 125 ns |
| 343 | |
| 344 | atarist_bitmap = auto_bitmap_alloc(Machine->screen[0].width, Machine->screen[0].height, Machine->screen[0].format); |
| 345 | |
| 346 | memset(&shifter, 0, sizeof(shifter)); |
| 347 | } |
| 348 | |
| 349 | VIDEO_UPDATE( atarist ) |
| 350 | { |
| 351 | copybitmap(bitmap, atarist_bitmap, 0, 0, 0, 0, cliprect, TRANSPARENCY_NONE, 0); |
| 352 | |
| 353 | return 0; |
| 354 | } |
src/mess/machine/rp5c15.c
| r811 | r812 | |
| 1 | | /*
|
| 2 | | |
| 3 | | Ricoh RP5C15 Real-time Clock
|
| 4 | | Written by Barry Rodewald
|
| 5 | | Started 04/07/07
|
| 6 | | |
| 7 | | Registers are separated into two banks, switchable through
|
| 8 | | the LSB of the MODE register.
|
| 9 | |
|
| 10 | | Date and time are stored in BCD, one digit to each register
|
| 11 | |
|
| 12 | | Register BANK 0 BANK 1
|
| 13 | | 0 Timer seconds CLKOUT
|
| 14 | | 1 Timer seconds (10s) RTC Adjustment
|
| 15 | | 2 Timer minutes Alarm minutes
|
| 16 | | 3 Timer minutes (10s) Alarm minutes (10s)
|
| 17 | | 4 Timer hours Alarm hours
|
| 18 | | 5 Timer hours (10s) Alarm hours (10s)
|
| 19 | | 6 Timer day-of-week Alarm day-of-week
|
| 20 | | 7 Timer day Alarm day
|
| 21 | | 8 Timer day (10s) Alarm day (10s)
|
| 22 | | 9 Timer month (unused)
|
| 23 | | 10 Timer month (10s) 12/24 hour clock selection
|
| 24 | | 11 Timer year Years until next leap year
|
| 25 | | 12 Timer year (10s) (unused)
|
| 26 | | 13 MODE register MODE register
|
| 27 | | 14 TEST register TEST register
|
| 28 | | 15 RESET register RESET register
|
| 29 | |
|
| 30 | |
|
| 31 | | CLKOUT (W/O) - on the X68000, this is connected to the Timer LED
|
| 32 | | xxxxx000 = always high (on)
|
| 33 | | xxxxx001 = 16384Hz
|
| 34 | | xxxxx010 = 1024Hz
|
| 35 | | xxxxx011 = 128Hz
|
| 36 | | xxxxx100 = 16Hz
|
| 37 | | xxxxx101 = 1Hz
|
| 38 | | xxxxx110 = 1/60Hz
|
| 39 | | xxxxx111 = always low (off)
|
| 40 | | |
| 41 | | Adjustment register (R/W)
|
| 42 | | bit 0 = if set, will reset the seconds to zero, and if the
|
| 43 | | seconds were > 30, increment the minutes by 1.
|
| 44 | | Always returns 0.
|
| 45 | | |
| 46 | | 12/24 hour clock register (R/W) (not implemented yet)
|
| 47 | | bit 0 = selects 12 or 24 hour clock
|
| 48 | | presumably, on reading, returns AM/PM status.
|
| 49 | | |
| 50 | | Leap year register
|
| 51 | | bit 0,1 = returns number of years until next leap year.
|
| 52 | | Is simply year % 4.
|
| 53 | | |
| 54 | | MODE register (R/W)
|
| 55 | | bit 0 = if set, selects BANK 1, if reset, selects BANK 0
|
| 56 | | bit 2 = Alarm enable
|
| 57 | | bit 3 = Timer enable
|
| 58 | | |
| 59 | | TEST register (not implemented yet)
|
| 60 | | bits 0-3 = generally all set to 0, use is unknown.
|
| 61 | | |
| 62 | | RESET register (not implemented yet)
|
| 63 | | bit 0 = Alarm reset
|
| 64 | | bit 1 = Timer reset
|
| 65 | | bit 2 = if set, 16Hz pulse is off
|
| 66 | | bit 3 = if set, 1Hz pulse is off
|
| 67 | | |
| 68 | | */
|
| 69 | | |
| 70 | | #include "rp5c15.h"
|
| 71 | | |
| 72 | | struct rp5c15 rtc;
|
| 73 | | |
| 74 | | mame_timer* rtc_timer;
|
| 75 | | |
| 76 | | TIMER_CALLBACK(rtc_alarm_pulse)
|
| 77 | | {
|
| 78 | | if(rtc.pulse16_state == 0) // low
|
| 79 | | {
|
| 80 | | rtc.pulse16_state = 1; // make high
|
| 81 | | rtc.pulse_count++;
|
| 82 | | }
|
| 83 | | else
|
| 84 | | {
|
| 85 | | rtc.pulse16_state = 0; // make low
|
| 86 | | }
|
| 87 | | |
| 88 | | if(rtc.pulse_count == 8)
|
| 89 | | {
|
| 90 | | rtc.pulse1_state = 0;
|
| 91 | | }
|
| 92 | | if(rtc.pulse_count == 16)
|
| 93 | | {
|
| 94 | | rtc.pulse_count = 0;
|
| 95 | | rtc.pulse1_state = 1;
|
| 96 | | rtc_add_second();
|
| 97 | | }
|
| 98 | | }
|
| 99 | | |
| 100 | | void rp5c15_init(struct rp5c15_interface* intf)
|
| 101 | | {
|
| 102 | | mame_system_time systm;
|
| 103 | | mame_system_tm time;
|
| 104 | |
|
| 105 | | rtc.alarm_callback = intf->alarm_irq_callback;
|
| 106 | |
|
| 107 | | mame_get_base_datetime(Machine,&systm);
|
| 108 | | time = systm.local_time;
|
| 109 | |
|
| 110 | | // date/time is stored as BCD
|
| 111 | | rtc.systime.sec_1 = time.second % 10;
|
| 112 | | rtc.systime.sec_10 = time.second / 10;
|
| 113 | | rtc.systime.min_1 = time.minute % 10;
|
| 114 | | rtc.systime.min_10 = time.minute / 10;
|
| 115 | | rtc.systime.hour_1 = time.hour % 10;
|
| 116 | | rtc.systime.hour_10 = time.hour / 10;
|
| 117 | | rtc.systime.day_1 = time.mday % 10;
|
| 118 | | rtc.systime.day_10 = time.mday / 10;
|
| 119 | | rtc.systime.month_1 = (time.month+1) % 10;
|
| 120 | | rtc.systime.month_10 = (time.month+1) / 10;
|
| 121 | | rtc.systime.year_1 = (time.year - 1980) % 10;
|
| 122 | | rtc.systime.year_10 = (time.year - 1980) / 10;
|
| 123 | | rtc.systime.dayofweek = time.weekday;
|
| 124 | | rtc.alarm.min_1 = time.minute % 10;
|
| 125 | | rtc.alarm.min_10 = time.minute / 10;
|
| 126 | | rtc.alarm.hour_1 = time.hour % 10;
|
| 127 | | rtc.alarm.hour_10 = time.hour / 10;
|
| 128 | | rtc.alarm.day_1 = time.mday % 10;
|
| 129 | | rtc.alarm.day_10 = time.mday / 10;
|
| 130 | | rtc.alarm.dayofweek = time.weekday;
|
| 131 | | rtc.leap = time.year % 4;
|
| 132 | | |
| 133 | | rtc.mode = 0x08; // Timer enabled, Alarm disable, BANK 0 selected (defaults are guessed)
|
| 134 | | rtc.reset = 0x00; // enable both 1Hz and 16Hz alarm counters by default
|
| 135 | | rtc.test = 0x00;
|
| 136 | | rtc.pulse_count = 0;
|
| 137 | |
|
| 138 | | rtc_timer = mame_timer_alloc(rtc_alarm_pulse);
|
| 139 | | mame_timer_adjust(rtc_timer, time_zero, 0, MAME_TIME_IN_HZ(32));
|
| 140 | | }
|
| 141 | | |
| 142 | | int rp5c15_read(int offset, UINT16 mem_mask)
|
| 143 | | {
|
| 144 | | if((rtc.mode & 0x01) == 0x00) // BANK 0 selected
|
| 145 | | {
|
| 146 | | switch(offset)
|
| 147 | | {
|
| 148 | | case 0:
|
| 149 | | return rtc.systime.sec_1;
|
| 150 | | case 1:
|
| 151 | | return rtc.systime.sec_10;
|
| 152 | | case 2:
|
| 153 | | return rtc.systime.min_1;
|
| 154 | | case 3:
|
| 155 | | return rtc.systime.min_10;
|
| 156 | | case 4:
|
| 157 | | return rtc.systime.hour_1;
|
| 158 | | case 5:
|
| 159 | | return rtc.systime.hour_10;
|
| 160 | | case 6:
|
| 161 | | return rtc.systime.dayofweek;
|
| 162 | | case 7:
|
| 163 | | return rtc.systime.day_1;
|
| 164 | | case 8:
|
| 165 | | return rtc.systime.day_10;
|
| 166 | | case 9:
|
| 167 | | return rtc.systime.month_1;
|
| 168 | | case 10:
|
| 169 | | return rtc.systime.month_10;
|
| 170 | | case 11:
|
| 171 | | return rtc.systime.year_1;
|
| 172 | | case 12:
|
| 173 | | return rtc.systime.year_10;
|
| 174 | | case 13:
|
| 175 | | return rtc.mode & 0x0f; |
| 176 | | }
|
| 177 | | }
|
| 178 | | else // BANK 1 selected
|
| 179 | | {
|
| 180 | | switch(offset)
|
| 181 | | {
|
| 182 | | case 0: // CLKOUT |
| 183 | | return rtc.clkout & 0x07;
|
| 184 | | case 1: // Adjustment (always returns 0)
|
| 185 | | return 0;
|
| 186 | | case 2:
|
| 187 | | return rtc.alarm.min_1;
|
| 188 | | case 3:
|
| 189 | | return rtc.alarm.min_10;
|
| 190 | | case 4:
|
| 191 | | return rtc.alarm.hour_1;
|
| 192 | | case 5:
|
| 193 | | return rtc.alarm.hour_10;
|
| 194 | | case 6:
|
| 195 | | return rtc.alarm.dayofweek;
|
| 196 | | case 7:
|
| 197 | | return rtc.alarm.day_1;
|
| 198 | | case 8:
|
| 199 | | return rtc.alarm.day_10;
|
| 200 | | case 10: // 12/24 hour selection (returns AM/PM?)
|
| 201 | | return 0;
|
| 202 | | case 11: // Leap year
|
| 203 | | return rtc.leap;
|
| 204 | | case 13:
|
| 205 | | return rtc.mode & 0x0f;
|
| 206 | | default:
|
| 207 | | return 0;
|
| 208 | | }
|
| 209 | | }
|
| 210 | | return 0;
|
| 211 | | }
|
| 212 | | |
| 213 | | void rp5c15_write(int offset, int data, UINT16 mem_mask)
|
| 214 | | {
|
| 215 | | if(offset == 13)
|
| 216 | | {
|
| 217 | | rtc.mode = data & 0x0f;
|
| 218 | | return;
|
| 219 | | }
|
| 220 | | if((rtc.mode & 0x01) == 0x00) // BANK 0 selected
|
| 221 | | {
|
| 222 | | switch(offset)
|
| 223 | | {
|
| 224 | | case 0:
|
| 225 | | rtc.systime.sec_1 = data & 0x0f;
|
| 226 | | break;
|
| 227 | | case 1:
|
| 228 | | rtc.systime.sec_10 = data & 0x0f;
|
| 229 | | break;
|
| 230 | | case 2:
|
| 231 | | rtc.systime.min_1 = data & 0x0f;
|
| 232 | | break;
|
| 233 | | case 3:
|
| 234 | | rtc.systime.min_10 = data & 0x0f;
|
| 235 | | break;
|
| 236 | | case 4:
|
| 237 | | rtc.systime.hour_1 = data & 0x0f;
|
| 238 | | break;
|
| 239 | | case 5:
|
| 240 | | rtc.systime.hour_10 = data & 0x0f;
|
| 241 | | break;
|
| 242 | | case 6:
|
| 243 | | rtc.systime.dayofweek = data & 0x0f;
|
| 244 | | break;
|
| 245 | | case 7:
|
| 246 | | rtc.systime.day_1 = data & 0x0f;
|
| 247 | | break;
|
| 248 | | case 8:
|
| 249 | | rtc.systime.day_10 = data & 0x0f;
|
| 250 | | break;
|
| 251 | | case 9:
|
| 252 | | rtc.systime.month_1 = data & 0x0f;
|
| 253 | | break;
|
| 254 | | case 10:
|
| 255 | | rtc.systime.month_10 = data & 0x0f;
|
| 256 | | break;
|
| 257 | | case 11:
|
| 258 | | rtc.systime.year_1 = data & 0x0f;
|
| 259 | | break;
|
| 260 | | case 12:
|
| 261 | | rtc.systime.year_10 = data & 0x0f;
|
| 262 | | break;
|
| 263 | | }
|
| 264 | | }
|
| 265 | | else // BANK 1 selected
|
| 266 | | {
|
| 267 | | switch(offset)
|
| 268 | | {
|
| 269 | | case 0:
|
| 270 | | rtc.clkout = data & 0x07;
|
| 271 | | break;
|
| 272 | | case 1: // Adjustment (resets seconds to 0, increases minute by 1 if seconds are > 30
|
| 273 | | if(rtc.systime.sec_10 >= 3)
|
| 274 | | rtc_add_minute();
|
| 275 | | rtc.systime.sec_1 = 0;
|
| 276 | | rtc.systime.sec_10 = 0;
|
| 277 | | break;
|
| 278 | | case 2:
|
| 279 | | rtc.alarm.min_1 = data & 0x0f;
|
| 280 | | break;
|
| 281 | | case 3:
|
| 282 | | rtc.alarm.min_10 = data & 0x0f;
|
| 283 | | break;
|
| 284 | | case 4:
|
| 285 | | rtc.alarm.hour_1 = data & 0x0f;
|
| 286 | | break;
|
| 287 | | case 5:
|
| 288 | | rtc.alarm.hour_10 = data & 0x0f;
|
| 289 | | break;
|
| 290 | | case 6:
|
| 291 | | rtc.alarm.dayofweek = data & 0x0f;
|
| 292 | | break;
|
| 293 | | case 7:
|
| 294 | | rtc.alarm.day_1 = data & 0x0f;
|
| 295 | | break;
|
| 296 | | case 8:
|
| 297 | | rtc.alarm.day_10 = data & 0x0f;
|
| 298 | | break;
|
| 299 | | case 10: // 12/24 hour clock selection
|
| 300 | | rtc.hour24 = data;
|
| 301 | | break;
|
| 302 | |
|
| 303 | | }
|
| 304 | | }
|
| 305 | | }
|
| 306 | | |
| 307 | | void rtc_add_second() // add one second to current time
|
| 308 | | {
|
| 309 | | if((rtc.mode & 0x08) == 0x00) // if timer is not enabled
|
| 310 | | return;
|
| 311 | | rtc.systime.sec_1++;
|
| 312 | | if(rtc.systime.sec_1 < 10)
|
| 313 | | return;
|
| 314 | | rtc.systime.sec_1 = 0;
|
| 315 | | rtc.systime.sec_10++;
|
| 316 | | if(rtc.systime.sec_10 < 6)
|
| 317 | | return;
|
| 318 | | rtc.systime.sec_10 = 0;
|
| 319 | | rtc_add_minute();
|
| 320 | | }
|
| 321 | | |
| 322 | | void rtc_add_minute()
|
| 323 | | {
|
| 324 | | rtc.systime.min_1++;
|
| 325 | | if(rtc.systime.min_1 < 10)
|
| 326 | | return;
|
| 327 | | rtc.systime.min_1 = 0;
|
| 328 | | rtc.systime.min_10++;
|
| 329 | | if(rtc.systime.min_10 < 6)
|
| 330 | | return;
|
| 331 | | rtc.systime.min_10 = 0;
|
| 332 | | rtc.systime.hour_1++;
|
| 333 | | if(rtc.systime.hour_1 < 10 && rtc.systime.hour_10 < 2)
|
| 334 | | return;
|
| 335 | | if(rtc.systime.hour_10 < 3 && rtc.systime.hour_1 < 4)
|
| 336 | | return;
|
| 337 | | rtc.systime.hour_1 = 0;
|
| 338 | | rtc.systime.hour_10++;
|
| 339 | | if(rtc.systime.hour_10 < 3)
|
| 340 | | return;
|
| 341 | | rtc.systime.hour_10 = 0;
|
| 342 | | rtc_add_day();
|
| 343 | | }
|
| 344 | | |
| 345 | | void rtc_add_day()
|
| 346 | | {
|
| 347 | | int d,m;
|
| 348 | |
|
| 349 | | rtc.systime.dayofweek++;
|
| 350 | | if(rtc.systime.dayofweek >= 7)
|
| 351 | | rtc.systime.dayofweek = 0;
|
| 352 | | d = (rtc.systime.day_10 << 4) | rtc.systime.day_1;
|
| 353 | | m = (rtc.systime.month_10 << 4) | rtc.systime.month_1;
|
| 354 | | d++;
|
| 355 | | if((d & 0x0f) >= 10)
|
| 356 | | {
|
| 357 | | d &= 0xf0;
|
| 358 | | d += 0x10;
|
| 359 | | }
|
| 360 | | rtc.systime.day_1 = (d & 0x0f);
|
| 361 | | rtc.systime.day_10 = (d & 0xf0) >> 4;
|
| 362 | | switch(m)
|
| 363 | | {
|
| 364 | | case 1:
|
| 365 | | case 3:
|
| 366 | | case 5:
|
| 367 | | case 7:
|
| 368 | | case 8:
|
| 369 | | case 0x10:
|
| 370 | | case 0x12:
|
| 371 | | if(d > 0x31)
|
| 372 | | {
|
| 373 | | rtc.systime.day_1 = 1;
|
| 374 | | rtc.systime.day_10 = 0;
|
| 375 | | rtc_add_month();
|
| 376 | | }
|
| 377 | | break;
|
| 378 | | case 4:
|
| 379 | | case 6:
|
| 380 | | case 9:
|
| 381 | | case 11:
|
| 382 | | if(d > 0x30)
|
| 383 | | {
|
| 384 | | rtc.systime.day_1 = 1;
|
| 385 | | rtc.systime.day_10 = 0;
|
| 386 | | rtc_add_month();
|
| 387 | | }
|
| 388 | | break;
|
| 389 | | case 2:
|
| 390 | | if(rtc.leap == 0) // this is a leap year
|
| 391 | | {
|
| 392 | | if(d > 0x29)
|
| 393 | | {
|
| 394 | | rtc.systime.day_1 = 1;
|
| 395 | | rtc.systime.day_10 = 0;
|
| 396 | | rtc_add_month();
|
| 397 | | }
|
| 398 | | }
|
| 399 | | else // not a leap year
|
| 400 | | {
|
| 401 | | if(d > 0x28)
|
| 402 | | {
|
| 403 | | rtc.systime.day_1 = 1;
|
| 404 | | rtc.systime.day_10 = 0;
|
| 405 | | rtc_add_month();
|
| 406 | | }
|
| 407 | | }
|
| 408 | | break;
|
| 409 | | }
|
| 410 | | }
|
| 411 | | |
| 412 | | void rtc_add_month()
|
| 413 | | {
|
| 414 | | rtc.systime.month_1++;
|
| 415 | | if(rtc.systime.month_1 < 10 && rtc.systime.month_10 < 1)
|
| 416 | | return;
|
| 417 | | if(rtc.systime.month_1 < 3 && rtc.systime.month_10 < 2)
|
| 418 | | return;
|
| 419 | | rtc.systime.month_1 = 0;
|
| 420 | | rtc.systime.month_10++;
|
| 421 | | if(rtc.systime.month_10 < 2)
|
| 422 | | return;
|
| 423 | | rtc.systime.month_1 = 1;
|
| 424 | | rtc.systime.month_10 = 0;
|
| 425 | | rtc.systime.year_1++;
|
| 426 | | if(rtc.systime.year_1 < 10)
|
| 427 | | return;
|
| 428 | | rtc.systime.year_1 = 0;
|
| 429 | | rtc.systime.year_10++;
|
| 430 | | if(rtc.systime.year_10 < 10)
|
| 431 | | return;
|
| 432 | | rtc.systime.year_10 = 0;
|
| 433 | | }
|
| 434 | | |
| 435 | | READ16_HANDLER(rp5c15_r) { return rp5c15_read(offset,mem_mask); }
|
| 436 | | WRITE16_HANDLER(rp5c15_w) { rp5c15_write(offset,data,mem_mask); }
|
| 1 | /* |
| 2 | |
| 3 | Ricoh RP5C15 Real-time Clock |
| 4 | Written by Barry Rodewald |
| 5 | Started 04/07/07 |
| 6 | |
| 7 | Registers are separated into two banks, switchable through |
| 8 | the LSB of the MODE register. |
| 9 | |
| 10 | Date and time are stored in BCD, one digit to each register |
| 11 | |
| 12 | Register BANK 0 BANK 1 |
| 13 | 0 Timer seconds CLKOUT |
| 14 | 1 Timer seconds (10s) RTC Adjustment |
| 15 | 2 Timer minutes Alarm minutes |
| 16 | 3 Timer minutes (10s) Alarm minutes (10s) |
| 17 | 4 Timer hours Alarm hours |
| 18 | 5 Timer hours (10s) Alarm hours (10s) |
| 19 | 6 Timer day-of-week Alarm day-of-week |
| 20 | 7 Timer day Alarm day |
| 21 | 8 Timer day (10s) Alarm day (10s) |
| 22 | 9 Timer month (unused) |
| 23 | 10 Timer month (10s) 12/24 hour clock selection |
| 24 | 11 Timer year Years until next leap year |
| 25 | 12 Timer year (10s) (unused) |
| 26 | 13 MODE register MODE register |
| 27 | 14 TEST register TEST register |
| 28 | 15 RESET register RESET register |
| 29 | |
| 30 | |
| 31 | CLKOUT (W/O) - on the X68000, this is connected to the Timer LED |
| 32 | xxxxx000 = always high (on) |
| 33 | xxxxx001 = 16384Hz |
| 34 | xxxxx010 = 1024Hz |
| 35 | xxxxx011 = 128Hz |
| 36 | xxxxx100 = 16Hz |
| 37 | xxxxx101 = 1Hz |
| 38 | xxxxx110 = 1/60Hz |
| 39 | xxxxx111 = always low (off) |
| 40 | |
| 41 | Adjustment register (R/W) |
| 42 | bit 0 = if set, will reset the seconds to zero, and if the |
| 43 | seconds were > 30, increment the minutes by 1. |
| 44 | Always returns 0. |
| 45 | |
| 46 | 12/24 hour clock register (R/W) (not implemented yet) |
| 47 | bit 0 = selects 12 or 24 hour clock |
| 48 | presumably, on reading, returns AM/PM status. |
| 49 | |
| 50 | Leap year register |
| 51 | bit 0,1 = returns number of years until next leap year. |
| 52 | Is simply year % 4. |
| 53 | |
| 54 | MODE register (R/W) |
| 55 | bit 0 = if set, selects BANK 1, if reset, selects BANK 0 |
| 56 | bit 2 = Alarm enable |
| 57 | bit 3 = Timer enable |
| 58 | |
| 59 | TEST register (not implemented yet) |
| 60 | bits 0-3 = generally all set to 0, use is unknown. |
| 61 | |
| 62 | RESET register (not implemented yet) |
| 63 | bit 0 = Alarm reset |
| 64 | bit 1 = Timer reset |
| 65 | bit 2 = if set, 16Hz pulse is off |
| 66 | bit 3 = if set, 1Hz pulse is off |
| 67 | |
| 68 | */ |
| 69 | |
| 70 | #include "rp5c15.h" |
| 71 | |
| 72 | struct rp5c15 rtc; |
| 73 | |
| 74 | mame_timer* rtc_timer; |
| 75 | |
| 76 | TIMER_CALLBACK(rtc_alarm_pulse) |
| 77 | { |
| 78 | if(rtc.pulse16_state == 0) // low |
| 79 | { |
| 80 | rtc.pulse16_state = 1; // make high |
| 81 | rtc.pulse_count++; |
| 82 | } |
| 83 | else |
| 84 | { |
| 85 | rtc.pulse16_state = 0; // make low |
| 86 | } |
| 87 | |
| 88 | if(rtc.pulse_count == 8) |
| 89 | { |
| 90 | rtc.pulse1_state = 0; |
| 91 | } |
| 92 | if(rtc.pulse_count == 16) |
| 93 | { |
| 94 | rtc.pulse_count = 0; |
| 95 | rtc.pulse1_state = 1; |
| 96 | rtc_add_second(); |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | void rp5c15_init(struct rp5c15_interface* intf) |
| 101 | { |
| 102 | mame_system_time systm; |
| 103 | mame_system_tm time; |
| 104 | |
| 105 | rtc.alarm_callback = intf->alarm_irq_callback; |
| 106 | |
| 107 | mame_get_base_datetime(Machine,&systm); |
| 108 | time = systm.local_time; |
| 109 | |
| 110 | // date/time is stored as BCD |
| 111 | rtc.systime.sec_1 = time.second % 10; |
| 112 | rtc.systime.sec_10 = time.second / 10; |
| 113 | rtc.systime.min_1 = time.minute % 10; |
| 114 | rtc.systime.min_10 = time.minute / 10; |
| 115 | rtc.systime.hour_1 = time.hour % 10; |
| 116 | rtc.systime.hour_10 = time.hour / 10; |
| 117 | rtc.systime.day_1 = time.mday % 10; |
| 118 | rtc.systime.day_10 = time.mday / 10; |
| 119 | rtc.systime.month_1 = (time.month+1) % 10; |
| 120 | rtc.systime.month_10 = (time.month+1) / 10; |
| 121 | rtc.systime.year_1 = (time.year - 1980) % 10; |
| 122 | rtc.systime.year_10 = (time.year - 1980) / 10; |
| 123 | rtc.systime.dayofweek = time.weekday; |
| 124 | rtc.alarm.min_1 = time.minute % 10; |
| 125 | rtc.alarm.min_10 = time.minute / 10; |
| 126 | rtc.alarm.hour_1 = time.hour % 10; |
| 127 | rtc.alarm.hour_10 = time.hour / 10; |
| 128 | rtc.alarm.day_1 = time.mday % 10; |
| 129 | rtc.alarm.day_10 = time.mday / 10; |
| 130 | rtc.alarm.dayofweek = time.weekday; |
| 131 | rtc.leap = time.year % 4; |
| 132 | |
| 133 | rtc.mode = 0x08; // Timer enabled, Alarm disable, BANK 0 selected (defaults are guessed) |
| 134 | rtc.reset = 0x00; // enable both 1Hz and 16Hz alarm counters by default |
| 135 | rtc.test = 0x00; |
| 136 | rtc.pulse_count = 0; |
| 137 | |
| 138 | rtc_timer = mame_timer_alloc(rtc_alarm_pulse); |
| 139 | mame_timer_adjust(rtc_timer, time_zero, 0, MAME_TIME_IN_HZ(32)); |
| 140 | } |
| 141 | |
| 142 | int rp5c15_read(int offset, UINT16 mem_mask) |
| 143 | { |
| 144 | if((rtc.mode & 0x01) == 0x00) // BANK 0 selected |
| 145 | { |
| 146 | switch(offset) |
| 147 | { |
| 148 | case 0: |
| 149 | return rtc.systime.sec_1; |
| 150 | case 1: |
| 151 | return rtc.systime.sec_10; |
| 152 | case 2: |
| 153 | return rtc.systime.min_1; |
| 154 | case 3: |
| 155 | return rtc.systime.min_10; |
| 156 | case 4: |
| 157 | return rtc.systime.hour_1; |
| 158 | case 5: |
| 159 | return rtc.systime.hour_10; |
| 160 | case 6: |
| 161 | return rtc.systime.dayofweek; |
| 162 | case 7: |
| 163 | return rtc.systime.day_1; |
| 164 | case 8: |
| 165 | return rtc.systime.day_10; |
| 166 | case 9: |
| 167 | return rtc.systime.month_1; |
| 168 | case 10: |
| 169 | return rtc.systime.month_10; |
| 170 | case 11: |
| 171 | return rtc.systime.year_1; |
| 172 | case 12: |
| 173 | return rtc.systime.year_10; |
| 174 | case 13: |
| 175 | return rtc.mode & 0x0f; |
| 176 | } |
| 177 | } |
| 178 | else // BANK 1 selected |
| 179 | { |
| 180 | switch(offset) |
| 181 | { |
| 182 | case 0: // CLKOUT |
| 183 | return rtc.clkout & 0x07; |
| 184 | case 1: // Adjustment (always returns 0) |
| 185 | return 0; |
| 186 | case 2: |
| 187 | return rtc.alarm.min_1; |
| 188 | case 3: |
| 189 | return rtc.alarm.min_10; |
| 190 | case 4: |
| 191 | return rtc.alarm.hour_1; |
| 192 | case 5: |
| 193 | return rtc.alarm.hour_10; |
| 194 | case 6: |
| 195 | return rtc.alarm.dayofweek; |
| 196 | case 7: |
| 197 | return rtc.alarm.day_1; |
| 198 | case 8: |
| 199 | return rtc.alarm.day_10; |
| 200 | case 10: // 12/24 hour selection (returns AM/PM?) |
| 201 | return 0; |
| 202 | case 11: // Leap year |
| 203 | return rtc.leap; |
| 204 | case 13: |
| 205 | return rtc.mode & 0x0f; |
| 206 | default: |
| 207 | return 0; |
| 208 | } |
| 209 | } |
| 210 | return 0; |
| 211 | } |
| 212 | |
| 213 | void rp5c15_write(int offset, int data, UINT16 mem_mask) |
| 214 | { |
| 215 | if(offset == 13) |
| 216 | { |
| 217 | rtc.mode = data & 0x0f; |
| 218 | return; |
| 219 | } |
| 220 | if((rtc.mode & 0x01) == 0x00) // BANK 0 selected |
| 221 | { |
| 222 | switch(offset) |
| 223 | { |
| 224 | case 0: |
| 225 | rtc.systime.sec_1 = data & 0x0f; |
| 226 | break; |
| 227 | case 1: |
| 228 | rtc.systime.sec_10 = data & 0x0f; |
| 229 | break; |
| 230 | case 2: |
| 231 | rtc.systime.min_1 = data & 0x0f; |
| 232 | break; |
| 233 | case 3: |
| 234 | rtc.systime.min_10 = data & 0x0f; |
| 235 | break; |
| 236 | case 4: |
| 237 | rtc.systime.hour_1 = data & 0x0f; |
| 238 | break; |
| 239 | case 5: |
| 240 | rtc.systime.hour_10 = data & 0x0f; |
| 241 | break; |
| 242 | case 6: |
| 243 | rtc.systime.dayofweek = data & 0x0f; |
| 244 | break; |
| 245 | case 7: |
| 246 | rtc.systime.day_1 = data & 0x0f; |
| 247 | break; |
| 248 | case 8: |
| 249 | rtc.systime.day_10 = data & 0x0f; |
| 250 | break; |
| 251 | case 9: |
| 252 | rtc.systime.month_1 = data & 0x0f; |
| 253 | break; |
| 254 | case 10: |
| 255 | rtc.systime.month_10 = data & 0x0f; |
| 256 | break; |
| 257 | case 11: |
| 258 | rtc.systime.year_1 = data & 0x0f; |
| 259 | break; |
| 260 | case 12: |
| 261 | rtc.systime.year_10 = data & 0x0f; |
| 262 | break; |
| 263 | } |
| 264 | } |
| 265 | else // BANK 1 selected |
| 266 | { |
| 267 | switch(offset) |
| 268 | { |
| 269 | case 0: |
| 270 | rtc.clkout = data & 0x07; |
| 271 | break; |
| 272 | case 1: // Adjustment (resets seconds to 0, increases minute by 1 if seconds are > 30 |
| 273 | if(rtc.systime.sec_10 >= 3) |
| 274 | rtc_add_minute(); |
| 275 | rtc.systime.sec_1 = 0; |
| 276 | rtc.systime.sec_10 = 0; |
| 277 | break; |
| 278 | case 2: |
| 279 | rtc.alarm.min_1 = data & 0x0f; |
| 280 | break; |
| 281 | case 3: |
| 282 | rtc.alarm.min_10 = data & 0x0f; |
| 283 | break; |
| 284 | case 4: |
| 285 | rtc.alarm.hour_1 = data & 0x0f; |
| 286 | break; |
| 287 | case 5: |
| 288 | rtc.alarm.hour_10 = data & 0x0f; |
| 289 | break; |
| 290 | case 6: |
| 291 | rtc.alarm.dayofweek = data & 0x0f; |
| 292 | break; |
| 293 | case 7: |
| 294 | rtc.alarm.day_1 = data & 0x0f; |
| 295 | break; |
| 296 | case 8: |
| 297 | rtc.alarm.day_10 = data & 0x0f; |
| 298 | break; |
| 299 | case 10: // 12/24 hour clock selection |
| 300 | rtc.hour24 = data; |
| 301 | break; |
| 302 | |
| 303 | } |
| 304 | } |
| 305 | } |
| 306 | |
| 307 | void rtc_add_second() // add one second to current time |
| 308 | { |
| 309 | if((rtc.mode & 0x08) == 0x00) // if timer is not enabled |
| 310 | return; |
| 311 | rtc.systime.sec_1++; |
| 312 | if(rtc.systime.sec_1 < 10) |
| 313 | return; |
| 314 | rtc.systime.sec_1 = 0; |
| 315 | rtc.systime.sec_10++; |
| 316 | if(rtc.systime.sec_10 < 6) |
| 317 | return; |
| 318 | rtc.systime.sec_10 = 0; |
| 319 | rtc_add_minute(); |
| 320 | } |
| 321 | |
| 322 | void rtc_add_minute() |
| 323 | { |
| 324 | rtc.systime.min_1++; |
| 325 | if(rtc.systime.min_1 < 10) |
| 326 | return; |
| 327 | rtc.systime.min_1 = 0; |
| 328 | rtc.systime.min_10++; |
| 329 | if(rtc.systime.min_10 < 6) |
| 330 | return; |
| 331 | rtc.systime.min_10 = 0; |
| 332 | rtc.systime.hour_1++; |
| 333 | if(rtc.systime.hour_1 < 10 && rtc.systime.hour_10 < 2) |
| 334 | return; |
| 335 | if(rtc.systime.hour_10 < 3 && rtc.systime.hour_1 < 4) |
| 336 | return; |
| 337 | rtc.systime.hour_1 = 0; |
| 338 | rtc.systime.hour_10++; |
| 339 | if(rtc.systime.hour_10 < 3) |
| 340 | return; |
| 341 | rtc.systime.hour_10 = 0; |
| 342 | rtc_add_day(); |
| 343 | } |
| 344 | |
| 345 | void rtc_add_day() |
| 346 | { |
| 347 | int d,m; |
| 348 | |
| 349 | rtc.systime.dayofweek++; |
| 350 | if(rtc.systime.dayofweek >= 7) |
| 351 | rtc.systime.dayofweek = 0; |
| 352 | d = (rtc.systime.day_10 << 4) | rtc.systime.day_1; |
| 353 | m = (rtc.systime.month_10 << 4) | rtc.systime.month_1; |
| 354 | d++; |
| 355 | if((d & 0x0f) >= 10) |
| 356 | { |
| 357 | d &= 0xf0; |
| 358 | d += 0x10; |
| 359 | } |
| 360 | rtc.systime.day_1 = (d & 0x0f); |
| 361 | rtc.systime.day_10 = (d & 0xf0) >> 4; |
| 362 | switch(m) |
| 363 | { |
| 364 | case 1: |
| 365 | case 3: |
| 366 | case 5: |
| 367 | case 7: |
| 368 | case 8: |
| 369 | case 0x10: |
| 370 | case 0x12: |
| 371 | if(d > 0x31) |
| 372 | { |
| 373 | rtc.systime.day_1 = 1; |
| 374 | rtc.systime.day_10 = 0; |
| 375 | rtc_add_month(); |
| 376 | } |
| 377 | break; |
| 378 | case 4: |
| 379 | case 6: |
| 380 | case 9: |
| 381 | case 11: |
| 382 | if(d > 0x30) |
| 383 | { |
| 384 | rtc.systime.day_1 = 1; |
| 385 | rtc.systime.day_10 = 0; |
| 386 | rtc_add_month(); |
| 387 | } |
| 388 | break; |
| 389 | case 2: |
| 390 | if(rtc.leap == 0) // this is a leap year |
| 391 | { |
| 392 | if(d > 0x29) |
| 393 | { |
| 394 | rtc.systime.day_1 = 1; |
| 395 | rtc.systime.day_10 = 0; |
| 396 | rtc_add_month(); |
| 397 | } |
| 398 | } |
| 399 | else // not a leap year |
| 400 | { |
| 401 | if(d > 0x28) |
| 402 | { |
| 403 | rtc.systime.day_1 = 1; |
| 404 | rtc.systime.day_10 = 0; |
| 405 | rtc_add_month(); |
| 406 | } |
| 407 | } |
| 408 | break; |
| 409 | } |
| 410 | } |
| 411 | |
| 412 | void rtc_add_month() |
| 413 | { |
| 414 | rtc.systime.month_1++; |
| 415 | if(rtc.systime.month_1 < 10 && rtc.systime.month_10 < 1) |
| 416 | return; |
| 417 | if(rtc.systime.month_1 < 3 && rtc.systime.month_10 < 2) |
| 418 | return; |
| 419 | rtc.systime.month_1 = 0; |
| 420 | rtc.systime.month_10++; |
| 421 | if(rtc.systime.month_10 < 2) |
| 422 | return; |
| 423 | rtc.systime.month_1 = 1; |
| 424 | rtc.systime.month_10 = 0; |
| 425 | rtc.systime.year_1++; |
| 426 | if(rtc.systime.year_1 < 10) |
| 427 | return; |
| 428 | rtc.systime.year_1 = 0; |
| 429 | rtc.systime.year_10++; |
| 430 | if(rtc.systime.year_10 < 10) |
| 431 | return; |
| 432 | rtc.systime.year_10 = 0; |
| 433 | } |
| 434 | |
| 435 | READ16_HANDLER(rp5c15_r) { return rp5c15_read(offset,mem_mask); } |
| 436 | WRITE16_HANDLER(rp5c15_w) { rp5c15_write(offset,data,mem_mask); } |
src/mess/machine/68901mfp.c
| r811 | r812 | |
| 1 | | /*
|
| 2 | | |
| 3 | | TODO:
|
| 4 | |
|
| 5 | | - pulse mode
|
| 6 | | - serial comms
|
| 7 | | - interrupt queueing
|
| 8 | | - gpio interrupts
|
| 9 | | - trigger interrupt on AER change
|
| 10 | | |
| 11 | | */
|
| 12 | | |
| 13 | | #include "68901mfp.h"
|
| 14 | | |
| 15 | | typedef struct
|
| 16 | | {
|
| 17 | | UINT8 gpip;
|
| 18 | | UINT8 aer;
|
| 19 | | UINT8 ddr;
|
| 20 | | |
| 21 | | UINT8 iera, ierb;
|
| 22 | | UINT8 ipra, iprb;
|
| 23 | | UINT8 isra, isrb;
|
| 24 | | UINT8 imra, imrb;
|
| 25 | | UINT8 vr;
|
| 26 | | |
| 27 | | UINT8 tacr, tbcr, tcdcr;
|
| 28 | | UINT8 tadr, tbdr, tcdr, tddr;
|
| 29 | | UINT8 tarr, tbrr, tcrr, tdrr;
|
| 30 | | int tao, tbo, tco, tdo;
|
| 31 | | int tai, tbi;
|
| 32 | | |
| 33 | | UINT8 scr;
|
| 34 | | UINT8 ucr;
|
| 35 | | UINT8 rsr;
|
| 36 | | UINT8 tsr;
|
| 37 | | UINT8 udr;
|
| 38 | | |
| 39 | | mame_timer *timer_a, *timer_b, *timer_c, *timer_d;
|
| 40 | | |
| 41 | | int chip_clock;
|
| 42 | | int timer_clock;
|
| 43 | | |
| 44 | | void (*tao_w)(int which, int value);
|
| 45 | | void (*tbo_w)(int which, int value);
|
| 46 | | void (*tco_w)(int which, int value);
|
| 47 | | void (*tdo_w)(int which, int value);
|
| 48 | | |
| 49 | | void (*irq_callback)(int which, int state, int vector);
|
| 50 | | |
| 51 | | read8_handler gpio_r;
|
| 52 | | write8_handler gpio_w;
|
| 53 | | } mfp_68901;
|
| 54 | | |
| 55 | | static mfp_68901 mfp[MAX_MFP];
|
| 56 | | |
| 57 | | static TIMER_CALLBACK( timer_a );
|
| 58 | | static TIMER_CALLBACK( timer_b );
|
| 59 | | static TIMER_CALLBACK( timer_c );
|
| 60 | | static TIMER_CALLBACK( timer_d );
|
| 61 | | |
| 62 | | void mfp68901_irq_ack(int which)
|
| 63 | | {
|
| 64 | | mfp_68901 *mfp_p = &mfp[which];
|
| 65 | | |
| 66 | | UINT16 ipr = (mfp_p->ipra << 8) | mfp_p->iprb;
|
| 67 | | UINT16 isr = (mfp_p->isra << 8) | mfp_p->isrb;
|
| 68 | | UINT16 imr = (mfp_p->imra << 8) | mfp_p->imrb;
|
| 69 | | int ch;
|
| 70 | | |
| 71 | | for (ch = 15; ch > 0; ch--)
|
| 72 | | {
|
| 73 | | if (BIT(isr, ch))
|
| 74 | | {
|
| 75 | | break;
|
| 76 | | }
|
| 77 | | |
| 78 | | if (BIT(ipr, ch) && BIT(imr, ch))
|
| 79 | | {
|
| 80 | | ipr -= (1 << ch);
|
| 81 | | |
| 82 | | mfp_p->ipra = (ipr & 0xff00) >> 8;
|
| 83 | | mfp_p->iprb = ipr & 0xff;
|
| 84 | | |
| 85 | | if (mfp_p->vr & MFP68901_VR_S)
|
| 86 | | {
|
| 87 | | isr |= (1 << ch);
|
| 88 | | |
| 89 | | mfp_p->isra = (isr & 0xff00) >> 8;
|
| 90 | | mfp_p->isrb = isr & 0xff;
|
| 91 | | }
|
| 92 | | |
| 93 | | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | (15 - ch));
|
| 94 | | return;
|
| 95 | | }
|
| 96 | | |
| 97 | | ipr <<= 1;
|
| 98 | | isr <<= 1;
|
| 99 | | imr <<= 1;
|
| 100 | | }
|
| 101 | | |
| 102 | | mfp_p->irq_callback(which, CLEAR_LINE, 0);
|
| 103 | | }
|
| 104 | | |
| 105 | | static UINT8 mfp68901_register_r(int which, int reg)
|
| 106 | | {
|
| 107 | | mfp_68901 *mfp_p = &mfp[which];
|
| 108 | | |
| 109 | | switch (reg)
|
| 110 | | {
|
| 111 | | case MFP68901_REGISTER_GPIP:
|
| 112 | | {
|
| 113 | | UINT8 gpio = 0x80;
|
| 114 | | |
| 115 | | if (mfp_p->gpio_r)
|
| 116 | | {
|
| 117 | | //gpio = (*mfp_p->gpio_r)(0);
|
| 118 | | }
|
| 119 | | |
| 120 | | gpio |= (mfp_p->gpip & mfp_p->ddr);
|
| 121 | | |
| 122 | | // signal interrupts if necessary
|
| 123 | | mfp68901_irq_ack(which);
|
| 124 | | return gpio;
|
| 125 | | }
|
| 126 | | case MFP68901_REGISTER_AER: return mfp_p->aer;
|
| 127 | | case MFP68901_REGISTER_DDR: return mfp_p->ddr;
|
| 128 | | |
| 129 | | case MFP68901_REGISTER_IERA: return mfp_p->iera;
|
| 130 | | case MFP68901_REGISTER_IERB: return mfp_p->ierb;
|
| 131 | | case MFP68901_REGISTER_IPRA: return mfp_p->ipra;
|
| 132 | | case MFP68901_REGISTER_IPRB: return mfp_p->iprb;
|
| 133 | | case MFP68901_REGISTER_ISRA: return mfp_p->isra;
|
| 134 | | case MFP68901_REGISTER_ISRB: return mfp_p->isrb;
|
| 135 | | case MFP68901_REGISTER_IMRA: return mfp_p->imra;
|
| 136 | | case MFP68901_REGISTER_IMRB: return mfp_p->imrb;
|
| 137 | | case MFP68901_REGISTER_VR: return mfp_p->vr;
|
| 138 | | |
| 139 | | case MFP68901_REGISTER_TACR: return mfp_p->tacr;
|
| 140 | | case MFP68901_REGISTER_TBCR: return mfp_p->tbcr;
|
| 141 | | case MFP68901_REGISTER_TCDCR: return mfp_p->tcdcr;
|
| 142 | | case MFP68901_REGISTER_TADR:
|
| 143 | | return mfp_p->tarr;
|
| 144 | | case MFP68901_REGISTER_TBDR: |
| 145 | | return mfp_p->tbrr;
|
| 146 | | case MFP68901_REGISTER_TCDR: return mfp_p->tcrr;
|
| 147 | | case MFP68901_REGISTER_TDDR: return mfp_p->tdrr;
|
| 148 | | |
| 149 | | case MFP68901_REGISTER_SCR: return mfp_p->scr;
|
| 150 | | case MFP68901_REGISTER_UCR: return mfp_p->ucr;
|
| 151 | | case MFP68901_REGISTER_RSR: return mfp_p->rsr;
|
| 152 | | case MFP68901_REGISTER_TSR: return mfp_p->tsr;
|
| 153 | | case MFP68901_REGISTER_UDR: return mfp_p->udr;
|
| 154 | | default:
|
| 155 | | return 0;
|
| 156 | | }
|
| 157 | | }
|
| 158 | | |
| 159 | | static void mfp68901_register_w(int which, int reg, UINT8 data)
|
| 160 | | {
|
| 161 | | mfp_68901 *mfp_p = &mfp[which];
|
| 162 | | |
| 163 | | switch (reg)
|
| 164 | | {
|
| 165 | | case MFP68901_REGISTER_GPIP:
|
| 166 | | logerror("MFP68901 GPIP %x\n", data);
|
| 167 | | mfp_p->gpip = data & mfp_p->ddr;
|
| 168 | | |
| 169 | | if (mfp_p->gpio_w)
|
| 170 | | {
|
| 171 | | mfp_p->gpio_w(0, mfp_p->gpip);
|
| 172 | | }
|
| 173 | | break;
|
| 174 | | case MFP68901_REGISTER_AER:
|
| 175 | | logerror("MFP68901 AER %x\n", data);
|
| 176 | | mfp_p->aer = data;
|
| 177 | | // check transition and trigger interrupt if necessary
|
| 178 | | mfp68901_irq_ack(which);
|
| 179 | | break;
|
| 180 | | case MFP68901_REGISTER_DDR:
|
| 181 | | logerror("MFP68901 DDR %x\n", data);
|
| 182 | | mfp_p->ddr = data;
|
| 183 | | break;
|
| 184 | | |
| 185 | | case MFP68901_REGISTER_IERA:
|
| 186 | | logerror("MFP68901 IERA %x\n", data);
|
| 187 | | mfp_p->iera = data;
|
| 188 | | mfp_p->ipra &= mfp_p->iera;
|
| 189 | | mfp68901_irq_ack(which);
|
| 190 | | break;
|
| 191 | | case MFP68901_REGISTER_IERB:
|
| 192 | | logerror("MFP68901 IERB %x\n", data);
|
| 193 | | mfp_p->ierb = data;
|
| 194 | | mfp_p->iprb &= mfp_p->ierb;
|
| 195 | | mfp68901_irq_ack(which);
|
| 196 | | break;
|
| 197 | | case MFP68901_REGISTER_IPRA:
|
| 198 | | logerror("MFP68901 IPRA %x\n", data);
|
| 199 | | mfp_p->ipra &= data;
|
| 200 | | mfp68901_irq_ack(which);
|
| 201 | | break;
|
| 202 | | case MFP68901_REGISTER_IPRB:
|
| 203 | | logerror("MFP68901 IPRB %x\n", data);
|
| 204 | | mfp_p->iprb &= data;
|
| 205 | | mfp68901_irq_ack(which);
|
| 206 | | break;
|
| 207 | | case MFP68901_REGISTER_ISRA:
|
| 208 | | logerror("MFP68901 ISRA %x\n", data);
|
| 209 | | mfp_p->isra = data;
|
| 210 | | mfp68901_irq_ack(which);
|
| 211 | | break;
|
| 212 | | case MFP68901_REGISTER_ISRB:
|
| 213 | | logerror("MFP68901 ISRB %x\n", data);
|
| 214 | | mfp_p->isrb = data;
|
| 215 | | mfp68901_irq_ack(which);
|
| 216 | | break;
|
| 217 | | case MFP68901_REGISTER_IMRA:
|
| 218 | | logerror("MFP68901 IMRA %x\n", data);
|
| 219 | | mfp_p->imra = data;
|
| 220 | | mfp68901_irq_ack(which);
|
| 221 | | break;
|
| 222 | | case MFP68901_REGISTER_IMRB:
|
| 223 | | logerror("MFP68901 IMRB %x\n", data);
|
| 224 | | mfp_p->imrb = data;
|
| 225 | | mfp68901_irq_ack(which);
|
| 226 | | break;
|
| 227 | | case MFP68901_REGISTER_VR:
|
| 228 | | logerror("MFP68901 VR %x\n", data);
|
| 229 | | mfp_p->vr = data & 0xf8;
|
| 230 | | if ((mfp_p->vr & MFP68901_VR_S) == 0)
|
| 231 | | {
|
| 232 | | mfp_p->isra = mfp_p->isrb = 0;
|
| 233 | | mfp68901_irq_ack(which);
|
| 234 | | }
|
| 235 | | break;
|
| 236 | | |
| 237 | | case MFP68901_REGISTER_TACR:
|
| 238 | | logerror("MFP68901 TACR %x\n", data);
|
| 239 | | mfp_p->tacr = data & 0x1f;
|
| 240 | | |
| 241 | | switch (mfp_p->tacr & 0x0f)
|
| 242 | | {
|
| 243 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 244 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4));
|
| 245 | | break;
|
| 246 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 247 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10));
|
| 248 | | break;
|
| 249 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 250 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16));
|
| 251 | | break;
|
| 252 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 253 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50));
|
| 254 | | break;
|
| 255 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 256 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64));
|
| 257 | | break;
|
| 258 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 259 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100));
|
| 260 | | break;
|
| 261 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 262 | | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200));
|
| 263 | | break;
|
| 264 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 265 | | case MFP68901_TCR_TIMER_EVENT:
|
| 266 | | case MFP68901_TCR_TIMER_PULSE_4:
|
| 267 | | case MFP68901_TCR_TIMER_PULSE_10:
|
| 268 | | case MFP68901_TCR_TIMER_PULSE_16:
|
| 269 | | case MFP68901_TCR_TIMER_PULSE_50:
|
| 270 | | case MFP68901_TCR_TIMER_PULSE_64:
|
| 271 | | case MFP68901_TCR_TIMER_PULSE_100:
|
| 272 | | case MFP68901_TCR_TIMER_PULSE_200:
|
| 273 | | mame_timer_enable(mfp_p->timer_a, 0);
|
| 274 | | break;
|
| 275 | | }
|
| 276 | | |
| 277 | | if (mfp_p->tacr & MFP68901_TCR_TIMER_RESET)
|
| 278 | | {
|
| 279 | | mfp_p->tao = 0;
|
| 280 | | |
| 281 | | if (mfp_p->tao_w)
|
| 282 | | {
|
| 283 | | mfp_p->tao_w(which, mfp_p->tao);
|
| 284 | | }
|
| 285 | | }
|
| 286 | | break;
|
| 287 | | case MFP68901_REGISTER_TBCR:
|
| 288 | | logerror("MFP68901 TBCR %x\n", data);
|
| 289 | | mfp_p->tbcr = data & 0x1f;
|
| 290 | | |
| 291 | | switch (mfp_p->tbcr & 0x0f)
|
| 292 | | {
|
| 293 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 294 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4));
|
| 295 | | break;
|
| 296 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 297 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10));
|
| 298 | | break;
|
| 299 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 300 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16));
|
| 301 | | break;
|
| 302 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 303 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50));
|
| 304 | | break;
|
| 305 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 306 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64));
|
| 307 | | break;
|
| 308 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 309 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100));
|
| 310 | | break;
|
| 311 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 312 | | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200));
|
| 313 | | break;
|
| 314 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 315 | | case MFP68901_TCR_TIMER_EVENT:
|
| 316 | | case MFP68901_TCR_TIMER_PULSE_4:
|
| 317 | | case MFP68901_TCR_TIMER_PULSE_10:
|
| 318 | | case MFP68901_TCR_TIMER_PULSE_16:
|
| 319 | | case MFP68901_TCR_TIMER_PULSE_50:
|
| 320 | | case MFP68901_TCR_TIMER_PULSE_64:
|
| 321 | | case MFP68901_TCR_TIMER_PULSE_100:
|
| 322 | | case MFP68901_TCR_TIMER_PULSE_200:
|
| 323 | | mame_timer_enable(mfp_p->timer_b, 0);
|
| 324 | | break;
|
| 325 | | }
|
| 326 | | |
| 327 | | if (mfp_p->tbcr & MFP68901_TCR_TIMER_RESET)
|
| 328 | | {
|
| 329 | | mfp_p->tbo = 0;
|
| 330 | | |
| 331 | | if (mfp_p->tbo_w)
|
| 332 | | {
|
| 333 | | mfp_p->tbo_w(which, mfp_p->tbo);
|
| 334 | | }
|
| 335 | | }
|
| 336 | | break;
|
| 337 | | case MFP68901_REGISTER_TCDCR: |
| 338 | | logerror("MFP68901 TCDCR %x\n", data);
|
| 339 | | mfp_p->tcdcr = data & 0x6f;
|
| 340 | | |
| 341 | | switch (mfp_p->tcdcr & 0x07)
|
| 342 | | {
|
| 343 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 344 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4));
|
| 345 | | break;
|
| 346 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 347 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10));
|
| 348 | | break;
|
| 349 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 350 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16));
|
| 351 | | break;
|
| 352 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 353 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50));
|
| 354 | | break;
|
| 355 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 356 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64));
|
| 357 | | break;
|
| 358 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 359 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100));
|
| 360 | | break;
|
| 361 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 362 | | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200));
|
| 363 | | break;
|
| 364 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 365 | | mame_timer_enable(mfp_p->timer_d, 0);
|
| 366 | | break;
|
| 367 | | }
|
| 368 | | |
| 369 | | switch ((mfp_p->tcdcr >> 4) & 0x07)
|
| 370 | | {
|
| 371 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 372 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4));
|
| 373 | | break;
|
| 374 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 375 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10));
|
| 376 | | break;
|
| 377 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 378 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16));
|
| 379 | | break;
|
| 380 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 381 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50));
|
| 382 | | break;
|
| 383 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 384 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64));
|
| 385 | | break;
|
| 386 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 387 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100));
|
| 388 | | break;
|
| 389 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 390 | | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200));
|
| 391 | | break;
|
| 392 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 393 | | mame_timer_enable(mfp_p->timer_c, 0);
|
| 394 | | break;
|
| 395 | | }
|
| 396 | | break;
|
| 397 | | case MFP68901_REGISTER_TADR:
|
| 398 | | logerror("MFP68901 TADR %x\n", data);
|
| 399 | | mfp_p->tadr = data;
|
| 400 | | |
| 401 | | if (!mame_timer_enabled(mfp_p->timer_a))
|
| 402 | | {
|
| 403 | | mfp_p->tarr = data;
|
| 404 | | }
|
| 405 | | break;
|
| 406 | | case MFP68901_REGISTER_TBDR:
|
| 407 | | logerror("MFP68901 TBDR %x\n", data);
|
| 408 | | mfp_p->tbdr = data;
|
| 409 | | |
| 410 | | if (!mame_timer_enabled(mfp_p->timer_b))
|
| 411 | | {
|
| 412 | | mfp_p->tbrr = data;
|
| 413 | | }
|
| 414 | | break;
|
| 415 | | case MFP68901_REGISTER_TCDR:
|
| 416 | | logerror("MFP68901 TCDR %x\n", data);
|
| 417 | | mfp_p->tcdr = data;
|
| 418 | | |
| 419 | | if (!mame_timer_enabled(mfp_p->timer_c))
|
| 420 | | {
|
| 421 | | mfp_p->tcrr = data;
|
| 422 | | }
|
| 423 | | break;
|
| 424 | | case MFP68901_REGISTER_TDDR:
|
| 425 | | logerror("MFP68901 TDDR %x\n", data);
|
| 426 | | mfp_p->tddr = data;
|
| 427 | | |
| 428 | | if (!mame_timer_enabled(mfp_p->timer_d))
|
| 429 | | {
|
| 430 | | mfp_p->tdrr = data;
|
| 431 | | }
|
| 432 | | break;
|
| 433 | | |
| 434 | | // USART not implemented
|
| 435 | | case MFP68901_REGISTER_SCR:
|
| 436 | | logerror("MFP68901 SCR %x\n", data);
|
| 437 | | mfp_p->scr = data;
|
| 438 | | break;
|
| 439 | | case MFP68901_REGISTER_UCR:
|
| 440 | | logerror("MFP68901 UCR %x\n", data);
|
| 441 | | mfp_p->ucr = data;
|
| 442 | | break;
|
| 443 | | case MFP68901_REGISTER_RSR:
|
| 444 | | logerror("MFP68901 RSR %x\n", data);
|
| 445 | | mfp_p->rsr = data;
|
| 446 | | break;
|
| 447 | | case MFP68901_REGISTER_TSR:
|
| 448 | | logerror("MFP68901 TSR %x\n", data);
|
| 449 | | mfp_p->tsr = data;
|
| 450 | | break;
|
| 451 | | case MFP68901_REGISTER_UDR:
|
| 452 | | logerror("MFP68901 UDR %x\n", data);
|
| 453 | | mfp_p->udr = data;
|
| 454 | | break;
|
| 455 | | }
|
| 456 | | }
|
| 457 | | |
| 458 | | void mfp68901_config(int which, const struct mfp68901_interface *intf)
|
| 459 | | {
|
| 460 | | mfp_68901 *mfp_p = &mfp[which];
|
| 461 | | |
| 462 | | if (which >= MAX_MFP)
|
| 463 | | {
|
| 464 | | return;
|
| 465 | | }
|
| 466 | | |
| 467 | | memset(mfp_p, 0, sizeof(mfp));
|
| 468 | | |
| 469 | | mfp_p->chip_clock = intf->chip_clock;
|
| 470 | | mfp_p->timer_clock = intf->timer_clock;
|
| 471 | | mfp_p->irq_callback = intf->irq_callback;
|
| 472 | | mfp_p->gpio_r = intf->gpio_r;
|
| 473 | | mfp_p->gpio_w = intf->gpio_w;
|
| 474 | |
|
| 475 | | mfp_p->timer_a = mame_timer_alloc(timer_a);
|
| 476 | | mfp_p->timer_b = mame_timer_alloc(timer_b);
|
| 477 | | mfp_p->timer_c = mame_timer_alloc(timer_c);
|
| 478 | | mfp_p->timer_d = mame_timer_alloc(timer_d);
|
| 479 | | |
| 480 | | mame_timer_reset(mfp_p->timer_a, time_never);
|
| 481 | | mame_timer_reset(mfp_p->timer_b, time_never);
|
| 482 | | mame_timer_reset(mfp_p->timer_c, time_never);
|
| 483 | | mame_timer_reset(mfp_p->timer_d, time_never);
|
| 484 | | |
| 485 | | state_save_register_item("mfp68901", which, mfp_p->gpip);
|
| 486 | | state_save_register_item("mfp68901", which, mfp_p->aer);
|
| 487 | | state_save_register_item("mfp68901", which, mfp_p->ddr);
|
| 488 | | state_save_register_item("mfp68901", which, mfp_p->iera);
|
| 489 | | state_save_register_item("mfp68901", which, mfp_p->ierb);
|
| 490 | | state_save_register_item("mfp68901", which, mfp_p->ipra);
|
| 491 | | state_save_register_item("mfp68901", which, mfp_p->iprb);
|
| 492 | | state_save_register_item("mfp68901", which, mfp_p->isra);
|
| 493 | | state_save_register_item("mfp68901", which, mfp_p->isrb);
|
| 494 | | state_save_register_item("mfp68901", which, mfp_p->imra);
|
| 495 | | state_save_register_item("mfp68901", which, mfp_p->imrb);
|
| 496 | | state_save_register_item("mfp68901", which, mfp_p->vr);
|
| 497 | | state_save_register_item("mfp68901", which, mfp_p->tacr);
|
| 498 | | state_save_register_item("mfp68901", which, mfp_p->tbcr);
|
| 499 | | state_save_register_item("mfp68901", which, mfp_p->tcdcr);
|
| 500 | | state_save_register_item("mfp68901", which, mfp_p->tadr);
|
| 501 | | state_save_register_item("mfp68901", which, mfp_p->tbdr);
|
| 502 | | state_save_register_item("mfp68901", which, mfp_p->tcdr);
|
| 503 | | state_save_register_item("mfp68901", which, mfp_p->tddr);
|
| 504 | | state_save_register_item("mfp68901", which, mfp_p->tarr);
|
| 505 | | state_save_register_item("mfp68901", which, mfp_p->tbrr);
|
| 506 | | state_save_register_item("mfp68901", which, mfp_p->tcrr);
|
| 507 | | state_save_register_item("mfp68901", which, mfp_p->tdrr);
|
| 508 | | state_save_register_item("mfp68901", which, mfp_p->tao);
|
| 509 | | state_save_register_item("mfp68901", which, mfp_p->tbo);
|
| 510 | | state_save_register_item("mfp68901", which, mfp_p->tco);
|
| 511 | | state_save_register_item("mfp68901", which, mfp_p->tdo);
|
| 512 | | state_save_register_item("mfp68901", which, mfp_p->tai);
|
| 513 | | state_save_register_item("mfp68901", which, mfp_p->tbi);
|
| 514 | | state_save_register_item("mfp68901", which, mfp_p->scr);
|
| 515 | | state_save_register_item("mfp68901", which, mfp_p->ucr);
|
| 516 | | state_save_register_item("mfp68901", which, mfp_p->rsr);
|
| 517 | | state_save_register_item("mfp68901", which, mfp_p->tsr);
|
| 518 | | state_save_register_item("mfp68901", which, mfp_p->udr);
|
| 519 | | state_save_register_item("mfp68901", which, mfp_p->chip_clock);
|
| 520 | | state_save_register_item("mfp68901", which, mfp_p->timer_clock);
|
| 521 | | }
|
| 522 | | |
| 523 | | void mfp68901_timer_count_a(int which)
|
| 524 | | {
|
| 525 | | mfp_68901 *mfp_p = &mfp[which];
|
| 526 | | |
| 527 | | if (mfp_p->tarr == 0x01)
|
| 528 | | {
|
| 529 | | if (mfp_p->iera & 0x20)
|
| 530 | | {
|
| 531 | | mfp_p->ipra |= 0x20;
|
| 532 | | |
| 533 | | if (mfp_p->imra & 0x20)
|
| 534 | | {
|
| 535 | | //mfp68901_irq_ack(which);
|
| 536 | | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_A);
|
| 537 | | |
| 538 | | if (mfp_p->tao)
|
| 539 | | {
|
| 540 | | mfp_p->tao = 0;
|
| 541 | | }
|
| 542 | | else
|
| 543 | | {
|
| 544 | | mfp_p->tao = 1;
|
| 545 | | }
|
| 546 | | |
| 547 | | if (mfp_p->tao_w)
|
| 548 | | {
|
| 549 | | mfp_p->tao_w(which, mfp_p->tao);
|
| 550 | | }
|
| 551 | | }
|
| 552 | | }
|
| 553 | | |
| 554 | | mfp_p->tarr = mfp_p->tadr;
|
| 555 | | }
|
| 556 | | else
|
| 557 | | {
|
| 558 | | mfp_p->tarr--;
|
| 559 | | }
|
| 560 | | }
|
| 561 | | |
| 562 | | void mfp68901_timer_count_b(int which)
|
| 563 | | {
|
| 564 | | mfp_68901 *mfp_p = &mfp[which];
|
| 565 | | |
| 566 | | if (mfp_p->tbrr == 0x01)
|
| 567 | | {
|
| 568 | | if (mfp_p->iera & 0x01)
|
| 569 | | {
|
| 570 | | mfp_p->ipra |= 0x01;
|
| 571 | | |
| 572 | | if (mfp_p->imra & 0x01)
|
| 573 | | {
|
| 574 | | //mfp68901_irq_ack(which);
|
| 575 | | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_B);
|
| 576 | | |
| 577 | | if (mfp_p->tbo)
|
| 578 | | {
|
| 579 | | mfp_p->tbo = 0;
|
| 580 | | }
|
| 581 | | else
|
| 582 | | {
|
| 583 | | mfp_p->tbo = 1;
|
| 584 | | }
|
| 585 | | |
| 586 | | if (mfp_p->tbo_w)
|
| 587 | | {
|
| 588 | | mfp_p->tbo_w(which, mfp_p->tbo);
|
| 589 | | }
|
| 590 | | }
|
| 591 | | }
|
| 592 | | |
| 593 | | mfp_p->tbrr = mfp_p->tbdr;
|
| 594 | | }
|
| 595 | | else
|
| 596 | | {
|
| 597 | | mfp_p->tbrr--;
|
| 598 | | }
|
| 599 | | }
|
| 600 | | |
| 601 | | void mfp68901_timer_count_c(int which)
|
| 602 | | {
|
| 603 | | mfp_68901 *mfp_p = &mfp[which];
|
| 604 | | |
| 605 | | if (mfp_p->tcrr == 0x01)
|
| 606 | | {
|
| 607 | | if (mfp_p->ierb & 0x20)
|
| 608 | | {
|
| 609 | | mfp_p->iprb |= 0x20;
|
| 610 | | |
| 611 | | if (mfp_p->imrb & 0x20)
|
| 612 | | {
|
| 613 | | //mfp68901_irq_ack(which);
|
| 614 | | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_C);
|
| 615 | | |
| 616 | | if (mfp_p->tco)
|
| 617 | | {
|
| 618 | | mfp_p->tco = 0;
|
| 619 | | }
|
| 620 | | else
|
| 621 | | {
|
| 622 | | mfp_p->tco = 1;
|
| 623 | | }
|
| 624 | | |
| 625 | | if (mfp_p->tco_w)
|
| 626 | | {
|
| 627 | | mfp_p->tco_w(which, mfp_p->tco);
|
| 628 | | }
|
| 629 | | }
|
| 630 | | }
|
| 631 | | |
| 632 | | mfp_p->tcrr = mfp_p->tcdr;
|
| 633 | | }
|
| 634 | | else
|
| 635 | | {
|
| 636 | | mfp_p->tcrr--;
|
| 637 | | }
|
| 638 | | }
|
| 639 | | |
| 640 | | void mfp68901_timer_count_d(int which)
|
| 641 | | {
|
| 642 | | mfp_68901 *mfp_p = &mfp[which];
|
| 643 | | |
| 644 | | if (mfp_p->tdrr == 0x01)
|
| 645 | | {
|
| 646 | | if (mfp_p->ierb & 0x01)
|
| 647 | | {
|
| 648 | | mfp_p->iprb |= 0x01;
|
| 649 | | |
| 650 | | if (mfp_p->imrb & 0x01)
|
| 651 | | {
|
| 652 | | //mfp68901_irq_ack(which);
|
| 653 | | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_D);
|
| 654 | | |
| 655 | | if (mfp_p->tdo)
|
| 656 | | {
|
| 657 | | mfp_p->tdo = 0;
|
| 658 | | }
|
| 659 | | else
|
| 660 | | {
|
| 661 | | mfp_p->tdo = 1;
|
| 662 | | }
|
| 663 | | |
| 664 | | if (mfp_p->tdo_w)
|
| 665 | | {
|
| 666 | | mfp_p->tdo_w(which, mfp_p->tdo);
|
| 667 | | }
|
| 668 | | }
|
| 669 | | }
|
| 670 | | |
| 671 | | mfp_p->tdrr = mfp_p->tddr;
|
| 672 | | }
|
| 673 | | else
|
| 674 | | {
|
| 675 | | mfp_p->tdrr--;
|
| 676 | | }
|
| 677 | | }
|
| 678 | | |
| 679 | | void mfp68901_tai_w(int which, int value)
|
| 680 | | {
|
| 681 | | mfp_68901 *mfp_p = &mfp[which];
|
| 682 | | |
| 683 | | switch (mfp_p->tacr & 0x0f)
|
| 684 | | {
|
| 685 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 686 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 687 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 688 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 689 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 690 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 691 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 692 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 693 | | return;
|
| 694 | | |
| 695 | | case MFP68901_TCR_TIMER_EVENT:
|
| 696 | | if (mfp_p->aer & MFP68901_AER_GPIP_4)
|
| 697 | | {
|
| 698 | | // count down on 0->1 transition
|
| 699 | | if (mfp_p->tai == 0 && value == 1)
|
| 700 | | {
|
| 701 | | mfp68901_timer_count_a(which);
|
| 702 | | }
|
| 703 | | }
|
| 704 | | else
|
| 705 | | {
|
| 706 | | // count down on 1->0 transition
|
| 707 | | if (mfp_p->tai == 1 && value == 0)
|
| 708 | | {
|
| 709 | | mfp68901_timer_count_a(which);
|
| 710 | | }
|
| 711 | | }
|
| 712 | | |
| 713 | | mfp_p->tai = value;
|
| 714 | | break;
|
| 715 | | |
| 716 | | case MFP68901_TCR_TIMER_PULSE_4:
|
| 717 | | case MFP68901_TCR_TIMER_PULSE_10:
|
| 718 | | case MFP68901_TCR_TIMER_PULSE_16:
|
| 719 | | case MFP68901_TCR_TIMER_PULSE_50:
|
| 720 | | case MFP68901_TCR_TIMER_PULSE_64:
|
| 721 | | case MFP68901_TCR_TIMER_PULSE_100:
|
| 722 | | case MFP68901_TCR_TIMER_PULSE_200:
|
| 723 | | break;
|
| 724 | | }
|
| 725 | | |
| 726 | | mfp68901_irq_ack(which);
|
| 727 | | }
|
| 728 | | |
| 729 | | void mfp68901_tbi_w(int which, int value)
|
| 730 | | {
|
| 731 | | mfp_68901 *mfp_p = &mfp[which];
|
| 732 | | |
| 733 | | switch (mfp_p->tbcr & 0x0f)
|
| 734 | | {
|
| 735 | | case MFP68901_TCR_TIMER_DELAY_4:
|
| 736 | | case MFP68901_TCR_TIMER_DELAY_10:
|
| 737 | | case MFP68901_TCR_TIMER_DELAY_16:
|
| 738 | | case MFP68901_TCR_TIMER_DELAY_50:
|
| 739 | | case MFP68901_TCR_TIMER_DELAY_64:
|
| 740 | | case MFP68901_TCR_TIMER_DELAY_100:
|
| 741 | | case MFP68901_TCR_TIMER_DELAY_200:
|
| 742 | | case MFP68901_TCR_TIMER_STOPPED:
|
| 743 | | return;
|
| 744 | | |
| 745 | | case MFP68901_TCR_TIMER_EVENT:
|
| 746 | | if (mfp_p->aer & MFP68901_AER_GPIP_3)
|
| 747 | | {
|
| 748 | | // count down on 0->1 transition
|
| 749 | | if (mfp_p->tbi == 0 && value == 1)
|
| 750 | | {
|
| 751 | | mfp68901_timer_count_b(which);
|
| 752 | | }
|
| 753 | | }
|
| 754 | | else
|
| 755 | | {
|
| 756 | | // count down on 1->0 transition
|
| 757 | | if (mfp_p->tbi == 1 && value == 0)
|
| 758 | | {
|
| 759 | | mfp68901_timer_count_b(which);
|
| 760 | | }
|
| 761 | | }
|
| 762 | | |
| 763 | | mfp_p->tbi = value;
|
| 764 | | break;
|
| 765 | | |
| 766 | | case MFP68901_TCR_TIMER_PULSE_4:
|
| 767 | | case MFP68901_TCR_TIMER_PULSE_10:
|
| 768 | | case MFP68901_TCR_TIMER_PULSE_16:
|
| 769 | | case MFP68901_TCR_TIMER_PULSE_50:
|
| 770 | | case MFP68901_TCR_TIMER_PULSE_64:
|
| 771 | | case MFP68901_TCR_TIMER_PULSE_100:
|
| 772 | | case MFP68901_TCR_TIMER_PULSE_200:
|
| 773 | | break;
|
| 774 | | }
|
| 775 | | |
| 776 | | mfp68901_irq_ack(which);
|
| 777 | | }
|
| 778 | | |
| 779 | | static TIMER_CALLBACK( timer_a )
|
| 780 | | {
|
| 781 | | int which = param;
|
| 782 | | |
| 783 | | mfp68901_timer_count_a(which);
|
| 784 | | }
|
| 785 | | |
| 786 | | static TIMER_CALLBACK( timer_b )
|
| 787 | | {
|
| 788 | | int which = param;
|
| 789 | | |
| 790 | | mfp68901_timer_count_b(which);
|
| 791 | | }
|
| 792 | | |
| 793 | | static TIMER_CALLBACK( timer_c )
|
| 794 | | {
|
| 795 | | int which = param;
|
| 796 | | |
| 797 | | mfp68901_timer_count_c(which);
|
| 798 | | }
|
| 799 | | |
| 800 | | static TIMER_CALLBACK( timer_d )
|
| 801 | | {
|
| 802 | | int which = param;
|
| 803 | | |
| 804 | | mfp68901_timer_count_d(which);
|
| 805 | | }
|
| 806 | | |
| 807 | | READ16_HANDLER( mfp68901_0_register16_r ) { return mfp68901_register_r(0, offset); }
|
| 808 | | READ16_HANDLER( mfp68901_1_register16_r ) { return mfp68901_register_r(1, offset); }
|
| 809 | | READ16_HANDLER( mfp68901_2_register16_r ) { return mfp68901_register_r(2, offset); }
|
| 810 | | READ16_HANDLER( mfp68901_3_register16_r ) { return mfp68901_register_r(3, offset); }
|
| 811 | | |
| 812 | | WRITE16_HANDLER( mfp68901_0_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); }
|
| 813 | | WRITE16_HANDLER( mfp68901_1_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); }
|
| 814 | | WRITE16_HANDLER( mfp68901_2_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); }
|
| 815 | | WRITE16_HANDLER( mfp68901_3_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); }
|
| 816 | | |
| 817 | | WRITE16_HANDLER( mfp68901_0_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); }
|
| 818 | | WRITE16_HANDLER( mfp68901_1_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); }
|
| 819 | | WRITE16_HANDLER( mfp68901_2_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); }
|
| 820 | | WRITE16_HANDLER( mfp68901_3_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); }
|
| 1 | /* |
| 2 | |
| 3 | TODO: |
| 4 | |
| 5 | - pulse mode |
| 6 | - serial comms |
| 7 | - interrupt queueing |
| 8 | - gpio interrupts |
| 9 | - trigger interrupt on AER change |
| 10 | |
| 11 | */ |
| 12 | |
| 13 | #include "68901mfp.h" |
| 14 | |
| 15 | typedef struct |
| 16 | { |
| 17 | UINT8 gpip; |
| 18 | UINT8 aer; |
| 19 | UINT8 ddr; |
| 20 | |
| 21 | UINT8 iera, ierb; |
| 22 | UINT8 ipra, iprb; |
| 23 | UINT8 isra, isrb; |
| 24 | UINT8 imra, imrb; |
| 25 | UINT8 vr; |
| 26 | |
| 27 | UINT8 tacr, tbcr, tcdcr; |
| 28 | UINT8 tadr, tbdr, tcdr, tddr; |
| 29 | UINT8 tarr, tbrr, tcrr, tdrr; |
| 30 | int tao, tbo, tco, tdo; |
| 31 | int tai, tbi; |
| 32 | |
| 33 | UINT8 scr; |
| 34 | UINT8 ucr; |
| 35 | UINT8 rsr; |
| 36 | UINT8 tsr; |
| 37 | UINT8 udr; |
| 38 | |
| 39 | mame_timer *timer_a, *timer_b, *timer_c, *timer_d; |
| 40 | |
| 41 | int chip_clock; |
| 42 | int timer_clock; |
| 43 | |
| 44 | void (*tao_w)(int which, int value); |
| 45 | void (*tbo_w)(int which, int value); |
| 46 | void (*tco_w)(int which, int value); |
| 47 | void (*tdo_w)(int which, int value); |
| 48 | |
| 49 | void (*irq_callback)(int which, int state, int vector); |
| 50 | |
| 51 | read8_handler gpio_r; |
| 52 | write8_handler gpio_w; |
| 53 | } mfp_68901; |
| 54 | |
| 55 | static mfp_68901 mfp[MAX_MFP]; |
| 56 | |
| 57 | static TIMER_CALLBACK( timer_a ); |
| 58 | static TIMER_CALLBACK( timer_b ); |
| 59 | static TIMER_CALLBACK( timer_c ); |
| 60 | static TIMER_CALLBACK( timer_d ); |
| 61 | |
| 62 | void mfp68901_irq_ack(int which) |
| 63 | { |
| 64 | mfp_68901 *mfp_p = &mfp[which]; |
| 65 | |
| 66 | UINT16 ipr = (mfp_p->ipra << 8) | mfp_p->iprb; |
| 67 | UINT16 isr = (mfp_p->isra << 8) | mfp_p->isrb; |
| 68 | UINT16 imr = (mfp_p->imra << 8) | mfp_p->imrb; |
| 69 | int ch; |
| 70 | |
| 71 | for (ch = 15; ch > 0; ch--) |
| 72 | { |
| 73 | if (BIT(isr, ch)) |
| 74 | { |
| 75 | break; |
| 76 | } |
| 77 | |
| 78 | if (BIT(ipr, ch) && BIT(imr, ch)) |
| 79 | { |
| 80 | ipr -= (1 << ch); |
| 81 | |
| 82 | mfp_p->ipra = (ipr & 0xff00) >> 8; |
| 83 | mfp_p->iprb = ipr & 0xff; |
| 84 | |
| 85 | if (mfp_p->vr & MFP68901_VR_S) |
| 86 | { |
| 87 | isr |= (1 << ch); |
| 88 | |
| 89 | mfp_p->isra = (isr & 0xff00) >> 8; |
| 90 | mfp_p->isrb = isr & 0xff; |
| 91 | } |
| 92 | |
| 93 | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | (15 - ch)); |
| 94 | return; |
| 95 | } |
| 96 | |
| 97 | ipr <<= 1; |
| 98 | isr <<= 1; |
| 99 | imr <<= 1; |
| 100 | } |
| 101 | |
| 102 | mfp_p->irq_callback(which, CLEAR_LINE, 0); |
| 103 | } |
| 104 | |
| 105 | static UINT8 mfp68901_register_r(int which, int reg) |
| 106 | { |
| 107 | mfp_68901 *mfp_p = &mfp[which]; |
| 108 | |
| 109 | switch (reg) |
| 110 | { |
| 111 | case MFP68901_REGISTER_GPIP: |
| 112 | { |
| 113 | UINT8 gpio = 0x80; |
| 114 | |
| 115 | if (mfp_p->gpio_r) |
| 116 | { |
| 117 | //gpio = (*mfp_p->gpio_r)(0); |
| 118 | } |
| 119 | |
| 120 | gpio |= (mfp_p->gpip & mfp_p->ddr); |
| 121 | |
| 122 | // signal interrupts if necessary |
| 123 | mfp68901_irq_ack(which); |
| 124 | return gpio; |
| 125 | } |
| 126 | case MFP68901_REGISTER_AER: return mfp_p->aer; |
| 127 | case MFP68901_REGISTER_DDR: return mfp_p->ddr; |
| 128 | |
| 129 | case MFP68901_REGISTER_IERA: return mfp_p->iera; |
| 130 | case MFP68901_REGISTER_IERB: return mfp_p->ierb; |
| 131 | case MFP68901_REGISTER_IPRA: return mfp_p->ipra; |
| 132 | case MFP68901_REGISTER_IPRB: return mfp_p->iprb; |
| 133 | case MFP68901_REGISTER_ISRA: return mfp_p->isra; |
| 134 | case MFP68901_REGISTER_ISRB: return mfp_p->isrb; |
| 135 | case MFP68901_REGISTER_IMRA: return mfp_p->imra; |
| 136 | case MFP68901_REGISTER_IMRB: return mfp_p->imrb; |
| 137 | case MFP68901_REGISTER_VR: return mfp_p->vr; |
| 138 | |
| 139 | case MFP68901_REGISTER_TACR: return mfp_p->tacr; |
| 140 | case MFP68901_REGISTER_TBCR: return mfp_p->tbcr; |
| 141 | case MFP68901_REGISTER_TCDCR: return mfp_p->tcdcr; |
| 142 | case MFP68901_REGISTER_TADR: |
| 143 | return mfp_p->tarr; |
| 144 | case MFP68901_REGISTER_TBDR: |
| 145 | return mfp_p->tbrr; |
| 146 | case MFP68901_REGISTER_TCDR: return mfp_p->tcrr; |
| 147 | case MFP68901_REGISTER_TDDR: return mfp_p->tdrr; |
| 148 | |
| 149 | case MFP68901_REGISTER_SCR: return mfp_p->scr; |
| 150 | case MFP68901_REGISTER_UCR: return mfp_p->ucr; |
| 151 | case MFP68901_REGISTER_RSR: return mfp_p->rsr; |
| 152 | case MFP68901_REGISTER_TSR: return mfp_p->tsr; |
| 153 | case MFP68901_REGISTER_UDR: return mfp_p->udr; |
| 154 | default: |
| 155 | return 0; |
| 156 | } |
| 157 | } |
| 158 | |
| 159 | static void mfp68901_register_w(int which, int reg, UINT8 data) |
| 160 | { |
| 161 | mfp_68901 *mfp_p = &mfp[which]; |
| 162 | |
| 163 | switch (reg) |
| 164 | { |
| 165 | case MFP68901_REGISTER_GPIP: |
| 166 | logerror("MFP68901 GPIP %x\n", data); |
| 167 | mfp_p->gpip = data & mfp_p->ddr; |
| 168 | |
| 169 | if (mfp_p->gpio_w) |
| 170 | { |
| 171 | mfp_p->gpio_w(0, mfp_p->gpip); |
| 172 | } |
| 173 | break; |
| 174 | case MFP68901_REGISTER_AER: |
| 175 | logerror("MFP68901 AER %x\n", data); |
| 176 | mfp_p->aer = data; |
| 177 | // check transition and trigger interrupt if necessary |
| 178 | mfp68901_irq_ack(which); |
| 179 | break; |
| 180 | case MFP68901_REGISTER_DDR: |
| 181 | logerror("MFP68901 DDR %x\n", data); |
| 182 | mfp_p->ddr = data; |
| 183 | break; |
| 184 | |
| 185 | case MFP68901_REGISTER_IERA: |
| 186 | logerror("MFP68901 IERA %x\n", data); |
| 187 | mfp_p->iera = data; |
| 188 | mfp_p->ipra &= mfp_p->iera; |
| 189 | mfp68901_irq_ack(which); |
| 190 | break; |
| 191 | case MFP68901_REGISTER_IERB: |
| 192 | logerror("MFP68901 IERB %x\n", data); |
| 193 | mfp_p->ierb = data; |
| 194 | mfp_p->iprb &= mfp_p->ierb; |
| 195 | mfp68901_irq_ack(which); |
| 196 | break; |
| 197 | case MFP68901_REGISTER_IPRA: |
| 198 | logerror("MFP68901 IPRA %x\n", data); |
| 199 | mfp_p->ipra &= data; |
| 200 | mfp68901_irq_ack(which); |
| 201 | break; |
| 202 | case MFP68901_REGISTER_IPRB: |
| 203 | logerror("MFP68901 IPRB %x\n", data); |
| 204 | mfp_p->iprb &= data; |
| 205 | mfp68901_irq_ack(which); |
| 206 | break; |
| 207 | case MFP68901_REGISTER_ISRA: |
| 208 | logerror("MFP68901 ISRA %x\n", data); |
| 209 | mfp_p->isra = data; |
| 210 | mfp68901_irq_ack(which); |
| 211 | break; |
| 212 | case MFP68901_REGISTER_ISRB: |
| 213 | logerror("MFP68901 ISRB %x\n", data); |
| 214 | mfp_p->isrb = data; |
| 215 | mfp68901_irq_ack(which); |
| 216 | break; |
| 217 | case MFP68901_REGISTER_IMRA: |
| 218 | logerror("MFP68901 IMRA %x\n", data); |
| 219 | mfp_p->imra = data; |
| 220 | mfp68901_irq_ack(which); |
| 221 | break; |
| 222 | case MFP68901_REGISTER_IMRB: |
| 223 | logerror("MFP68901 IMRB %x\n", data); |
| 224 | mfp_p->imrb = data; |
| 225 | mfp68901_irq_ack(which); |
| 226 | break; |
| 227 | case MFP68901_REGISTER_VR: |
| 228 | logerror("MFP68901 VR %x\n", data); |
| 229 | mfp_p->vr = data & 0xf8; |
| 230 | if ((mfp_p->vr & MFP68901_VR_S) == 0) |
| 231 | { |
| 232 | mfp_p->isra = mfp_p->isrb = 0; |
| 233 | mfp68901_irq_ack(which); |
| 234 | } |
| 235 | break; |
| 236 | |
| 237 | case MFP68901_REGISTER_TACR: |
| 238 | logerror("MFP68901 TACR %x\n", data); |
| 239 | mfp_p->tacr = data & 0x1f; |
| 240 | |
| 241 | switch (mfp_p->tacr & 0x0f) |
| 242 | { |
| 243 | case MFP68901_TCR_TIMER_DELAY_4: |
| 244 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4)); |
| 245 | break; |
| 246 | case MFP68901_TCR_TIMER_DELAY_10: |
| 247 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10)); |
| 248 | break; |
| 249 | case MFP68901_TCR_TIMER_DELAY_16: |
| 250 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16)); |
| 251 | break; |
| 252 | case MFP68901_TCR_TIMER_DELAY_50: |
| 253 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50)); |
| 254 | break; |
| 255 | case MFP68901_TCR_TIMER_DELAY_64: |
| 256 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64)); |
| 257 | break; |
| 258 | case MFP68901_TCR_TIMER_DELAY_100: |
| 259 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100)); |
| 260 | break; |
| 261 | case MFP68901_TCR_TIMER_DELAY_200: |
| 262 | mame_timer_adjust(mfp_p->timer_a, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200)); |
| 263 | break; |
| 264 | case MFP68901_TCR_TIMER_STOPPED: |
| 265 | case MFP68901_TCR_TIMER_EVENT: |
| 266 | case MFP68901_TCR_TIMER_PULSE_4: |
| 267 | case MFP68901_TCR_TIMER_PULSE_10: |
| 268 | case MFP68901_TCR_TIMER_PULSE_16: |
| 269 | case MFP68901_TCR_TIMER_PULSE_50: |
| 270 | case MFP68901_TCR_TIMER_PULSE_64: |
| 271 | case MFP68901_TCR_TIMER_PULSE_100: |
| 272 | case MFP68901_TCR_TIMER_PULSE_200: |
| 273 | mame_timer_enable(mfp_p->timer_a, 0); |
| 274 | break; |
| 275 | } |
| 276 | |
| 277 | if (mfp_p->tacr & MFP68901_TCR_TIMER_RESET) |
| 278 | { |
| 279 | mfp_p->tao = 0; |
| 280 | |
| 281 | if (mfp_p->tao_w) |
| 282 | { |
| 283 | mfp_p->tao_w(which, mfp_p->tao); |
| 284 | } |
| 285 | } |
| 286 | break; |
| 287 | case MFP68901_REGISTER_TBCR: |
| 288 | logerror("MFP68901 TBCR %x\n", data); |
| 289 | mfp_p->tbcr = data & 0x1f; |
| 290 | |
| 291 | switch (mfp_p->tbcr & 0x0f) |
| 292 | { |
| 293 | case MFP68901_TCR_TIMER_DELAY_4: |
| 294 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4)); |
| 295 | break; |
| 296 | case MFP68901_TCR_TIMER_DELAY_10: |
| 297 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10)); |
| 298 | break; |
| 299 | case MFP68901_TCR_TIMER_DELAY_16: |
| 300 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16)); |
| 301 | break; |
| 302 | case MFP68901_TCR_TIMER_DELAY_50: |
| 303 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50)); |
| 304 | break; |
| 305 | case MFP68901_TCR_TIMER_DELAY_64: |
| 306 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64)); |
| 307 | break; |
| 308 | case MFP68901_TCR_TIMER_DELAY_100: |
| 309 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100)); |
| 310 | break; |
| 311 | case MFP68901_TCR_TIMER_DELAY_200: |
| 312 | mame_timer_adjust(mfp_p->timer_b, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200)); |
| 313 | break; |
| 314 | case MFP68901_TCR_TIMER_STOPPED: |
| 315 | case MFP68901_TCR_TIMER_EVENT: |
| 316 | case MFP68901_TCR_TIMER_PULSE_4: |
| 317 | case MFP68901_TCR_TIMER_PULSE_10: |
| 318 | case MFP68901_TCR_TIMER_PULSE_16: |
| 319 | case MFP68901_TCR_TIMER_PULSE_50: |
| 320 | case MFP68901_TCR_TIMER_PULSE_64: |
| 321 | case MFP68901_TCR_TIMER_PULSE_100: |
| 322 | case MFP68901_TCR_TIMER_PULSE_200: |
| 323 | mame_timer_enable(mfp_p->timer_b, 0); |
| 324 | break; |
| 325 | } |
| 326 | |
| 327 | if (mfp_p->tbcr & MFP68901_TCR_TIMER_RESET) |
| 328 | { |
| 329 | mfp_p->tbo = 0; |
| 330 | |
| 331 | if (mfp_p->tbo_w) |
| 332 | { |
| 333 | mfp_p->tbo_w(which, mfp_p->tbo); |
| 334 | } |
| 335 | } |
| 336 | break; |
| 337 | case MFP68901_REGISTER_TCDCR: |
| 338 | logerror("MFP68901 TCDCR %x\n", data); |
| 339 | mfp_p->tcdcr = data & 0x6f; |
| 340 | |
| 341 | switch (mfp_p->tcdcr & 0x07) |
| 342 | { |
| 343 | case MFP68901_TCR_TIMER_DELAY_4: |
| 344 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4)); |
| 345 | break; |
| 346 | case MFP68901_TCR_TIMER_DELAY_10: |
| 347 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10)); |
| 348 | break; |
| 349 | case MFP68901_TCR_TIMER_DELAY_16: |
| 350 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16)); |
| 351 | break; |
| 352 | case MFP68901_TCR_TIMER_DELAY_50: |
| 353 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50)); |
| 354 | break; |
| 355 | case MFP68901_TCR_TIMER_DELAY_64: |
| 356 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64)); |
| 357 | break; |
| 358 | case MFP68901_TCR_TIMER_DELAY_100: |
| 359 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100)); |
| 360 | break; |
| 361 | case MFP68901_TCR_TIMER_DELAY_200: |
| 362 | mame_timer_adjust(mfp_p->timer_d, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200)); |
| 363 | break; |
| 364 | case MFP68901_TCR_TIMER_STOPPED: |
| 365 | mame_timer_enable(mfp_p->timer_d, 0); |
| 366 | break; |
| 367 | } |
| 368 | |
| 369 | switch ((mfp_p->tcdcr >> 4) & 0x07) |
| 370 | { |
| 371 | case MFP68901_TCR_TIMER_DELAY_4: |
| 372 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 4)); |
| 373 | break; |
| 374 | case MFP68901_TCR_TIMER_DELAY_10: |
| 375 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 10)); |
| 376 | break; |
| 377 | case MFP68901_TCR_TIMER_DELAY_16: |
| 378 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 16)); |
| 379 | break; |
| 380 | case MFP68901_TCR_TIMER_DELAY_50: |
| 381 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 50)); |
| 382 | break; |
| 383 | case MFP68901_TCR_TIMER_DELAY_64: |
| 384 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 64)); |
| 385 | break; |
| 386 | case MFP68901_TCR_TIMER_DELAY_100: |
| 387 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 100)); |
| 388 | break; |
| 389 | case MFP68901_TCR_TIMER_DELAY_200: |
| 390 | mame_timer_adjust(mfp_p->timer_c, time_never, 0, MAME_TIME_IN_HZ(mfp_p->timer_clock / 200)); |
| 391 | break; |
| 392 | case MFP68901_TCR_TIMER_STOPPED: |
| 393 | mame_timer_enable(mfp_p->timer_c, 0); |
| 394 | break; |
| 395 | } |
| 396 | break; |
| 397 | case MFP68901_REGISTER_TADR: |
| 398 | logerror("MFP68901 TADR %x\n", data); |
| 399 | mfp_p->tadr = data; |
| 400 | |
| 401 | if (!mame_timer_enabled(mfp_p->timer_a)) |
| 402 | { |
| 403 | mfp_p->tarr = data; |
| 404 | } |
| 405 | break; |
| 406 | case MFP68901_REGISTER_TBDR: |
| 407 | logerror("MFP68901 TBDR %x\n", data); |
| 408 | mfp_p->tbdr = data; |
| 409 | |
| 410 | if (!mame_timer_enabled(mfp_p->timer_b)) |
| 411 | { |
| 412 | mfp_p->tbrr = data; |
| 413 | } |
| 414 | break; |
| 415 | case MFP68901_REGISTER_TCDR: |
| 416 | logerror("MFP68901 TCDR %x\n", data); |
| 417 | mfp_p->tcdr = data; |
| 418 | |
| 419 | if (!mame_timer_enabled(mfp_p->timer_c)) |
| 420 | { |
| 421 | mfp_p->tcrr = data; |
| 422 | } |
| 423 | break; |
| 424 | case MFP68901_REGISTER_TDDR: |
| 425 | logerror("MFP68901 TDDR %x\n", data); |
| 426 | mfp_p->tddr = data; |
| 427 | |
| 428 | if (!mame_timer_enabled(mfp_p->timer_d)) |
| 429 | { |
| 430 | mfp_p->tdrr = data; |
| 431 | } |
| 432 | break; |
| 433 | |
| 434 | // USART not implemented |
| 435 | case MFP68901_REGISTER_SCR: |
| 436 | logerror("MFP68901 SCR %x\n", data); |
| 437 | mfp_p->scr = data; |
| 438 | break; |
| 439 | case MFP68901_REGISTER_UCR: |
| 440 | logerror("MFP68901 UCR %x\n", data); |
| 441 | mfp_p->ucr = data; |
| 442 | break; |
| 443 | case MFP68901_REGISTER_RSR: |
| 444 | logerror("MFP68901 RSR %x\n", data); |
| 445 | mfp_p->rsr = data; |
| 446 | break; |
| 447 | case MFP68901_REGISTER_TSR: |
| 448 | logerror("MFP68901 TSR %x\n", data); |
| 449 | mfp_p->tsr = data; |
| 450 | break; |
| 451 | case MFP68901_REGISTER_UDR: |
| 452 | logerror("MFP68901 UDR %x\n", data); |
| 453 | mfp_p->udr = data; |
| 454 | break; |
| 455 | } |
| 456 | } |
| 457 | |
| 458 | void mfp68901_config(int which, const struct mfp68901_interface *intf) |
| 459 | { |
| 460 | mfp_68901 *mfp_p = &mfp[which]; |
| 461 | |
| 462 | if (which >= MAX_MFP) |
| 463 | { |
| 464 | return; |
| 465 | } |
| 466 | |
| 467 | memset(mfp_p, 0, sizeof(mfp)); |
| 468 | |
| 469 | mfp_p->chip_clock = intf->chip_clock; |
| 470 | mfp_p->timer_clock = intf->timer_clock; |
| 471 | mfp_p->irq_callback = intf->irq_callback; |
| 472 | mfp_p->gpio_r = intf->gpio_r; |
| 473 | mfp_p->gpio_w = intf->gpio_w; |
| 474 | |
| 475 | mfp_p->timer_a = mame_timer_alloc(timer_a); |
| 476 | mfp_p->timer_b = mame_timer_alloc(timer_b); |
| 477 | mfp_p->timer_c = mame_timer_alloc(timer_c); |
| 478 | mfp_p->timer_d = mame_timer_alloc(timer_d); |
| 479 | |
| 480 | mame_timer_reset(mfp_p->timer_a, time_never); |
| 481 | mame_timer_reset(mfp_p->timer_b, time_never); |
| 482 | mame_timer_reset(mfp_p->timer_c, time_never); |
| 483 | mame_timer_reset(mfp_p->timer_d, time_never); |
| 484 | |
| 485 | state_save_register_item("mfp68901", which, mfp_p->gpip); |
| 486 | state_save_register_item("mfp68901", which, mfp_p->aer); |
| 487 | state_save_register_item("mfp68901", which, mfp_p->ddr); |
| 488 | state_save_register_item("mfp68901", which, mfp_p->iera); |
| 489 | state_save_register_item("mfp68901", which, mfp_p->ierb); |
| 490 | state_save_register_item("mfp68901", which, mfp_p->ipra); |
| 491 | state_save_register_item("mfp68901", which, mfp_p->iprb); |
| 492 | state_save_register_item("mfp68901", which, mfp_p->isra); |
| 493 | state_save_register_item("mfp68901", which, mfp_p->isrb); |
| 494 | state_save_register_item("mfp68901", which, mfp_p->imra); |
| 495 | state_save_register_item("mfp68901", which, mfp_p->imrb); |
| 496 | state_save_register_item("mfp68901", which, mfp_p->vr); |
| 497 | state_save_register_item("mfp68901", which, mfp_p->tacr); |
| 498 | state_save_register_item("mfp68901", which, mfp_p->tbcr); |
| 499 | state_save_register_item("mfp68901", which, mfp_p->tcdcr); |
| 500 | state_save_register_item("mfp68901", which, mfp_p->tadr); |
| 501 | state_save_register_item("mfp68901", which, mfp_p->tbdr); |
| 502 | state_save_register_item("mfp68901", which, mfp_p->tcdr); |
| 503 | state_save_register_item("mfp68901", which, mfp_p->tddr); |
| 504 | state_save_register_item("mfp68901", which, mfp_p->tarr); |
| 505 | state_save_register_item("mfp68901", which, mfp_p->tbrr); |
| 506 | state_save_register_item("mfp68901", which, mfp_p->tcrr); |
| 507 | state_save_register_item("mfp68901", which, mfp_p->tdrr); |
| 508 | state_save_register_item("mfp68901", which, mfp_p->tao); |
| 509 | state_save_register_item("mfp68901", which, mfp_p->tbo); |
| 510 | state_save_register_item("mfp68901", which, mfp_p->tco); |
| 511 | state_save_register_item("mfp68901", which, mfp_p->tdo); |
| 512 | state_save_register_item("mfp68901", which, mfp_p->tai); |
| 513 | state_save_register_item("mfp68901", which, mfp_p->tbi); |
| 514 | state_save_register_item("mfp68901", which, mfp_p->scr); |
| 515 | state_save_register_item("mfp68901", which, mfp_p->ucr); |
| 516 | state_save_register_item("mfp68901", which, mfp_p->rsr); |
| 517 | state_save_register_item("mfp68901", which, mfp_p->tsr); |
| 518 | state_save_register_item("mfp68901", which, mfp_p->udr); |
| 519 | state_save_register_item("mfp68901", which, mfp_p->chip_clock); |
| 520 | state_save_register_item("mfp68901", which, mfp_p->timer_clock); |
| 521 | } |
| 522 | |
| 523 | void mfp68901_timer_count_a(int which) |
| 524 | { |
| 525 | mfp_68901 *mfp_p = &mfp[which]; |
| 526 | |
| 527 | if (mfp_p->tarr == 0x01) |
| 528 | { |
| 529 | if (mfp_p->iera & 0x20) |
| 530 | { |
| 531 | mfp_p->ipra |= 0x20; |
| 532 | |
| 533 | if (mfp_p->imra & 0x20) |
| 534 | { |
| 535 | //mfp68901_irq_ack(which); |
| 536 | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_A); |
| 537 | |
| 538 | if (mfp_p->tao) |
| 539 | { |
| 540 | mfp_p->tao = 0; |
| 541 | } |
| 542 | else |
| 543 | { |
| 544 | mfp_p->tao = 1; |
| 545 | } |
| 546 | |
| 547 | if (mfp_p->tao_w) |
| 548 | { |
| 549 | mfp_p->tao_w(which, mfp_p->tao); |
| 550 | } |
| 551 | } |
| 552 | } |
| 553 | |
| 554 | mfp_p->tarr = mfp_p->tadr; |
| 555 | } |
| 556 | else |
| 557 | { |
| 558 | mfp_p->tarr--; |
| 559 | } |
| 560 | } |
| 561 | |
| 562 | void mfp68901_timer_count_b(int which) |
| 563 | { |
| 564 | mfp_68901 *mfp_p = &mfp[which]; |
| 565 | |
| 566 | if (mfp_p->tbrr == 0x01) |
| 567 | { |
| 568 | if (mfp_p->iera & 0x01) |
| 569 | { |
| 570 | mfp_p->ipra |= 0x01; |
| 571 | |
| 572 | if (mfp_p->imra & 0x01) |
| 573 | { |
| 574 | //mfp68901_irq_ack(which); |
| 575 | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_B); |
| 576 | |
| 577 | if (mfp_p->tbo) |
| 578 | { |
| 579 | mfp_p->tbo = 0; |
| 580 | } |
| 581 | else |
| 582 | { |
| 583 | mfp_p->tbo = 1; |
| 584 | } |
| 585 | |
| 586 | if (mfp_p->tbo_w) |
| 587 | { |
| 588 | mfp_p->tbo_w(which, mfp_p->tbo); |
| 589 | } |
| 590 | } |
| 591 | } |
| 592 | |
| 593 | mfp_p->tbrr = mfp_p->tbdr; |
| 594 | } |
| 595 | else |
| 596 | { |
| 597 | mfp_p->tbrr--; |
| 598 | } |
| 599 | } |
| 600 | |
| 601 | void mfp68901_timer_count_c(int which) |
| 602 | { |
| 603 | mfp_68901 *mfp_p = &mfp[which]; |
| 604 | |
| 605 | if (mfp_p->tcrr == 0x01) |
| 606 | { |
| 607 | if (mfp_p->ierb & 0x20) |
| 608 | { |
| 609 | mfp_p->iprb |= 0x20; |
| 610 | |
| 611 | if (mfp_p->imrb & 0x20) |
| 612 | { |
| 613 | //mfp68901_irq_ack(which); |
| 614 | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_C); |
| 615 | |
| 616 | if (mfp_p->tco) |
| 617 | { |
| 618 | mfp_p->tco = 0; |
| 619 | } |
| 620 | else |
| 621 | { |
| 622 | mfp_p->tco = 1; |
| 623 | } |
| 624 | |
| 625 | if (mfp_p->tco_w) |
| 626 | { |
| 627 | mfp_p->tco_w(which, mfp_p->tco); |
| 628 | } |
| 629 | } |
| 630 | } |
| 631 | |
| 632 | mfp_p->tcrr = mfp_p->tcdr; |
| 633 | } |
| 634 | else |
| 635 | { |
| 636 | mfp_p->tcrr--; |
| 637 | } |
| 638 | } |
| 639 | |
| 640 | void mfp68901_timer_count_d(int which) |
| 641 | { |
| 642 | mfp_68901 *mfp_p = &mfp[which]; |
| 643 | |
| 644 | if (mfp_p->tdrr == 0x01) |
| 645 | { |
| 646 | if (mfp_p->ierb & 0x01) |
| 647 | { |
| 648 | mfp_p->iprb |= 0x01; |
| 649 | |
| 650 | if (mfp_p->imrb & 0x01) |
| 651 | { |
| 652 | //mfp68901_irq_ack(which); |
| 653 | mfp_p->irq_callback(which, ASSERT_LINE, (mfp_p->vr & 0xf0) | MFP68901_INT_TIMER_D); |
| 654 | |
| 655 | if (mfp_p->tdo) |
| 656 | { |
| 657 | mfp_p->tdo = 0; |
| 658 | } |
| 659 | else |
| 660 | { |
| 661 | mfp_p->tdo = 1; |
| 662 | } |
| 663 | |
| 664 | if (mfp_p->tdo_w) |
| 665 | { |
| 666 | mfp_p->tdo_w(which, mfp_p->tdo); |
| 667 | } |
| 668 | } |
| 669 | } |
| 670 | |
| 671 | mfp_p->tdrr = mfp_p->tddr; |
| 672 | } |
| 673 | else |
| 674 | { |
| 675 | mfp_p->tdrr--; |
| 676 | } |
| 677 | } |
| 678 | |
| 679 | void mfp68901_tai_w(int which, int value) |
| 680 | { |
| 681 | mfp_68901 *mfp_p = &mfp[which]; |
| 682 | |
| 683 | switch (mfp_p->tacr & 0x0f) |
| 684 | { |
| 685 | case MFP68901_TCR_TIMER_DELAY_4: |
| 686 | case MFP68901_TCR_TIMER_DELAY_10: |
| 687 | case MFP68901_TCR_TIMER_DELAY_16: |
| 688 | case MFP68901_TCR_TIMER_DELAY_50: |
| 689 | case MFP68901_TCR_TIMER_DELAY_64: |
| 690 | case MFP68901_TCR_TIMER_DELAY_100: |
| 691 | case MFP68901_TCR_TIMER_DELAY_200: |
| 692 | case MFP68901_TCR_TIMER_STOPPED: |
| 693 | return; |
| 694 | |
| 695 | case MFP68901_TCR_TIMER_EVENT: |
| 696 | if (mfp_p->aer & MFP68901_AER_GPIP_4) |
| 697 | { |
| 698 | // count down on 0->1 transition |
| 699 | if (mfp_p->tai == 0 && value == 1) |
| 700 | { |
| 701 | mfp68901_timer_count_a(which); |
| 702 | } |
| 703 | } |
| 704 | else |
| 705 | { |
| 706 | // count down on 1->0 transition |
| 707 | if (mfp_p->tai == 1 && value == 0) |
| 708 | { |
| 709 | mfp68901_timer_count_a(which); |
| 710 | } |
| 711 | } |
| 712 | |
| 713 | mfp_p->tai = value; |
| 714 | break; |
| 715 | |
| 716 | case MFP68901_TCR_TIMER_PULSE_4: |
| 717 | case MFP68901_TCR_TIMER_PULSE_10: |
| 718 | case MFP68901_TCR_TIMER_PULSE_16: |
| 719 | case MFP68901_TCR_TIMER_PULSE_50: |
| 720 | case MFP68901_TCR_TIMER_PULSE_64: |
| 721 | case MFP68901_TCR_TIMER_PULSE_100: |
| 722 | case MFP68901_TCR_TIMER_PULSE_200: |
| 723 | break; |
| 724 | } |
| 725 | |
| 726 | mfp68901_irq_ack(which); |
| 727 | } |
| 728 | |
| 729 | void mfp68901_tbi_w(int which, int value) |
| 730 | { |
| 731 | mfp_68901 *mfp_p = &mfp[which]; |
| 732 | |
| 733 | switch (mfp_p->tbcr & 0x0f) |
| 734 | { |
| 735 | case MFP68901_TCR_TIMER_DELAY_4: |
| 736 | case MFP68901_TCR_TIMER_DELAY_10: |
| 737 | case MFP68901_TCR_TIMER_DELAY_16: |
| 738 | case MFP68901_TCR_TIMER_DELAY_50: |
| 739 | case MFP68901_TCR_TIMER_DELAY_64: |
| 740 | case MFP68901_TCR_TIMER_DELAY_100: |
| 741 | case MFP68901_TCR_TIMER_DELAY_200: |
| 742 | case MFP68901_TCR_TIMER_STOPPED: |
| 743 | return; |
| 744 | |
| 745 | case MFP68901_TCR_TIMER_EVENT: |
| 746 | if (mfp_p->aer & MFP68901_AER_GPIP_3) |
| 747 | { |
| 748 | // count down on 0->1 transition |
| 749 | if (mfp_p->tbi == 0 && value == 1) |
| 750 | { |
| 751 | mfp68901_timer_count_b(which); |
| 752 | } |
| 753 | } |
| 754 | else |
| 755 | { |
| 756 | // count down on 1->0 transition |
| 757 | if (mfp_p->tbi == 1 && value == 0) |
| 758 | { |
| 759 | mfp68901_timer_count_b(which); |
| 760 | } |
| 761 | } |
| 762 | |
| 763 | mfp_p->tbi = value; |
| 764 | break; |
| 765 | |
| 766 | case MFP68901_TCR_TIMER_PULSE_4: |
| 767 | case MFP68901_TCR_TIMER_PULSE_10: |
| 768 | case MFP68901_TCR_TIMER_PULSE_16: |
| 769 | case MFP68901_TCR_TIMER_PULSE_50: |
| 770 | case MFP68901_TCR_TIMER_PULSE_64: |
| 771 | case MFP68901_TCR_TIMER_PULSE_100: |
| 772 | case MFP68901_TCR_TIMER_PULSE_200: |
| 773 | break; |
| 774 | } |
| 775 | |
| 776 | mfp68901_irq_ack(which); |
| 777 | } |
| 778 | |
| 779 | static TIMER_CALLBACK( timer_a ) |
| 780 | { |
| 781 | int which = param; |
| 782 | |
| 783 | mfp68901_timer_count_a(which); |
| 784 | } |
| 785 | |
| 786 | static TIMER_CALLBACK( timer_b ) |
| 787 | { |
| 788 | int which = param; |
| 789 | |
| 790 | mfp68901_timer_count_b(which); |
| 791 | } |
| 792 | |
| 793 | static TIMER_CALLBACK( timer_c ) |
| 794 | { |
| 795 | int which = param; |
| 796 | |
| 797 | mfp68901_timer_count_c(which); |
| 798 | } |
| 799 | |
| 800 | static TIMER_CALLBACK( timer_d ) |
| 801 | { |
| 802 | int which = param; |
| 803 | |
| 804 | mfp68901_timer_count_d(which); |
| 805 | } |
| 806 | |
| 807 | READ16_HANDLER( mfp68901_0_register16_r ) { return mfp68901_register_r(0, offset); } |
| 808 | READ16_HANDLER( mfp68901_1_register16_r ) { return mfp68901_register_r(1, offset); } |
| 809 | READ16_HANDLER( mfp68901_2_register16_r ) { return mfp68901_register_r(2, offset); } |
| 810 | READ16_HANDLER( mfp68901_3_register16_r ) { return mfp68901_register_r(3, offset); } |
| 811 | |
| 812 | WRITE16_HANDLER( mfp68901_0_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); } |
| 813 | WRITE16_HANDLER( mfp68901_1_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); } |
| 814 | WRITE16_HANDLER( mfp68901_2_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); } |
| 815 | WRITE16_HANDLER( mfp68901_3_register_msb_w ) { if (ACCESSING_MSB) mfp68901_register_w(0, offset, (data >> 8) & 0xff); } |
| 816 | |
| 817 | WRITE16_HANDLER( mfp68901_0_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); } |
| 818 | WRITE16_HANDLER( mfp68901_1_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); } |
| 819 | WRITE16_HANDLER( mfp68901_2_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); } |
| 820 | WRITE16_HANDLER( mfp68901_3_register_lsb_w ) { if (ACCESSING_LSB) mfp68901_register_w(0, offset, data & 0xff); } |
src/mess/machine/68901mfp.h
| r811 | r812 | |
| 1 | | #ifndef MFP68901_H
|
| 2 | | #define MFP68901_H
|
| 3 | | |
| 4 | | #define MAX_MFP 4
|
| 5 | | |
| 6 | | #include "driver.h"
|
| 7 | | #include "timer.h"
|
| 8 | | |
| 9 | | struct mfp68901_interface
|
| 10 | | {
|
| 11 | | int chip_clock;
|
| 12 | | int timer_clock;
|
| 13 | | |
| 14 | | void (*tao_w)(int which, int value);
|
| 15 | | void (*tbo_w)(int which, int value);
|
| 16 | | void (*tco_w)(int which, int value);
|
| 17 | | void (*tdo_w)(int which, int value);
|
| 18 | | |
| 19 | | void (*irq_callback)(int which, int state, int vector);
|
| 20 | | |
| 21 | | read8_handler gpio_r;
|
| 22 | | write8_handler gpio_w;
|
| 23 | | };
|
| 24 | | |
| 25 | | enum
|
| 26 | | {
|
| 27 | | MFP68901_REGISTER_GPIP = 0,
|
| 28 | | MFP68901_REGISTER_AER,
|
| 29 | | MFP68901_REGISTER_DDR,
|
| 30 | | MFP68901_REGISTER_IERA,
|
| 31 | | MFP68901_REGISTER_IERB,
|
| 32 | | MFP68901_REGISTER_IPRA,
|
| 33 | | MFP68901_REGISTER_IPRB,
|
| 34 | | MFP68901_REGISTER_ISRA,
|
| 35 | | MFP68901_REGISTER_ISRB,
|
| 36 | | MFP68901_REGISTER_IMRA,
|
| 37 | | MFP68901_REGISTER_IMRB,
|
| 38 | | MFP68901_REGISTER_VR,
|
| 39 | | MFP68901_REGISTER_TACR,
|
| 40 | | MFP68901_REGISTER_TBCR,
|
| 41 | | MFP68901_REGISTER_TCDCR,
|
| 42 | | MFP68901_REGISTER_TADR,
|
| 43 | | MFP68901_REGISTER_TBDR,
|
| 44 | | MFP68901_REGISTER_TCDR,
|
| 45 | | MFP68901_REGISTER_TDDR,
|
| 46 | | MFP68901_REGISTER_SCR,
|
| 47 | | MFP68901_REGISTER_UCR,
|
| 48 | | MFP68901_REGISTER_RSR,
|
| 49 | | MFP68901_REGISTER_TSR,
|
| 50 | | MFP68901_REGISTER_UDR
|
| 51 | | };
|
| 52 | | |
| 53 | | enum
|
| 54 | | {
|
| 55 | | MFP68901_INT_GPI0 = 0,
|
| 56 | | MFP68901_INT_GPI1,
|
| 57 | | MFP68901_INT_GPI2,
|
| 58 | | MFP68901_INT_GPI3,
|
| 59 | | MFP68901_INT_TIMER_D,
|
| 60 | | MFP68901_INT_TIMER_C,
|
| 61 | | MFP68901_INT_GPI4,
|
| 62 | | MFP68901_INT_GPI5,
|
| 63 | | MFP68901_INT_TIMER_B,
|
| 64 | | MFP68901_INT_XMIT_ERROR,
|
| 65 | | MFP68901_INT_XMIT_BUFFER_EMPTY,
|
| 66 | | MFP68901_INT_RCV_ERROR,
|
| 67 | | MFP68901_INT_RCV_BUFFER_FULL,
|
| 68 | | MFP68901_INT_TIMER_A,
|
| 69 | | MFP68901_INT_GPI6,
|
| 70 | | MFP68901_INT_GPI7
|
| 71 | | };
|
| 72 | | |
| 73 | | #define MFP68901_AER_GPIP_0 0x01
|
| 74 | | #define MFP68901_AER_GPIP_1 0x02
|
| 75 | | #define MFP68901_AER_GPIP_2 0x04
|
| 76 | | #define MFP68901_AER_GPIP_3 0x08
|
| 77 | | #define MFP68901_AER_GPIP_4 0x10
|
| 78 | | #define MFP68901_AER_GPIP_5 0x20
|
| 79 | | #define MFP68901_AER_GPIP_6 0x40
|
| 80 | | #define MFP68901_AER_GPIP_7 0x80
|
| 81 | | |
| 82 | | #define MFP68901_VR_S 0x08
|
| 83 | | |
| 84 | | #define MFP68901_IPRB_GPIP_0 0x01
|
| 85 | | #define MFP68901_IPRB_GPIP_1 0x02
|
| 86 | | #define MFP68901_IPRB_GPIP_2 0x04
|
| 87 | | #define MFP68901_IPRB_GPIP_3 0x08
|
| 88 | | #define MFP68901_IPRB_TIMER_D 0x10
|
| 89 | | #define MFP68901_IPRB_TIMER_C 0x20
|
| 90 | | #define MFP68901_IPRB_GPIP_4 0x40
|
| 91 | | #define MFP68901_IPRB_GPIP_5 0x80
|
| 92 | | |
| 93 | | #define MFP68901_IPRA_TIMER_B 0x01
|
| 94 | | #define MFP68901_IPRA_XMIT_ERROR 0x02
|
| 95 | | #define MFP68901_IPRA_XMIT_BUFFER_EMPTY 0x04
|
| 96 | | #define MFP68901_IPRA_RCV_ERROR 0x08
|
| 97 | | #define MFP68901_IPRA_RCV_BUFFER_FULL 0x10
|
| 98 | | #define MFP68901_IPRA_TIMER_A 0x20
|
| 99 | | #define MFP68901_IPRA_GPIP_6 0x40
|
| 100 | | #define MFP68901_IPRA_GPIP_7 0x80
|
| 101 | | |
| 102 | | #define MFP68901_TCR_TIMER_STOPPED 0x00
|
| 103 | | #define MFP68901_TCR_TIMER_DELAY_4 0x01
|
| 104 | | #define MFP68901_TCR_TIMER_DELAY_10 0x02
|
| 105 | | #define MFP68901_TCR_TIMER_DELAY_16 0x03
|
| 106 | | #define MFP68901_TCR_TIMER_DELAY_50 0x04
|
| 107 | | #define MFP68901_TCR_TIMER_DELAY_64 0x05
|
| 108 | | #define MFP68901_TCR_TIMER_DELAY_100 0x06
|
| 109 | | #define MFP68901_TCR_TIMER_DELAY_200 0x07
|
| 110 | | #define MFP68901_TCR_TIMER_EVENT 0x08
|
| 111 | | #define MFP68901_TCR_TIMER_PULSE_4 0x09
|
| 112 | | #define MFP68901_TCR_TIMER_PULSE_10 0x0a
|
| 113 | | #define MFP68901_TCR_TIMER_PULSE_16 0x0b
|
| 114 | | #define MFP68901_TCR_TIMER_PULSE_50 0x0c
|
| 115 | | #define MFP68901_TCR_TIMER_PULSE_64 0x0d
|
| 116 | | #define MFP68901_TCR_TIMER_PULSE_100 0x0e
|
| 117 | | #define MFP68901_TCR_TIMER_PULSE_200 0x0f
|
| 118 | | #define MFP68901_TCR_TIMER_RESET 0x10
|
| 119 | | |
| 120 | | #define MFP68901_UCR_PARITY_ENABLED 0x04
|
| 121 | | #define MFP68901_UCR_PARITY_EVEN 0x02
|
| 122 | | #define MFP68901_UCR_PARITY_ODD 0x00
|
| 123 | | #define MFP68901_UCR_WORD_LENGTH_8 0x00
|
| 124 | | #define MFP68901_UCR_WORD_LENGTH_7 0x20
|
| 125 | | #define MFP68901_UCR_WORD_LENGTH_6 0x40
|
| 126 | | #define MFP68901_UCR_WORD_LENGTH_5 0x60
|
| 127 | | #define MFP68901_UCR_START_STOP_0_0 0x00
|
| 128 | | #define MFP68901_UCR_START_STOP_1_1 0x08
|
| 129 | | #define MFP68901_UCR_START_STOP_1_15 0x10
|
| 130 | | #define MFP68901_UCR_START_STOP_1_2 0x18
|
| 131 | | #define MFP68901_UCR_CLOCK_DIVIDE_16 0x80
|
| 132 | | #define MFP68901_UCR_CLOCK_DIVIDE_1 0x00
|
| 133 | | |
| 134 | | #define MFP68901_RSR_RCV_ENABLE 0x01
|
| 135 | | #define MFP68901_RSR_SYNC_STRIP_ENABLE 0x02
|
| 136 | | #define MFP68901_RSR_MCIP 0x04
|
| 137 | | #define MFP68901_RSR_FOUND_SEARCH 0x08
|
| 138 | | #define MFP68901_RSR_FRAME_ERROR 0x10
|
| 139 | | #define MFP68901_RSR_PARITY_ERROR 0x20
|
| 140 | | #define MFP68901_RSR_OVERRUN_ERROR 0x40
|
| 141 | | #define MFP68901_RSR_BUFFER_FULL 0x80
|
| 142 | | |
| 143 | | #define MFP68901_TSR_XMIT_ENABLE 0x01
|
| 144 | | #define MFP68901_TSR_LOW 0x02
|
| 145 | | #define MFP68901_TSR_HIGH 0x04
|
| 146 | | #define MFP68901_TSR_BREAK 0x08
|
| 147 | | #define MFP68901_TSR_END_OF_XMIT 0x10
|
| 148 | | #define MFP68901_TSR_AUTO_TURNAROUND 0x20
|
| 149 | | #define MFP68901_TSR_UNDERRUN_ERROR 0x40
|
| 150 | | #define MFP68901_TSR_BUFFER_EMPTY 0x80
|
| 151 | | |
| 152 | | void mfp68901_config(int which, const struct mfp68901_interface *intf);
|
| 153 | | |
| 154 | | void mfp68901_tai_w(int which, int value);
|
| 155 | | void mfp68901_tbi_w(int which, int value);
|
| 156 | | |
| 157 | | READ16_HANDLER( mfp68901_0_register16_r );
|
| 158 | | READ16_HANDLER( mfp68901_1_register16_r );
|
| 159 | | READ16_HANDLER( mfp68901_2_register16_r );
|
| 160 | | READ16_HANDLER( mfp68901_3_register16_r );
|
| 161 | | |
| 162 | | WRITE16_HANDLER( mfp68901_0_register_msb_w );
|
| 163 | | WRITE16_HANDLER( mfp68901_1_register_msb_w );
|
| 164 | | WRITE16_HANDLER( mfp68901_2_register_msb_w );
|
| 165 | | WRITE16_HANDLER( mfp68901_3_register_msb_w );
|
| 166 | | |
| 167 | | WRITE16_HANDLER( mfp68901_0_register_lsb_w );
|
| 168 | | WRITE16_HANDLER( mfp68901_1_register_lsb_w );
|
| 169 | | WRITE16_HANDLER( mfp68901_2_register_lsb_w );
|
| 170 | | WRITE16_HANDLER( mfp68901_3_register_lsb_w );
|
| 171 | | |
| 172 | | #endif
|
| 1 | #ifndef MFP68901_H |
| 2 | #define MFP68901_H |
| 3 | |
| 4 | #define MAX_MFP 4 |
| 5 | |
| 6 | #include "driver.h" |
| 7 | #include "timer.h" |
| 8 | |
| 9 | struct mfp68901_interface |
| 10 | { |
| 11 | int chip_clock; |
| 12 | int timer_clock; |
| 13 | |
| 14 | void (*tao_w)(int which, int value); |
| 15 | void (*tbo_w)(int which, int value); |
| 16 | void (*tco_w)(int which, int value); |
| 17 | void (*tdo_w)(int which, int value); |
| 18 | |
| 19 | void (*irq_callback)(int which, int state, int vector); |
| 20 | |
| 21 | read8_handler gpio_r; |
| 22 | write8_handler gpio_w; |
| 23 | }; |
| 24 | |
| 25 | enum |
| 26 | { |
| 27 | MFP68901_REGISTER_GPIP = 0, |
| 28 | MFP68901_REGISTER_AER, |
| 29 | MFP68901_REGISTER_DDR, |
| 30 | MFP68901_REGISTER_IERA, |
| 31 | MFP68901_REGISTER_IERB, |
| 32 | MFP68901_REGISTER_IPRA, |
| 33 | MFP68901_REGISTER_IPRB, |
| 34 | MFP68901_REGISTER_ISRA, |
| 35 | MFP68901_REGISTER_ISRB, |
| 36 | MFP68901_REGISTER_IMRA, |
| 37 | MFP68901_REGISTER_IMRB, |
| 38 | MFP68901_REGISTER_VR, |
| 39 | MFP68901_REGISTER_TACR, |
| 40 | MFP68901_REGISTER_TBCR, |
| 41 | MFP68901_REGISTER_TCDCR, |
| 42 | MFP68901_REGISTER_TADR, |
| 43 | MFP68901_REGISTER_TBDR, |
| 44 | MFP68901_REGISTER_TCDR, |
| 45 | MFP68901_REGISTER_TDDR, |
| 46 | MFP68901_REGISTER_SCR, |
| 47 | MFP68901_REGISTER_UCR, |
| 48 | MFP68901_REGISTER_RSR, |
| 49 | MFP68901_REGISTER_TSR, |
| 50 | MFP68901_REGISTER_UDR |
| 51 | }; |
| 52 | |
| 53 | enum |
| 54 | { |
| 55 | MFP68901_INT_GPI0 = 0, |
| 56 | MFP68901_INT_GPI1, |
| 57 | MFP68901_INT_GPI2, |
| 58 | MFP68901_INT_GPI3, |
| 59 | MFP68901_INT_TIMER_D, |
| 60 | MFP68901_INT_TIMER_C, |
| 61 | MFP68901_INT_GPI4, |
| 62 | MFP68901_INT_GPI5, |
| 63 | MFP68901_INT_TIMER_B, |
| 64 | MFP68901_INT_XMIT_ERROR, |
| 65 | MFP68901_INT_XMIT_BUFFER_EMPTY, |
| 66 | MFP68901_INT_RCV_ERROR, |
| 67 | MFP68901_INT_RCV_BUFFER_FULL, |
| 68 | MFP68901_INT_TIMER_A, |
| 69 | MFP68901_INT_GPI6, |
| 70 | MFP68901_INT_GPI7 |
| 71 | }; |
| 72 | |
| 73 | #define MFP68901_AER_GPIP_0 0x01 |
| 74 | #define MFP68901_AER_GPIP_1 0x02 |
| 75 | #define MFP68901_AER_GPIP_2 0x04 |
| 76 | #define MFP68901_AER_GPIP_3 0x08 |
| 77 | #define MFP68901_AER_GPIP_4 0x10 |
| 78 | #define MFP68901_AER_GPIP_5 0x20 |
| 79 | #define MFP68901_AER_GPIP_6 0x40 |
| 80 | #define MFP68901_AER_GPIP_7 0x80 |
| 81 | |
| 82 | #define MFP68901_VR_S 0x08 |
| 83 | |
| 84 | #define MFP68901_IPRB_GPIP_0 0x01 |
| 85 | #define MFP68901_IPRB_GPIP_1 0x02 |
| 86 | #define MFP68901_IPRB_GPIP_2 0x04 |
| 87 | #define MFP68901_IPRB_GPIP_3 0x08 |
| 88 | #define MFP68901_IPRB_TIMER_D 0x10 |
| 89 | #define MFP68901_IPRB_TIMER_C 0x20 |
| 90 | #define MFP68901_IPRB_GPIP_4 0x40 |
| 91 | #define MFP68901_IPRB_GPIP_5 0x80 |
| 92 | |
| 93 | #define MFP68901_IPRA_TIMER_B 0x01 |
| 94 | #define MFP68901_IPRA_XMIT_ERROR 0x02 |
| 95 | #define MFP68901_IPRA_XMIT_BUFFER_EMPTY 0x04 |
| 96 | #define MFP68901_IPRA_RCV_ERROR 0x08 |
| 97 | #define MFP68901_IPRA_RCV_BUFFER_FULL 0x10 |
| 98 | #define MFP68901_IPRA_TIMER_A 0x20 |
| 99 | #define MFP68901_IPRA_GPIP_6 0x40 |
| 100 | #define MFP68901_IPRA_GPIP_7 0x80 |
| 101 | |
| 102 | #define MFP68901_TCR_TIMER_STOPPED 0x00 |
| 103 | #define MFP68901_TCR_TIMER_DELAY_4 0x01 |
| 104 | #define MFP68901_TCR_TIMER_DELAY_10 0x02 |
| 105 | #define MFP68901_TCR_TIMER_DELAY_16 0x03 |
| 106 | #define MFP68901_TCR_TIMER_DELAY_50 0x04 |
| 107 | #define MFP68901_TCR_TIMER_DELAY_64 0x05 |
| 108 | #define MFP68901_TCR_TIMER_DELAY_100 0x06 |
| 109 | #define MFP68901_TCR_TIMER_DELAY_200 0x07 |
| 110 | #define MFP68901_TCR_TIMER_EVENT 0x08 |
| 111 | #define MFP68901_TCR_TIMER_PULSE_4 0x09 |
| 112 | #define MFP68901_TCR_TIMER_PULSE_10 0x0a |
| 113 | #define MFP68901_TCR_TIMER_PULSE_16 0x0b |
| 114 | #define MFP68901_TCR_TIMER_PULSE_50 0x0c |
| 115 | #define MFP68901_TCR_TIMER_PULSE_64 0x0d |
| 116 | #define MFP68901_TCR_TIMER_PULSE_100 0x0e |
| 117 | #define MFP68901_TCR_TIMER_PULSE_200 0x0f |
| 118 | #define MFP68901_TCR_TIMER_RESET 0x10 |
| 119 | |
| 120 | #define MFP68901_UCR_PARITY_ENABLED 0x04 |
| 121 | #define MFP68901_UCR_PARITY_EVEN 0x02 |
| 122 | #define MFP68901_UCR_PARITY_ODD 0x00 |
| 123 | #define MFP68901_UCR_WORD_LENGTH_8 0x00 |
| 124 | #define MFP68901_UCR_WORD_LENGTH_7 0x20 |
| 125 | #define MFP68901_UCR_WORD_LENGTH_6 0x40 |
| 126 | #define MFP68901_UCR_WORD_LENGTH_5 0x60 |
| 127 | #define MFP68901_UCR_START_STOP_0_0 0x00 |
| 128 | #define MFP68901_UCR_START_STOP_1_1 0x08 |
| 129 | #define MFP68901_UCR_START_STOP_1_15 0x10 |
| 130 | #define MFP68901_UCR_START_STOP_1_2 0x18 |
| 131 | #define MFP68901_UCR_CLOCK_DIVIDE_16 0x80 |
| 132 | #define MFP68901_UCR_CLOCK_DIVIDE_1 0x00 |
| 133 | |
| 134 | #define MFP68901_RSR_RCV_ENABLE 0x01 |
| 135 | #define MFP68901_RSR_SYNC_STRIP_ENABLE 0x02 |
| 136 | #define MFP68901_RSR_MCIP 0x04 |
| 137 | #define MFP68901_RSR_FOUND_SEARCH 0x08 |
| 138 | #define MFP68901_RSR_FRAME_ERROR 0x10 |
| 139 | #define MFP68901_RSR_PARITY_ERROR 0x20 |
| 140 | #define MFP68901_RSR_OVERRUN_ERROR 0x40 |
| 141 | #define MFP68901_RSR_BUFFER_FULL 0x80 |
| 142 | |
| 143 | #define MFP68901_TSR_XMIT_ENABLE 0x01 |
| 144 | #define MFP68901_TSR_LOW 0x02 |
| 145 | #define MFP68901_TSR_HIGH 0x04 |
| 146 | #define MFP68901_TSR_BREAK 0x08 |
| 147 | #define MFP68901_TSR_END_OF_XMIT 0x10 |
| 148 | #define MFP68901_TSR_AUTO_TURNAROUND 0x20 |
| 149 | #define MFP68901_TSR_UNDERRUN_ERROR 0x40 |
| 150 | #define MFP68901_TSR_BUFFER_EMPTY 0x80 |
| 151 | |
| 152 | void mfp68901_config(int which, const struct mfp68901_interface *intf); |
| 153 | |
| 154 | void mfp68901_tai_w(int which, int value); |
| 155 | void mfp68901_tbi_w(int which, int value); |
| 156 | |
| 157 | READ16_HANDLER( mfp68901_0_register16_r ); |
| 158 | READ16_HANDLER( mfp68901_1_register16_r ); |
| 159 | READ16_HANDLER( mfp68901_2_register16_r ); |
| 160 | READ16_HANDLER( mfp68901_3_register16_r ); |
| 161 | |
| 162 | WRITE16_HANDLER( mfp68901_0_register_msb_w ); |
| 163 | WRITE16_HANDLER( mfp68901_1_register_msb_w ); |
| 164 | WRITE16_HANDLER( mfp68901_2_register_msb_w ); |
| 165 | WRITE16_HANDLER( mfp68901_3_register_msb_w ); |
| 166 | |
| 167 | WRITE16_HANDLER( mfp68901_0_register_lsb_w ); |
| 168 | WRITE16_HANDLER( mfp68901_1_register_lsb_w ); |
| 169 | WRITE16_HANDLER( mfp68901_2_register_lsb_w ); |
| 170 | WRITE16_HANDLER( mfp68901_3_register_lsb_w ); |
| 171 | |
| 172 | #endif |