BasiliskII/src/scsi.cpp

/*
 *  scsi.cpp - SCSI Manager
 *
 *  Basilisk II (C) 1997-1999 Christian Bauer
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 *  SEE ALSO
 *    Inside Macintosh: Devices, chapter 3 "SCSI Manager"
 *    Technote DV 24: "Fear No SCSI"
 */

#include <stdio.h>
#include <string.h>

#include "sysdeps.h"
#include "cpu_emulation.h"
#include "main.h"
#include "user_strings.h"
#include "scsi.h"

#define DEBUG 0
#include "debug.h"


// Error codes
enum {
        scCommErr = 2,
        scArbNBErr,
        scBadParmsErr,
        scPhaseErr,
        scCompareErr,
        scMgrBusyErr,
        scSequenceErr,
        scBusTOErr,
        scComplPhaseErr
};

// TIB opcodes
enum {
        scInc = 1,
        scNoInc,
        scAdd,
        scMove,
        scLoop,
        scNop,
        scStop,
        scComp
};

// Logical SCSI phases
enum {
        PH_FREE,                // Bus free
        PH_ARBITRATED,  // Bus arbitrated (after SCSIGet())
        PH_SELECTED,    // Target selected (after SCSISelect())
        PH_TRANSFER             // Command sent (after SCSICmd())
};

// Global variables
static int target_id;                                   // ID of active target
static int phase;                                               // Logical SCSI phase
static uint16 fake_status;                              // Faked 5830 status word
static bool reading;                                    // Flag: reading from device

const int SG_TABLE_SIZE = 1024;
static int sg_index;                                    // Index of first unused entry in S/G table
static uint8 *sg_ptr[SG_TABLE_SIZE];    // Scatter/gather table data pointer (host address space)
static uint32 sg_len[SG_TABLE_SIZE];    // Scatter/gather table data length
static uint32 sg_total_length;                  // Total data length


/*
 *  Execute TIB, constructing S/G table
 */

static int16 exec_tib(uint32 tib)
{
        for (;;) {

                // Read next opcode and parameters
                uint16 cmd = ReadMacInt16(tib); tib += 2;
                uint32 ptr = ReadMacInt32(tib); tib += 4;
                uint32 len = ReadMacInt32(tib); tib += 4;

                D(bug(" %d %08x %d\n", cmd, ptr, len));

                switch (cmd) {
                        case scInc:
                                WriteMacInt32(tib - 8, ptr + len);
                        case scNoInc:
                                if ((sg_index > 0) && (Mac2HostAddr(ptr) == sg_ptr[sg_index-1] + sg_len[sg_index-1]))
                                        sg_len[sg_index-1] += len;                              // Merge to previous entry
                                else {
                                        if (sg_index == SG_TABLE_SIZE) {
                                                ErrorAlert(GetString(STR_SCSI_SG_FULL_ERR));
                                                return -108;
                                        }
                                        sg_ptr[sg_index] = Mac2HostAddr(ptr);   // Create new entry
                                        sg_len[sg_index] = len;
                                        sg_index++;
                                }
                                sg_total_length += len;
                                break;

                        case scAdd:
                                WriteMacInt32(ptr, ReadMacInt32(ptr) + len);
                                break;

                        case scMove:
                                WriteMacInt32(len, ReadMacInt32(ptr));
                                break;

                        case scLoop:
                                WriteMacInt32(tib - 4, len - 1);
                                if (len - 1 > 0)
                                        tib += (int32)ptr - 10;
                                break;

                        case scNop:
                                break;

                        case scStop:
                                return 0;

                        case scComp:
                                printf("WARNING: Unimplemented scComp opcode\n");
                                return scCompareErr;

                        default:
                                printf("FATAL: Unrecognized TIB opcode %d\n", cmd);
                                return scBadParmsErr;
                }
        }
}


/*
 *  Reset SCSI bus
 */

int16 SCSIReset(void)
{
        D(bug("SCSIReset\n"));

        phase = PH_FREE;
        fake_status = 0x0000;   // Bus free
        sg_index = 0;
        target_id = 8;
        return 0;
}


/*
 *  Arbitrate bus
 */

int16 SCSIGet(void)
{
        D(bug("SCSIGet\n"));
        if (phase != PH_FREE)
                return scMgrBusyErr;

        phase = PH_ARBITRATED;
        fake_status = 0x0040;   // Bus busy
        reading = false;
        sg_index = 0;                   // Flush S/G table
        sg_total_length = 0;
        return 0;
}


/*
 *  Select SCSI device
 */

int16 SCSISelect(int id)
{
        D(bug("SCSISelect %d\n", id));
        if (phase != PH_ARBITRATED)
                return scSequenceErr;

        // ID valid?
        if (id >= 0 && id <= 7) {
                target_id = id;

                // Target present?
                if (scsi_is_target_present(target_id)) {
                        phase = PH_SELECTED;
                        fake_status = 0x006a;                   // Target selected, command phase
                        return 0;
                }
        }

        // Error
        phase = PH_FREE;
        fake_status = 0x0000;           // Bus free
        return scCommErr;
}


/*
 *  Send SCSI command
 */

int16 SCSICmd(int cmd_length, uint8 *cmd)
{
        D(bug("SCSICmd len %d, cmd %08x%08x%08x\n", cmd_length, ntohl(0[(uint32 *)cmd]), ntohl(1[(uint32 *)cmd]), ntohl(2[(uint32 *)cmd])));
        if (phase != PH_SELECTED)
                return scPhaseErr;

        // Commdn length valid?
        if (cmd_length != 6 && cmd_length != 10 && cmd_length != 12)
                return scBadParmsErr;

        // Set command, extract LUN
        scsi_set_cmd(cmd_length, cmd);

        // Extract LUN, set target
        if (!scsi_set_target(target_id, (cmd[1] >> 5) & 7)) {
                phase = PH_FREE;
                fake_status = 0x0000;   // Bus free
                return scCommErr;
        }

        phase = PH_TRANSFER;
        fake_status = 0x006e;           // Target selected, data phase
        return 0;
}


/*
 *  Read data
 */

int16 SCSIRead(uint32 tib)
{
        D(bug("SCSIRead TIB %08lx\n", tib));
        if (phase != PH_TRANSFER)
                return scPhaseErr;

        // Execute TIB, fill S/G table
        reading = true;
        return exec_tib(tib);
}


/*
 *  Write data
 */

int16 SCSIWrite(uint32 tib)
{
        D(bug("SCSIWrite TIB %08lx\n", tib));
        if (phase != PH_TRANSFER)
                return scPhaseErr;

        // Execute TIB, fill S/G table
        return exec_tib(tib);
}


/*
 *  Wait for command completion (we're actually doing everything in here...)
 */

int16 SCSIComplete(uint32 timeout, uint32 message, uint32 stat)
{
        D(bug("SCSIComplete wait %d, msg %08lx, stat %08lx\n", timeout, message, stat));
        WriteMacInt16(message, 0);
        if (phase != PH_TRANSFER)
                return scPhaseErr;

        // Send command, process S/G table
        uint16 scsi_stat = 0;
        bool success = scsi_send_cmd(sg_total_length, reading, sg_index, sg_ptr, sg_len, &scsi_stat, timeout);
        WriteMacInt16(stat, scsi_stat);

        // Complete command
        phase = PH_FREE;
        fake_status = 0x0000;   // Bus free
        return success ? 0 : scCommErr;
}


/*
 *  Get bus status
 */

uint16 SCSIStat(void)
{
        D(bug("SCSIStat returns %04x\n", fake_status));
        return fake_status;
}


/*
 *  SCSI Manager busy?
 */

int16 SCSIMgrBusy(void)
{
//      D(bug("SCSIMgrBusy\n"));
        return phase != PH_FREE;
}
Revision:	1.1.1.1 (vendor branch)
Committed:	1999-10-03T14:16:25Z (25 years, 2 months ago) by cebix
Branch:	cebix
CVS Tags:	release-0_7-2, snapshot-21101999, start, snapshot-22121999, release-0_8-1, snapshot-02111999
Changes since 1.1:	+0 -0 lines
Log Message:	Imported sources
#	Content
1	/*
2	* scsi.cpp - SCSI Manager
3	*
4	* Basilisk II (C) 1997-1999 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	/*
22	* SEE ALSO
23	* Inside Macintosh: Devices, chapter 3 "SCSI Manager"
24	* Technote DV 24: "Fear No SCSI"
25	*/
26
27	#include <stdio.h>
28	#include <string.h>
29
30	#include "sysdeps.h"
31	#include "cpu_emulation.h"
32	#include "main.h"
33	#include "user_strings.h"
34	#include "scsi.h"
35
36	#define DEBUG 0
37	#include "debug.h"
38
39
40	// Error codes
41	enum {
42	scCommErr = 2,
43	scArbNBErr,
44	scBadParmsErr,
45	scPhaseErr,
46	scCompareErr,
47	scMgrBusyErr,
48	scSequenceErr,
49	scBusTOErr,
50	scComplPhaseErr
51	};
52
53	// TIB opcodes
54	enum {
55	scInc = 1,
56	scNoInc,
57	scAdd,
58	scMove,
59	scLoop,
60	scNop,
61	scStop,
62	scComp
63	};
64
65	// Logical SCSI phases
66	enum {
67	PH_FREE, // Bus free
68	PH_ARBITRATED, // Bus arbitrated (after SCSIGet())
69	PH_SELECTED, // Target selected (after SCSISelect())
70	PH_TRANSFER // Command sent (after SCSICmd())
71	};
72
73	// Global variables
74	static int target_id; // ID of active target
75	static int phase; // Logical SCSI phase
76	static uint16 fake_status; // Faked 5830 status word
77	static bool reading; // Flag: reading from device
78
79	const int SG_TABLE_SIZE = 1024;
80	static int sg_index; // Index of first unused entry in S/G table
81	static uint8 *sg_ptr[SG_TABLE_SIZE]; // Scatter/gather table data pointer (host address space)
82	static uint32 sg_len[SG_TABLE_SIZE]; // Scatter/gather table data length
83	static uint32 sg_total_length; // Total data length
84
85
86	/*
87	* Execute TIB, constructing S/G table
88	*/
89
90	static int16 exec_tib(uint32 tib)
91	{
92	for (;;) {
93
94	// Read next opcode and parameters
95	uint16 cmd = ReadMacInt16(tib); tib += 2;
96	uint32 ptr = ReadMacInt32(tib); tib += 4;
97	uint32 len = ReadMacInt32(tib); tib += 4;
98
99	D(bug(" %d %08x %d\n", cmd, ptr, len));
100
101	switch (cmd) {
102	case scInc:
103	WriteMacInt32(tib - 8, ptr + len);
104	case scNoInc:
105	if ((sg_index > 0) && (Mac2HostAddr(ptr) == sg_ptr[sg_index-1] + sg_len[sg_index-1]))
106	sg_len[sg_index-1] += len; // Merge to previous entry
107	else {
108	if (sg_index == SG_TABLE_SIZE) {
109	ErrorAlert(GetString(STR_SCSI_SG_FULL_ERR));
110	return -108;
111	}
112	sg_ptr[sg_index] = Mac2HostAddr(ptr); // Create new entry
113	sg_len[sg_index] = len;
114	sg_index++;
115	}
116	sg_total_length += len;
117	break;
118
119	case scAdd:
120	WriteMacInt32(ptr, ReadMacInt32(ptr) + len);
121	break;
122
123	case scMove:
124	WriteMacInt32(len, ReadMacInt32(ptr));
125	break;
126
127	case scLoop:
128	WriteMacInt32(tib - 4, len - 1);
129	if (len - 1 > 0)
130	tib += (int32)ptr - 10;
131	break;
132
133	case scNop:
134	break;
135
136	case scStop:
137	return 0;
138
139	case scComp:
140	printf("WARNING: Unimplemented scComp opcode\n");
141	return scCompareErr;
142
143	default:
144	printf("FATAL: Unrecognized TIB opcode %d\n", cmd);
145	return scBadParmsErr;
146	}
147	}
148	}
149
150
151	/*
152	* Reset SCSI bus
153	*/
154
155	int16 SCSIReset(void)
156	{
157	D(bug("SCSIReset\n"));
158
159	phase = PH_FREE;
160	fake_status = 0x0000; // Bus free
161	sg_index = 0;
162	target_id = 8;
163	return 0;
164	}
165
166
167	/*
168	* Arbitrate bus
169	*/
170
171	int16 SCSIGet(void)
172	{
173	D(bug("SCSIGet\n"));
174	if (phase != PH_FREE)
175	return scMgrBusyErr;
176
177	phase = PH_ARBITRATED;
178	fake_status = 0x0040; // Bus busy
179	reading = false;
180	sg_index = 0; // Flush S/G table
181	sg_total_length = 0;
182	return 0;
183	}
184
185
186	/*
187	* Select SCSI device
188	*/
189
190	int16 SCSISelect(int id)
191	{
192	D(bug("SCSISelect %d\n", id));
193	if (phase != PH_ARBITRATED)
194	return scSequenceErr;
195
196	// ID valid?
197	if (id >= 0 && id <= 7) {
198	target_id = id;
199
200	// Target present?
201	if (scsi_is_target_present(target_id)) {
202	phase = PH_SELECTED;
203	fake_status = 0x006a; // Target selected, command phase
204	return 0;
205	}
206	}
207
208	// Error
209	phase = PH_FREE;
210	fake_status = 0x0000; // Bus free
211	return scCommErr;
212	}
213
214
215	/*
216	* Send SCSI command
217	*/
218
219	int16 SCSICmd(int cmd_length, uint8 *cmd)
220	{
221	D(bug("SCSICmd len %d, cmd %08x%08x%08x\n", cmd_length, ntohl(0[(uint32 )cmd]), ntohl(1[(uint32 )cmd]), ntohl(2[(uint32 *)cmd])));
222	if (phase != PH_SELECTED)
223	return scPhaseErr;
224
225	// Commdn length valid?
226	if (cmd_length != 6 && cmd_length != 10 && cmd_length != 12)
227	return scBadParmsErr;
228
229	// Set command, extract LUN
230	scsi_set_cmd(cmd_length, cmd);
231
232	// Extract LUN, set target
233	if (!scsi_set_target(target_id, (cmd[1] >> 5) & 7)) {
234	phase = PH_FREE;
235	fake_status = 0x0000; // Bus free
236	return scCommErr;
237	}
238
239	phase = PH_TRANSFER;
240	fake_status = 0x006e; // Target selected, data phase
241	return 0;
242	}
243
244
245	/*
246	* Read data
247	*/
248
249	int16 SCSIRead(uint32 tib)
250	{
251	D(bug("SCSIRead TIB %08lx\n", tib));
252	if (phase != PH_TRANSFER)
253	return scPhaseErr;
254
255	// Execute TIB, fill S/G table
256	reading = true;
257	return exec_tib(tib);
258	}
259
260
261	/*
262	* Write data
263	*/
264
265	int16 SCSIWrite(uint32 tib)
266	{
267	D(bug("SCSIWrite TIB %08lx\n", tib));
268	if (phase != PH_TRANSFER)
269	return scPhaseErr;
270
271	// Execute TIB, fill S/G table
272	return exec_tib(tib);
273	}
274
275
276	/*
277	* Wait for command completion (we're actually doing everything in here...)
278	*/
279
280	int16 SCSIComplete(uint32 timeout, uint32 message, uint32 stat)
281	{
282	D(bug("SCSIComplete wait %d, msg %08lx, stat %08lx\n", timeout, message, stat));
283	WriteMacInt16(message, 0);
284	if (phase != PH_TRANSFER)
285	return scPhaseErr;
286
287	// Send command, process S/G table
288	uint16 scsi_stat = 0;
289	bool success = scsi_send_cmd(sg_total_length, reading, sg_index, sg_ptr, sg_len, &scsi_stat, timeout);
290	WriteMacInt16(stat, scsi_stat);
291
292	// Complete command
293	phase = PH_FREE;
294	fake_status = 0x0000; // Bus free
295	return success ? 0 : scCommErr;
296	}
297
298
299	/*
300	* Get bus status
301	*/
302
303	uint16 SCSIStat(void)
304	{
305	D(bug("SCSIStat returns %04x\n", fake_status));
306	return fake_status;
307	}
308
309
310	/*
311	* SCSI Manager busy?
312	*/
313
314	int16 SCSIMgrBusy(void)
315	{
316	// D(bug("SCSIMgrBusy\n"));
317	return phase != PH_FREE;
318	}