src/mess/machine/pc1403.c
| r9721 | r9722 | |
| 2 | 2 | #include "cpu/sc61860/sc61860.h" |
| 3 | 3 | |
| 4 | 4 | #include "includes/pocketc.h" |
| 5 | | #include "includes/pc1401.h" |
| 6 | 5 | #include "includes/pc1403.h" |
| 7 | 6 | #include "devices/messram.h" |
| 8 | 7 | |
| 9 | 8 | /* C-CE while reset, program will not be destroyed! */ |
| 10 | 9 | |
| 11 | | static UINT8 outa; |
| 12 | | UINT8 pc1403_portc; |
| 13 | 10 | |
| 14 | | static int power; /* simulates pressed cce when mess is started */ |
| 15 | 11 | |
| 16 | 12 | |
| 17 | 13 | /* |
| r9721 | r9722 | |
| 20 | 16 | port 3: |
| 21 | 17 | bits 0..6 keyboard output select matrix line |
| 22 | 18 | */ |
| 23 | | static UINT8 asic[4]; |
| 24 | 19 | |
| 25 | 20 | WRITE8_HANDLER(pc1403_asic_write) |
| 26 | 21 | { |
| 27 | | asic[offset>>9]=data; |
| 22 | pc1403_state *state = space->machine->driver_data<pc1403_state>(); |
| 23 | state->asic[offset>>9]=data; |
| 28 | 24 | switch( (offset>>9) ){ |
| 29 | 25 | case 0/*0x3800*/: |
| 30 | 26 | // output |
| r9721 | r9722 | |
| 43 | 39 | |
| 44 | 40 | READ8_HANDLER(pc1403_asic_read) |
| 45 | 41 | { |
| 46 | | UINT8 data=asic[offset>>9]; |
| 42 | pc1403_state *state = space->machine->driver_data<pc1403_state>(); |
| 43 | UINT8 data=state->asic[offset>>9]; |
| 47 | 44 | switch( (offset>>9) ){ |
| 48 | 45 | case 0: case 1: case 2: |
| 49 | 46 | logerror ("asic read %.4x %.2x\n",offset, data); |
| r9721 | r9722 | |
| 54 | 51 | |
| 55 | 52 | void pc1403_outa(running_device *device, int data) |
| 56 | 53 | { |
| 57 | | outa=data; |
| 54 | pc1403_state *state = device->machine->driver_data<pc1403_state>(); |
| 55 | state->outa=data; |
| 58 | 56 | } |
| 59 | 57 | |
| 60 | 58 | int pc1403_ina(running_device *device) |
| 61 | 59 | { |
| 62 | | UINT8 data=outa; |
| 60 | pc1403_state *state = device->machine->driver_data<pc1403_state>(); |
| 61 | UINT8 data=state->outa; |
| 63 | 62 | |
| 64 | | if (asic[3] & 0x01) |
| 63 | if (state->asic[3] & 0x01) |
| 65 | 64 | data |= input_port_read(device->machine, "KEY0"); |
| 66 | 65 | |
| 67 | | if (asic[3] & 0x02) |
| 66 | if (state->asic[3] & 0x02) |
| 68 | 67 | data |= input_port_read(device->machine, "KEY1"); |
| 69 | 68 | |
| 70 | | if (asic[3] & 0x04) |
| 69 | if (state->asic[3] & 0x04) |
| 71 | 70 | data |= input_port_read(device->machine, "KEY2"); |
| 72 | 71 | |
| 73 | | if (asic[3] & 0x08) |
| 72 | if (state->asic[3] & 0x08) |
| 74 | 73 | data |= input_port_read(device->machine, "KEY3"); |
| 75 | 74 | |
| 76 | | if (asic[3] & 0x10) |
| 75 | if (state->asic[3] & 0x10) |
| 77 | 76 | data |= input_port_read(device->machine, "KEY4"); |
| 78 | 77 | |
| 79 | | if (asic[3] & 0x20) |
| 78 | if (state->asic[3] & 0x20) |
| 80 | 79 | data |= input_port_read(device->machine, "KEY5"); |
| 81 | 80 | |
| 82 | | if (asic[3] & 0x40) |
| 81 | if (state->asic[3] & 0x40) |
| 83 | 82 | data |= input_port_read(device->machine, "KEY6"); |
| 84 | 83 | |
| 85 | | if (outa & 0x01) |
| 84 | if (state->outa & 0x01) |
| 86 | 85 | { |
| 87 | 86 | data |= input_port_read(device->machine, "KEY7"); |
| 88 | 87 | |
| 89 | 88 | /* At Power Up we fake a 'C-CE' pressure */ |
| 90 | | if (power) |
| 89 | if (state->power) |
| 91 | 90 | data |= 0x02; |
| 92 | 91 | } |
| 93 | 92 | |
| 94 | | if (outa & 0x02) |
| 93 | if (state->outa & 0x02) |
| 95 | 94 | data |= input_port_read(device->machine, "KEY8"); |
| 96 | 95 | |
| 97 | | if (outa & 0x04) |
| 96 | if (state->outa & 0x04) |
| 98 | 97 | data |= input_port_read(device->machine, "KEY9"); |
| 99 | 98 | |
| 100 | | if (outa & 0x08) |
| 99 | if (state->outa & 0x08) |
| 101 | 100 | data |= input_port_read(device->machine, "KEY10"); |
| 102 | 101 | |
| 103 | | if (outa & 0x10) |
| 102 | if (state->outa & 0x10) |
| 104 | 103 | data |= input_port_read(device->machine, "KEY11"); |
| 105 | 104 | |
| 106 | | if (outa & 0x20) |
| 105 | if (state->outa & 0x20) |
| 107 | 106 | data |= input_port_read(device->machine, "KEY12"); |
| 108 | 107 | |
| 109 | | if (outa & 0x40) |
| 108 | if (state->outa & 0x40) |
| 110 | 109 | data |= input_port_read(device->machine, "KEY13"); |
| 111 | 110 | |
| 112 | 111 | return data; |
| r9721 | r9722 | |
| 115 | 114 | #if 0 |
| 116 | 115 | int pc1403_inb(void) |
| 117 | 116 | { |
| 118 | | int data = outb; |
| 117 | pc1403_state *state = machine->driver_data<pc140_state>(); |
| 118 | int data = state->outb; |
| 119 | 119 | |
| 120 | 120 | if (input_port_read(machine, "KEY13")) |
| 121 | 121 | data |= 1; |
| r9721 | r9722 | |
| 126 | 126 | |
| 127 | 127 | void pc1403_outc(running_device *device, int data) |
| 128 | 128 | { |
| 129 | | pc1403_portc = data; |
| 129 | pc1403_state *state = device->machine->driver_data<pc1403_state>(); |
| 130 | state->portc = data; |
| 130 | 131 | // logerror("%g pc %.4x outc %.2x\n", attotime_to_double(timer_get_time(device->machine)), cpu_get_pc(device->machine->device("maincpu")), data); |
| 131 | 132 | } |
| 132 | 133 | |
| r9721 | r9722 | |
| 167 | 168 | |
| 168 | 169 | static TIMER_CALLBACK(pc1403_power_up) |
| 169 | 170 | { |
| 170 | | power=0; |
| 171 | pc1403_state *state = machine->driver_data<pc1403_state>(); |
| 172 | state->power=0; |
| 171 | 173 | } |
| 172 | 174 | |
| 173 | 175 | DRIVER_INIT( pc1403 ) |
| 174 | 176 | { |
| 177 | pc1403_state *state = machine->driver_data<pc1403_state>(); |
| 175 | 178 | int i; |
| 176 | 179 | UINT8 *gfx=memory_region(machine, "gfx1"); |
| 177 | 180 | |
| 178 | 181 | for (i=0; i<128; i++) gfx[i]=i; |
| 179 | 182 | |
| 180 | | power = 1; |
| 183 | state->power = 1; |
| 181 | 184 | timer_set(machine, ATTOTIME_IN_SEC(1), NULL, 0, pc1403_power_up); |
| 182 | 185 | |
| 183 | 186 | memory_set_bankptr(machine, "bank1", memory_region(machine, "user1")); |
src/mess/video/pc1401.c
| r9721 | r9722 | |
| 17 | 17 | 603d: 0 BUSY, 1 DEF, 2 SHIFT, 3 BGN, 4 STAT, 5 FIN, 6 PRINT |
| 18 | 18 | 607c: 0 E, 1 M, 2 BAL, 3 INT, 4 PRN, 5 Sum-Sign, 6 PRO */ |
| 19 | 19 | |
| 20 | | static struct { |
| 21 | | UINT8 reg[0x100]; |
| 22 | | } pc1401_lcd; |
| 23 | | |
| 24 | 20 | READ8_HANDLER(pc1401_lcd_read) |
| 25 | 21 | { |
| 22 | pc1401_state *state = space->machine->driver_data<pc1401_state>(); |
| 26 | 23 | offset&=0xff; |
| 27 | | return pc1401_lcd.reg[offset]; |
| 24 | return state->reg[offset]; |
| 28 | 25 | } |
| 29 | 26 | |
| 30 | 27 | WRITE8_HANDLER(pc1401_lcd_write) |
| 31 | 28 | { |
| 29 | pc1401_state *state = space->machine->driver_data<pc1401_state>(); |
| 32 | 30 | offset&=0xff; |
| 33 | | pc1401_lcd.reg[offset]=data; |
| 31 | state->reg[offset]=data; |
| 34 | 32 | } |
| 35 | 33 | |
| 36 | 34 | static const POCKETC_FIGURE line={ /* simple line */ |
| r9721 | r9722 | |
| 135 | 133 | |
| 136 | 134 | VIDEO_UPDATE( pc1401 ) |
| 137 | 135 | { |
| 136 | pc1401_state *state = screen->machine->driver_data<pc1401_state>(); |
| 138 | 137 | running_machine *machine = screen->machine; |
| 139 | 138 | int x, y, i, j; |
| 140 | 139 | int color[2]; |
| r9721 | r9722 | |
| 150 | 149 | color[0] = 7; |
| 151 | 150 | color[1] = 8; |
| 152 | 151 | |
| 153 | | if (pc1401_portc&1) |
| 152 | if (state->portc&1) |
| 154 | 153 | { |
| 155 | 154 | for (x=RIGHT,y=DOWN,i=0; i<0x28;x+=2) |
| 156 | 155 | { |
| 157 | 156 | for (j=0; j<5;j++,i++,x+=2) |
| 158 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1401_lcd.reg[i],CONTRAST,0,0,x,y); |
| 157 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0,x,y); |
| 159 | 158 | } |
| 160 | 159 | for (i=0x67; i>=0x40;x+=2) |
| 161 | 160 | { |
| 162 | 161 | for (j=0; j<5;j++,i--,x+=2) |
| 163 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1401_lcd.reg[i],CONTRAST,0,0,x,y); |
| 162 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0,x,y); |
| 164 | 163 | } |
| 165 | 164 | } |
| 166 | 165 | |
| 167 | 166 | pocketc_draw_special(bitmap, RIGHT+149, DOWN+24, line, |
| 168 | | pc1401_lcd.reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 167 | state->reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 169 | 168 | |
| 170 | 169 | pocketc_draw_special(bitmap, RIGHT, DOWN-10, busy, |
| 171 | | pc1401_lcd.reg[0x3d] & 0x01 ? color[1] : color[0]); |
| 170 | state->reg[0x3d] & 0x01 ? color[1] : color[0]); |
| 172 | 171 | |
| 173 | 172 | pocketc_draw_special(bitmap, RIGHT+18, DOWN-10, def, |
| 174 | | pc1401_lcd.reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 173 | state->reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 175 | 174 | |
| 176 | 175 | pocketc_draw_special(bitmap, RIGHT+43, DOWN-10,shift, |
| 177 | | pc1401_lcd.reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 176 | state->reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 178 | 177 | |
| 179 | 178 | pocketc_draw_special(bitmap, RIGHT+63, DOWN-10,hyp, |
| 180 | | pc1401_lcd.reg[0x3d] & 0x08 ? color[1] : color[0]); |
| 179 | state->reg[0x3d] & 0x08 ? color[1] : color[0]); |
| 181 | 180 | |
| 182 | 181 | pocketc_draw_special(bitmap, RIGHT+38, DOWN+24,line, |
| 183 | | pc1401_lcd.reg[0x3d] & 0x10 ? color[1] : color[0]); |
| 182 | state->reg[0x3d] & 0x10 ? color[1] : color[0]); |
| 184 | 183 | |
| 185 | 184 | pocketc_draw_special(bitmap, RIGHT+23, DOWN+24,line, |
| 186 | | pc1401_lcd.reg[0x3d] & 0x20 ? color[1] : color[0]); |
| 185 | state->reg[0x3d] & 0x20 ? color[1] : color[0]); |
| 187 | 186 | |
| 188 | 187 | pocketc_draw_special(bitmap, RIGHT+8, DOWN+24,line, |
| 189 | | pc1401_lcd.reg[0x3d] & 0x40 ? color[1] : color[0]); |
| 188 | state->reg[0x3d] & 0x40 ? color[1] : color[0]); |
| 190 | 189 | |
| 191 | 190 | pocketc_draw_special(bitmap, RIGHT+183, DOWN-10,e, |
| 192 | | pc1401_lcd.reg[0x7c] & 0x01 ? color[1] : color[0]); |
| 191 | state->reg[0x7c] & 0x01 ? color[1] : color[0]); |
| 193 | 192 | |
| 194 | 193 | pocketc_draw_special(bitmap, RIGHT+176, DOWN-10,m, |
| 195 | | pc1401_lcd.reg[0x7c] & 0x02 ? color[1] : color[0]); |
| 194 | state->reg[0x7c] & 0x02 ? color[1] : color[0]); |
| 196 | 195 | |
| 197 | 196 | pocketc_draw_special(bitmap, RIGHT+168, DOWN-10,braces, |
| 198 | | pc1401_lcd.reg[0x7c] & 0x04 ? color[1] : color[0]); |
| 197 | state->reg[0x7c] & 0x04 ? color[1] : color[0]); |
| 199 | 198 | |
| 200 | 199 | pocketc_draw_special(bitmap, RIGHT+138, DOWN-10,rad, |
| 201 | | pc1401_lcd.reg[0x7c] & 0x08 ? color[1] : color[0]); |
| 200 | state->reg[0x7c] & 0x08 ? color[1] : color[0]); |
| 202 | 201 | |
| 203 | 202 | pocketc_draw_special(bitmap, RIGHT+134, DOWN-10,g, |
| 204 | | pc1401_lcd.reg[0x7c] & 0x10 ? color[1] : color[0]); |
| 203 | state->reg[0x7c] & 0x10 ? color[1] : color[0]); |
| 205 | 204 | |
| 206 | 205 | pocketc_draw_special(bitmap, RIGHT+126, DOWN-10,de, |
| 207 | | pc1401_lcd.reg[0x7c] & 0x20 ? color[1] : color[0]); |
| 206 | state->reg[0x7c] & 0x20 ? color[1] : color[0]); |
| 208 | 207 | |
| 209 | 208 | pocketc_draw_special(bitmap, RIGHT+165, DOWN+24,line, |
| 210 | | pc1401_lcd.reg[0x7c] & 0x40 ? color[1] : color[0]); |
| 209 | state->reg[0x7c] & 0x40 ? color[1] : color[0]); |
| 211 | 210 | |
| 212 | 211 | /* |
| 213 | 212 | 603c: 3 STAT |
src/mess/video/pc1350.c
| r9721 | r9722 | |
| 95 | 95 | "1 1 11 1e" |
| 96 | 96 | }; |
| 97 | 97 | |
| 98 | | static struct { |
| 99 | | UINT8 reg[0x1000]; |
| 100 | | } pc1350_lcd; |
| 101 | | |
| 102 | 98 | READ8_HANDLER(pc1350_lcd_read) |
| 103 | 99 | { |
| 100 | pc1350_state *state = space->machine->driver_data<pc1350_state>(); |
| 104 | 101 | int data; |
| 105 | | data=pc1350_lcd.reg[offset&0xfff]; |
| 102 | data = state->reg[offset&0xfff]; |
| 106 | 103 | logerror("pc1350 read %.3x %.2x\n",offset,data); |
| 107 | 104 | return data; |
| 108 | 105 | } |
| 109 | 106 | |
| 110 | 107 | WRITE8_HANDLER(pc1350_lcd_write) |
| 111 | 108 | { |
| 109 | pc1350_state *state = space->machine->driver_data<pc1350_state>(); |
| 112 | 110 | logerror("pc1350 write %.3x %.2x\n",offset,data); |
| 113 | | pc1350_lcd.reg[offset&0xfff]=data; |
| 111 | state->reg[offset&0xfff] = data; |
| 114 | 112 | } |
| 115 | 113 | |
| 116 | | int pc1350_keyboard_line_r(void) |
| 114 | int pc1350_keyboard_line_r(running_machine *machine) |
| 117 | 115 | { |
| 118 | | return pc1350_lcd.reg[0xe00]; |
| 116 | pc1350_state *state = machine->driver_data<pc1350_state>(); |
| 117 | return state->reg[0xe00]; |
| 119 | 118 | } |
| 120 | 119 | |
| 121 | 120 | /* pc1350 |
| r9721 | r9722 | |
| 131 | 130 | #define RIGHT 76 |
| 132 | 131 | |
| 133 | 132 | VIDEO_UPDATE( pc1350 ) |
| 134 | | { /* The contrast colours need some work done - select contrast level 7 for now */ |
| 133 | { |
| 134 | pc1350_state *state = screen->machine->driver_data<pc1350_state>(); /* The contrast colours need some work done - select contrast level 7 for now */ |
| 135 | 135 | int x, y=DOWN, i, j, k=0, b; |
| 136 | 136 | int color[4]; |
| 137 | 137 | running_machine *machine = screen->machine; |
| r9721 | r9722 | |
| 148 | 148 | for (x=RIGHT, i=pc1350_addr[k]; i<0xa00; i+=0x200) |
| 149 | 149 | for (j=0; j<=0x1d; j++, x+=2) |
| 150 | 150 | for (b = 0; b < 8; b++) |
| 151 | | plot_box(bitmap, x, y + b * 2, 2, 2, color[(pc1350_lcd.reg[j+i] >> b) & 1]); |
| 151 | plot_box(bitmap, x, y + b * 2, 2, 2, color[(state->reg[j+i] >> b) & 1]); |
| 152 | 152 | |
| 153 | 153 | |
| 154 | 154 | /* 783c: 0 SHIFT 1 DEF 4 RUN 5 PRO 6 JAPAN 7 SML */ |
| 155 | 155 | /* I don't know how they really look like in the lcd */ |
| 156 | 156 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+45, shift, |
| 157 | | pc1350_lcd.reg[0x83c] & 0x01 ? color[2] : color[3]); |
| 157 | state->reg[0x83c] & 0x01 ? color[2] : color[3]); |
| 158 | 158 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+55, def, |
| 159 | | pc1350_lcd.reg[0x83c] & 0x02 ? color[2] : color[3]); |
| 159 | state->reg[0x83c] & 0x02 ? color[2] : color[3]); |
| 160 | 160 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+5, run, |
| 161 | | pc1350_lcd.reg[0x83c] & 0x10 ? color[2] : color[3]); |
| 161 | state->reg[0x83c] & 0x10 ? color[2] : color[3]); |
| 162 | 162 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+15, pro, |
| 163 | | pc1350_lcd.reg[0x83c] & 0x20 ? color[2] : color[3]); |
| 163 | state->reg[0x83c] & 0x20 ? color[2] : color[3]); |
| 164 | 164 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+25, japan, |
| 165 | | pc1350_lcd.reg[0x83c] & 0x40 ? color[2] : color[3]); |
| 165 | state->reg[0x83c] & 0x40 ? color[2] : color[3]); |
| 166 | 166 | pocketc_draw_special(bitmap, RIGHT-30, DOWN+35, sml, |
| 167 | | pc1350_lcd.reg[0x83c] & 0x80 ? color[2] : color[3]); |
| 167 | state->reg[0x83c] & 0x80 ? color[2] : color[3]); |
| 168 | 168 | |
| 169 | 169 | return 0; |
| 170 | 170 | } |
src/mess/video/pc1403.c
| r9721 | r9722 | |
| 33 | 33 | #include "includes/pocketc.h" |
| 34 | 34 | #include "includes/pc1403.h" |
| 35 | 35 | |
| 36 | | static struct { |
| 37 | | UINT8 reg[0x100]; |
| 38 | | } pc1403_lcd; |
| 39 | 36 | |
| 40 | | static int DOWN, RIGHT; |
| 41 | | |
| 42 | 37 | VIDEO_START( pc1403 ) |
| 43 | 38 | { |
| 39 | pc1403_state *state = machine->driver_data<pc1403_state>(); |
| 44 | 40 | if (strcmp(machine->gamedrv->name, "pc1403h") == 0) |
| 45 | 41 | { |
| 46 | | DOWN = 69; |
| 47 | | RIGHT = 155; |
| 42 | state->DOWN = 69; |
| 43 | state->RIGHT = 155; |
| 48 | 44 | } |
| 49 | 45 | else |
| 50 | 46 | { |
| 51 | | DOWN = 67; |
| 52 | | RIGHT = 152; |
| 47 | state->DOWN = 67; |
| 48 | state->RIGHT = 152; |
| 53 | 49 | } |
| 54 | | |
| 55 | | VIDEO_START_CALL(pocketc); |
| 56 | 50 | } |
| 57 | 51 | |
| 58 | 52 | |
| 59 | 53 | READ8_HANDLER(pc1403_lcd_read) |
| 60 | 54 | { |
| 61 | | UINT8 data=pc1403_lcd.reg[offset]; |
| 62 | | return data; |
| 55 | pc1403_state *state = space->machine->driver_data<pc1403_state>(); |
| 56 | return state->reg[offset]; |
| 63 | 57 | } |
| 64 | 58 | |
| 65 | 59 | WRITE8_HANDLER(pc1403_lcd_write) |
| 66 | 60 | { |
| 67 | | pc1403_lcd.reg[offset]=data; |
| 61 | pc1403_state *state = space->machine->driver_data<pc1403_state>(); |
| 62 | state->reg[offset]=data; |
| 68 | 63 | } |
| 69 | 64 | |
| 70 | 65 | static const POCKETC_FIGURE line={ /* simple line */ |
| r9721 | r9722 | |
| 154 | 149 | |
| 155 | 150 | VIDEO_UPDATE( pc1403 ) |
| 156 | 151 | { |
| 152 | pc1403_state *state = screen->machine->driver_data<pc1403_state>(); |
| 157 | 153 | running_machine *machine = screen->machine; |
| 158 | 154 | int x, y, i, j; |
| 159 | 155 | int color[3]; |
| r9721 | r9722 | |
| 163 | 159 | /* HJB: we cannot initialize array with values from other arrays, thus... */ |
| 164 | 160 | color[0] = 7; // pocketc_colortable[CONTRAST][0]; |
| 165 | 161 | color[2] = 8; // pocketc_colortable[CONTRAST][1]; |
| 166 | | color[1] = (pc1403_portc & 1) ? color[2] : color[0]; |
| 162 | color[1] = (state->portc & 1) ? color[2] : color[0]; |
| 167 | 163 | |
| 168 | | if (pc1403_portc & 1) |
| 164 | if (state->portc & 1) |
| 169 | 165 | { |
| 170 | | for (x=RIGHT, y=DOWN, i=0; i<6*5; x+=2) { |
| 166 | for (x=state->RIGHT, y=state->DOWN, i=0; i<6*5; x+=2) { |
| 171 | 167 | for (j=0; j<5; j++, i++, x+=2) |
| 172 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 168 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 173 | 169 | x,y); |
| 174 | 170 | } |
| 175 | 171 | for (i=9*5; i<12*5; x+=2) |
| 176 | 172 | { |
| 177 | 173 | for (j=0; j<5; j++, i++, x+=2) |
| 178 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 174 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 179 | 175 | x,y); |
| 180 | 176 | } |
| 181 | 177 | for (i=6*5; i<9*5; x+=2) |
| 182 | 178 | { |
| 183 | 179 | for (j=0; j<5; j++, i++, x+=2) |
| 184 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 180 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 185 | 181 | x,y); |
| 186 | 182 | } |
| 187 | 183 | for (i=0x7b-3*5; i>0x7b-6*5; x+=2) |
| 188 | 184 | { |
| 189 | 185 | for (j=0; j<5; j++, i--, x+=2) |
| 190 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 186 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 191 | 187 | x,y); |
| 192 | 188 | } |
| 193 | 189 | for (i=0x7b; i>0x7b-3*5; x+=2) |
| 194 | 190 | { |
| 195 | 191 | for (j=0; j<5; j++, i--, x+=2) |
| 196 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 192 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 197 | 193 | x,y); |
| 198 | 194 | } |
| 199 | 195 | for (i=0x7b-6*5; i>0x7b-12*5; x+=2) |
| 200 | 196 | { |
| 201 | 197 | for (j=0; j<5; j++, i--, x+=2) |
| 202 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1403_lcd.reg[i],CONTRAST,0,0, |
| 198 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i],CONTRAST,0,0, |
| 203 | 199 | x,y); |
| 204 | 200 | } |
| 205 | 201 | } |
| 206 | | /* if display is off, busy is always visible? it seems to behave like that. */ |
| 207 | | /* But if computer is off, busy is hidden. */ |
| 208 | | if(!(pc1403_portc&8)) |
| 209 | | { |
| 210 | | if (pc1403_portc&1) |
| 211 | | pocketc_draw_special(bitmap, RIGHT, DOWN-13, busy, |
| 212 | | pc1403_lcd.reg[0x3d] & 1 ? color[2] : color[0]); |
| 202 | /* if display is off, busy is always visible? it seems to behave like that. */ |
| 203 | /* But if computer is off, busy is hidden. */ |
| 204 | if(!(state->portc&8)) |
| 205 | { |
| 206 | if (state->portc&1) |
| 207 | pocketc_draw_special(bitmap, state->RIGHT, state->DOWN-13, busy, |
| 208 | state->reg[0x3d] & 1 ? color[2] : color[0]); |
| 213 | 209 | |
| 214 | | else pocketc_draw_special(bitmap, RIGHT, DOWN-13, busy, color[2]); |
| 215 | | } |
| 216 | | else pocketc_draw_special(bitmap, RIGHT, DOWN-13, busy, color[0]); |
| 210 | else pocketc_draw_special(bitmap, state->RIGHT, state->DOWN-13, busy, color[2]); |
| 211 | } |
| 212 | else |
| 213 | pocketc_draw_special(bitmap, state->RIGHT, state->DOWN-13, busy, color[0]); |
| 217 | 214 | |
| 218 | | pocketc_draw_special(bitmap, RIGHT+18, DOWN-13, def, |
| 219 | | pc1403_lcd.reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 220 | | pocketc_draw_special(bitmap, RIGHT+43, DOWN-13, shift, |
| 221 | | pc1403_lcd.reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 222 | | pocketc_draw_special(bitmap, RIGHT+63, DOWN-13, hyp, |
| 223 | | pc1403_lcd.reg[0x3d] & 0x08 ? color[1] : color[0]); |
| 215 | pocketc_draw_special(bitmap, state->RIGHT+18, state->DOWN-13, def, |
| 216 | state->reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 217 | pocketc_draw_special(bitmap, state->RIGHT+43, state->DOWN-13, shift, |
| 218 | state->reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 219 | pocketc_draw_special(bitmap, state->RIGHT+63, state->DOWN-13, hyp, |
| 220 | state->reg[0x3d] & 0x08 ? color[1] : color[0]); |
| 224 | 221 | |
| 225 | | pocketc_draw_special(bitmap, RIGHT+155, DOWN-13, kana, |
| 226 | | pc1403_lcd.reg[0x3c] & 0x01 ? color[1] : color[0]); |
| 227 | | pocketc_draw_special(bitmap, RIGHT+167, DOWN-13, shoo, |
| 228 | | pc1403_lcd.reg[0x3c] & 0x02 ? color[1] : color[0]); |
| 229 | | pocketc_draw_special(bitmap, RIGHT+178, DOWN-13, sml, |
| 230 | | pc1403_lcd.reg[0x3c] & 0x04 ? color[1] : color[0]); |
| 222 | pocketc_draw_special(bitmap, state->RIGHT+155, state->DOWN-13, kana, |
| 223 | state->reg[0x3c] & 0x01 ? color[1] : color[0]); |
| 224 | pocketc_draw_special(bitmap, state->RIGHT+167, state->DOWN-13, shoo, |
| 225 | state->reg[0x3c] & 0x02 ? color[1] : color[0]); |
| 226 | pocketc_draw_special(bitmap, state->RIGHT+178, state->DOWN-13, sml, |
| 227 | state->reg[0x3c] & 0x04 ? color[1] : color[0]); |
| 231 | 228 | |
| 232 | | pocketc_draw_special(bitmap, RIGHT+191, DOWN-13, de, |
| 233 | | pc1403_lcd.reg[0x7c] & 0x20 ? color[1] : color[0]); |
| 234 | | pocketc_draw_special(bitmap, RIGHT+199, DOWN-13, g, |
| 235 | | pc1403_lcd.reg[0x7c] & 0x10 ? color[1] : color[0]); |
| 236 | | pocketc_draw_special(bitmap, RIGHT+203, DOWN-13, rad, |
| 237 | | pc1403_lcd.reg[0x7c] & 0x08 ? color[1] : color[0]); |
| 229 | pocketc_draw_special(bitmap, state->RIGHT+191, state->DOWN-13, de, |
| 230 | state->reg[0x7c] & 0x20 ? color[1] : color[0]); |
| 231 | pocketc_draw_special(bitmap, state->RIGHT+199, state->DOWN-13, g, |
| 232 | state->reg[0x7c] & 0x10 ? color[1] : color[0]); |
| 233 | pocketc_draw_special(bitmap, state->RIGHT+203, state->DOWN-13, rad, |
| 234 | state->reg[0x7c] & 0x08 ? color[1] : color[0]); |
| 238 | 235 | |
| 239 | | pocketc_draw_special(bitmap, RIGHT+266, DOWN-13, braces, |
| 240 | | pc1403_lcd.reg[0x7c] & 0x04 ? color[1] : color[0]); |
| 241 | | pocketc_draw_special(bitmap, RIGHT+274, DOWN-13, m, |
| 242 | | pc1403_lcd.reg[0x7c] & 0x02 ? color[1] : color[0]); |
| 243 | | pocketc_draw_special(bitmap, RIGHT+281, DOWN-13, e, |
| 244 | | pc1403_lcd.reg[0x7c] & 0x01 ? color[1] : color[0]); |
| 236 | pocketc_draw_special(bitmap, state->RIGHT+266, state->DOWN-13, braces, |
| 237 | state->reg[0x7c] & 0x04 ? color[1] : color[0]); |
| 238 | pocketc_draw_special(bitmap, state->RIGHT+274, state->DOWN-13, m, |
| 239 | state->reg[0x7c] & 0x02 ? color[1] : color[0]); |
| 240 | pocketc_draw_special(bitmap, state->RIGHT+281, state->DOWN-13, e, |
| 241 | state->reg[0x7c] & 0x01 ? color[1] : color[0]); |
| 245 | 242 | |
| 246 | | pocketc_draw_special(bitmap, RIGHT+10, DOWN+27, line /* empty */, |
| 247 | | pc1403_lcd.reg[0x3c] & 0x40 ? color[1] : color[0]); |
| 248 | | pocketc_draw_special(bitmap, RIGHT+31, DOWN+27, line /*calc*/, |
| 249 | | pc1403_lcd.reg[0x3d] & 0x40 ? color[1] : color[0]); |
| 250 | | pocketc_draw_special(bitmap, RIGHT+52, DOWN+27, line/*run*/, |
| 251 | | pc1403_lcd.reg[0x3d] & 0x20 ? color[1] : color[0]); |
| 252 | | pocketc_draw_special(bitmap, RIGHT+73, DOWN+27, line/*prog*/, |
| 253 | | pc1403_lcd.reg[0x3d] & 0x10 ? color[1] : color[0]); |
| 254 | | pocketc_draw_special(bitmap, RIGHT+94, DOWN+27, line /* empty */, |
| 255 | | pc1403_lcd.reg[0x3c] & 0x20 ? color[1] : color[0]); |
| 243 | pocketc_draw_special(bitmap, state->RIGHT+10, state->DOWN+27, line /* empty */, |
| 244 | state->reg[0x3c] & 0x40 ? color[1] : color[0]); |
| 245 | pocketc_draw_special(bitmap, state->RIGHT+31, state->DOWN+27, line /*calc*/, |
| 246 | state->reg[0x3d] & 0x40 ? color[1] : color[0]); |
| 247 | pocketc_draw_special(bitmap, state->RIGHT+52, state->DOWN+27, line/*run*/, |
| 248 | state->reg[0x3d] & 0x20 ? color[1] : color[0]); |
| 249 | pocketc_draw_special(bitmap, state->RIGHT+73, state->DOWN+27, line/*prog*/, |
| 250 | state->reg[0x3d] & 0x10 ? color[1] : color[0]); |
| 251 | pocketc_draw_special(bitmap, state->RIGHT+94, state->DOWN+27, line /* empty */, |
| 252 | state->reg[0x3c] & 0x20 ? color[1] : color[0]); |
| 256 | 253 | |
| 257 | | pocketc_draw_special(bitmap, RIGHT+232, DOWN+27, line/*matrix*/, |
| 258 | | pc1403_lcd.reg[0x3c] & 0x10 ? color[1] : color[0]); |
| 259 | | pocketc_draw_special(bitmap, RIGHT+253, DOWN+27, line/*stat*/, |
| 260 | | pc1403_lcd.reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 261 | | pocketc_draw_special(bitmap, RIGHT+274, DOWN+27, line/*print*/, |
| 262 | | pc1403_lcd.reg[0x7c] & 0x40 ? color[1] : color[0]); |
| 254 | pocketc_draw_special(bitmap, state->RIGHT+232, state->DOWN+27, line/*matrix*/, |
| 255 | state->reg[0x3c] & 0x10 ? color[1] : color[0]); |
| 256 | pocketc_draw_special(bitmap, state->RIGHT+253, state->DOWN+27, line/*stat*/, |
| 257 | state->reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 258 | pocketc_draw_special(bitmap, state->RIGHT+274, state->DOWN+27, line/*print*/, |
| 259 | state->reg[0x7c] & 0x40 ? color[1] : color[0]); |
| 263 | 260 | |
| 264 | 261 | return 0; |
| 265 | 262 | } |
src/mess/video/pc1251.c
| r9721 | r9722 | |
| 95 | 95 | "1 1 11 1e" |
| 96 | 96 | }; |
| 97 | 97 | |
| 98 | | static struct { |
| 99 | | UINT8 reg[0x100]; |
| 100 | | } pc1251_lcd; |
| 101 | | |
| 102 | 98 | READ8_HANDLER(pc1251_lcd_read) |
| 103 | 99 | { |
| 100 | pc1251_state *state = space->machine->driver_data<pc1251_state>(); |
| 104 | 101 | int data; |
| 105 | | data=pc1251_lcd.reg[offset&0xff]; |
| 102 | data = state->reg[offset&0xff]; |
| 106 | 103 | logerror("pc1251 read %.3x %.2x\n",offset,data); |
| 107 | 104 | return data; |
| 108 | 105 | } |
| 109 | 106 | |
| 110 | 107 | WRITE8_HANDLER(pc1251_lcd_write) |
| 111 | 108 | { |
| 109 | pc1251_state *state = space->machine->driver_data<pc1251_state>(); |
| 112 | 110 | logerror("pc1251 write %.3x %.2x\n",offset,data); |
| 113 | | pc1251_lcd.reg[offset&0xff]=data; |
| 111 | state->reg[offset&0xff] = data; |
| 114 | 112 | } |
| 115 | 113 | |
| 116 | 114 | #define DOWN 62 |
| r9721 | r9722 | |
| 118 | 116 | |
| 119 | 117 | VIDEO_UPDATE( pc1251 ) |
| 120 | 118 | { |
| 119 | pc1251_state *state = screen->machine->driver_data<pc1251_state>(); |
| 121 | 120 | int x, y, i, j; |
| 122 | 121 | int color[2]; |
| 123 | 122 | running_machine *machine = screen->machine; |
| r9721 | r9722 | |
| 131 | 130 | for (x=RIGHT,y=DOWN, i=0; i<60; x+=3) |
| 132 | 131 | { |
| 133 | 132 | for (j=0; j<5; j++, i++, x+=3) |
| 134 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1251_lcd.reg[i], |
| 133 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i], |
| 135 | 134 | PC1251_CONTRAST,0,0, |
| 136 | 135 | x,y); |
| 137 | 136 | } |
| 138 | 137 | for (i=0x7b; i>=0x40; x+=3) |
| 139 | 138 | { |
| 140 | 139 | for (j=0; j<5; j++, i--, x+=3) |
| 141 | | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], pc1251_lcd.reg[i], |
| 140 | drawgfx_opaque(bitmap, 0, screen->machine->gfx[0], state->reg[i], |
| 142 | 141 | PC1251_CONTRAST,0,0, |
| 143 | 142 | x,y); |
| 144 | 143 | } |
| 145 | 144 | |
| 146 | 145 | pocketc_draw_special(bitmap, RIGHT+134, DOWN-10, de, |
| 147 | | pc1251_lcd.reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 146 | state->reg[0x3c] & 0x08 ? color[1] : color[0]); |
| 148 | 147 | pocketc_draw_special(bitmap, RIGHT+142, DOWN-10, g, |
| 149 | | pc1251_lcd.reg[0x3c] & 0x04 ? color[1] : color[0]); |
| 148 | state->reg[0x3c] & 0x04 ? color[1] : color[0]); |
| 150 | 149 | pocketc_draw_special(bitmap, RIGHT+146, DOWN-10, rad, |
| 151 | | pc1251_lcd.reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 150 | state->reg[0x3d] & 0x04 ? color[1] : color[0]); |
| 152 | 151 | pocketc_draw_special(bitmap, RIGHT+18, DOWN-10, def, |
| 153 | | pc1251_lcd.reg[0x3c] & 0x01 ? color[1] : color[0]); |
| 152 | state->reg[0x3c] & 0x01 ? color[1] : color[0]); |
| 154 | 153 | pocketc_draw_special(bitmap, RIGHT, DOWN-10, shift, |
| 155 | | pc1251_lcd.reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 154 | state->reg[0x3d] & 0x02 ? color[1] : color[0]); |
| 156 | 155 | pocketc_draw_special(bitmap, RIGHT+38, DOWN-10, pro, |
| 157 | | pc1251_lcd.reg[0x3e] & 0x01 ? color[1] : color[0]); |
| 156 | state->reg[0x3e] & 0x01 ? color[1] : color[0]); |
| 158 | 157 | pocketc_draw_special(bitmap, RIGHT+53, DOWN-10, run, |
| 159 | | pc1251_lcd.reg[0x3e] & 0x02 ? color[1] : color[0]); |
| 158 | state->reg[0x3e] & 0x02 ? color[1] : color[0]); |
| 160 | 159 | pocketc_draw_special(bitmap, RIGHT+68, DOWN-10, rsv, |
| 161 | | pc1251_lcd.reg[0x3e] & 0x04 ? color[1] : color[0]); |
| 160 | state->reg[0x3e] & 0x04 ? color[1] : color[0]); |
| 162 | 161 | |
| 163 | 162 | /* 0x3c 1 def?, 4 g, 8 de |
| 164 | 163 | 0x3d 2 shift, 4 rad, 8 error |
src/mess/drivers/pocketc.c
| r9721 | r9722 | |
| 715 | 715 | pc1401_outc |
| 716 | 716 | }; |
| 717 | 717 | |
| 718 | | static MACHINE_CONFIG_START( pc1401, pocketc_state ) |
| 719 | | /* basic machine hardware */ |
| 720 | | MDRV_CPU_ADD("maincpu", SC61860, 192000) /* 7.8336 MHz */ |
| 721 | | MDRV_CPU_PROGRAM_MAP(pc1401_mem) |
| 722 | | MDRV_CPU_CONFIG(pc1401_config) |
| 723 | | |
| 718 | static MACHINE_CONFIG_FRAGMENT( pocketc ) |
| 724 | 719 | MDRV_QUANTUM_TIME(HZ(60)) |
| 725 | 720 | |
| 726 | 721 | MDRV_NVRAM_HANDLER( pc1401 ) |
| r9721 | r9722 | |
| 743 | 738 | MDRV_PALETTE_LENGTH(8*2) |
| 744 | 739 | MDRV_PALETTE_INIT( pocketc ) |
| 745 | 740 | |
| 746 | | MDRV_VIDEO_START( pocketc ) |
| 747 | | MDRV_VIDEO_UPDATE( pc1401 ) |
| 748 | | |
| 749 | 741 | /* sound hardware */ |
| 750 | 742 | /*MDRV_SOUND_ADD("dac", DAC, pocketc_sound_interface)*/ |
| 751 | 743 | MACHINE_CONFIG_END |
| 752 | 744 | |
| 745 | static MACHINE_CONFIG_START( pc1401, pc1401_state ) |
| 746 | MDRV_CPU_ADD("maincpu", SC61860, 192000) /* 7.8336 MHz */ |
| 747 | MDRV_CPU_PROGRAM_MAP(pc1401_mem) |
| 748 | MDRV_CPU_CONFIG(pc1401_config) |
| 749 | |
| 750 | MDRV_FRAGMENT_ADD(pocketc) |
| 751 | |
| 752 | MDRV_VIDEO_UPDATE( pc1401 ) |
| 753 | |
| 754 | MACHINE_CONFIG_END |
| 755 | |
| 753 | 756 | static MACHINE_CONFIG_DERIVED( pc1402, pc1401 ) |
| 754 | 757 | MDRV_CPU_MODIFY( "maincpu" ) |
| 755 | 758 | MDRV_CPU_PROGRAM_MAP( pc1402_mem) |
| r9721 | r9722 | |
| 757 | 760 | |
| 758 | 761 | static const sc61860_cpu_core pc1251_config = |
| 759 | 762 | { |
| 760 | | NULL, pc1251_brk, NULL, |
| 761 | | pc1251_ina, pc1251_outa, |
| 762 | | pc1251_inb, pc1251_outb, |
| 763 | | pc1251_outc |
| 763 | NULL, pc1251_brk, NULL, |
| 764 | pc1251_ina, pc1251_outa, |
| 765 | pc1251_inb, pc1251_outb, |
| 766 | pc1251_outc |
| 764 | 767 | }; |
| 765 | 768 | |
| 766 | | static MACHINE_CONFIG_DERIVED( pc1250, pc1401 ) |
| 767 | | MDRV_CPU_MODIFY( "maincpu" ) |
| 769 | static MACHINE_CONFIG_START( pc1250, pc1251_state ) |
| 770 | MDRV_CPU_ADD("maincpu", SC61860, 192000) /* 7.8336 MHz */ |
| 768 | 771 | MDRV_CPU_PROGRAM_MAP( pc1250_mem) |
| 769 | 772 | MDRV_CPU_CONFIG( pc1251_config ) |
| 770 | 773 | |
| 774 | MDRV_FRAGMENT_ADD(pocketc) |
| 775 | |
| 771 | 776 | MDRV_NVRAM_HANDLER( pc1251 ) |
| 772 | 777 | |
| 773 | 778 | /* video hardware */ |
| r9721 | r9722 | |
| 826 | 831 | |
| 827 | 832 | static const sc61860_cpu_core pc1350_config = |
| 828 | 833 | { |
| 829 | | NULL, pc1350_brk,NULL, |
| 830 | | pc1350_ina, pc1350_outa, |
| 831 | | pc1350_inb, pc1350_outb, |
| 832 | | pc1350_outc |
| 834 | NULL, pc1350_brk,NULL, |
| 835 | pc1350_ina, pc1350_outa, |
| 836 | pc1350_inb, pc1350_outb, |
| 837 | pc1350_outc |
| 833 | 838 | }; |
| 834 | 839 | |
| 835 | | static MACHINE_CONFIG_DERIVED( pc1350, pc1401 ) |
| 836 | | MDRV_CPU_MODIFY( "maincpu" ) |
| 840 | static MACHINE_CONFIG_START( pc1350, pc1350_state ) |
| 841 | MDRV_CPU_ADD("maincpu", SC61860, 192000) /* 7.8336 MHz */ |
| 837 | 842 | MDRV_CPU_PROGRAM_MAP( pc1350_mem) |
| 838 | 843 | MDRV_CPU_CONFIG( pc1350_config ) |
| 839 | 844 | |
| 845 | MDRV_FRAGMENT_ADD( pocketc ) |
| 846 | |
| 840 | 847 | MDRV_MACHINE_START( pc1350 ) |
| 841 | 848 | MDRV_NVRAM_HANDLER( pc1350 ) |
| 842 | 849 | |
| r9721 | r9722 | |
| 859 | 866 | |
| 860 | 867 | static const sc61860_cpu_core pc1403_config = |
| 861 | 868 | { |
| 862 | | NULL, pc1403_brk, NULL, |
| 863 | | pc1403_ina, pc1403_outa, |
| 864 | | NULL,NULL, |
| 865 | | pc1403_outc |
| 869 | NULL, pc1403_brk, NULL, |
| 870 | pc1403_ina, pc1403_outa, |
| 871 | NULL,NULL, |
| 872 | pc1403_outc |
| 866 | 873 | }; |
| 867 | 874 | |
| 868 | | static MACHINE_CONFIG_DERIVED( pc1403, pc1401 ) |
| 875 | static MACHINE_CONFIG_START( pc1403, pc1403_state ) |
| 876 | MDRV_CPU_ADD("maincpu", SC61860, 192000) /* 7.8336 MHz */ |
| 877 | MDRV_CPU_PROGRAM_MAP(pc1401_mem) |
| 878 | MDRV_CPU_CONFIG(pc1401_config) |
| 879 | |
| 880 | MDRV_FRAGMENT_ADD( pocketc ) |
| 881 | |
| 869 | 882 | MDRV_CPU_REPLACE( "maincpu", SC61860, 256000 ) |
| 870 | 883 | MDRV_CPU_PROGRAM_MAP( pc1403_mem) |
| 871 | 884 | MDRV_CPU_CONFIG( pc1403_config ) |