Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-21 16:01:56 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

-sun4: Added basic support for cgsix/TurboGX SBus card. [Ryan Holtz]

Browse Source
This commit is contained in:
Ryan Holtz 2018-09-13 13:37:12 +02:00
parent b8c68d5ff0
commit 7d3082e044
8 changed files with 278 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/src/bus.lua
View File

@ -3042,6 +3042,8 @@ if (BUSES["SBUS"]~=null) then
MAME_DIR .. "src/devices/bus/sbus/bwtwo.h",
MAME_DIR .. "src/devices/bus/sbus/cgthree.cpp",
MAME_DIR .. "src/devices/bus/sbus/cgthree.h",
MAME_DIR .. "src/devices/bus/sbus/turbogx.cpp",
MAME_DIR .. "src/devices/bus/sbus/turbogx.h",
MAME_DIR .. "src/devices/bus/sbus/sbus.cpp",
MAME_DIR .. "src/devices/bus/sbus/sbus.h",
}

1
src/devices/bus/sbus/bwtwo.h
View File

@ -40,7 +40,6 @@ private:
void mem_map(address_map &map) override;
//required_shared_ptr<uint32_t> m_vram;
required_memory_region m_rom;
std::unique_ptr<uint32_t[]> m_vram;
required_device<screen_device> m_screen;

62
src/devices/bus/sbus/cgthree.cpp
View File

@ -16,6 +16,7 @@ void sbus_cgthree_device::mem_map(address_map &map)
{
map(0x00000000, 0x01ffffff).rw(FUNC(sbus_cgthree_device::unknown_r), FUNC(sbus_cgthree_device::unknown_w));
map(0x00000000, 0x000007ff).r(FUNC(sbus_cgthree_device::rom_r));
map(0x00400000, 0x00400007).w(FUNC(sbus_cgthree_device::palette_w));
map(0x007ff800, 0x007ff81f).rw(FUNC(sbus_cgthree_device::regs_r), FUNC(sbus_cgthree_device::regs_w));
map(0x00800000, 0x008fd1ff).rw(FUNC(sbus_cgthree_device::vram2_r), FUNC(sbus_cgthree_device::vram2_w));
map(0x00bff800, 0x00cfcbff).rw(FUNC(sbus_cgthree_device::vram_r), FUNC(sbus_cgthree_device::vram_w));
@ -55,7 +56,21 @@ void sbus_cgthree_device::device_start()
{
m_vram = std::make_unique<uint32_t[]>(0x100000/4);
m_vram2 = std::make_unique<uint32_t[]>(0x100000/4);
entry = r = g = b = step = 0;
save_item(NAME(m_palette_entry));
save_item(NAME(m_palette_r));
save_item(NAME(m_palette_g));
save_item(NAME(m_palette_b));
save_item(NAME(m_palette_step));
}
void sbus_cgthree_device::device_reset()
{
m_palette_entry = 0;
m_palette_r = 0;
m_palette_g = 0;
m_palette_b = 0;
m_palette_step = 0;
}
void sbus_cgthree_device::install_device()
@ -70,7 +85,6 @@ void sbus_cgthree_device::palette_init(palette_device &palette)
const uint8_t reversed = 255 - i;
palette.set_pen_color(i, rgb_t(reversed, reversed, reversed));
}
printf("\n");
}
uint32_t sbus_cgthree_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
@ -83,7 +97,7 @@ uint32_t sbus_cgthree_device::screen_update(screen_device &screen, bitmap_rgb32
uint32_t *scanline = &bitmap.pix32(y);
for (int x = 0; x < 1152; x++)
{
const uint8_t pixel = vram[(y * 1152) + (BYTE4_XOR_BE(x))];
const uint8_t pixel = vram[y * 1152 + BYTE4_XOR_BE(x)];
*scanline++ = pens[pixel];
}
}
@ -99,27 +113,35 @@ READ32_MEMBER(sbus_cgthree_device::unknown_r)
WRITE32_MEMBER(sbus_cgthree_device::unknown_w)
{
if (offset == 0x100000)
logerror("%s: unknown_w: %08x = %08x & %08x\n", machine().describe_context(), offset << 2, data, mem_mask);
}
WRITE32_MEMBER(sbus_cgthree_device::palette_w)
{
if (offset == 0)
{
entry = data >> 24;
step = 0;
}
else if (offset == 0x100001)
{
switch (step)
{
case 0: r = data>>24; step++; break;
case 1: g = data>>24; step++; break;
case 2:
b = data>>24;
m_palette->set_pen_color(entry, rgb_t(r, g, b));
step = 0;
break;
}
m_palette_entry = data >> 24;
m_palette_step = 0;
}
else
{
logerror("%s: unknown_w: %08x = %08x & %08x\n", machine().describe_context(), offset << 2, data, mem_mask);
switch (m_palette_step)
{
case 0:
m_palette_r = data >> 24;
m_palette_step++;
break;
case 1:
m_palette_g = data >> 24;
m_palette_step++;
break;
case 2:
m_palette_b = data >> 24;
m_palette->set_pen_color(m_palette_entry, rgb_t(m_palette_r, m_palette_g, m_palette_b));
m_palette_step = 0;
m_palette_entry++;
break;
}
}
}

8
src/devices/bus/sbus/cgthree.h
View File

@ -25,6 +25,7 @@ protected:
virtual const tiny_rom_entry *device_rom_region() const override;
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_reset() override;
// device_sbus_slot_interface overrides
virtual void install_device() override;
@ -33,6 +34,7 @@ protected:
DECLARE_READ32_MEMBER(unknown_r);
DECLARE_WRITE32_MEMBER(unknown_w);
DECLARE_WRITE32_MEMBER(palette_w);
DECLARE_READ8_MEMBER(regs_r);
DECLARE_WRITE8_MEMBER(regs_w);
DECLARE_READ32_MEMBER(rom_r);
@ -51,7 +53,11 @@ private:
std::unique_ptr<uint32_t[]> m_vram2; // ???
required_device<screen_device> m_screen;
required_device<palette_device> m_palette;
int entry, r, g, b, step;
uint8_t m_palette_entry;
uint8_t m_palette_r;
uint8_t m_palette_g;
uint8_t m_palette_b;
uint8_t m_palette_step;
};
// device type definition

2
src/devices/bus/sbus/sbus.cpp
View File

@ -9,12 +9,14 @@
#include "emu.h"
#include "bwtwo.h"
#include "cgthree.h"
#include "turbogx.h"
#include "sbus.h"
void sbus_cards(device_slot_interface &device)
{
device.option_add("bwtwo", SBUS_BWTWO); /* Sun bwtwo monochrome display board */
device.option_add("cgthree", SBUS_CGTHREE); /* Sun cgthree color display board */
device.option_add("turbogx", SBUS_TURBOGX); /* Sun TurboGX 8-bit color display board */
}
DEFINE_DEVICE_TYPE(SBUS_SLOT, sbus_slot_device, "sbus_slot", "Sun SBus Slot")

163
src/devices/bus/sbus/turbogx.cpp Normal file
View File

@ -0,0 +1,163 @@
// license:BSD-3-Clause
// copyright-holders:Ryan Holtz
/***************************************************************************
Sun TurboGX accelerated 8-bit color video controller
***************************************************************************/
#include "emu.h"
#include "turbogx.h"
#include "screen.h"
DEFINE_DEVICE_TYPE(SBUS_TURBOGX, sbus_turbogx_device, "turbogx", "Sun TurboGX SBus Video")
void sbus_turbogx_device::mem_map(address_map &map)
{
map(0x00000000, 0x01ffffff).rw(FUNC(sbus_turbogx_device::unknown_r), FUNC(sbus_turbogx_device::unknown_w));
map(0x00000000, 0x00007fff).r(FUNC(sbus_turbogx_device::rom_r));
map(0x00200000, 0x00200007).w(FUNC(sbus_turbogx_device::palette_w));
map(0x00800000, 0x008fffff).rw(FUNC(sbus_turbogx_device::vram_r), FUNC(sbus_turbogx_device::vram_w));
}
ROM_START( sbus_turbogx )
ROM_REGION32_BE(0x8000, "prom", ROMREGION_ERASEFF)
ROM_LOAD( "sunw,501-2325.bin", 0x0000, 0x8000, CRC(bbdc45f8) SHA1(e4a51d78e199cd57f2fcb9d45b25dfae2bd537e4))
ROM_END
const tiny_rom_entry *sbus_turbogx_device::device_rom_region() const
{
return ROM_NAME( sbus_turbogx );
}
void sbus_turbogx_device::device_add_mconfig(machine_config &config)
{
screen_device &screen(SCREEN(config, "screen", SCREEN_TYPE_RASTER));
screen.set_screen_update(FUNC(sbus_turbogx_device::screen_update));
screen.set_size(1152, 900);
screen.set_visarea(0, 1152-1, 0, 900-1);
screen.set_refresh_hz(72);
PALETTE(config, m_palette, 256).set_init(DEVICE_SELF, FUNC(sbus_turbogx_device::palette_init));
}
sbus_turbogx_device::sbus_turbogx_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, SBUS_TURBOGX, tag, owner, clock)
, device_sbus_card_interface(mconfig, *this)
, m_rom(*this, "prom")
, m_screen(*this, "screen")
, m_palette(*this, "palette")
{
}
void sbus_turbogx_device::device_start()
{
m_vram = std::make_unique<uint32_t[]>(0x100000/4);
save_item(NAME(m_palette_entry));
save_item(NAME(m_palette_r));
save_item(NAME(m_palette_g));
save_item(NAME(m_palette_b));
save_item(NAME(m_palette_step));
}
void sbus_turbogx_device::device_reset()
{
m_palette_entry = 0;
m_palette_r = 0;
m_palette_g = 0;
m_palette_b = 0;
m_palette_step = 0;
}
void sbus_turbogx_device::install_device()
{
m_sbus->install_device(m_base, m_base + 0x1ffffff, *this, &sbus_turbogx_device::mem_map);
}
void sbus_turbogx_device::palette_init(palette_device &palette)
{
for (int i = 0; i < 256; i++)
{
const uint8_t reversed = 255 - i;
palette.set_pen_color(i, rgb_t(reversed, reversed, reversed));
}
}
uint32_t sbus_turbogx_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect)
{
const pen_t *pens = m_palette->pens();
uint8_t *vram = (uint8_t *)&m_vram[0];
for (int y = 0; y < 900; y++)
{
uint32_t *scanline = &bitmap.pix32(y);
for (int x = 0; x < 1152; x++)
{
const uint8_t pixel = vram[y * 1152 + BYTE4_XOR_BE(x)];
*scanline++ = pens[pixel];
}
}
return 0;
}
READ32_MEMBER(sbus_turbogx_device::rom_r)
{
return ((uint32_t*)m_rom->base())[offset];
}
READ32_MEMBER(sbus_turbogx_device::unknown_r)
{
logerror("%s: unknown_r: %08x & %08x\n", machine().describe_context(), offset << 2, mem_mask);
return 0;
}
WRITE32_MEMBER(sbus_turbogx_device::unknown_w)
{
logerror("%s: unknown_w: %08x = %08x & %08x\n", machine().describe_context(), offset << 2, data, mem_mask);
}
READ32_MEMBER(sbus_turbogx_device::vram_r)
{
return m_vram[offset];
}
WRITE32_MEMBER(sbus_turbogx_device::vram_w)
{
COMBINE_DATA(&m_vram[offset]);
}
WRITE32_MEMBER(sbus_turbogx_device::palette_w)
{
if (offset == 0)
{
m_palette_entry = data >> 24;
logerror("selecting palette entry %d\n", (uint32_t)m_palette_entry);
m_palette_step = 0;
}
else if (offset == 1)
{
switch (m_palette_step)
{
case 0:
logerror("palette entry %d red: %02x\n", (uint32_t)m_palette_entry, data);
m_palette_r = data >> 24;
m_palette_step++;
break;
case 1:
logerror("palette entry %d green: %02x\n", (uint32_t)m_palette_entry, data);
m_palette_g = data >> 24;
m_palette_step++;
break;
case 2:
logerror("palette entry %d blue: %02x\n", (uint32_t)m_palette_entry, data);
m_palette_b = data >> 24;
m_palette->set_pen_color(m_palette_entry, rgb_t(m_palette_r, m_palette_g, m_palette_b));
m_palette_step = 0;
m_palette_entry++;
break;
}
}
}

62
src/devices/bus/sbus/turbogx.h Normal file
View File

@ -0,0 +1,62 @@
// license:BSD-3-Clause
// copyright-holders:Ryan Holtz
/***************************************************************************
Sun TurboGX accelerated 8-bit color video controller
***************************************************************************/
#ifndef MAME_BUS_SBUS_TURBOGX_H
#define MAME_BUS_SBUS_TURBOGX_H
#pragma once
#include "sbus.h"
#include "emupal.h"
class sbus_turbogx_device : public device_t, public device_sbus_card_interface
{
public:
// construction/destruction
sbus_turbogx_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
// device_t overrides
virtual const tiny_rom_entry *device_rom_region() const override;
virtual void device_add_mconfig(machine_config &config) override;
virtual void device_start() override;
virtual void device_reset() override;
// device_sbus_slot_interface overrides
virtual void install_device() override;
void palette_init(palette_device &palette);
DECLARE_READ32_MEMBER(rom_r);
DECLARE_READ32_MEMBER(unknown_r);
DECLARE_WRITE32_MEMBER(unknown_w);
DECLARE_READ32_MEMBER(vram_r);
DECLARE_WRITE32_MEMBER(vram_w);
DECLARE_WRITE32_MEMBER(palette_w);
private:
uint32_t screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect);
void mem_map(address_map &map) override;
required_memory_region m_rom;
std::unique_ptr<uint32_t[]> m_vram;
required_device<screen_device> m_screen;
required_device<palette_device> m_palette;
uint8_t m_palette_entry;
uint8_t m_palette_r;
uint8_t m_palette_g;
uint8_t m_palette_b;
uint8_t m_palette_step;
};
// device type definition
DECLARE_DEVICE_TYPE(SBUS_TURBOGX, sbus_turbogx_device)
#endif // MAME_BUS_SBUS_TURBOGX_H

5
src/mame/drivers/sun4.cpp
View File

@ -2269,11 +2269,6 @@ ROM_START( sun4_300 )
ROM_LOAD32_BYTE( "1036-09.rom", 0x00000, 0x10000, CRC(cb3d45a7) SHA1(9d5da09ff87ec52dc99ffabd1003d30811eafdb0))
ROM_LOAD32_BYTE( "1037-09.rom", 0x00001, 0x10000, CRC(4f005bea) SHA1(db3f6133ea7c497ba440bc797123dde41abea6fd))
ROM_LOAD32_BYTE( "1038-09.rom", 0x00002, 0x10000, CRC(1e429d31) SHA1(498ce4d34a74ea6e3e369bb7eb9c2b87e12bd080))
ROM_REGION( 0x10000, "devices", ROMREGION_ERASEFF )
// TurboGX 8-Bit Color Frame Buffer
ROM_LOAD( "sunw,501-2325.bin", 0x1000, 0x8000, CRC(bbdc45f8) SHA1(e4a51d78e199cd57f2fcb9d45b25dfae2bd537e4))
ROM_END
ROM_START( sun4_400 )