/*****************************************************************************/
/*
* baycom.c -- baycom ser12 and par96 radio modem driver.
*
* Copyright (C) 1996 Thomas Sailer (sailer@ife.ee.ethz.ch)
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Please note that the GPL allows you to use the driver, NOT the radio.
* In order to use the radio, you need a license from the communications
* authority of your country.
*
*
* Supported modems
*
* ser12: This is a very simple 1200 baud AFSK modem. The modem consists only
* of a modulator/demodulator chip, usually a TI TCM3105. The computer
* is responsible for regenerating the receiver bit clock, as well as
* for handling the HDLC protocol. The modem connects to a serial port,
* hence the name. Since the serial port is not used as an async serial
* port, the kernel driver for serial ports cannot be used, and this
* driver only supports standard serial hardware (8250, 16450, 16550)
*
* par96: This is a modem for 9600 baud FSK compatible to the G3RUH standard.
* The modem does all the filtering and regenerates the receiver clock.
* Data is transferred from and to the PC via a shift register.
* The shift register is filled with 16 bits and an interrupt is
* signalled. The PC then empties the shift register in a burst. This
* modem connects to the parallel port, hence the name. The modem
* leaves the implementation of the HDLC protocol and the scrambler
* polynomial to the PC.
*
* par97: This is a redesign of the par96 modem by Henning Rech, DF9IC. The
* modem is protocol compatible to par96, but uses only three low
* power ICs and can therefore be fed from the parallel port and
* does not require an additional power supply.
*
*
* Command line options (insmod command line)
*
* major major number the driver should use; default 60
* modem modem type of the first channel (minor 0); 1=ser12,
* 2=par96/par97, any other value invalid
* iobase base address of the port; common values are for ser12 0x3f8,
* 0x2f8, 0x3e8, 0x2e8 and for par96/par97 0x378, 0x278, 0x3bc
* irq interrupt line of the port; common values are for ser12 3,4
* and for par96/par97 7
* options 0=use hardware DCD, 1=use software DCD
*
*
* History:
* 0.1 03.05.96 Renamed from ser12 0.5 and added support for par96
* Various resource allocation cleanups
* 0.2 12.05.96 Changed major to allocated 51. Integrated into kernel
* source tree
* 0.3 04.06.96 Major bug fixed (forgot to wake up after write) which
* interestingly manifested only with kernel ax25
* (the slip line discipline)
* introduced bottom half and tq_baycom
* HDLC processing now done with interrupts on
*/
/*****************************************************************************/
#include <linux/module.h>
#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <asm/segment.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/malloc.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/interrupt.h>
#include <linux/tqueue.h>
#include <linux/baycom.h>
/* --------------------------------------------------------------------- */
#define BAYCOM_TYPE_NORMAL 0 /* not used */
#define TTY_DRIVER_TYPE_BAYCOM 6
/*
* ser12 options:
* BAYCOM_OPTIONS_SOFTDCD: if undefined, you must use the transmitters
* hardware carrier detect circuitry, the driver will report DCD as soon as
* there are transitions on the input line. Advantage: lower interrupt load
* on the system. Disadvantage: slower, since hardware carrier detect
* circuitry is usually slow.
*/
#define BUFLEN_RX 8192
#define BUFLEN_TX 8192
#define NR_PORTS 4
#define KISS_VERBOSE
#define BAYCOM_MAGIC 0x3105bac0
/* --------------------------------------------------------------------- */
/*
* user settable parameters (from the command line)
*/
#ifndef MODULE
static
#endif /* MODULE */
int major = BAYCOM_MAJOR;
/* --------------------------------------------------------------------- */
static struct tty_struct *baycom_table[NR_PORTS];
static struct termios *baycom_termios[NR_PORTS];
static struct termios *baycom_termios_locked[NR_PORTS];
static int baycom_refcount;
static struct tty_driver baycom_driver;
static struct {
int modem, iobase, irq, options;
} baycom_ports[NR_PORTS] = { { BAYCOM_MODEM_INVALID, 0, 0, 0, }, };
/* --------------------------------------------------------------------- */
#define RBR(iobase) (iobase+0)
#define THR(iobase) (iobase+0)
#define IER(iobase) (iobase+1)
#define IIR(iobase) (iobase+2)
#define FCR(iobase) (iobase+2)
#define LCR(iobase) (iobase+3)
#define MCR(iobase) (iobase+4)
#define LSR(iobase) (iobase+5)
#define MSR(iobase) (iobase+6)
#define SCR(iobase) (iobase+7)
#define DLL(iobase) (iobase+0)
#define DLM(iobase) (iobase+1)
#define SER12_EXTENT 8
#define LPT_DATA(iobase) (iobase+0)
#define LPT_STATUS(iobase) (iobase+1)
#define LPT_CONTROL(iobase) (iobase+2)
#define LPT_IRQ_ENABLE 0x10
#define PAR96_BURSTBITS 16
#define PAR96_BURST 4
#define PAR96_PTT 2
#define PAR96_TXBIT 1
#define PAR96_ACK 0x40
#define PAR96_RXBIT 0x20
#define PAR96_DCD 0x10
#define PAR97_POWER 0xf8
#define PAR96_EXTENT 3
/* ---------------------------------------------------------------------- */
struct access_params {
int tx_delay;
int tx_tail;
int slottime;
int ppersist;
int fulldup;
};
struct hdlc_state_rx {
int rx_state; /* 0 = sync hunt, != 0 receiving */
unsigned int bitstream;
unsigned int bitbuf;
int numbits;
unsigned int shreg1, shreg2;
int len;
unsigned char *bp;
unsigned char buffer[BAYCOM_MAXFLEN+2]; /* make room for CRC */
};
struct hdlc_state_tx {
/*
* 0 = send flags
* 1 = send txtail (flags)
* 2 = send packet
*/
int tx_state;
int numflags;
unsigned int bitstream;
unsigned int current_byte;
unsigned char ptt;
unsigned int bitbuf;
int numbits;
unsigned int shreg1, shreg2;
int len;
unsigned char *bp;
unsigned char buffer[BAYCOM_MAXFLEN+2]; /* make room for CRC */
};
struct modem_state_ser12 {
unsigned char last_sample;
unsigned char interm_sample;
unsigned int bit_pll;
unsigned int dcd_shreg;
int dcd_sum0, dcd_sum1, dcd_sum2;
unsigned int dcd_time;
unsigned char last_rxbit;
unsigned char tx_bit;
};
struct modem_state_par96 {
int dcd_count;
unsigned int dcd_shreg;
unsigned long descram;
unsigned long scram;
};
struct modem_state {
unsigned char dcd;
short arb_divider;
unsigned char flags;
struct modem_state_ser12 ser12;
struct modem_state_par96 par96;
};
struct packet_buffer {
unsigned int rd;
unsigned int wr;
unsigned int buflen;
unsigned char *buffer;
};
struct packet_hdr {
unsigned int next;
unsigned int len;
/* packet following */
};
#ifdef BAYCOM_DEBUG
struct bit_buffer {
unsigned int rd;
unsigned int wr;
unsigned int shreg;
unsigned char buffer[64];
};
struct debug_vals {
unsigned long last_jiffies;
unsigned cur_intcnt;
unsigned last_intcnt;
int cur_pllcorr;
int last_pllcorr;
};
#endif /* BAYCOM_DEBUG */
struct kiss_decode {
unsigned char dec_state; /* 0 = hunt FEND */
unsigned char escaped;
unsigned char pkt_buf[BAYCOM_MAXFLEN+1];
unsigned int wr;
};
/* ---------------------------------------------------------------------- */
struct baycom_state {
int magic;
unsigned char modem_type;
unsigned int iobase;
unsigned int irq;
unsigned int options;
int opened;
struct tty_struct *tty;
#ifdef BAYCOM_USE_BH
struct tq_struct tq_receiver, tq_transmitter, tq_arbitrate;
#endif /* BAYCOM_USE_BH */
struct packet_buffer rx_buf;
struct packet_buffer tx_buf;
struct access_params ch_params;
struct hdlc_state_rx hdlc_rx;
struct hdlc_state_tx hdlc_tx;
int calibrate;
struct modem_state modem;
#ifdef BAYCOM_DEBUG
struct bit_buffer bitbuf_channel;
struct bit_buffer bitbuf_hdlc;
struct debug_vals debug_vals;
#endif /* BAYCOM_DEBUG */
struct kiss_decode kiss_decode;
struct baycom_statistics stat;
};
/* --------------------------------------------------------------------- */
struct baycom_state baycom_state[NR_PORTS];
#ifdef BAYCOM_USE_BH
DECLARE_TASK_QUEUE(tq_baycom);
#endif /* BAYCOM_USE_BH */
/* --------------------------------------------------------------------- */
/*
* the CRC routines are stolen from WAMPES
* by Dieter Deyke
*/
static const unsigned short crc_ccitt_table[] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
/*---------------------------------------------------------------------------*/
static inline void append_crc_ccitt(unsigned char *buffer, int len)
{
unsigned int crc = 0xffff;
for (;len>0;len--)
crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buffer++) & 0xff];
crc ^= 0xffff;
*buffer++ = crc;
*buffer++ = crc >> 8;
}
/*---------------------------------------------------------------------------*/
static inline int check_crc_ccitt(const unsigned char *buf,int cnt)
{
unsigned int crc = 0xffff;
for (; cnt > 0; cnt--)
crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
return (crc & 0xffff) == 0xf0b8;
}
/*---------------------------------------------------------------------------*/
#if 0
static int calc_crc_ccitt(const unsigned char *buf,int cnt)
{
unsigned int crc = 0xffff;
for (; cnt > 0; cnt--)
crc = (crc >> 8) ^ crc_ccitt_table[(crc ^ *buf++) & 0xff];
crc ^= 0xffff;
return (crc & 0xffff);
}
#endif
/* ---------------------------------------------------------------------- */
static int store_packet(struct packet_buffer *buf, unsigned char *data,
char from_user, unsigned int len)
{
unsigned int free;
struct packet_hdr *hdr;
unsigned int needed = sizeof(struct packet_hdr)+len;
free = buf->rd-buf->wr;
if(buf->rd <= buf->wr) {
free = buf->buflen - buf->wr;
if((free < needed) && (buf->rd >= needed)) {
hdr = (struct packet_hdr *)(buf->buffer+buf->wr);
hdr->next = 0;
hdr->len = 0;
buf->wr = 0;
free = buf->rd;
}
}
if(free < needed) return 0; /* buffer overrun */
hdr = (struct packet_hdr *)(buf->buffer+buf->wr);
if (from_user)
memcpy_fromfs(hdr+1,data,len);
else
memcpy(hdr+1,data,len);
hdr->len = len;
hdr->next = buf->wr+needed;
if (hdr->next + sizeof(struct packet_hdr) >= buf->buflen)
hdr->next = 0;
buf->wr = hdr->next;
return 1;
}
/* ---------------------------------------------------------------------- */
static void get_packet(struct packet_buffer *buf, unsigned char **data,
unsigned int *len)
{
struct packet_hdr *hdr;
*data = NULL;
*len = 0;
if (buf->rd == buf->wr)
return;
hdr = (struct packet_hdr *)(buf->buffer+buf->rd);
while (!(hdr->len)) {
buf->rd = hdr->next;
if (buf->rd == buf->wr)
return;
hdr = (struct packet_hdr *)(buf->buffer+buf->rd);
}
*data = (unsigned char *)(hdr+1);
*len = hdr->len;
}
/* ---------------------------------------------------------------------- */
static void ack_packet(struct packet_buffer *buf)
{
struct packet_hdr *hdr;
if (buf->rd == buf->wr)
return;
hdr = (struct packet_hdr *)(buf->buffer+buf->rd);
buf->rd = hdr->next;
}
/* ---------------------------------------------------------------------- */
static int store_kiss_packet(struct packet_buffer *buf, unsigned char *data,
unsigned int len)
{
unsigned char *bp = data;
int ln = len;
/*
* variables of buf
*/
unsigned int rd;
unsigned int wr;
unsigned int buflen;
unsigned char *buffer;
if (!len || !data || !buf)
return 0;
buflen = buf->buflen;
rd = buf->rd;
wr = buf->wr;
buffer = buf->buffer;
#define ADD_CHAR(c) {\
buffer[wr++] = c;\
if (wr >= buflen) wr = 0;\
if (wr == rd) return 0;\
}
#define ADD_KISSCHAR(c) {\
if (((c) & 0xff) == KISS_FEND) {\
ADD_CHAR(KISS_FESC);\
ADD_CHAR(KISS_TFEND);\
} else if (((c) & 0xff) == KISS_FESC) {\
ADD_CHAR(KISS_FESC);\
ADD_CHAR(KISS_TFESC);\
} else {\
ADD_CHAR(c);\
}\
}
ADD_CHAR(KISS_FEND);
ADD_KISSCHAR(KISS_CMD_DATA);
for(; ln > 0; ln--,bp++) {
ADD_KISSCHAR(*bp);
}
ADD_CHAR(KISS_FEND);
buf->wr = wr;
#undef ADD_CHAR
#undef ADD_KISSCHAR
return 1;
}
/* ---------------------------------------------------------------------- */
#ifdef BAYCOM_DEBUG
static inline void add_bitbuffer(struct bit_buffer * buf, unsigned int bit)
{
unsigned char new;
if (!buf) return;
new = buf->shreg & 1;
buf->shreg >>= 1;
if (bit)
buf->shreg |= 0x80;
if (new) {
buf->buffer[buf->wr] = buf->shreg;
buf->wr = (buf->wr+1) % sizeof(buf->buffer);
buf->shreg = 0x80;
}
}
static inline void add_bitbuffer_word(struct bit_buffer * buf,
unsigned int bits)
{
buf->buffer[buf->wr] = bits & 0xff;
buf->wr = (buf->wr+1) % sizeof(buf->buffer);
buf->buffer[buf->wr] = (bits >> 8) & 0xff;
buf->wr = (buf->wr+1) % sizeof(buf->buffer);
}
#endif /* BAYCOM_DEBUG */
/* ---------------------------------------------------------------------- */
static inline unsigned int tenms_to_2flags(struct baycom_state *bc,
unsigned int tenms)
{
switch (bc->modem_type) {
case BAYCOM_MODEM_SER12:
return tenms * 3 / 4;
case BAYCOM_MODEM_PAR96:
return tenms * 6;
default:
return 0;
}
}
/* ---------------------------------------------------------------------- */
/*
* The HDLC routines
*/
static inline int hdlc_rx_add_bytes(struct baycom_state *bc,
unsigned int bits, int num)
{
int added = 0;
while (bc->hdlc_rx.rx_state && num >= 8) {
if (bc->hdlc_rx.len >= sizeof(bc->hdlc_rx.buffer)) {
bc->hdlc_rx.rx_state = 0;
return 0;
}
*bc->hdlc_rx.bp++ = bits >> (32-num);
bc->hdlc_rx.len++;
num -= 8;
added += 8;
}
return added;
}
static inline void hdlc_rx_flag(struct baycom_state *bc)
{
if (bc->hdlc_rx.len < 4)
return;
if (!check_crc_ccitt(bc->hdlc_rx.buffer, bc->hdlc_rx.len))
return;
bc->stat.rx_packets++;
if (!store_kiss_packet(&bc->rx_buf,
bc->hdlc_rx.buffer,
bc->hdlc_rx.len-2))
bc->stat.rx_bufferoverrun++;
}
static void hdlc_rx_word(struct baycom_state *bc, unsigned int word)
{
int i;
unsigned int mask1, mask2, mask3, mask4, mask5, mask6;
if (!bc) return;
word &= 0xffff;
#ifdef BAYCOM_DEBUG
add_bitbuffer_word(&bc->bitbuf_hdlc, word);
#endif /* BAYCOM_DEBUG */
bc->hdlc_rx.bitstream >>= 16;
bc->hdlc_rx.bitstream |= word << 16;
bc->hdlc_rx.bitbuf >>= 16;
bc->hdlc_rx.bitbuf |= word << 16;
bc->hdlc_rx.numbits += 16;
for(i = 15, mask1 = 0x1fc00, mask2 = 0x1fe00, mask3 = 0x0fc00,
mask4 = 0x1f800, mask5 = 0xf800, mask6 = 0xffff;
i >= 0;
i--, mask1 <<= 1, mask2 <<= 1, mask3 <<= 1, mask4 <<= 1,
mask5 <<= 1, mask6 = (mask6 << 1) | 1) {
if ((bc->hdlc_rx.bitstream & mask1) == mask1)
bc->hdlc_rx.rx_state = 0; /* abort received */
else if ((bc->hdlc_rx.bitstream & mask2) == mask3) {
/* flag received */
if (bc->hdlc_rx.rx_state) {
hdlc_rx_add_bytes(bc, bc->hdlc_rx.bitbuf <<
(8 + i), bc->hdlc_rx.numbits
- 8 - i);
hdlc_rx_flag(bc);
}
bc->hdlc_rx.len = 0;
bc->hdlc_rx.bp = bc->hdlc_rx.buffer;
bc->hdlc_rx.rx_state = 1;
bc->hdlc_rx.numbits = i;
} else if ((bc->hdlc_rx.bitstream & mask4) == mask5) {
/* stuffed bit */
bc->hdlc_rx.numbits--;
bc->hdlc_rx.bitbuf = (bc->hdlc_rx.bitbuf & (~mask6)) |
((bc->hdlc_rx.bitbuf & mask6) << 1);
}
}
bc->hdlc_rx.numbits -= hdlc_rx_add_bytes(bc, bc->hdlc_rx.bitbuf,
bc->hdlc_rx.numbits);
}
/* ---------------------------------------------------------------------- */
static unsigned int hdlc_tx_word(struct baycom_state *bc)
{
unsigned int mask1, mask2, mask3;
int i;
if (!bc || !bc->hdlc_tx.ptt)
return 0;
for (;;) {
if (bc->hdlc_tx.numbits >= 16) {
unsigned int ret = bc->hdlc_tx.bitbuf & 0xffff;
bc->hdlc_tx.bitbuf >>= 16;
bc->hdlc_tx.numbits -= 16;
return ret;
}
switch (bc->hdlc_tx.tx_state) {
default:
bc->hdlc_tx.ptt = 0;
bc->hdlc_tx.tx_state = 0;
return 0;
case 0:
case 1:
if (bc->hdlc_tx.numflags) {
bc->hdlc_tx.numflags--;
bc->hdlc_tx.bitbuf |=
0x7e7e << bc->hdlc_tx.numbits;
bc->hdlc_tx.numbits += 16;
break;
}
if (bc->hdlc_tx.tx_state == 1) {
bc->hdlc_tx.ptt = 0;
return 0;
}
get_packet(&bc->tx_buf, &bc->hdlc_tx.bp,
&bc->hdlc_tx.len);
if (!bc->hdlc_tx.bp || !bc->hdlc_tx.len) {
bc->hdlc_tx.tx_state = 1;
bc->hdlc_tx.numflags = tenms_to_2flags
(bc, bc->ch_params.tx_tail);
break;
}
if (bc->hdlc_tx.len >= BAYCOM_MAXFLEN) {
bc->hdlc_tx.tx_state = 0;
bc->hdlc_tx.numflags = 1;
ack_packet(&bc->tx_buf);
break;
}
memcpy(bc->hdlc_tx.buffer, bc->hdlc_tx.bp,
bc->hdlc_tx.len);
ack_packet(&bc->tx_buf);
bc->hdlc_tx.bp = bc->hdlc_tx.buffer;
append_crc_ccitt(bc->hdlc_tx.buffer, bc->hdlc_tx.len);
/* the appended CRC */
bc->hdlc_tx.len += 2;
bc->hdlc_tx.tx_state = 2;
bc->hdlc_tx.bitstream = 0;
bc->stat.tx_packets++;
break;
case 2:
if (!bc->hdlc_tx.len) {
bc->hdlc_tx.tx_state = 0;
bc->hdlc_tx.numflags = 1;
break;
}
bc->hdlc_tx.len--;
bc->hdlc_tx.bitbuf |= *bc->hdlc_tx.bp <<
bc->hdlc_tx.numbits;
bc->hdlc_tx.bitstream >>= 8;
bc->hdlc_tx.bitstream |= (*bc->hdlc_tx.bp++) << 16;
mask1 = 0x1f000;
mask2 = 0x10000;
mask3 = 0xffffffff >> (31-bc->hdlc_tx.numbits);
bc->hdlc_tx.numbits += 8;
for(i = 0; i < 8; i++, mask1 <<= 1, mask2 <<= 1,
mask3 = (mask3 << 1) | 1) {
if ((bc->hdlc_tx.bitstream & mask1) != mask1)
continue;
bc->hdlc_tx.bitstream &= ~mask2;
bc->hdlc_tx.bitbuf =
(bc->hdlc_tx.bitbuf & mask3) |
((bc->hdlc_tx.bitbuf &
(~mask3)) << 1);
bc->hdlc_tx.numbits++;
mask3 = (mask3 << 1) | 1;
}
break;
}
}
}
/* ---------------------------------------------------------------------- */
static unsigned short random_seed;
static inline unsigned short random_num(void)
{
random_seed = 28629 * random_seed + 157;
return random_seed;
}
/* ---------------------------------------------------------------------- */
static inline void tx_arbitrate(struct baycom_state *bc)
{
unsigned char *bp;
unsigned int len;
if (!bc || bc->hdlc_tx.ptt || bc->modem.dcd)
return;
get_packet(&bc->tx_buf, &bp, &len);
if (!bp || !len)
return;
if (!bc->ch_params.fulldup) {
if ((random_num() % 256) > bc->ch_params.ppersist)
return;
}
bc->hdlc_tx.tx_state = 0;
bc->hdlc_tx.numflags = tenms_to_2flags(bc, bc->ch_params.tx_delay);
bc->hdlc_tx.numbits = bc->hdlc_tx.bitbuf = bc->hdlc_tx.bitstream = 0;
bc->hdlc_tx.ptt = 1;
bc->stat.ptt_keyed++;
}
/* --------------------------------------------------------------------- */
#ifdef BAYCOM_DEBUG
static void inline baycom_int_freq(struct baycom_state *bc)
{
unsigned long cur_jiffies = jiffies;
/*
* measure the interrupt frequency
*/
bc->debug_vals.cur_intcnt++;
if ((cur_jiffies - bc->debug_vals.last_jiffies) >= HZ) {
bc->debug_vals.last_jiffies = cur_jiffies;
bc->debug_vals.last_intcnt = bc->debug_vals.cur_intcnt;
bc->debug_vals.cur_intcnt = 0;
bc->debug_vals.last_pllcorr = bc->debug_vals.cur_pllcorr;
bc->debug_vals.cur_pllcorr = 0;
}
}
#endif /* BAYCOM_DEBUG */
/* --------------------------------------------------------------------- */
static inline void rx_chars_to_flip(struct baycom_state *bc)
{
int flip_free;
unsigned int cnt;
unsigned int new_rd;
unsigned long flags;
if ((!bc) || (!bc->tty) || (bc->tty->flip.count >= TTY_FLIPBUF_SIZE) ||
(bc->rx_buf.rd == bc->rx_buf.wr) ||
(!bc->tty->flip.char_buf_ptr) ||
(!bc->tty->flip.flag_buf_ptr))
return;
for(;;) {
flip_free = TTY_FLIPBUF_SIZE - bc->tty->flip.count;
if (bc->rx_buf.rd <= bc->rx_buf.wr)
cnt = bc->rx_buf.wr - bc->rx_buf.rd;
else
cnt = bc->rx_buf.buflen - bc->rx_buf.rd;
if ((flip_free <= 0) || (!cnt)) {
tty_schedule_flip(bc->tty);
return;
}
if (cnt > flip_free)
cnt = flip_free;
save_flags(flags); cli();
memcpy(bc->tty->flip.char_buf_ptr, bc->rx_buf.buffer+bc->rx_buf.rd, cnt);
memset(bc->tty->flip.flag_buf_ptr, TTY_NORMAL, cnt);
bc->tty->flip.count += cnt;
bc->tty->flip.char_buf_ptr += cnt;
bc->tty->flip.flag_buf_ptr += cnt;
restore_flags(flags);
new_rd = bc->rx_buf.rd+cnt;
if (new_rd >= bc->rx_buf.buflen)
new_rd -= bc->rx_buf.buflen;
bc->rx_buf.rd = new_rd;
}
}
/* --------------------------------------------------------------------- */
/*
* ===================== SER12 specific routines =========================
*/
static void inline ser12_set_divisor(struct baycom_state *bc,
unsigned char divisor)
{
outb(0x81, LCR(bc->iobase)); /* DLAB = 1 */
outb(divisor, DLL(bc->iobase));
outb(0, DLM(bc->iobase));
outb(0x01, LCR(bc->iobase)); /* word length = 6 */
}
/* --------------------------------------------------------------------- */
/*
* must call the TX arbitrator every 10ms
*/
#define SER12_ARB_DIVIDER(bc) ((bc->options & BAYCOM_OPTIONS_SOFTDCD) ? \
36 : 24)
#define SER12_DCD_INTERVAL(bc) ((bc->options & BAYCOM_OPTIONS_SOFTDCD) ? \
240 : 12)
static void baycom_ser12_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct baycom_state *bc = (struct baycom_state *)dev_id;
unsigned char cur_s;
if (!bc || bc->magic != BAYCOM_MAGIC)
return;
/*
* make sure the next interrupt is generated;
* 0 must be used to power the modem; the modem draws its
* power from the TxD line
*/
outb(0x00, THR(bc->iobase));
rx_chars_to_flip(bc);
#ifdef BAYCOM_DEBUG
baycom_int_freq(bc);
#endif /* BAYCOM_DEBUG */
/*
* check if transmitter active
*/
if (bc->hdlc_tx.ptt || bc->calibrate > 0) {
ser12_set_divisor(bc, 12); /* one interrupt per channel bit */
/*
* first output the last bit (!) then call HDLC transmitter,
* since this may take quite long
*/
outb(0x0e | (bc->modem.ser12.tx_bit ? 1 : 0), MCR(bc->iobase));
if (bc->hdlc_tx.shreg1 <= 1) {
if (bc->calibrate > 0) {
bc->hdlc_tx.shreg1 = 0x10000;
bc->calibrate--;
} else {
#ifdef BAYCOM_USE_BH
bc->hdlc_tx.shreg1 = bc->hdlc_tx.shreg2;
bc->hdlc_tx.shreg2 = 0;
queue_task_irq_off(&bc->tq_transmitter,
&tq_baycom);
mark_bh(BAYCOM_BH);
#ifdef HDLC_LOOPBACK
bc->hdlc_rx.shreg2 = bc->hdlc_tx.shreg1;
queue_task_irq_off(&bc->tq_receiver,
&tq_baycom);
#endif /* HDLC_LOOPBACK */
#else /* BAYCOM_USE_BH */
bc->hdlc_tx.shreg1 = hdlc_tx_word(bc)
| 0x10000;
#ifdef HDLC_LOOPBACK
hdlc_rx_word(bc, bc->hdlc_tx.shreg1);
#endif /* HDLC_LOOPBACK */
#endif /* BAYCOM_USE_BH */
}
}
if (!(bc->hdlc_tx.shreg1 & 1))
bc->modem.ser12.tx_bit = !bc->modem.ser12.tx_bit;
bc->hdlc_tx.shreg1 >>= 1;
return;
}
/*
* do demodulator
*/
outb(0x0d, MCR(bc->iobase)); /* transmitter off */
cur_s = inb(MSR(bc->iobase)) & 0x10; /* the CTS line */
#ifdef BAYCOM_DEBUG
add_bitbuffer(&bc->bitbuf_channel, cur_s);
#endif /* BAYCOM_DEBUG */
bc->modem.ser12.dcd_shreg <<= 1;
if(cur_s != bc->modem.ser12.last_sample) {
bc->modem.ser12.dcd_shreg |= 1;
if (bc->options & BAYCOM_OPTIONS_SOFTDCD) {
unsigned int dcdspos, dcdsneg;
dcdspos = dcdsneg = 0;
dcdspos += ((bc->modem.ser12.dcd_shreg >> 1) & 1);
if (!(bc->modem.ser12.dcd_shreg & 0x7ffffffe))
dcdspos += 2;
dcdsneg += ((bc->modem.ser12.dcd_shreg >> 2) & 1);
dcdsneg += ((bc->modem.ser12.dcd_shreg >> 3) & 1);
dcdsneg += ((bc->modem.ser12.dcd_shreg >> 4) & 1);
bc->modem.ser12.dcd_sum0 += 16*dcdspos - dcdsneg;
} else
bc->modem.ser12.dcd_sum0--;
}
bc->modem.ser12.last_sample = cur_s;
if(!bc->modem.ser12.dcd_time) {
bc->modem.dcd = (bc->modem.ser12.dcd_sum0 +
bc->modem.ser12.dcd_sum1 +
bc->modem.ser12.dcd_sum2) < 0;
bc->modem.ser12.dcd_sum2 = bc->modem.ser12.dcd_sum1;
bc->modem.ser12.dcd_sum1 = bc->modem.ser12.dcd_sum0;
/* offset to ensure DCD off on silent input */
bc->modem.ser12.dcd_sum0 = 2;
bc->modem.ser12.dcd_time = SER12_DCD_INTERVAL(bc);
}
bc->modem.ser12.dcd_time--;
if (bc->options & BAYCOM_OPTIONS_SOFTDCD) {
/*
* PLL code for the improved software DCD algorithm
*/
if (bc->modem.ser12.interm_sample) {
/*
* intermediate sample; set timing correction to normal
*/
ser12_set_divisor(bc, 4);
} else {
/*
* do PLL correction and call HDLC receiver
*/
switch (bc->modem.ser12.dcd_shreg & 7) {
case 1: /* transition too late */
ser12_set_divisor(bc, 5);
#ifdef BAYCOM_DEBUG
bc->debug_vals.cur_pllcorr++;
#endif /* BAYCOM_DEBUG */
break;
case 4: /* transition too early */
ser12_set_divisor(bc, 3);
#ifdef BAYCOM_DEBUG
bc->debug_vals.cur_pllcorr--;
#endif /* BAYCOM_DEBUG */
break;
default:
ser12_set_divisor(bc, 4);
break;
}
bc->hdlc_rx.shreg1 >>= 1;
if (bc->modem.ser12.last_sample ==
bc->modem.ser12.last_rxbit)
bc->hdlc_rx.shreg1 |= 0x10000;
bc->modem.ser12.last_rxbit =
bc->modem.ser12.last_sample;
}
if (++bc->modem.ser12.interm_sample >= 3)
bc->modem.ser12.interm_sample = 0;
} else {
/*
* PLL algorithm for the hardware squelch DCD algorithm
*/
if (bc->modem.ser12.interm_sample) {
/*
* intermediate sample; set timing correction to normal
*/
ser12_set_divisor(bc, 6);
} else {
/*
* do PLL correction and call HDLC receiver
*/
switch (bc->modem.ser12.dcd_shreg & 3) {
case 1: /* transition too late */
ser12_set_divisor(bc, 7);
#ifdef BAYCOM_DEBUG
bc->debug_vals.cur_pllcorr++;
#endif /* BAYCOM_DEBUG */
break;
case 2: /* transition too early */
ser12_set_divisor(bc, 5);
#ifdef BAYCOM_DEBUG
bc->debug_vals.cur_pllcorr--;
#endif /* BAYCOM_DEBUG */
break;
default:
ser12_set_divisor(bc, 6);
break;
}
bc->hdlc_rx.shreg1 >>= 1;
if (bc->modem.ser12.last_sample ==
bc->modem.ser12.last_rxbit)
bc->hdlc_rx.shreg1 |= 0x10000;
bc->modem.ser12.last_rxbit =
bc->modem.ser12.last_sample;
}
bc->modem.ser12.interm_sample = !bc->modem.ser12.interm_sample;
}
if (bc->hdlc_rx.shreg1 & 1) {
#ifdef BAYCOM_USE_BH
bc->hdlc_rx.shreg2 = (bc->hdlc_rx.shreg1 >> 1) | 0x10000;
queue_task_irq_off(&bc->tq_receiver, &tq_baycom);
mark_bh(BAYCOM_BH);
#else /* BAYCOM_USE_BH */
hdlc_rx_word(bc, bc->hdlc_rx.shreg1 >> 1);
#endif /* BAYCOM_USE_BH */
bc->hdlc_rx.shreg1 = 0x10000;
}
if (--bc->modem.arb_divider <= 0) {
#ifdef BAYCOM_USE_BH
queue_task_irq_off(&bc->tq_arbitrate, &tq_baycom);
mark_bh(BAYCOM_BH);
#else /* BAYCOM_USE_BH */
tx_arbitrate(bc);
#endif /* BAYCOM_USE_BH */
bc->modem.arb_divider = bc->ch_params.slottime *
SER12_ARB_DIVIDER(bc);
}
}
/* --------------------------------------------------------------------- */
enum uart { c_uart_unknown, c_uart_8250,
c_uart_16450, c_uart_16550, c_uart_16550A};
static const char *uart_str[] =
{ "unknown", "8250", "16450", "16550", "16550A" };
static enum uart ser12_check_uart(unsigned int iobase)
{
unsigned char b1,b2,b3;
enum uart u;
enum uart uart_tab[] =
{ c_uart_16450, c_uart_unknown, c_uart_16550, c_uart_16550A };
b1 = inb(MCR(iobase));
outb(b1 | 0x10, MCR(iobase)); /* loopback mode */
b2 = inb(MSR(iobase));
outb(0x1a, MCR(iobase));
b3 = inb(MSR(iobase)) & 0xf0;
outb(b1, MCR(iobase)); /* restore old values */
outb(b2, MSR(iobase));
if (b3 != 0x90)
return c_uart_unknown;
inb(RBR(iobase));
inb(RBR(iobase));
outb(0x01, FCR(iobase)); /* enable FIFOs */
u = uart_tab[(inb(IIR(iobase)) >> 6) & 3];
if (u == c_uart_16450) {
outb(0x5a, SCR(iobase));
b1 = inb(SCR(iobase));
outb(0xa5, SCR(iobase));
b2 = inb(SCR(iobase));
if ((b1 != 0x5a) || (b2 != 0xa5))
u = c_uart_8250;
}
return u;
}
/* --------------------------------------------------------------------- */
static int ser12_allocate_resources(unsigned int iobase, unsigned int irq,
unsigned int options)
{
enum uart u;
if (!iobase || iobase > 0xfff || irq < 2 || irq > 15)
return -ENXIO;
if (check_region(iobase, SER12_EXTENT))
return -EACCES;
if ((u = ser12_check_uart(iobase)) == c_uart_unknown)
return -EIO;
request_region(iobase, SER12_EXTENT, "baycom_ser12");
outb(0, FCR(iobase)); /* disable FIFOs */
outb(0x0d, MCR(iobase));
printk(KERN_INFO "baycom: ser12 at iobase 0x%x irq %u options 0x%x "
"uart %s\n", iobase, irq, options, uart_str[u]);
return 0;
}
/* --------------------------------------------------------------------- */
static void ser12_deallocate_resources(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_SER12)
return;
/*
* disable interrupts
*/
outb(0, IER(bc->iobase));
outb(1, MCR(bc->iobase));
/*
* this should prevent kernel: Trying to free IRQx
* messages
*/
if (bc->opened > 0)
free_irq(bc->irq, bc);
release_region(bc->iobase, SER12_EXTENT);
bc->modem_type = BAYCOM_MODEM_INVALID;
printk(KERN_INFO "baycom: release ser12 at iobase 0x%x irq %u\n",
bc->iobase, bc->irq);
bc->iobase = bc->irq = bc->options = 0;
}
/* --------------------------------------------------------------------- */
static int ser12_on_open(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_SER12)
return -ENXIO;
/*
* set the SIO to 6 Bits/character and 19200 or 28800 baud, so that
* we get exactly (hopefully) 2 or 3 interrupts per radio symbol,
* depending on the usage of the software DCD routine
*/
ser12_set_divisor(bc, (bc->options & BAYCOM_OPTIONS_SOFTDCD) ? 4 : 6);
outb(0x0d, MCR(bc->iobase));
outb(0, IER(bc->iobase));
if (request_irq(bc->irq, baycom_ser12_interrupt, SA_INTERRUPT,
"baycom_ser12", bc))
return -EBUSY;
/*
* enable transmitter empty interrupt
*/
outb(2, IER(bc->iobase));
/*
* the value here serves to power the modem
*/
outb(0x00, THR(bc->iobase));
return 0;
}
/* --------------------------------------------------------------------- */
static void ser12_on_close(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_SER12)
return;
/*
* disable interrupts
*/
outb(0, IER(bc->iobase));
outb(1, MCR(bc->iobase));
free_irq(bc->irq, bc);
}
/* --------------------------------------------------------------------- */
/*
* ===================== PAR96 specific routines =========================
*/
#define PAR96_DESCRAM_TAP1 0x20000
#define PAR96_DESCRAM_TAP2 0x01000
#define PAR96_DESCRAM_TAP3 0x00001
#define PAR96_DESCRAM_TAPSH1 17
#define PAR96_DESCRAM_TAPSH2 12
#define PAR96_DESCRAM_TAPSH3 0
#define PAR96_SCRAM_TAP1 0x20000 /* X^17 */
#define PAR96_SCRAM_TAPN 0x00021 /* X^0+X^5 */
/* --------------------------------------------------------------------- */
static void baycom_par96_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
register struct baycom_state *bc = (struct baycom_state *)dev_id;
int i;
unsigned int data, descx, mask, mask2;
if (!bc || bc->magic != BAYCOM_MAGIC)
return;
rx_chars_to_flip(bc);
#ifdef BAYCOM_DEBUG
baycom_int_freq(bc);
#endif /* BAYCOM_DEBUG */
/*
* check if transmitter active
*/
if (bc->hdlc_tx.ptt || bc->calibrate > 0) {
/*
* first output the last 16 bits (!) then call HDLC
* transmitter, since this may take quite long
* do the differential encoder and the scrambler on the fly
*/
data = bc->hdlc_tx.shreg1;
for(i = 0; i < PAR96_BURSTBITS; i++, data >>= 1) {
unsigned char val = PAR97_POWER;
bc->modem.par96.scram = ((bc->modem.par96.scram << 1) |
(bc->modem.par96.scram & 1));
if (!(data & 1))
bc->modem.par96.scram ^= 1;
if (bc->modem.par96.scram & (PAR96_SCRAM_TAP1 << 1))
bc->modem.par96.scram ^=
(PAR96_SCRAM_TAPN << 1);
if (bc->modem.par96.scram & (PAR96_SCRAM_TAP1 << 2))
val |= PAR96_TXBIT;
outb(val, LPT_DATA(bc->iobase));
outb(val | PAR96_BURST, LPT_DATA(bc->iobase));
}
if (bc->calibrate > 0) {
bc->hdlc_tx.shreg1 = 0x10000;
bc->calibrate--;
} else {
#ifdef BAYCOM_USE_BH
bc->hdlc_tx.shreg1 = bc->hdlc_tx.shreg2;
bc->hdlc_tx.shreg2 = 0;
queue_task_irq_off(&bc->tq_transmitter, &tq_baycom);
mark_bh(BAYCOM_BH);
#ifdef HDLC_LOOPBACK
bc->hdlc_rx.shreg2 = bc->hdlc_tx.shreg1;
queue_task_irq_off(&bc->tq_receiver, &tq_baycom);
#endif /* HDLC_LOOPBACK */
#else /* BAYCOM_USE_BH */
bc->hdlc_tx.shreg1 = hdlc_tx_word(bc);
#ifdef HDLC_LOOPBACK
hdlc_rx_word(bc, bc->hdlc_tx.shreg1);
#endif /* HDLC_LOOPBACK */
#endif /* BAYCOM_USE_BH */
}
return;
}
/*
* do receiver; differential decode and descramble on the fly
*/
for(data = i = 0; i < PAR96_BURSTBITS; i++) {
bc->modem.par96.descram = (bc->modem.par96.descram << 1);
if (inb(LPT_STATUS(bc->iobase)) & PAR96_RXBIT)
bc->modem.par96.descram |= 1;
descx = bc->modem.par96.descram ^
(bc->modem.par96.descram >> 1);
/* now the diff decoded data is inverted in descram */
outb(PAR97_POWER | PAR96_PTT, LPT_DATA(bc->iobase));
descx ^= ((descx >> PAR96_DESCRAM_TAPSH1) ^
(descx >> PAR96_DESCRAM_TAPSH2));
data >>= 1;
if (!(descx & 1))
data |= 0x8000;
outb(PAR97_POWER | PAR96_PTT | PAR96_BURST,
LPT_DATA(bc->iobase));
}
#ifdef BAYCOM_USE_BH
bc->hdlc_rx.shreg2 = bc->hdlc_rx.shreg1;
bc->hdlc_rx.shreg1 = data | 0x10000;
queue_task_irq_off(&bc->tq_receiver, &tq_baycom);
mark_bh(BAYCOM_BH);
#else /* BAYCOM_USE_BH */
hdlc_rx_word(bc, data);
#endif /* BAYCOM_USE_BH */
/*
* do DCD algorithm
*/
if (bc->options & BAYCOM_OPTIONS_SOFTDCD) {
bc->modem.par96.dcd_shreg = (bc->modem.par96.dcd_shreg >> 16)
| (data << 16);
/* search for flags and set the dcd counter appropriately */
for(mask = 0x1fe00, mask2 = 0xfc00, i = 0;
i < PAR96_BURSTBITS; i++, mask <<= 1, mask2 <<= 1)
if ((bc->modem.par96.dcd_shreg & mask) == mask2)
bc->modem.par96.dcd_count = BAYCOM_MAXFLEN+4;
/* check for abort/noise sequences */
for(mask = 0x1fe00, mask2 = 0x1fe00, i = 0;
i < PAR96_BURSTBITS; i++, mask <<= 1, mask2 <<= 1)
if (((bc->modem.par96.dcd_shreg & mask) == mask2) &&
(bc->modem.par96.dcd_count >= 0))
bc->modem.par96.dcd_count -= BAYCOM_MAXFLEN-10;
/* decrement and set the dcd variable */
if (bc->modem.par96.dcd_count >= 0)
bc->modem.par96.dcd_count -= 2;
bc->modem.dcd = bc->modem.par96.dcd_count > 0;
} else {
bc->modem.dcd = !!(inb(LPT_STATUS(bc->iobase))
& PAR96_DCD);
}
if (--bc->modem.arb_divider <= 0) {
#ifdef BAYCOM_USE_BH
queue_task_irq_off(&bc->tq_arbitrate, &tq_baycom);
mark_bh(BAYCOM_BH);
#else /* BAYCOM_USE_BH */
tx_arbitrate(bc);
#endif /* BAYCOM_USE_BH */
bc->modem.arb_divider = bc->ch_params.slottime * 6;
}
}
/* --------------------------------------------------------------------- */
static int par96_check_lpt(unsigned int iobase)
{
unsigned char b1,b2;
int i;
b1 = inb(LPT_DATA(iobase));
b2 = inb(LPT_CONTROL(iobase));
outb(0xaa, LPT_DATA(iobase));
i = inb(LPT_DATA(iobase)) == 0xaa;
outb(0x55, LPT_DATA(iobase));
i &= inb(LPT_DATA(iobase)) == 0x55;
outb(0x0a, LPT_CONTROL(iobase));
i &= (inb(LPT_CONTROL(iobase)) & 0xf) == 0x0a;
outb(0x05, LPT_CONTROL(iobase));
i &= (inb(LPT_CONTROL(iobase)) & 0xf) == 0x05;
outb(b1, LPT_DATA(iobase));
outb(b2, LPT_CONTROL(iobase));
return !i;
}
/* --------------------------------------------------------------------- */
static int par96_allocate_resources(unsigned int iobase, unsigned int irq,
unsigned int options)
{
if (!iobase || iobase > 0xfff || irq < 2 || irq > 15)
return -ENXIO;
if (check_region(iobase, PAR96_EXTENT))
return -EACCES;
if (par96_check_lpt(iobase))
return -EIO;
request_region(iobase, PAR96_EXTENT, "baycom_par96");
outb(0, LPT_CONTROL(iobase)); /* disable interrupt */
outb(PAR96_PTT | PAR97_POWER, LPT_DATA(iobase)); /* switch off PTT */
printk(KERN_INFO "baycom: par96 at iobase 0x%x irq %u options 0x%x\n",
iobase, irq, options);
return 0;
}
/* --------------------------------------------------------------------- */
static void par96_deallocate_resources(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_PAR96)
return;
outb(0, LPT_CONTROL(bc->iobase)); /* disable interrupt */
outb(PAR96_PTT, LPT_DATA(bc->iobase)); /* switch off PTT */
/*
* this should prevent kernel: Trying to free IRQx
* messages
*/
if (bc->opened > 0)
free_irq(bc->irq, bc);
release_region(bc->iobase, PAR96_EXTENT);
bc->modem_type = BAYCOM_MODEM_INVALID;
printk(KERN_INFO "baycom: release par96 at iobase 0x%x irq %u\n",
bc->iobase, bc->irq);
bc->iobase = bc->irq = bc->options = 0;
}
/* --------------------------------------------------------------------- */
static int par96_on_open(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_PAR96)
return -ENXIO;
outb(0, LPT_CONTROL(bc->iobase)); /* disable interrupt */
/* switch off PTT */
outb(PAR96_PTT | PAR97_POWER, LPT_DATA(bc->iobase));
if (request_irq(bc->irq, baycom_par96_interrupt, SA_INTERRUPT,
"baycom_par96", bc))
return -EBUSY;
outb(LPT_IRQ_ENABLE, LPT_CONTROL(bc->iobase)); /* enable interrupt */
return 0;
}
/* --------------------------------------------------------------------- */
static void par96_on_close(struct baycom_state *bc)
{
if (!bc || bc->modem_type != BAYCOM_MODEM_PAR96)
return;
outb(0, LPT_CONTROL(bc->iobase)); /* disable interrupt */
/* switch off PTT */
outb(PAR96_PTT | PAR97_POWER, LPT_DATA(bc->iobase));
free_irq(bc->irq, bc);
}
/* --------------------------------------------------------------------- */
/*
* ===================== Bottom half (soft interrupt) ====================
*/
#ifdef BAYCOM_USE_BH
static void bh_receiver(void *private)
{
struct baycom_state *bc = (struct baycom_state *)private;
unsigned int temp;
if (!bc || bc->magic != BAYCOM_MAGIC)
return;
if (!bc->hdlc_rx.shreg2)
return;
temp = bc->hdlc_rx.shreg2;
bc->hdlc_rx.shreg2 = 0;
hdlc_rx_word(bc, temp);
}
/* --------------------------------------------------------------------- */
static void bh_transmitter(void *private)
{
struct baycom_state *bc = (struct baycom_state *)private;
if (!bc || bc->magic != BAYCOM_MAGIC)
return;
if (bc->hdlc_tx.shreg2)
return;
bc->hdlc_tx.shreg2 = hdlc_tx_word(bc) | 0x10000;
}
/* --------------------------------------------------------------------- */
static void bh_arbitrate(void *private)
{
struct baycom_state *bc = (struct baycom_state *)private;
if (!bc || bc->magic != BAYCOM_MAGIC)
return;
tx_arbitrate(bc);
}
/* --------------------------------------------------------------------- */
static void baycom_bottom_half(void)
{
run_task_queue(&tq_baycom);
}
#endif /* BAYCOM_USE_BH */
/* --------------------------------------------------------------------- */
/*
* ===================== TTY interface routines ==========================
*/
static inline int baycom_paranoia_check(struct baycom_state *bc,
const char *routine)
{
if (!bc || bc->magic != BAYCOM_MAGIC) {
printk(KERN_ERR "baycom: bad magic number for baycom struct "
"in routine %s\n", routine);
return 1;
}
return 0;
}
/* --------------------------------------------------------------------- */
/*
* Here the tty driver code starts
*/
static void baycom_put_fend(struct baycom_state *bc)
{
if (bc->kiss_decode.wr <= 0 ||
(bc->kiss_decode.pkt_buf[0] & 0xf0) != 0)
return;
switch (bc->kiss_decode.pkt_buf[0] & 0xf) {
case KISS_CMD_DATA:
if (bc->kiss_decode.wr <= 8)
break;
if (!store_packet(&bc->tx_buf, bc->kiss_decode.pkt_buf+1, 0,
bc->kiss_decode.wr-1))
bc->stat.tx_bufferoverrun++;
break;
case KISS_CMD_TXDELAY:
if (bc->kiss_decode.wr < 2)
break;
bc->ch_params.tx_delay = bc->kiss_decode.pkt_buf[1];
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: TX delay = %ums\n",
bc->ch_params.tx_delay * 10);
#endif /* KISS_VERBOSE */
break;
case KISS_CMD_PPERSIST:
if (bc->kiss_decode.wr < 2)
break;
bc->ch_params.ppersist = bc->kiss_decode.pkt_buf[1];
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: p-persistence = %u\n",
bc->ch_params.ppersist);
#endif /* KISS_VERBOSE */
break;
case KISS_CMD_SLOTTIME:
if (bc->kiss_decode.wr < 2)
break;
bc->ch_params.slottime = bc->kiss_decode.pkt_buf[1];
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: slottime = %ums\n",
bc->ch_params.slottime * 10);
#endif /* KISS_VERBOSE */
break;
case KISS_CMD_TXTAIL:
if (bc->kiss_decode.wr < 2)
break;
bc->ch_params.tx_tail = bc->kiss_decode.pkt_buf[1];
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: TX tail = %ums\n",
bc->ch_params.tx_tail * 10);
#endif /* KISS_VERBOSE */
break;
case KISS_CMD_FULLDUP:
if (bc->kiss_decode.wr < 2)
break;
bc->ch_params.fulldup = bc->kiss_decode.pkt_buf[1];
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: %s duplex\n",
bc->ch_params.fulldup ? "full" : "half");
#endif /* KISS_VERBOSE */
break;
default:
#ifdef KISS_VERBOSE
printk(KERN_INFO "baycom: unhandled KISS packet code %u\n",
bc->kiss_decode.pkt_buf[0] & 0xf);
#endif /* KISS_VERBOSE */
break;
}
}
/* --------------------------------------------------------------------- */
static void baycom_put_char(struct tty_struct *tty, unsigned char ch)
{
struct baycom_state *bc;
if (!tty)
return;
if (baycom_paranoia_check(bc = tty->driver_data, "put_char"))
return;
if (ch == KISS_FEND) {
baycom_put_fend(bc);
bc->kiss_decode.wr = 0;
bc->kiss_decode.escaped = 0;
bc->kiss_decode.dec_state = 1;
return;
}
if (!bc->kiss_decode.dec_state)
return;
if (ch == KISS_FESC) {
bc->kiss_decode.escaped = 1;
return;
}
if (bc->kiss_decode.wr >= sizeof(bc->kiss_decode.pkt_buf)) {
bc->kiss_decode.wr = 0;
bc->kiss_decode.dec_state = 0;
return;
}
if (bc->kiss_decode.escaped) {
if (ch == KISS_TFEND)
bc->kiss_decode.pkt_buf[bc->kiss_decode.wr++] =
KISS_FEND;
else if (ch == KISS_TFESC)
bc->kiss_decode.pkt_buf[bc->kiss_decode.wr++] =
KISS_FESC;
else {
bc->kiss_decode.wr = 0;
bc->kiss_decode.dec_state = 0;
}
bc->kiss_decode.escaped = 0;
return;
}
bc->kiss_decode.pkt_buf[bc->kiss_decode.wr++] = ch;
}
/* --------------------------------------------------------------------- */
static int baycom_write(struct tty_struct * tty, int from_user,
const unsigned char *buf, int count)
{
int c;
const unsigned char *bp;
struct baycom_state *bc;
if (!tty || !buf || count <= 0)
return count;
if (baycom_paranoia_check(bc = tty->driver_data, "write"))
return count;
if (from_user) {
for(c = count, bp = buf; c > 0; c--,bp++)
baycom_put_char(tty, get_user(bp));
} else {
for(c = count, bp = buf; c > 0; c--,bp++)
baycom_put_char(tty, *bp);
}
if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
tty->ldisc.write_wakeup)
(tty->ldisc.write_wakeup)(tty);
wake_up_interruptible(&tty->write_wait);
return count;
}
/* --------------------------------------------------------------------- */
static int baycom_write_room(struct tty_struct *tty)
{
int free;
struct baycom_state *bc;
if (!tty)
return 0;
if (baycom_paranoia_check(bc = tty->driver_data, "write_room"))
return 0;
free = bc->tx_buf.rd - bc->tx_buf.wr;
if (free <= 0) {
free = bc->tx_buf.buflen - bc->tx_buf.wr;
if (free < bc->tx_buf.rd)
free = bc->tx_buf.rd; /* we may fold */
}
return free / 2; /* a rather pessimistic estimate */
}
/* --------------------------------------------------------------------- */
static int baycom_chars_in_buffer(struct tty_struct *tty)
{
int cnt;
struct baycom_state *bc;
if (!tty)
return 0;
if (baycom_paranoia_check(bc = tty->driver_data, "chars_in_buffer"))
return 0;
cnt = bc->tx_buf.wr - bc->tx_buf.rd;
if (cnt < 0)
cnt += bc->tx_buf.buflen;
return cnt;
}
/* --------------------------------------------------------------------- */
static void baycom_flush_buffer(struct tty_struct *tty)
{
struct baycom_state *bc;
if (!tty)
return;
if (baycom_paranoia_check(bc = tty->driver_data, "flush_buffer"))
return;
wake_up_interruptible(&tty->write_wait);
if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
tty->ldisc.write_wakeup)
(tty->ldisc.write_wakeup)(tty);
}
/* --------------------------------------------------------------------- */
static inline void baycom_dealloc_hw(struct baycom_state *bc)
{
if (!bc || bc->magic != BAYCOM_MAGIC ||
bc->modem_type == BAYCOM_MODEM_INVALID)
return;
switch(bc->modem_type) {
case BAYCOM_MODEM_SER12:
ser12_deallocate_resources(bc);
break;
case BAYCOM_MODEM_PAR96:
par96_deallocate_resources(bc);
break;
}
}
/* --------------------------------------------------------------------- */
static int baycom_set_hardware(struct baycom_state *bc,
unsigned int modem_type, unsigned int iobase,
unsigned int irq, unsigned int options)
{
int i;
if (!bc)
return -EINVAL;
if (modem_type == BAYCOM_MODEM_SER12) {
i = ser12_allocate_resources(iobase, irq, options);
if (i < 0)
return i;
} else if (modem_type == BAYCOM_MODEM_PAR96) {
i = par96_allocate_resources(iobase, irq, options);
if (i < 0)
return i;
} else if (modem_type == BAYCOM_MODEM_INVALID) {
iobase = irq = options = 0;
} else {
return -ENXIO;
}
baycom_dealloc_hw(bc);
bc->modem_type = modem_type;
bc->iobase = iobase;
bc->irq = irq;
bc->options = options;
i = 0;
if (bc->opened > 0) {
switch(bc->modem_type) {
case BAYCOM_MODEM_SER12:
i = ser12_on_open(bc);
break;
case BAYCOM_MODEM_PAR96:
i = par96_on_open(bc);
break;
}
}
return i;
}
/* --------------------------------------------------------------------- */
static int baycom_ioctl(struct tty_struct *tty, struct file * file,
unsigned int cmd, unsigned long arg)
{
int i;
struct baycom_state *bc;
struct baycom_params par;
if (!tty)
return -EINVAL;
if (baycom_paranoia_check(bc = tty->driver_data, "ioctl"))
return -EINVAL;
switch (cmd) {
default:
return -ENOIOCTLCMD;
case TIOCMGET:
i = verify_area(VERIFY_WRITE, (void *) arg, sizeof(int));
if (i)
return i;
i = (bc->modem.dcd ? TIOCM_CAR : 0) |
(bc->hdlc_tx.ptt ? TIOCM_RTS : 0);
put_user(i, (int *) arg);
return 0;
case BAYCOMCTL_GETDCD:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned char));
if (!i)
put_user(bc->modem.dcd, (unsigned char *) arg);
return i;
case BAYCOMCTL_GETPTT:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned char));
if (!i)
put_user(bc->hdlc_tx.ptt, (unsigned char *) arg);
return i;
case BAYCOMCTL_PARAM_TXDELAY:
if (arg > 255)
return -EINVAL;
bc->ch_params.tx_delay = arg;
return 0;
case BAYCOMCTL_PARAM_PPERSIST:
if (arg > 255)
return -EINVAL;
bc->ch_params.ppersist = arg;
return 0;
case BAYCOMCTL_PARAM_SLOTTIME:
if (arg > 255)
return -EINVAL;
bc->ch_params.slottime = arg;
return 0;
case BAYCOMCTL_PARAM_TXTAIL:
if (arg > 255)
return -EINVAL;
bc->ch_params.tx_tail = arg;
return 0;
case BAYCOMCTL_PARAM_FULLDUP:
bc->ch_params.fulldup = arg ? 1 : 0;
return 0;
case BAYCOMCTL_CALIBRATE:
bc->calibrate = arg * ((bc->modem_type == BAYCOM_MODEM_PAR96) ?
600 : 75);
return 0;
case BAYCOMCTL_GETPARAMS:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(par));
if (i)
return i;
par.modem_type = bc->modem_type;
par.iobase = bc->iobase;
par.irq = bc->irq;
par.options = bc->options;
par.tx_delay = bc->ch_params.tx_delay;
par.tx_tail = bc->ch_params.tx_tail;
par.slottime = bc->ch_params.slottime;
par.ppersist = bc->ch_params.ppersist;
par.fulldup = bc->ch_params.fulldup;
memcpy_tofs((void *)arg, &par, sizeof(par));
return 0;
case BAYCOMCTL_SETPARAMS:
if (!suser())
return -EPERM;
i = verify_area(VERIFY_READ, (void *) arg,
sizeof(par));
if (i)
return i;
memcpy_fromfs(&par, (void *)arg, sizeof(par));
printk(KERN_INFO "baycom: changing hardware type: modem %u "
"iobase 0x%x irq %u options 0x%x\n", par.modem_type,
par.iobase, par.irq, par.options);
i = baycom_set_hardware(bc, par.modem_type, par.iobase,
par.irq, par.options);
if (i)
return i;
bc->ch_params.tx_delay = par.tx_delay;
bc->ch_params.tx_tail = par.tx_tail;
bc->ch_params.slottime = par.slottime;
bc->ch_params.ppersist = par.ppersist;
bc->ch_params.fulldup = par.fulldup;
return 0;
case BAYCOMCTL_GETSTAT:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(struct baycom_statistics));
if (i)
return i;
memcpy_tofs((void *)arg, &bc->stat,
sizeof(struct baycom_statistics));
return 0;
#ifdef BAYCOM_DEBUG
case BAYCOMCTL_GETSAMPLES:
if (bc->bitbuf_channel.rd == bc->bitbuf_channel.wr)
return -EAGAIN;
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned char));
if (!i) {
put_user(bc->bitbuf_channel.buffer
[bc->bitbuf_channel.rd],
(unsigned char *) arg);
bc->bitbuf_channel.rd = (bc->bitbuf_channel.rd+1) %
sizeof(bc->bitbuf_channel.buffer);
}
return i;
case BAYCOMCTL_GETBITS:
if (bc->bitbuf_hdlc.rd == bc->bitbuf_hdlc.wr)
return -EAGAIN;
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned char));
if (!i) {
put_user(bc->bitbuf_hdlc.buffer[bc->bitbuf_hdlc.rd],
(unsigned char *) arg);
bc->bitbuf_hdlc.rd = (bc->bitbuf_hdlc.rd+1) %
sizeof(bc->bitbuf_hdlc.buffer);
}
return i;
case BAYCOMCTL_DEBUG1:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned long));
if (!i)
put_user((bc->rx_buf.wr-bc->rx_buf.rd) %
bc->rx_buf.buflen, (unsigned long *)arg);
return i;
case BAYCOMCTL_DEBUG2:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned long));
if (!i)
put_user(bc->debug_vals.last_intcnt,
(unsigned long *)arg);
return i;
case BAYCOMCTL_DEBUG3:
i = verify_area(VERIFY_WRITE, (void *) arg,
sizeof(unsigned long));
if (!i)
put_user((long)bc->debug_vals.last_pllcorr,
(long *)arg);
return i;
#endif /* BAYCOM_DEBUG */
}
}
/* --------------------------------------------------------------------- */
int baycom_open(struct tty_struct *tty, struct file * filp)
{
int line;
struct baycom_state *bc;
int i;
if(!tty)
return -ENODEV;
line = MINOR(tty->device) - tty->driver.minor_start;
if (line < 0 || line >= NR_PORTS)
return -ENODEV;
bc = baycom_state+line;
if (bc->opened > 0) {
bc->opened++;
MOD_INC_USE_COUNT;
return 0;
}
/*
* initialise some variables
*/
bc->calibrate = 0;
/*
* allocate the buffer space
*/
if (bc->rx_buf.buffer)
kfree_s(bc->rx_buf.buffer, bc->rx_buf.buflen);
if (bc->tx_buf.buffer)
kfree_s(bc->tx_buf.buffer, bc->tx_buf.buflen);
bc->rx_buf.buflen = BUFLEN_RX;
bc->tx_buf.buflen = BUFLEN_TX;
bc->rx_buf.rd = bc->rx_buf.wr = 0;
bc->tx_buf.rd = bc->tx_buf.wr = 0;
bc->rx_buf.buffer = kmalloc(bc->rx_buf.buflen, GFP_KERNEL);
bc->tx_buf.buffer = kmalloc(bc->tx_buf.buflen, GFP_KERNEL);
if (!bc->rx_buf.buffer || !bc->tx_buf.buffer) {
if (bc->rx_buf.buffer)
kfree_s(bc->rx_buf.buffer, bc->rx_buf.buflen);
if (bc->tx_buf.buffer)
kfree_s(bc->tx_buf.buffer, bc->tx_buf.buflen);
bc->rx_buf.buffer = bc->tx_buf.buffer = NULL;
bc->rx_buf.buflen = bc->tx_buf.buflen = 0;
return -ENOMEM;
}
/*
* check if the modem type has been set
*/
switch(bc->modem_type) {
case BAYCOM_MODEM_SER12:
i = ser12_on_open(bc);
break;
case BAYCOM_MODEM_PAR96:
i = par96_on_open(bc);
break;
case BAYCOM_MODEM_INVALID:
/*
* may open even if no hardware specified, in order to
* subsequently allow the BAYCOMCTL_SETPARAMS ioctl
*/
i = 0;
break;
default:
return -ENODEV;
}
if (i)
return i;
bc->opened++;
MOD_INC_USE_COUNT;
tty->driver_data = bc;
bc->tty = tty;
return 0;
}
/* --------------------------------------------------------------------- */
static void baycom_close(struct tty_struct *tty, struct file * filp)
{
struct baycom_state *bc;
if(!tty) return;
if (baycom_paranoia_check(bc = tty->driver_data, "close"))
return;
MOD_DEC_USE_COUNT;
bc->opened--;
if (bc->opened <= 0) {
switch(bc->modem_type) {
case BAYCOM_MODEM_SER12:
ser12_on_close(bc);
break;
case BAYCOM_MODEM_PAR96:
par96_on_close(bc);
break;
}
tty->driver_data = NULL;
bc->tty = NULL;
bc->opened = 0;
/*
* free the buffers
*/
bc->rx_buf.rd = bc->rx_buf.wr = 0;
bc->tx_buf.rd = bc->tx_buf.wr = 0;
if (bc->rx_buf.buffer)
kfree_s(bc->rx_buf.buffer, bc->rx_buf.buflen);
if (bc->tx_buf.buffer)
kfree_s(bc->tx_buf.buffer, bc->tx_buf.buflen);
bc->rx_buf.buffer = bc->tx_buf.buffer = NULL;
bc->rx_buf.buflen = bc->tx_buf.buflen = 0;
}
}
/* --------------------------------------------------------------------- */
/*
* And now the modules code and kernel interface.
*/
static void init_channel(struct baycom_state *bc)
{
struct access_params dflt_ch_params = { 20, 2, 10, 40, 0 };
if (!bc)
return;
bc->hdlc_rx.rx_state = 0;
bc->hdlc_tx.tx_state = bc->hdlc_tx.numflags = 0;
bc->hdlc_tx.bitstream = 0;
bc->hdlc_tx.current_byte = bc->hdlc_tx.ptt = 0;
memset(&bc->modem, 0, sizeof(bc->modem));
#ifdef BAYCOM_DEBUG
bc->bitbuf_channel.rd = bc->bitbuf_channel.wr = 0;
bc->bitbuf_channel.shreg = 0x80;
bc->bitbuf_hdlc.rd = bc->bitbuf_hdlc.wr = 0;
bc->bitbuf_hdlc.shreg = 0x80;
#endif /* BAYCOM_DEBUG */
bc->kiss_decode.dec_state = bc->kiss_decode.escaped =
bc->kiss_decode.wr = 0;
bc->ch_params = dflt_ch_params;
#ifdef BAYCOM_USE_BH
bc->tq_receiver.next = bc->tq_transmitter.next =
bc->tq_arbitrate.next = NULL;
bc->tq_receiver.sync = bc->tq_transmitter.sync =
bc->tq_arbitrate.sync = 0;
bc->tq_receiver.data = bc->tq_transmitter.data =
bc->tq_arbitrate.data = bc;
bc->tq_receiver.routine = bh_receiver;
bc->tq_transmitter.routine = bh_transmitter;
bc->tq_arbitrate.routine = bh_arbitrate;
#endif /* BAYCOM_USE_BH */
}
static void init_datastructs(void)
{
int i;
for(i = 0; i < NR_PORTS; i++) {
struct baycom_state *bc = baycom_state+i;
bc->magic = BAYCOM_MAGIC;
bc->modem_type = BAYCOM_MODEM_INVALID;
bc->iobase = bc->irq = bc->options = bc->opened = 0;
bc->tty = NULL;
bc->rx_buf.rd = bc->rx_buf.wr = 0;
bc->rx_buf.buflen = 0;
bc->rx_buf.buffer = NULL;
bc->tx_buf.rd = bc->tx_buf.wr = 0;
bc->tx_buf.buflen = 0;
bc->tx_buf.buffer = NULL;
memset(&bc->stat, 0, sizeof(bc->stat));
init_channel(bc);
}
}
int baycom_init(void) {
int i, j;
/*
* initialize the data structures
*/
init_datastructs();
/*
* initialize bottom half handler
*/
#ifdef BAYCOM_USE_BH
init_bh(BAYCOM_BH, baycom_bottom_half);
#endif /* BAYCOM_USE_BH */
/*
* register the driver as tty driver
*/
memset(&baycom_driver, 0, sizeof(struct tty_driver));
baycom_driver.magic = TTY_DRIVER_MAGIC;
baycom_driver.name = "baycom";
baycom_driver.major = major;
baycom_driver.minor_start = 0;
baycom_driver.num = NR_PORTS;
baycom_driver.type = TTY_DRIVER_TYPE_BAYCOM;
baycom_driver.subtype = BAYCOM_TYPE_NORMAL;
baycom_driver.init_termios.c_iflag = 0;
baycom_driver.init_termios.c_oflag = 0;
baycom_driver.init_termios.c_cflag = CS8 | B1200 | CREAD | CLOCAL;
baycom_driver.init_termios.c_lflag = 0;
baycom_driver.flags = TTY_DRIVER_REAL_RAW;
baycom_driver.refcount = &baycom_refcount;
baycom_driver.table = baycom_table;
baycom_driver.termios = baycom_termios;
baycom_driver.termios_locked = baycom_termios_locked;
/*
* the functions
*/
baycom_driver.open = baycom_open;
baycom_driver.close = baycom_close;
baycom_driver.write = baycom_write;
baycom_driver.put_char = baycom_put_char;
baycom_driver.flush_chars = NULL;
baycom_driver.write_room = baycom_write_room;
baycom_driver.chars_in_buffer = baycom_chars_in_buffer;
baycom_driver.flush_buffer = baycom_flush_buffer;
baycom_driver.ioctl = baycom_ioctl;
/*
* cannot throttle the transmitter on this layer
*/
baycom_driver.throttle = NULL;
baycom_driver.unthrottle = NULL;
/*
* no special actions on termio changes
*/
baycom_driver.set_termios = NULL;
/*
* no XON/XOFF and no hangup on the radio port
*/
baycom_driver.stop = NULL;
baycom_driver.start = NULL;
baycom_driver.hangup = NULL;
baycom_driver.set_ldisc = NULL;
if (tty_register_driver(&baycom_driver)) {
printk(KERN_WARNING "baycom: tty_register_driver failed\n");
return -EIO;
}
for (i = 0; i < NR_PORTS &&
baycom_ports[i].modem != BAYCOM_MODEM_INVALID; i++) {
j = baycom_set_hardware(baycom_state+i,
baycom_ports[i].modem,
baycom_ports[i].iobase,
baycom_ports[i].irq,
baycom_ports[i].options);
if (j < 0) {
const char *s;
switch (-j) {
case ENXIO:
s = "invalid iobase and/or irq";
break;
case EACCES:
s = "io region already used";
break;
case EIO:
s = "no uart/lpt port at iobase";
break;
case EBUSY:
s = "interface already in use";
break;
case EINVAL:
s = "internal error";
break;
default:
s = "unknown error";
break;
}
printk(KERN_WARNING "baycom: modem %u iobase 0x%x "
"irq %u: (%i) %s\n", baycom_ports[i].modem,
baycom_ports[i].iobase, baycom_ports[i].irq,
j, s);
}
}
return 0;
}
/* --------------------------------------------------------------------- */
#ifdef MODULE
int modem = BAYCOM_MODEM_INVALID;
int iobase = 0x3f8;
int irq = 4;
int options = BAYCOM_OPTIONS_SOFTDCD;
int init_module(void)
{
int i;
printk(KERN_INFO "baycom: init_module called\n");
baycom_ports[0].modem = modem;
baycom_ports[0].iobase = iobase;
baycom_ports[0].irq = irq;
baycom_ports[0].options = options;
baycom_ports[1].modem = BAYCOM_MODEM_INVALID;
i = baycom_init();
if (i)
return i;
printk(KERN_INFO "baycom: version 0.3; "
"(C) 1996 by Thomas Sailer HB9JNX, sailer@ife.ee.ethz.ch\n");
return 0;
}
/* --------------------------------------------------------------------- */
void cleanup_module(void)
{
int i;
printk(KERN_INFO "baycom: cleanup_module called\n");
disable_bh(BAYCOM_BH);
if (tty_unregister_driver(&baycom_driver))
printk(KERN_WARNING "baycom: failed to unregister tty "
"driver\n");
for(i = 0; i < NR_PORTS; i++) {
struct baycom_state *bc = baycom_state+i;
if (bc->magic != BAYCOM_MAGIC)
printk(KERN_ERR "baycom: invalid magic in "
"cleanup_module\n");
else {
baycom_dealloc_hw(bc);
/*
* free the buffers
*/
bc->rx_buf.rd = bc->rx_buf.wr = 0;
bc->tx_buf.rd = bc->tx_buf.wr = 0;
if (bc->rx_buf.buffer)
kfree_s(bc->rx_buf.buffer, bc->rx_buf.buflen);
if (bc->tx_buf.buffer)
kfree_s(bc->tx_buf.buffer, bc->tx_buf.buflen);
bc->rx_buf.buffer = bc->tx_buf.buffer = NULL;
bc->rx_buf.buflen = bc->tx_buf.buflen = 0;
}
}
}
#else /* MODULE */
/* --------------------------------------------------------------------- */
/*
* format: baycom=modem,io,irq,options[,modem,io,irq,options]
* modem=1: ser12, modem=2: par96
* options=0: hardware DCD, options=1: software DCD
*/
void baycom_setup(char *str, int *ints)
{
int i;
for (i = 0; i < NR_PORTS; i++)
if (ints[0] >= 4*i+4) {
baycom_ports[i].modem = ints[4*i+1];
baycom_ports[i].iobase = ints[4*i+2];
baycom_ports[i].irq = ints[4*i+3];
baycom_ports[i].options = ints[4*i+4];
} else
baycom_ports[i].modem = BAYCOM_MODEM_INVALID;
}
#endif /* MODULE */
/* --------------------------------------------------------------------- */
