/*
|
/*
|
* Modem device driver for RTEMS
|
* Modem device driver for RTEMS
|
* Author: Tomasz Domin (dot@comarch.pl)
|
* Author: Tomasz Domin (dot@comarch.pl)
|
* Copyright (C) 1998 by ComArch SA
|
* Copyright (C) 1998 by ComArch SA
|
* Driver will use termios for character output and ppp specific out procecedures for network protocols
|
* Driver will use termios for character output and ppp specific out procecedures for network protocols
|
*/
|
*/
|
|
|
#include <bsp.h>
|
#include <bsp.h>
|
#include <rtems.h>
|
#include <rtems.h>
|
#include <rtems/libio.h>
|
#include <rtems/libio.h>
|
#include <sys/ttycom.h>
|
#include <sys/ttycom.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <sys/errno.h>
|
#include <sys/errno.h>
|
#include <rtems/rtems/event.h>
|
#include <rtems/rtems/event.h>
|
#include <rtems/rtems/tasks.h>
|
#include <rtems/rtems/tasks.h>
|
#include <mpc823.h>
|
#include <mpc823.h>
|
#include <sys/param.h>
|
#include <sys/param.h>
|
#include <sys/systm.h>
|
#include <sys/systm.h>
|
#include <sys/proc.h>
|
#include <sys/proc.h>
|
#include <sys/mbuf.h>
|
#include <sys/mbuf.h>
|
#include <sys/socket.h>
|
#include <sys/socket.h>
|
#include <sys/ioctl.h>
|
#include <sys/ioctl.h>
|
#include <sys/file.h>
|
#include <sys/file.h>
|
|
|
#include <sys/kernel.h>
|
#include <sys/kernel.h>
|
#include <sys/conf.h>
|
#include <sys/conf.h>
|
#include <net/if.h>
|
#include <net/if.h>
|
#include <net/ppp_defs.h>
|
#include <net/ppp_defs.h>
|
#include <sys/fcntl.h>
|
#include <sys/fcntl.h>
|
#include "ppp.h"
|
#include "ppp.h"
|
#include <net/if_pppvar.h>
|
#include <net/if_pppvar.h>
|
#include <net/if_ppp.h>
|
#include <net/if_ppp.h>
|
/* RTEMS specific */
|
/* RTEMS specific */
|
rtems_id modem_task_id;
|
rtems_id modem_task_id;
|
#include "16550.h"
|
#include "16550.h"
|
#include <mpc823.h>
|
#include <mpc823.h>
|
#define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
|
#define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
|
#define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
|
#define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
|
|
|
#define M_DATASTART(m) \
|
#define M_DATASTART(m) \
|
(M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
|
(M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
|
(m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
|
(m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
|
|
|
#define M_DATASIZE(m) \
|
#define M_DATASIZE(m) \
|
(M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
|
(M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
|
(m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
|
(m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
|
|
|
|
|
struct rtems_termios_tty *modem_tty;
|
struct rtems_termios_tty *modem_tty;
|
/*
|
/*
|
* RTEMS event used by interrupt handler to signal daemons.
|
* RTEMS event used by interrupt handler to signal daemons.
|
* This must *not* be the same event used by the KA9Q task synchronization.
|
* This must *not* be the same event used by the KA9Q task synchronization.
|
*/
|
*/
|
#define INTERRUPT_EVENT RTEMS_EVENT_1
|
#define INTERRUPT_EVENT RTEMS_EVENT_1
|
#define START_TRANSMIT_EVENT RTEMS_EVENT_2
|
#define START_TRANSMIT_EVENT RTEMS_EVENT_2
|
#define PPP_LOWAT 100 /* Process more output when < LOWAT on queue */
|
#define PPP_LOWAT 100 /* Process more output when < LOWAT on queue */
|
#define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */
|
#define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */
|
|
|
/*
|
/*
|
* RTEMS event used to start transmit daemon.
|
* RTEMS event used to start transmit daemon.
|
* This must not be the same as INTERRUPT_EVENT.
|
* This must not be the same as INTERRUPT_EVENT.
|
*/
|
*/
|
|
|
/*static struct modem_tty *tp=&modem_tp;*/
|
/*static struct modem_tty *tp=&modem_tp;*/
|
static rtems_id modem_rx_task,modem_tx_task;
|
static rtems_id modem_rx_task,modem_tx_task;
|
|
|
|
|
|
|
/* internal FIFO buffers for input and output characters */
|
/* internal FIFO buffers for input and output characters */
|
#define MODEM_BUFFER_LENGTH 4096
|
#define MODEM_BUFFER_LENGTH 4096
|
#define RTS_STOP_SIZE MODEM_BUFFER_LENGTH-128
|
#define RTS_STOP_SIZE MODEM_BUFFER_LENGTH-128
|
#define RTS_START_SIZE 16
|
#define RTS_START_SIZE 16
|
|
|
int xmt_start,xmt_len;
|
int xmt_start,xmt_len;
|
int rcv_start,rcv_len;
|
int rcv_start,rcv_len;
|
|
|
static unsigned char xmt_buf[MODEM_BUFFER_LENGTH];
|
static unsigned char xmt_buf[MODEM_BUFFER_LENGTH];
|
static unsigned char rcv_buf[MODEM_BUFFER_LENGTH];
|
static unsigned char rcv_buf[MODEM_BUFFER_LENGTH];
|
|
|
static volatile char _tx_stop = 0 ,_modem_cd=0;
|
static volatile char _tx_stop = 0 ,_modem_cd=0;
|
struct ModemData
|
struct ModemData
|
{
|
{
|
int t_line;
|
int t_line;
|
struct ppp_softc *t_sc;
|
struct ppp_softc *t_sc;
|
rtems_id pppsem;
|
rtems_id pppsem;
|
int offhook;
|
int offhook;
|
} ModemData;
|
} ModemData;
|
|
|
int pppstart(struct tty *ignore);
|
int pppstart(struct tty *ignore);
|
static u_short fcstab[256] = {
|
static u_short fcstab[256] = {
|
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
|
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
|
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
|
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
|
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
|
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
|
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
|
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
|
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
|
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
|
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
|
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
|
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
|
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
|
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
|
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
|
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
|
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
|
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
|
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
|
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
|
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
|
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
|
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
|
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
|
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
|
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
|
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
|
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
|
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
|
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
|
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
|
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
|
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
|
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
|
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
|
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
|
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
|
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
|
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
|
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
|
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
|
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
|
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
|
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
|
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
|
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
|
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
|
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
|
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
|
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
|
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
|
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
|
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
|
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
|
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
|
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
|
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
|
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
|
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
|
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
|
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
|
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
|
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
|
};
|
};
|
|
|
|
|
static u_short
|
static u_short
|
pppfcs(fcs, cp, len)
|
pppfcs(fcs, cp, len)
|
register u_short fcs;
|
register u_short fcs;
|
register u_char *cp;
|
register u_char *cp;
|
register int len;
|
register int len;
|
{
|
{
|
while (len--)
|
while (len--)
|
fcs = PPP_FCS(fcs, *cp++);
|
fcs = PPP_FCS(fcs, *cp++);
|
return (fcs);
|
return (fcs);
|
}
|
}
|
|
|
static void
|
static void
|
ppp_timeout(x)
|
ppp_timeout(x)
|
void *x;
|
void *x;
|
{
|
{
|
struct ppp_softc *sc = ModemData.t_sc;
|
struct ppp_softc *sc = ModemData.t_sc;
|
struct tty *tp = (struct tty *) sc->sc_devp;
|
struct tty *tp = (struct tty *) sc->sc_devp;
|
int s;
|
int s;
|
|
|
sc->sc_flags &= ~SC_TIMEOUT;
|
sc->sc_flags &= ~SC_TIMEOUT;
|
pppstart(tp);
|
pppstart(tp);
|
}
|
}
|
|
|
static void
|
static void
|
pppasyncrelinq(sc)
|
pppasyncrelinq(sc)
|
struct ppp_softc *sc;
|
struct ppp_softc *sc;
|
{
|
{
|
int s;
|
int s;
|
|
|
if (sc->sc_outm) {
|
if (sc->sc_outm) {
|
m_freem(sc->sc_outm);
|
m_freem(sc->sc_outm);
|
sc->sc_outm = NULL;
|
sc->sc_outm = NULL;
|
}
|
}
|
if (sc->sc_m) {
|
if (sc->sc_m) {
|
m_freem(sc->sc_m);
|
m_freem(sc->sc_m);
|
sc->sc_m = NULL;
|
sc->sc_m = NULL;
|
}
|
}
|
if (sc->sc_flags & SC_TIMEOUT) {
|
if (sc->sc_flags & SC_TIMEOUT) {
|
untimeout(ppp_timeout, (void *) sc);
|
untimeout(ppp_timeout, (void *) sc);
|
sc->sc_flags &= ~SC_TIMEOUT;
|
sc->sc_flags &= ~SC_TIMEOUT;
|
}
|
}
|
}
|
}
|
|
|
/* Put data in input queue */
|
/* Put data in input queue */
|
int
|
int
|
pppstart(struct tty *ignore)
|
pppstart(struct tty *ignore)
|
{
|
{
|
register struct ppp_softc *sc = ModemData.t_sc;
|
register struct ppp_softc *sc = ModemData.t_sc;
|
|
|
/*
|
/*
|
* If there is stuff in the output queue, send it now.
|
* If there is stuff in the output queue, send it now.
|
* We are being called in lieu of ttstart and must do what it would.
|
* We are being called in lieu of ttstart and must do what it would.
|
*/
|
*/
|
rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT);
|
rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT);
|
sc->sc_if.if_flags |= IFF_OACTIVE;
|
sc->sc_if.if_flags |= IFF_OACTIVE;
|
|
|
/*
|
/*
|
* If the transmit queue has drained and the tty has not hung up
|
* If the transmit queue has drained and the tty has not hung up
|
* or been disconnected from the ppp unit, then tell if_ppp.c that
|
* or been disconnected from the ppp unit, then tell if_ppp.c that
|
* we need more output.
|
* we need more output.
|
*/
|
*/
|
/* if (CCOUNT(&tp->t_outq) < PPP_LOWAT
|
/* if (CCOUNT(&tp->t_outq) < PPP_LOWAT
|
&& !((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
|
&& !((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
|
&& sc != NULL && tp == (struct tty *) sc->sc_devp) {
|
&& sc != NULL && tp == (struct tty *) sc->sc_devp) {
|
ppp_restart(sc);
|
ppp_restart(sc);
|
}
|
}
|
*/
|
*/
|
return 0;
|
return 0;
|
}
|
}
|
int putc(unsigned char c)
|
int putc(unsigned char c)
|
{
|
{
|
int level;
|
int level;
|
|
|
if (xmt_len<MODEM_BUFFER_LENGTH-1)
|
if (xmt_len<MODEM_BUFFER_LENGTH-1)
|
{
|
{
|
_CPU_ISR_Disable(level);
|
_CPU_ISR_Disable(level);
|
xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=c;
|
xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=c;
|
xmt_len++;
|
xmt_len++;
|
_CPU_ISR_Enable(level);
|
_CPU_ISR_Enable(level);
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
void unputc(void)
|
void unputc(void)
|
{
|
{
|
int level;
|
int level;
|
|
|
if (xmt_len==0)
|
if (xmt_len==0)
|
return;
|
return;
|
_CPU_ISR_Disable(level);
|
_CPU_ISR_Disable(level);
|
xmt_len--;
|
xmt_len--;
|
_CPU_ISR_Enable(level);
|
_CPU_ISR_Enable(level);
|
}
|
}
|
|
|
static void
|
static void
|
pppasyncstart(sc)
|
pppasyncstart(sc)
|
register struct ppp_softc *sc;
|
register struct ppp_softc *sc;
|
{
|
{
|
/* Call pppstart to start output again if necessary. */
|
/* Call pppstart to start output again if necessary. */
|
pppstart(sc->sc_devp);
|
pppstart(sc->sc_devp);
|
|
|
/*
|
/*
|
* This timeout is needed for operation on a pseudo-tty,
|
* This timeout is needed for operation on a pseudo-tty,
|
* because the pty code doesn't call pppstart after it has
|
* because the pty code doesn't call pppstart after it has
|
* drained the t_outq.
|
* drained the t_outq.
|
*/
|
*/
|
/* if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
|
/* if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
|
timeout(ppp_timeout, (void *) sc, 1);
|
timeout(ppp_timeout, (void *) sc, 1);
|
sc->sc_flags |= SC_TIMEOUT;
|
sc->sc_flags |= SC_TIMEOUT;
|
}
|
}
|
*/
|
*/
|
|
|
}
|
}
|
|
|
|
|
void modem_sendpacket()
|
void modem_sendpacket()
|
{
|
{
|
struct mbuf *l = NULL;
|
struct mbuf *l = NULL;
|
rtems_unsigned16 status;
|
rtems_unsigned16 status;
|
int curr;
|
int curr;
|
register struct mbuf *m;
|
register struct mbuf *m;
|
register int len;
|
register int len;
|
register u_char *start, *stop, *cp;
|
register u_char *start, *stop, *cp;
|
int n, ndone, done, idle;
|
int n, ndone, done, idle;
|
struct mbuf *m2;
|
struct mbuf *m2;
|
int s;
|
int s;
|
register struct ppp_softc *sc=ModemData.t_sc;
|
register struct ppp_softc *sc=ModemData.t_sc;
|
|
|
|
|
while (xmt_len < PPP_HIWAT) {
|
while (xmt_len < PPP_HIWAT) {
|
/*
|
/*
|
* See if we have an existing packet partly sent.
|
* See if we have an existing packet partly sent.
|
* If not, get a new packet and start sending it.
|
* If not, get a new packet and start sending it.
|
*/
|
*/
|
m = sc->sc_outm;
|
m = sc->sc_outm;
|
if (m == NULL) {
|
if (m == NULL) {
|
/*
|
/*
|
* Get another packet to be sent.
|
* Get another packet to be sent.
|
|
|
*/
|
*/
|
m = ppp_dequeue(sc);
|
m = ppp_dequeue(sc);
|
if (m == NULL)
|
if (m == NULL)
|
{
|
{
|
break;
|
break;
|
}
|
}
|
|
|
/*
|
/*
|
* The extra PPP_FLAG will start up a new packet, and thus
|
* The extra PPP_FLAG will start up a new packet, and thus
|
* will flush any accumulated garbage. We do this whenever
|
* will flush any accumulated garbage. We do this whenever
|
* the line may have been idle for some time.
|
* the line may have been idle for some time.
|
*/
|
*/
|
if (xmt_len == 0) {
|
if (xmt_len == 0) {
|
++sc->sc_stats.ppp_obytes;
|
++sc->sc_stats.ppp_obytes;
|
putc(PPP_FLAG);
|
putc(PPP_FLAG);
|
}
|
}
|
|
|
/* Calculate the FCS for the first mbuf's worth. */
|
/* Calculate the FCS for the first mbuf's worth. */
|
sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
|
sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
|
microtime(&sc->sc_if.if_lastchange);
|
microtime(&sc->sc_if.if_lastchange);
|
}
|
}
|
|
|
for (;;) {
|
for (;;) {
|
start = mtod(m, u_char *);
|
start = mtod(m, u_char *);
|
len = m->m_len;
|
len = m->m_len;
|
stop = start + len;
|
stop = start + len;
|
while (len > 0) {
|
while (len > 0) {
|
/*
|
/*
|
* Find out how many bytes in the string we can
|
* Find out how many bytes in the string we can
|
* handle without doing something special.
|
* handle without doing something special.
|
*/
|
*/
|
for (cp = start; cp < stop; cp++)
|
for (cp = start; cp < stop; cp++)
|
if (ESCAPE_P(*cp))
|
if (ESCAPE_P(*cp))
|
break;
|
break;
|
n = cp - start;
|
n = cp - start;
|
if (n) {
|
if (n) {
|
register int i;
|
register int i;
|
/* NetBSD (0.9 or later), 4.3-Reno or similar. */
|
/* NetBSD (0.9 or later), 4.3-Reno or similar. */
|
for(i=0;i<n;i++)
|
for(i=0;i<n;i++)
|
if (putc(start[i]))
|
if (putc(start[i]))
|
break;
|
break;
|
ndone = i;
|
ndone = i;
|
len -= ndone;
|
len -= ndone;
|
start += ndone;
|
start += ndone;
|
sc->sc_stats.ppp_obytes += ndone;
|
sc->sc_stats.ppp_obytes += ndone;
|
|
|
if (ndone < n)
|
if (ndone < n)
|
break; /* packet doesn't fit */
|
break; /* packet doesn't fit */
|
}
|
}
|
/*
|
/*
|
* If there are characters left in the mbuf,
|
* If there are characters left in the mbuf,
|
* the first one must be special.
|
* the first one must be special.
|
* Put it out in a different form.
|
* Put it out in a different form.
|
*/
|
*/
|
if (len) {
|
if (len) {
|
if (putc(PPP_ESCAPE))
|
if (putc(PPP_ESCAPE))
|
break;
|
break;
|
if (putc(*start ^ PPP_TRANS)) {
|
if (putc(*start ^ PPP_TRANS)) {
|
unputc();
|
unputc();
|
break;
|
break;
|
}
|
}
|
sc->sc_stats.ppp_obytes += 2;
|
sc->sc_stats.ppp_obytes += 2;
|
start++;
|
start++;
|
len--;
|
len--;
|
}
|
}
|
}
|
}
|
|
|
/*
|
/*
|
* If we didn't empty this mbuf, remember where we're up to.
|
* If we didn't empty this mbuf, remember where we're up to.
|
* If we emptied the last mbuf, try to add the FCS and closing
|
* If we emptied the last mbuf, try to add the FCS and closing
|
* flag, and if we can't, leave sc_outm pointing to m, but with
|
* flag, and if we can't, leave sc_outm pointing to m, but with
|
* m->m_len == 0, to remind us to output the FCS and flag later.
|
* m->m_len == 0, to remind us to output the FCS and flag later.
|
*/
|
*/
|
done = len == 0;
|
done = len == 0;
|
if (done && m->m_next == NULL) {
|
if (done && m->m_next == NULL) {
|
u_char *p, *q;
|
u_char *p, *q;
|
int c;
|
int c;
|
u_char endseq[8];
|
u_char endseq[8];
|
|
|
/*
|
/*
|
* We may have to escape the bytes in the FCS.
|
* We may have to escape the bytes in the FCS.
|
*/
|
*/
|
p = endseq;
|
p = endseq;
|
c = ~sc->sc_outfcs & 0xFF;
|
c = ~sc->sc_outfcs & 0xFF;
|
if (ESCAPE_P(c)) {
|
if (ESCAPE_P(c)) {
|
*p++ = PPP_ESCAPE;
|
*p++ = PPP_ESCAPE;
|
*p++ = c ^ PPP_TRANS;
|
*p++ = c ^ PPP_TRANS;
|
} else
|
} else
|
*p++ = c;
|
*p++ = c;
|
c = (~sc->sc_outfcs >> 8) & 0xFF;
|
c = (~sc->sc_outfcs >> 8) & 0xFF;
|
if (ESCAPE_P(c)) {
|
if (ESCAPE_P(c)) {
|
*p++ = PPP_ESCAPE;
|
*p++ = PPP_ESCAPE;
|
*p++ = c ^ PPP_TRANS;
|
*p++ = c ^ PPP_TRANS;
|
} else
|
} else
|
*p++ = c;
|
*p++ = c;
|
*p++ = PPP_FLAG;
|
*p++ = PPP_FLAG;
|
|
|
/*
|
/*
|
* Try to output the FCS and flag. If the bytes
|
* Try to output the FCS and flag. If the bytes
|
* don't all fit, back out.
|
* don't all fit, back out.
|
*/
|
*/
|
for (q = endseq; q < p; ++q)
|
for (q = endseq; q < p; ++q)
|
if (putc(*q)) {
|
if (putc(*q)) {
|
done = 0;
|
done = 0;
|
for (; q > endseq; --q)
|
for (; q > endseq; --q)
|
unputc();
|
unputc();
|
break;
|
break;
|
}
|
}
|
if (done)
|
if (done)
|
sc->sc_stats.ppp_obytes += q - endseq;
|
sc->sc_stats.ppp_obytes += q - endseq;
|
}
|
}
|
|
|
if (!done) {
|
if (!done) {
|
/* remember where we got to */
|
/* remember where we got to */
|
m->m_data = start;
|
m->m_data = start;
|
m->m_len = len;
|
m->m_len = len;
|
break;
|
break;
|
}
|
}
|
|
|
/* Finished with this mbuf; free it and move on. */
|
/* Finished with this mbuf; free it and move on. */
|
MFREE(m, m2);
|
MFREE(m, m2);
|
m = m2;
|
m = m2;
|
if (m == NULL) {
|
if (m == NULL) {
|
/* Finished a packet */
|
/* Finished a packet */
|
break;
|
break;
|
}
|
}
|
sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
|
sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
|
}
|
}
|
|
|
/*
|
/*
|
* If m == NULL, we have finished a packet.
|
* If m == NULL, we have finished a packet.
|
* If m != NULL, we've either done as much work this time
|
* If m != NULL, we've either done as much work this time
|
* as we need to, or else we've filled up the output queue.
|
* as we need to, or else we've filled up the output queue.
|
*/
|
*/
|
sc->sc_outm = m;
|
sc->sc_outm = m;
|
if (m)
|
if (m)
|
break;
|
break;
|
}
|
}
|
|
|
}
|
}
|
|
|
static void
|
static void
|
pppasyncctlp(sc)
|
pppasyncctlp(sc)
|
struct ppp_softc *sc;
|
struct ppp_softc *sc;
|
{
|
{
|
rtems_semaphore_release(ModemData.pppsem);
|
rtems_semaphore_release(ModemData.pppsem);
|
}
|
}
|
|
|
|
|
static unsigned paritytab[8] = {
|
static unsigned paritytab[8] = {
|
0x96696996, 0x69969669, 0x69969669, 0x96696996,
|
0x96696996, 0x69969669, 0x69969669, 0x96696996,
|
0x69969669, 0x96696996, 0x96696996, 0x69969669
|
0x69969669, 0x96696996, 0x96696996, 0x69969669
|
};
|
};
|
#define MAX_DUMP_BYTES 128
|
#define MAX_DUMP_BYTES 128
|
|
|
static void
|
static void
|
pppdumpb(b, l)
|
pppdumpb(b, l)
|
u_char *b;
|
u_char *b;
|
int l;
|
int l;
|
{
|
{
|
char buf[3*MAX_DUMP_BYTES+4];
|
char buf[3*MAX_DUMP_BYTES+4];
|
char *bp = buf;
|
char *bp = buf;
|
static char digits[] = "0123456789abcdef";
|
static char digits[] = "0123456789abcdef";
|
|
|
while (l--) {
|
while (l--) {
|
if (bp >= buf + sizeof(buf) - 3) {
|
if (bp >= buf + sizeof(buf) - 3) {
|
*bp++ = '>';
|
*bp++ = '>';
|
break;
|
break;
|
}
|
}
|
*bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
|
*bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
|
*bp++ = digits[*b++ & 0xf];
|
*bp++ = digits[*b++ & 0xf];
|
*bp++ = ' ';
|
*bp++ = ' ';
|
}
|
}
|
|
|
*bp = 0;
|
*bp = 0;
|
|
|
}
|
}
|
|
|
static void
|
static void
|
ppplogchar(sc, c)
|
ppplogchar(sc, c)
|
struct ppp_softc *sc;
|
struct ppp_softc *sc;
|
int c;
|
int c;
|
{
|
{
|
if (c >= 0)
|
if (c >= 0)
|
sc->sc_rawin[sc->sc_rawin_count++] = c;
|
sc->sc_rawin[sc->sc_rawin_count++] = c;
|
if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
|
if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
|
|| (c < 0 && sc->sc_rawin_count > 0)) {
|
|| (c < 0 && sc->sc_rawin_count > 0)) {
|
/* printf("ppp%d input: ", sc->sc_if.if_unit);
|
/* printf("ppp%d input: ", sc->sc_if.if_unit);
|
*/ pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
|
*/ pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
|
sc->sc_rawin_count = 0;
|
sc->sc_rawin_count = 0;
|
}
|
}
|
}
|
}
|
static void
|
static void
|
pppgetm(sc)
|
pppgetm(sc)
|
register struct ppp_softc *sc;
|
register struct ppp_softc *sc;
|
{
|
{
|
struct mbuf *m, **mp;
|
struct mbuf *m, **mp;
|
int len;
|
int len;
|
mp = &sc->sc_m;
|
mp = &sc->sc_m;
|
for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
|
for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
|
if ((m = *mp) == NULL) {
|
if ((m = *mp) == NULL) {
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
MGETHDR(m, M_DONTWAIT, MT_DATA);
|
if (m == NULL)
|
if (m == NULL)
|
break;
|
break;
|
*mp = m;
|
*mp = m;
|
MCLGET(m, M_DONTWAIT);
|
MCLGET(m, M_DONTWAIT);
|
}
|
}
|
len -= M_DATASIZE(m);
|
len -= M_DATASIZE(m);
|
mp = &m->m_next;
|
mp = &m->m_next;
|
}
|
}
|
}
|
}
|
|
|
|
|
int
|
int
|
pppinput(c)
|
pppinput(c)
|
int c;
|
int c;
|
|
|
{
|
{
|
register struct ppp_softc *sc=ModemData.t_sc;
|
register struct ppp_softc *sc=ModemData.t_sc;
|
struct mbuf *m;
|
struct mbuf *m;
|
int ilen, s;
|
int ilen, s;
|
|
|
if (sc == NULL )
|
if (sc == NULL )
|
return 0;
|
return 0;
|
|
|
++sc->sc_stats.ppp_ibytes;
|
++sc->sc_stats.ppp_ibytes;
|
/*
|
/*
|
if (c & TTY_FE) {*/
|
if (c & TTY_FE) {*/
|
/* framing error or overrun on this char - abort packet */
|
/* framing error or overrun on this char - abort packet */
|
/* if (sc->sc_flags & SC_DEBUG)
|
/* if (sc->sc_flags & SC_DEBUG)
|
printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c);
|
printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c);
|
goto flush;
|
goto flush;
|
}*/
|
}*/
|
|
|
c &= 0xff;
|
c &= 0xff;
|
|
|
/*
|
/*
|
* Handle software flow control of output.
|
* Handle software flow control of output.
|
*/
|
*/
|
/* if (tp->t_iflag & IXON) {
|
/* if (tp->t_iflag & IXON) {
|
if (c == tp->t_cc[VSTOP] ) {
|
if (c == tp->t_cc[VSTOP] ) {
|
if ((tp->t_state & TS_TTSTOP) == 0) {
|
if ((tp->t_state & TS_TTSTOP) == 0) {
|
tp->t_state |= TS_TTSTOP;
|
tp->t_state |= TS_TTSTOP;
|
sccppp_stop_transmission(tp);
|
sccppp_stop_transmission(tp);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
if (c == tp->t_cc[VSTART] ) {
|
if (c == tp->t_cc[VSTART] ) {
|
tp->t_state &= ~TS_TTSTOP;
|
tp->t_state &= ~TS_TTSTOP;
|
sccppp_start_transmission(tp);
|
sccppp_start_transmission(tp);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
*/
|
*/
|
|
|
if (c & 0x80)
|
if (c & 0x80)
|
sc->sc_flags |= SC_RCV_B7_1;
|
sc->sc_flags |= SC_RCV_B7_1;
|
else
|
else
|
sc->sc_flags |= SC_RCV_B7_0;
|
sc->sc_flags |= SC_RCV_B7_0;
|
if (paritytab[c >> 5] & (1 << (c & 0x1F)))
|
if (paritytab[c >> 5] & (1 << (c & 0x1F)))
|
sc->sc_flags |= SC_RCV_ODDP;
|
sc->sc_flags |= SC_RCV_ODDP;
|
else
|
else
|
sc->sc_flags |= SC_RCV_EVNP;
|
sc->sc_flags |= SC_RCV_EVNP;
|
|
|
|
|
/* if (sc->sc_flags & SC_LOG_RAWIN)*/
|
/* if (sc->sc_flags & SC_LOG_RAWIN)*/
|
// ppplogchar(sc, c);
|
// ppplogchar(sc, c);
|
|
|
if (c == PPP_FLAG) {
|
if (c == PPP_FLAG) {
|
ilen = sc->sc_ilen;
|
ilen = sc->sc_ilen;
|
sc->sc_ilen = 0;
|
sc->sc_ilen = 0;
|
|
|
if (sc->sc_rawin_count > 0)
|
if (sc->sc_rawin_count > 0)
|
ppplogchar(sc, -1);
|
ppplogchar(sc, -1);
|
|
|
/*
|
/*
|
* If SC_ESCAPED is set, then we've seen the packet
|
* If SC_ESCAPED is set, then we've seen the packet
|
* abort sequence
|
* abort sequence
|
*/
|
*/
|
if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
|
if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
|
|| (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) {
|
|| (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) {
|
sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
|
sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
|
if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
|
if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
printf("ppp%d: bad fcs %x, pkt len %d\n",
|
printf("ppp%d: bad fcs %x, pkt len %d\n",
|
sc->sc_if.if_unit, sc->sc_fcs, ilen);
|
sc->sc_if.if_unit, sc->sc_fcs, ilen);
|
sc->sc_if.if_ierrors++;
|
sc->sc_if.if_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
} else
|
} else
|
sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
|
sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
|
if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
|
if (ilen) {
|
if (ilen) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
|
/* printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
|
*/ sc->sc_if.if_ierrors++;
|
*/ sc->sc_if.if_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
sc->sc_flags |= SC_PKTLOST;
|
sc->sc_flags |= SC_PKTLOST;
|
splx(s);
|
splx(s);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Remove FCS trailer. Somewhat painful...
|
* Remove FCS trailer. Somewhat painful...
|
*/
|
*/
|
ilen -= 2;
|
ilen -= 2;
|
if (--sc->sc_mc->m_len == 0) {
|
if (--sc->sc_mc->m_len == 0) {
|
for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
|
for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
|
;
|
;
|
sc->sc_mc = m;
|
sc->sc_mc = m;
|
}
|
}
|
sc->sc_mc->m_len--;
|
sc->sc_mc->m_len--;
|
|
|
/* excise this mbuf chain */
|
/* excise this mbuf chain */
|
m = sc->sc_m;
|
m = sc->sc_m;
|
sc->sc_m = sc->sc_mc->m_next;
|
sc->sc_m = sc->sc_mc->m_next;
|
sc->sc_mc->m_next = NULL;
|
sc->sc_mc->m_next = NULL;
|
ppppktin(sc, m, sc->sc_flags & SC_PKTLOST);
|
ppppktin(sc, m, sc->sc_flags & SC_PKTLOST);
|
if (sc->sc_flags & SC_PKTLOST) {
|
if (sc->sc_flags & SC_PKTLOST) {
|
sc->sc_flags &= ~SC_PKTLOST;
|
sc->sc_flags &= ~SC_PKTLOST;
|
}
|
}
|
|
|
pppgetm(sc);
|
pppgetm(sc);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (sc->sc_flags & SC_FLUSH) {
|
if (sc->sc_flags & SC_FLUSH) {
|
if (sc->sc_flags & SC_LOG_FLUSH)
|
if (sc->sc_flags & SC_LOG_FLUSH)
|
ppplogchar(sc, c);
|
ppplogchar(sc, c);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
|
if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
|
return 0;
|
return 0;
|
|
|
if (sc->sc_flags & SC_ESCAPED) {
|
if (sc->sc_flags & SC_ESCAPED) {
|
sc->sc_flags &= ~SC_ESCAPED;
|
sc->sc_flags &= ~SC_ESCAPED;
|
c ^= PPP_TRANS;
|
c ^= PPP_TRANS;
|
} else if (c == PPP_ESCAPE) {
|
} else if (c == PPP_ESCAPE) {
|
sc->sc_flags |= SC_ESCAPED;
|
sc->sc_flags |= SC_ESCAPED;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* Initialize buffer on first octet received.
|
* Initialize buffer on first octet received.
|
* First octet could be address or protocol (when compressing
|
* First octet could be address or protocol (when compressing
|
* address/control).
|
* address/control).
|
* Second octet is control.
|
* Second octet is control.
|
* Third octet is first or second (when compressing protocol)
|
* Third octet is first or second (when compressing protocol)
|
* octet of protocol.
|
* octet of protocol.
|
* Fourth octet is second octet of protocol.
|
* Fourth octet is second octet of protocol.
|
*/
|
*/
|
if (sc->sc_ilen == 0) {
|
if (sc->sc_ilen == 0) {
|
/* reset the first input mbuf */
|
/* reset the first input mbuf */
|
if (sc->sc_m == NULL) {
|
if (sc->sc_m == NULL) {
|
pppgetm(sc);
|
pppgetm(sc);
|
if (sc->sc_m == NULL) {
|
if (sc->sc_m == NULL) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit);
|
/* printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit);
|
*/ goto flush;
|
*/ goto flush;
|
}
|
}
|
}
|
}
|
m = sc->sc_m;
|
m = sc->sc_m;
|
m->m_len = 0;
|
m->m_len = 0;
|
m->m_data = M_DATASTART(sc->sc_m);
|
m->m_data = M_DATASTART(sc->sc_m);
|
sc->sc_mc = m;
|
sc->sc_mc = m;
|
sc->sc_mp = mtod(m, char *);
|
sc->sc_mp = mtod(m, char *);
|
sc->sc_fcs = PPP_INITFCS;
|
sc->sc_fcs = PPP_INITFCS;
|
if (c != PPP_ALLSTATIONS) {
|
if (c != PPP_ALLSTATIONS) {
|
if (sc->sc_flags & SC_REJ_COMP_AC) {
|
if (sc->sc_flags & SC_REJ_COMP_AC) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: garbage received: 0x%x (need 0xFF)\n",
|
/* printf("ppp%d: garbage received: 0x%x (need 0xFF)\n",
|
sc->sc_if.if_unit, c);*/
|
sc->sc_if.if_unit, c);*/
|
goto flush;
|
goto flush;
|
}
|
}
|
*sc->sc_mp++ = PPP_ALLSTATIONS;
|
*sc->sc_mp++ = PPP_ALLSTATIONS;
|
*sc->sc_mp++ = PPP_UI;
|
*sc->sc_mp++ = PPP_UI;
|
sc->sc_ilen += 2;
|
sc->sc_ilen += 2;
|
m->m_len += 2;
|
m->m_len += 2;
|
}
|
}
|
}
|
}
|
if (sc->sc_ilen == 1 && c != PPP_UI) {
|
if (sc->sc_ilen == 1 && c != PPP_UI) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: missing UI (0x3), got 0x%x\n",
|
/* printf("ppp%d: missing UI (0x3), got 0x%x\n",
|
sc->sc_if.if_unit, c);
|
sc->sc_if.if_unit, c);
|
*/ goto flush;
|
*/ goto flush;
|
}
|
}
|
if (sc->sc_ilen == 2 && (c & 1) == 1) {
|
if (sc->sc_ilen == 2 && (c & 1) == 1) {
|
/* a compressed protocol */
|
/* a compressed protocol */
|
*sc->sc_mp++ = 0;
|
*sc->sc_mp++ = 0;
|
sc->sc_ilen++;
|
sc->sc_ilen++;
|
sc->sc_mc->m_len++;
|
sc->sc_mc->m_len++;
|
}
|
}
|
if (sc->sc_ilen == 3 && (c & 1) == 0) {
|
if (sc->sc_ilen == 3 && (c & 1) == 0) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit,
|
/* printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit,
|
(sc->sc_mp[-1] << 8) + c);
|
(sc->sc_mp[-1] << 8) + c);
|
*/ goto flush;
|
*/ goto flush;
|
}
|
}
|
|
|
/* packet beyond configured mru? */
|
/* packet beyond configured mru? */
|
if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
|
if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: packet too big\n", sc->sc_if.if_unit);
|
/* printf("ppp%d: packet too big\n", sc->sc_if.if_unit);
|
*/ goto flush;
|
*/ goto flush;
|
}
|
}
|
|
|
/* is this mbuf full? */
|
/* is this mbuf full? */
|
m = sc->sc_mc;
|
m = sc->sc_mc;
|
if (M_TRAILINGSPACE(m) <= 0) {
|
if (M_TRAILINGSPACE(m) <= 0) {
|
if (m->m_next == NULL) {
|
if (m->m_next == NULL) {
|
pppgetm(sc);
|
pppgetm(sc);
|
if (m->m_next == NULL) {
|
if (m->m_next == NULL) {
|
if (sc->sc_flags & SC_DEBUG)
|
if (sc->sc_flags & SC_DEBUG)
|
/* printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit);
|
/* printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit);
|
*/ goto flush;
|
*/ goto flush;
|
}
|
}
|
}
|
}
|
sc->sc_mc = m = m->m_next;
|
sc->sc_mc = m = m->m_next;
|
m->m_len = 0;
|
m->m_len = 0;
|
m->m_data = M_DATASTART(m);
|
m->m_data = M_DATASTART(m);
|
sc->sc_mp = mtod(m, char *);
|
sc->sc_mp = mtod(m, char *);
|
}
|
}
|
|
|
++m->m_len;
|
++m->m_len;
|
*sc->sc_mp++ = c;
|
*sc->sc_mp++ = c;
|
sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
|
sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
|
return 0;
|
return 0;
|
|
|
flush:
|
flush:
|
if (!(sc->sc_flags & SC_FLUSH)) {
|
if (!(sc->sc_flags & SC_FLUSH)) {
|
sc->sc_if.if_ierrors++;
|
sc->sc_if.if_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
sc->sc_stats.ppp_ierrors++;
|
sc->sc_flags |= SC_FLUSH;
|
sc->sc_flags |= SC_FLUSH;
|
if (sc->sc_flags & SC_LOG_FLUSH)
|
if (sc->sc_flags & SC_LOG_FLUSH)
|
ppplogchar(sc, c);
|
ppplogchar(sc, c);
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
void
|
void
|
modem_txDaemon (void *arg)
|
modem_txDaemon (void *arg)
|
{
|
{
|
rtems_event_set events;
|
rtems_event_set events;
|
register int level,i,maxonce;
|
register int level,i,maxonce;
|
while (1)
|
while (1)
|
{
|
{
|
if (xmt_len==0) //jezeli nic nie ma to czekajmy na event
|
if (xmt_len==0) //jezeli nic nie ma to czekajmy na event
|
rtems_event_receive(START_TRANSMIT_EVENT|INTERRUPT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
rtems_event_receive(START_TRANSMIT_EVENT|INTERRUPT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
/* wait for transmit buffer to become empty */
|
/* wait for transmit buffer to become empty */
|
|
|
while(_tx_stop) //tu czekamy na start transmisji
|
while(_tx_stop) //tu czekamy na start transmisji
|
rtems_event_receive(INTERRUPT_EVENT|START_TRANSMIT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
rtems_event_receive(INTERRUPT_EVENT|START_TRANSMIT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
|
|
_CPU_ISR_Disable(level);
|
_CPU_ISR_Disable(level);
|
if (*LSR & THRE) //jezeli nie ma transmisji to wyslijmy pierwsze bajty, jezeli jest, same pojda
|
if (*LSR & THRE) //jezeli nie ma transmisji to wyslijmy pierwsze bajty, jezeli jest, same pojda
|
{
|
{
|
maxonce=(xmt_len>14)?14:xmt_len;
|
maxonce=(xmt_len>14)?14:xmt_len;
|
if (maxonce>0)
|
if (maxonce>0)
|
{
|
{
|
for (i=0;i<maxonce;i++)
|
for (i=0;i<maxonce;i++)
|
{
|
{
|
*THR=xmt_buf[xmt_start];
|
*THR=xmt_buf[xmt_start];
|
xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH;
|
xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH;
|
}
|
}
|
xmt_len-=maxonce;
|
xmt_len-=maxonce;
|
}
|
}
|
}
|
}
|
_CPU_ISR_Enable(level);
|
_CPU_ISR_Enable(level);
|
if ((ModemData.t_line==PPPDISC))
|
if ((ModemData.t_line==PPPDISC))
|
{
|
{
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
modem_sendpacket();
|
modem_sendpacket();
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
}
|
}
|
|
|
}
|
}
|
}
|
}
|
|
|
static void modem_rxDaemon (void *arg)
|
static void modem_rxDaemon (void *arg)
|
{
|
{
|
rtems_event_set events;
|
rtems_event_set events;
|
unsigned char bufor_posr[MODEM_BUFFER_LENGTH];
|
unsigned char bufor_posr[MODEM_BUFFER_LENGTH];
|
register unsigned char ch;
|
register unsigned char ch;
|
int level,i,j;
|
int level,i,j;
|
while(1)
|
while(1)
|
{
|
{
|
/* wait for interrupt */
|
/* wait for interrupt */
|
i=0;
|
i=0;
|
_CPU_ISR_Disable(level);
|
_CPU_ISR_Disable(level);
|
while(rcv_len>0)
|
while(rcv_len>0)
|
{
|
{
|
bufor_posr[i++]=rcv_buf[rcv_start];
|
bufor_posr[i++]=rcv_buf[rcv_start];
|
rcv_start=(rcv_start+1)%MODEM_BUFFER_LENGTH;
|
rcv_start=(rcv_start+1)%MODEM_BUFFER_LENGTH;
|
rcv_len--;
|
rcv_len--;
|
}
|
}
|
_CPU_ISR_Enable(level);
|
_CPU_ISR_Enable(level);
|
if (ModemData.t_line==PPPDISC)
|
if (ModemData.t_line==PPPDISC)
|
{
|
{
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
for(j=0;j<i;j++)
|
for(j=0;j<i;j++)
|
pppinput(bufor_posr[j]);
|
pppinput(bufor_posr[j]);
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
}
|
}
|
else
|
else
|
if (i!=0)rtems_termios_enqueue_raw_characters(modem_tty,bufor_posr,i);
|
if (i!=0)rtems_termios_enqueue_raw_characters(modem_tty,bufor_posr,i);
|
rtems_event_receive(INTERRUPT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
rtems_event_receive(INTERRUPT_EVENT,RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT,&events);
|
}
|
}
|
}
|
}
|
#define CLK_FREQ 1843200
|
#define CLK_FREQ 1843200
|
void set_modem_speed(int speed)
|
void set_modem_speed(int speed)
|
{
|
{
|
*LCR = (char)(DLAB);
|
*LCR = (char)(DLAB);
|
*DLL = (char)((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF);
|
*DLL = (char)((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF);
|
*DLM = (char)(((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF00) >> 8);
|
*DLM = (char)(((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF00) >> 8);
|
*LCR = (char)(WL_8 ); /* 8 bitowe slowo */
|
*LCR = (char)(WL_8 ); /* 8 bitowe slowo */
|
}
|
}
|
|
|
|
|
static void
|
static void
|
modem_init (int speed) /* port is the SMC number (i.e. 1 or 2) */
|
modem_init (int speed) /* port is the SMC number (i.e. 1 or 2) */
|
{
|
{
|
set_modem_speed(speed);
|
set_modem_speed(speed);
|
/* Line control setup */
|
/* Line control setup */
|
|
|
*LCR = (char)(WL_8 ); /* 8 bitowe slowo */
|
*LCR = (char)(WL_8 ); /* 8 bitowe slowo */
|
/* bylo NSB - bylo 2 jest 1*/
|
/* bylo NSB - bylo 2 jest 1*/
|
|
|
/* Interrupt setup */
|
/* Interrupt setup */
|
*IER = (char) 0x0f; /* enable transmit, receive, modem stat int */
|
*IER = (char) 0x0f; /* enable transmit, receive, modem stat int */
|
|
|
/* FIFO setup */
|
/* FIFO setup */
|
*FCR = (char)(FIFO_E | 0xc0);
|
*FCR = (char)(FIFO_E | 0xc0);
|
|
|
/* Modem control setup */
|
/* Modem control setup */
|
*MCR = (char) RTS|DTR|OUT2;
|
*MCR = (char) RTS|DTR|OUT2;
|
|
|
/* init tx_stop with CTS */
|
/* init tx_stop with CTS */
|
_tx_stop = ( (*MDSR & CTS) ? 0 : 1);
|
_tx_stop = ( (*MDSR & CTS) ? 0 : 1);
|
}
|
}
|
|
|
void set_modem_dtr(int how)
|
void set_modem_dtr(int how)
|
{
|
{
|
unsigned char znak;
|
unsigned char znak;
|
znak=*MCR;
|
znak=*MCR;
|
*MCR=(how)?(znak|DTR):(znak&(~DTR));
|
*MCR=(how)?(znak|DTR):(znak&(~DTR));
|
}
|
}
|
void modem_status()
|
void modem_status()
|
{
|
{
|
unsigned char status;
|
unsigned char status;
|
status=*MDSR;
|
status=*MDSR;
|
|
|
/* printf("Modem Status %x ",status);
|
/* printf("Modem Status %x ",status);
|
*/ if (status&CTS)
|
*/ if (status&CTS)
|
{
|
{
|
_tx_stop=0;
|
_tx_stop=0;
|
rtems_event_send (modem_tx_task, START_TRANSMIT_EVENT|INTERRUPT_EVENT);
|
rtems_event_send (modem_tx_task, START_TRANSMIT_EVENT|INTERRUPT_EVENT);
|
}
|
}
|
else
|
else
|
{
|
{
|
_tx_stop=1;
|
_tx_stop=1;
|
}
|
}
|
if (status&DCD)
|
if (status&DCD)
|
_modem_cd=1;
|
_modem_cd=1;
|
else
|
else
|
_modem_cd=0;
|
_modem_cd=0;
|
}
|
}
|
|
|
static rtems_isr
|
static rtems_isr
|
modemInterruptHandler (rtems_vector_number v)
|
modemInterruptHandler (rtems_vector_number v)
|
{
|
{
|
register char a,i,ch;
|
register char a,i,ch;
|
register int maxonce;
|
register int maxonce;
|
static errcount = 0;
|
static errcount = 0;
|
for(;;)
|
for(;;)
|
{
|
{
|
a=*IIR & (NIP | IID_MASK); /* read interrupt id register */
|
a=*IIR & (NIP | IID_MASK); /* read interrupt id register */
|
switch (a) {
|
switch (a) {
|
case 0x04: case 0x0c:
|
case 0x04: case 0x0c:
|
/*
|
/*
|
* Buffer received?
|
* Buffer received?
|
*/
|
*/
|
while( (*LSR & DR) != 0)
|
while( (*LSR & DR) != 0)
|
{
|
{
|
ch=*RBR;
|
ch=*RBR;
|
rcv_buf[(rcv_start+rcv_len)%MODEM_BUFFER_LENGTH]=ch;
|
rcv_buf[(rcv_start+rcv_len)%MODEM_BUFFER_LENGTH]=ch;
|
rcv_len++;
|
rcv_len++;
|
}
|
}
|
rtems_event_send (modem_rx_task, INTERRUPT_EVENT);
|
rtems_event_send (modem_rx_task, INTERRUPT_EVENT);
|
break;
|
break;
|
case 0x02:
|
case 0x02:
|
/*
|
/*
|
* Buffer transmitted ?
|
* Buffer transmitted ?
|
*/
|
*/
|
if (*LSR & THRE) //jezeli nie ma transmisji (a nie powinno byc) to wyslijmy bajty
|
if (*LSR & THRE) //jezeli nie ma transmisji (a nie powinno byc) to wyslijmy bajty
|
{
|
{
|
maxonce=(xmt_len>14)?14:xmt_len;
|
maxonce=(xmt_len>14)?14:xmt_len;
|
if (maxonce>0)
|
if (maxonce>0)
|
{
|
{
|
for (i=0;i<maxonce;i++)
|
for (i=0;i<maxonce;i++)
|
{
|
{
|
*THR=xmt_buf[xmt_start];
|
*THR=xmt_buf[xmt_start];
|
xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH;
|
xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH;
|
}
|
}
|
xmt_len-=maxonce;
|
xmt_len-=maxonce;
|
}
|
}
|
}
|
}
|
rtems_event_send (modem_tx_task, INTERRUPT_EVENT);
|
rtems_event_send (modem_tx_task, INTERRUPT_EVENT);
|
break;
|
break;
|
case 0x00:
|
case 0x00:
|
modem_status();
|
modem_status();
|
break;
|
break;
|
case 0x01:
|
case 0x01:
|
return;
|
return;
|
case 0x06:
|
case 0x06:
|
ch=*RBR;
|
ch=*RBR;
|
errcount++;
|
errcount++;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
void modem_flush(int mode)
|
void modem_flush(int mode)
|
{
|
{
|
if (mode&FWRITE)
|
if (mode&FWRITE)
|
{
|
{
|
}
|
}
|
if (mode&FREAD)
|
if (mode&FREAD)
|
{
|
{
|
}
|
}
|
|
|
}
|
}
|
|
|
|
|
|
|
int modemWriteTermios(int minor, const char *buf, int len)
|
int modemWriteTermios(int minor, const char *buf, int len)
|
{
|
{
|
int level;
|
int level;
|
int i,maxonce;
|
int i,maxonce;
|
if (len<=0)
|
if (len<=0)
|
return 0;
|
return 0;
|
|
|
if (ModemData.t_line!=PPPDISC)
|
if (ModemData.t_line!=PPPDISC)
|
{
|
{
|
_CPU_ISR_Disable(level);
|
_CPU_ISR_Disable(level);
|
for(i=0;i<len;i++)
|
for(i=0;i<len;i++)
|
{
|
{
|
if (xmt_len>=MODEM_BUFFER_LENGTH)
|
if (xmt_len>=MODEM_BUFFER_LENGTH)
|
break;
|
break;
|
xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=buf[i];
|
xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=buf[i];
|
xmt_len++;
|
xmt_len++;
|
}
|
}
|
_CPU_ISR_Enable(level);
|
_CPU_ISR_Enable(level);
|
}
|
}
|
rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT);
|
rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT);
|
return i;
|
return i;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Initialize and register the device
|
* Initialize and register the device
|
*/
|
*/
|
rtems_device_driver modem_initialize(
|
rtems_device_driver modem_initialize(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void *arg
|
void *arg
|
)
|
)
|
{
|
{
|
rtems_status_code status;
|
rtems_status_code status;
|
rtems_isr_entry old_handler;
|
rtems_isr_entry old_handler;
|
rtems_status_code sc;
|
rtems_status_code sc;
|
rtems_termios_initialize ();
|
rtems_termios_initialize ();
|
sc = rtems_semaphore_create (
|
sc = rtems_semaphore_create (
|
rtems_build_name ('M', 'D', 'M', 'P'),
|
rtems_build_name ('M', 'D', 'M', 'P'),
|
0,
|
0,
|
RTEMS_COUNTING_SEMAPHORE,
|
RTEMS_COUNTING_SEMAPHORE,
|
RTEMS_NO_PRIORITY_CEILING,
|
RTEMS_NO_PRIORITY_CEILING,
|
&ModemData.pppsem);
|
&ModemData.pppsem);
|
if (sc != RTEMS_SUCCESSFUL)
|
if (sc != RTEMS_SUCCESSFUL)
|
rtems_fatal_error_occurred (sc);
|
rtems_fatal_error_occurred (sc);
|
modem_init(9600);
|
modem_init(9600);
|
|
|
sc = rtems_interrupt_catch (modemInterruptHandler,
|
sc = rtems_interrupt_catch (modemInterruptHandler,
|
PPC_IRQ_IRQ4,
|
PPC_IRQ_IRQ4,
|
&old_handler);
|
&old_handler);
|
|
|
/*
|
/*
|
* Register the devices
|
* Register the devices
|
*/
|
*/
|
modem_tx_task=0;
|
modem_tx_task=0;
|
modem_rx_task=0;
|
modem_rx_task=0;
|
status = rtems_io_register_name ("/dev/modem", major, 0);
|
status = rtems_io_register_name ("/dev/modem", major, 0);
|
if (status != RTEMS_SUCCESSFUL)
|
if (status != RTEMS_SUCCESSFUL)
|
rtems_fatal_error_occurred (status);
|
rtems_fatal_error_occurred (status);
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
rtems_device_driver modem_first_open(
|
rtems_device_driver modem_first_open(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
modem_tty=(struct rtems_termios_tty *)(((rtems_libio_open_close_args_t *)arg)->iop->data1);
|
modem_tty=(struct rtems_termios_tty *)(((rtems_libio_open_close_args_t *)arg)->iop->data1);
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
rtems_device_driver modem_last_close(
|
rtems_device_driver modem_last_close(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
m823.siu.simask &=(~M823_SIMASK_IRM4); /* block the interrupts */
|
m823.siu.simask &=(~M823_SIMASK_IRM4); /* block the interrupts */
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
static int
|
static int
|
modemSetAttr(int minor, const struct termios *t)
|
modemSetAttr(int minor, const struct termios *t)
|
{
|
{
|
int baud;
|
int baud;
|
|
|
switch (t->c_cflag & CBAUD)
|
switch (t->c_cflag & CBAUD)
|
{
|
{
|
case B50:
|
case B50:
|
baud = 50;
|
baud = 50;
|
break;
|
break;
|
case B75:
|
case B75:
|
baud = 75;
|
baud = 75;
|
break;
|
break;
|
case B110:
|
case B110:
|
baud = 110;
|
baud = 110;
|
break;
|
break;
|
case B134:
|
case B134:
|
baud = 134;
|
baud = 134;
|
break;
|
break;
|
case B150:
|
case B150:
|
baud = 150;
|
baud = 150;
|
break;
|
break;
|
case B200:
|
case B200:
|
baud = 200;
|
baud = 200;
|
break;
|
break;
|
case B300:
|
case B300:
|
baud = 300;
|
baud = 300;
|
break;
|
break;
|
case B600:
|
case B600:
|
baud = 600;
|
baud = 600;
|
break;
|
break;
|
case B1200:
|
case B1200:
|
baud = 1200;
|
baud = 1200;
|
break;
|
break;
|
case B1800:
|
case B1800:
|
baud = 1800;
|
baud = 1800;
|
break;
|
break;
|
case B2400:
|
case B2400:
|
baud = 2400;
|
baud = 2400;
|
break;
|
break;
|
case B4800:
|
case B4800:
|
baud = 4800;
|
baud = 4800;
|
break;
|
break;
|
case B9600:
|
case B9600:
|
baud = 9600;
|
baud = 9600;
|
break;
|
break;
|
case B19200:
|
case B19200:
|
baud = 19200;
|
baud = 19200;
|
break;
|
break;
|
case B38400:
|
case B38400:
|
baud = 38400;
|
baud = 38400;
|
break;
|
break;
|
case B57600:
|
case B57600:
|
baud = 57600;
|
baud = 57600;
|
break;
|
break;
|
case B115200:
|
case B115200:
|
baud = 115200;
|
baud = 115200;
|
break;
|
break;
|
default:
|
default:
|
baud = 0;
|
baud = 0;
|
rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
|
rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
|
return 0;
|
return 0;
|
}
|
}
|
set_modem_speed(baud);
|
set_modem_speed(baud);
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
|
|
/*
|
/*
|
* Open the device
|
* Open the device
|
*/
|
*/
|
|
|
|
|
|
|
rtems_device_driver modem_open(
|
rtems_device_driver modem_open(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
int error, s;
|
int error, s;
|
rtems_status_code status;
|
rtems_status_code status;
|
register struct ppp_softc *sc;
|
register struct ppp_softc *sc;
|
static rtems_termios_callbacks cb =
|
static rtems_termios_callbacks cb =
|
{
|
{
|
modem_first_open, /* firstOpen */
|
modem_first_open, /* firstOpen */
|
modem_last_close, /* lastClose */
|
modem_last_close, /* lastClose */
|
NULL, /* poll read */
|
NULL, /* poll read */
|
modemWriteTermios, /* write */
|
modemWriteTermios, /* write */
|
modemSetAttr, /* setAttributes */
|
modemSetAttr, /* setAttributes */
|
NULL, /* stopRemoteTx */
|
NULL, /* stopRemoteTx */
|
NULL, /* startRemoteTx */
|
NULL, /* startRemoteTx */
|
0 /* outputUsesInterrupts */
|
0 /* outputUsesInterrupts */
|
};
|
};
|
|
|
if (ModemData.t_line == PPPDISC)
|
if (ModemData.t_line == PPPDISC)
|
{
|
{
|
sc = ModemData.t_sc;
|
sc = ModemData.t_sc;
|
if (sc != NULL && sc->sc_devp == (void *) &ModemData)
|
if (sc != NULL && sc->sc_devp == (void *) &ModemData)
|
{
|
{
|
return (0);
|
return (0);
|
}
|
}
|
}
|
}
|
|
|
if ((ModemData.t_sc= sc = pppalloc(1)) == NULL)
|
if ((ModemData.t_sc= sc = pppalloc(1)) == NULL)
|
return 2;
|
return 2;
|
|
|
if (sc->sc_relinq)
|
if (sc->sc_relinq)
|
(*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */
|
(*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */
|
|
|
sc->sc_ilen = 0;
|
sc->sc_ilen = 0;
|
sc->sc_m = NULL;
|
sc->sc_m = NULL;
|
bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
|
bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
|
sc->sc_asyncmap[0] = 0xffffffff;
|
sc->sc_asyncmap[0] = 0xffffffff;
|
sc->sc_asyncmap[3] = 0x60000000;
|
sc->sc_asyncmap[3] = 0x60000000;
|
sc->sc_rasyncmap = 0;
|
sc->sc_rasyncmap = 0;
|
sc->sc_devp = &ModemData;
|
sc->sc_devp = &ModemData;
|
sc->sc_start = pppasyncstart;
|
sc->sc_start = pppasyncstart;
|
sc->sc_ctlp = pppasyncctlp;
|
sc->sc_ctlp = pppasyncctlp;
|
sc->sc_relinq = pppasyncrelinq;
|
sc->sc_relinq = pppasyncrelinq;
|
sc->sc_outm = NULL;
|
sc->sc_outm = NULL;
|
pppgetm(sc);
|
pppgetm(sc);
|
sc->sc_if.if_flags |= IFF_RUNNING;
|
sc->sc_if.if_flags |= IFF_RUNNING;
|
sc->sc_if.if_baudrate = 38400;
|
sc->sc_if.if_baudrate = 38400;
|
|
|
status = rtems_termios_open (major, minor, arg, &cb);
|
status = rtems_termios_open (major, minor, arg, &cb);
|
if(status != RTEMS_SUCCESSFUL)
|
if(status != RTEMS_SUCCESSFUL)
|
{
|
{
|
/* printf("Error openning console device\n");
|
/* printf("Error openning console device\n");
|
*/ return status;
|
*/ return status;
|
}
|
}
|
|
|
|
|
/* init rx and tx task for device */
|
/* init rx and tx task for device */
|
xmt_start=xmt_len=0;
|
xmt_start=xmt_len=0;
|
rcv_start=rcv_len=0;
|
rcv_start=rcv_len=0;
|
|
|
if (modem_rx_task==0 && modem_tx_task==0)
|
if (modem_rx_task==0 && modem_tx_task==0)
|
{
|
{
|
rtems_status_code sc;
|
rtems_status_code sc;
|
sc = rtems_task_create (rtems_build_name ('M', 'D', 't', 'x'),
|
sc = rtems_task_create (rtems_build_name ('M', 'D', 't', 'x'),
|
101,
|
101,
|
16*1024,
|
16*1024,
|
RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
|
RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
|
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
|
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
|
&modem_tx_task);
|
&modem_tx_task);
|
if (sc != RTEMS_SUCCESSFUL) {
|
if (sc != RTEMS_SUCCESSFUL) {
|
|
|
}
|
}
|
|
|
sc = rtems_task_start (modem_tx_task, (void *)modem_txDaemon, 0);
|
sc = rtems_task_start (modem_tx_task, (void *)modem_txDaemon, 0);
|
if (sc != RTEMS_SUCCESSFUL) {
|
if (sc != RTEMS_SUCCESSFUL) {
|
|
|
}
|
}
|
|
|
sc = rtems_task_create (rtems_build_name ('M', 'D', 'r', 'x'),
|
sc = rtems_task_create (rtems_build_name ('M', 'D', 'r', 'x'),
|
101,
|
101,
|
16*1024,
|
16*1024,
|
RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
|
RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0),
|
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
|
RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL,
|
&modem_rx_task);
|
&modem_rx_task);
|
if (sc != RTEMS_SUCCESSFUL) {
|
if (sc != RTEMS_SUCCESSFUL) {
|
|
|
}
|
}
|
|
|
sc = rtems_task_start (modem_rx_task, (void *)modem_rxDaemon, 0);
|
sc = rtems_task_start (modem_rx_task, (void *)modem_rxDaemon, 0);
|
if (sc != RTEMS_SUCCESSFUL) {
|
if (sc != RTEMS_SUCCESSFUL) {
|
|
|
}
|
}
|
|
|
}
|
}
|
/* Enable modem interrupts */
|
/* Enable modem interrupts */
|
m823.siu.simask |= M823_SIMASK_IRM4;
|
m823.siu.simask |= M823_SIMASK_IRM4;
|
|
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
/*
|
/*
|
* Close the device
|
* Close the device
|
*/
|
*/
|
rtems_device_driver modem_close(
|
rtems_device_driver modem_close(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
register struct ppp_softc *sc;
|
register struct ppp_softc *sc;
|
modem_flush( FREAD|FWRITE);
|
modem_flush( FREAD|FWRITE);
|
|
|
ModemData.t_line = 0;
|
ModemData.t_line = 0;
|
sc = ModemData.t_sc;
|
sc = ModemData.t_sc;
|
if (sc != NULL) {
|
if (sc != NULL) {
|
ModemData.t_sc = NULL;
|
ModemData.t_sc = NULL;
|
if (&ModemData == (struct tty *) sc->sc_devp) {
|
if (&ModemData == (struct tty *) sc->sc_devp) {
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
pppasyncrelinq(sc);
|
pppasyncrelinq(sc);
|
pppdealloc(sc);
|
pppdealloc(sc);
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
}
|
}
|
}
|
}
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
/* for now works only as serial device */
|
/* for now works only as serial device */
|
|
|
|
|
rtems_device_driver modem_read(
|
rtems_device_driver modem_read(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
rtems_libio_rw_args_t *rw_args= (rtems_libio_rw_args_t *)arg;
|
rtems_libio_rw_args_t *rw_args= (rtems_libio_rw_args_t *)arg;
|
char *buffer;
|
char *buffer;
|
int count=0,maximum;
|
int count=0,maximum;
|
rtems_status_code sc;
|
rtems_status_code sc;
|
|
|
buffer = rw_args->buffer;
|
buffer = rw_args->buffer;
|
maximum = rw_args->count;
|
maximum = rw_args->count;
|
if (ModemData.t_line==PPPDISC)
|
if (ModemData.t_line==PPPDISC)
|
{
|
{
|
|
|
struct mbuf *m, *m0;
|
struct mbuf *m, *m0;
|
register int s;
|
register int s;
|
int error = 0;
|
int error = 0;
|
rtems_status_code status;
|
rtems_status_code status;
|
rtems_interval ticks;
|
rtems_interval ticks;
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
ticks=1000000/rtems_bsdnet_microseconds_per_tick;
|
ticks=1000000/rtems_bsdnet_microseconds_per_tick;
|
|
|
if (sc == NULL)
|
if (sc == NULL)
|
return 0;
|
return 0;
|
/*
|
/*
|
* Loop waiting for input, checking that nothing disasterous
|
* Loop waiting for input, checking that nothing disasterous
|
* happens in the meantime.
|
* happens in the meantime.
|
*/
|
*/
|
for (;;) {
|
for (;;) {
|
if (sc->sc_inq.ifq_head != NULL)
|
if (sc->sc_inq.ifq_head != NULL)
|
{
|
{
|
/* printf("Read : Dane sa w buforze\n");
|
/* printf("Read : Dane sa w buforze\n");
|
*/ break;
|
*/ break;
|
}
|
}
|
/* printf("Read : Czekam na dane\n");
|
/* printf("Read : Czekam na dane\n");
|
*/
|
*/
|
status=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks);
|
status=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks);
|
if (_modem_cd==0)
|
if (_modem_cd==0)
|
{
|
{
|
rw_args->bytes_moved =0;
|
rw_args->bytes_moved =0;
|
return RTEMS_SUCCESSFUL;
|
return RTEMS_SUCCESSFUL;
|
}
|
}
|
|
|
if (status==RTEMS_TIMEOUT)
|
if (status==RTEMS_TIMEOUT)
|
return status;
|
return status;
|
}
|
}
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
IF_DEQUEUE(&sc->sc_inq, m0);
|
IF_DEQUEUE(&sc->sc_inq, m0);
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
|
|
for (m = m0; m && (count+m->m_next->m_len<maximum); m = m->m_next) /* check if packet will fit in buffer */
|
for (m = m0; m && (count+m->m_next->m_len<maximum); m = m->m_next) /* check if packet will fit in buffer */
|
{
|
{
|
memcpy(buffer,mtod(m, u_char *),m->m_len);
|
memcpy(buffer,mtod(m, u_char *),m->m_len);
|
count+=m->m_len;
|
count+=m->m_len;
|
buffer+=m->m_len;
|
buffer+=m->m_len;
|
}
|
}
|
m_freem(m0);
|
m_freem(m0);
|
rw_args->bytes_moved = count;
|
rw_args->bytes_moved = count;
|
|
|
}
|
}
|
else
|
else
|
sc = rtems_termios_read (arg);
|
sc = rtems_termios_read (arg);
|
|
|
count=rw_args->bytes_moved;
|
count=rw_args->bytes_moved;
|
return (count >= 0) ? RTEMS_SUCCESSFUL : RTEMS_UNSATISFIED;
|
return (count >= 0) ? RTEMS_SUCCESSFUL : RTEMS_UNSATISFIED;
|
}
|
}
|
|
|
/*
|
/*
|
* Write to the device
|
* Write to the device
|
*/
|
*/
|
rtems_device_driver modem_write(
|
rtems_device_driver modem_write(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
int count,len;
|
int count,len;
|
rtems_libio_rw_args_t *rw_args;
|
rtems_libio_rw_args_t *rw_args;
|
char *out_buffer;
|
char *out_buffer;
|
int n,maximum;
|
int n,maximum;
|
rw_args = (rtems_libio_rw_args_t *) arg;
|
rw_args = (rtems_libio_rw_args_t *) arg;
|
|
|
out_buffer = rw_args->buffer;
|
out_buffer = rw_args->buffer;
|
maximum = rw_args->count;
|
maximum = rw_args->count;
|
|
|
if (ModemData.t_line==PPPDISC)
|
if (ModemData.t_line==PPPDISC)
|
{
|
{
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
struct sockaddr dst;
|
struct sockaddr dst;
|
struct mbuf *m, *m0, **mp;
|
struct mbuf *m, *m0, **mp;
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
for (mp = &m0; maximum; mp = &m->m_next)
|
for (mp = &m0; maximum; mp = &m->m_next)
|
{
|
{
|
MGET(m, M_WAIT, MT_DATA);
|
MGET(m, M_WAIT, MT_DATA);
|
if ((*mp = m) == NULL)
|
if ((*mp = m) == NULL)
|
{
|
{
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
m_freem(m0);
|
m_freem(m0);
|
return (ENOBUFS);
|
return (ENOBUFS);
|
}
|
}
|
m->m_len = 0;
|
m->m_len = 0;
|
if (maximum>= MCLBYTES / 2)
|
if (maximum>= MCLBYTES / 2)
|
MCLGET(m, M_DONTWAIT);
|
MCLGET(m, M_DONTWAIT);
|
len = M_TRAILINGSPACE(m);
|
len = M_TRAILINGSPACE(m);
|
if (len > maximum)
|
if (len > maximum)
|
{
|
{
|
memcpy(mtod(m, u_char *),out_buffer,maximum);
|
memcpy(mtod(m, u_char *),out_buffer,maximum);
|
m->m_len=maximum;
|
m->m_len=maximum;
|
maximum=0;
|
maximum=0;
|
}
|
}
|
else
|
else
|
{
|
{
|
memcpy(mtod(m, u_char *),out_buffer,len);
|
memcpy(mtod(m, u_char *),out_buffer,len);
|
maximum-=len;
|
maximum-=len;
|
m->m_len=len;
|
m->m_len=len;
|
out_buffer+=len;
|
out_buffer+=len;
|
}
|
}
|
}
|
}
|
|
|
dst.sa_family = AF_UNSPEC;
|
dst.sa_family = AF_UNSPEC;
|
bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN);
|
bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN);
|
m0->m_data += PPP_HDRLEN;
|
m0->m_data += PPP_HDRLEN;
|
m0->m_len -= PPP_HDRLEN;
|
m0->m_len -= PPP_HDRLEN;
|
|
|
/* printf("Wysylam %d bajtow \n",m0->m_len);
|
/* printf("Wysylam %d bajtow \n",m0->m_len);
|
*/ n=pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0);
|
*/ n=pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0);
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
return n;
|
return n;
|
}
|
}
|
else
|
else
|
return rtems_termios_write (arg);
|
return rtems_termios_write (arg);
|
}
|
}
|
|
|
|
|
|
|
/*
|
/*
|
* Handle ioctl request.
|
* Handle ioctl request.
|
* Should set hardware line speed, bits/char, etc.
|
* Should set hardware line speed, bits/char, etc.
|
*/
|
*/
|
rtems_device_driver modem_control(
|
rtems_device_driver modem_control(
|
rtems_device_major_number major,
|
rtems_device_major_number major,
|
rtems_device_minor_number minor,
|
rtems_device_minor_number minor,
|
void * arg
|
void * arg
|
)
|
)
|
{
|
{
|
rtems_libio_ioctl_args_t *args=(rtems_libio_ioctl_args_t *)arg;
|
rtems_libio_ioctl_args_t *args=(rtems_libio_ioctl_args_t *)arg;
|
struct ppp_softc *sc=ModemData.t_sc;
|
struct ppp_softc *sc=ModemData.t_sc;
|
int cmd;
|
int cmd;
|
caddr_t data;
|
caddr_t data;
|
int error=RTEMS_SUCCESSFUL;
|
int error=RTEMS_SUCCESSFUL;
|
|
|
data=args->buffer;
|
data=args->buffer;
|
cmd=args->command;
|
cmd=args->command;
|
|
|
switch (cmd) {
|
switch (cmd) {
|
case RTEMS_IO_GET_ATTRIBUTES:
|
case RTEMS_IO_GET_ATTRIBUTES:
|
case RTEMS_IO_SET_ATTRIBUTES:
|
case RTEMS_IO_SET_ATTRIBUTES:
|
case RTEMS_IO_TCDRAIN:
|
case RTEMS_IO_TCDRAIN:
|
return rtems_termios_ioctl (arg);
|
return rtems_termios_ioctl (arg);
|
break;
|
break;
|
case PPPIOCSASYNCMAP:
|
case PPPIOCSASYNCMAP:
|
sc->sc_asyncmap[0] = *(u_int *)data;
|
sc->sc_asyncmap[0] = *(u_int *)data;
|
break;
|
break;
|
|
|
case PPPIOCGASYNCMAP:
|
case PPPIOCGASYNCMAP:
|
*(u_int *)data = sc->sc_asyncmap[0];
|
*(u_int *)data = sc->sc_asyncmap[0];
|
break;
|
break;
|
|
|
case PPPIOCSRASYNCMAP:
|
case PPPIOCSRASYNCMAP:
|
sc->sc_rasyncmap = *(u_int *)data;
|
sc->sc_rasyncmap = *(u_int *)data;
|
break;
|
break;
|
|
|
case TIOCSETD:
|
case TIOCSETD:
|
ModemData.t_line=*(int*)data;
|
ModemData.t_line=*(int*)data;
|
break;
|
break;
|
case TIOCGETD:
|
case TIOCGETD:
|
*(int*)data=ModemData.t_line;
|
*(int*)data=ModemData.t_line;
|
break;
|
break;
|
case TIOCMBIS:
|
case TIOCMBIS:
|
if ((*(int*)data)&TIOCM_DTR)
|
if ((*(int*)data)&TIOCM_DTR)
|
set_modem_dtr(1);
|
set_modem_dtr(1);
|
break;
|
break;
|
case TIOCMBIC:
|
case TIOCMBIC:
|
if ((*(int*)data)&TIOCM_DTR)
|
if ((*(int*)data)&TIOCM_DTR)
|
set_modem_dtr(0);
|
set_modem_dtr(0);
|
break;
|
break;
|
case PPPIOCGRASYNCMAP:
|
case PPPIOCGRASYNCMAP:
|
*(u_int *)data = sc->sc_rasyncmap;
|
*(u_int *)data = sc->sc_rasyncmap;
|
break;
|
break;
|
|
|
case PPPIOCSXASYNCMAP:
|
case PPPIOCSXASYNCMAP:
|
bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
|
bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
|
sc->sc_asyncmap[1] = 0; /* mustn't escape 0x20 - 0x3f */
|
sc->sc_asyncmap[1] = 0; /* mustn't escape 0x20 - 0x3f */
|
sc->sc_asyncmap[2] &= ~0x40000000; /* mustn't escape 0x5e */
|
sc->sc_asyncmap[2] &= ~0x40000000; /* mustn't escape 0x5e */
|
sc->sc_asyncmap[3] |= 0x60000000; /* must escape 0x7d, 0x7e */
|
sc->sc_asyncmap[3] |= 0x60000000; /* must escape 0x7d, 0x7e */
|
break;
|
break;
|
|
|
case PPPIOCGXASYNCMAP:
|
case PPPIOCGXASYNCMAP:
|
bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
|
bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
|
break;
|
break;
|
|
|
default:
|
default:
|
rtems_bsdnet_semaphore_obtain();
|
rtems_bsdnet_semaphore_obtain();
|
error = pppioctl(sc, cmd, data, 0, NULL);
|
error = pppioctl(sc, cmd, data, 0, NULL);
|
if (error == 0 && cmd == PPPIOCSMRU)
|
if (error == 0 && cmd == PPPIOCSMRU)
|
pppgetm(sc);
|
pppgetm(sc);
|
rtems_bsdnet_semaphore_release();
|
rtems_bsdnet_semaphore_release();
|
|
|
}
|
}
|
return error;
|
return error;
|
|
|
}
|
}
|
|
|
|
|
|
|
void
|
void
|
wait_input(timo)
|
wait_input(timo)
|
struct timeval *timo;
|
struct timeval *timo;
|
{
|
{
|
int n;
|
int n;
|
rtems_event_set events;
|
rtems_event_set events;
|
rtems_interval ticks;
|
rtems_interval ticks;
|
rtems_status_code err;
|
rtems_status_code err;
|
int czekaj=1;
|
int czekaj=1;
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc;
|
ticks = 1+(timo->tv_sec*1000000+timo->tv_usec)/rtems_bsdnet_microseconds_per_tick;
|
ticks = 1+(timo->tv_sec*1000000+timo->tv_usec)/rtems_bsdnet_microseconds_per_tick;
|
while (czekaj)
|
while (czekaj)
|
{
|
{
|
|
|
if (sc->sc_inq.ifq_head != NULL)
|
if (sc->sc_inq.ifq_head != NULL)
|
break;
|
break;
|
/* printf("Wait : Czekam na dane przez %d ticks\n",ticks);
|
/* printf("Wait : Czekam na dane przez %d ticks\n",ticks);
|
*/ err=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks);
|
*/ err=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks);
|
if (err==RTEMS_TIMEOUT)
|
if (err==RTEMS_TIMEOUT)
|
{
|
{
|
/* printf("TIMEOUT :Brak danych\n");
|
/* printf("TIMEOUT :Brak danych\n");
|
*/ break;
|
*/ break;
|
}
|
}
|
}
|
}
|
|
|
}
|
}
|
|
|
