1 /**********************************************************************************************
2 *
3 * streaming ADPCM driver
4 * by Aaron Giles
5 *
6 * Library to transcode from an ADPCM source to raw PCM.
7 * Written by Buffoni Mirko in 08/06/97
8 * References: various sources and documents.
9 *
10 * HJB 08/31/98
11 * modified to use an automatically selected oversampling factor
12 * for the current Machine->sample_rate
13 *
14 * Mish 21/7/99
15 * Updated to allow multiple OKI chips with different sample rates
16 *
17 **********************************************************************************************/
18
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <math.h>
23
24 #include "driver.h"
25 #include "adpcm.h"
26
27
28 #define MAX_SAMPLE_CHUNK 10000
29
30 #define FRAC_BITS 14
31 #define FRAC_ONE (1 << FRAC_BITS)
32 #define FRAC_MASK (FRAC_ONE - 1)
33
34
35 /* struct describing a single playing ADPCM voice */
36 struct ADPCMVoice
37 {
38 int stream; /* which stream are we playing on? */
39 UINT8 playing; /* 1 if we are actively playing */
40
41 UINT8 *region_base; /* pointer to the base of the region */
42 UINT8 *base; /* pointer to the base memory location */
43 UINT32 sample; /* current sample number */
44 UINT32 count; /* total samples to play */
45
46 UINT32 signal; /* current ADPCM signal */
47 UINT32 step; /* current ADPCM step */
48 UINT32 volume; /* output volume */
49
50 INT16 last_sample; /* last sample output */
51 INT16 curr_sample; /* current sample target */
52 UINT32 source_step; /* step value for frequency conversion */
53 UINT32 source_pos; /* current fractional position */
54 };
55
56 /* array of ADPCM voices */
57 static UINT8 num_voices;
58 static struct ADPCMVoice adpcm[MAX_ADPCM];
59
60 /* global pointer to the current array of samples */
61 static struct ADPCMsample *sample_list;
62
63 /* step size index shift table */
64 static int index_shift[8] = { -1, -1, -1, -1, 2, 4, 6, 8 };
65
66 /* lookup table for the precomputed difference */
67 static int diff_lookup[49*16];
68
69 /* volume lookup table */
70 static UINT32 volume_table[16];
71
72
73
74 /**********************************************************************************************
75
76 compute_tables -- compute the difference tables
77
78 ***********************************************************************************************/
79
compute_tables(void)80 static void compute_tables(void)
81 {
82 /* nibble to bit map */
83 static int nbl2bit[16][4] =
84 {
85 { 1, 0, 0, 0}, { 1, 0, 0, 1}, { 1, 0, 1, 0}, { 1, 0, 1, 1},
86 { 1, 1, 0, 0}, { 1, 1, 0, 1}, { 1, 1, 1, 0}, { 1, 1, 1, 1},
87 {-1, 0, 0, 0}, {-1, 0, 0, 1}, {-1, 0, 1, 0}, {-1, 0, 1, 1},
88 {-1, 1, 0, 0}, {-1, 1, 0, 1}, {-1, 1, 1, 0}, {-1, 1, 1, 1}
89 };
90
91 int step, nib;
92
93 /* loop over all possible steps */
94 for (step = 0; step <= 48; step++)
95 {
96 /* compute the step value */
97 int stepval = floor(16.0 * pow(11.0 / 10.0, (float)step));
98
99 /* loop over all nibbles and compute the difference */
100 for (nib = 0; nib < 16; nib++)
101 {
102 diff_lookup[step*16 + nib] = nbl2bit[nib][0] *
103 (stepval * nbl2bit[nib][1] +
104 stepval/2 * nbl2bit[nib][2] +
105 stepval/4 * nbl2bit[nib][3] +
106 stepval/8);
107 }
108 }
109
110 /* generate the OKI6295 volume table */
111 for (step = 0; step < 16; step++)
112 {
113 float out = 256.0;
114 int vol = step;
115
116 /* 3dB per step */
117 while (vol-- > 0)
118 out /= 1.412537545; /* = 10 ^ (3/20) = 3dB */
119 volume_table[step] = (UINT32)out;
120 }
121 }
122
123
124
125 /**********************************************************************************************
126
127 generate_adpcm -- general ADPCM decoding routine
128
129 ***********************************************************************************************/
130
generate_adpcm(struct ADPCMVoice * voice,INT16 * buffer,int samples)131 static void generate_adpcm(struct ADPCMVoice *voice, INT16 *buffer, int samples)
132 {
133 /* if this voice is active */
134 if (voice->playing)
135 {
136 UINT8 *base = voice->base;
137 int sample = voice->sample;
138 int signal = voice->signal;
139 int count = voice->count;
140 int step = voice->step;
141 int val;
142
143 /* loop while we still have samples to generate */
144 while (samples)
145 {
146 /* compute the new amplitude and update the current step */
147 val = base[sample / 2] >> (((sample & 1) << 2) ^ 4);
148 signal += diff_lookup[step * 16 + (val & 15)];
149
150 /* clamp to the maximum */
151 if (signal > 2047)
152 signal = 2047;
153 else if (signal < -2048)
154 signal = -2048;
155
156 /* adjust the step size and clamp */
157 step += index_shift[val & 7];
158 if (step > 48)
159 step = 48;
160 else if (step < 0)
161 step = 0;
162
163 /* output to the buffer, scaling by the volume */
164 *buffer++ = signal * voice->volume / 16;
165 samples--;
166
167 /* next! */
168 if (++sample > count)
169 {
170 voice->playing = 0;
171 break;
172 }
173 }
174
175 /* update the parameters */
176 voice->sample = sample;
177 voice->signal = signal;
178 voice->step = step;
179 }
180
181 /* fill the rest with silence */
182 while (samples--)
183 *buffer++ = 0;
184 }
185
186
187
188 /**********************************************************************************************
189
190 adpcm_update -- update the sound chip so that it is in sync with CPU execution
191
192 ***********************************************************************************************/
193
adpcm_update(int num,INT16 * buffer,int length)194 static void adpcm_update(int num, INT16 *buffer, int length)
195 {
196 struct ADPCMVoice *voice = &adpcm[num];
197 INT16 sample_data[MAX_SAMPLE_CHUNK], *curr_data = sample_data;
198 INT16 prev = voice->last_sample, curr = voice->curr_sample;
199 UINT32 final_pos;
200 UINT32 new_samples;
201
202 /* finish off the current sample */
203 if (voice->source_pos > 0)
204 {
205 /* interpolate */
206 while (length > 0 && voice->source_pos < FRAC_ONE)
207 {
208 *buffer++ = (((INT32)prev * (FRAC_ONE - voice->source_pos)) + ((INT32)curr * voice->source_pos)) >> FRAC_BITS;
209 voice->source_pos += voice->source_step;
210 length--;
211 }
212
213 /* if we're over, continue; otherwise, we're done */
214 if (voice->source_pos >= FRAC_ONE)
215 voice->source_pos -= FRAC_ONE;
216 else
217 return;
218 }
219
220 /* compute how many new samples we need */
221 final_pos = voice->source_pos + length * voice->source_step;
222 new_samples = (final_pos + FRAC_ONE - 1) >> FRAC_BITS;
223 if (new_samples > MAX_SAMPLE_CHUNK)
224 new_samples = MAX_SAMPLE_CHUNK;
225
226 /* generate them into our buffer */
227 generate_adpcm(voice, sample_data, new_samples);
228 prev = curr;
229 curr = *curr_data++;
230
231 /* then sample-rate convert with linear interpolation */
232 while (length > 0)
233 {
234 /* interpolate */
235 while (length > 0 && voice->source_pos < FRAC_ONE)
236 {
237 *buffer++ = (((INT32)prev * (FRAC_ONE - voice->source_pos)) + ((INT32)curr * voice->source_pos)) >> FRAC_BITS;
238 voice->source_pos += voice->source_step;
239 length--;
240 }
241
242 /* if we're over, grab the next samples */
243 if (voice->source_pos >= FRAC_ONE)
244 {
245 voice->source_pos -= FRAC_ONE;
246 prev = curr;
247 curr = *curr_data++;
248 }
249 }
250
251 /* remember the last samples */
252 voice->last_sample = prev;
253 voice->curr_sample = curr;
254 }
255
256
257
258 /**********************************************************************************************
259
260 ADPCM_sh_start -- start emulation of several ADPCM output streams
261
262 ***********************************************************************************************/
263
ADPCM_sh_start(const struct MachineSound * msound)264 int ADPCM_sh_start(const struct MachineSound *msound)
265 {
266 const struct ADPCMinterface *intf = (const struct ADPCMinterface *)msound->sound_interface;
267 char stream_name[40];
268 int i;
269
270 /* reset the ADPCM system */
271 num_voices = intf->num;
272 compute_tables();
273 sample_list = 0;
274
275 /* generate the sample table, if one is needed */
276 if (intf->init)
277 {
278 /* allocate memory for it */
279 sample_list = (struct ADPCMsample*)malloc(257 * sizeof(struct ADPCMsample));
280 if (!sample_list)
281 return 1;
282 memset(sample_list, 0, 257 * sizeof(struct ADPCMsample));
283
284 /* callback to initialize */
285 (*intf->init)(intf, sample_list, 256);
286 }
287
288 /* initialize the voices */
289 memset(adpcm, 0, sizeof(adpcm));
290 for (i = 0; i < num_voices; i++)
291 {
292 /* generate the name and create the stream */
293 sprintf(stream_name, "%s #%d", sound_name(msound), i);
294 adpcm[i].stream = stream_init(stream_name, intf->mixing_level[i], Machine->sample_rate, i, adpcm_update);
295 if (adpcm[i].stream == -1)
296 return 1;
297
298 /* initialize the rest of the structure */
299 adpcm[i].region_base = memory_region(intf->region);
300 adpcm[i].volume = 255;
301 adpcm[i].signal = -2;
302 if (Machine->sample_rate)
303 adpcm[i].source_step = (UINT32)((float)intf->frequency * (float)FRAC_ONE / (float)Machine->sample_rate);
304 }
305
306 /* success */
307 return 0;
308 }
309
310
311
312 /**********************************************************************************************
313
314 ADPCM_sh_stop -- stop emulation of several ADPCM output streams
315
316 ***********************************************************************************************/
317
ADPCM_sh_stop(void)318 void ADPCM_sh_stop(void)
319 {
320 /* free the temporary table if we created it */
321 if (sample_list)
322 {
323 free(sample_list);
324 sample_list = 0;
325 }
326 }
327
328
329
330 /**********************************************************************************************
331
332 ADPCM_sh_update -- update ADPCM streams
333
334 ***********************************************************************************************/
335
ADPCM_sh_update(void)336 void ADPCM_sh_update(void)
337 {
338 }
339
340
341
342 /**********************************************************************************************
343
344 ADPCM_trigger -- handle a write to the ADPCM data stream
345
346 ***********************************************************************************************/
347
ADPCM_trigger(int num,int which)348 void ADPCM_trigger(int num, int which)
349 {
350 struct ADPCMVoice *voice = &adpcm[num];
351 struct ADPCMsample *sample;
352
353 /* bail if we're not playing anything */
354 if (Machine->sample_rate == 0)
355 return;
356
357 /* range check the numbers */
358 if (num >= num_voices)
359 {
360 logerror("error: ADPCM_trigger() called with channel = %d, but only %d channels allocated\n", num, num_voices);
361 return;
362 }
363
364 /* find a match */
365 for (sample = sample_list; sample->length > 0; sample++)
366 if (sample->num == which)
367 {
368 /* update the ADPCM voice */
369 stream_update(voice->stream, 0);
370
371 /* set up the voice to play this sample */
372 voice->playing = 1;
373 voice->base = &voice->region_base[sample->offset];
374 voice->sample = 0;
375 voice->count = sample->length;
376
377 /* also reset the ADPCM parameters */
378 voice->signal = -2;
379 voice->step = 0;
380 return;
381 }
382
383 logerror("warning: ADPCM_trigger() called with unknown trigger = %08x\n",which);
384 }
385
386
387
388 /**********************************************************************************************
389
390 ADPCM_play -- play data from a specific offset for a specific length
391
392 ***********************************************************************************************/
393
ADPCM_play(int num,int offset,int length)394 void ADPCM_play(int num, int offset, int length)
395 {
396 struct ADPCMVoice *voice = &adpcm[num];
397
398 /* bail if we're not playing anything */
399 if (Machine->sample_rate == 0)
400 return;
401
402 /* range check the numbers */
403 if (num >= num_voices)
404 {
405 logerror("error: ADPCM_trigger() called with channel = %d, but only %d channels allocated\n", num, num_voices);
406 return;
407 }
408
409 /* update the ADPCM voice */
410 stream_update(voice->stream, 0);
411
412 /* set up the voice to play this sample */
413 voice->playing = 1;
414 voice->base = &voice->region_base[offset];
415 voice->sample = 0;
416 voice->count = length;
417
418 /* also reset the ADPCM parameters */
419 voice->signal = -2;
420 voice->step = 0;
421 }
422
423
424
425 /**********************************************************************************************
426
427 ADPCM_play -- stop playback on an ADPCM data channel
428
429 ***********************************************************************************************/
430
ADPCM_stop(int num)431 void ADPCM_stop(int num)
432 {
433 struct ADPCMVoice *voice = &adpcm[num];
434
435 /* bail if we're not playing anything */
436 if (Machine->sample_rate == 0)
437 return;
438
439 /* range check the numbers */
440 if (num >= num_voices)
441 {
442 logerror("error: ADPCM_stop() called with channel = %d, but only %d channels allocated\n", num, num_voices);
443 return;
444 }
445
446 /* update the ADPCM voice */
447 stream_update(voice->stream, 0);
448
449 /* stop playback */
450 voice->playing = 0;
451 }
452
453
454
455 /**********************************************************************************************
456
457 ADPCM_setvol -- change volume on an ADPCM data channel
458
459 ***********************************************************************************************/
460
ADPCM_setvol(int num,int vol)461 void ADPCM_setvol(int num, int vol)
462 {
463 struct ADPCMVoice *voice = &adpcm[num];
464
465 /* bail if we're not playing anything */
466 if (Machine->sample_rate == 0)
467 return;
468
469 /* range check the numbers */
470 if (num >= num_voices)
471 {
472 logerror("error: ADPCM_setvol() called with channel = %d, but only %d channels allocated\n", num, num_voices);
473 return;
474 }
475
476 /* update the ADPCM voice */
477 stream_update(voice->stream, 0);
478 voice->volume = vol;
479 }
480
481
482
483 /**********************************************************************************************
484
485 ADPCM_playing -- returns true if an ADPCM data channel is still playing
486
487 ***********************************************************************************************/
488
ADPCM_playing(int num)489 int ADPCM_playing(int num)
490 {
491 struct ADPCMVoice *voice = &adpcm[num];
492
493 /* bail if we're not playing anything */
494 if (Machine->sample_rate == 0)
495 return 0;
496
497 /* range check the numbers */
498 if (num >= num_voices)
499 {
500 logerror("error: ADPCM_playing() called with channel = %d, but only %d channels allocated\n", num, num_voices);
501 return 0;
502 }
503
504 /* update the ADPCM voice */
505 stream_update(voice->stream, 0);
506 return voice->playing;
507 }
508
509
510
511 /**********************************************************************************************
512 *
513 * OKIM 6295 ADPCM chip:
514 *
515 * Command bytes are sent:
516 *
517 * 1xxx xxxx = start of 2-byte command sequence, xxxxxxx is the sample number to trigger
518 * abcd vvvv = second half of command; one of the abcd bits is set to indicate which voice
519 * the v bits seem to be volumed
520 *
521 * 0abc d000 = stop playing; one or more of the abcd bits is set to indicate which voice(s)
522 *
523 * Status is read:
524 *
525 * ???? abcd = one bit per voice, set to 0 if nothing is playing, or 1 if it is active
526 *
527 ***********************************************************************************************/
528
529 static int okim6295_command[MAX_OKIM6295];
530 static int okim6295_base[MAX_OKIM6295][MAX_OKIM6295_VOICES];
531
532
533 /**********************************************************************************************
534
535 OKIM6295_sh_start -- start emulation of an OKIM6295-compatible chip
536
537 ***********************************************************************************************/
538
OKIM6295_sh_start(const struct MachineSound * msound)539 int OKIM6295_sh_start(const struct MachineSound *msound)
540 {
541 const struct OKIM6295interface *intf = (const struct OKIM6295interface *)msound->sound_interface;
542 char stream_name[40];
543 int i;
544
545 /* reset the ADPCM system */
546 num_voices = intf->num * MAX_OKIM6295_VOICES;
547 compute_tables();
548 sample_list = 0;
549
550 /* initialize the voices */
551 memset(adpcm, 0, sizeof(adpcm));
552 for (i = 0; i < num_voices; i++)
553 {
554 int chip = i / MAX_OKIM6295_VOICES;
555 int voice = i % MAX_OKIM6295_VOICES;
556
557 /* reset the OKI-specific parameters */
558 okim6295_command[chip] = -1;
559 okim6295_base[chip][voice] = 0;
560
561 /* generate the name and create the stream */
562 sprintf(stream_name, "%s #%d (voice %d)", sound_name(msound), chip, voice);
563 adpcm[i].stream = stream_init(stream_name, intf->mixing_level[chip], Machine->sample_rate, i, adpcm_update);
564 if (adpcm[i].stream == -1)
565 return 1;
566
567 /* initialize the rest of the structure */
568 adpcm[i].region_base = memory_region(intf->region[chip]);
569 adpcm[i].volume = 255;
570 adpcm[i].signal = -2;
571 if (Machine->sample_rate)
572 adpcm[i].source_step = (UINT32)((float)intf->frequency[chip] * (float)FRAC_ONE / (float)Machine->sample_rate);
573 }
574
575 /* success */
576 return 0;
577 }
578
579
580
581 /**********************************************************************************************
582
583 OKIM6295_sh_stop -- stop emulation of an OKIM6295-compatible chip
584
585 ***********************************************************************************************/
586
OKIM6295_sh_stop(void)587 void OKIM6295_sh_stop(void)
588 {
589 }
590
591
592
593 /**********************************************************************************************
594
595 OKIM6295_sh_update -- update emulation of an OKIM6295-compatible chip
596
597 ***********************************************************************************************/
598
OKIM6295_sh_update(void)599 void OKIM6295_sh_update(void)
600 {
601 }
602
603
604
605 /**********************************************************************************************
606
607 OKIM6295_set_bank_base -- set the base of the bank for a given voice on a given chip
608
609 ***********************************************************************************************/
610
OKIM6295_set_bank_base(int which,int channel,int base)611 void OKIM6295_set_bank_base(int which, int channel, int base)
612 {
613 struct ADPCMVoice *voice = &adpcm[which * MAX_OKIM6295_VOICES + channel];
614
615 /* handle the all voice case */
616 if (channel == ALL_VOICES)
617 {
618 int i;
619
620 for (i = 0; i < MAX_OKIM6295_VOICES; i++)
621 OKIM6295_set_bank_base(which, i, base);
622 return;
623 }
624
625 /* update the stream and set the new base */
626 stream_update(voice->stream, 0);
627 okim6295_base[which][channel] = base;
628 }
629
630
631
632 /**********************************************************************************************
633
634 OKIM6295_set_frequency -- dynamically adjusts the frequency of a given ADPCM voice
635
636 ***********************************************************************************************/
637
OKIM6295_set_frequency(int which,int channel,int frequency)638 void OKIM6295_set_frequency(int which, int channel, int frequency)
639 {
640 struct ADPCMVoice *voice = &adpcm[which * MAX_OKIM6295_VOICES + channel];
641
642 /* handle the all voice case */
643 if (channel == ALL_VOICES)
644 {
645 int i;
646
647 for (i = 0; i < MAX_OKIM6295_VOICES; i++)
648 OKIM6295_set_frequency(which, i, frequency);
649 return;
650 }
651
652 /* update the stream and set the new base */
653 stream_update(voice->stream, 0);
654 if (Machine->sample_rate)
655 voice->source_step = (UINT32)((float)frequency * (float)FRAC_ONE / (float)Machine->sample_rate);
656 }
657
658
659 /**********************************************************************************************
660
661 OKIM6295_status_r -- read the status port of an OKIM6295-compatible chip
662
663 ***********************************************************************************************/
664
OKIM6295_status_r(int num)665 static int OKIM6295_status_r(int num)
666 {
667 int i, result;
668
669 /* range check the numbers */
670 if (num >= num_voices / MAX_OKIM6295_VOICES)
671 {
672 logerror("error: OKIM6295_status_r() called with chip = %d, but only %d chips allocated\n",num, num_voices / MAX_OKIM6295_VOICES);
673 return 0x0f;
674 }
675
676 /* set the bit to 1 if something is playing on a given channel */
677 result = 0;
678 for (i = 0; i < MAX_OKIM6295_VOICES; i++)
679 {
680 struct ADPCMVoice *voice = &adpcm[num * MAX_OKIM6295_VOICES + i];
681
682 /* update the stream */
683 stream_update(voice->stream, 0);
684
685 /* set the bit if it's playing */
686 if (voice->playing)
687 result |= 1 << i;
688 }
689
690 return result;
691 }
692
693
694
695 /**********************************************************************************************
696
697 OKIM6295_data_w -- write to the data port of an OKIM6295-compatible chip
698
699 ***********************************************************************************************/
700
OKIM6295_data_w(int num,int data)701 static void OKIM6295_data_w(int num, int data)
702 {
703 /* range check the numbers */
704 if (num >= num_voices / MAX_OKIM6295_VOICES)
705 {
706 logerror("error: OKIM6295_data_w() called with chip = %d, but only %d chips allocated\n", num, num_voices / MAX_OKIM6295_VOICES);
707 return;
708 }
709
710 /* if a command is pending, process the second half */
711 if (okim6295_command[num] != -1)
712 {
713 int temp = data >> 4, i, start, stop;
714 unsigned char *base;
715
716 /* determine which voice(s) (voice is set by a 1 bit in the upper 4 bits of the second byte) */
717 for (i = 0; i < MAX_OKIM6295_VOICES; i++, temp >>= 1)
718 if (temp & 1)
719 {
720 struct ADPCMVoice *voice = &adpcm[num * MAX_OKIM6295_VOICES + i];
721
722 /* update the stream */
723 stream_update(voice->stream, 0);
724
725 /* determine the start/stop positions */
726 base = &voice->region_base[okim6295_base[num][i] + okim6295_command[num] * 8];
727 start = (base[0] << 16) + (base[1] << 8) + base[2];
728 stop = (base[3] << 16) + (base[4] << 8) + base[5];
729
730 /* set up the voice to play this sample */
731 if (start < 0x40000 && stop < 0x40000)
732 {
733 voice->playing = 1;
734 voice->base = &voice->region_base[okim6295_base[num][i] + start];
735 voice->sample = 0;
736 voice->count = 2 * (stop - start + 1);
737
738 /* also reset the ADPCM parameters */
739 voice->signal = -2;
740 voice->step = 0;
741 voice->volume = volume_table[data & 0x0f];
742 }
743
744 /* invalid samples go here */
745 else
746 {
747 logerror("OKIM6295: requested to play invalid sample %02x\n",okim6295_command[num]);
748 voice->playing = 0;
749 }
750 }
751
752 /* reset the command */
753 okim6295_command[num] = -1;
754 }
755
756 /* if this is the start of a command, remember the sample number for next time */
757 else if (data & 0x80)
758 {
759 okim6295_command[num] = data & 0x7f;
760 }
761
762 /* otherwise, see if this is a silence command */
763 else
764 {
765 int temp = data >> 3, i;
766
767 /* determine which voice(s) (voice is set by a 1 bit in bits 3-6 of the command */
768 for (i = 0; i < 4; i++, temp >>= 1)
769 if (temp & 1)
770 {
771 struct ADPCMVoice *voice = &adpcm[num * MAX_OKIM6295_VOICES + i];
772
773 /* update the stream, then turn it off */
774 stream_update(voice->stream, 0);
775 voice->playing = 0;
776 }
777 }
778 }
779
780
781
782 /**********************************************************************************************
783
784 OKIM6295_status_0_r -- generic status read functions
785 OKIM6295_status_1_r
786
787 ***********************************************************************************************/
788
READ_HANDLER(OKIM6295_status_0_r)789 READ_HANDLER( OKIM6295_status_0_r )
790 {
791 return OKIM6295_status_r(0);
792 }
793
READ_HANDLER(OKIM6295_status_1_r)794 READ_HANDLER( OKIM6295_status_1_r )
795 {
796 return OKIM6295_status_r(1);
797 }
798
799
800
801 /**********************************************************************************************
802
803 OKIM6295_data_0_w -- generic data write functions
804 OKIM6295_data_1_w
805
806 ***********************************************************************************************/
807
WRITE_HANDLER(OKIM6295_data_0_w)808 WRITE_HANDLER( OKIM6295_data_0_w )
809 {
810 OKIM6295_data_w(0, data);
811 }
812
WRITE_HANDLER(OKIM6295_data_1_w)813 WRITE_HANDLER( OKIM6295_data_1_w )
814 {
815 OKIM6295_data_w(1, data);
816 }
817