BasiliskII/src/scsi.cpp

/*
 *  scsi.cpp - SCSI Manager
 *
 *  Basilisk II (C) 1997-2008 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;

#if DEBUG
                const char *cmd_str;
                switch (cmd) {
                        case scInc:   cmd_str = "INC  "; break;
                        case scNoInc: cmd_str = "NOINC"; break;
                        case scAdd:   cmd_str = "ADD  "; break;
                        case scMove:  cmd_str = "MOVE "; break;
                        case scLoop:  cmd_str = "LOOP "; break;
                        case scNop:   cmd_str = "NOP  "; break;
                        case scStop:  cmd_str = "STOP "; break;
                        case scComp:  cmd_str = "COMP "; break;
                        default:      cmd_str = "???  "; break;
                }
                D(bug(" %s(%d) %08x %d\n", cmd_str, cmd, ptr, len));
#endif

                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)
{
#if DEBUG
        switch (cmd_length) {
                case 6:
                        D(bug("SCSICmd len 6, cmd %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5]));
                        break;
                case 10:
                        D(bug("SCSICmd len 10, cmd %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7], cmd[8], cmd[9]));
                        break;
                case 12:
                        D(bug("SCSICmd len 12, cmd %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7], cmd[8], cmd[9], cmd[10], cmd[11]));
                        break;
                default:
                        D(bug("SCSICmd bogus length %d\n", cmd_length));
                        break;
        }
#endif

        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.8
Committed:	2008-01-01T09:40:31Z (16 years, 10 months ago) by gbeauche
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.7:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	cebix	1.1	/*
2			* scsi.cpp - SCSI Manager
3			*
4	gbeauche	1.8	* Basilisk II (C) 1997-2008 Christian Bauer
5	cebix	1.1	*
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	cebix	1.5	#if DEBUG
100			const char *cmd_str;
101			switch (cmd) {
102			case scInc: cmd_str = "INC "; break;
103			case scNoInc: cmd_str = "NOINC"; break;
104			case scAdd: cmd_str = "ADD "; break;
105			case scMove: cmd_str = "MOVE "; break;
106			case scLoop: cmd_str = "LOOP "; break;
107			case scNop: cmd_str = "NOP "; break;
108			case scStop: cmd_str = "STOP "; break;
109			case scComp: cmd_str = "COMP "; break;
110			default: cmd_str = "??? "; break;
111			}
112			D(bug(" %s(%d) %08x %d\n", cmd_str, cmd, ptr, len));
113			#endif
114	cebix	1.1
115			switch (cmd) {
116			case scInc:
117			WriteMacInt32(tib - 8, ptr + len);
118			case scNoInc:
119			if ((sg_index > 0) && (Mac2HostAddr(ptr) == sg_ptr[sg_index-1] + sg_len[sg_index-1]))
120			sg_len[sg_index-1] += len; // Merge to previous entry
121			else {
122			if (sg_index == SG_TABLE_SIZE) {
123			ErrorAlert(GetString(STR_SCSI_SG_FULL_ERR));
124			return -108;
125			}
126			sg_ptr[sg_index] = Mac2HostAddr(ptr); // Create new entry
127			sg_len[sg_index] = len;
128			sg_index++;
129			}
130			sg_total_length += len;
131			break;
132
133			case scAdd:
134			WriteMacInt32(ptr, ReadMacInt32(ptr) + len);
135			break;
136
137			case scMove:
138			WriteMacInt32(len, ReadMacInt32(ptr));
139			break;
140
141			case scLoop:
142			WriteMacInt32(tib - 4, len - 1);
143			if (len - 1 > 0)
144			tib += (int32)ptr - 10;
145			break;
146
147			case scNop:
148			break;
149
150			case scStop:
151			return 0;
152
153			case scComp:
154			printf("WARNING: Unimplemented scComp opcode\n");
155			return scCompareErr;
156
157			default:
158			printf("FATAL: Unrecognized TIB opcode %d\n", cmd);
159			return scBadParmsErr;
160			}
161			}
162			}
163
164
165			/*
166			* Reset SCSI bus
167			*/
168
169			int16 SCSIReset(void)
170			{
171			D(bug("SCSIReset\n"));
172
173			phase = PH_FREE;
174			fake_status = 0x0000; // Bus free
175			sg_index = 0;
176			target_id = 8;
177			return 0;
178			}
179
180
181			/*
182			* Arbitrate bus
183			*/
184
185			int16 SCSIGet(void)
186			{
187			D(bug("SCSIGet\n"));
188			if (phase != PH_FREE)
189			return scMgrBusyErr;
190
191			phase = PH_ARBITRATED;
192			fake_status = 0x0040; // Bus busy
193			reading = false;
194			sg_index = 0; // Flush S/G table
195			sg_total_length = 0;
196			return 0;
197			}
198
199
200			/*
201			* Select SCSI device
202			*/
203
204			int16 SCSISelect(int id)
205			{
206			D(bug("SCSISelect %d\n", id));
207			if (phase != PH_ARBITRATED)
208			return scSequenceErr;
209
210			// ID valid?
211			if (id >= 0 && id <= 7) {
212			target_id = id;
213
214			// Target present?
215			if (scsi_is_target_present(target_id)) {
216			phase = PH_SELECTED;
217			fake_status = 0x006a; // Target selected, command phase
218			return 0;
219			}
220			}
221
222			// Error
223			phase = PH_FREE;
224			fake_status = 0x0000; // Bus free
225			return scCommErr;
226			}
227
228
229			/*
230			* Send SCSI command
231			*/
232
233			int16 SCSICmd(int cmd_length, uint8 *cmd)
234			{
235	cebix	1.5	#if DEBUG
236			switch (cmd_length) {
237			case 6:
238			D(bug("SCSICmd len 6, cmd %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5]));
239			break;
240			case 10:
241			D(bug("SCSICmd len 10, cmd %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7], cmd[8], cmd[9]));
242			break;
243			case 12:
244			D(bug("SCSICmd len 12, cmd %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7], cmd[8], cmd[9], cmd[10], cmd[11]));
245			break;
246			default:
247			D(bug("SCSICmd bogus length %d\n", cmd_length));
248			break;
249			}
250			#endif
251
252	cebix	1.1	if (phase != PH_SELECTED)
253			return scPhaseErr;
254
255			// Commdn length valid?
256			if (cmd_length != 6 && cmd_length != 10 && cmd_length != 12)
257			return scBadParmsErr;
258
259			// Set command, extract LUN
260			scsi_set_cmd(cmd_length, cmd);
261
262			// Extract LUN, set target
263			if (!scsi_set_target(target_id, (cmd[1] >> 5) & 7)) {
264			phase = PH_FREE;
265			fake_status = 0x0000; // Bus free
266			return scCommErr;
267			}
268
269			phase = PH_TRANSFER;
270			fake_status = 0x006e; // Target selected, data phase
271			return 0;
272			}
273
274
275			/*
276			* Read data
277			*/
278
279			int16 SCSIRead(uint32 tib)
280			{
281			D(bug("SCSIRead TIB %08lx\n", tib));
282			if (phase != PH_TRANSFER)
283			return scPhaseErr;
284
285			// Execute TIB, fill S/G table
286			reading = true;
287			return exec_tib(tib);
288			}
289
290
291			/*
292			* Write data
293			*/
294
295			int16 SCSIWrite(uint32 tib)
296			{
297			D(bug("SCSIWrite TIB %08lx\n", tib));
298			if (phase != PH_TRANSFER)
299			return scPhaseErr;
300
301			// Execute TIB, fill S/G table
302			return exec_tib(tib);
303			}
304
305
306			/*
307			* Wait for command completion (we're actually doing everything in here...)
308			*/
309
310			int16 SCSIComplete(uint32 timeout, uint32 message, uint32 stat)
311			{
312			D(bug("SCSIComplete wait %d, msg %08lx, stat %08lx\n", timeout, message, stat));
313			WriteMacInt16(message, 0);
314			if (phase != PH_TRANSFER)
315			return scPhaseErr;
316
317			// Send command, process S/G table
318			uint16 scsi_stat = 0;
319			bool success = scsi_send_cmd(sg_total_length, reading, sg_index, sg_ptr, sg_len, &scsi_stat, timeout);
320			WriteMacInt16(stat, scsi_stat);
321
322			// Complete command
323			phase = PH_FREE;
324			fake_status = 0x0000; // Bus free
325			return success ? 0 : scCommErr;
326			}
327
328
329			/*
330			* Get bus status
331			*/
332
333			uint16 SCSIStat(void)
334			{
335			D(bug("SCSIStat returns %04x\n", fake_status));
336			return fake_status;
337			}
338
339
340			/*
341			* SCSI Manager busy?
342			*/
343
344			int16 SCSIMgrBusy(void)
345			{
346			// D(bug("SCSIMgrBusy\n"));
347			return phase != PH_FREE;
348			}