macemu/BasiliskII/src/serial.cpp

252 lines
6.4 KiB
C++
Raw Normal View History

1999-10-03 14:16:26 +00:00
/*
* serial.cpp - Serial device driver
*
2005-01-30 21:42:16 +00:00
* Basilisk II (C) 1997-2005 Christian Bauer
1999-10-03 14:16:26 +00:00
*
* 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 7 "Serial Driver"
* Technote HW 04: "Break/CTS Device Driver Event Structure"
* Technote 1018: "Understanding the SerialDMA Driver"
*/
#include <stdio.h>
#include "sysdeps.h"
#include "cpu_emulation.h"
#include "main.h"
#include "macos_util.h"
#include "serial.h"
#include "serial_defs.h"
#include "emul_op.h"
#define DEBUG 0
#include "debug.h"
// Global variables
SERDPort *the_serd_port[2];
/*
* Driver Open() routine
*/
int16 SerialOpen(uint32 pb, uint32 dce, int port)
{
D(bug("SerialOpen port %d, pb %08lx, dce %08lx\n", port, pb, dce));
if (port == 0 || port == 2) {
// Do nothing for input side
return noErr;
} else {
// Do nothing if port is already open
SERDPort *the_port = the_serd_port[port >> 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
1999-10-19 19:28:28 +00:00
int16 res = the_port->open(ReadMacInt16(0x1fc + (port & 2)));
1999-10-03 14:16:26 +00:00
if (res)
return res;
// Allocate Deferred Task structures
M68kRegisters r;
r.d[0] = SIZEOF_serdt * 2;
Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
if (r.a[0] == 0) {
1999-10-19 19:28:28 +00:00
the_port->close();
1999-10-03 14:16:26 +00:00
return openErr;
}
uint32 input_dt = the_port->input_dt = r.a[0];
uint32 output_dt = the_port->output_dt = r.a[0] + 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() routine
*/
int16 SerialPrime(uint32 pb, uint32 dce, int port)
{
D(bug("SerialPrime port %d, pb %08lx, dce %08lx\n", port, pb, dce));
// Error if port is not open
SERDPort *the_port = the_serd_port[port >> 1];
if (!the_port->is_open)
return notOpenErr;
if (port == 0 || port == 2) {
if (the_port->read_pending) {
printf("FATAL: SerialPrimeIn() called while request is pending\n");
return readErr;
} else
1999-10-19 19:28:28 +00:00
return the_port->prime_in(pb, dce);
1999-10-03 14:16:26 +00:00
} else {
if (the_port->write_pending) {
printf("FATAL: SerialPrimeOut() called while request is pending\n");
return readErr;
} else
1999-10-19 19:28:28 +00:00
return the_port->prime_out(pb, dce);
1999-10-03 14:16:26 +00:00
}
}
/*
* Driver Control() routine
*/
int16 SerialControl(uint32 pb, uint32 dce, int port)
{
uint16 code = ReadMacInt16(pb + csCode);
D(bug("SerialControl %d, port %d, pb %08lx, dce %08lx\n", code, port, pb, dce));
// Error if port is not open
SERDPort *the_port = the_serd_port[port >> 1];
if (!the_port->is_open)
return notOpenErr;
switch (code) {
case kSERDSetPollWrite:
return noErr;
default:
1999-10-19 19:28:28 +00:00
return the_port->control(pb, dce, code);
1999-10-03 14:16:26 +00:00
}
}
/*
* Driver Status() routine
*/
int16 SerialStatus(uint32 pb, uint32 dce, int port)
{
uint16 code = ReadMacInt16(pb + csCode);
D(bug("SerialStatus %d, port %d, pb %08lx, dce %08lx\n", code, port, pb, dce));
// Error if port is not open
SERDPort *the_port = the_serd_port[port >> 1];
if (!the_port->is_open)
return notOpenErr;
switch (code) {
case kSERDVersion:
WriteMacInt8(pb + csParam, 9); // Second-generation SerialDMA driver
return noErr;
case 0x8000:
WriteMacInt8(pb + csParam, 9); // Second-generation SerialDMA driver
WriteMacInt16(pb + csParam + 4, 0x1997); // Date of serial driver
WriteMacInt16(pb + csParam + 6, 0x0616);
return noErr;
default:
1999-10-19 19:28:28 +00:00
return the_port->status(pb, dce, code);
1999-10-03 14:16:26 +00:00
}
}
/*
* Driver Close() routine
*/
int16 SerialClose(uint32 pb, uint32 dce, int port)
{
D(bug("SerialClose port %d, pb %08lx, dce %08lx\n", port, pb, dce));
if (port == 0 || port == 2) {
// Do nothing for input side
return noErr;
} else {
// Close port if open
SERDPort *the_port = the_serd_port[port >> 1];
if (the_port->is_open) {
1999-10-19 19:28:28 +00:00
int16 res = the_port->close();
1999-10-03 14:16:26 +00:00
M68kRegisters r; // Free Deferred Task structures
r.a[0] = the_port->input_dt;
Execute68kTrap(0xa01f, &r); // DisposePtr()
the_port->is_open = false;
return res;
} else
return noErr;
}
}
/*
* Serial interrupt - Prime command completed, activate deferred tasks to call IODone
*/
static void serial_irq(SERDPort *p)
{
if (p->is_open) {
if (p->read_pending && p->read_done) {
1999-10-19 19:28:28 +00:00
EnqueueMac(p->input_dt, 0xd92);
1999-10-03 14:16:26 +00:00
p->read_pending = p->read_done = false;
}
if (p->write_pending && p->write_done) {
1999-10-19 19:28:28 +00:00
EnqueueMac(p->output_dt, 0xd92);
1999-10-03 14:16:26 +00:00
p->write_pending = p->write_done = false;
}
}
}
void SerialInterrupt(void)
{
D(bug("SerialIRQ\n"));
serial_irq(the_serd_port[0]);
serial_irq(the_serd_port[1]);
}