SheepShaver/src/serial.cpp

/*
 *  serial.cpp - Serial device driver
 *
 *  SheepShaver (C) 1997-2002 Marc Hellwig and 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
 */

#include "sysdeps.h"
#include "main.h"
#include "macos_util.h"
#include "serial.h"
#include "serial_defs.h"

#define DEBUG 0
#include "debug.h"


// Global variables
SERDPort *the_serd_port[2];

// Function pointers from imported functions
typedef int16 (*iocommandiscomplete_ptr)(uint32, int16);
static iocommandiscomplete_ptr IOCommandIsComplete;


/*
 *  Empty function (AIn/BIn Open/Close)
 */

int16 SerialNothing(uint32 pb, uint32 dce)
{
        return noErr;
}


/*
 *  Driver Open() routine (output side only)
 */

int16 SerialOpen(uint32 pb, uint32 dce)
{
        D(bug("SerialOpen pb %08lx, dce %08lx\n", pb, dce));

        // Get IOCommandIsComplete function
        IOCommandIsComplete = (iocommandiscomplete_ptr)FindLibSymbol("\021DriverServicesLib", "\023IOCommandIsComplete");
        D(bug("IOCommandIsComplete TVECT at %08lx\n", (uint32)IOCommandIsComplete));
        if (IOCommandIsComplete == NULL) {
                printf("FATAL: SerialOpen(): Can't find IOCommandIsComplete()\n");
                return openErr;
        }

        // Do nothing if port is already open
        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (the_port->is_open)
                return noErr;

        // Init variables
        the_port->read_pending = the_port->write_pending = false;
        the_port->read_done = the_port->write_done = false;
        the_port->cum_errors = 0;

        // Open port
        int16 res = the_port->open(ReadMacInt16(0x1fc + ((-(int16)ReadMacInt16(dce + dCtlRefNum)-6) & 2)));
        if (res)
                return res;

        // Allocate Deferred Task structures
        uint32 input_dt = the_port->input_dt = (uint32)the_port->dt_store;
        uint32 output_dt = the_port->output_dt = (uint32)the_port->dt_store + SIZEOF_serdt;
        D(bug(" input_dt %08lx, output_dt %08lx\n", input_dt, output_dt));

        WriteMacInt16(input_dt + qType, dtQType);
        WriteMacInt32(input_dt + dtAddr, input_dt + serdtCode);
        WriteMacInt32(input_dt + dtParam, input_dt + serdtResult);
                                                                                                                        // Deferred function for signalling that Prime is complete (pointer to mydtResult in a1)
        WriteMacInt16(input_dt + serdtCode, 0x2019);                    // move.l       (a1)+,d0        (result)
        WriteMacInt16(input_dt + serdtCode + 2, 0x2251);                // move.l       (a1),a1         (dce)
        WriteMacInt32(input_dt + serdtCode + 4, 0x207808fc);    // move.l       JIODone,a0
        WriteMacInt16(input_dt + serdtCode + 8, 0x4ed0);                // jmp          (a0)

        WriteMacInt16(output_dt + qType, dtQType);
        WriteMacInt32(output_dt + dtAddr, output_dt + serdtCode);
        WriteMacInt32(output_dt + dtParam, output_dt + serdtResult);
                                                                                                                        // Deferred function for signalling that Prime is complete (pointer to mydtResult in a1)
        WriteMacInt16(output_dt + serdtCode, 0x2019);                   // move.l       (a1)+,d0        (result)
        WriteMacInt16(output_dt + serdtCode + 2, 0x2251);               // move.l       (a1),a1         (dce)
        WriteMacInt32(output_dt + serdtCode + 4, 0x207808fc);   // move.l       JIODone,a0
        WriteMacInt16(output_dt + serdtCode + 8, 0x4ed0);               // jmp          (a0)

        the_port->is_open = true;
        return noErr;
}


/*
 *  Driver Prime() routines
 */

int16 SerialPrimeIn(uint32 pb, uint32 dce)
{
        D(bug("SerialPrimeIn pb %08lx, dce %08lx\n", pb, dce));
        int16 res;

        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (!the_port->is_open)
                res = notOpenErr;
        else {
                if (the_port->read_pending) {
                        printf("FATAL: SerialPrimeIn() called while request is pending\n");
                        res = readErr;
                } else
                        res = the_port->prime_in(pb, dce);
        }

        if (ReadMacInt16(pb + ioTrap) & 0x0200)
                if (res > 0) {
                        WriteMacInt16(pb + ioResult, 0);
                        return 0;       // Command in progress
                } else {
                        WriteMacInt16(pb + ioResult, res);
                        return res;
                }
        else
                if (res > 0)
                        return 0;                                       // Command in progress
                else {
                        IOCommandIsComplete(pb, res);
                        return res;
                }
}

int16 SerialPrimeOut(uint32 pb, uint32 dce)
{
        D(bug("SerialPrimeOut pb %08lx, dce %08lx\n", pb, dce));
        int16 res;

        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (!the_port->is_open)
                res = notOpenErr;
        else {
                if (the_port->write_pending) {
                        printf("FATAL: SerialPrimeOut() called while request is pending\n");
                        res = writErr;
                } else
                        res = the_port->prime_out(pb, dce);
        }

        if (ReadMacInt16(pb + ioTrap) & 0x0200)
                if (res > 0) {
                        WriteMacInt16(pb + ioResult, 0);
                        return 0;       // Command in progress
                } else {
                        WriteMacInt16(pb + ioResult, res);
                        return res;
                }
        else
                if (res > 0)
                        return 0;                                       // Command in progress
                else {
                        IOCommandIsComplete(pb, res);
                        return res;
                }
}


/*
 *  Driver Control() routine
 */

int16 SerialControl(uint32 pb, uint32 dce)
{
        uint16 code = ReadMacInt16(pb + csCode);
        D(bug("SerialControl %d, pb %08lx, dce %08lx\n", code, pb, dce));
        int16 res;

        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (!the_port->is_open)
                res = notOpenErr;
        else {
                switch (code) {
                        case kSERDSetPollWrite:
                                res = noErr;
                                break;
                        default:
                                res = the_port->control(pb, dce, code);
                                break;
                }
        }

        if (code == 1)
                return res;
        else if (ReadMacInt16(pb + ioTrap) & 0x0200) {
                WriteMacInt16(pb + ioResult, res);
                return res;
        } else {
                IOCommandIsComplete(pb, res);
                return res;
        }
}


/*
 *  Driver Status() routine
 */

int16 SerialStatus(uint32 pb, uint32 dce)
{
        uint16 code = ReadMacInt16(pb + csCode);
        D(bug("SerialStatus %d, pb %08lx, dce %08lx\n", code, pb, dce));
        int16 res;

        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (!the_port->is_open)
                res = notOpenErr;
        else {
                switch (code) {
                        case kSERDVersion:
                                WriteMacInt8(pb + csParam, 9);          // Second-generation SerialDMA driver
                                res = noErr;
                                break;

                        case 0x8000:
                                WriteMacInt8(pb + csParam, 9);          // Second-generation SerialDMA driver
                                WriteMacInt16(pb + csParam + 4, 0x1997);        // Date of serial driver
                                WriteMacInt16(pb + csParam + 6, 0x0616);
                                res = noErr;
                                break;
        
                        default:
                                res = the_port->status(pb, dce, code);
                                break;
                }
        }

        if (ReadMacInt16(pb + ioTrap) & 0x0200) {
                WriteMacInt16(pb + ioResult, res);
                return res;
        } else {
                IOCommandIsComplete(pb, res);
                return res;
        }
}


/*
 *  Driver Close() routine
 */

int16 SerialClose(uint32 pb, uint32 dce)
{
        D(bug("SerialClose pb %08lx, dce %08lx\n", pb, dce));

        // Close port if open
        SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
        if (the_port->is_open) {
                int16 res = the_port->close();
                the_port->is_open = false;
                return res;
        } else
                return noErr;
}


/*
 *  Serial interrupt - Prime command completed, activate deferred tasks to call IODone
 */

void SerialInterrupt(void)
{
        D(bug("SerialIRQ\n"));

        // Port 0
        if (the_serd_port[0]->is_open) {
                if (the_serd_port[0]->read_pending && the_serd_port[0]->read_done) {
                        Enqueue(the_serd_port[0]->input_dt, 0xd92);
                        the_serd_port[0]->read_pending = the_serd_port[0]->read_done = false;
                }
                if (the_serd_port[0]->write_pending && the_serd_port[0]->write_done) {
                        Enqueue(the_serd_port[0]->output_dt, 0xd92);
                        the_serd_port[0]->write_pending = the_serd_port[0]->write_done = false;
                }
        }

        // Port 1
        if (the_serd_port[1]->is_open) {
                if (the_serd_port[1]->read_pending && the_serd_port[1]->read_done) {
                        Enqueue(the_serd_port[1]->input_dt, 0xd92);
                        the_serd_port[1]->read_pending = the_serd_port[1]->read_done = false;
                }
                if (the_serd_port[1]->write_pending && the_serd_port[1]->write_done) {
                        Enqueue(the_serd_port[1]->output_dt, 0xd92);
                        the_serd_port[1]->write_pending = the_serd_port[1]->write_done = false;
                }
        }
}
Revision:	1.1
Committed:	2002-02-04T16:58:13Z (22 years, 9 months ago) by cebix
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	User	Rev	Content
1	cebix	1.1	/*
2			* serial.cpp - Serial device driver
3			*
4			* SheepShaver (C) 1997-2002 Marc Hellwig and 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			#include "sysdeps.h"
22			#include "main.h"
23			#include "macos_util.h"
24			#include "serial.h"
25			#include "serial_defs.h"
26
27			#define DEBUG 0
28			#include "debug.h"
29
30
31			// Global variables
32			SERDPort *the_serd_port[2];
33
34			// Function pointers from imported functions
35			typedef int16 (*iocommandiscomplete_ptr)(uint32, int16);
36			static iocommandiscomplete_ptr IOCommandIsComplete;
37
38
39			/*
40			* Empty function (AIn/BIn Open/Close)
41			*/
42
43			int16 SerialNothing(uint32 pb, uint32 dce)
44			{
45			return noErr;
46			}
47
48
49			/*
50			* Driver Open() routine (output side only)
51			*/
52
53			int16 SerialOpen(uint32 pb, uint32 dce)
54			{
55			D(bug("SerialOpen pb %08lx, dce %08lx\n", pb, dce));
56
57			// Get IOCommandIsComplete function
58			IOCommandIsComplete = (iocommandiscomplete_ptr)FindLibSymbol("\021DriverServicesLib", "\023IOCommandIsComplete");
59			D(bug("IOCommandIsComplete TVECT at %08lx\n", (uint32)IOCommandIsComplete));
60			if (IOCommandIsComplete == NULL) {
61			printf("FATAL: SerialOpen(): Can't find IOCommandIsComplete()\n");
62			return openErr;
63			}
64
65			// Do nothing if port is already open
66			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
67			if (the_port->is_open)
68			return noErr;
69
70			// Init variables
71			the_port->read_pending = the_port->write_pending = false;
72			the_port->read_done = the_port->write_done = false;
73			the_port->cum_errors = 0;
74
75			// Open port
76			int16 res = the_port->open(ReadMacInt16(0x1fc + ((-(int16)ReadMacInt16(dce + dCtlRefNum)-6) & 2)));
77			if (res)
78			return res;
79
80			// Allocate Deferred Task structures
81			uint32 input_dt = the_port->input_dt = (uint32)the_port->dt_store;
82			uint32 output_dt = the_port->output_dt = (uint32)the_port->dt_store + SIZEOF_serdt;
83			D(bug(" input_dt %08lx, output_dt %08lx\n", input_dt, output_dt));
84
85			WriteMacInt16(input_dt + qType, dtQType);
86			WriteMacInt32(input_dt + dtAddr, input_dt + serdtCode);
87			WriteMacInt32(input_dt + dtParam, input_dt + serdtResult);
88			// Deferred function for signalling that Prime is complete (pointer to mydtResult in a1)
89			WriteMacInt16(input_dt + serdtCode, 0x2019); // move.l (a1)+,d0 (result)
90			WriteMacInt16(input_dt + serdtCode + 2, 0x2251); // move.l (a1),a1 (dce)
91			WriteMacInt32(input_dt + serdtCode + 4, 0x207808fc); // move.l JIODone,a0
92			WriteMacInt16(input_dt + serdtCode + 8, 0x4ed0); // jmp (a0)
93
94			WriteMacInt16(output_dt + qType, dtQType);
95			WriteMacInt32(output_dt + dtAddr, output_dt + serdtCode);
96			WriteMacInt32(output_dt + dtParam, output_dt + serdtResult);
97			// Deferred function for signalling that Prime is complete (pointer to mydtResult in a1)
98			WriteMacInt16(output_dt + serdtCode, 0x2019); // move.l (a1)+,d0 (result)
99			WriteMacInt16(output_dt + serdtCode + 2, 0x2251); // move.l (a1),a1 (dce)
100			WriteMacInt32(output_dt + serdtCode + 4, 0x207808fc); // move.l JIODone,a0
101			WriteMacInt16(output_dt + serdtCode + 8, 0x4ed0); // jmp (a0)
102
103			the_port->is_open = true;
104			return noErr;
105			}
106
107
108			/*
109			* Driver Prime() routines
110			*/
111
112			int16 SerialPrimeIn(uint32 pb, uint32 dce)
113			{
114			D(bug("SerialPrimeIn pb %08lx, dce %08lx\n", pb, dce));
115			int16 res;
116
117			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
118			if (!the_port->is_open)
119			res = notOpenErr;
120			else {
121			if (the_port->read_pending) {
122			printf("FATAL: SerialPrimeIn() called while request is pending\n");
123			res = readErr;
124			} else
125			res = the_port->prime_in(pb, dce);
126			}
127
128			if (ReadMacInt16(pb + ioTrap) & 0x0200)
129			if (res > 0) {
130			WriteMacInt16(pb + ioResult, 0);
131			return 0; // Command in progress
132			} else {
133			WriteMacInt16(pb + ioResult, res);
134			return res;
135			}
136			else
137			if (res > 0)
138			return 0; // Command in progress
139			else {
140			IOCommandIsComplete(pb, res);
141			return res;
142			}
143			}
144
145			int16 SerialPrimeOut(uint32 pb, uint32 dce)
146			{
147			D(bug("SerialPrimeOut pb %08lx, dce %08lx\n", pb, dce));
148			int16 res;
149
150			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
151			if (!the_port->is_open)
152			res = notOpenErr;
153			else {
154			if (the_port->write_pending) {
155			printf("FATAL: SerialPrimeOut() called while request is pending\n");
156			res = writErr;
157			} else
158			res = the_port->prime_out(pb, dce);
159			}
160
161			if (ReadMacInt16(pb + ioTrap) & 0x0200)
162			if (res > 0) {
163			WriteMacInt16(pb + ioResult, 0);
164			return 0; // Command in progress
165			} else {
166			WriteMacInt16(pb + ioResult, res);
167			return res;
168			}
169			else
170			if (res > 0)
171			return 0; // Command in progress
172			else {
173			IOCommandIsComplete(pb, res);
174			return res;
175			}
176			}
177
178
179			/*
180			* Driver Control() routine
181			*/
182
183			int16 SerialControl(uint32 pb, uint32 dce)
184			{
185			uint16 code = ReadMacInt16(pb + csCode);
186			D(bug("SerialControl %d, pb %08lx, dce %08lx\n", code, pb, dce));
187			int16 res;
188
189			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
190			if (!the_port->is_open)
191			res = notOpenErr;
192			else {
193			switch (code) {
194			case kSERDSetPollWrite:
195			res = noErr;
196			break;
197			default:
198			res = the_port->control(pb, dce, code);
199			break;
200			}
201			}
202
203			if (code == 1)
204			return res;
205			else if (ReadMacInt16(pb + ioTrap) & 0x0200) {
206			WriteMacInt16(pb + ioResult, res);
207			return res;
208			} else {
209			IOCommandIsComplete(pb, res);
210			return res;
211			}
212			}
213
214
215			/*
216			* Driver Status() routine
217			*/
218
219			int16 SerialStatus(uint32 pb, uint32 dce)
220			{
221			uint16 code = ReadMacInt16(pb + csCode);
222			D(bug("SerialStatus %d, pb %08lx, dce %08lx\n", code, pb, dce));
223			int16 res;
224
225			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
226			if (!the_port->is_open)
227			res = notOpenErr;
228			else {
229			switch (code) {
230			case kSERDVersion:
231			WriteMacInt8(pb + csParam, 9); // Second-generation SerialDMA driver
232			res = noErr;
233			break;
234
235			case 0x8000:
236			WriteMacInt8(pb + csParam, 9); // Second-generation SerialDMA driver
237			WriteMacInt16(pb + csParam + 4, 0x1997); // Date of serial driver
238			WriteMacInt16(pb + csParam + 6, 0x0616);
239			res = noErr;
240			break;
241
242			default:
243			res = the_port->status(pb, dce, code);
244			break;
245			}
246			}
247
248			if (ReadMacInt16(pb + ioTrap) & 0x0200) {
249			WriteMacInt16(pb + ioResult, res);
250			return res;
251			} else {
252			IOCommandIsComplete(pb, res);
253			return res;
254			}
255			}
256
257
258			/*
259			* Driver Close() routine
260			*/
261
262			int16 SerialClose(uint32 pb, uint32 dce)
263			{
264			D(bug("SerialClose pb %08lx, dce %08lx\n", pb, dce));
265
266			// Close port if open
267			SERDPort *the_port = the_serd_port[(-(int16)ReadMacInt16(dce + dCtlRefNum)-6) >> 1];
268			if (the_port->is_open) {
269			int16 res = the_port->close();
270			the_port->is_open = false;
271			return res;
272			} else
273			return noErr;
274			}
275
276
277			/*
278			* Serial interrupt - Prime command completed, activate deferred tasks to call IODone
279			*/
280
281			void SerialInterrupt(void)
282			{
283			D(bug("SerialIRQ\n"));
284
285			// Port 0
286			if (the_serd_port[0]->is_open) {
287			if (the_serd_port[0]->read_pending && the_serd_port[0]->read_done) {
288			Enqueue(the_serd_port[0]->input_dt, 0xd92);
289			the_serd_port[0]->read_pending = the_serd_port[0]->read_done = false;
290			}
291			if (the_serd_port[0]->write_pending && the_serd_port[0]->write_done) {
292			Enqueue(the_serd_port[0]->output_dt, 0xd92);
293			the_serd_port[0]->write_pending = the_serd_port[0]->write_done = false;
294			}
295			}
296
297			// Port 1
298			if (the_serd_port[1]->is_open) {
299			if (the_serd_port[1]->read_pending && the_serd_port[1]->read_done) {
300			Enqueue(the_serd_port[1]->input_dt, 0xd92);
301			the_serd_port[1]->read_pending = the_serd_port[1]->read_done = false;
302			}
303			if (the_serd_port[1]->write_pending && the_serd_port[1]->write_done) {
304			Enqueue(the_serd_port[1]->output_dt, 0xd92);
305			the_serd_port[1]->write_pending = the_serd_port[1]->write_done = false;
306			}
307			}
308			}