2020-02-28 16:04:28 +00:00
|
|
|
/*
|
|
|
|
|
DingusPPC - The Experimental PowerPC Macintosh emulator
|
2023-02-01 23:21:36 +00:00
|
|
|
Copyright (C) 2018-23 divingkatae and maximum
|
2020-02-28 16:04:28 +00:00
|
|
|
(theweirdo) spatium
|
|
|
|
|
|
|
|
|
|
(Contact divingkatae#1017 or powermax#2286 on Discord for more info)
|
|
|
|
|
|
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
|
*/
|
2019-07-02 02:15:33 +00:00
|
|
|
|
2022-01-16 20:30:43 +00:00
|
|
|
/** MPC106 (Grackle) emulation. */
|
2019-07-02 02:15:33 +00:00
|
|
|
|
2021-10-23 18:17:47 +00:00
|
|
|
#include <devices/common/hwcomponent.h>
|
2022-07-17 03:33:06 +00:00
|
|
|
#include <devices/deviceregistry.h>
|
2021-10-23 18:17:47 +00:00
|
|
|
#include <devices/memctrl/memctrlbase.h>
|
|
|
|
|
#include <devices/memctrl/mpc106.h>
|
2023-02-02 00:59:07 +00:00
|
|
|
#include <loguru.hpp>
|
2021-10-23 18:17:47 +00:00
|
|
|
|
2019-07-02 02:15:33 +00:00
|
|
|
#include <cinttypes>
|
2020-05-12 18:55:45 +00:00
|
|
|
#include <cstring>
|
2022-08-19 18:07:22 +00:00
|
|
|
#include <string>
|
2019-07-15 00:05:10 +00:00
|
|
|
|
2022-03-13 21:22:53 +00:00
|
|
|
MPC106::MPC106() : MemCtrlBase(), PCIDevice("Grackle"), PCIHost()
|
2022-01-16 20:30:43 +00:00
|
|
|
{
|
2022-01-26 15:45:21 +00:00
|
|
|
supports_types(HWCompType::MEM_CTRL | HWCompType::MMIO_DEV |
|
|
|
|
|
HWCompType::PCI_HOST | HWCompType::PCI_DEV);
|
|
|
|
|
|
2022-03-13 21:22:53 +00:00
|
|
|
// populate PCI config header
|
|
|
|
|
this->vendor_id = PCI_VENDOR_MOTOROLA;
|
|
|
|
|
this->device_id = 0x0002;
|
|
|
|
|
this->class_rev = 0x06000040;
|
|
|
|
|
this->cache_ln_sz = 8;
|
|
|
|
|
this->command = 6;
|
|
|
|
|
this->status = 0x80;
|
|
|
|
|
|
2023-02-02 00:59:07 +00:00
|
|
|
// assign PCI device number zero to myself
|
2023-02-05 08:37:29 +00:00
|
|
|
this->pci_register_device(DEV_FUN(0,0), this);
|
2023-02-02 00:59:07 +00:00
|
|
|
|
2022-03-13 21:22:53 +00:00
|
|
|
// add PCI/ISA I/O space, 64K for now
|
2020-03-31 19:12:06 +00:00
|
|
|
add_mmio_region(0xFE000000, 0x10000, this);
|
|
|
|
|
|
2022-03-13 21:22:53 +00:00
|
|
|
// add memory mapped I/O region for MPC106 registers
|
2019-08-21 06:33:01 +00:00
|
|
|
add_mmio_region(0xFEC00000, 0x300000, this);
|
|
|
|
|
}
|
2019-07-12 05:27:14 +00:00
|
|
|
|
2022-08-19 18:07:22 +00:00
|
|
|
int MPC106::device_postinit()
|
|
|
|
|
{
|
|
|
|
|
std::string pci_dev_name;
|
|
|
|
|
|
|
|
|
|
static const std::map<std::string, int> pci_slots = {
|
2023-02-05 08:37:29 +00:00
|
|
|
{"pci_A1", DEV_FUN(0xD,0)}, {"pci_B1", DEV_FUN(0xE,0)}, {"pci_C1", DEV_FUN(0xF,0)}
|
2022-08-19 18:07:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
for (auto& slot : pci_slots) {
|
|
|
|
|
pci_dev_name = GET_STR_PROP(slot.first);
|
|
|
|
|
if (!pci_dev_name.empty()) {
|
|
|
|
|
this->attach_pci_device(pci_dev_name, slot.second);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-22 10:16:31 +00:00
|
|
|
uint32_t MPC106::read(uint32_t rgn_start, uint32_t offset, int size) {
|
|
|
|
|
if (rgn_start == 0xFE000000) {
|
2022-10-26 06:06:12 +00:00
|
|
|
return pci_io_read_broadcast(offset, size);
|
|
|
|
|
}
|
|
|
|
|
if (offset < 0x200000) {
|
2023-02-02 11:45:44 +00:00
|
|
|
return this->config_addr;
|
2020-03-31 19:12:06 +00:00
|
|
|
}
|
2022-10-26 06:06:12 +00:00
|
|
|
if (this->config_addr & 0x80) { // process only if bit E (enable) is set
|
|
|
|
|
return pci_read(offset, size);
|
2019-07-07 06:10:32 +00:00
|
|
|
}
|
|
|
|
|
return 0;
|
2019-07-02 02:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2022-08-22 10:16:31 +00:00
|
|
|
void MPC106::write(uint32_t rgn_start, uint32_t offset, uint32_t value, int size) {
|
|
|
|
|
if (rgn_start == 0xFE000000) {
|
2022-10-26 06:06:12 +00:00
|
|
|
pci_io_write_broadcast(offset, size, value);
|
2020-03-31 19:12:06 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (offset < 0x200000) {
|
|
|
|
|
this->config_addr = value;
|
2022-10-26 06:06:12 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (this->config_addr & 0x80) { // process only if bit E (enable) is set
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
return pci_write(offset, value, size);
|
2020-03-31 19:12:06 +00:00
|
|
|
}
|
2019-07-07 06:10:32 +00:00
|
|
|
}
|
2019-07-15 00:05:10 +00:00
|
|
|
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
uint32_t MPC106::pci_read(uint32_t offset, uint32_t size) {
|
2022-10-26 06:06:12 +00:00
|
|
|
int bus_num, dev_num, fun_num;
|
|
|
|
|
uint8_t reg_offs;
|
|
|
|
|
AccessDetails details;
|
|
|
|
|
PCIDevice *device;
|
|
|
|
|
cfg_setup(offset, size, bus_num, dev_num, fun_num, reg_offs, details, device);
|
|
|
|
|
details.flags |= PCI_CONFIG_READ;
|
|
|
|
|
if (device) {
|
|
|
|
|
return pci_conv_rd_data(device->pci_cfg_read(reg_offs, details), details);
|
2019-08-21 06:33:01 +00:00
|
|
|
}
|
2022-10-26 06:06:12 +00:00
|
|
|
LOG_READ_NON_EXISTENT_PCI_DEVICE();
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
return 0xFFFFFFFFUL; // PCI spec §6.1
|
2019-07-15 00:05:10 +00:00
|
|
|
}
|
|
|
|
|
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
void MPC106::pci_write(uint32_t offset, uint32_t value, uint32_t size) {
|
2022-10-26 06:06:12 +00:00
|
|
|
int bus_num, dev_num, fun_num;
|
|
|
|
|
uint8_t reg_offs;
|
|
|
|
|
AccessDetails details;
|
|
|
|
|
PCIDevice *device;
|
|
|
|
|
cfg_setup(offset, size, bus_num, dev_num, fun_num, reg_offs, details, device);
|
|
|
|
|
details.flags |= PCI_CONFIG_WRITE;
|
|
|
|
|
if (device) {
|
|
|
|
|
if (size == 4 && !details.offset) { // aligned DWORD writes -> fast path
|
|
|
|
|
device->pci_cfg_write(reg_offs, BYTESWAP_32(value), details);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
// otherwise perform necessary data transformations -> slow path
|
|
|
|
|
uint32_t old_val = details.size == 4 ? 0 : device->pci_cfg_read(reg_offs, details);
|
|
|
|
|
uint32_t new_val = pci_conv_wr_data(old_val, value, details);
|
|
|
|
|
device->pci_cfg_write(reg_offs, new_val, details);
|
2019-08-21 06:33:01 +00:00
|
|
|
return;
|
2019-07-15 00:05:10 +00:00
|
|
|
}
|
2022-10-26 06:06:12 +00:00
|
|
|
LOG_WRITE_NON_EXISTENT_PCI_DEVICE();
|
|
|
|
|
}
|
2023-02-02 00:59:07 +00:00
|
|
|
|
2023-02-07 13:41:42 +00:00
|
|
|
inline void MPC106::cfg_setup(uint32_t offset, int size, int &bus_num, int &dev_num,
|
|
|
|
|
int &fun_num, uint8_t ®_offs, AccessDetails &details,
|
|
|
|
|
PCIDevice *&device)
|
2022-10-26 06:06:12 +00:00
|
|
|
{
|
|
|
|
|
device = NULL;
|
|
|
|
|
details.size = size;
|
|
|
|
|
details.offset = offset & 3;
|
2023-02-02 00:59:07 +00:00
|
|
|
|
2022-10-26 06:06:12 +00:00
|
|
|
bus_num = (this->config_addr >> 8) & 0xFF;
|
|
|
|
|
dev_num = (this->config_addr >> 19) & 0x1F;
|
|
|
|
|
fun_num = (this->config_addr >> 16) & 0x07;
|
|
|
|
|
reg_offs = (this->config_addr >> 24) & 0xFC;
|
|
|
|
|
|
|
|
|
|
if (bus_num) {
|
|
|
|
|
details.flags = PCI_CONFIG_TYPE_1;
|
|
|
|
|
device = pci_find_device(bus_num, dev_num, fun_num);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
details.flags = PCI_CONFIG_TYPE_0;
|
|
|
|
|
if (this->dev_map.count(DEV_FUN(dev_num, fun_num))) {
|
|
|
|
|
device = this->dev_map[DEV_FUN(dev_num, fun_num)];
|
2023-02-02 00:59:07 +00:00
|
|
|
}
|
|
|
|
|
}
|
2019-07-02 02:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
uint32_t MPC106::pci_cfg_read(uint32_t reg_offs, AccessDetails &details) {
|
2022-03-13 21:22:53 +00:00
|
|
|
if (reg_offs < 64) {
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
return PCIDevice::pci_cfg_read(reg_offs, details);
|
2022-03-13 21:22:53 +00:00
|
|
|
}
|
|
|
|
|
|
2023-02-01 23:21:36 +00:00
|
|
|
switch (reg_offs) {
|
|
|
|
|
case GrackleReg::CFG10:
|
|
|
|
|
return 0;
|
|
|
|
|
case GrackleReg::PMCR1:
|
|
|
|
|
return (this->odcr << 24) | (this->pmcr2 << 16) | this->pmcr1;
|
2023-02-10 16:44:16 +00:00
|
|
|
case GrackleReg::MSAR1:
|
|
|
|
|
case GrackleReg::MSAR2:
|
|
|
|
|
return this->mem_start[(reg_offs >> 2) & 1];
|
|
|
|
|
case GrackleReg::EMSAR1:
|
|
|
|
|
case GrackleReg::EMSAR2:
|
|
|
|
|
return this->ext_mem_start[(reg_offs >> 2) & 1];
|
|
|
|
|
case GrackleReg::MEAR1:
|
|
|
|
|
case GrackleReg::MEAR2:
|
|
|
|
|
return this->mem_end[(reg_offs >> 2) & 1];
|
|
|
|
|
case GrackleReg::EMEAR1:
|
|
|
|
|
case GrackleReg::EMEAR2:
|
|
|
|
|
return this->ext_mem_end[(reg_offs >> 2) & 1];
|
2023-02-01 23:21:36 +00:00
|
|
|
case GrackleReg::MBER:
|
|
|
|
|
return this->mem_bank_en;
|
|
|
|
|
case GrackleReg::PICR1:
|
|
|
|
|
return this->picr1;
|
|
|
|
|
case GrackleReg::PICR2:
|
|
|
|
|
return this->picr2;
|
|
|
|
|
case GrackleReg::MCCR1:
|
|
|
|
|
return this->mccr1;
|
2023-02-10 16:44:16 +00:00
|
|
|
case GrackleReg::MCCR2:
|
|
|
|
|
return this->mccr2;
|
|
|
|
|
case GrackleReg::MCCR3:
|
|
|
|
|
return this->mccr3;
|
|
|
|
|
case GrackleReg::MCCR4:
|
|
|
|
|
return this->mccr4;
|
2023-02-01 23:21:36 +00:00
|
|
|
default:
|
|
|
|
|
LOG_READ_UNIMPLEMENTED_CONFIG_REGISTER();
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
}
|
2023-02-01 23:21:36 +00:00
|
|
|
|
|
|
|
|
return 0; // PCI Spec §6.1
|
2019-07-15 00:05:10 +00:00
|
|
|
}
|
|
|
|
|
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
void MPC106::pci_cfg_write(uint32_t reg_offs, uint32_t value, AccessDetails &details) {
|
2022-03-13 21:22:53 +00:00
|
|
|
if (reg_offs < 64) {
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
PCIDevice::pci_cfg_write(reg_offs, value, details);
|
2022-03-13 21:22:53 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2023-02-01 23:21:36 +00:00
|
|
|
switch (reg_offs) {
|
|
|
|
|
case GrackleReg::CFG10:
|
|
|
|
|
// Open Firmware writes 0 to subordinate bus # - we don't care
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::PMCR1:
|
|
|
|
|
this->pmcr1 = value & 0xFFFFU;
|
|
|
|
|
this->pmcr2 = (value >> 16) & 0xFF;
|
|
|
|
|
this->odcr = value >> 24;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MSAR1:
|
|
|
|
|
case GrackleReg::MSAR2:
|
|
|
|
|
this->mem_start[(reg_offs >> 2) & 1] = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::EMSAR1:
|
|
|
|
|
case GrackleReg::EMSAR2:
|
|
|
|
|
this->ext_mem_start[(reg_offs >> 2) & 1] = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MEAR1:
|
|
|
|
|
case GrackleReg::MEAR2:
|
|
|
|
|
this->mem_end[(reg_offs >> 2) & 1] = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::EMEAR1:
|
|
|
|
|
case GrackleReg::EMEAR2:
|
|
|
|
|
this->ext_mem_end[(reg_offs >> 2) & 1] = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MBER:
|
|
|
|
|
this->mem_bank_en = value & 0xFFU;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::PICR1:
|
|
|
|
|
this->picr1 = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::PICR2:
|
|
|
|
|
this->picr2 = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MCCR1:
|
|
|
|
|
if ((value ^ this->mccr1) & MEMGO) {
|
|
|
|
|
if (value & MEMGO)
|
|
|
|
|
setup_ram();
|
Fix PCI config r/w of byte and word and unaligned.
dingusppc could not read bytes from offset 1,2,3 or words from offset 2.
dingusppc did not read words from offset 1,3 and longs from offset 1,2,3 in the same way as a real Power Mac 8600 or B&W G3.
This commit fixes those issues.
- Added pci_cfg_rev_read. It takes a 32 bit value from offset 0 and returns a value of the specified size using bytes starting from the specified offset. Offsets 4,5, & 6 wrap around to 0,1, & 2 respectively. The result bytes are in flipped order as required by the read method (so a value of 0x12345678 is returned as 0x78563412)
A real Power Mac 8600 might return a random byte for offset 4, 5, 6 for vci0 but usually not for pci1. A B&W G3 seems to always wrap around correctly. We won't read random bytes, and we won't read a default such as 00 or FF. We'll do the wrap around which makes the most sense because writing 0x12345678 to any offset and reading from the same offset should produce the value that was written.
- Added pci_cfg_rev_write. It takes a 32 bit value from offset 0, and modifies a specified number of bytes starting at a specified offset with the offset wrapping around to 0 if it exceeds 3. The modified bytes take their new values from the flipped bytes passed to pci_cfg_write. When size is 4, the original value is not used since all bytes will be modified.
Basically, those two functions handle all the sizes and all the offsets and replace calls to BYTESWAP_32, read_mem or read_mem_rev, and write_mem or write_mem_rev.
read_mem_rev, as it was used by pcidevice and some other places, could read beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always read the wrong byte or word if they were not at offset 0. Same for read_mem as used by mpc106.
write_mem_rev, as it was used by pcidevice and some other places, could write beyond offset 3 if it were ever passed a reg_offs value that did not have offset as 0. Since the offset was always zero, it would always write the wrong byte or word if they were not at offset 0. Same for write_mem as used by mpc106.
pcidevice:
- The logging macros should be used to handle all config register access logging.
- Unaligned PCI config register accesses will be output as ERROR instead of WARNING.
- The logging macros include the offset and size. They also include the value for named registers or for writes.
- Added MMIODevice read and write methods so that PCIDevice is not abstract if a PCIDevice doesn't override the read and write method since some PCIDevices don't have MMIO.
pcihost:
- Added pci_find_device stub for handling PCI bridges in future commit.
bandit and mpc106:
- PCI host controllers will handle all PCI config access alignment and sizing. A PCIDevice will always access config registers as 32 bits on a 4 byte boundary. The AccessDetails passed to a PCIDevice config read or write method is there only for logging purposes.
bandit:
- Common MMIO code is moved to new BanditHost class so both Bandit and Chaos can use it. PCI related code is moved to new BanditPCI class.
- Simplify IDSEL to/from PCI device number conversion by removing the shift or subtract.
- Remove BANDIT_ID_SEL check. The IDSEL conversion to PCI device number can find the bandit PCI device.
- For logging, make best guess of PCI device number from invalid IDSEL - the result is always reasonable for device 0x00 to 0x0A when accessing config register 0x00 (as one would do when scanning for PCI devices like lspci does).
mpc106:
- Common config space code is put in cfg_setup. It handles extracting the offset.
- Added code to log access to unimplemented config registers of grackle.
- Don't call setup_ram when writing to config registers that setup_ram doesn't use.
- pci_cfg_read calls READ_DWORD_LE_A and pci_cfg_write calls WRITE_DWORD_LE_A. When reading or writing memory that is organized as little endian dwords, such as my_pci_cfg_hdr of mpc106, the function should explicitly state that it's little endian so that the emulator may be ported one day to a CPU architecture that is not little endian.
atirage:
- The changes correctly place user_cfg at byte 0x40 instead of 0x43 and writes the correct byte depending on size and offset.
2022-09-02 10:32:28 +00:00
|
|
|
}
|
2023-02-01 23:21:36 +00:00
|
|
|
this->mccr1 = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MCCR2:
|
|
|
|
|
this->mccr2 = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MCCR3:
|
|
|
|
|
this->mccr3 = value;
|
|
|
|
|
break;
|
|
|
|
|
case GrackleReg::MCCR4:
|
|
|
|
|
this->mccr4 = value;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
LOG_WRITE_UNIMPLEMENTED_CONFIG_REGISTER();
|
2019-10-07 01:21:01 +00:00
|
|
|
}
|
2019-07-02 02:15:33 +00:00
|
|
|
}
|
2019-08-23 19:30:30 +00:00
|
|
|
|
2020-05-12 18:55:45 +00:00
|
|
|
void MPC106::setup_ram() {
|
2019-10-07 01:21:01 +00:00
|
|
|
uint32_t mem_start, mem_end, ext_mem_start, ext_mem_end, bank_start, bank_end;
|
|
|
|
|
uint32_t ram_size = 0;
|
|
|
|
|
|
|
|
|
|
for (int bank = 0; bank < 8; bank++) {
|
2023-02-01 23:21:36 +00:00
|
|
|
if (this->mem_bank_en & (1 << bank)) {
|
2019-10-07 01:21:01 +00:00
|
|
|
if (bank < 4) {
|
2023-02-01 23:21:36 +00:00
|
|
|
mem_start = this->mem_start[0];
|
|
|
|
|
ext_mem_start = this->ext_mem_start[0];
|
|
|
|
|
mem_end = this->mem_end[0];
|
|
|
|
|
ext_mem_end = this->ext_mem_end[0];
|
2019-10-07 01:21:01 +00:00
|
|
|
} else {
|
2023-02-01 23:21:36 +00:00
|
|
|
mem_start = this->mem_start[1];
|
|
|
|
|
ext_mem_start = this->ext_mem_start[1];
|
|
|
|
|
mem_end = this->mem_end[1];
|
|
|
|
|
ext_mem_end = this->ext_mem_end[1];
|
2019-10-07 01:21:01 +00:00
|
|
|
}
|
|
|
|
|
bank_start = (((ext_mem_start >> bank * 8) & 3) << 30) |
|
|
|
|
|
(((mem_start >> bank * 8) & 0xFF) << 20);
|
|
|
|
|
bank_end = (((ext_mem_end >> bank * 8) & 3) << 30) |
|
|
|
|
|
(((mem_end >> bank * 8) & 0xFF) << 20) | 0xFFFFFUL;
|
|
|
|
|
if (bank && bank_start != ram_size)
|
2023-02-01 23:21:36 +00:00
|
|
|
LOG_F(WARNING, "Grackle: RAM not contiguous!");
|
2021-02-03 22:29:48 +00:00
|
|
|
ram_size += bank_end - bank_start + 1;
|
2019-10-07 01:21:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!this->add_ram_region(0, ram_size)) {
|
2023-02-01 23:21:36 +00:00
|
|
|
LOG_F(WARNING, "Grackle: RAM allocation 0x%X..0x%X failed (maybe already exists?)",
|
2023-01-11 22:35:54 +00:00
|
|
|
0, ram_size - 1);
|
2019-10-07 01:21:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
2022-07-17 03:33:06 +00:00
|
|
|
|
2022-08-19 18:07:22 +00:00
|
|
|
static const PropMap Grackle_Properties = {
|
|
|
|
|
{"pci_A1",
|
|
|
|
|
new StrProperty("")},
|
|
|
|
|
{"pci_B1",
|
|
|
|
|
new StrProperty("")},
|
|
|
|
|
{"pci_C1",
|
|
|
|
|
new StrProperty("")},
|
|
|
|
|
};
|
|
|
|
|
|
2022-07-17 03:33:06 +00:00
|
|
|
static const DeviceDescription Grackle_Descriptor = {
|
2022-08-19 18:07:22 +00:00
|
|
|
MPC106::create, {}, Grackle_Properties
|
2022-07-17 03:33:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
REGISTER_DEVICE(Grackle, Grackle_Descriptor);
|
