src/mess/video/hd44102.c
| r0 | r4669 | |
| 1 | /********************************************************************** |
| 2 | |
| 3 | HD44102 Dot Matrix Liquid Crystal Graphic Display Column Driver emulation |
| 4 | |
| 5 | Copyright MESS Team. |
| 6 | Visit http://mamedev.org for licensing and usage restrictions. |
| 7 | |
| 8 | **********************************************************************/ |
| 9 | |
| 10 | /* |
| 11 | |
| 12 | TODO: |
| 13 | |
| 14 | - 4 bit mode |
| 15 | - what if write Y > 49? |
| 16 | |
| 17 | */ |
| 18 | |
| 19 | #include "driver.h" |
| 20 | #include "hd44102.h" |
| 21 | |
| 22 | /*************************************************************************** |
| 23 | PARAMETERS |
| 24 | ***************************************************************************/ |
| 25 | |
| 26 | #define LOG 0 |
| 27 | |
| 28 | #define HD44102_CONTROL_DISPLAY_OFF 0x38 |
| 29 | #define HD44102_CONTROL_DISPLAY_ON 0x39 |
| 30 | #define HD44102_CONTROL_COUNT_DOWN_MODE 0x3a |
| 31 | #define HD44102_CONTROL_COUNT_UP_MODE 0x3b |
| 32 | #define HD44102_CONTROL_Y_ADDRESS_MASK 0x3f |
| 33 | #define HD44102_CONTROL_X_ADDRESS_MASK 0xc0 |
| 34 | |
| 35 | #define HD44102_STATUS_BUSY 0x80 |
| 36 | #define HD44102_STATUS_COUNT_UP 0x40 |
| 37 | #define HD44102_STATUS_DISPLAY_OFF 0x20 |
| 38 | #define HD44102_STATUS_RESET 0x10 |
| 39 | |
| 40 | /*************************************************************************** |
| 41 | TYPE DEFINITIONS |
| 42 | ***************************************************************************/ |
| 43 | |
| 44 | typedef struct _hd44102_t hd44102_t; |
| 45 | struct _hd44102_t |
| 46 | { |
| 47 | const device_config *screen; /* screen */ |
| 48 | |
| 49 | UINT8 ram[4][50]; /* display memory */ |
| 50 | |
| 51 | UINT8 status; /* status register */ |
| 52 | UINT8 output; /* output register */ |
| 53 | |
| 54 | int x; /* X address */ |
| 55 | int y; /* Y address */ |
| 56 | }; |
| 57 | |
| 58 | /*************************************************************************** |
| 59 | INLINE FUNCTIONS |
| 60 | ***************************************************************************/ |
| 61 | |
| 62 | INLINE hd44102_t *get_safe_token(const device_config *device) |
| 63 | { |
| 64 | assert(device != NULL); |
| 65 | assert(device->token != NULL); |
| 66 | return (hd44102_t *)device->token; |
| 67 | } |
| 68 | |
| 69 | INLINE hd44102_config *get_safe_config(const device_config *device) |
| 70 | { |
| 71 | assert(device != NULL); |
| 72 | assert(device->type == HD44102); |
| 73 | return (hd44102_config *)device->inline_config; |
| 74 | } |
| 75 | |
| 76 | /*************************************************************************** |
| 77 | IMPLEMENTATION |
| 78 | ***************************************************************************/ |
| 79 | |
| 80 | /*------------------------------------------------- |
| 81 | hd44102_status_r - status read |
| 82 | -------------------------------------------------*/ |
| 83 | |
| 84 | READ8_DEVICE_HANDLER( hd44102_status_r ) |
| 85 | { |
| 86 | hd44102_t *hd44102 = get_safe_token(device); |
| 87 | |
| 88 | return hd44102->status; |
| 89 | } |
| 90 | |
| 91 | /*------------------------------------------------- |
| 92 | hd44102_control_w - control write |
| 93 | -------------------------------------------------*/ |
| 94 | |
| 95 | WRITE8_DEVICE_HANDLER( hd44102_control_w ) |
| 96 | { |
| 97 | hd44102_t *hd44102 = get_safe_token(device); |
| 98 | |
| 99 | if (hd44102->status & HD44102_STATUS_BUSY) return; |
| 100 | |
| 101 | switch (data) |
| 102 | { |
| 103 | case HD44102_CONTROL_DISPLAY_OFF: |
| 104 | if (LOG) logerror("HD44102 '%s' Display Off\n", device->tag); |
| 105 | hd44102->status |= HD44102_STATUS_DISPLAY_OFF; |
| 106 | break; |
| 107 | |
| 108 | case HD44102_CONTROL_DISPLAY_ON: |
| 109 | if (LOG) logerror("HD44102 '%s' Display On\n", device->tag); |
| 110 | hd44102->status &= ~HD44102_STATUS_DISPLAY_OFF; |
| 111 | break; |
| 112 | |
| 113 | case HD44102_CONTROL_COUNT_DOWN_MODE: |
| 114 | if (LOG) logerror("HD44102 '%s' Count Down Mode\n", device->tag); |
| 115 | hd44102->status &= ~HD44102_STATUS_COUNT_UP; |
| 116 | break; |
| 117 | |
| 118 | case HD44102_CONTROL_COUNT_UP_MODE: |
| 119 | if (LOG) logerror("HD44102 '%s' Count Up Mode\n", device->tag); |
| 120 | hd44102->status |= HD44102_STATUS_COUNT_UP; |
| 121 | break; |
| 122 | |
| 123 | default: |
| 124 | hd44102->x = (data & HD44102_CONTROL_X_ADDRESS_MASK) >> 6; |
| 125 | hd44102->y = data & HD44102_CONTROL_Y_ADDRESS_MASK; |
| 126 | if (LOG) logerror("HD44102 '%s' Address %02x -> X %u Y %u\n", device->tag, data, hd44102->x, hd44102->y); |
| 127 | break; |
| 128 | } |
| 129 | } |
| 130 | |
| 131 | /*------------------------------------------------- |
| 132 | hd44102_data_r - data read |
| 133 | -------------------------------------------------*/ |
| 134 | |
| 135 | READ8_DEVICE_HANDLER( hd44102_data_r ) |
| 136 | { |
| 137 | hd44102_t *hd44102 = get_safe_token(device); |
| 138 | |
| 139 | UINT8 data = hd44102->output; |
| 140 | |
| 141 | hd44102->output = hd44102->ram[hd44102->x][hd44102->y]; |
| 142 | |
| 143 | if (hd44102->status & HD44102_STATUS_COUNT_UP) |
| 144 | { |
| 145 | if (++hd44102->y > 49) hd44102->y = 0; |
| 146 | } |
| 147 | else |
| 148 | { |
| 149 | if (--hd44102->y < 0) hd44102->y = 49; |
| 150 | } |
| 151 | |
| 152 | return data; |
| 153 | } |
| 154 | |
| 155 | /*------------------------------------------------- |
| 156 | hd44102_data_w - data write |
| 157 | -------------------------------------------------*/ |
| 158 | |
| 159 | WRITE8_DEVICE_HANDLER( hd44102_data_w ) |
| 160 | { |
| 161 | hd44102_t *hd44102 = get_safe_token(device); |
| 162 | |
| 163 | hd44102->ram[hd44102->x][hd44102->y] = data; |
| 164 | |
| 165 | if (hd44102->status & HD44102_STATUS_COUNT_UP) |
| 166 | { |
| 167 | if (++hd44102->y > 49) hd44102->y = 0; |
| 168 | } |
| 169 | else |
| 170 | { |
| 171 | if (--hd44102->y < 0) hd44102->y = 49; |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | /*------------------------------------------------- |
| 176 | hd44102_update - update screen |
| 177 | -------------------------------------------------*/ |
| 178 | |
| 179 | void hd44102_update(const device_config *device, bitmap_t *bitmap, const rectangle *cliprect) |
| 180 | { |
| 181 | hd44102_t *hd44102 = get_safe_token(device); |
| 182 | const hd44102_config *config = get_safe_config(device); |
| 183 | |
| 184 | if (hd44102->status & HD44102_STATUS_DISPLAY_OFF) |
| 185 | { |
| 186 | } |
| 187 | else |
| 188 | { |
| 189 | int y, z; |
| 190 | |
| 191 | for (y = 0; y < 50; y++) |
| 192 | { |
| 193 | for (z = 0; z < 32; z++) |
| 194 | { |
| 195 | UINT8 data = hd44102->ram[z / 8][y]; |
| 196 | |
| 197 | int sy = config->sy + z; |
| 198 | int sx = config->sx + y; |
| 199 | |
| 200 | if ((sy >= cliprect->min_y) && (sy <= cliprect->max_y) && (sx >= cliprect->min_x) && (sx <= cliprect->max_x)) |
| 201 | { |
| 202 | *BITMAP_ADDR16(bitmap, sy, sx) = BIT(data, z % 8); |
| 203 | } |
| 204 | } |
| 205 | } |
| 206 | } |
| 207 | } |
| 208 | |
| 209 | /*------------------------------------------------- |
| 210 | DEVICE_START( hd44102 ) |
| 211 | -------------------------------------------------*/ |
| 212 | |
| 213 | static DEVICE_START( hd44102 ) |
| 214 | { |
| 215 | hd44102_t *hd44102 = get_safe_token(device); |
| 216 | const hd44102_config *config = get_safe_config(device); |
| 217 | |
| 218 | /* get the screen device */ |
| 219 | hd44102->screen = devtag_get_device(device->machine, config->screen_tag); |
| 220 | assert(hd44102->screen != NULL); |
| 221 | |
| 222 | /* register for state saving */ |
| 223 | state_save_register_device_item(device, 0, hd44102->status); |
| 224 | state_save_register_device_item(device, 0, hd44102->output); |
| 225 | state_save_register_device_item(device, 0, hd44102->x); |
| 226 | state_save_register_device_item(device, 0, hd44102->y); |
| 227 | } |
| 228 | |
| 229 | /*------------------------------------------------- |
| 230 | DEVICE_RESET( hd44102 ) |
| 231 | -------------------------------------------------*/ |
| 232 | |
| 233 | static DEVICE_RESET( hd44102 ) |
| 234 | { |
| 235 | // hd44102_t *hd44102 = get_safe_token(device); |
| 236 | |
| 237 | } |
| 238 | |
| 239 | /*------------------------------------------------- |
| 240 | DEVICE_GET_INFO( hd44102 ) |
| 241 | -------------------------------------------------*/ |
| 242 | |
| 243 | DEVICE_GET_INFO( hd44102 ) |
| 244 | { |
| 245 | switch (state) |
| 246 | { |
| 247 | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 248 | case DEVINFO_INT_TOKEN_BYTES: info->i = sizeof(hd44102_t); break; |
| 249 | case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = sizeof(hd44102_config); break; |
| 250 | case DEVINFO_INT_CLASS: info->i = DEVICE_CLASS_PERIPHERAL; break; |
| 251 | |
| 252 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 253 | case DEVINFO_FCT_START: info->start = DEVICE_START_NAME(hd44102); break; |
| 254 | case DEVINFO_FCT_STOP: /* Nothing */ break; |
| 255 | case DEVINFO_FCT_RESET: info->reset = DEVICE_RESET_NAME(hd44102); break; |
| 256 | |
| 257 | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 258 | case DEVINFO_STR_NAME: strcpy(info->s, "Hitachi HD44102"); break; |
| 259 | case DEVINFO_STR_FAMILY: strcpy(info->s, "Hitachi HD44102"); break; |
| 260 | case DEVINFO_STR_VERSION: strcpy(info->s, "1.0"); break; |
| 261 | case DEVINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; |
| 262 | case DEVINFO_STR_CREDITS: strcpy(info->s, "Copyright MESS Team"); break; |
| 263 | } |
| 264 | } |
src/mess/video/hd44102.h
| r0 | r4669 | |
| 1 | /********************************************************************** |
| 2 | |
| 3 | HD44102 Dot Matrix Liquid Crystal Graphic Display Column Driver emulation |
| 4 | |
| 5 | Copyright MESS Team. |
| 6 | Visit http://mamedev.org for licensing and usage restrictions. |
| 7 | |
| 8 | **********************************************************************/ |
| 9 | |
| 10 | #ifndef __HD44102__ |
| 11 | #define __HD44102__ |
| 12 | |
| 13 | #include "driver.h" |
| 14 | #include "devcb.h" |
| 15 | |
| 16 | /*************************************************************************** |
| 17 | MACROS / CONSTANTS |
| 18 | ***************************************************************************/ |
| 19 | |
| 20 | #define HD44102 DEVICE_GET_INFO_NAME( hd44102 ) |
| 21 | |
| 22 | #define MDRV_HD44102_ADD(_tag, _clock, _screen, _sx, _sy) \ |
| 23 | MDRV_DEVICE_ADD((_tag), HD44102, _clock) \ |
| 24 | MDRV_DEVICE_CONFIG_DATA32(hd44102_config, screen_tag, _screen) \ |
| 25 | MDRV_DEVICE_CONFIG_DATA32(hd44102_config, sx, _sx) \ |
| 26 | MDRV_DEVICE_CONFIG_DATA32(hd44102_config, sy, _sy) |
| 27 | |
| 28 | /*************************************************************************** |
| 29 | TYPE DEFINITIONS |
| 30 | ***************************************************************************/ |
| 31 | |
| 32 | typedef struct _hd44102_config hd44102_config; |
| 33 | struct _hd44102_config |
| 34 | { |
| 35 | const char *screen_tag; /* screen we are acting on */ |
| 36 | |
| 37 | int sx; /* X origin on screen */ |
| 38 | int sy; /* Y origin on screen */ |
| 39 | }; |
| 40 | |
| 41 | /*************************************************************************** |
| 42 | PROTOTYPES |
| 43 | ***************************************************************************/ |
| 44 | |
| 45 | /* device interface */ |
| 46 | DEVICE_GET_INFO( hd44102 ); |
| 47 | |
| 48 | /* register access */ |
| 49 | READ8_DEVICE_HANDLER( hd44102_status_r ); |
| 50 | WRITE8_DEVICE_HANDLER( hd44102_control_w ); |
| 51 | |
| 52 | /* memory access */ |
| 53 | READ8_DEVICE_HANDLER( hd44102_data_r ); |
| 54 | WRITE8_DEVICE_HANDLER( hd44102_data_w ); |
| 55 | |
| 56 | /* screen update */ |
| 57 | void hd44102_update(const device_config *device, bitmap_t *bitmap, const rectangle *cliprect); |
| 58 | |
| 59 | #endif |
src/mess/video/kyocera.c
| r4668 | r4669 | |
| 1 | 1 | #include "driver.h" |
| 2 | 2 | #include "includes/kyocera.h" |
| 3 | #include "video/hd44102.h" |
| 3 | 4 | |
| 4 | | static bitmap_t *kyo_tmpbitmap; |
| 5 | | static int bank; |
| 6 | | static UINT8 lcd[11][256]; |
| 7 | | static UINT8 lcd_addr[10]; |
| 8 | | |
| 9 | | void kyo85_set_lcd_bank(UINT16 data) |
| 5 | void kyo85_set_lcd_bank(running_machine *machine, UINT16 data) |
| 10 | 6 | { |
| 11 | | switch (data) |
| 12 | | { |
| 13 | | case 0x000: bank = 0; break; |
| 14 | | case 0x001: bank = 1; break; |
| 15 | | case 0x002: bank = 2; break; |
| 16 | | case 0x004: bank = 3; break; |
| 17 | | case 0x008: bank = 4; break; |
| 18 | | case 0x010: bank = 5; break; |
| 19 | | case 0x020: bank = 6; break; |
| 20 | | case 0x040: bank = 7; break; |
| 21 | | case 0x080: bank = 8; break; |
| 22 | | case 0x100: bank = 9; break; |
| 23 | | case 0x200: bank = 10; break; |
| 24 | | default: /*logerror("pc8201: bank update with unk bank = %d\n", bank);*/ break; |
| 25 | | } |
| 7 | kyocera_state *state = machine->driver_data; |
| 8 | |
| 9 | state->lcd_cs2 = data; |
| 26 | 10 | } |
| 27 | 11 | |
| 28 | | static void increase(void) { |
| 29 | | UINT8 addr = lcd_addr[bank]; |
| 30 | | int col = addr & 0x3f; |
| 31 | | int row = addr >> 6; |
| 12 | READ8_HANDLER( kyo85_lcd_status_r ) |
| 13 | { |
| 14 | kyocera_state *state = space->machine->driver_data; |
| 32 | 15 | |
| 33 | | col++; |
| 16 | UINT8 data = 0; |
| 17 | int i; |
| 34 | 18 | |
| 35 | | if (bank == 5 || bank == 10) |
| 19 | for (i = 0; i < 10; i++) |
| 36 | 20 | { |
| 37 | | if (col == 40) |
| 21 | if (BIT(state->lcd_cs2, i)) |
| 38 | 22 | { |
| 39 | | col = 0; |
| 40 | | row++; |
| 23 | data |= hd44102_status_r(state->hd44102[i], 0); |
| 41 | 24 | } |
| 42 | 25 | } |
| 43 | | else |
| 44 | | { |
| 45 | | if (col == 50) |
| 46 | | { |
| 47 | | col = 0; |
| 48 | | row++; |
| 49 | | } |
| 50 | | } |
| 51 | 26 | |
| 52 | | lcd_addr[bank] = (row << 6) | col; |
| 27 | return data; |
| 53 | 28 | } |
| 54 | 29 | |
| 55 | | READ8_HANDLER( kyo85_lcd_status_r ) |
| 56 | | { |
| 57 | | return 0; // always ready |
| 58 | | } |
| 59 | | |
| 60 | 30 | READ8_HANDLER( kyo85_lcd_data_r ) |
| 61 | 31 | { |
| 62 | | UINT8 addr = lcd_addr[bank]; |
| 32 | kyocera_state *state = space->machine->driver_data; |
| 33 | UINT8 data = 0; |
| 34 | int i; |
| 63 | 35 | |
| 64 | | //logerror("LCD driver %u column %u row %u data read %02x\n", bank, addr & 0x3f, addr >> 6, lcd[bank][addr]); |
| 36 | for (i = 0; i < 10; i++) |
| 37 | { |
| 38 | if (BIT(state->lcd_cs2, i)) |
| 39 | { |
| 40 | data |= hd44102_data_r(state->hd44102[i], 0); |
| 41 | } |
| 42 | } |
| 65 | 43 | |
| 66 | | increase(); |
| 67 | | |
| 68 | | return lcd[bank][addr]; |
| 44 | return data; |
| 69 | 45 | } |
| 70 | 46 | |
| 71 | 47 | WRITE8_HANDLER( kyo85_lcd_command_w ) |
| 72 | 48 | { |
| 73 | | /* |
| 49 | kyocera_state *state = space->machine->driver_data; |
| 50 | int i; |
| 74 | 51 | |
| 75 | | bit description |
| 76 | | |
| 77 | | 0 column bit 0 |
| 78 | | 1 column bit 1 |
| 79 | | 2 column bit 2 |
| 80 | | 3 column bit 3 |
| 81 | | 4 column bit 4 |
| 82 | | 5 column bit 5 |
| 83 | | 6 row bit 0 |
| 84 | | 7 row bit 1 |
| 85 | | |
| 86 | | */ |
| 87 | | |
| 88 | | lcd_addr[bank] = data; |
| 89 | | |
| 90 | | //logerror("LCD driver %u column %u row %u\n", bank, data & 0x3f, data >> 6); |
| 52 | for (i = 0; i < 10; i++) |
| 53 | { |
| 54 | if (BIT(state->lcd_cs2, i)) |
| 55 | { |
| 56 | hd44102_control_w(state->hd44102[i], 0, data); |
| 57 | } |
| 58 | } |
| 91 | 59 | } |
| 92 | 60 | |
| 93 | 61 | WRITE8_HANDLER( kyo85_lcd_data_w ) |
| 94 | 62 | { |
| 95 | | UINT8 addr = lcd_addr[bank]; |
| 96 | | |
| 97 | | int col = addr & 0x3f; |
| 98 | | int row = addr >> 6; |
| 99 | | int sx, sy, y; |
| 63 | kyocera_state *state = space->machine->driver_data; |
| 64 | int i; |
| 100 | 65 | |
| 101 | | if (bank > 5) |
| 66 | for (i = 0; i < 10; i++) |
| 102 | 67 | { |
| 103 | | sx = (bank - 6) * 50; |
| 104 | | sy = 32; |
| 68 | if (BIT(state->lcd_cs2, i)) |
| 69 | { |
| 70 | hd44102_data_w(state->hd44102[i], 0, data); |
| 71 | } |
| 105 | 72 | } |
| 106 | | else |
| 107 | | { |
| 108 | | sx = (bank - 1) * 50; |
| 109 | | sy = 0; |
| 110 | | } |
| 111 | | |
| 112 | | sx += col; |
| 113 | | sy += row * 8; |
| 114 | | |
| 115 | | lcd[bank][addr] = data; |
| 116 | | |
| 117 | | for (y = 0; y < 8; y++) |
| 118 | | { |
| 119 | | int color = BIT(data, y); |
| 120 | | *BITMAP_ADDR16(kyo_tmpbitmap, sy + y, sx) = color; |
| 121 | | } |
| 122 | | |
| 123 | | //logerror("LCD driver %u column %u row %u data write %02x\n", bank, addr & 0x3f, addr >> 6, data); |
| 124 | | |
| 125 | | increase(); |
| 126 | 73 | } |
| 127 | 74 | |
| 128 | | PALETTE_INIT( kyo85 ) |
| 75 | static PALETTE_INIT( kyo85 ) |
| 129 | 76 | { |
| 130 | 77 | palette_set_color(machine, 0, MAKE_RGB(138, 146, 148)); |
| 131 | 78 | palette_set_color(machine, 1, MAKE_RGB(92, 83, 88)); |
| 132 | 79 | } |
| 133 | 80 | |
| 134 | | VIDEO_START( kyo85 ) |
| 81 | static VIDEO_START( kyo85 ) |
| 135 | 82 | { |
| 136 | | /* allocate the temporary bitmap */ |
| 137 | | kyo_tmpbitmap = auto_bitmap_alloc(240, 64, BITMAP_FORMAT_INDEXED16); |
| 83 | kyocera_state *state = machine->driver_data; |
| 84 | |
| 85 | state->hd44102[0] = devtag_get_device(machine, "m1"); |
| 86 | state->hd44102[1] = devtag_get_device(machine, "m2"); |
| 87 | state->hd44102[2] = devtag_get_device(machine, "m3"); |
| 88 | state->hd44102[3] = devtag_get_device(machine, "m4"); |
| 89 | state->hd44102[4] = devtag_get_device(machine, "m5"); |
| 90 | state->hd44102[5] = devtag_get_device(machine, "m6"); |
| 91 | state->hd44102[6] = devtag_get_device(machine, "m7"); |
| 92 | state->hd44102[7] = devtag_get_device(machine, "m8"); |
| 93 | state->hd44102[8] = devtag_get_device(machine, "m9"); |
| 94 | state->hd44102[9] = devtag_get_device(machine, "m10"); |
| 95 | |
| 96 | /* register for state saving */ |
| 97 | state_save_register_global(machine, state->lcd_cs2); |
| 138 | 98 | } |
| 139 | 99 | |
| 140 | | VIDEO_UPDATE( kyo85 ) |
| 100 | static VIDEO_UPDATE( kyo85 ) |
| 141 | 101 | { |
| 142 | | copybitmap(bitmap, kyo_tmpbitmap, 0, 0, 0, 0, cliprect); |
| 102 | kyocera_state *state = screen->machine->driver_data; |
| 143 | 103 | |
| 104 | int i; |
| 105 | |
| 106 | for (i = 0; i < 10; i++) |
| 107 | { |
| 108 | hd44102_update(state->hd44102[i], bitmap, cliprect); |
| 109 | } |
| 110 | |
| 144 | 111 | return 0; |
| 145 | 112 | } |
| 113 | |
| 114 | MACHINE_DRIVER_START( kyo85_video ) |
| 115 | MDRV_SCREEN_ADD(SCREEN_TAG, LCD) |
| 116 | MDRV_SCREEN_REFRESH_RATE(44) |
| 117 | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 118 | MDRV_SCREEN_SIZE(240, 64) |
| 119 | MDRV_SCREEN_VISIBLE_AREA(0, 240-1, 0, 64-1) |
| 120 | |
| 121 | // MDRV_DEFAULT_LAYOUT(layout_kyo85) |
| 122 | |
| 123 | MDRV_PALETTE_LENGTH(2) |
| 124 | MDRV_PALETTE_INIT(kyo85) |
| 125 | |
| 126 | MDRV_VIDEO_START(kyo85) |
| 127 | MDRV_VIDEO_UPDATE(kyo85) |
| 128 | |
| 129 | MDRV_HD44102_ADD( "m1", 0, SCREEN_TAG, 0, 0) |
| 130 | MDRV_HD44102_ADD( "m2", 0, SCREEN_TAG, 50, 0) |
| 131 | MDRV_HD44102_ADD( "m3", 0, SCREEN_TAG, 100, 0) |
| 132 | MDRV_HD44102_ADD( "m4", 0, SCREEN_TAG, 150, 0) |
| 133 | MDRV_HD44102_ADD( "m5", 0, SCREEN_TAG, 200, 0) |
| 134 | MDRV_HD44102_ADD( "m6", 0, SCREEN_TAG, 0, 32) |
| 135 | MDRV_HD44102_ADD( "m7", 0, SCREEN_TAG, 50, 32) |
| 136 | MDRV_HD44102_ADD( "m8", 0, SCREEN_TAG, 100, 32) |
| 137 | MDRV_HD44102_ADD( "m9", 0, SCREEN_TAG, 150, 32) |
| 138 | MDRV_HD44102_ADD("m10", 0, SCREEN_TAG, 200, 32) |
| 139 | MACHINE_DRIVER_END |
src/mess/drivers/kyocera.c
| r4668 | r4669 | |
| 661 | 661 | const device_config *rtc = devtag_get_device(device->machine, UPD1990A_TAG); |
| 662 | 662 | |
| 663 | 663 | port_a = data; |
| 664 | | kyo85_set_lcd_bank( port_a | ((port_b & 3) << 8) ); |
| 664 | kyo85_set_lcd_bank( device->machine, port_a | ((port_b & 3) << 8) ); |
| 665 | 665 | |
| 666 | 666 | /* |
| 667 | 667 | The first 5 bits of this port is used to control the 1990 real time clock chip. |
| r4668 | r4669 | |
| 695 | 695 | 6 - DTR (not) line for RS232 |
| 696 | 696 | 7 - RTS (not) line for RS232 */ |
| 697 | 697 | port_b = data; |
| 698 | | kyo85_set_lcd_bank( port_a | ((port_b & 3) << 8) ); |
| 698 | kyo85_set_lcd_bank( device->machine, port_a | ((port_b & 3) << 8) ); |
| 699 | 699 | } |
| 700 | 700 | |
| 701 | 701 | static PIO8155_INTERFACE( kyocera_8155_intf ) |
| r4668 | r4669 | |
| 710 | 710 | }; |
| 711 | 711 | |
| 712 | 712 | static MACHINE_DRIVER_START( kyo85 ) |
| 713 | MDRV_DRIVER_DATA(kyocera_state) |
| 714 | |
| 713 | 715 | /* basic machine hardware */ |
| 714 | 716 | MDRV_CPU_ADD(I8085_TAG, 8085A, 2400000) |
| 715 | 717 | MDRV_CPU_PROGRAM_MAP(kyo85_mem, 0) |
| r4668 | r4669 | |
| 719 | 721 | MDRV_MACHINE_RESET( kyo85 ) |
| 720 | 722 | |
| 721 | 723 | /* video hardware */ |
| 722 | | MDRV_SCREEN_ADD(SCREEN_TAG, LCD) |
| 723 | | MDRV_SCREEN_REFRESH_RATE(44) |
| 724 | | MDRV_SCREEN_FORMAT(BITMAP_FORMAT_INDEXED16) |
| 725 | | MDRV_SCREEN_SIZE(240, 64) |
| 726 | | MDRV_SCREEN_VISIBLE_AREA(0, 240-1, 0, 64-1) |
| 724 | MDRV_IMPORT_FROM(kyo85_video) |
| 727 | 725 | |
| 728 | | // MDRV_DEFAULT_LAYOUT(layout_kyo85) |
| 729 | | |
| 730 | | MDRV_PALETTE_LENGTH(2) |
| 731 | | MDRV_PALETTE_INIT(kyo85) |
| 732 | | |
| 733 | | MDRV_VIDEO_START(kyo85) |
| 734 | | MDRV_VIDEO_UPDATE(kyo85) |
| 735 | | |
| 736 | 726 | /* sound hardware */ |
| 737 | 727 | // MDRV_SPEAKER_STANDARD_MONO("mono") |
| 738 | 728 | // MDRV_SOUND_ADD("speaker", SPEAKER, 0) |
| r4668 | r4669 | |
| 771 | 761 | |
| 772 | 762 | ROM_START(trsm100) |
| 773 | 763 | ROM_REGION( 0x8000, I8085_TAG, 0 ) |
| 774 | | ROM_SYSTEM_BIOS(0, "default", "Model 100") |
| 775 | | ROMX_LOAD( "m100rom.bin", 0x0000, 0x8000, CRC(730a3611) SHA1(094dbc4ac5a4ea5cdf51a1ac581a40a9622bb25d), ROM_BIOS(1) ) |
| 776 | | ROM_SYSTEM_BIOS(1, "alt", "Model 100 (alt)") |
| 777 | | ROMX_LOAD( "m100arom.bin", 0x0000, 0x8000, CRC(75ac39b7) SHA1(824e730ae45babf886023151504fcd6191bbed10), ROM_BIOS(2) ) |
| 764 | ROM_LOAD( "m100rom.bin", 0x0000, 0x8000, CRC(730a3611) SHA1(094dbc4ac5a4ea5cdf51a1ac581a40a9622bb25d) ) |
| 778 | 765 | ROM_END |
| 779 | 766 | |
| 780 | 767 | ROM_START(olivm10) |
| 781 | 768 | ROM_REGION( 0x8010, I8085_TAG, 0 ) |
| 782 | | ROM_SYSTEM_BIOS(0, "default", "M10") |
| 783 | | ROMX_LOAD( "m10rom.bin", 0x0000, 0x8010, CRC(0be02b58) SHA1(56f2087a658efd0323663d15afcd4f5f27c68664), ROM_BIOS(1) ) |
| 784 | | ROM_SYSTEM_BIOS(1, "alt", "M10 (alt)") |
| 785 | | ROMX_LOAD( "m10arom.bin", 0x0000, 0x8010, CRC(afd5a43d) SHA1(b8362f7f248692de13128a47c6c116172e38da10), ROM_BIOS(2) ) |
| 769 | ROM_LOAD( "m10rom.bin", 0x0000, 0x8010, CRC(0be02b58) SHA1(56f2087a658efd0323663d15afcd4f5f27c68664) ) |
| 786 | 770 | ROM_END |
| 787 | 771 | |
| 788 | 772 | ROM_START(kyo85) |