src/Unix/serial_unix.cpp

/*
 *  serial_unix.cpp - Serial device driver, Unix specific stuff
 *
 *  Basilisk II (C) 1997-2002 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 <sys/ioctl.h>
#include <sys/stat.h>
#include <pthread.h>
#include <semaphore.h>
#include <termios.h>
#ifdef __linux__
#include <linux/lp.h>
#include <linux/major.h>
#include <linux/kdev_t.h>
#endif

#include "cpu_emulation.h"
#include "main.h"
#include "macos_util.h"
#include "prefs.h"
#include "serial.h"
#include "serial_defs.h"

#define DEBUG 0
#include "debug.h"

#define MONITOR 0


// Missing functions
#ifndef HAVE_CFMAKERAW
static int cfmakeraw(struct termios *termios_p)
{
        termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
        termios_p->c_oflag &= ~OPOST;
        termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
        termios_p->c_cflag &= ~(CSIZE|PARENB);
        termios_p->c_cflag |= CS8;
}
#endif


// Driver private variables
class XSERDPort : public SERDPort {
public:
        XSERDPort(const char *dev)
        {
                device_name = dev;
                is_parallel = false;
                fd = -1;
                input_thread_active = output_thread_active = false;

                pthread_attr_init(&thread_attr);
#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
                if (geteuid() == 0) {
                        pthread_attr_setinheritsched(&thread_attr, PTHREAD_EXPLICIT_SCHED);
                        pthread_attr_setschedpolicy(&thread_attr, SCHED_FIFO);
                        struct sched_param fifo_param;
                        fifo_param.sched_priority = (sched_get_priority_min(SCHED_FIFO) + sched_get_priority_max(SCHED_FIFO)) / 2 + 2;
                        pthread_attr_setschedparam(&thread_attr, &fifo_param);
                }
#endif
        }

        virtual ~XSERDPort()
        {
                if (input_thread_active) {
                        input_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
                        pthread_cancel(input_thread);
#endif
                        pthread_join(input_thread, NULL);
                        sem_destroy(&input_signal);
                        input_thread_active = false;
                }
                if (output_thread_active) {
                        output_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
                        pthread_cancel(output_thread);
#endif
                        pthread_join(output_thread, NULL);
                        sem_destroy(&output_signal);
                        output_thread_active = false;
                }
        }

        virtual int16 open(uint16 config);
        virtual int16 prime_in(uint32 pb, uint32 dce);
        virtual int16 prime_out(uint32 pb, uint32 dce);
        virtual int16 control(uint32 pb, uint32 dce, uint16 code);
        virtual int16 status(uint32 pb, uint32 dce, uint16 code);
        virtual int16 close(void);

private:
        bool configure(uint16 config);
        void set_handshake(uint32 s, bool with_dtr);
        static void *input_func(void *arg);
        static void *output_func(void *arg);

        const char *device_name;                        // Device name
        bool is_parallel;                                       // Flag: Port is parallel
        int fd;                                                         // FD of device

        bool io_killed;                                         // Flag: KillIO called, I/O threads must not call deferred tasks
        bool quitting;                                          // Flag: Quit threads

        pthread_attr_t thread_attr;                     // Input/output thread attributes

        bool input_thread_active;                       // Flag: Input thread installed
        volatile bool input_thread_cancel;      // Flag: Cancel input thread
        pthread_t input_thread;                         // Data input thread
        sem_t input_signal;                                     // Signal for input thread: execute command
        uint32 input_pb;                                        // Command parameter for input thread

        bool output_thread_active;                      // Flag: Output thread installed
        volatile bool output_thread_cancel;     // Flag: Cancel output thread
        pthread_t output_thread;                        // Data output thread
        sem_t output_signal;                            // Signal for output thread: execute command
        uint32 output_pb;                                       // Command parameter for output thread

        struct termios mode;                            // Terminal configuration
};


/*
 *  Initialization
 */

void SerialInit(void)
{
        // Read serial preferences and create structs for both ports
        the_serd_port[0] = new XSERDPort(PrefsFindString("seriala"));
        the_serd_port[1] = new XSERDPort(PrefsFindString("serialb"));
}


/*
 *  Deinitialization
 */

void SerialExit(void)
{
        delete (XSERDPort *)the_serd_port[0];
        delete (XSERDPort *)the_serd_port[1];
}


/*
 *  Open serial port
 */

int16 XSERDPort::open(uint16 config)
{
        // Don't open NULL name devices
        if (device_name == NULL)
                return openErr;

        // Init variables
        io_killed = false;
        quitting = false;

        // Open port
        fd = ::open(device_name, O_RDWR);
        if (fd < 0)
                goto open_error;

#if defined(__linux__)
        // Parallel port?
        struct stat st;
        if (fstat(fd, &st) == 0)
                if (S_ISCHR(st.st_mode))
                        is_parallel = (MAJOR(st.st_rdev) == LP_MAJOR);
#elif defined(__FreeBSD__) || defined(__NetBSD__)
        // Parallel port?
        struct stat st;
        if (fstat(fd, &st) == 0)
                if (S_ISCHR(st.st_mode))
                        is_parallel = ((st.st_rdev >> 16) == 16);
#endif

        // Configure port for raw mode
        if (!is_parallel) {
                if (tcgetattr(fd, &mode) < 0)
                        goto open_error;
                cfmakeraw(&mode);
                mode.c_cflag |= HUPCL;
                mode.c_cc[VMIN] = 1;
                mode.c_cc[VTIME] = 0;
                tcsetattr(fd, TCSAFLUSH, &mode);
        }
        configure(config);

        // Start input/output threads
        input_thread_cancel = false;
        output_thread_cancel = false;
        if (sem_init(&input_signal, 0, 0) < 0)
                goto open_error;
        if (sem_init(&output_signal, 0, 0) < 0)
                goto open_error; 
        input_thread_active = (pthread_create(&input_thread, &thread_attr, input_func, this) == 0);
        output_thread_active = (pthread_create(&output_thread, &thread_attr, output_func, this) == 0);
        if (!input_thread_active || !output_thread_active)
                goto open_error;
        return noErr;

open_error:
        if (input_thread_active) {
                input_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
                pthread_cancel(input_thread);
#endif
                pthread_join(input_thread, NULL);
                sem_destroy(&input_signal);
                input_thread_active = false;
        }
        if (output_thread_active) {
                output_thread_cancel = true;
#ifdef HAVE_PTHREAD_CANCEL
                pthread_cancel(output_thread);
#endif
                pthread_join(output_thread, NULL);
                sem_destroy(&output_signal);
                output_thread_active = false;
        }
        if (fd > 0) {
                ::close(fd);
                fd = -1;
        }
        return openErr;
}


/*
 *  Read data from port
 */

int16 XSERDPort::prime_in(uint32 pb, uint32 dce)
{
        // Send input command to input_thread
        read_done = false;
        read_pending = true;
        input_pb = pb;
        WriteMacInt32(input_dt + serdtDCE, dce);
        sem_post(&input_signal);
        return 1;       // Command in progress
}


/*
 *  Write data to port
 */

int16 XSERDPort::prime_out(uint32 pb, uint32 dce)
{
        // Send output command to output_thread
        write_done = false;
        write_pending = true;
        output_pb = pb;
        WriteMacInt32(output_dt + serdtDCE, dce);
        sem_post(&output_signal);
        return 1;       // Command in progress
}


/*
 *      Control calls
 */

int16 XSERDPort::control(uint32 pb, uint32 dce, uint16 code)
{
        switch (code) {
                case 1:                 // KillIO
                        io_killed = true;
                        if (!is_parallel)
                                tcflush(fd, TCIOFLUSH);
                        while (read_pending || write_pending)
                                usleep(10000);
                        io_killed = false;
                        return noErr;

                case kSERDConfiguration:
                        if (configure(ReadMacInt16(pb + csParam)))
                                return noErr;
                        else
                                return paramErr;

                case kSERDInputBuffer:
                        return noErr;   // Not supported under Unix

                case kSERDSerHShake:
                        set_handshake(pb + csParam, false);
                        return noErr;

                case kSERDSetBreak:
                        if (!is_parallel)
                                tcsendbreak(fd, 0);
                        return noErr;

                case kSERDClearBreak:
                        return noErr;

                case kSERDBaudRate: {
                        if (is_parallel)
                                return noErr;
                        uint16 rate = ReadMacInt16(pb + csParam);
                        speed_t baud_rate;
                        if (rate <= 50) {
                                rate = 50; baud_rate = B50;
                        } else if (rate <= 75) {
                                rate = 75; baud_rate = B75;
                        } else if (rate <= 110) {
                                rate = 110; baud_rate = B110;
                        } else if (rate <= 134) {
                                rate = 134; baud_rate = B134;
                        } else if (rate <= 150) {
                                rate = 150; baud_rate = B150;
                        } else if (rate <= 200) {
                                rate = 200; baud_rate = B200;
                        } else if (rate <= 300) {
                                rate = 300; baud_rate = B300;
                        } else if (rate <= 600) {
                                rate = 600; baud_rate = B600;
                        } else if (rate <= 1200) {
                                rate = 1200; baud_rate = B1200;
                        } else if (rate <= 1800) {
                                rate = 1800; baud_rate = B1800;
                        } else if (rate <= 2400) {
                                rate = 2400; baud_rate = B2400;
                        } else if (rate <= 4800) {
                                rate = 4800; baud_rate = B4800;
                        } else if (rate <= 9600) {
                                rate = 9600; baud_rate = B9600;
                        } else if (rate <= 19200) {
                                rate = 19200; baud_rate = B19200;
                        } else if (rate <= 38400) {
                                rate = 38400; baud_rate = B38400;
                        } else if (rate <= 57600) {
                                rate = 57600; baud_rate = B57600;
                        } else {
                                // Just for safety in case someone wants a rate between 57600 and 65535
                                rate = 57600; baud_rate = B57600;
                        }
                        WriteMacInt16(pb + csParam, rate);
                        cfsetispeed(&mode, B115200);
                        cfsetospeed(&mode, B115200);
                        tcsetattr(fd, TCSANOW, &mode);
                        return noErr;
                }

                case kSERDHandshake:
                case kSERDHandshakeRS232:
                        set_handshake(pb + csParam, true);
                        return noErr;

                case kSERDMiscOptions:
                        if (is_parallel)
                                return noErr;
                        if (ReadMacInt8(pb + csParam) & kOptionPreserveDTR)
                                mode.c_cflag &= ~HUPCL;
                        else
                                mode.c_cflag |= HUPCL;
                        tcsetattr(fd, TCSANOW, &mode);
                        return noErr;

                case kSERDAssertDTR: {
                        if (is_parallel)
                                return noErr;
                        unsigned int status = TIOCM_DTR;
                        ioctl(fd, TIOCMBIS, &status);
                        return noErr;
                }

                case kSERDNegateDTR: {
                        if (is_parallel)
                                return noErr;
                        unsigned int status = TIOCM_DTR;
                        ioctl(fd, TIOCMBIC, &status);
                        return noErr;
                }

                case kSERDSetPEChar:
                case kSERDSetPEAltChar:
                        return noErr;   // Not supported under Unix

                case kSERDResetChannel:
                        if (!is_parallel)
                                tcflush(fd, TCIOFLUSH);
                        return noErr;

                case kSERDAssertRTS: {
                        if (is_parallel)
                                return noErr;
                        unsigned int status = TIOCM_RTS;
                        ioctl(fd, TIOCMBIS, &status);
                        return noErr;
                }

                case kSERDNegateRTS: {
                        if (is_parallel)
                                return noErr;
                        unsigned int status = TIOCM_RTS;
                        ioctl(fd, TIOCMBIC, &status);
                        return noErr;
                }

                case kSERD115KBaud:
                        if (is_parallel)
                                return noErr;
                        cfsetispeed(&mode, B115200);
                        cfsetospeed(&mode, B115200);
                        tcsetattr(fd, TCSANOW, &mode);
                        return noErr;

                case kSERD230KBaud:
                case kSERDSetHighSpeed:
                        if (is_parallel)
                                return noErr;
                        cfsetispeed(&mode, B230400);
                        cfsetospeed(&mode, B230400);
                        tcsetattr(fd, TCSANOW, &mode);
                        return noErr;

                default:
                        printf("WARNING: SerialControl(): unimplemented control code %d\n", code);
                        return controlErr;
        }
}


/*
 *      Status calls
 */

int16 XSERDPort::status(uint32 pb, uint32 dce, uint16 code)
{
        switch (code) {
                case kSERDInputCount: {
                        int num;
                        ioctl(fd, FIONREAD, &num);
                        WriteMacInt32(pb + csParam, num);
                        return noErr;
                }

                case kSERDStatus: {
                        uint32 p = pb + csParam;
                        WriteMacInt8(p + staCumErrs, cum_errors);
                        cum_errors = 0;
                        WriteMacInt8(p + staXOffSent, 0);
                        WriteMacInt8(p + staXOffHold, 0);
                        WriteMacInt8(p + staRdPend, read_pending);
                        WriteMacInt8(p + staWrPend, write_pending);
                        if (is_parallel) {
                                WriteMacInt8(p + staCtsHold, 0);
                                WriteMacInt8(p + staDsrHold, 0);
                                WriteMacInt8(p + staModemStatus, dsrEvent | dcdEvent | ctsEvent);
                        } else {
                                unsigned int status;
                                ioctl(fd, TIOCMGET, &status);
                                WriteMacInt8(p + staCtsHold, status & TIOCM_CTS ? 0 : 1);
                                WriteMacInt8(p + staDsrHold, status & TIOCM_DTR ? 0 : 1);
                                WriteMacInt8(p + staModemStatus,
                                        (status & TIOCM_DSR ? dsrEvent : 0)
                                        | (status & TIOCM_RI ? riEvent : 0)
                                        | (status & TIOCM_CD ? dcdEvent : 0)
                                        | (status & TIOCM_CTS ? ctsEvent : 0));
                        }
                        return noErr;
                }

                default:
                        printf("WARNING: SerialStatus(): unimplemented status code %d\n", code);
                        return statusErr;
        }
}


/*
 *      Close serial port
 */

int16 XSERDPort::close()
{
        // Kill threads
        if (input_thread_active) {
                quitting = true;
                sem_post(&input_signal);
                pthread_join(input_thread, NULL);
                input_thread_active = false;
                sem_destroy(&input_signal);
        }
        if (output_thread_active) {
                quitting = true;
                sem_post(&output_signal);
                pthread_join(output_thread, NULL);
                output_thread_active = false;
                sem_destroy(&output_signal);
        }

        // Close port
        if (fd > 0)
                ::close(fd);
        fd = -1;
        return noErr;
}


/*
 *  Configure serial port with MacOS config word
 */

bool XSERDPort::configure(uint16 config)
{
        D(bug(" configure %04x\n", config));
        if (is_parallel)
                return true;

        // Set number of stop bits
        switch (config & 0xc000) {
                case stop10:
                        mode.c_cflag &= ~CSTOPB;
                        break;
                case stop20:
                        mode.c_cflag |= CSTOPB;
                        break;
                default:
                        return false;
        }

        // Set parity mode
        switch (config & 0x3000) {
                case noParity:
                        mode.c_iflag &= ~INPCK;
                        mode.c_oflag &= ~PARENB;
                        break;
                case oddParity:
                        mode.c_iflag |= INPCK;
                        mode.c_oflag |= PARENB;
                        mode.c_oflag |= PARODD;
                        break;
                case evenParity:
                        mode.c_iflag |= INPCK;
                        mode.c_oflag |= PARENB;
                        mode.c_oflag &= ~PARODD;
                        break;
                default:
                        return false;
        }

        // Set number of data bits
        switch (config & 0x0c00) {
                case data5:
                        mode.c_cflag = mode.c_cflag & ~CSIZE | CS5;
                        break;
                case data6:
                        mode.c_cflag = mode.c_cflag & ~CSIZE | CS6;
                        break;
                case data7:
                        mode.c_cflag = mode.c_cflag & ~CSIZE | CS7;
                        break;
                case data8:
                        mode.c_cflag = mode.c_cflag & ~CSIZE | CS8;
                        break;
        }

        // Set baud rate
        speed_t baud_rate;
        switch (config & 0x03ff) {
                case baud150: baud_rate = B150; break;
                case baud300: baud_rate = B300; break;
                case baud600: baud_rate = B600; break;
                case baud1200: baud_rate = B1200; break;
                case baud1800: baud_rate = B1800; break;
                case baud2400: baud_rate = B2400; break;
                case baud4800: baud_rate = B4800; break;
                case baud9600: baud_rate = B9600; break;
                case baud19200: baud_rate = B19200; break;
                case baud38400: baud_rate = B38400; break;
                case baud57600: baud_rate = B57600; break;
                default:
                        return false;
        }
        cfsetispeed(&mode, baud_rate);
        cfsetospeed(&mode, baud_rate);
        tcsetattr(fd, TCSANOW, &mode);
        return true;
}


/*
 *  Set serial handshaking
 */

void XSERDPort::set_handshake(uint32 s, bool with_dtr)
{
        D(bug(" set_handshake %02x %02x %02x %02x %02x %02x %02x %02x\n",
                ReadMacInt8(s + 0), ReadMacInt8(s + 1), ReadMacInt8(s + 2), ReadMacInt8(s + 3),
                ReadMacInt8(s + 4), ReadMacInt8(s + 5), ReadMacInt8(s + 6), ReadMacInt8(s + 7)));
        if (is_parallel)
                return;

        if (with_dtr) {
                if (ReadMacInt8(s + shkFCTS) || ReadMacInt8(s + shkFDTR))
                        mode.c_cflag |= CRTSCTS;
                else
                        mode.c_cflag &= ~CRTSCTS;
        } else {
                if (ReadMacInt8(s + shkFCTS))
                        mode.c_cflag |= CRTSCTS;
                else
                        mode.c_cflag &= ~CRTSCTS;
        }

        D(bug(" %sware flow control\n", mode.c_cflag & CRTSCTS ? "hard" : "soft"));
        tcsetattr(fd, TCSANOW, &mode);
}


/*
 *  Data input thread
 */

void *XSERDPort::input_func(void *arg)
{
        XSERDPort *s = (XSERDPort *)arg;
        while (!s->input_thread_cancel) {

                // Wait for commands
                sem_wait(&s->input_signal);
                if (s->quitting)
                        break;

                // Execute command
                void *buf = Mac2HostAddr(ReadMacInt32(s->input_pb + ioBuffer));
                uint32 length = ReadMacInt32(s->input_pb + ioReqCount);
                D(bug("input_func waiting for %ld bytes of data...\n", length));
                int32 actual = read(s->fd, buf, length);
                D(bug(" %ld bytes received\n", actual));

#if MONITOR
                bug("Receiving serial data:\n");
                uint8 *adr = (uint8 *)buf;
                for (int i=0; i<actual; i++) {
                        bug("%02x ", adr[i]);
                }
                bug("\n");
#endif

                // KillIO called? Then simply return
                if (s->io_killed) {

                        WriteMacInt16(s->input_pb + ioResult, uint16(abortErr));
                        WriteMacInt32(s->input_pb + ioActCount, 0);
                        s->read_pending = s->read_done = false;

                } else {

                        // Set error code
                        if (actual >= 0) {
                                WriteMacInt32(s->input_pb + ioActCount, actual);
                                WriteMacInt32(s->input_dt + serdtResult, noErr);
                        } else {
                                WriteMacInt32(s->input_pb + ioActCount, 0);
                                WriteMacInt32(s->input_dt + serdtResult, uint16(readErr));
                        }
        
                        // Trigger serial interrupt
                        D(bug(" triggering serial interrupt\n"));
                        s->read_done = true;
                        SetInterruptFlag(INTFLAG_SERIAL);
                        TriggerInterrupt();
                }
        }
        return NULL;
}


/*
 *  Data output thread
 */

void *XSERDPort::output_func(void *arg)
{
        XSERDPort *s = (XSERDPort *)arg;
        while (!s->output_thread_cancel) {

                // Wait for commands
                sem_wait(&s->output_signal);
                if (s->quitting)
                        break;

                // Execute command
                void *buf = Mac2HostAddr(ReadMacInt32(s->output_pb + ioBuffer));
                uint32 length = ReadMacInt32(s->output_pb + ioReqCount);
                D(bug("output_func transmitting %ld bytes of data...\n", length));

#if MONITOR
                bug("Sending serial data:\n");
                uint8 *adr = (uint8 *)buf;
                for (int i=0; i<length; i++) {
                        bug("%02x ", adr[i]);
                }
                bug("\n");
#endif

                int32 actual = write(s->fd, buf, length);
                D(bug(" %ld bytes transmitted\n", actual));

                // KillIO called? Then simply return
                if (s->io_killed) {

                        WriteMacInt16(s->output_pb + ioResult, uint16(abortErr));
                        WriteMacInt32(s->output_pb + ioActCount, 0);
                        s->write_pending = s->write_done = false;

                } else {

                        // Set error code
                        if (actual >= 0) {
                                WriteMacInt32(s->output_pb + ioActCount, actual);
                                WriteMacInt32(s->output_dt + serdtResult, noErr);
                        } else {
                                WriteMacInt32(s->output_pb + ioActCount, 0);
                                WriteMacInt32(s->output_dt + serdtResult, uint16(writErr));
                        }
        
                        // Trigger serial interrupt
                        D(bug(" triggering serial interrupt\n"));
                        s->write_done = true;
                        SetInterruptFlag(INTFLAG_SERIAL);
                        TriggerInterrupt();
                }
        }
        return NULL;
}
Revision:	1.9
Committed:	2002-01-15T14:58:37Z (22 years, 7 months ago) by cebix
Branch:	MAIN
CVS Tags:	snapshot-15012002
Changes since 1.8:	+1 -1 lines
Log Message:	- documentation updates - 2001 -> 2002 - version 0.9 -> 1.0
#	User	Rev	Content
1	cebix	1.1	/*
2			* serial_unix.cpp - Serial device driver, Unix specific stuff
3			*
4	cebix	1.9	* Basilisk II (C) 1997-2002 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			#include "sysdeps.h"
22
23			#include <sys/ioctl.h>
24			#include <sys/stat.h>
25			#include <pthread.h>
26			#include <semaphore.h>
27			#include <termios.h>
28			#ifdef __linux__
29			#include <linux/lp.h>
30			#include <linux/major.h>
31			#include <linux/kdev_t.h>
32			#endif
33
34			#include "cpu_emulation.h"
35			#include "main.h"
36			#include "macos_util.h"
37			#include "prefs.h"
38			#include "serial.h"
39			#include "serial_defs.h"
40
41			#define DEBUG 0
42			#include "debug.h"
43
44			#define MONITOR 0
45
46
47			// Missing functions
48			#ifndef HAVE_CFMAKERAW
49			static int cfmakeraw(struct termios *termios_p)
50			{
51			termios_p->c_iflag &= ~(IGNBRK\|BRKINT\|PARMRK\|ISTRIP\|INLCR\|IGNCR\|ICRNL\|IXON);
52			termios_p->c_oflag &= ~OPOST;
53			termios_p->c_lflag &= ~(ECHO\|ECHONL\|ICANON\|ISIG\|IEXTEN);
54			termios_p->c_cflag &= ~(CSIZE\|PARENB);
55			termios_p->c_cflag \|= CS8;
56			}
57			#endif
58
59
60			// Driver private variables
61			class XSERDPort : public SERDPort {
62			public:
63			XSERDPort(const char *dev)
64			{
65			device_name = dev;
66			is_parallel = false;
67			fd = -1;
68			input_thread_active = output_thread_active = false;
69
70			pthread_attr_init(&thread_attr);
71			#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)
72			if (geteuid() == 0) {
73			pthread_attr_setinheritsched(&thread_attr, PTHREAD_EXPLICIT_SCHED);
74			pthread_attr_setschedpolicy(&thread_attr, SCHED_FIFO);
75			struct sched_param fifo_param;
76			fifo_param.sched_priority = (sched_get_priority_min(SCHED_FIFO) + sched_get_priority_max(SCHED_FIFO)) / 2 + 2;
77			pthread_attr_setschedparam(&thread_attr, &fifo_param);
78			}
79			#endif
80			}
81
82			virtual ~XSERDPort()
83			{
84			if (input_thread_active) {
85			input_thread_cancel = true;
86			#ifdef HAVE_PTHREAD_CANCEL
87			pthread_cancel(input_thread);
88			#endif
89			pthread_join(input_thread, NULL);
90			sem_destroy(&input_signal);
91			input_thread_active = false;
92			}
93			if (output_thread_active) {
94			output_thread_cancel = true;
95			#ifdef HAVE_PTHREAD_CANCEL
96			pthread_cancel(output_thread);
97			#endif
98			pthread_join(output_thread, NULL);
99			sem_destroy(&output_signal);
100			output_thread_active = false;
101			}
102			}
103
104	cebix	1.3	virtual int16 open(uint16 config);
105			virtual int16 prime_in(uint32 pb, uint32 dce);
106			virtual int16 prime_out(uint32 pb, uint32 dce);
107			virtual int16 control(uint32 pb, uint32 dce, uint16 code);
108			virtual int16 status(uint32 pb, uint32 dce, uint16 code);
109			virtual int16 close(void);
110	cebix	1.1
111			private:
112			bool configure(uint16 config);
113			void set_handshake(uint32 s, bool with_dtr);
114			static void input_func(void arg);
115			static void output_func(void arg);
116
117			const char *device_name; // Device name
118			bool is_parallel; // Flag: Port is parallel
119			int fd; // FD of device
120
121			bool io_killed; // Flag: KillIO called, I/O threads must not call deferred tasks
122			bool quitting; // Flag: Quit threads
123
124			pthread_attr_t thread_attr; // Input/output thread attributes
125
126			bool input_thread_active; // Flag: Input thread installed
127			volatile bool input_thread_cancel; // Flag: Cancel input thread
128			pthread_t input_thread; // Data input thread
129			sem_t input_signal; // Signal for input thread: execute command
130			uint32 input_pb; // Command parameter for input thread
131
132			bool output_thread_active; // Flag: Output thread installed
133			volatile bool output_thread_cancel; // Flag: Cancel output thread
134			pthread_t output_thread; // Data output thread
135			sem_t output_signal; // Signal for output thread: execute command
136			uint32 output_pb; // Command parameter for output thread
137
138			struct termios mode; // Terminal configuration
139			};
140
141
142			/*
143			* Initialization
144			*/
145
146			void SerialInit(void)
147			{
148			// Read serial preferences and create structs for both ports
149			the_serd_port[0] = new XSERDPort(PrefsFindString("seriala"));
150			the_serd_port[1] = new XSERDPort(PrefsFindString("serialb"));
151			}
152
153
154			/*
155			* Deinitialization
156			*/
157
158			void SerialExit(void)
159			{
160			delete (XSERDPort *)the_serd_port[0];
161			delete (XSERDPort *)the_serd_port[1];
162			}
163
164
165			/*
166			* Open serial port
167			*/
168
169	cebix	1.3	int16 XSERDPort::open(uint16 config)
170	cebix	1.1	{
171			// Don't open NULL name devices
172			if (device_name == NULL)
173			return openErr;
174
175			// Init variables
176			io_killed = false;
177			quitting = false;
178
179			// Open port
180	cebix	1.4	fd = ::open(device_name, O_RDWR);
181	cebix	1.1	if (fd < 0)
182			goto open_error;
183
184	cebix	1.2	#if defined(__linux__)
185	cebix	1.1	// Parallel port?
186			struct stat st;
187			if (fstat(fd, &st) == 0)
188			if (S_ISCHR(st.st_mode))
189			is_parallel = (MAJOR(st.st_rdev) == LP_MAJOR);
190	cebix	1.2	#elif defined(__FreeBSD__) \|\| defined(__NetBSD__)
191	cebix	1.1	// Parallel port?
192			struct stat st;
193			if (fstat(fd, &st) == 0)
194			if (S_ISCHR(st.st_mode))
195			is_parallel = ((st.st_rdev >> 16) == 16);
196			#endif
197
198			// Configure port for raw mode
199			if (!is_parallel) {
200			if (tcgetattr(fd, &mode) < 0)
201			goto open_error;
202			cfmakeraw(&mode);
203			mode.c_cflag \|= HUPCL;
204			mode.c_cc[VMIN] = 1;
205			mode.c_cc[VTIME] = 0;
206			tcsetattr(fd, TCSAFLUSH, &mode);
207			}
208			configure(config);
209
210			// Start input/output threads
211	cebix	1.8	input_thread_cancel = false;
212			output_thread_cancel = false;
213	cebix	1.1	if (sem_init(&input_signal, 0, 0) < 0)
214			goto open_error;
215			if (sem_init(&output_signal, 0, 0) < 0)
216			goto open_error;
217			input_thread_active = (pthread_create(&input_thread, &thread_attr, input_func, this) == 0);
218			output_thread_active = (pthread_create(&output_thread, &thread_attr, output_func, this) == 0);
219			if (!input_thread_active \|\| !output_thread_active)
220			goto open_error;
221			return noErr;
222
223			open_error:
224			if (input_thread_active) {
225			input_thread_cancel = true;
226			#ifdef HAVE_PTHREAD_CANCEL
227			pthread_cancel(input_thread);
228			#endif
229			pthread_join(input_thread, NULL);
230			sem_destroy(&input_signal);
231			input_thread_active = false;
232			}
233			if (output_thread_active) {
234			output_thread_cancel = true;
235			#ifdef HAVE_PTHREAD_CANCEL
236			pthread_cancel(output_thread);
237			#endif
238			pthread_join(output_thread, NULL);
239			sem_destroy(&output_signal);
240			output_thread_active = false;
241			}
242			if (fd > 0) {
243	cebix	1.4	::close(fd);
244	cebix	1.1	fd = -1;
245			}
246			return openErr;
247			}
248
249
250			/*
251			* Read data from port
252			*/
253
254	cebix	1.3	int16 XSERDPort::prime_in(uint32 pb, uint32 dce)
255	cebix	1.1	{
256			// Send input command to input_thread
257			read_done = false;
258			read_pending = true;
259			input_pb = pb;
260			WriteMacInt32(input_dt + serdtDCE, dce);
261			sem_post(&input_signal);
262			return 1; // Command in progress
263			}
264
265
266			/*
267			* Write data to port
268			*/
269
270	cebix	1.3	int16 XSERDPort::prime_out(uint32 pb, uint32 dce)
271	cebix	1.1	{
272			// Send output command to output_thread
273			write_done = false;
274			write_pending = true;
275			output_pb = pb;
276			WriteMacInt32(output_dt + serdtDCE, dce);
277			sem_post(&output_signal);
278			return 1; // Command in progress
279			}
280
281
282			/*
283			* Control calls
284			*/
285
286	cebix	1.3	int16 XSERDPort::control(uint32 pb, uint32 dce, uint16 code)
287	cebix	1.1	{
288			switch (code) {
289			case 1: // KillIO
290			io_killed = true;
291			if (!is_parallel)
292			tcflush(fd, TCIOFLUSH);
293			while (read_pending \|\| write_pending)
294			usleep(10000);
295			io_killed = false;
296			return noErr;
297
298			case kSERDConfiguration:
299			if (configure(ReadMacInt16(pb + csParam)))
300			return noErr;
301			else
302			return paramErr;
303
304			case kSERDInputBuffer:
305			return noErr; // Not supported under Unix
306
307			case kSERDSerHShake:
308			set_handshake(pb + csParam, false);
309			return noErr;
310
311			case kSERDSetBreak:
312			if (!is_parallel)
313			tcsendbreak(fd, 0);
314			return noErr;
315
316			case kSERDClearBreak:
317			return noErr;
318
319			case kSERDBaudRate: {
320			if (is_parallel)
321			return noErr;
322			uint16 rate = ReadMacInt16(pb + csParam);
323			speed_t baud_rate;
324			if (rate <= 50) {
325			rate = 50; baud_rate = B50;
326			} else if (rate <= 75) {
327			rate = 75; baud_rate = B75;
328			} else if (rate <= 110) {
329			rate = 110; baud_rate = B110;
330			} else if (rate <= 134) {
331			rate = 134; baud_rate = B134;
332			} else if (rate <= 150) {
333			rate = 150; baud_rate = B150;
334			} else if (rate <= 200) {
335			rate = 200; baud_rate = B200;
336			} else if (rate <= 300) {
337			rate = 300; baud_rate = B300;
338			} else if (rate <= 600) {
339			rate = 600; baud_rate = B600;
340			} else if (rate <= 1200) {
341			rate = 1200; baud_rate = B1200;
342			} else if (rate <= 1800) {
343			rate = 1800; baud_rate = B1800;
344			} else if (rate <= 2400) {
345			rate = 2400; baud_rate = B2400;
346			} else if (rate <= 4800) {
347			rate = 4800; baud_rate = B4800;
348			} else if (rate <= 9600) {
349			rate = 9600; baud_rate = B9600;
350			} else if (rate <= 19200) {
351			rate = 19200; baud_rate = B19200;
352			} else if (rate <= 38400) {
353			rate = 38400; baud_rate = B38400;
354			} else if (rate <= 57600) {
355			rate = 57600; baud_rate = B57600;
356			} else {
357			// Just for safety in case someone wants a rate between 57600 and 65535
358			rate = 57600; baud_rate = B57600;
359			}
360			WriteMacInt16(pb + csParam, rate);
361			cfsetispeed(&mode, B115200);
362			cfsetospeed(&mode, B115200);
363			tcsetattr(fd, TCSANOW, &mode);
364			return noErr;
365			}
366
367			case kSERDHandshake:
368			case kSERDHandshakeRS232:
369			set_handshake(pb + csParam, true);
370			return noErr;
371
372			case kSERDMiscOptions:
373			if (is_parallel)
374			return noErr;
375			if (ReadMacInt8(pb + csParam) & kOptionPreserveDTR)
376			mode.c_cflag &= ~HUPCL;
377			else
378			mode.c_cflag \|= HUPCL;
379			tcsetattr(fd, TCSANOW, &mode);
380			return noErr;
381
382			case kSERDAssertDTR: {
383			if (is_parallel)
384			return noErr;
385			unsigned int status = TIOCM_DTR;
386			ioctl(fd, TIOCMBIS, &status);
387			return noErr;
388			}
389
390			case kSERDNegateDTR: {
391			if (is_parallel)
392			return noErr;
393			unsigned int status = TIOCM_DTR;
394			ioctl(fd, TIOCMBIC, &status);
395			return noErr;
396			}
397
398			case kSERDSetPEChar:
399			case kSERDSetPEAltChar:
400			return noErr; // Not supported under Unix
401
402			case kSERDResetChannel:
403			if (!is_parallel)
404			tcflush(fd, TCIOFLUSH);
405			return noErr;
406
407			case kSERDAssertRTS: {
408			if (is_parallel)
409			return noErr;
410			unsigned int status = TIOCM_RTS;
411			ioctl(fd, TIOCMBIS, &status);
412			return noErr;
413			}
414
415			case kSERDNegateRTS: {
416			if (is_parallel)
417			return noErr;
418			unsigned int status = TIOCM_RTS;
419			ioctl(fd, TIOCMBIC, &status);
420			return noErr;
421			}
422
423			case kSERD115KBaud:
424			if (is_parallel)
425			return noErr;
426			cfsetispeed(&mode, B115200);
427			cfsetospeed(&mode, B115200);
428			tcsetattr(fd, TCSANOW, &mode);
429			return noErr;
430
431			case kSERD230KBaud:
432			case kSERDSetHighSpeed:
433			if (is_parallel)
434			return noErr;
435			cfsetispeed(&mode, B230400);
436			cfsetospeed(&mode, B230400);
437			tcsetattr(fd, TCSANOW, &mode);
438			return noErr;
439
440			default:
441			printf("WARNING: SerialControl(): unimplemented control code %d\n", code);
442			return controlErr;
443			}
444			}
445
446
447			/*
448			* Status calls
449			*/
450
451	cebix	1.3	int16 XSERDPort::status(uint32 pb, uint32 dce, uint16 code)
452	cebix	1.1	{
453			switch (code) {
454			case kSERDInputCount: {
455			int num;
456			ioctl(fd, FIONREAD, &num);
457			WriteMacInt32(pb + csParam, num);
458			return noErr;
459			}
460
461			case kSERDStatus: {
462			uint32 p = pb + csParam;
463			WriteMacInt8(p + staCumErrs, cum_errors);
464			cum_errors = 0;
465			WriteMacInt8(p + staXOffSent, 0);
466			WriteMacInt8(p + staXOffHold, 0);
467			WriteMacInt8(p + staRdPend, read_pending);
468			WriteMacInt8(p + staWrPend, write_pending);
469			if (is_parallel) {
470			WriteMacInt8(p + staCtsHold, 0);
471			WriteMacInt8(p + staDsrHold, 0);
472			WriteMacInt8(p + staModemStatus, dsrEvent \| dcdEvent \| ctsEvent);
473			} else {
474			unsigned int status;
475			ioctl(fd, TIOCMGET, &status);
476			WriteMacInt8(p + staCtsHold, status & TIOCM_CTS ? 0 : 1);
477			WriteMacInt8(p + staDsrHold, status & TIOCM_DTR ? 0 : 1);
478			WriteMacInt8(p + staModemStatus,
479			(status & TIOCM_DSR ? dsrEvent : 0)
480			\| (status & TIOCM_RI ? riEvent : 0)
481			\| (status & TIOCM_CD ? dcdEvent : 0)
482			\| (status & TIOCM_CTS ? ctsEvent : 0));
483			}
484			return noErr;
485			}
486
487			default:
488			printf("WARNING: SerialStatus(): unimplemented status code %d\n", code);
489			return statusErr;
490			}
491			}
492
493
494			/*
495			* Close serial port
496			*/
497
498	cebix	1.3	int16 XSERDPort::close()
499	cebix	1.1	{
500			// Kill threads
501			if (input_thread_active) {
502			quitting = true;
503			sem_post(&input_signal);
504			pthread_join(input_thread, NULL);
505			input_thread_active = false;
506			sem_destroy(&input_signal);
507			}
508			if (output_thread_active) {
509			quitting = true;
510			sem_post(&output_signal);
511			pthread_join(output_thread, NULL);
512			output_thread_active = false;
513			sem_destroy(&output_signal);
514			}
515
516			// Close port
517			if (fd > 0)
518	cebix	1.4	::close(fd);
519	cebix	1.1	fd = -1;
520			return noErr;
521			}
522
523
524			/*
525			* Configure serial port with MacOS config word
526			*/
527
528			bool XSERDPort::configure(uint16 config)
529			{
530			D(bug(" configure %04x\n", config));
531			if (is_parallel)
532			return true;
533
534			// Set number of stop bits
535			switch (config & 0xc000) {
536			case stop10:
537			mode.c_cflag &= ~CSTOPB;
538			break;
539			case stop20:
540			mode.c_cflag \|= CSTOPB;
541			break;
542			default:
543			return false;
544			}
545
546			// Set parity mode
547			switch (config & 0x3000) {
548			case noParity:
549			mode.c_iflag &= ~INPCK;
550			mode.c_oflag &= ~PARENB;
551			break;
552			case oddParity:
553			mode.c_iflag \|= INPCK;
554			mode.c_oflag \|= PARENB;
555			mode.c_oflag \|= PARODD;
556			break;
557			case evenParity:
558			mode.c_iflag \|= INPCK;
559			mode.c_oflag \|= PARENB;
560			mode.c_oflag &= ~PARODD;
561			break;
562			default:
563			return false;
564			}
565
566			// Set number of data bits
567			switch (config & 0x0c00) {
568			case data5:
569			mode.c_cflag = mode.c_cflag & ~CSIZE \| CS5;
570			break;
571			case data6:
572			mode.c_cflag = mode.c_cflag & ~CSIZE \| CS6;
573			break;
574			case data7:
575			mode.c_cflag = mode.c_cflag & ~CSIZE \| CS7;
576			break;
577			case data8:
578			mode.c_cflag = mode.c_cflag & ~CSIZE \| CS8;
579			break;
580			}
581
582			// Set baud rate
583			speed_t baud_rate;
584			switch (config & 0x03ff) {
585			case baud150: baud_rate = B150; break;
586			case baud300: baud_rate = B300; break;
587			case baud600: baud_rate = B600; break;
588			case baud1200: baud_rate = B1200; break;
589			case baud1800: baud_rate = B1800; break;
590			case baud2400: baud_rate = B2400; break;
591			case baud4800: baud_rate = B4800; break;
592			case baud9600: baud_rate = B9600; break;
593			case baud19200: baud_rate = B19200; break;
594			case baud38400: baud_rate = B38400; break;
595			case baud57600: baud_rate = B57600; break;
596			default:
597			return false;
598			}
599			cfsetispeed(&mode, baud_rate);
600			cfsetospeed(&mode, baud_rate);
601			tcsetattr(fd, TCSANOW, &mode);
602			return true;
603			}
604
605
606			/*
607			* Set serial handshaking
608			*/
609
610			void XSERDPort::set_handshake(uint32 s, bool with_dtr)
611			{
612			D(bug(" set_handshake %02x %02x %02x %02x %02x %02x %02x %02x\n",
613			ReadMacInt8(s + 0), ReadMacInt8(s + 1), ReadMacInt8(s + 2), ReadMacInt8(s + 3),
614			ReadMacInt8(s + 4), ReadMacInt8(s + 5), ReadMacInt8(s + 6), ReadMacInt8(s + 7)));
615			if (is_parallel)
616			return;
617
618			if (with_dtr) {
619			if (ReadMacInt8(s + shkFCTS) \|\| ReadMacInt8(s + shkFDTR))
620			mode.c_cflag \|= CRTSCTS;
621			else
622			mode.c_cflag &= ~CRTSCTS;
623			} else {
624			if (ReadMacInt8(s + shkFCTS))
625			mode.c_cflag \|= CRTSCTS;
626			else
627			mode.c_cflag &= ~CRTSCTS;
628			}
629
630			D(bug(" %sware flow control\n", mode.c_cflag & CRTSCTS ? "hard" : "soft"));
631			tcsetattr(fd, TCSANOW, &mode);
632			}
633
634
635			/*
636			* Data input thread
637			*/
638
639			void XSERDPort::input_func(void arg)
640			{
641			XSERDPort s = (XSERDPort )arg;
642			while (!s->input_thread_cancel) {
643
644			// Wait for commands
645			sem_wait(&s->input_signal);
646			if (s->quitting)
647			break;
648
649			// Execute command
650			void *buf = Mac2HostAddr(ReadMacInt32(s->input_pb + ioBuffer));
651			uint32 length = ReadMacInt32(s->input_pb + ioReqCount);
652			D(bug("input_func waiting for %ld bytes of data...\n", length));
653			int32 actual = read(s->fd, buf, length);
654			D(bug(" %ld bytes received\n", actual));
655
656			#if MONITOR
657			bug("Receiving serial data:\n");
658			uint8 adr = (uint8 )buf;
659			for (int i=0; i<actual; i++) {
660			bug("%02x ", adr[i]);
661			}
662			bug("\n");
663			#endif
664
665			// KillIO called? Then simply return
666			if (s->io_killed) {
667
668	cebix	1.6	WriteMacInt16(s->input_pb + ioResult, uint16(abortErr));
669	cebix	1.1	WriteMacInt32(s->input_pb + ioActCount, 0);
670			s->read_pending = s->read_done = false;
671
672			} else {
673
674			// Set error code
675			if (actual >= 0) {
676			WriteMacInt32(s->input_pb + ioActCount, actual);
677			WriteMacInt32(s->input_dt + serdtResult, noErr);
678			} else {
679			WriteMacInt32(s->input_pb + ioActCount, 0);
680	cebix	1.6	WriteMacInt32(s->input_dt + serdtResult, uint16(readErr));
681	cebix	1.1	}
682
683			// Trigger serial interrupt
684			D(bug(" triggering serial interrupt\n"));
685			s->read_done = true;
686			SetInterruptFlag(INTFLAG_SERIAL);
687			TriggerInterrupt();
688			}
689			}
690			return NULL;
691			}
692
693
694			/*
695			* Data output thread
696			*/
697
698			void XSERDPort::output_func(void arg)
699			{
700			XSERDPort s = (XSERDPort )arg;
701			while (!s->output_thread_cancel) {
702
703			// Wait for commands
704			sem_wait(&s->output_signal);
705			if (s->quitting)
706			break;
707
708			// Execute command
709			void *buf = Mac2HostAddr(ReadMacInt32(s->output_pb + ioBuffer));
710			uint32 length = ReadMacInt32(s->output_pb + ioReqCount);
711			D(bug("output_func transmitting %ld bytes of data...\n", length));
712
713			#if MONITOR
714			bug("Sending serial data:\n");
715			uint8 adr = (uint8 )buf;
716			for (int i=0; i<length; i++) {
717			bug("%02x ", adr[i]);
718			}
719			bug("\n");
720			#endif
721
722			int32 actual = write(s->fd, buf, length);
723			D(bug(" %ld bytes transmitted\n", actual));
724
725			// KillIO called? Then simply return
726			if (s->io_killed) {
727
728	cebix	1.6	WriteMacInt16(s->output_pb + ioResult, uint16(abortErr));
729	cebix	1.1	WriteMacInt32(s->output_pb + ioActCount, 0);
730			s->write_pending = s->write_done = false;
731
732			} else {
733
734			// Set error code
735			if (actual >= 0) {
736			WriteMacInt32(s->output_pb + ioActCount, actual);
737			WriteMacInt32(s->output_dt + serdtResult, noErr);
738			} else {
739			WriteMacInt32(s->output_pb + ioActCount, 0);
740	cebix	1.6	WriteMacInt32(s->output_dt + serdtResult, uint16(writErr));
741	cebix	1.1	}
742
743			// Trigger serial interrupt
744			D(bug(" triggering serial interrupt\n"));
745			s->write_done = true;
746			SetInterruptFlag(INTFLAG_SERIAL);
747			TriggerInterrupt();
748			}
749			}
750			return NULL;
751			}