src/mame/drivers/firefox.c
| r14846 | r14847 | |
| 398 | 398 | |
| 399 | 399 | WRITE8_MEMBER(firefox_state::nvram_w) |
| 400 | 400 | { |
| 401 | | m_nvram_1c->write(*&space, offset, data >> 4); |
| 402 | | m_nvram_1d->write(*&space, offset, data & 0xf); |
| 401 | m_nvram_1c->write(space, offset, data >> 4); |
| 402 | m_nvram_1d->write(space, offset, data & 0xf); |
| 403 | 403 | } |
| 404 | 404 | |
| 405 | 405 | READ8_MEMBER(firefox_state::nvram_r) |
| 406 | 406 | { |
| 407 | | return (m_nvram_1c->read(*&space, offset) << 4) | (m_nvram_1d->read(*&space, offset) & 0x0f); |
| 407 | return (m_nvram_1c->read(space, offset) << 4) | (m_nvram_1d->read(space, offset) & 0x0f); |
| 408 | 408 | } |
| 409 | 409 | |
| 410 | 410 | WRITE8_MEMBER(firefox_state::novram_recall_w) |
src/mame/drivers/aristmk4.c
| r14846 | r14847 | |
| 526 | 526 | { |
| 527 | 527 | /* uncomment this code once RTC is fixed */ |
| 528 | 528 | |
| 529 | | //return machine().device<mc146818_device>("rtc")->read(*&space,1); |
| 529 | //return machine().device<mc146818_device>("rtc")->read(space,1); |
| 530 | 530 | return 0; // OK for now, the aussie version has no RTC on the MB so this is valid. |
| 531 | 531 | } |
| 532 | 532 | |
| r14846 | r14847 | |
| 536 | 536 | mc146818_device *mc = machine().device<mc146818_device>("rtc"); |
| 537 | 537 | if(m_rtc_data_strobe) |
| 538 | 538 | { |
| 539 | | mc->write(*&space,1,data); |
| 539 | mc->write(space,1,data); |
| 540 | 540 | //logerror("rtc protocol write data: %02X\n",data); |
| 541 | 541 | } |
| 542 | 542 | else |
| 543 | 543 | { |
| 544 | | mc->write(*&space,0,data); |
| 544 | mc->write(space,0,data); |
| 545 | 545 | //logerror("rtc protocol write address: %02X\n",data); |
| 546 | 546 | } |
| 547 | 547 | } |
src/mame/drivers/acommand.c
| r14846 | r14847 | |
| 321 | 321 | return input_port_read(machine(), "IN0"); |
| 322 | 322 | case 0x0014/2: |
| 323 | 323 | case 0x0016/2: |
| 324 | | return machine().device<okim6295_device>("oki1")->read(*&space,0); |
| 324 | return machine().device<okim6295_device>("oki1")->read(space,0); |
| 325 | 325 | case 0x0018/2: |
| 326 | 326 | case 0x001a/2: |
| 327 | | return machine().device<okim6295_device>("oki2")->read(*&space,0); |
| 327 | return machine().device<okim6295_device>("oki2")->read(space,0); |
| 328 | 328 | case 0x0040/2: |
| 329 | 329 | /* |
| 330 | 330 | "Upper switch / Under Switch" |
| r14846 | r14847 | |
| 413 | 413 | if(ACCESSING_BITS_0_7) |
| 414 | 414 | { |
| 415 | 415 | okim6295_device *oki1 = machine().device<okim6295_device>("oki1"); |
| 416 | | oki1->write(*&space,0,data); |
| 416 | oki1->write(space,0,data); |
| 417 | 417 | } |
| 418 | 418 | break; |
| 419 | 419 | case 0x18/2: |
| r14846 | r14847 | |
| 421 | 421 | if(ACCESSING_BITS_0_7) |
| 422 | 422 | { |
| 423 | 423 | okim6295_device *oki2 = machine().device<okim6295_device>("oki2"); |
| 424 | | oki2->write(*&space,0,data); |
| 424 | oki2->write(space,0,data); |
| 425 | 425 | } |
| 426 | 426 | break; |
| 427 | 427 | case 0x1c/2: |
src/mame/drivers/spool99.c
| r14846 | r14847 | |
| 178 | 178 | // case 0xafe5: return 1; |
| 179 | 179 | // case 0xafe6: return 1; |
| 180 | 180 | case 0xafe7: return machine().device<eeprom_device>("eeprom")->read_bit(); |
| 181 | | case 0xaff8: return machine().device<okim6295_device>("oki")->read(*&space,0); |
| 181 | case 0xaff8: return machine().device<okim6295_device>("oki")->read(space,0); |
| 182 | 182 | } |
| 183 | 183 | } |
| 184 | 184 | // printf("%04x %d\n",offset+0xaf00,io_switch); |
| r14846 | r14847 | |
| 239 | 239 | case 0xa725: return input_port_read(machine(),"HOLD3"); |
| 240 | 240 | case 0xa726: return input_port_read(machine(),"HOLD4"); |
| 241 | 241 | case 0xa727: return input_port_read(machine(),"HOLD2"); |
| 242 | | case 0xa780: return machine().device<okim6295_device>("oki")->read(*&space,0); |
| 242 | case 0xa780: return machine().device<okim6295_device>("oki")->read(space,0); |
| 243 | 243 | case 0xa7a0: return input_port_read(machine(),"HOLD1"); |
| 244 | 244 | case 0xa7a1: return input_port_read(machine(),"HOLD5"); |
| 245 | 245 | case 0xa7a2: return input_port_read(machine(),"START"); |
src/mame/drivers/blitz68k.c
| r14846 | r14847 | |
| 841 | 841 | { |
| 842 | 842 | mc6845_device *mc6845 = machine().device<mc6845_device>("crtc"); |
| 843 | 843 | if (offset) |
| 844 | | return mc6845->register_r(*&space, 0); |
| 844 | return mc6845->register_r(space, 0); |
| 845 | 845 | else |
| 846 | | return mc6845->status_r(*&space, 0); |
| 846 | return mc6845->status_r(space, 0); |
| 847 | 847 | } |
| 848 | 848 | |
| 849 | 849 | WRITE8_MEMBER(blitz68k_state::crtc_w) |
| 850 | 850 | { |
| 851 | 851 | mc6845_device *mc6845 = machine().device<mc6845_device>("crtc"); |
| 852 | 852 | if (offset) |
| 853 | | mc6845->register_w(*&space, 0, data); |
| 853 | mc6845->register_w(space, 0, data); |
| 854 | 854 | else |
| 855 | | mc6845->address_w(*&space, 0, data); |
| 855 | mc6845->address_w(space, 0, data); |
| 856 | 856 | } |
| 857 | 857 | |
| 858 | 858 | static WRITE16_DEVICE_HANDLER( crtc_lpen_w ) |
src/mess/drivers/pc9801.c
| r14846 | r14847 | |
| 651 | 651 | } |
| 652 | 652 | else // odd |
| 653 | 653 | { |
| 654 | | return machine().device<i8255_device>("ppi8255_sys")->read(*&space, (offset & 6) >> 1); |
| 654 | return machine().device<i8255_device>("ppi8255_sys")->read(space, (offset & 6) >> 1); |
| 655 | 655 | } |
| 656 | 656 | } |
| 657 | 657 | |
| r14846 | r14847 | |
| 666 | 666 | } |
| 667 | 667 | else // odd |
| 668 | 668 | { |
| 669 | | machine().device<i8255_device>("ppi8255_sys")->write(*&space, (offset & 6) >> 1,data); |
| 669 | machine().device<i8255_device>("ppi8255_sys")->write(space, (offset & 6) >> 1,data); |
| 670 | 670 | } |
| 671 | 671 | } |
| 672 | 672 | |
| r14846 | r14847 | |
| 675 | 675 | |
| 676 | 676 | if((offset & 1) == 0) |
| 677 | 677 | { |
| 678 | | return machine().device<i8255_device>("ppi8255_prn")->read(*&space, (offset & 6) >> 1); |
| 678 | return machine().device<i8255_device>("ppi8255_prn")->read(space, (offset & 6) >> 1); |
| 679 | 679 | } |
| 680 | 680 | else // odd |
| 681 | 681 | { |
| r14846 | r14847 | |
| 704 | 704 | { |
| 705 | 705 | if((offset & 1) == 0) |
| 706 | 706 | { |
| 707 | | machine().device<i8255_device>("ppi8255_prn")->write(*&space, (offset & 6) >> 1,data); |
| 707 | machine().device<i8255_device>("ppi8255_prn")->write(space, (offset & 6) >> 1,data); |
| 708 | 708 | } |
| 709 | 709 | else // odd |
| 710 | 710 | { |
| r14846 | r14847 | |
| 729 | 729 | } |
| 730 | 730 | else // odd |
| 731 | 731 | { |
| 732 | | return machine().device<i8255_device>("ppi8255_fdd")->read(*&space, (offset & 6) >> 1); |
| 732 | return machine().device<i8255_device>("ppi8255_fdd")->read(space, (offset & 6) >> 1); |
| 733 | 733 | } |
| 734 | 734 | } |
| 735 | 735 | |
| r14846 | r14847 | |
| 746 | 746 | } |
| 747 | 747 | else // odd |
| 748 | 748 | { |
| 749 | | machine().device<i8255_device>("ppi8255_fdd")->write(*&space, (offset & 6) >> 1,data); |
| 749 | machine().device<i8255_device>("ppi8255_fdd")->write(space, (offset & 6) >> 1,data); |
| 750 | 750 | } |
| 751 | 751 | } |
| 752 | 752 | |
| r14846 | r14847 | |
| 755 | 755 | |
| 756 | 756 | if((offset & 1) == 0) |
| 757 | 757 | { |
| 758 | | return m_hgdc1->read(*&space, (offset & 2) >> 1); // upd7220 character port |
| 758 | return m_hgdc1->read(space, (offset & 2) >> 1); // upd7220 character port |
| 759 | 759 | } |
| 760 | 760 | else // odd |
| 761 | 761 | { |
| r14846 | r14847 | |
| 769 | 769 | |
| 770 | 770 | if((offset & 1) == 0) |
| 771 | 771 | { |
| 772 | | m_hgdc1->write(*&space, (offset & 2) >> 1,data); // upd7220 character port |
| 772 | m_hgdc1->write(space, (offset & 2) >> 1,data); // upd7220 character port |
| 773 | 773 | } |
| 774 | 774 | else // odd |
| 775 | 775 | { |
| r14846 | r14847 | |
| 891 | 891 | { |
| 892 | 892 | case 0x00: |
| 893 | 893 | case 0x02: |
| 894 | | return m_hgdc2->read(*&space, (offset & 2) >> 1); |
| 894 | return m_hgdc2->read(space, (offset & 2) >> 1); |
| 895 | 895 | /* bitmap palette clut read */ |
| 896 | 896 | case 0x04: |
| 897 | 897 | return m_vram_disp & 1; |
| r14846 | r14847 | |
| 932 | 932 | { |
| 933 | 933 | case 0x00: |
| 934 | 934 | case 0x02: |
| 935 | | m_hgdc2->write(*&space, (offset & 2) >> 1,data); |
| 935 | m_hgdc2->write(space, (offset & 2) >> 1,data); |
| 936 | 936 | return; |
| 937 | 937 | case 0x04: m_vram_disp = data & 1; return; |
| 938 | 938 | case 0x06: |
| 939 | 939 | m_vram_bank = data & 1; |
| 940 | | //m_hgdc2->bank_w(*&space, 0,(data & 1) << 2); //TODO: check me |
| 940 | //m_hgdc2->bank_w(space, 0,(data & 1) << 2); //TODO: check me |
| 941 | 941 | return; |
| 942 | 942 | /* bitmap palette clut write */ |
| 943 | 943 | case 0x08: |
| r14846 | r14847 | |
| 1005 | 1005 | { |
| 1006 | 1006 | switch((offset & 6) + 1) |
| 1007 | 1007 | { |
| 1008 | | case 1: return m_sio->data_r(*&space, 0); |
| 1009 | | case 3: return m_sio->status_r(*&space, 0); |
| 1008 | case 1: return m_sio->data_r(space, 0); |
| 1009 | case 3: return m_sio->status_r(space, 0); |
| 1010 | 1010 | } |
| 1011 | 1011 | printf("Read to undefined port [%02x]\n",offset+0x90); |
| 1012 | 1012 | return 0xff; |
| r14846 | r14847 | |
| 1043 | 1043 | { |
| 1044 | 1044 | switch((offset & 6) + 1) |
| 1045 | 1045 | { |
| 1046 | | case 1: m_sio->data_w(*&space, 0, data); return; |
| 1047 | | case 3: m_sio->control_w(*&space, 0, data); return; |
| 1046 | case 1: m_sio->data_w(space, 0, data); return; |
| 1047 | case 3: m_sio->control_w(space, 0, data); return; |
| 1048 | 1048 | } |
| 1049 | 1049 | printf("Write to undefined port [%02x] <- %02x\n",offset+0x90,data); |
| 1050 | 1050 | } |
src/mess/drivers/pc6001.c
| r14846 | r14847 | |
| 777 | 777 | return res; |
| 778 | 778 | } |
| 779 | 779 | |
| 780 | | return m_ppi->read(*&space, offset); |
| 780 | return m_ppi->read(space, offset); |
| 781 | 781 | } |
| 782 | 782 | |
| 783 | 783 | WRITE8_MEMBER(pc6001_state::nec_ppi8255_w) |
| r14846 | r14847 | |
| 811 | 811 | memory_set_bankptr(machine(), "bank1", &gfx_data[0]); |
| 812 | 812 | } |
| 813 | 813 | } |
| 814 | | m_ppi->write(*&space,offset,data); |
| 814 | m_ppi->write(space,offset,data); |
| 815 | 815 | } |
| 816 | 816 | |
| 817 | 817 | static ADDRESS_MAP_START(pc6001_map, AS_PROGRAM, 8, pc6001_state ) |
| r14846 | r14847 | |
| 1163 | 1163 | } |
| 1164 | 1164 | } |
| 1165 | 1165 | } |
| 1166 | | m_ppi->write(*&space,offset,data); |
| 1166 | m_ppi->write(space,offset,data); |
| 1167 | 1167 | } |
| 1168 | 1168 | |
| 1169 | 1169 | static void vram_bank_change(running_machine &machine,UINT8 vram_bank) |
| r14846 | r14847 | |
| 1597 | 1597 | memory_set_bankptr(machine(), "bank1", &gfx_data[0]); |
| 1598 | 1598 | } |
| 1599 | 1599 | } |
| 1600 | | m_ppi->write(*&space,offset,data); |
| 1600 | m_ppi->write(space,offset,data); |
| 1601 | 1601 | } |
| 1602 | 1602 | |
| 1603 | 1603 | |
src/mess/drivers/sgi_ip2.c
| r14846 | r14847 | |
| 170 | 170 | READ8_MEMBER(sgi_ip2_state::sgi_ip2_clock_ctl_r) |
| 171 | 171 | { |
| 172 | 172 | mc146818_device *rtc = machine().device<mc146818_device>("rtc"); |
| 173 | | UINT8 ret = rtc->read(*&space, 1); |
| 173 | UINT8 ret = rtc->read(space, 1); |
| 174 | 174 | verboselog(machine(), 1, "sgi_ip2_clock_ctl_r: %02x\n", ret); |
| 175 | 175 | return ret; |
| 176 | 176 | } |
| r14846 | r14847 | |
| 179 | 179 | { |
| 180 | 180 | verboselog(machine(), 1, "sgi_ip2_clock_ctl_w: %02x\n", data); |
| 181 | 181 | mc146818_device *rtc = machine().device<mc146818_device>("rtc"); |
| 182 | | rtc->write(*&space, 1, data); |
| 182 | rtc->write(space, 1, data); |
| 183 | 183 | } |
| 184 | 184 | |
| 185 | 185 | READ8_MEMBER(sgi_ip2_state::sgi_ip2_clock_data_r) |
| 186 | 186 | { |
| 187 | 187 | mc146818_device *rtc = machine().device<mc146818_device>("rtc"); |
| 188 | | UINT8 ret = rtc->read(*&space, 0); |
| 188 | UINT8 ret = rtc->read(space, 0); |
| 189 | 189 | |
| 190 | 190 | verboselog(machine(), 1, "sgi_ip2_clock_data_r: %02x\n", ret); |
| 191 | 191 | return ret; |
| r14846 | r14847 | |
| 195 | 195 | { |
| 196 | 196 | verboselog(machine(), 1, "sgi_ip2_clock_data_w: %02x\n", data); |
| 197 | 197 | mc146818_device *rtc = machine().device<mc146818_device>("rtc"); |
| 198 | | rtc->write(*&space, 0, data); |
| 198 | rtc->write(space, 0, data); |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | 201 | |
src/mess/drivers/mmodular.c
| r14846 | r14847 | |
| 237 | 237 | if (BIT(data,1)) { |
| 238 | 238 | hd44780_device *hd44780 = machine().device<hd44780_device>("hd44780"); |
| 239 | 239 | if (BIT(data,0)) { |
| 240 | | hd44780->data_write(*&space, 128, lcd_char); |
| 240 | hd44780->data_write(space, 128, lcd_char); |
| 241 | 241 | } else { |
| 242 | | hd44780->control_write(*&space, 128, lcd_char); |
| 242 | hd44780->control_write(space, 128, lcd_char); |
| 243 | 243 | } |
| 244 | 244 | } |
| 245 | 245 | |
| r14846 | r14847 | |
| 328 | 328 | { |
| 329 | 329 | hd44780_device *hd44780 = machine().device<hd44780_device>("hd44780"); |
| 330 | 330 | if(BIT(sfortea_latch,0)) { |
| 331 | | hd44780->data_write(*&space, 128, data); |
| 331 | hd44780->data_write(space, 128, data); |
| 332 | 332 | logerror("LCD DTA = %02x\n",data); |
| 333 | 333 | } else { |
| 334 | 334 | if (BIT(data,7)) { |
| 335 | 335 | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8 |
| 336 | 336 | } |
| 337 | | hd44780->control_write(*&space, 128, data); |
| 337 | hd44780->control_write(space, 128, data); |
| 338 | 338 | logerror("LCD CMD = %02x\n",data); |
| 339 | 339 | } |
| 340 | 340 | } |
| r14846 | r14847 | |
| 345 | 345 | hd44780_device *hd44780 = machine().device<hd44780_device>("hd44780"); |
| 346 | 346 | |
| 347 | 347 | if (offset) { |
| 348 | | hd44780->data_write(*&space, 128, data); |
| 348 | hd44780->data_write(space, 128, data); |
| 349 | 349 | } else { |
| 350 | | hd44780->control_write(*&space, 128, data); |
| 350 | hd44780->control_write(space, 128, data); |
| 351 | 351 | } |
| 352 | 352 | } |
| 353 | 353 | |
| r14846 | r14847 | |
| 393 | 393 | if (BIT(data,7)) { |
| 394 | 394 | if ((data & 0x7f) >= 0x40) data -= 56; // adjust for 16x1 display as 2 sets of 8 |
| 395 | 395 | } |
| 396 | | hd44780->control_write(*&space, 128, data); |
| 396 | hd44780->control_write(space, 128, data); |
| 397 | 397 | // logerror("Control %02x\n", data); |
| 398 | 398 | // printf("Control %02x\n", data); |
| 399 | 399 | } else { |
| 400 | | hd44780->data_write(*&space, 128, data); |
| 400 | hd44780->data_write(space, 128, data); |
| 401 | 401 | // printf("LCDdata %04x [%c]\n", data,data); |
| 402 | 402 | // logerror("LCDdata %04x [%c]\n", data,data); |
| 403 | 403 | } |
src/mess/drivers/ip20.c
| r14846 | r14847 | |
| 165 | 165 | case 0x0d00: |
| 166 | 166 | verboselog(machine(), 2, "HPC DUART0 Channel B Control Read\n" ); |
| 167 | 167 | // return 0x00000004; |
| 168 | | return 0x7c; //scc->reg_r(*&space, 0); |
| 168 | return 0x7c; //scc->reg_r(space, 0); |
| 169 | 169 | case 0x0d04: |
| 170 | 170 | verboselog(machine(), 2, "HPC DUART0 Channel B Data Read\n" ); |
| 171 | 171 | // return 0; |
| 172 | 172 | scc = machine().device<scc8530_t>("scc"); |
| 173 | | return scc->reg_r(*&space, 2); |
| 173 | return scc->reg_r(space, 2); |
| 174 | 174 | case 0x0d08: |
| 175 | 175 | verboselog(machine(), 2, "HPC DUART0 Channel A Control Read (%08x)\n", mem_mask ); |
| 176 | 176 | // return 0x40; |
| 177 | | return 0x7c; //scc->reg_r(*&space, 1); |
| 177 | return 0x7c; //scc->reg_r(space, 1); |
| 178 | 178 | case 0x0d0c: |
| 179 | 179 | verboselog(machine(), 2, "HPC DUART0 Channel A Data Read\n" ); |
| 180 | 180 | // return 0; |
| 181 | 181 | scc = machine().device<scc8530_t>("scc"); |
| 182 | | return scc->reg_r(*&space, 3); |
| 182 | return scc->reg_r(space, 3); |
| 183 | 183 | case 0x0d10: |
| 184 | 184 | // verboselog(machine, 2, "HPC DUART1 Channel B Control Read\n" ); |
| 185 | 185 | return 0x00000004; |
| r14846 | r14847 | |
| 361 | 361 | case 0x0d00: |
| 362 | 362 | verboselog(machine(), 2, "HPC DUART0 Channel B Control Write: %08x (%08x)\n", data, mem_mask ); |
| 363 | 363 | scc = machine().device<scc8530_t>("scc"); |
| 364 | | scc->reg_w(*&space, 0, data); |
| 364 | scc->reg_w(space, 0, data); |
| 365 | 365 | break; |
| 366 | 366 | case 0x0d04: |
| 367 | 367 | verboselog(machine(), 2, "HPC DUART0 Channel B Data Write: %08x (%08x)\n", data, mem_mask ); |
| 368 | 368 | scc = machine().device<scc8530_t>("scc"); |
| 369 | | scc->reg_w(*&space, 2, data); |
| 369 | scc->reg_w(space, 2, data); |
| 370 | 370 | break; |
| 371 | 371 | case 0x0d08: |
| 372 | 372 | verboselog(machine(), 2, "HPC DUART0 Channel A Control Write: %08x (%08x)\n", data, mem_mask ); |
| 373 | 373 | scc = machine().device<scc8530_t>("scc"); |
| 374 | | scc->reg_w(*&space, 1, data); |
| 374 | scc->reg_w(space, 1, data); |
| 375 | 375 | break; |
| 376 | 376 | case 0x0d0c: |
| 377 | 377 | verboselog(machine(), 2, "HPC DUART0 Channel A Data Write: %08x (%08x)\n", data, mem_mask ); |
| 378 | 378 | scc = machine().device<scc8530_t>("scc"); |
| 379 | | scc->reg_w(*&space, 3, data); |
| 379 | scc->reg_w(space, 3, data); |
| 380 | 380 | break; |
| 381 | 381 | case 0x0d10: |
| 382 | 382 | if( ( data & 0x000000ff ) >= 0x00000020 ) |