summaryrefslogtreecommitdiffstatshomepage
path: root/src/devices/machine/legscsi.cpp
blob: c379c797f730fd2ed3b8707ec7c0fcd635a89b45 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
// license:BSD-3-Clause
// copyright-holders:smf
#include "emu.h"
#include "legscsi.h"

legacy_scsi_host_adapter::legacy_scsi_host_adapter(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
	: device_t(mconfig, type, tag, owner, clock)
	, m_selected(0)
	, m_scsi_port(*this, finder_base::DUMMY_TAG)
{
}

void legacy_scsi_host_adapter::device_start()
{
}

void legacy_scsi_host_adapter::reset_bus()
{
	for (int i = 0; i <= 7; i++)
	{
		scsihle_device *scsidev = get_device(i);
		if (scsidev != nullptr)
		{
			scsidev->reset();
		}
	}
}

bool legacy_scsi_host_adapter::select(int id)
{
	m_selected = id;

	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		return true;
	}

	return false;
}

void legacy_scsi_host_adapter::send_command(uint8_t *data, int bytes)
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		scsidev->SetCommand(data, bytes);
		scsidev->ExecCommand();
	}
	else
	{
		logerror("send_command unknown SCSI id %d\n", m_selected);
	}
}

int legacy_scsi_host_adapter::get_length(void)
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		int length;
		scsidev->GetLength(&length);
		return length;
	}
	else
	{
		logerror("get_length unknown SCSI id %d\n", m_selected);
		return 0;
	}
}

int legacy_scsi_host_adapter::get_phase(void)
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		int phase;
		scsidev->GetPhase(&phase);
		return phase;
	}
	else
	{
		logerror("get_phase unknown SCSI id %d\n", m_selected);
		return 0;
	}
}

void legacy_scsi_host_adapter::read_data(uint8_t *data, int bytes)
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		scsidev->ReadData(data, bytes);
	}
	else
	{
		logerror("read_data unknown SCSI id %d\n", m_selected);
	}
}

void legacy_scsi_host_adapter::write_data(uint8_t *data, int bytes)
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		scsidev->WriteData(data, bytes);
	}
	else
	{
		logerror("write_data unknown SCSI id %d\n", m_selected);
	}
}

uint8_t legacy_scsi_host_adapter::get_status()
{
	scsihle_device *scsidev = get_device(m_selected);
	if (scsidev != nullptr)
	{
		void *image;

		scsidev->GetDevice(&image);
		if (image != nullptr)
			return 0x00;

		return 0x02;
	}
	else
	{
		logerror("get_status unknown SCSI id %d\n", m_selected);
		return 0;
	}
}

scsihle_device *legacy_scsi_host_adapter::get_device(int id)
{
	// steal SCSI devices from bus
	for (device_t &device : m_scsi_port->subdevices())
	{
		scsi_port_slot_device *slot = dynamic_cast<scsi_port_slot_device *>(&device);
		if (slot != nullptr)
		{
			scsihle_device *scsidev = dynamic_cast<scsihle_device *>(slot->dev());
			if (scsidev != nullptr)
			{
				if (scsidev->GetDeviceID() == id)
				{
					return scsidev;
				}
			}
		}
	}

	return nullptr;
}