summaryrefslogtreecommitdiffstatshomepage
path: root/src/devices/cpu/upd7810/upd7810.h
blob: a609707f1d9dbdba36cc644086e098eebca95efc (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
// license:BSD-3-Clause
// copyright-holders:Juergen Buchmueller
#ifndef MAME_CPU_UPD7810_UPD7810_H
#define MAME_CPU_UPD7810_UPD7810_H

#pragma once


/*
  all types have internal ram at 0xff00-0xffff
  7810
  7811 (4kbyte),7812(8),7814(16) have internal rom at 0x0000
*/


enum
{
	UPD7810_PC=1, UPD7810_SP, UPD7810_PSW,
	UPD7810_EA, UPD7810_V, UPD7810_A, UPD7810_VA,
	UPD7810_BC, UPD7810_B, UPD7810_C, UPD7810_DE, UPD7810_D, UPD7810_E, UPD7810_HL, UPD7810_H, UPD7810_L,
	UPD7810_EA2, UPD7810_V2, UPD7810_A2, UPD7810_VA2,
	UPD7810_BC2, UPD7810_B2, UPD7810_C2, UPD7810_DE2, UPD7810_D2, UPD7810_E2, UPD7810_HL2, UPD7810_H2, UPD7810_L2,
	UPD7810_CNT0, UPD7810_CNT1, UPD7810_TM0, UPD7810_TM1, UPD7810_ECNT, UPD7810_ECPT, UPD7810_ETM0, UPD7810_ETM1,
	UPD7810_MA, UPD7810_MB, UPD7810_MCC, UPD7810_MC, UPD7810_MM, UPD7810_MF,
	UPD7810_TMM, UPD7810_ETMM, UPD7810_EOM, UPD7810_SML, UPD7810_SMH,
	UPD7810_ANM, UPD7810_MKL, UPD7810_MKH, UPD7810_ZCM,
	UPD7810_TXB, UPD7810_RXB, UPD7810_CR0, UPD7810_CR1, UPD7810_CR2, UPD7810_CR3,
	UPD7810_AN0, UPD7810_AN1, UPD7810_AN2, UPD7810_AN3, UPD7810_AN4, UPD7810_AN5, UPD7810_AN6, UPD7810_AN7,
	UPD7810_TXD, UPD7810_RXD, UPD7810_SCK, UPD7810_TI, UPD7810_TO, UPD7810_CI, UPD7810_CO0, UPD7810_CO1,
	UPD7810_LV0, UPD7810_LV1
};

/* IRQ lines */
#define UPD7810_INTF1       0
#define UPD7810_INTF2       1
#define UPD7810_INTF0       2
#define UPD7810_INTFE1      4



#define MCFG_UPD7810_TO(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_to_func(DEVCB_##_devcb);

#define MCFG_UPD7810_CO0(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_co0_func(DEVCB_##_devcb);

#define MCFG_UPD7810_CO1(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_co1_func(DEVCB_##_devcb);

#define MCFG_UPD7810_TXD(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_txd_func(DEVCB_##_devcb);

#define MCFG_UPD7810_RXD(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_rxd_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN0(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an0_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN1(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an1_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN2(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an2_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN3(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an3_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN4(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an4_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN5(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an5_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN6(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an6_func(DEVCB_##_devcb);

#define MCFG_UPD7810_AN7(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_an7_func(DEVCB_##_devcb);


#define MCFG_UPD7810_PORTA_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pa_in_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTB_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pb_in_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTC_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pc_in_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTD_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pd_in_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTF_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pf_in_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTA_WRITE_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pa_out_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTB_WRITE_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pb_out_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTC_WRITE_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pc_out_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTD_WRITE_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pd_out_cb(DEVCB_##_devcb);

#define MCFG_UPD7810_PORTF_WRITE_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pf_out_cb(DEVCB_##_devcb);


#define MCFG_UPD7807_PORTA_READ_CB MCFG_UPD7810_PORTA_READ_CB
#define MCFG_UPD7807_PORTB_READ_CB MCFG_UPD7810_PORTB_READ_CB
#define MCFG_UPD7807_PORTC_READ_CB MCFG_UPD7810_PORTC_READ_CB
#define MCFG_UPD7807_PORTD_READ_CB MCFG_UPD7810_PORTD_READ_CB
#define MCFG_UPD7807_PORTF_READ_CB MCFG_UPD7810_PORTF_READ_CB
#define MCFG_UPD7807_PORTA_WRITE_CB MCFG_UPD7810_PORTA_WRITE_CB
#define MCFG_UPD7807_PORTB_WRITE_CB MCFG_UPD7810_PORTB_WRITE_CB
#define MCFG_UPD7807_PORTC_WRITE_CB MCFG_UPD7810_PORTC_WRITE_CB
#define MCFG_UPD7807_PORTD_WRITE_CB MCFG_UPD7810_PORTD_WRITE_CB
#define MCFG_UPD7807_PORTF_WRITE_CB MCFG_UPD7810_PORTF_WRITE_CB

#define MCFG_UPD7807_PORTT_READ_CB(_devcb) \
	devcb = &downcast<upd7810_device &>(*device).set_pt_in_cb(DEVCB_##_devcb);


class upd7810_device : public cpu_device
{
public:
	// construction/destruction
	upd7810_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);

	// configuration helpers
	template <class Object> devcb_base &set_to_func(Object &&cb) { return m_to_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_co0_func(Object &&cb) { return m_co0_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_co1_func(Object &&cb) { return m_co1_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_txd_func(Object &&cb) { return m_txd_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_rxd_func(Object &&cb) { return m_rxd_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an0_func(Object &&cb) { return m_an0_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an1_func(Object &&cb) { return m_an1_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an2_func(Object &&cb) { return m_an2_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an3_func(Object &&cb) { return m_an3_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an4_func(Object &&cb) { return m_an4_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an5_func(Object &&cb) { return m_an5_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an6_func(Object &&cb) { return m_an6_func.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_an7_func(Object &&cb) { return m_an7_func.set_callback(std::forward<Object>(cb)); }

	template <class Object> devcb_base &set_pa_in_cb(Object &&cb) { return m_pa_in_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pb_in_cb(Object &&cb) { return m_pb_in_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pc_in_cb(Object &&cb) { return m_pc_in_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pd_in_cb(Object &&cb) { return m_pd_in_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pf_in_cb(Object &&cb) { return m_pf_in_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pa_out_cb(Object &&cb) { return m_pa_out_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pb_out_cb(Object &&cb) { return m_pb_out_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pc_out_cb(Object &&cb) { return m_pc_out_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pd_out_cb(Object &&cb) { return m_pd_out_cb.set_callback(std::forward<Object>(cb)); }
	template <class Object> devcb_base &set_pf_out_cb(Object &&cb) { return m_pf_out_cb.set_callback(std::forward<Object>(cb)); }

	template <class Object> devcb_base &set_pt_in_cb(Object &&cb) { return m_pt_in_cb.set_callback(std::forward<Object>(cb)); }

	DECLARE_WRITE8_MEMBER(pa_w);
	DECLARE_WRITE8_MEMBER(pb_w);
	DECLARE_WRITE8_MEMBER(pc_w);
	DECLARE_WRITE8_MEMBER(pd_w);
	DECLARE_WRITE8_MEMBER(pf_w);

	void upd_internal_128_ram_map(address_map &map);
	void upd_internal_256_ram_map(address_map &map);
	void upd_internal_4096_rom_map(address_map &map);
protected:
	// flags
	enum
	{
		CY = 0x01,
		F1 = 0x02,
		L0 = 0x04,
		L1 = 0x08,
		HC = 0x10,
		SK = 0x20,
		Z  = 0x40,
		F7 = 0x80
	};

	// IRR flags
	enum
	{
		INTNMI  = 0x0001,
		INTFT0  = 0x0002,
		INTFT1  = 0x0004,
		INTF1   = 0x0008,
		INTF2   = 0x0010,
		INTFE0  = 0x0020,
		INTFE1  = 0x0040,
		INTFEIN = 0x0080,
		INTFAD  = 0x0100,
		INTFSR  = 0x0200,
		INTFST  = 0x0400,
		INTER   = 0x0800,
		INTOV   = 0x1000,
		INTF0   = 0x2000
	};

	// ITF flags
	enum
	{
		INTAN4 = 0x0001,
		INTAN5 = 0x0002,
		INTAN6 = 0x0004,
		INTAN7 = 0x0008,
		INTSB  = 0x0010
	};

	upd7810_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, address_map_constructor internal_map);

	// device-level overrides
	virtual void device_start() override;
	virtual void device_reset() override;

	// device_execute_interface overrides
	virtual uint32_t execute_min_cycles() const override { return 1; }
	virtual uint32_t execute_max_cycles() const override { return 40; }
	virtual uint32_t execute_input_lines() const override { return 2; }
	virtual bool execute_input_edge_triggered(int inputnum) const override { return true; }
	virtual void execute_run() override;
	virtual void execute_set_input(int inputnum, int state) override;

	// device_memory_interface overrides
	virtual space_config_vector memory_space_config() const override;

	// device_state_interface overrides
	virtual void state_string_export(const device_state_entry &entry, std::string &str) const override;

	// device_disasm_interface overrides
	virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;

	virtual void handle_timers(int cycles);
	virtual void upd7810_take_irq();

	void upd7810_handle_timer0(int cycles, int clkdiv);
	void upd7810_handle_timer1(int cycles, int clkdiv);

	void upd7810_co0_output_change();
	void upd7810_co1_output_change();

	devcb_write_line  m_to_func;
	devcb_write_line  m_co0_func;
	devcb_write_line  m_co1_func;
	devcb_write_line  m_txd_func;
	devcb_read_line   m_rxd_func;
	devcb_read8       m_an0_func;
	devcb_read8       m_an1_func;
	devcb_read8       m_an2_func;
	devcb_read8       m_an3_func;
	devcb_read8       m_an4_func;
	devcb_read8       m_an5_func;
	devcb_read8       m_an6_func;
	devcb_read8       m_an7_func;

	devcb_read8       m_pa_in_cb;
	devcb_read8       m_pb_in_cb;
	devcb_read8       m_pc_in_cb;
	devcb_read8       m_pd_in_cb;
	devcb_read8       m_pf_in_cb;
	devcb_write8      m_pa_out_cb;
	devcb_write8      m_pb_out_cb;
	devcb_write8      m_pc_out_cb;
	devcb_write8      m_pd_out_cb;
	devcb_write8      m_pf_out_cb;

	devcb_read8       m_pt_in_cb; // TODO: uPD7807 only

	typedef void (upd7810_device::*opcode_func)();

	struct opcode_s {
		opcode_func opfunc;
		uint8_t oplen;
		uint8_t cycles;
		uint8_t cycles_skip;
		uint8_t mask_l0_l1;
	};

	virtual void configure_ops();

	static const struct opcode_s s_op48[256];
	static const struct opcode_s s_op4C[256];
	static const struct opcode_s s_op4D[256];
	static const struct opcode_s s_op60[256];
	static const struct opcode_s s_op64[256];
	static const struct opcode_s s_op70[256];
	static const struct opcode_s s_op74[256];
	static const struct opcode_s s_opXX_7810[256];
	static const struct opcode_s s_opXX_7807[256];
	static const struct opcode_s s_op48_7801[256];
	static const struct opcode_s s_op4C_7801[256];
	static const struct opcode_s s_op4D_7801[256];
	static const struct opcode_s s_op60_7801[256];
	static const struct opcode_s s_op64_7801[256];
	static const struct opcode_s s_op70_7801[256];
	static const struct opcode_s s_op74_7801[256];
	static const struct opcode_s s_opXX_7801[256];
	static const struct opcode_s s_op48_78c05[256];
	static const struct opcode_s s_op4C_78c05[256];
	static const struct opcode_s s_op4D_78c05[256];
	static const struct opcode_s s_op60_78c05[256];
	static const struct opcode_s s_op64_78c05[256];
	static const struct opcode_s s_op70_78c05[256];
	static const struct opcode_s s_op74_78c05[256];
	static const struct opcode_s s_opXX_78c05[256];
	static const struct opcode_s s_op48_78c06[256];
	static const struct opcode_s s_op4C_78c06[256];
	static const struct opcode_s s_op4D_78c06[256];
	static const struct opcode_s s_op60_78c06[256];
	static const struct opcode_s s_op64_78c06[256];
	static const struct opcode_s s_op70_78c06[256];
	static const struct opcode_s s_op74_78c06[256];
	static const struct opcode_s s_opXX_78c06[256];

	address_space_config m_program_config;

	PAIR    m_ppc;    /* previous program counter */
	PAIR    m_pc;     /* program counter */
	PAIR    m_sp;     /* stack pointer */
	uint8_t   m_op;     /* opcode */
	uint8_t   m_op2;    /* opcode part 2 */
	uint8_t   m_iff;    /* interrupt enable flip flop */
	uint8_t   m_psw;    /* processor status word */
	PAIR    m_ea;     /* extended accumulator */
	PAIR    m_va;     /* accumulator + vector register */
	PAIR    m_bc;     /* 8bit B and C registers / 16bit BC register */
	PAIR    m_de;     /* 8bit D and E registers / 16bit DE register */
	PAIR    m_hl;     /* 8bit H and L registers / 16bit HL register */
	PAIR    m_ea2;    /* alternate register set */
	PAIR    m_va2;
	PAIR    m_bc2;
	PAIR    m_de2;
	PAIR    m_hl2;
	PAIR    m_cnt;    /* 8 bit timer counter */
	PAIR    m_tm;     /* 8 bit timer 0/1 comparator inputs */
	PAIR    m_ecnt;   /* timer counter register / capture register */
	PAIR    m_etm;    /* timer 0/1 comparator inputs */
	uint8_t   m_ma;     /* port A input or output mask */
	uint8_t   m_mb;     /* port B input or output mask */
	uint8_t   m_mcc;    /* port C control/port select */
	uint8_t   m_mc;     /* port C input or output mask */
	uint8_t   m_mm;     /* memory mapping */
	uint8_t   m_mf;     /* port F input or output mask */
	uint8_t   m_tmm;    /* timer 0 and timer 1 operating parameters */
	uint8_t   m_etmm;   /* 16-bit multifunction timer/event counter */
	uint8_t   m_eom;    /* 16-bit timer/event counter output control */
	uint8_t   m_sml;    /* serial interface parameters low */
	uint8_t   m_smh;    /* -"- high */
	uint8_t   m_panm;   /* previous analog to digital converter operating parameters */
	uint8_t   m_anm;    /* analog to digital converter operating parameters */
	uint8_t   m_mkl;    /* interrupt mask low */
	uint8_t   m_mkh;    /* -"- high */
	uint8_t   m_zcm;    /* bias circuitry for ac zero-cross detection */
	uint8_t   m_pa_in;  /* port A,B,C,D,F inputs */
	uint8_t   m_pb_in;
	uint8_t   m_pc_in;
	uint8_t   m_pd_in;
	uint8_t   m_pf_in;
	uint8_t   m_pa_out; /* port A,B,C,D,F outputs */
	uint8_t   m_pb_out;
	uint8_t   m_pc_out;
	uint8_t   m_pd_out;
	uint8_t   m_pf_out;
	uint8_t   m_cr0;    /* analog digital conversion register 0 */
	uint8_t   m_cr1;    /* analog digital conversion register 1 */
	uint8_t   m_cr2;    /* analog digital conversion register 2 */
	uint8_t   m_cr3;    /* analog digital conversion register 3 */
	uint8_t   m_txb;    /* transmitter buffer */
	uint8_t   m_rxb;    /* receiver buffer */
	uint8_t   m_txd;    /* port C control line states */
	uint8_t   m_rxd;
	uint8_t   m_sck;
	uint8_t   m_ti;
	uint8_t   m_to;
	uint8_t   m_ci;
	uint8_t   m_lv0;    /* level flip flop for co0 */
	uint8_t   m_lv1;    /* level flip flop for co1 */
	uint8_t   m_co0;
	uint8_t   m_co1;
	uint16_t  m_irr;    /* interrupt request register */
	uint16_t  m_itf;    /* interrupt test flag register */
	int     m_nmi;    /* keep track of current nmi state. Needed for 7810 irq checking. */
	int     m_int1;   /* keep track of current int1 state. Needed for irq checking. */
	int     m_int2;   /* keep track to current int2 state. Needed for irq checking. */

	/* internal helper variables */
	uint16_t  m_txs;    /* transmitter shift register */
	uint16_t  m_rxs;    /* receiver shift register */
	uint8_t   m_txcnt;  /* transmitter shift register bit count */
	uint8_t   m_rxcnt;  /* receiver shift register bit count */
	uint8_t   m_txbuf;  /* transmitter buffer was written */
	int32_t   m_ovc0;   /* overflow counter for timer 0 (for clock div 12/384) */
	int32_t   m_ovc1;   /* overflow counter for timer 0 (for clock div 12/384) */
	int32_t   m_ovce;   /* overflow counter for ecnt */
	int32_t   m_ovcf;   /* overflow counter for fixed clock div 3 mode */
	int32_t   m_ovcs;   /* overflow counter for serial I/O */
	uint8_t   m_edges;  /* rising/falling edge flag for serial I/O */
	uint16_t  m_adcnt;  /* A/D converter cycle count */
	uint8_t   m_adtot;  /* A/D converter total cycles per conversion */
	uint8_t   m_tmpcr;  /* temporary analog digital conversion register */
	int     m_shdone; /* A/D converter sample and hold done */
	int     m_adout;  /* currently selected A/D converter output register */
	int     m_adin;   /* currently selected A/D converter input */
	int     m_adrange;/* in scan mode, A/D converter range (AN0-AN3 or AN4-AN7) */

	const struct opcode_s *m_opXX;    /* opcode table */
	const struct opcode_s *m_op48;
	const struct opcode_s *m_op4C;
	const struct opcode_s *m_op4D;
	const struct opcode_s *m_op60;
	const struct opcode_s *m_op64;
	const struct opcode_s *m_op70;
	const struct opcode_s *m_op74;
	address_space *m_program;
	memory_access_cache<0, 0, ENDIANNESS_LITTLE> *m_cache;
	int m_icount;

	uint8_t RP(offs_t port);
	void WP(offs_t port, uint8_t data);
	void upd7810_write_EOM();
	void upd7810_write_TXB();
	void upd7810_sio_output();
	void upd7810_sio_input();
	void illegal();
	void illegal2();
	void SLRC_A();
	void SLRC_B();
	void SLRC_C();
	void SLLC_A();
	void SLLC_B();
	void SLLC_C();
	void SK_NV();
	void SK_CY();
	void SK_HC();
	void SK_Z();
	void SKN_NV();
	void SKN_CY();
	void SKN_HC();
	void SKN_Z();
	void SLR_A();
	void SLR_B();
	void SLR_C();
	void SLL_A();
	void SLL_B();
	void SLL_C();
	void JEA();
	void CALB();
	void CLC();
	void STC();
	void MUL_A();
	void MUL_B();
	void MUL_C();
	void RLR_A();
	void RLR_B();
	void RLR_C();
	void RLL_A();
	void RLL_B();
	void RLL_C();
	void RLD();
	void RRD();
	void NEGA();
	void HALT();
	void DIV_A();
	void DIV_B();
	void DIV_C();
	void SKIT_NMI();
	void SKIT_FT0();
	void SKIT_FT1();
	void SKIT_F1();
	void SKIT_F2();
	void SKIT_FE0();
	void SKIT_FE1();
	void SKIT_FEIN();
	void SKIT_FAD();
	void SKIT_FSR();
	void SKIT_FST();
	void SKIT_ER();
	void SKIT_OV();
	void SKIT_AN4();
	void SKIT_AN5();
	void SKIT_AN6();
	void SKIT_AN7();
	void SKIT_SB();
	void SKNIT_NMI();
	void SKNIT_FT0();
	void SKNIT_FT1();
	void SKNIT_F1();
	void SKNIT_F2();
	void SKNIT_FE0();
	void SKNIT_FE1();
	void SKNIT_FEIN();
	void SKNIT_FAD();
	void SKNIT_FSR();
	void SKNIT_FST();
	void SKNIT_ER();
	void SKNIT_OV();
	void SKNIT_AN4();
	void SKNIT_AN5();
	void SKNIT_AN6();
	void SKNIT_AN7();
	void SKNIT_SB();
	void LDEAX_D();
	void LDEAX_H();
	void LDEAX_Dp();
	void LDEAX_Hp();
	void LDEAX_D_xx();
	void LDEAX_H_A();
	void LDEAX_H_B();
	void LDEAX_H_EA();
	void LDEAX_H_xx();
	void STEAX_D();
	void STEAX_H();
	void STEAX_Dp();
	void STEAX_Hp();
	void STEAX_D_xx();
	void STEAX_H_A();
	void STEAX_H_B();
	void STEAX_H_EA();
	void STEAX_H_xx();
	void DSLR_EA();
	void DSLL_EA();
	void TABLE();
	void DRLR_EA();
	void DRLL_EA();
	void STOP();
	void DMOV_EA_ECNT();
	void DMOV_EA_ECPT();
	void DMOV_ETM0_EA();
	void DMOV_ETM1_EA();
	void MOV_A_PA();
	void MOV_A_PB();
	void MOV_A_PC();
	void MOV_A_PD();
	void MOV_A_PF();
	void MOV_A_MKH();
	void MOV_A_MKL();
	void MOV_A_ANM();
	void MOV_A_SMH();
	void MOV_A_EOM();
	void MOV_A_TMM();
	void MOV_A_PT();
	void MOV_A_RXB();
	void MOV_A_CR0();
	void MOV_A_CR1();
	void MOV_A_CR2();
	void MOV_A_CR3();
	void MOV_PA_A();
	void MOV_PB_A();
	void MOV_PC_A();
	void MOV_PD_A();
	void MOV_PF_A();
	void MOV_MKH_A();
	void MOV_MKL_A();
	void MOV_ANM_A();
	void MOV_SMH_A();
	void MOV_SML_A();
	void MOV_EOM_A();
	void MOV_ETMM_A();
	void MOV_TMM_A();
	void MOV_MM_A();
	void MOV_MCC_A();
	void MOV_MA_A();
	void MOV_MB_A();
	void MOV_MC_A();
	void MOV_MF_A();
	void MOV_TXB_A();
	void MOV_TM0_A();
	void MOV_TM1_A();
	void MOV_ZCM_A();
	void ANA_V_A();
	void ANA_A_A();
	void ANA_B_A();
	void ANA_C_A();
	void ANA_D_A();
	void ANA_E_A();
	void ANA_H_A();
	void ANA_L_A();
	void XRA_V_A();
	void XRA_A_A();
	void XRA_B_A();
	void XRA_C_A();
	void XRA_D_A();
	void XRA_E_A();
	void XRA_H_A();
	void XRA_L_A();
	void ORA_V_A();
	void ORA_A_A();
	void ORA_B_A();
	void ORA_C_A();
	void ORA_D_A();
	void ORA_E_A();
	void ORA_H_A();
	void ORA_L_A();
	void ADDNC_V_A();
	void ADDNC_A_A();
	void ADDNC_B_A();
	void ADDNC_C_A();
	void ADDNC_D_A();
	void ADDNC_E_A();
	void ADDNC_H_A();
	void ADDNC_L_A();
	void GTA_V_A();
	void GTA_A_A();
	void GTA_B_A();
	void GTA_C_A();
	void GTA_D_A();
	void GTA_E_A();
	void GTA_H_A();
	void GTA_L_A();
	void SUBNB_V_A();
	void SUBNB_A_A();
	void SUBNB_B_A();
	void SUBNB_C_A();
	void SUBNB_D_A();
	void SUBNB_E_A();
	void SUBNB_H_A();
	void SUBNB_L_A();
	void LTA_V_A();
	void LTA_A_A();
	void LTA_B_A();
	void LTA_C_A();
	void LTA_D_A();
	void LTA_E_A();
	void LTA_H_A();
	void LTA_L_A();
	void ADD_V_A();
	void ADD_A_A();
	void ADD_B_A();
	void ADD_C_A();
	void ADD_D_A();
	void ADD_E_A();
	void ADD_H_A();
	void ADD_L_A();
	void ADC_V_A();
	void ADC_A_A();
	void ADC_B_A();
	void ADC_C_A();
	void ADC_D_A();
	void ADC_E_A();
	void ADC_H_A();
	void ADC_L_A();
	void SUB_V_A();
	void SUB_A_A();
	void SUB_B_A();
	void SUB_C_A();
	void SUB_D_A();
	void SUB_E_A();
	void SUB_H_A();
	void SUB_L_A();
	void NEA_V_A();
	void NEA_A_A();
	void NEA_B_A();
	void NEA_C_A();
	void NEA_D_A();
	void NEA_E_A();
	void NEA_H_A();
	void NEA_L_A();
	void SBB_V_A();
	void SBB_A_A();
	void SBB_B_A();
	void SBB_C_A();
	void SBB_D_A();
	void SBB_E_A();
	void SBB_H_A();
	void SBB_L_A();
	void EQA_V_A();
	void EQA_A_A();
	void EQA_B_A();
	void EQA_C_A();
	void EQA_D_A();
	void EQA_E_A();
	void EQA_H_A();
	void EQA_L_A();
	void ANA_A_V();
	void ANA_A_B();
	void ANA_A_C();
	void ANA_A_D();
	void ANA_A_E();
	void ANA_A_H();
	void ANA_A_L();
	void XRA_A_V();
	void XRA_A_B();
	void XRA_A_C();
	void XRA_A_D();
	void XRA_A_E();
	void XRA_A_H();
	void XRA_A_L();
	void ORA_A_V();
	void ORA_A_B();
	void ORA_A_C();
	void ORA_A_D();
	void ORA_A_E();
	void ORA_A_H();
	void ORA_A_L();
	void ADDNC_A_V();
	void ADDNC_A_B();
	void ADDNC_A_C();
	void ADDNC_A_D();
	void ADDNC_A_E();
	void ADDNC_A_H();
	void ADDNC_A_L();
	void GTA_A_V();
	void GTA_A_B();
	void GTA_A_C();
	void GTA_A_D();
	void GTA_A_E();
	void GTA_A_H();
	void GTA_A_L();
	void SUBNB_A_V();
	void SUBNB_A_B();
	void SUBNB_A_C();
	void SUBNB_A_D();
	void SUBNB_A_E();
	void SUBNB_A_H();
	void SUBNB_A_L();
	void LTA_A_V();
	void LTA_A_B();
	void LTA_A_C();
	void LTA_A_D();
	void LTA_A_E();
	void LTA_A_H();
	void LTA_A_L();
	void ADD_A_V();
	void ADD_A_B();
	void ADD_A_C();
	void ADD_A_D();
	void ADD_A_E();
	void ADD_A_H();
	void ADD_A_L();
	void ONA_A_V();
	void ONA_A_A();
	void ONA_A_B();
	void ONA_A_C();
	void ONA_A_D();
	void ONA_A_E();
	void ONA_A_H();
	void ONA_A_L();
	void ADC_A_V();
	void ADC_A_B();
	void ADC_A_C();
	void ADC_A_D();
	void ADC_A_E();
	void ADC_A_H();
	void ADC_A_L();
	void OFFA_A_V();
	void OFFA_A_A();
	void OFFA_A_B();
	void OFFA_A_C();
	void OFFA_A_D();
	void OFFA_A_E();
	void OFFA_A_H();
	void OFFA_A_L();
	void SUB_A_V();
	void SUB_A_B();
	void SUB_A_C();
	void SUB_A_D();
	void SUB_A_E();
	void SUB_A_H();
	void SUB_A_L();
	void NEA_A_V();
	void NEA_A_B();
	void NEA_A_C();
	void NEA_A_D();
	void NEA_A_E();
	void NEA_A_H();
	void NEA_A_L();
	void SBB_A_V();
	void SBB_A_B();
	void SBB_A_C();
	void SBB_A_D();
	void SBB_A_E();
	void SBB_A_H();
	void SBB_A_L();
	void EQA_A_V();
	void EQA_A_B();
	void EQA_A_C();
	void EQA_A_D();
	void EQA_A_E();
	void EQA_A_H();
	void EQA_A_L();
	void MVI_PA_xx();
	void MVI_PB_xx();
	void MVI_PC_xx();
	void MVI_PD_xx();
	void MVI_PF_xx();
	void MVI_MKH_xx();
	void MVI_MKL_xx();
	void ANI_PA_xx();
	void ANI_PB_xx();
	void ANI_PC_xx();
	void ANI_PD_xx();
	void ANI_PF_xx();
	void ANI_MKH_xx();
	void ANI_MKL_xx();
	void XRI_PA_xx();
	void XRI_PB_xx();
	void XRI_PC_xx();
	void XRI_PD_xx();
	void XRI_PF_xx();
	void XRI_MKH_xx();
	void XRI_MKL_xx();
	void ORI_PA_xx();
	void ORI_PB_xx();
	void ORI_PC_xx();
	void ORI_PD_xx();
	void ORI_PF_xx();
	void ORI_MKH_xx();
	void ORI_MKL_xx();
	void ADINC_PA_xx();
	void ADINC_PB_xx();
	void ADINC_PC_xx();
	void ADINC_PD_xx();
	void ADINC_PF_xx();
	void ADINC_MKH_xx();
	void ADINC_MKL_xx();
	void GTI_PA_xx();
	void GTI_PB_xx();
	void GTI_PC_xx();
	void GTI_PD_xx();
	void GTI_PF_xx();
	void GTI_MKH_xx();
	void GTI_MKL_xx();
	void SUINB_PA_xx();
	void SUINB_PB_xx();
	void SUINB_PC_xx();
	void SUINB_PD_xx();
	void SUINB_PF_xx();
	void SUINB_MKH_xx();
	void SUINB_MKL_xx();
	void LTI_PA_xx();
	void LTI_PB_xx();
	void LTI_PC_xx();
	void LTI_PD_xx();
	void LTI_PF_xx();
	void LTI_MKH_xx();
	void LTI_MKL_xx();
	void ADI_PA_xx();
	void ADI_PB_xx();
	void ADI_PC_xx();
	void ADI_PD_xx();
	void ADI_PF_xx();
	void ADI_MKH_xx();
	void ADI_MKL_xx();
	void ONI_PA_xx();
	void ONI_PB_xx();
	void ONI_PC_xx();
	void ONI_PD_xx();
	void ONI_PF_xx();
	void ONI_MKH_xx();
	void ONI_MKL_xx();
	void ACI_PA_xx();
	void ACI_PB_xx();
	void ACI_PC_xx();
	void ACI_PD_xx();
	void ACI_PF_xx();
	void ACI_MKH_xx();
	void ACI_MKL_xx();
	void OFFI_PA_xx();
	void OFFI_PB_xx();
	void OFFI_PC_xx();
	void OFFI_PD_xx();
	void OFFI_PF_xx();
	void OFFI_MKH_xx();
	void OFFI_MKL_xx();
	void SUI_PA_xx();
	void SUI_PB_xx();
	void SUI_PC_xx();
	void SUI_PD_xx();
	void SUI_PF_xx();
	void SUI_MKH_xx();
	void SUI_MKL_xx();
	void NEI_PA_xx();
	void NEI_PB_xx();
	void NEI_PC_xx();
	void NEI_PD_xx();
	void NEI_PF_xx();
	void NEI_MKH_xx();
	void NEI_MKL_xx();
	void SBI_PA_xx();
	void SBI_PB_xx();
	void SBI_PC_xx();
	void SBI_PD_xx();
	void SBI_PF_xx();
	void SBI_MKH_xx();
	void SBI_MKL_xx();
	void EQI_PA_xx();
	void EQI_PB_xx();
	void EQI_PC_xx();
	void EQI_PD_xx();
	void EQI_PF_xx();
	void EQI_MKH_xx();
	void EQI_MKL_xx();
	void MVI_ANM_xx();
	void MVI_SMH_xx();
	void MVI_EOM_xx();
	void MVI_TMM_xx();
	void ANI_ANM_xx();
	void ANI_SMH_xx();
	void ANI_EOM_xx();
	void ANI_TMM_xx();
	void XRI_ANM_xx();
	void XRI_SMH_xx();
	void XRI_EOM_xx();
	void XRI_TMM_xx();
	void ORI_ANM_xx();
	void ORI_SMH_xx();
	void ORI_EOM_xx();
	void ORI_TMM_xx();
	void ADINC_ANM_xx();
	void ADINC_SMH_xx();
	void ADINC_EOM_xx();
	void ADINC_TMM_xx();
	void GTI_ANM_xx();
	void GTI_SMH_xx();
	void GTI_EOM_xx();
	void GTI_TMM_xx();
	void SUINB_ANM_xx();
	void SUINB_SMH_xx();
	void SUINB_EOM_xx();
	void SUINB_TMM_xx();
	void LTI_ANM_xx();
	void LTI_SMH_xx();
	void LTI_EOM_xx();
	void LTI_TMM_xx();
	void ADI_ANM_xx();
	void ADI_SMH_xx();
	void ADI_EOM_xx();
	void ADI_TMM_xx();
	void ONI_ANM_xx();
	void ONI_SMH_xx();
	void ONI_EOM_xx();
	void ONI_TMM_xx();
	void ACI_ANM_xx();
	void ACI_SMH_xx();
	void ACI_EOM_xx();
	void ACI_TMM_xx();
	void OFFI_ANM_xx();
	void OFFI_SMH_xx();
	void OFFI_EOM_xx();
	void OFFI_TMM_xx();
	void SUI_ANM_xx();
	void SUI_SMH_xx();
	void SUI_EOM_xx();
	void SUI_TMM_xx();
	void NEI_ANM_xx();
	void NEI_SMH_xx();
	void NEI_EOM_xx();
	void NEI_TMM_xx();
	void SBI_ANM_xx();
	void SBI_SMH_xx();
	void SBI_EOM_xx();
	void SBI_TMM_xx();
	void EQI_ANM_xx();
	void EQI_SMH_xx();
	void EQI_EOM_xx();
	void EQI_TMM_xx();
	void SSPD_w();
	void LSPD_w();
	void SBCD_w();
	void LBCD_w();
	void SDED_w();
	void LDED_w();
	void SHLD_w();
	void LHLD_w();
	void EADD_EA_A();
	void EADD_EA_B();
	void EADD_EA_C();
	void ESUB_EA_A();
	void ESUB_EA_B();
	void ESUB_EA_C();
	void MOV_V_w();
	void MOV_A_w();
	void MOV_B_w();
	void MOV_C_w();
	void MOV_D_w();
	void MOV_E_w();
	void MOV_H_w();
	void MOV_L_w();
	void MOV_w_V();
	void MOV_w_A();
	void MOV_w_B();
	void MOV_w_C();
	void MOV_w_D();
	void MOV_w_E();
	void MOV_w_H();
	void MOV_w_L();
	void ANAX_B();
	void ANAX_D();
	void ANAX_H();
	void ANAX_Dp();
	void ANAX_Hp();
	void ANAX_Dm();
	void ANAX_Hm();
	void XRAX_B();
	void XRAX_D();
	void XRAX_H();
	void XRAX_Dp();
	void XRAX_Hp();
	void XRAX_Dm();
	void XRAX_Hm();
	void ORAX_B();
	void ORAX_D();
	void ORAX_H();
	void ORAX_Dp();
	void ORAX_Hp();
	void ORAX_Dm();
	void ORAX_Hm();
	void ADDNCX_B();
	void ADDNCX_D();
	void ADDNCX_H();
	void ADDNCX_Dp();
	void ADDNCX_Hp();
	void ADDNCX_Dm();
	void ADDNCX_Hm();
	void GTAX_B();
	void GTAX_D();
	void GTAX_H();
	void GTAX_Dp();
	void GTAX_Hp();
	void GTAX_Dm();
	void GTAX_Hm();
	void SUBNBX_B();
	void SUBNBX_D();
	void SUBNBX_H();
	void SUBNBX_Dp();
	void SUBNBX_Hp();
	void SUBNBX_Dm();
	void SUBNBX_Hm();
	void LTAX_B();
	void LTAX_D();
	void LTAX_H();
	void LTAX_Dp();
	void LTAX_Hp();
	void LTAX_Dm();
	void LTAX_Hm();
	void ADDX_B();
	void ADDX_D();
	void ADDX_H();
	void ADDX_Dp();
	void ADDX_Hp();
	void ADDX_Dm();
	void ADDX_Hm();
	void ONAX_B();
	void ONAX_D();
	void ONAX_H();
	void ONAX_Dp();
	void ONAX_Hp();
	void ONAX_Dm();
	void ONAX_Hm();
	void ADCX_B();
	void ADCX_D();
	void ADCX_H();
	void ADCX_Dp();
	void ADCX_Hp();
	void ADCX_Dm();
	void ADCX_Hm();
	void OFFAX_B();
	void OFFAX_D();
	void OFFAX_H();
	void OFFAX_Dp();
	void OFFAX_Hp();
	void OFFAX_Dm();
	void OFFAX_Hm();
	void SUBX_B();
	void SUBX_D();
	void SUBX_H();
	void SUBX_Dp();
	void SUBX_Hp();
	void SUBX_Dm();
	void SUBX_Hm();
	void NEAX_B();
	void NEAX_D();
	void NEAX_H();
	void NEAX_Dp();
	void NEAX_Hp();
	void NEAX_Dm();
	void NEAX_Hm();
	void SBBX_B();
	void SBBX_D();
	void SBBX_H();
	void SBBX_Dp();
	void SBBX_Hp();
	void SBBX_Dm();
	void SBBX_Hm();
	void EQAX_B();
	void EQAX_D();
	void EQAX_H();
	void EQAX_Dp();
	void EQAX_Hp();
	void EQAX_Dm();
	void EQAX_Hm();
	void ANI_V_xx();
	void ANI_A_xx();
	void ANI_B_xx();
	void ANI_C_xx();
	void ANI_D_xx();
	void ANI_E_xx();
	void ANI_H_xx();
	void ANI_L_xx();
	void XRI_V_xx();
	void XRI_A_xx();
	void XRI_B_xx();
	void XRI_C_xx();
	void XRI_D_xx();
	void XRI_E_xx();
	void XRI_H_xx();
	void XRI_L_xx();
	void ORI_V_xx();
	void ORI_A_xx();
	void ORI_B_xx();
	void ORI_C_xx();
	void ORI_D_xx();
	void ORI_E_xx();
	void ORI_H_xx();
	void ORI_L_xx();
	void ADINC_V_xx();
	void ADINC_A_xx();
	void ADINC_B_xx();
	void ADINC_C_xx();
	void ADINC_D_xx();
	void ADINC_E_xx();
	void ADINC_H_xx();
	void ADINC_L_xx();
	void GTI_V_xx();
	void GTI_A_xx();
	void GTI_B_xx();
	void GTI_C_xx();
	void GTI_D_xx();
	void GTI_E_xx();
	void GTI_H_xx();
	void GTI_L_xx();
	void SUINB_V_xx();
	void SUINB_A_xx();
	void SUINB_B_xx();
	void SUINB_C_xx();
	void SUINB_D_xx();
	void SUINB_E_xx();
	void SUINB_H_xx();
	void SUINB_L_xx();
	void LTI_V_xx();
	void LTI_A_xx();
	void LTI_B_xx();
	void LTI_C_xx();
	void LTI_D_xx();
	void LTI_E_xx();
	void LTI_H_xx();
	void LTI_L_xx();
	void ADI_V_xx();
	void ADI_A_xx();
	void ADI_B_xx();
	void ADI_C_xx();
	void ADI_D_xx();
	void ADI_E_xx();
	void ADI_H_xx();
	void ADI_L_xx();
	void ONI_V_xx();
	void ONI_A_xx();
	void ONI_B_xx();
	void ONI_C_xx();
	void ONI_D_xx();
	void ONI_E_xx();
	void ONI_H_xx();
	void ONI_L_xx();
	void ACI_V_xx();
	void ACI_A_xx();
	void ACI_B_xx();
	void ACI_C_xx();
	void ACI_D_xx();
	void ACI_E_xx();
	void ACI_H_xx();
	void ACI_L_xx();
	void OFFI_V_xx();
	void OFFI_A_xx();
	void OFFI_B_xx();
	void OFFI_C_xx();
	void OFFI_D_xx();
	void OFFI_E_xx();
	void OFFI_H_xx();
	void OFFI_L_xx();
	void SUI_V_xx();
	void SUI_A_xx();
	void SUI_B_xx();
	void SUI_C_xx();
	void SUI_D_xx();
	void SUI_E_xx();
	void SUI_H_xx();
	void SUI_L_xx();
	void NEI_V_xx();
	void NEI_A_xx();
	void NEI_B_xx();
	void NEI_C_xx();
	void NEI_D_xx();
	void NEI_E_xx();
	void NEI_H_xx();
	void NEI_L_xx();
	void SBI_V_xx();
	void SBI_A_xx();
	void SBI_B_xx();
	void SBI_C_xx();
	void SBI_D_xx();
	void SBI_E_xx();
	void SBI_H_xx();
	void SBI_L_xx();
	void EQI_V_xx();
	void EQI_A_xx();
	void EQI_B_xx();
	void EQI_C_xx();
	void EQI_D_xx();
	void EQI_E_xx();
	void EQI_H_xx();
	void EQI_L_xx();
	void ANAW_wa();
	void DAN_EA_BC();
	void DAN_EA_DE();
	void DAN_EA_HL();
	void XRAW_wa();
	void DXR_EA_BC();
	void DXR_EA_DE();
	void DXR_EA_HL();
	void ORAW_wa();
	void DOR_EA_BC();
	void DOR_EA_DE();
	void DOR_EA_HL();
	void ADDNCW_wa();
	void DADDNC_EA_BC();
	void DADDNC_EA_DE();
	void DADDNC_EA_HL();
	void GTAW_wa();
	void DGT_EA_BC();
	void DGT_EA_DE();
	void DGT_EA_HL();
	void SUBNBW_wa();
	void DSUBNB_EA_BC();
	void DSUBNB_EA_DE();
	void DSUBNB_EA_HL();
	void LTAW_wa();
	void DLT_EA_BC();
	void DLT_EA_DE();
	void DLT_EA_HL();
	void ADDW_wa();
	void DADD_EA_BC();
	void DADD_EA_DE();
	void DADD_EA_HL();
	void ONAW_wa();
	void DON_EA_BC();
	void DON_EA_DE();
	void DON_EA_HL();
	void ADCW_wa();
	void DADC_EA_BC();
	void DADC_EA_DE();
	void DADC_EA_HL();
	void OFFAW_wa();
	void DOFF_EA_BC();
	void DOFF_EA_DE();
	void DOFF_EA_HL();
	void SUBW_wa();
	void DSUB_EA_BC();
	void DSUB_EA_DE();
	void DSUB_EA_HL();
	void NEAW_wa();
	void DNE_EA_BC();
	void DNE_EA_DE();
	void DNE_EA_HL();
	void SBBW_wa();
	void DSBB_EA_BC();
	void DSBB_EA_DE();
	void DSBB_EA_HL();
	void EQAW_wa();
	void DEQ_EA_BC();
	void DEQ_EA_DE();
	void DEQ_EA_HL();
	void NOP();
	void LDAW_wa();
	void INX_SP();
	void DCX_SP();
	void LXI_S_w();
	void ANIW_wa_xx();
	void MOV_A_EAH();
	void MOV_A_EAL();
	void MOV_A_B();
	void MOV_A_C();
	void MOV_A_D();
	void MOV_A_E();
	void MOV_A_H();
	void MOV_A_L();
	void EXA();
	void EXX();
	void EXR();
	void INX_BC();
	void DCX_BC();
	void LXI_B_w();
	void ORIW_wa_xx();
	void MOV_EAH_A();
	void MOV_EAL_A();
	void MOV_B_A();
	void MOV_C_A();
	void MOV_D_A();
	void MOV_E_A();
	void MOV_H_A();
	void MOV_L_A();
	void INRW_wa();
	void JB();
	void INX_DE();
	void DCX_DE();
	void LXI_D_w();
	void GTIW_wa_xx();
	void LDAX_B();
	void LDAX_D();
	void LDAX_H();
	void LDAX_Dp();
	void LDAX_Hp();
	void LDAX_Dm();
	void LDAX_Hm();
	void DCRW_wa();
	void BLOCK();
	void INX_HL();
	void DCX_HL();
	void LXI_H_w();
	void LTIW_wa_xx();
	void STAX_B();
	void STAX_D();
	void STAX_H();
	void STAX_Dp();
	void STAX_Hp();
	void STAX_Dm();
	void STAX_Hm();
	void CALL_w();
	void INR_A();
	void INR_B();
	void INR_C();
	void LXI_EA_s();
	void ONIW_wa_xx();
	void PRE_48();
	void MVIX_BC_xx();
	void MVIX_DE_xx();
	void MVIX_HL_xx();
	void PRE_4C();
	void PRE_4D();
	void JRE();
	void EXH();
	void DCR_A();
	void DCR_B();
	void DCR_C();
	void JMP_w();
	void OFFIW_wa_xx();
	void BIT_0_wa();
	void BIT_1_wa();
	void BIT_2_wa();
	void BIT_3_wa();
	void BIT_4_wa();
	void BIT_5_wa();
	void BIT_6_wa();
	void BIT_7_wa();
	void SKN_bit();
	void SETB();
	void CLR();
	void SK_bit();
	void PRE_60();
	void DAA();
	void RETI();
	void STAW_wa();
	void PRE_64();
	void NEIW_wa_xx();
	void MVI_V_xx();
	void MVI_A_xx();
	void MVI_B_xx();
	void MVI_C_xx();
	void MVI_D_xx();
	void MVI_E_xx();
	void MVI_H_xx();
	void MVI_L_xx();
	void PRE_70();
	void MVIW_wa_xx();
	void SOFTI();
	void PRE_74();
	void EQIW_wa_xx();
	void CALF();
	void CALT();
	void POP_VA();
	void POP_BC();
	void POP_DE();
	void POP_HL();
	void POP_EA();
	void DMOV_EA_BC();
	void DMOV_EA_DE();
	void DMOV_EA_HL();
	void INX_EA();
	void DCX_EA();
	void EI();
	void LDAX_D_xx();
	void LDAX_H_A();
	void LDAX_H_B();
	void LDAX_H_EA();
	void LDAX_H_xx();
	void PUSH_VA();
	void PUSH_BC();
	void PUSH_DE();
	void PUSH_HL();
	void PUSH_EA();
	void DMOV_BC_EA();
	void DMOV_DE_EA();
	void DMOV_HL_EA();
	void RET();
	void RETS();
	void DI();
	void STAX_D_xx();
	void STAX_H_A();
	void STAX_H_B();
	void STAX_H_EA();
	void STAX_H_xx();
	void JR();
	void CALT_7801();
	void DCR_A_7801();
	void DCR_B_7801();
	void DCR_C_7801();
	void DCRW_wa_7801();
	void INR_A_7801();
	void INR_B_7801();
	void INR_C_7801();
	void INRW_wa_7801();
	void IN();
	void OUT();
	void MOV_A_S();
	void MOV_S_A();
	void PEN();
	void PER();
	void PEX();
	void SIO();
	void SKIT_F0();
	void SKNIT_F0();
	void STM();
	void STM_7801();
	void MOV_MC_A_7801();
	void base_device_start();
};


class upd7807_device : public upd7810_device
{
public:
	// construction/destruction
	upd7807_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);

protected:
	virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;
	virtual void configure_ops() override;
};


class upd7801_device : public upd7810_device
{
public:
	// construction/destruction
	upd7801_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);

protected:
	virtual void device_reset() override;
	virtual void execute_set_input(int inputnum, int state) override;
	virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;
	virtual void handle_timers(int cycles) override;
	virtual void upd7810_take_irq() override;
	virtual void configure_ops() override;
};


class upd78c05_device : public upd7810_device
{
public:
	// construction/destruction
	upd78c05_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);

protected:
	upd78c05_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);

	virtual void device_start() override;
	virtual void device_reset() override;
	virtual uint64_t execute_clocks_to_cycles(uint64_t clocks) const override { return (clocks + 4 - 1) / 4; }
	virtual uint64_t execute_cycles_to_clocks(uint64_t cycles) const override { return (cycles * 4); }
	virtual std::unique_ptr<util::disasm_interface> create_disassembler() override;
	virtual void handle_timers(int cycles) override;
	virtual void configure_ops() override;
};


class upd78c06_device : public upd78c05_device
{
public:
	// construction/destruction
	upd78c06_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
	virtual void configure_ops() override;
};


DECLARE_DEVICE_TYPE(UPD7810,  upd7810_device)
DECLARE_DEVICE_TYPE(UPD7807,  upd7807_device)
DECLARE_DEVICE_TYPE(UPD7801,  upd7801_device)
DECLARE_DEVICE_TYPE(UPD78C05, upd78c05_device)
DECLARE_DEVICE_TYPE(UPD78C06, upd78c06_device)

#endif // MAME_CPU_UPD7810_UPD7810_H