Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-01 08:18:59 +03:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

chihiro.cpp, xbox.cpp: Eliminate machine().device (nw)

Browse Source
This commit is contained in:
AJR 2018-06-30 22:16:05 -04:00
parent 811766c06e
commit 8e6155337f
2 changed files with 65 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
src/mame/drivers/chihiro.cpp
View File

@ -498,8 +498,9 @@ private:
uint8_t buffer_out[32768]; uint8_t buffer_out[32768];
int buffer_out_used; int buffer_out_used;
int buffer_out_packets; int buffer_out_packets;
jvs_master *master;
} jvs; } jvs;
required_device<jvs_master> m_jvs_master;
}; };
DEFINE_DEVICE_TYPE(OHCI_HLEAN2131QC, ohci_hlean2131qc_device, "ohci_hlean2131qc", "OHCI an2131qc HLE") DEFINE_DEVICE_TYPE(OHCI_HLEAN2131QC, ohci_hlean2131qc_device, "ohci_hlean2131qc", "OHCI an2131qc HLE")
@ -561,14 +562,22 @@ DEFINE_DEVICE_TYPE(OHCI_HLEAN2131SC, ohci_hlean2131sc_device, "ohci_hlean2131sc"
class chihiro_state : public xbox_base_state class chihiro_state : public xbox_base_state
{ {
public: friend class ide_baseboard_device;
chihiro_state(const machine_config &mconfig, device_type type, const char *tag) :
xbox_base_state(mconfig, type, tag),
hack_index(-1),
hack_counter(0),
dimm_board_memory(nullptr),
dimm_board_memory_size(0) { }
public:
chihiro_state(const machine_config &mconfig, device_type type, const char *tag)
: xbox_base_state(mconfig, type, tag)
, m_ide(*this, "ide")
, m_dimmboard(*this, "rom_board")
, m_hack_index(-1)
, m_hack_counter(0)
, m_dimm_board_memory(nullptr)
, m_dimm_board_memory_size(0) { }
void chihirogd(machine_config &config);
void chihiro_base(machine_config &config);
private:
DECLARE_READ32_MEMBER(mediaboard_r); DECLARE_READ32_MEMBER(mediaboard_r);
DECLARE_WRITE32_MEMBER(mediaboard_w); DECLARE_WRITE32_MEMBER(mediaboard_w);
@ -580,22 +589,20 @@ public:
virtual void hack_eeprom() override; virtual void hack_eeprom() override;
virtual void hack_usb() override; virtual void hack_usb() override;
struct chihiro_devices { // devices
bus_master_ide_controller_device *ide; optional_device<bus_master_ide_controller_device> m_ide;
naomi_gdrom_board *dimmboard; optional_device<naomi_gdrom_board> m_dimmboard;
} chihiro_devs;
int hack_index; int m_hack_index;
int hack_counter; int m_hack_counter;
uint8_t *dimm_board_memory; uint8_t *m_dimm_board_memory;
uint32_t dimm_board_memory_size; uint32_t m_dimm_board_memory_size;
static void an2131qc_configuration(device_t *device); static void an2131qc_configuration(device_t *device);
static void an2131sc_configuration(device_t *device); static void an2131sc_configuration(device_t *device);
void chihirogd(machine_config &config);
void chihiro_base(machine_config &config);
void chihiro_map(address_map &map); void chihiro_map(address_map &map);
void chihiro_map_io(address_map &map); void chihiro_map_io(address_map &map);
private:
void jamtable_disasm(address_space &space, uint32_t address, uint32_t size); void jamtable_disasm(address_space &space, uint32_t address, uint32_t size);
void jamtable_disasm_command(int ref, const std::vector<std::string> &params); void jamtable_disasm_command(int ref, const std::vector<std::string> &params);
void chihiro_help_command(int ref, const std::vector<std::string> &params); void chihiro_help_command(int ref, const std::vector<std::string> &params);
@ -776,8 +783,8 @@ void chihiro_state::hack_usb()
{ {
int p; int p;
if (hack_counter == 1) if (m_hack_counter == 1)
p = hack_index; // need to patch the game p = m_hack_index; // need to patch the game
else else
p = -1; p = -1;
if (p >= 0) { if (p >= 0) {
@ -787,7 +794,7 @@ void chihiro_state::hack_usb()
m_maincpu->space(0).write_byte(hacks[p].modify[a].address, hacks[p].modify[a].write_byte); m_maincpu->space(0).write_byte(hacks[p].modify[a].address, hacks[p].modify[a].write_byte);
} }
} }
hack_counter++; m_hack_counter++;
} }
//************************************************************************** //**************************************************************************
@ -812,10 +819,11 @@ const uint8_t ohci_hlean2131qc_device::strdesc0[] = { 0x04,0x03,0x00,0x00 };
const uint8_t ohci_hlean2131qc_device::strdesc1[] = { 0x0A,0x03,0x53,0x00,0x45,0x00,0x47,0x00,0x41,0x00 }; const uint8_t ohci_hlean2131qc_device::strdesc1[] = { 0x0A,0x03,0x53,0x00,0x45,0x00,0x47,0x00,0x41,0x00 };
const uint8_t ohci_hlean2131qc_device::strdesc2[] = { 0x0E,0x03,0x42,0x00,0x41,0x00,0x53,0x00,0x45,0x00,0x42,0x03,0xFF,0x0B }; const uint8_t ohci_hlean2131qc_device::strdesc2[] = { 0x0E,0x03,0x42,0x00,0x41,0x00,0x53,0x00,0x45,0x00,0x42,0x03,0xFF,0x0B };
ohci_hlean2131qc_device::ohci_hlean2131qc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : ohci_hlean2131qc_device::ohci_hlean2131qc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
device_t(mconfig, OHCI_HLEAN2131QC, tag, owner, clock), : device_t(mconfig, OHCI_HLEAN2131QC, tag, owner, clock)
ohci_function(), , ohci_function()
device_slot_card_interface(mconfig, *this) , device_slot_card_interface(mconfig, *this)
, m_jvs_master(*this, "^^^^jvs_master")
{ {
maximum_send = 0; maximum_send = 0;
region_tag = nullptr; region_tag = nullptr;
@ -824,7 +832,6 @@ ohci_hlean2131qc_device::ohci_hlean2131qc_device(const machine_config &mconfig,
jvs.buffer_in_expected = 0; jvs.buffer_in_expected = 0;
jvs.buffer_out_used = 0; jvs.buffer_out_used = 0;
jvs.buffer_out_packets = 0; jvs.buffer_out_packets = 0;
jvs.master = nullptr;
} }
void ohci_hlean2131qc_device::initialize(running_machine &machine) void ohci_hlean2131qc_device::initialize(running_machine &machine)
@ -847,7 +854,6 @@ void ohci_hlean2131qc_device::initialize(running_machine &machine)
add_string_descriptor(strdesc0); add_string_descriptor(strdesc0);
add_string_descriptor(strdesc1); add_string_descriptor(strdesc1);
add_string_descriptor(strdesc2); add_string_descriptor(strdesc2);
jvs.master = machine.device<jvs_master>("jvs_master");
} }
void ohci_hlean2131qc_device::set_region_base(uint8_t *data) void ohci_hlean2131qc_device::set_region_base(uint8_t *data)
@ -873,7 +879,7 @@ int ohci_hlean2131qc_device::handle_nonstandard_request(int endpoint, USBSetupPa
// default valuse for data stage // default valuse for data stage
for (int n = 0; n < setup->wLength; n++) for (int n = 0; n < setup->wLength; n++)
endpoints[endpoint].buffer[n] = 0x50 ^ n; endpoints[endpoint].buffer[n] = 0x50 ^ n;
sense = jvs.master->get_sense_line(); sense = m_jvs_master->get_sense_line();
if (sense == 25) if (sense == 25)
sense = 3; sense = 3;
else else
@ -1091,11 +1097,11 @@ void ohci_hlean2131qc_device::process_jvs_packet()
continue; continue;
} }
// use data of this packet // use data of this packet
jvs.master->send_packet(dest, len, jvs.buffer_in + p); m_jvs_master->send_packet(dest, len, jvs.buffer_in + p);
// generate response // generate response
if (dest == 0xff) if (dest == 0xff)
dest = 0; dest = 0;
int recv = jvs.master->received_packet(jvs.buffer_out + jvs.buffer_out_used + 5); int recv = m_jvs_master->received_packet(jvs.buffer_out + jvs.buffer_out_used + 5);
// update buffer_out // update buffer_out
if (recv > 0) if (recv > 0)
{ {
@ -1142,10 +1148,10 @@ const uint8_t ohci_hlean2131sc_device::strdesc0[] = { 0x04,0x03,0x00,0x00 };
const uint8_t ohci_hlean2131sc_device::strdesc1[] = { 0x0A,0x03,0x53,0x00,0x45,0x00,0x47,0x00,0x41,0x00 }; const uint8_t ohci_hlean2131sc_device::strdesc1[] = { 0x0A,0x03,0x53,0x00,0x45,0x00,0x47,0x00,0x41,0x00 };
const uint8_t ohci_hlean2131sc_device::strdesc2[] = { 0x0E,0x03,0x42,0x00,0x41,0x00,0x53,0x00,0x45,0x00,0x42,0x00,0x44,0x00 }; const uint8_t ohci_hlean2131sc_device::strdesc2[] = { 0x0E,0x03,0x42,0x00,0x41,0x00,0x53,0x00,0x45,0x00,0x42,0x00,0x44,0x00 };
ohci_hlean2131sc_device::ohci_hlean2131sc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : ohci_hlean2131sc_device::ohci_hlean2131sc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
device_t(mconfig, OHCI_HLEAN2131SC, tag, owner, clock), : device_t(mconfig, OHCI_HLEAN2131SC, tag, owner, clock)
ohci_function(), , ohci_function()
device_slot_card_interface(mconfig, *this) , device_slot_card_interface(mconfig, *this)
{ {
region = nullptr; region = nullptr;
region_tag = nullptr; region_tag = nullptr;
@ -1666,8 +1672,8 @@ void chihiro_state::baseboard_ide_event(int type, uint8_t *read_buffer, uint8_t
uint8_t *chihiro_state::baseboard_ide_dimmboard(uint32_t lba) uint8_t *chihiro_state::baseboard_ide_dimmboard(uint32_t lba)
{ {
// return pointer to memory containing decrypted gdrom data (contains an image of a fatx partition) // return pointer to memory containing decrypted gdrom data (contains an image of a fatx partition)
if (chihiro_devs.dimmboard != nullptr) if (m_dimmboard.found())
return dimm_board_memory + lba * 512; return &m_dimm_board_memory[lba * 512];
return nullptr; return nullptr;
} }
@ -1774,25 +1780,24 @@ static INPUT_PORTS_START(chihiro)
void chihiro_state::machine_start() void chihiro_state::machine_start()
{ {
xbox_base_state::machine_start(); xbox_base_state::machine_start();
chihiro_devs.ide = machine().device<bus_master_ide_controller_device>("ide");
chihiro_devs.dimmboard = machine().device<naomi_gdrom_board>("rom_board"); if (m_dimmboard.found())
if (chihiro_devs.dimmboard != nullptr) { m_dimm_board_memory = m_dimmboard->memory(m_dimm_board_memory_size);
dimm_board_memory = chihiro_devs.dimmboard->memory(dimm_board_memory_size);
}
if (machine().debug_flags & DEBUG_FLAG_ENABLED) if (machine().debug_flags & DEBUG_FLAG_ENABLED)
{ {
using namespace std::placeholders; using namespace std::placeholders;
machine().debugger().console().register_command("chihiro", CMDFLAG_NONE, 0, 1, 4, std::bind(&chihiro_state::debug_commands, this, _1, _2)); machine().debugger().console().register_command("chihiro", CMDFLAG_NONE, 0, 1, 4, std::bind(&chihiro_state::debug_commands, this, _1, _2));
} }
hack_index = -1; m_hack_index = -1;
for (int a = 1; a < HACK_ITEMS; a++) for (int a = 1; a < HACK_ITEMS; a++)
if (strcmp(machine().basename(), hacks[a].game_name) == 0) { if (strcmp(machine().basename(), hacks[a].game_name) == 0) {
hack_index = a; m_hack_index = a;
break; break;
} }
hack_counter = 0; m_hack_counter = 0;
// savestates // savestates
save_item(NAME(hack_counter)); save_item(NAME(m_hack_counter));
} }
class sega_network_board : public device_t class sega_network_board : public device_t

27
src/mame/drivers/xbox.cpp
View File

@ -31,14 +31,18 @@
class xbox_state : public xbox_base_state class xbox_state : public xbox_base_state
{ {
public: public:
xbox_state(const machine_config &mconfig, device_type type, const char *tag) : xbox_state(const machine_config &mconfig, device_type type, const char *tag)
xbox_base_state(mconfig, type, tag) : xbox_base_state(mconfig, type, tag)
, m_ide(*this, "ide")
, m_devh(*this, "pci:09.0:ide:0:hdd")
, m_devc(*this, "pci:09.0:ide:1:cdrom")
{ } { }
void xbox(machine_config &config); void xbox(machine_config &config);
protected:
void xbox_map(address_map &map); void xbox_map(address_map &map);
void xbox_map_io(address_map &map); void xbox_map_io(address_map &map);
protected:
// driver_device overrides // driver_device overrides
virtual void machine_start() override; virtual void machine_start() override;
virtual void machine_reset() override; virtual void machine_reset() override;
@ -46,9 +50,10 @@ protected:
virtual void hack_eeprom() override; virtual void hack_eeprom() override;
struct chihiro_devices { // devices
bus_master_ide_controller_device *ide; optional_device<bus_master_ide_controller_device> m_ide;
} xbox_devs; required_device<ata_mass_storage_device> m_devh;
required_device<atapi_cdrom_device> m_devc;
}; };
void xbox_state::video_start() void xbox_state::video_start()
@ -136,24 +141,20 @@ void xbox_state::hack_eeprom()
void xbox_state::machine_start() void xbox_state::machine_start()
{ {
xbox_base_state::machine_start(); xbox_base_state::machine_start();
xbox_devs.ide = machine().device<bus_master_ide_controller_device>("ide");
// savestates // savestates
//save_item(NAME(item)); //save_item(NAME(item));
} }
void xbox_state::machine_reset() void xbox_state::machine_reset()
{ {
ata_mass_storage_device *devh;
atapi_cdrom_device *devc;
uint16_t *id; uint16_t *id;
// set some needed parameters // set some needed parameters
devh = machine().device<ata_mass_storage_device>(":pci:09.0:ide:0:hdd"); id = m_devh->identify_device_buffer();
id = devh->identify_device_buffer();
id[88] |= (1 << 2); // ultra dma mode 2 supported id[88] |= (1 << 2); // ultra dma mode 2 supported
id[128] |= 2; // bits 2-1=01 drive already unlocked id[128] |= 2; // bits 2-1=01 drive already unlocked
devc = machine().device<atapi_cdrom_device>(":pci:09.0:ide:1:cdrom");
id = devc->identify_device_buffer(); id = m_devc->identify_device_buffer();
id[64] |= (1 << 1); id[64] |= (1 << 1);
id[88] |= (1 << 2); // ultra dma mode 2 supported id[88] |= (1 << 2); // ultra dma mode 2 supported
} }