trunk/src/mame/drivers/nemesis.c
| r23667 | r23668 | |
| 54 | 54 | #include "sound/3812intf.h" |
| 55 | 55 | #include "sound/vlm5030.h" |
| 56 | 56 | #include "sound/k005289.h" |
| 57 | | #include "sound/k007232.h" |
| 58 | 57 | #include "sound/k051649.h" |
| 59 | 58 | #include "includes/nemesis.h" |
| 60 | 59 | #include "includes/konamipt.h" |
| r23667 | r23668 | |
| 254 | 253 | { |
| 255 | 254 | int bank_A = (data & 0x03); |
| 256 | 255 | int bank_B = ((data >> 2) & 0x03); |
| 257 | | k007232_set_bank(m_k007232, bank_A, bank_B); |
| 256 | m_k007232->set_bank(bank_A, bank_B); |
| 258 | 257 | } |
| 259 | 258 | |
| 260 | 259 | |
| r23667 | r23668 | |
| 541 | 540 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 542 | 541 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 543 | 542 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 544 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) |
| 543 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 545 | 544 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) |
| 546 | 545 | AM_RANGE(0xd000, 0xd000) AM_DEVWRITE_LEGACY("vlm", vlm5030_data_w) |
| 547 | 546 | AM_RANGE(0xe000, 0xe000) AM_READ(wd_r) /* watchdog?? */ |
| r23667 | r23668 | |
| 552 | 551 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 553 | 552 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 554 | 553 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 555 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) |
| 554 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 556 | 555 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) |
| 557 | 556 | AM_RANGE(0xe000, 0xe000) AM_READ(wd_r) /* watchdog?? */ |
| 558 | 557 | ADDRESS_MAP_END |
| r23667 | r23668 | |
| 566 | 565 | AM_RANGE(0x988f, 0x988f) AM_DEVWRITE("k051649", k051649_device, k051649_keyonoff_w) |
| 567 | 566 | AM_RANGE(0x98e0, 0x98ff) AM_DEVREADWRITE("k051649", k051649_device, k051649_test_r, k051649_test_w) |
| 568 | 567 | AM_RANGE(0xa000, 0xa001) AM_DEVREADWRITE("ymsnd", ym3812_device, read, write) |
| 569 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) |
| 568 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 570 | 569 | AM_RANGE(0xc000, 0xc000) AM_WRITE(city_sound_bank_w) /* 7232 bankswitch */ |
| 571 | 570 | AM_RANGE(0xd000, 0xd000) AM_READ(soundlatch_byte_r) |
| 572 | 571 | ADDRESS_MAP_END |
| r23667 | r23668 | |
| 1492 | 1491 | |
| 1493 | 1492 | WRITE8_MEMBER(nemesis_state::volume_callback) |
| 1494 | 1493 | { |
| 1495 | | k007232_set_volume(m_k007232, 0, (data >> 4) * 0x11, 0); |
| 1496 | | k007232_set_volume(m_k007232, 1, 0, (data & 0x0f) * 0x11); |
| 1494 | m_k007232->set_volume(0, (data >> 4) * 0x11, 0); |
| 1495 | m_k007232->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 1497 | 1496 | } |
| 1498 | 1497 | |
| 1499 | 1498 | static const k007232_interface k007232_config = |
trunk/src/mame/drivers/bottom9.c
| r23667 | r23668 | |
| 16 | 16 | #include "cpu/z80/z80.h" |
| 17 | 17 | #include "cpu/m6809/m6809.h" |
| 18 | 18 | #include "video/konicdev.h" |
| 19 | | #include "sound/k007232.h" |
| 20 | 19 | #include "includes/konamipt.h" |
| 21 | 20 | #include "includes/bottom9.h" |
| 22 | 21 | |
| r23667 | r23668 | |
| 146 | 145 | |
| 147 | 146 | bank_A = ((data >> 0) & 0x03); |
| 148 | 147 | bank_B = ((data >> 2) & 0x03); |
| 149 | | k007232_set_bank(m_k007232_1, bank_A, bank_B); |
| 148 | m_k007232_1->set_bank(bank_A, bank_B); |
| 150 | 149 | |
| 151 | 150 | bank_A = ((data >> 4) & 0x03); |
| 152 | 151 | bank_B = ((data >> 6) & 0x03); |
| 153 | | k007232_set_bank(m_k007232_2, bank_A, bank_B); |
| 152 | m_k007232_2->set_bank(bank_A, bank_B); |
| 154 | 153 | } |
| 155 | 154 | |
| 156 | 155 | |
| r23667 | r23668 | |
| 178 | 177 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 179 | 178 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 180 | 179 | AM_RANGE(0x9000, 0x9000) AM_WRITE(sound_bank_w) |
| 181 | | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE_LEGACY("k007232_1", k007232_r, k007232_w) |
| 182 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232_2", k007232_r, k007232_w) |
| 180 | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE("k007232_1", k007232_device, read, write) |
| 181 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232_2", k007232_device, read, write) |
| 183 | 182 | AM_RANGE(0xd000, 0xd000) AM_READ(soundlatch_byte_r) |
| 184 | 183 | AM_RANGE(0xf000, 0xf000) AM_WRITE(nmi_enable_w) |
| 185 | 184 | ADDRESS_MAP_END |
| r23667 | r23668 | |
| 263 | 262 | |
| 264 | 263 | WRITE8_MEMBER(bottom9_state::volume_callback0) |
| 265 | 264 | { |
| 266 | | k007232_set_volume(m_k007232_1, 0, (data >> 4) * 0x11, 0); |
| 267 | | k007232_set_volume(m_k007232_1, 1, 0, (data & 0x0f) * 0x11); |
| 265 | m_k007232_1->set_volume(0, (data >> 4) * 0x11, 0); |
| 266 | m_k007232_1->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 268 | 267 | } |
| 269 | 268 | |
| 270 | 269 | WRITE8_MEMBER(bottom9_state::volume_callback1) |
| 271 | 270 | { |
| 272 | | k007232_set_volume(m_k007232_2, 0, (data >> 4) * 0x11, 0); |
| 273 | | k007232_set_volume(m_k007232_2, 1, 0, (data & 0x0f) * 0x11); |
| 271 | m_k007232_2->set_volume(0, (data >> 4) * 0x11, 0); |
| 272 | m_k007232_2->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 274 | 273 | } |
| 275 | 274 | |
| 276 | 275 | static const k007232_interface k007232_interface_1 = |
trunk/src/mame/drivers/fastlane.c
| r23667 | r23668 | |
| 11 | 11 | |
| 12 | 12 | #include "emu.h" |
| 13 | 13 | #include "cpu/m6809/hd6309.h" |
| 14 | | #include "sound/k007232.h" |
| 15 | 14 | #include "video/konicdev.h" |
| 16 | 15 | #include "includes/konamipt.h" |
| 17 | 16 | #include "includes/fastlane.h" |
| r23667 | r23668 | |
| 46 | 45 | membank("bank1")->set_entry((data & 0x0c) >> 2); |
| 47 | 46 | |
| 48 | 47 | /* bit 4: bank # for the 007232 (chip 2) */ |
| 49 | | k007232_set_bank(m_k007232_2, 0 + ((data & 0x10) >> 4), 2 + ((data & 0x10) >> 4)); |
| 48 | m_k007232_2->set_bank(0 + ((data & 0x10) >> 4), 2 + ((data & 0x10) >> 4)); |
| 50 | 49 | |
| 51 | 50 | /* other bits seems to be unused */ |
| 52 | 51 | } |
| r23667 | r23668 | |
| 56 | 55 | |
| 57 | 56 | READ8_MEMBER(fastlane_state::fastlane_k1_k007232_r) |
| 58 | 57 | { |
| 59 | | return k007232_r(m_k007232_1, space, offset ^ 1); |
| 58 | return m_k007232_1->read(space, offset ^ 1); |
| 60 | 59 | } |
| 61 | 60 | |
| 62 | 61 | WRITE8_MEMBER(fastlane_state::fastlane_k1_k007232_w) |
| 63 | 62 | { |
| 64 | | k007232_w(m_k007232_1, space, offset ^ 1, data); |
| 63 | m_k007232_1->write(space, offset ^ 1, data); |
| 65 | 64 | } |
| 66 | 65 | |
| 67 | 66 | READ8_MEMBER(fastlane_state::fastlane_k2_k007232_r) |
| 68 | 67 | { |
| 69 | | return k007232_r(m_k007232_2, space, offset ^ 1); |
| 68 | return m_k007232_2->read(space, offset ^ 1); |
| 70 | 69 | } |
| 71 | 70 | |
| 72 | 71 | WRITE8_MEMBER(fastlane_state::fastlane_k2_k007232_w) |
| 73 | 72 | { |
| 74 | | k007232_w(m_k007232_2, space, offset ^ 1, data); |
| 73 | m_k007232_2->write(space, offset ^ 1, data); |
| 75 | 74 | } |
| 76 | 75 | static ADDRESS_MAP_START( fastlane_map, AS_PROGRAM, 8, fastlane_state ) |
| 77 | 76 | AM_RANGE(0x0000, 0x005f) AM_RAM_WRITE(k007121_registers_w) AM_SHARE("k007121_regs") /* 007121 registers */ |
| r23667 | r23668 | |
| 177 | 176 | |
| 178 | 177 | WRITE8_MEMBER(fastlane_state::volume_callback0) |
| 179 | 178 | { |
| 180 | | k007232_set_volume(m_k007232_1, 0, (data >> 4) * 0x11, 0); |
| 181 | | k007232_set_volume(m_k007232_1, 1, 0, (data & 0x0f) * 0x11); |
| 179 | m_k007232_1->set_volume(0, (data >> 4) * 0x11, 0); |
| 180 | m_k007232_1->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 182 | 181 | } |
| 183 | 182 | |
| 184 | 183 | WRITE8_MEMBER(fastlane_state::volume_callback1) |
| 185 | 184 | { |
| 186 | | k007232_set_volume(m_k007232_2, 0, (data >> 4) * 0x11, 0); |
| 187 | | k007232_set_volume(m_k007232_2, 1, 0, (data & 0x0f) * 0x11); |
| 185 | m_k007232_2->set_volume(0, (data >> 4) * 0x11, 0); |
| 186 | m_k007232_2->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 188 | 187 | } |
| 189 | 188 | |
| 190 | 189 | static const k007232_interface k007232_interface_1 = |
trunk/src/mame/drivers/tmnt.c
| r23667 | r23668 | |
| 74 | 74 | #include "sound/samples.h" |
| 75 | 75 | #include "sound/k053260.h" |
| 76 | 76 | #include "sound/k054539.h" |
| 77 | | #include "sound/k007232.h" |
| 78 | 77 | #include "sound/upd7759.h" |
| 79 | 78 | #include "machine/nvram.h" |
| 80 | 79 | #include "includes/tmnt.h" |
| r23667 | r23668 | |
| 1081 | 1080 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 1082 | 1081 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 1083 | 1082 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 1084 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) |
| 1083 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 1085 | 1084 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) |
| 1086 | 1085 | ADDRESS_MAP_END |
| 1087 | 1086 | |
| r23667 | r23668 | |
| 1091 | 1090 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 1092 | 1091 | AM_RANGE(0x9000, 0x9000) AM_READWRITE(tmnt_sres_r, tmnt_sres_w) /* title music & UPD7759C reset */ |
| 1093 | 1092 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 1094 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) |
| 1093 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 1095 | 1094 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) |
| 1096 | 1095 | AM_RANGE(0xd000, 0xd000) AM_DEVWRITE_LEGACY("upd", upd7759_port_w) |
| 1097 | 1096 | AM_RANGE(0xe000, 0xe000) AM_WRITE(tmnt_upd_start_w) |
| r23667 | r23668 | |
| 2015 | 2014 | |
| 2016 | 2015 | WRITE8_MEMBER(tmnt_state::volume_callback) |
| 2017 | 2016 | { |
| 2018 | | k007232_set_volume(m_k007232, 0, (data >> 4) * 0x11, 0); |
| 2019 | | k007232_set_volume(m_k007232, 1, 0, (data & 0x0f) * 0x11); |
| 2017 | m_k007232->set_volume(0, (data >> 4) * 0x11, 0); |
| 2018 | m_k007232->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 2020 | 2019 | } |
| 2021 | 2020 | |
| 2022 | 2021 | static const k007232_interface k007232_config = |
trunk/src/mame/drivers/spy.c
| r23667 | r23668 | |
| 22 | 22 | #include "cpu/m6809/m6809.h" |
| 23 | 23 | #include "video/konicdev.h" |
| 24 | 24 | #include "sound/3812intf.h" |
| 25 | | #include "sound/k007232.h" |
| 26 | 25 | #include "includes/konamipt.h" |
| 27 | 26 | #include "includes/spy.h" |
| 28 | 27 | |
| r23667 | r23668 | |
| 336 | 335 | |
| 337 | 336 | bank_A = (data >> 0) & 0x03; |
| 338 | 337 | bank_B = (data >> 2) & 0x03; |
| 339 | | k007232_set_bank(m_k007232_1, bank_A, bank_B); |
| 338 | m_k007232_1->set_bank(bank_A, bank_B); |
| 340 | 339 | |
| 341 | 340 | bank_A = (data >> 4) & 0x03; |
| 342 | 341 | bank_B = (data >> 6) & 0x03; |
| 343 | | k007232_set_bank(m_k007232_2, bank_A, bank_B); |
| 342 | m_k007232_2->set_bank(bank_A, bank_B); |
| 344 | 343 | } |
| 345 | 344 | |
| 346 | 345 | |
| r23667 | r23668 | |
| 391 | 390 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 392 | 391 | AM_RANGE(0x8000, 0x87ff) AM_RAM |
| 393 | 392 | AM_RANGE(0x9000, 0x9000) AM_WRITE(sound_bank_w) |
| 394 | | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE_LEGACY("k007232_1", k007232_r, k007232_w) |
| 395 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232_2", k007232_r, k007232_w) |
| 393 | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE("k007232_1", k007232_device, read, write) |
| 394 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232_2", k007232_device, read, write) |
| 396 | 395 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym3812_device, read, write) |
| 397 | 396 | AM_RANGE(0xd000, 0xd000) AM_READ(soundlatch_byte_r) |
| 398 | 397 | ADDRESS_MAP_END |
| r23667 | r23668 | |
| 449 | 448 | |
| 450 | 449 | WRITE8_MEMBER(spy_state::volume_callback0) |
| 451 | 450 | { |
| 452 | | k007232_set_volume(m_k007232_1, 0, (data >> 4) * 0x11, 0); |
| 453 | | k007232_set_volume(m_k007232_1, 1, 0, (data & 0x0f) * 0x11); |
| 451 | m_k007232_1->set_volume(0, (data >> 4) * 0x11, 0); |
| 452 | m_k007232_1->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 454 | 453 | } |
| 455 | 454 | |
| 456 | 455 | static const k007232_interface spy_k007232_interface_1 = |
| r23667 | r23668 | |
| 460 | 459 | |
| 461 | 460 | WRITE8_MEMBER(spy_state::volume_callback1) |
| 462 | 461 | { |
| 463 | | k007232_set_volume(m_k007232_2, 0, (data >> 4) * 0x11, 0); |
| 464 | | k007232_set_volume(m_k007232_2, 1, 0, (data & 0x0f) * 0x11); |
| 462 | m_k007232_2->set_volume(0, (data >> 4) * 0x11, 0); |
| 463 | m_k007232_2->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 465 | 464 | } |
| 466 | 465 | |
| 467 | 466 | static const k007232_interface spy_k007232_interface_2 = |
trunk/src/mame/drivers/wecleman.c
| r23667 | r23668 | |
| 263 | 263 | #include "video/konicdev.h" |
| 264 | 264 | #include "cpu/m6809/m6809.h" |
| 265 | 265 | #include "sound/2151intf.h" |
| 266 | | #include "sound/k007232.h" |
| 267 | 266 | #include "wecleman.lh" |
| 268 | 267 | #include "includes/wecleman.h" |
| 269 | 268 | |
| r23667 | r23668 | |
| 617 | 616 | |
| 618 | 617 | WRITE8_MEMBER(wecleman_state::wecleman_K00723216_bank_w) |
| 619 | 618 | { |
| 620 | | k007232_set_bank(m_k007232, 0, ~data&1 ); //* (wecleman062gre) |
| 619 | m_k007232->set_bank(0, ~data&1 ); //* (wecleman062gre) |
| 621 | 620 | } |
| 622 | 621 | |
| 623 | 622 | static ADDRESS_MAP_START( wecleman_sound_map, AS_PROGRAM, 8, wecleman_state ) |
| r23667 | r23668 | |
| 628 | 627 | AM_RANGE(0x9000, 0x9001) AM_WRITE(multiply_w) // Protection |
| 629 | 628 | AM_RANGE(0x9006, 0x9006) AM_WRITENOP // ? |
| 630 | 629 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) // From main CPU |
| 631 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r, k007232_w) // K007232 (Reading offset 5/b triggers the sample) |
| 630 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) // K007232 (Reading offset 5/b triggers the sample) |
| 632 | 631 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) |
| 633 | 632 | AM_RANGE(0xf000, 0xf000) AM_WRITE(wecleman_K00723216_bank_w) // Samples banking |
| 634 | 633 | ADDRESS_MAP_END |
| r23667 | r23668 | |
| 650 | 649 | |
| 651 | 650 | WRITE8_MEMBER(wecleman_state::hotchase_sound_control_w) |
| 652 | 651 | { |
| 653 | | k007232_device *sound[3]; |
| 654 | | |
| 655 | 652 | // int reg[8]; |
| 656 | 653 | |
| 657 | | sound[0] = m_k007232_1; |
| 658 | | sound[1] = m_k007232_2; |
| 659 | | sound[2] = m_k007232_3; |
| 660 | 654 | |
| 661 | 655 | // reg[offset] = data; |
| 662 | 656 | |
| r23667 | r23668 | |
| 673 | 667 | ++------ chip select ( 0:chip 1, 1:chip2, 2:chip3) |
| 674 | 668 | data&0x0f left volume (data>>4)&0x0f right volume |
| 675 | 669 | */ |
| 676 | | k007232_set_volume( sound[offset>>1], offset&1, (data&0x0f) * 0x08, (data>>4) * 0x08 ); |
| 670 | m_k007232_1->set_volume( offset&1, (data&0x0f) * 0x08, (data>>4) * 0x08 ); |
| 671 | m_k007232_2->set_volume( offset&1, (data&0x0f) * 0x08, (data>>4) * 0x08 ); |
| 672 | m_k007232_3->set_volume( offset&1, (data&0x0f) * 0x08, (data>>4) * 0x08 ); |
| 677 | 673 | break; |
| 678 | 674 | |
| 679 | 675 | case 0x06: /* Bankswitch for chips 0 & 1 */ |
| r23667 | r23668 | |
| 685 | 681 | // bit 6: chip 2 - ch0 ? |
| 686 | 682 | // bit 7: chip 2 - ch1 ? |
| 687 | 683 | |
| 688 | | k007232_set_bank( sound[0], bank0_a, bank0_b ); |
| 689 | | k007232_set_bank( sound[1], bank1_a, bank1_b ); |
| 684 | m_k007232_1->set_bank( bank0_a, bank0_b ); |
| 685 | m_k007232_2->set_bank( bank1_a, bank1_b ); |
| 690 | 686 | } |
| 691 | 687 | break; |
| 692 | 688 | |
| r23667 | r23668 | |
| 695 | 691 | int bank2_a = (data >> 0) & 7; |
| 696 | 692 | int bank2_b = (data >> 3) & 7; |
| 697 | 693 | |
| 698 | | k007232_set_bank( sound[2], bank2_a, bank2_b ); |
| 694 | m_k007232_3->set_bank( bank2_a, bank2_b ); |
| 699 | 695 | } |
| 700 | 696 | break; |
| 701 | 697 | } |
| r23667 | r23668 | |
| 705 | 701 | even and odd register are mapped swapped */ |
| 706 | 702 | READ8_MEMBER(wecleman_state::hotchase_1_k007232_r) |
| 707 | 703 | { |
| 708 | | return k007232_r(m_k007232_1, space, offset ^ 1); |
| 704 | return m_k007232_1->read(space, offset ^ 1); |
| 709 | 705 | } |
| 710 | 706 | |
| 711 | 707 | WRITE8_MEMBER(wecleman_state::hotchase_1_k007232_w) |
| 712 | 708 | { |
| 713 | | k007232_w(m_k007232_1, space, offset ^ 1, data); |
| 709 | m_k007232_1->write(space, offset ^ 1, data); |
| 714 | 710 | } |
| 715 | 711 | |
| 716 | 712 | READ8_MEMBER(wecleman_state::hotchase_2_k007232_r) |
| 717 | 713 | { |
| 718 | | return k007232_r(m_k007232_2, space, offset ^ 1); |
| 714 | return m_k007232_2->read(space, offset ^ 1); |
| 719 | 715 | } |
| 720 | 716 | |
| 721 | 717 | WRITE8_MEMBER(wecleman_state::hotchase_2_k007232_w) |
| 722 | 718 | { |
| 723 | | k007232_w(m_k007232_2, space, offset ^ 1, data); |
| 719 | m_k007232_2->write(space, offset ^ 1, data); |
| 724 | 720 | } |
| 725 | 721 | |
| 726 | 722 | READ8_MEMBER(wecleman_state::hotchase_3_k007232_r) |
| 727 | 723 | { |
| 728 | | return k007232_r(m_k007232_3, space, offset ^ 1); |
| 724 | return m_k007232_3->read(space, offset ^ 1); |
| 729 | 725 | } |
| 730 | 726 | |
| 731 | 727 | WRITE8_MEMBER(wecleman_state::hotchase_3_k007232_w) |
| 732 | 728 | { |
| 733 | | k007232_w(m_k007232_3, space, offset ^ 1, data); |
| 729 | m_k007232_3->write(space, offset ^ 1, data); |
| 734 | 730 | } |
| 735 | 731 | |
| 736 | 732 | static ADDRESS_MAP_START( hotchase_sound_map, AS_PROGRAM, 8, wecleman_state ) |
| r23667 | r23668 | |
| 1040 | 1036 | |
| 1041 | 1037 | MACHINE_RESET_MEMBER(wecleman_state,wecleman) |
| 1042 | 1038 | { |
| 1043 | | k007232_set_bank( m_k007232, 0, 1 ); |
| 1039 | m_k007232->set_bank( 0, 1 ); |
| 1044 | 1040 | } |
| 1045 | 1041 | |
| 1046 | 1042 | static MACHINE_CONFIG_START( wecleman, wecleman_state ) |
trunk/src/mame/drivers/ajax.c
| r23667 | r23668 | |
| 16 | 16 | #include "cpu/m6809/konami.h" |
| 17 | 17 | #include "video/konicdev.h" |
| 18 | 18 | #include "sound/2151intf.h" |
| 19 | | #include "sound/k007232.h" |
| 20 | 19 | #include "includes/ajax.h" |
| 21 | 20 | #include "includes/konamipt.h" |
| 22 | 21 | |
| r23667 | r23668 | |
| 51 | 50 | AM_RANGE(0x0000, 0x7fff) AM_ROM /* ROM F6 */ |
| 52 | 51 | AM_RANGE(0x8000, 0x87ff) AM_RAM /* RAM 2128SL at D16 */ |
| 53 | 52 | AM_RANGE(0x9000, 0x9000) AM_WRITE(sound_bank_w) /* 007232 bankswitch */ |
| 54 | | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE_LEGACY("k007232_1", k007232_r, k007232_w) /* 007232 registers (chip 1) */ |
| 55 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232_2", k007232_r, k007232_w) /* 007232 registers (chip 2) */ |
| 53 | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE("k007232_1", k007232_device, read, write) /* 007232 registers (chip 1) */ |
| 54 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232_2", k007232_device, read, write) /* 007232 registers (chip 2) */ |
| 56 | 55 | AM_RANGE(0xb80c, 0xb80c) AM_WRITE(k007232_extvol_w) /* extra volume, goes to the 007232 w/ A11 */ |
| 57 | 56 | /* selecting a different latch for the external port */ |
| 58 | 57 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) /* YM2151 */ |
| r23667 | r23668 | |
| 142 | 141 | /* banks # for the 007232 (chip 1) */ |
| 143 | 142 | bank_A = BIT(data, 1); |
| 144 | 143 | bank_B = BIT(data, 0); |
| 145 | | k007232_set_bank(m_k007232_1, bank_A, bank_B); |
| 144 | m_k007232_1->set_bank(bank_A, bank_B); |
| 146 | 145 | |
| 147 | 146 | /* banks # for the 007232 (chip 2) */ |
| 148 | 147 | bank_A = ((data >> 4) & 0x03); |
| 149 | 148 | bank_B = ((data >> 2) & 0x03); |
| 150 | | k007232_set_bank(m_k007232_2, bank_A, bank_B); |
| 149 | m_k007232_2->set_bank(bank_A, bank_B); |
| 151 | 150 | } |
| 152 | 151 | |
| 153 | 152 | WRITE8_MEMBER(ajax_state::volume_callback0) |
| 154 | 153 | { |
| 155 | | k007232_set_volume(m_k007232_1, 0, (data >> 4) * 0x11, 0); |
| 156 | | k007232_set_volume(m_k007232_1, 1, 0, (data & 0x0f) * 0x11); |
| 154 | m_k007232_1->set_volume(0, (data >> 4) * 0x11, 0); |
| 155 | m_k007232_1->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 157 | 156 | } |
| 158 | 157 | |
| 159 | 158 | WRITE8_MEMBER(ajax_state::k007232_extvol_w) |
| 160 | 159 | { |
| 161 | 160 | /* channel A volume (mono) */ |
| 162 | | k007232_set_volume(m_k007232_2, 0, (data & 0x0f) * 0x11/2, (data & 0x0f) * 0x11/2); |
| 161 | m_k007232_2->set_volume(0, (data & 0x0f) * 0x11/2, (data & 0x0f) * 0x11/2); |
| 163 | 162 | } |
| 164 | 163 | |
| 165 | 164 | WRITE8_MEMBER(ajax_state::volume_callback1) |
| 166 | 165 | { |
| 167 | 166 | /* channel B volume/pan */ |
| 168 | | k007232_set_volume(m_k007232_2, 1, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 167 | m_k007232_2->set_volume(1, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 169 | 168 | } |
| 170 | 169 | |
| 171 | 170 | static const k007232_interface k007232_interface_1 = |
trunk/src/mame/drivers/mainevt.c
| r23667 | r23668 | |
| 26 | 26 | #include "video/konicdev.h" |
| 27 | 27 | #include "cpu/m6809/m6809.h" |
| 28 | 28 | #include "sound/2151intf.h" |
| 29 | | #include "sound/k007232.h" |
| 30 | 29 | #include "sound/upd7759.h" |
| 31 | 30 | #include "includes/konamipt.h" |
| 32 | 31 | #include "includes/mainevt.h" |
| r23667 | r23668 | |
| 107 | 106 | /* bits 0-3 select the 007232 banks */ |
| 108 | 107 | bank_A = (data & 0x3); |
| 109 | 108 | bank_B = ((data >> 2) & 0x3); |
| 110 | | k007232_set_bank(m_k007232, bank_A, bank_B); |
| 109 | m_k007232->set_bank(bank_A, bank_B); |
| 111 | 110 | |
| 112 | 111 | /* bits 4-5 select the UPD7759 bank */ |
| 113 | 112 | upd7759_set_bank_base(m_upd7759, ((data >> 4) & 0x03) * 0x20000); |
| r23667 | r23668 | |
| 122 | 121 | /* bits 0-3 select the 007232 banks */ |
| 123 | 122 | bank_A = (data & 0x3); |
| 124 | 123 | bank_B = ((data >> 2) & 0x3); |
| 125 | | k007232_set_bank(m_k007232, bank_A, bank_B); |
| 124 | m_k007232->set_bank(bank_A, bank_B); |
| 126 | 125 | } |
| 127 | 126 | |
| 128 | 127 | READ8_MEMBER(mainevt_state::k052109_051960_r) |
| r23667 | r23668 | |
| 205 | 204 | AM_RANGE(0x8000, 0x83ff) AM_RAM |
| 206 | 205 | AM_RANGE(0x9000, 0x9000) AM_DEVWRITE_LEGACY("upd", upd7759_port_w) |
| 207 | 206 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 208 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r,k007232_w) |
| 207 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 209 | 208 | AM_RANGE(0xd000, 0xd000) AM_READ(mainevt_sh_busy_r) |
| 210 | 209 | AM_RANGE(0xe000, 0xe000) AM_WRITE(mainevt_sh_irqcontrol_w) |
| 211 | 210 | AM_RANGE(0xf000, 0xf000) AM_WRITE(mainevt_sh_bankswitch_w) |
| r23667 | r23668 | |
| 215 | 214 | AM_RANGE(0x0000, 0x7fff) AM_ROM |
| 216 | 215 | AM_RANGE(0x8000, 0x83ff) AM_RAM |
| 217 | 216 | AM_RANGE(0xa000, 0xa000) AM_READ(soundlatch_byte_r) |
| 218 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232", k007232_r,k007232_w) |
| 217 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232", k007232_device, read, write) |
| 219 | 218 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device,read,write) |
| 220 | 219 | AM_RANGE(0xe000, 0xe000) AM_WRITE(devstor_sh_irqcontrol_w) |
| 221 | 220 | AM_RANGE(0xf000, 0xf000) AM_WRITE(dv_sh_bankswitch_w) |
| r23667 | r23668 | |
| 375 | 374 | |
| 376 | 375 | WRITE8_MEMBER(mainevt_state::volume_callback) |
| 377 | 376 | { |
| 378 | | k007232_set_volume(m_k007232, 0, (data >> 4) * 0x11, 0); |
| 379 | | k007232_set_volume(m_k007232, 1, 0, (data & 0x0f) * 0x11); |
| 377 | m_k007232->set_volume(0, (data >> 4) * 0x11, 0); |
| 378 | m_k007232->set_volume(1, 0, (data & 0x0f) * 0x11); |
| 380 | 379 | } |
| 381 | 380 | |
| 382 | 381 | static const k007232_interface k007232_config = |
trunk/src/mame/drivers/chqflag.c
| r23667 | r23668 | |
| 17 | 17 | #include "cpu/m6809/konami.h" |
| 18 | 18 | #include "video/konicdev.h" |
| 19 | 19 | #include "sound/2151intf.h" |
| 20 | | #include "sound/k007232.h" |
| 21 | 20 | #include "includes/chqflag.h" |
| 22 | 21 | #include "includes/konamipt.h" |
| 23 | 22 | |
| r23667 | r23668 | |
| 169 | 168 | /* banks # for the 007232 (chip 1) */ |
| 170 | 169 | bank_A = ((data >> 4) & 0x03); |
| 171 | 170 | bank_B = ((data >> 6) & 0x03); |
| 172 | | k007232_set_bank(m_k007232_1, bank_A, bank_B); |
| 171 | m_k007232_1->set_bank(bank_A, bank_B); |
| 173 | 172 | |
| 174 | 173 | /* banks # for the 007232 (chip 2) */ |
| 175 | 174 | bank_A = ((data >> 0) & 0x03); |
| 176 | 175 | bank_B = ((data >> 2) & 0x03); |
| 177 | | k007232_set_bank(m_k007232_2, bank_A, bank_B); |
| 176 | m_k007232_2->set_bank(bank_A, bank_B); |
| 178 | 177 | } |
| 179 | 178 | |
| 180 | 179 | static ADDRESS_MAP_START( chqflag_sound_map, AS_PROGRAM, 8, chqflag_state ) |
| 181 | 180 | AM_RANGE(0x0000, 0x7fff) AM_ROM /* ROM */ |
| 182 | 181 | AM_RANGE(0x8000, 0x87ff) AM_RAM /* RAM */ |
| 183 | 182 | AM_RANGE(0x9000, 0x9000) AM_WRITE(k007232_bankswitch_w) /* 007232 bankswitch */ |
| 184 | | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE_LEGACY("k007232_1", k007232_r, k007232_w) /* 007232 (chip 1) */ |
| 183 | AM_RANGE(0xa000, 0xa00d) AM_DEVREADWRITE("k007232_1", k007232_device, read, write) /* 007232 (chip 1) */ |
| 185 | 184 | AM_RANGE(0xa01c, 0xa01c) AM_WRITE(k007232_extvolume_w) /* extra volume, goes to the 007232 w/ A11 */ |
| 186 | | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE_LEGACY("k007232_2", k007232_r, k007232_w) /* 007232 (chip 2) */ |
| 185 | AM_RANGE(0xb000, 0xb00d) AM_DEVREADWRITE("k007232_2", k007232_device, read, write) /* 007232 (chip 2) */ |
| 187 | 186 | AM_RANGE(0xc000, 0xc001) AM_DEVREADWRITE("ymsnd", ym2151_device, read, write) /* YM2151 */ |
| 188 | 187 | AM_RANGE(0xd000, 0xd000) AM_READ(soundlatch_byte_r) /* soundlatch_byte_r */ |
| 189 | 188 | AM_RANGE(0xe000, 0xe000) AM_READ(soundlatch2_byte_r) /* engine sound volume */ |
| r23667 | r23668 | |
| 257 | 256 | |
| 258 | 257 | WRITE8_MEMBER(chqflag_state::volume_callback0) |
| 259 | 258 | { |
| 260 | | k007232_set_volume(m_k007232_1, 0, (data & 0x0f) * 0x11, 0); |
| 261 | | k007232_set_volume(m_k007232_1, 1, 0, (data >> 4) * 0x11); |
| 259 | m_k007232_1->set_volume(0, (data & 0x0f) * 0x11, 0); |
| 260 | m_k007232_1->set_volume(1, 0, (data >> 4) * 0x11); |
| 262 | 261 | } |
| 263 | 262 | |
| 264 | 263 | WRITE8_MEMBER(chqflag_state::k007232_extvolume_w) |
| 265 | 264 | { |
| 266 | | k007232_set_volume(m_k007232_2, 1, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 265 | m_k007232_2->set_volume(1, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 267 | 266 | } |
| 268 | 267 | |
| 269 | 268 | WRITE8_MEMBER(chqflag_state::volume_callback1) |
| 270 | 269 | { |
| 271 | | k007232_set_volume(m_k007232_2, 0, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 270 | m_k007232_2->set_volume(0, (data & 0x0f) * 0x11/2, (data >> 4) * 0x11/2); |
| 272 | 271 | } |
| 273 | 272 | |
| 274 | 273 | static const k007232_interface k007232_interface_1 = |
trunk/src/emu/sound/k007232.c
| r23667 | r23668 | |
| 26 | 26 | #include "emu.h" |
| 27 | 27 | #include "k007232.h" |
| 28 | 28 | |
| 29 | | |
| 30 | | #define KDAC_A_PCM_MAX (2) /* Channels per chip */ |
| 31 | | |
| 32 | | |
| 33 | | struct KDAC_A_PCM |
| 34 | | { |
| 35 | | UINT8 vol[KDAC_A_PCM_MAX][2]; /* volume for the left and right channel */ |
| 36 | | UINT32 addr[KDAC_A_PCM_MAX]; |
| 37 | | UINT32 start[KDAC_A_PCM_MAX]; |
| 38 | | UINT32 step[KDAC_A_PCM_MAX]; |
| 39 | | UINT32 bank[KDAC_A_PCM_MAX]; |
| 40 | | int play[KDAC_A_PCM_MAX]; |
| 41 | | |
| 42 | | UINT8 wreg[0x10]; /* write data */ |
| 43 | | UINT8 * pcmbuf[2]; /* Channel A & B pointers */ |
| 44 | | |
| 45 | | UINT32 clock; /* chip clock */ |
| 46 | | UINT32 pcmlimit; |
| 47 | | |
| 48 | | sound_stream * stream; |
| 49 | | const k007232_interface *intf; |
| 50 | | UINT32 fncode[0x200]; |
| 51 | | devcb_resolved_write8 portwritehandler; |
| 52 | | }; |
| 53 | | |
| 54 | | |
| 55 | 29 | #define BASE_SHIFT (12) |
| 56 | 30 | |
| 57 | 31 | |
| 58 | | INLINE KDAC_A_PCM *get_safe_token(device_t *device) |
| 59 | | { |
| 60 | | assert(device != NULL); |
| 61 | | assert(device->type() == K007232); |
| 62 | | return (KDAC_A_PCM *)downcast<k007232_device *>(device)->token(); |
| 63 | | } |
| 64 | | |
| 65 | | |
| 66 | 32 | #if 0 |
| 67 | 33 | static const int kdac_note[] = { |
| 68 | 34 | 261.63/8, 277.18/8, |
| r23667 | r23668 | |
| 175 | 141 | #endif |
| 176 | 142 | |
| 177 | 143 | /*************************************************************/ |
| 178 | | static void KDAC_A_make_fncode( KDAC_A_PCM *info ){ |
| 179 | | int i; |
| 144 | |
| 145 | |
| 146 | const device_type K007232 = &device_creator<k007232_device>; |
| 147 | |
| 148 | k007232_device::k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 149 | : device_t(mconfig, K007232, "K007232", tag, owner, clock), |
| 150 | device_sound_interface(mconfig, *this) |
| 151 | { |
| 152 | |
| 153 | } |
| 154 | |
| 155 | //------------------------------------------------- |
| 156 | // device_config_complete - perform any |
| 157 | // operations now that the configuration is |
| 158 | // complete |
| 159 | //------------------------------------------------- |
| 160 | |
| 161 | void k007232_device::device_config_complete() |
| 162 | { |
| 163 | // inherit a copy of the static data |
| 164 | const k007232_interface *intf = reinterpret_cast<const k007232_interface *>(static_config()); |
| 165 | if (intf != NULL) |
| 166 | *static_cast<k007232_interface *>(this) = *intf; |
| 167 | |
| 168 | // or initialize to defaults if none provided |
| 169 | else |
| 170 | { |
| 171 | memset(&m_portwritehandler, 0, sizeof(m_portwritehandler)); |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | //------------------------------------------------- |
| 176 | // device_start - device-specific startup |
| 177 | //------------------------------------------------- |
| 178 | |
| 179 | void k007232_device::device_start() |
| 180 | { |
| 181 | /* Set up the chips */ |
| 182 | m_pcmbuf[0] = *region(); |
| 183 | m_pcmbuf[1] = *region(); |
| 184 | m_pcmlimit = region()->bytes(); |
| 185 | |
| 186 | m_portwritehandler_func.resolve(m_portwritehandler,*this); |
| 187 | |
| 188 | for (int i = 0; i < KDAC_A_PCM_MAX; i++) |
| 189 | { |
| 190 | m_addr[i] = 0; |
| 191 | m_start[i] = 0; |
| 192 | m_step[i] = 0; |
| 193 | m_play[i] = 0; |
| 194 | m_bank[i] = 0; |
| 195 | } |
| 196 | m_vol[0][0] = 255; /* channel A output to output A */ |
| 197 | m_vol[0][1] = 0; |
| 198 | m_vol[1][0] = 0; |
| 199 | m_vol[1][1] = 255; /* channel B output to output B */ |
| 200 | |
| 201 | for (int i = 0; i < 0x10; i++) |
| 202 | m_wreg[i] = 0; |
| 203 | |
| 204 | m_stream = machine().sound().stream_alloc(*this, 0 , 2, clock()/128, this); |
| 205 | |
| 206 | KDAC_A_make_fncode(); |
| 207 | |
| 208 | save_item(NAME(m_vol)); |
| 209 | save_item(NAME(m_addr)); |
| 210 | save_item(NAME(m_start)); |
| 211 | save_item(NAME(m_step)); |
| 212 | save_item(NAME(m_bank)); |
| 213 | save_item(NAME(m_play)); |
| 214 | save_item(NAME(m_wreg)); |
| 215 | } |
| 216 | |
| 217 | void k007232_device::KDAC_A_make_fncode() |
| 218 | { |
| 180 | 219 | #if 0 |
| 181 | 220 | int i, j, k; |
| 182 | 221 | float fn; |
| r23667 | r23668 | |
| 206 | 245 | #endif |
| 207 | 246 | |
| 208 | 247 | #else |
| 209 | | for( i = 0; i < 0x200; i++ ){ |
| 248 | int i; |
| 249 | for( i = 0; i < 0x200; i++ ) |
| 250 | { |
| 210 | 251 | //fncode[i] = (0x200 * 55) / (0x200 - i); |
| 211 | | info->fncode[i] = (32 << BASE_SHIFT) / (0x200 - i); |
| 212 | | // info->fncode[i] = ((0x200 * 55.2 / 880) / (0x200 - i)); |
| 252 | m_fncode[i] = (32 << BASE_SHIFT) / (0x200 - i); |
| 253 | // m_fncode[i] = ((0x200 * 55.2 / 880) / (0x200 - i)); |
| 213 | 254 | // = 512 * 55.2 / 220 / (512 - i) = 128 / (512 - i) |
| 214 | 255 | // logerror("2 : fncode[%04x] = %.2f\n", i, fncode[i] ); |
| 215 | 256 | } |
| r23667 | r23668 | |
| 219 | 260 | |
| 220 | 261 | |
| 221 | 262 | /************************************************/ |
| 222 | | /* Konami PCM update */ |
| 223 | | /************************************************/ |
| 224 | | |
| 225 | | static STREAM_UPDATE( KDAC_A_update ) |
| 226 | | { |
| 227 | | KDAC_A_PCM *info = (KDAC_A_PCM *)param; |
| 228 | | int i; |
| 229 | | |
| 230 | | memset(outputs[0],0,samples * sizeof(*outputs[0])); |
| 231 | | memset(outputs[1],0,samples * sizeof(*outputs[1])); |
| 232 | | |
| 233 | | for( i = 0; i < KDAC_A_PCM_MAX; i++ ) |
| 234 | | { |
| 235 | | if (info->play[i]) |
| 236 | | { |
| 237 | | int volA,volB,j,out; |
| 238 | | unsigned int addr, old_addr; |
| 239 | | //int cen; |
| 240 | | |
| 241 | | /**** PCM setup ****/ |
| 242 | | addr = info->start[i] + ((info->addr[i]>>BASE_SHIFT)&0x000fffff); |
| 243 | | volA = info->vol[i][0] * 2; |
| 244 | | volB = info->vol[i][1] * 2; |
| 245 | | #if 0 |
| 246 | | cen = (volA + volB) / 2; |
| 247 | | volA = (volA + cen) < 0x1fe ? (volA + cen) : 0x1fe; |
| 248 | | volB = (volB + cen) < 0x1fe ? (volB + cen) : 0x1fe; |
| 249 | | #endif |
| 250 | | |
| 251 | | for( j = 0; j < samples; j++ ) |
| 252 | | { |
| 253 | | old_addr = addr; |
| 254 | | addr = info->start[i] + ((info->addr[i]>>BASE_SHIFT)&0x000fffff); |
| 255 | | while (old_addr <= addr) |
| 256 | | { |
| 257 | | if( (info->pcmbuf[i][old_addr] & 0x80) || old_addr >= info->pcmlimit ) |
| 258 | | { |
| 259 | | /* end of sample */ |
| 260 | | |
| 261 | | if( info->wreg[0x0d]&(1<<i) ) |
| 262 | | { |
| 263 | | /* loop to the beginning */ |
| 264 | | info->start[i] = |
| 265 | | ((((unsigned int)info->wreg[i*0x06 + 0x04]<<16)&0x00010000) | |
| 266 | | (((unsigned int)info->wreg[i*0x06 + 0x03]<< 8)&0x0000ff00) | |
| 267 | | (((unsigned int)info->wreg[i*0x06 + 0x02] )&0x000000ff) | |
| 268 | | info->bank[i]); |
| 269 | | addr = info->start[i]; |
| 270 | | info->addr[i] = 0; |
| 271 | | old_addr = addr; /* skip loop */ |
| 272 | | } |
| 273 | | else |
| 274 | | { |
| 275 | | /* stop sample */ |
| 276 | | info->play[i] = 0; |
| 277 | | } |
| 278 | | break; |
| 279 | | } |
| 280 | | |
| 281 | | old_addr++; |
| 282 | | } |
| 283 | | |
| 284 | | if (info->play[i] == 0) |
| 285 | | break; |
| 286 | | |
| 287 | | info->addr[i] += info->step[i]; |
| 288 | | |
| 289 | | out = (info->pcmbuf[i][addr] & 0x7f) - 0x40; |
| 290 | | |
| 291 | | outputs[0][j] += out * volA; |
| 292 | | outputs[1][j] += out * volB; |
| 293 | | } |
| 294 | | } |
| 295 | | } |
| 296 | | } |
| 297 | | |
| 298 | | |
| 299 | | /************************************************/ |
| 300 | | /* Konami PCM start */ |
| 301 | | /************************************************/ |
| 302 | | static DEVICE_START( k007232 ) |
| 303 | | { |
| 304 | | static const k007232_interface defintrf = { DEVCB_NULL }; |
| 305 | | int i; |
| 306 | | KDAC_A_PCM *info = get_safe_token(device); |
| 307 | | |
| 308 | | info->intf = (device->static_config() != NULL) ? (const k007232_interface *)device->static_config() : &defintrf; |
| 309 | | |
| 310 | | /* Set up the chips */ |
| 311 | | |
| 312 | | info->pcmbuf[0] = *device->region(); |
| 313 | | info->pcmbuf[1] = *device->region(); |
| 314 | | info->pcmlimit = device->region()->bytes(); |
| 315 | | |
| 316 | | info->clock = device->clock(); |
| 317 | | |
| 318 | | info->portwritehandler.resolve(info->intf->portwritehandler,*device); |
| 319 | | |
| 320 | | for( i = 0; i < KDAC_A_PCM_MAX; i++ ) |
| 321 | | { |
| 322 | | info->start[i] = 0; |
| 323 | | info->step[i] = 0; |
| 324 | | info->play[i] = 0; |
| 325 | | info->bank[i] = 0; |
| 326 | | } |
| 327 | | info->vol[0][0] = 255; /* channel A output to output A */ |
| 328 | | info->vol[0][1] = 0; |
| 329 | | info->vol[1][0] = 0; |
| 330 | | info->vol[1][1] = 255; /* channel B output to output B */ |
| 331 | | |
| 332 | | for( i = 0; i < 0x10; i++ ) info->wreg[i] = 0; |
| 333 | | |
| 334 | | info->stream = device->machine().sound().stream_alloc(*device,0,2,device->clock()/128,info,KDAC_A_update); |
| 335 | | |
| 336 | | KDAC_A_make_fncode(info); |
| 337 | | } |
| 338 | | |
| 339 | | /************************************************/ |
| 340 | 263 | /* Konami PCM write register */ |
| 341 | 264 | /************************************************/ |
| 342 | | WRITE8_DEVICE_HANDLER( k007232_w ) |
| 265 | WRITE8_MEMBER( k007232_device::write ) |
| 343 | 266 | { |
| 344 | | KDAC_A_PCM *info = get_safe_token(device); |
| 345 | 267 | int r = offset; |
| 346 | 268 | int v = data; |
| 347 | 269 | |
| 348 | | info->stream->update(); |
| 270 | m_stream->update(); |
| 349 | 271 | |
| 350 | | info->wreg[r] = v; /* stock write data */ |
| 272 | m_wreg[r] = v; /* stock write data */ |
| 351 | 273 | |
| 352 | 274 | if (r == 0x0c){ |
| 353 | 275 | /* external port, usually volume control */ |
| 354 | | if (!info->portwritehandler.isnull()) info->portwritehandler(0,v); |
| 276 | if (!m_portwritehandler_func.isnull()) m_portwritehandler_func(0,v); |
| 355 | 277 | return; |
| 356 | 278 | } |
| 357 | 279 | else if( r == 0x0d ){ |
| r23667 | r23668 | |
| 372 | 294 | case 0x01: |
| 373 | 295 | { |
| 374 | 296 | /**** address step ****/ |
| 375 | | int idx = (((((unsigned int)info->wreg[reg_port*0x06 + 0x01])<<8)&0x0100) | (((unsigned int)info->wreg[reg_port*0x06 + 0x00])&0x00ff)); |
| 297 | int idx = (((((unsigned int)m_wreg[reg_port*0x06 + 0x01])<<8)&0x0100) | (((unsigned int)m_wreg[reg_port*0x06 + 0x00])&0x00ff)); |
| 376 | 298 | #if 0 |
| 377 | 299 | if( !reg_port && r == 1 ) |
| 378 | 300 | logerror("%04x\n" ,idx ); |
| 379 | 301 | #endif |
| 380 | 302 | |
| 381 | | info->step[reg_port] = info->fncode[idx]; |
| 303 | m_step[reg_port] = m_fncode[idx]; |
| 382 | 304 | break; |
| 383 | 305 | } |
| 384 | 306 | case 0x02: |
| r23667 | r23668 | |
| 387 | 309 | break; |
| 388 | 310 | case 0x05: |
| 389 | 311 | /**** start address ****/ |
| 390 | | info->start[reg_port] = |
| 391 | | ((((unsigned int)info->wreg[reg_port*0x06 + 0x04]<<16)&0x00010000) | |
| 392 | | (((unsigned int)info->wreg[reg_port*0x06 + 0x03]<< 8)&0x0000ff00) | |
| 393 | | (((unsigned int)info->wreg[reg_port*0x06 + 0x02] )&0x000000ff) | |
| 394 | | info->bank[reg_port]); |
| 395 | | if (info->start[reg_port] < info->pcmlimit ){ |
| 396 | | info->play[reg_port] = 1; |
| 397 | | info->addr[reg_port] = 0; |
| 312 | m_start[reg_port] = |
| 313 | ((((unsigned int)m_wreg[reg_port*0x06 + 0x04]<<16)&0x00010000) | |
| 314 | (((unsigned int)m_wreg[reg_port*0x06 + 0x03]<< 8)&0x0000ff00) | |
| 315 | (((unsigned int)m_wreg[reg_port*0x06 + 0x02] )&0x000000ff) | |
| 316 | m_bank[reg_port]); |
| 317 | if (m_start[reg_port] < m_pcmlimit ){ |
| 318 | m_play[reg_port] = 1; |
| 319 | m_addr[reg_port] = 0; |
| 398 | 320 | } |
| 399 | 321 | break; |
| 400 | 322 | } |
| r23667 | r23668 | |
| 404 | 326 | /************************************************/ |
| 405 | 327 | /* Konami PCM read register */ |
| 406 | 328 | /************************************************/ |
| 407 | | READ8_DEVICE_HANDLER( k007232_r ) |
| 329 | READ8_MEMBER( k007232_device::read ) |
| 408 | 330 | { |
| 409 | | KDAC_A_PCM *info = get_safe_token(device); |
| 410 | 331 | int r = offset; |
| 411 | 332 | int ch = 0; |
| 412 | 333 | |
| r23667 | r23668 | |
| 414 | 335 | ch = r/0x0006; |
| 415 | 336 | r = ch * 0x0006; |
| 416 | 337 | |
| 417 | | info->start[ch] = |
| 418 | | ((((unsigned int)info->wreg[r + 0x04]<<16)&0x00010000) | |
| 419 | | (((unsigned int)info->wreg[r + 0x03]<< 8)&0x0000ff00) | |
| 420 | | (((unsigned int)info->wreg[r + 0x02] )&0x000000ff) | |
| 421 | | info->bank[ch]); |
| 338 | m_start[ch] = |
| 339 | ((((unsigned int)m_wreg[r + 0x04]<<16)&0x00010000) | |
| 340 | (((unsigned int)m_wreg[r + 0x03]<< 8)&0x0000ff00) | |
| 341 | (((unsigned int)m_wreg[r + 0x02] )&0x000000ff) | |
| 342 | m_bank[ch]); |
| 422 | 343 | |
| 423 | | if (info->start[ch] < info->pcmlimit ){ |
| 424 | | info->play[ch] = 1; |
| 425 | | info->addr[ch] = 0; |
| 344 | if (m_start[ch] < m_pcmlimit ){ |
| 345 | m_play[ch] = 1; |
| 346 | m_addr[ch] = 0; |
| 426 | 347 | } |
| 427 | 348 | } |
| 428 | 349 | return 0; |
| r23667 | r23668 | |
| 430 | 351 | |
| 431 | 352 | /*****************************************************************************/ |
| 432 | 353 | |
| 433 | | void k007232_set_volume(device_t *device,int channel,int volumeA,int volumeB) |
| 354 | void k007232_device::set_volume(int channel,int volumeA,int volumeB) |
| 434 | 355 | { |
| 435 | | KDAC_A_PCM *info = get_safe_token(device); |
| 436 | | info->vol[channel][0] = volumeA; |
| 437 | | info->vol[channel][1] = volumeB; |
| 356 | m_vol[channel][0] = volumeA; |
| 357 | m_vol[channel][1] = volumeB; |
| 438 | 358 | } |
| 439 | 359 | |
| 440 | | void k007232_set_bank( device_t *device, int chABank, int chBBank ) |
| 360 | void k007232_device::set_bank(int chABank, int chBBank ) |
| 441 | 361 | { |
| 442 | | KDAC_A_PCM *info = get_safe_token(device); |
| 443 | | info->bank[0] = chABank<<17; |
| 444 | | info->bank[1] = chBBank<<17; |
| 362 | m_bank[0] = chABank<<17; |
| 363 | m_bank[1] = chBBank<<17; |
| 445 | 364 | } |
| 446 | 365 | |
| 447 | 366 | /*****************************************************************************/ |
| 448 | 367 | |
| 449 | | const device_type K007232 = &device_creator<k007232_device>; |
| 450 | 368 | |
| 451 | | k007232_device::k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) |
| 452 | | : device_t(mconfig, K007232, "K007232", tag, owner, clock), |
| 453 | | device_sound_interface(mconfig, *this) |
| 454 | | { |
| 455 | | m_token = global_alloc_clear(KDAC_A_PCM); |
| 456 | | } |
| 457 | | |
| 458 | 369 | //------------------------------------------------- |
| 459 | | // device_config_complete - perform any |
| 460 | | // operations now that the configuration is |
| 461 | | // complete |
| 370 | // sound_stream_update - handle a stream update |
| 462 | 371 | //------------------------------------------------- |
| 463 | 372 | |
| 464 | | void k007232_device::device_config_complete() |
| 373 | void k007232_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) |
| 465 | 374 | { |
| 466 | | } |
| 375 | int i; |
| 467 | 376 | |
| 468 | | //------------------------------------------------- |
| 469 | | // device_start - device-specific startup |
| 470 | | //------------------------------------------------- |
| 377 | memset(outputs[0],0,samples * sizeof(*outputs[0])); |
| 378 | memset(outputs[1],0,samples * sizeof(*outputs[1])); |
| 471 | 379 | |
| 472 | | void k007232_device::device_start() |
| 473 | | { |
| 474 | | DEVICE_START_NAME( k007232 )(this); |
| 475 | | } |
| 380 | for( i = 0; i < KDAC_A_PCM_MAX; i++ ) |
| 381 | { |
| 382 | if (m_play[i]) |
| 383 | { |
| 384 | int volA,volB,j,out; |
| 385 | unsigned int addr, old_addr; |
| 386 | //int cen; |
| 476 | 387 | |
| 477 | | //------------------------------------------------- |
| 478 | | // sound_stream_update - handle a stream update |
| 479 | | //------------------------------------------------- |
| 388 | /**** PCM setup ****/ |
| 389 | addr = m_start[i] + ((m_addr[i]>>BASE_SHIFT)&0x000fffff); |
| 390 | volA = m_vol[i][0] * 2; |
| 391 | volB = m_vol[i][1] * 2; |
| 392 | #if 0 |
| 393 | cen = (volA + volB) / 2; |
| 394 | volA = (volA + cen) < 0x1fe ? (volA + cen) : 0x1fe; |
| 395 | volB = (volB + cen) < 0x1fe ? (volB + cen) : 0x1fe; |
| 396 | #endif |
| 480 | 397 | |
| 481 | | void k007232_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) |
| 482 | | { |
| 483 | | // should never get here |
| 484 | | fatalerror("sound_stream_update called; not applicable to legacy sound devices\n"); |
| 398 | for( j = 0; j < samples; j++ ) |
| 399 | { |
| 400 | old_addr = addr; |
| 401 | addr = m_start[i] + ((m_addr[i]>>BASE_SHIFT)&0x000fffff); |
| 402 | while (old_addr <= addr) |
| 403 | { |
| 404 | if( (m_pcmbuf[i][old_addr] & 0x80) || old_addr >= m_pcmlimit ) |
| 405 | { |
| 406 | /* end of sample */ |
| 407 | |
| 408 | if( m_wreg[0x0d]&(1<<i) ) |
| 409 | { |
| 410 | /* loop to the beginning */ |
| 411 | m_start[i] = |
| 412 | ((((unsigned int)m_wreg[i*0x06 + 0x04]<<16)&0x00010000) | |
| 413 | (((unsigned int)m_wreg[i*0x06 + 0x03]<< 8)&0x0000ff00) | |
| 414 | (((unsigned int)m_wreg[i*0x06 + 0x02] )&0x000000ff) | |
| 415 | m_bank[i]); |
| 416 | addr = m_start[i]; |
| 417 | m_addr[i] = 0; |
| 418 | old_addr = addr; /* skip loop */ |
| 419 | } |
| 420 | else |
| 421 | { |
| 422 | /* stop sample */ |
| 423 | m_play[i] = 0; |
| 424 | } |
| 425 | break; |
| 426 | } |
| 427 | |
| 428 | old_addr++; |
| 429 | } |
| 430 | |
| 431 | if (m_play[i] == 0) |
| 432 | break; |
| 433 | |
| 434 | m_addr[i] += m_step[i]; |
| 435 | |
| 436 | out = (m_pcmbuf[i][addr] & 0x7f) - 0x40; |
| 437 | |
| 438 | outputs[0][j] += out * volA; |
| 439 | outputs[1][j] += out * volB; |
| 440 | } |
| 441 | } |
| 442 | } |
| 485 | 443 | } |
trunk/src/emu/sound/k007232.h
| r23667 | r23668 | |
| 7 | 7 | #ifndef __K007232_H__ |
| 8 | 8 | #define __K007232_H__ |
| 9 | 9 | |
| 10 | | #include "devlegcy.h" |
| 10 | #define KDAC_A_PCM_MAX (2) /* Channels per chip */ |
| 11 | 11 | |
| 12 | 12 | struct k007232_interface |
| 13 | 13 | { |
| 14 | | devcb_write8 portwritehandler; |
| 14 | devcb_write8 m_portwritehandler; |
| 15 | 15 | }; |
| 16 | 16 | |
| 17 | | DECLARE_WRITE8_DEVICE_HANDLER( k007232_w ); |
| 18 | | DECLARE_READ8_DEVICE_HANDLER( k007232_r ); |
| 17 | class k007232_device : public device_t, |
| 18 | public device_sound_interface, |
| 19 | public k007232_interface |
| 20 | { |
| 21 | public: |
| 22 | k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 23 | ~k007232_device() {} |
| 19 | 24 | |
| 20 | | void k007232_set_bank( device_t *device, int chABank, int chBBank ); |
| 21 | | |
| 22 | | /* |
| 25 | DECLARE_WRITE8_MEMBER( write ); |
| 26 | DECLARE_READ8_MEMBER( read ); |
| 27 | |
| 28 | /* |
| 23 | 29 | The 007232 has two channels and produces two outputs. The volume control |
| 24 | 30 | is external, however to make it easier to use we handle that inside the |
| 25 | 31 | emulation. You can control volume and panning: for each of the two channels |
| 26 | 32 | you can set the volume of the two outputs. If panning is not required, |
| 27 | 33 | then volumeB will be 0 for channel 0, and volumeA will be 0 for channel 1. |
| 28 | 34 | Volume is in the range 0-255. |
| 29 | | */ |
| 30 | | void k007232_set_volume(device_t *device,int channel,int volumeA,int volumeB); |
| 31 | | |
| 32 | | class k007232_device : public device_t, |
| 33 | | public device_sound_interface |
| 34 | | { |
| 35 | | public: |
| 36 | | k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); |
| 37 | | ~k007232_device() { global_free(m_token); } |
| 38 | | |
| 39 | | // access to legacy token |
| 40 | | void *token() const { assert(m_token != NULL); return m_token; } |
| 35 | */ |
| 36 | void set_volume(int channel,int volumeA,int volumeB); |
| 37 | |
| 38 | void set_bank( int chABank, int chBBank ); |
| 39 | |
| 41 | 40 | protected: |
| 42 | 41 | // device-level overrides |
| 43 | 42 | virtual void device_config_complete(); |
| r23667 | r23668 | |
| 45 | 44 | |
| 46 | 45 | // sound stream update overrides |
| 47 | 46 | virtual void sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples); |
| 47 | |
| 48 | void KDAC_A_make_fncode(); |
| 49 | |
| 48 | 50 | private: |
| 49 | 51 | // internal state |
| 50 | | void *m_token; |
| 52 | UINT8 m_vol[KDAC_A_PCM_MAX][2]; /* volume for the left and right channel */ |
| 53 | UINT32 m_addr[KDAC_A_PCM_MAX]; |
| 54 | UINT32 m_start[KDAC_A_PCM_MAX]; |
| 55 | UINT32 m_step[KDAC_A_PCM_MAX]; |
| 56 | UINT32 m_bank[KDAC_A_PCM_MAX]; |
| 57 | int m_play[KDAC_A_PCM_MAX]; |
| 58 | |
| 59 | UINT8 m_wreg[0x10]; /* write data */ |
| 60 | UINT8 * m_pcmbuf[2]; /* Channel A & B pointers */ |
| 61 | |
| 62 | UINT32 m_pcmlimit; |
| 63 | |
| 64 | sound_stream * m_stream; |
| 65 | UINT32 m_fncode[0x200]; |
| 66 | devcb_resolved_write8 m_portwritehandler_func; |
| 51 | 67 | }; |
| 52 | 68 | |
| 53 | 69 | extern const device_type K007232; |