URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libnetworking/] [pppd/] [modem_example/] [modem.c] - Rev 543
Go to most recent revision | Compare with Previous | Blame | View Log
/* * Modem device driver for RTEMS * Author: Tomasz Domin (dot@comarch.pl) * Copyright (C) 1998 by ComArch SA * Driver will use termios for character output and ppp specific out procecedures for network protocols */ #include <bsp.h> #include <rtems.h> #include <rtems/libio.h> #include <sys/ttycom.h> #include <unistd.h> #include <sys/errno.h> #include <rtems/rtems/event.h> #include <rtems/rtems/tasks.h> #include <mpc823.h> #include <sys/param.h> #include <sys/systm.h> #include <sys/proc.h> #include <sys/mbuf.h> #include <sys/socket.h> #include <sys/ioctl.h> #include <sys/file.h> #include <sys/kernel.h> #include <sys/conf.h> #include <net/if.h> #include <net/ppp_defs.h> #include <sys/fcntl.h> #include "ppp.h" #include <net/if_pppvar.h> #include <net/if_ppp.h> /* RTEMS specific */ rtems_id modem_task_id; #include "16550.h" #include <mpc823.h> #define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F))) #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT) #define M_DATASTART(m) \ (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \ (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat) #define M_DATASIZE(m) \ (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \ (m)->m_flags & M_PKTHDR ? MHLEN: MLEN) struct rtems_termios_tty *modem_tty; /* * RTEMS event used by interrupt handler to signal daemons. * This must *not* be the same event used by the KA9Q task synchronization. */ #define INTERRUPT_EVENT RTEMS_EVENT_1 #define START_TRANSMIT_EVENT RTEMS_EVENT_2 #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 */ /* * RTEMS event used to start transmit daemon. * This must not be the same as INTERRUPT_EVENT. */ /*static struct modem_tty *tp=&modem_tp;*/ static rtems_id modem_rx_task,modem_tx_task; /* internal FIFO buffers for input and output characters */ #define MODEM_BUFFER_LENGTH 4096 #define RTS_STOP_SIZE MODEM_BUFFER_LENGTH-128 #define RTS_START_SIZE 16 int xmt_start,xmt_len; int rcv_start,rcv_len; static unsigned char xmt_buf[MODEM_BUFFER_LENGTH]; static unsigned char rcv_buf[MODEM_BUFFER_LENGTH]; static volatile char _tx_stop = 0 ,_modem_cd=0; struct ModemData { int t_line; struct ppp_softc *t_sc; rtems_id pppsem; int offhook; } ModemData; int pppstart(struct tty *ignore); static u_short fcstab[256] = { 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 u_short pppfcs(fcs, cp, len) register u_short fcs; register u_char *cp; register int len; { while (len--) fcs = PPP_FCS(fcs, *cp++); return (fcs); } static void ppp_timeout(x) void *x; { struct ppp_softc *sc = ModemData.t_sc; struct tty *tp = (struct tty *) sc->sc_devp; int s; sc->sc_flags &= ~SC_TIMEOUT; pppstart(tp); } static void pppasyncrelinq(sc) struct ppp_softc *sc; { int s; if (sc->sc_outm) { m_freem(sc->sc_outm); sc->sc_outm = NULL; } if (sc->sc_m) { m_freem(sc->sc_m); sc->sc_m = NULL; } if (sc->sc_flags & SC_TIMEOUT) { untimeout(ppp_timeout, (void *) sc); sc->sc_flags &= ~SC_TIMEOUT; } } /* Put data in input queue */ int pppstart(struct tty *ignore) { register struct ppp_softc *sc = ModemData.t_sc; /* * 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. */ rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT); sc->sc_if.if_flags |= IFF_OACTIVE; /* * 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 * we need more output. */ /* if (CCOUNT(&tp->t_outq) < PPP_LOWAT && !((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) && sc != NULL && tp == (struct tty *) sc->sc_devp) { ppp_restart(sc); } */ return 0; } int putc(unsigned char c) { int level; if (xmt_len<MODEM_BUFFER_LENGTH-1) { _CPU_ISR_Disable(level); xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=c; xmt_len++; _CPU_ISR_Enable(level); return 0; } return 1; } void unputc(void) { int level; if (xmt_len==0) return; _CPU_ISR_Disable(level); xmt_len--; _CPU_ISR_Enable(level); } static void pppasyncstart(sc) register struct ppp_softc *sc; { /* Call pppstart to start output again if necessary. */ pppstart(sc->sc_devp); /* * This timeout is needed for operation on a pseudo-tty, * because the pty code doesn't call pppstart after it has * drained the t_outq. */ /* if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) { timeout(ppp_timeout, (void *) sc, 1); sc->sc_flags |= SC_TIMEOUT; } */ } void modem_sendpacket() { struct mbuf *l = NULL; rtems_unsigned16 status; int curr; register struct mbuf *m; register int len; register u_char *start, *stop, *cp; int n, ndone, done, idle; struct mbuf *m2; int s; register struct ppp_softc *sc=ModemData.t_sc; while (xmt_len < PPP_HIWAT) { /* * See if we have an existing packet partly sent. * If not, get a new packet and start sending it. */ m = sc->sc_outm; if (m == NULL) { /* * Get another packet to be sent. */ m = ppp_dequeue(sc); if (m == NULL) { break; } /* * The extra PPP_FLAG will start up a new packet, and thus * will flush any accumulated garbage. We do this whenever * the line may have been idle for some time. */ if (xmt_len == 0) { ++sc->sc_stats.ppp_obytes; putc(PPP_FLAG); } /* Calculate the FCS for the first mbuf's worth. */ sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len); microtime(&sc->sc_if.if_lastchange); } for (;;) { start = mtod(m, u_char *); len = m->m_len; stop = start + len; while (len > 0) { /* * Find out how many bytes in the string we can * handle without doing something special. */ for (cp = start; cp < stop; cp++) if (ESCAPE_P(*cp)) break; n = cp - start; if (n) { register int i; /* NetBSD (0.9 or later), 4.3-Reno or similar. */ for(i=0;i<n;i++) if (putc(start[i])) break; ndone = i; len -= ndone; start += ndone; sc->sc_stats.ppp_obytes += ndone; if (ndone < n) break; /* packet doesn't fit */ } /* * If there are characters left in the mbuf, * the first one must be special. * Put it out in a different form. */ if (len) { if (putc(PPP_ESCAPE)) break; if (putc(*start ^ PPP_TRANS)) { unputc(); break; } sc->sc_stats.ppp_obytes += 2; start++; len--; } } /* * 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 * 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. */ done = len == 0; if (done && m->m_next == NULL) { u_char *p, *q; int c; u_char endseq[8]; /* * We may have to escape the bytes in the FCS. */ p = endseq; c = ~sc->sc_outfcs & 0xFF; if (ESCAPE_P(c)) { *p++ = PPP_ESCAPE; *p++ = c ^ PPP_TRANS; } else *p++ = c; c = (~sc->sc_outfcs >> 8) & 0xFF; if (ESCAPE_P(c)) { *p++ = PPP_ESCAPE; *p++ = c ^ PPP_TRANS; } else *p++ = c; *p++ = PPP_FLAG; /* * Try to output the FCS and flag. If the bytes * don't all fit, back out. */ for (q = endseq; q < p; ++q) if (putc(*q)) { done = 0; for (; q > endseq; --q) unputc(); break; } if (done) sc->sc_stats.ppp_obytes += q - endseq; } if (!done) { /* remember where we got to */ m->m_data = start; m->m_len = len; break; } /* Finished with this mbuf; free it and move on. */ MFREE(m, m2); m = m2; if (m == NULL) { /* Finished a packet */ break; } 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've either done as much work this time * as we need to, or else we've filled up the output queue. */ sc->sc_outm = m; if (m) break; } } static void pppasyncctlp(sc) struct ppp_softc *sc; { rtems_semaphore_release(ModemData.pppsem); } static unsigned paritytab[8] = { 0x96696996, 0x69969669, 0x69969669, 0x96696996, 0x69969669, 0x96696996, 0x96696996, 0x69969669 }; #define MAX_DUMP_BYTES 128 static void pppdumpb(b, l) u_char *b; int l; { char buf[3*MAX_DUMP_BYTES+4]; char *bp = buf; static char digits[] = "0123456789abcdef"; while (l--) { if (bp >= buf + sizeof(buf) - 3) { *bp++ = '>'; break; } *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */ *bp++ = digits[*b++ & 0xf]; *bp++ = ' '; } *bp = 0; } static void ppplogchar(sc, c) struct ppp_softc *sc; int c; { if (c >= 0) sc->sc_rawin[sc->sc_rawin_count++] = c; if (sc->sc_rawin_count >= sizeof(sc->sc_rawin) || (c < 0 && sc->sc_rawin_count > 0)) { /* printf("ppp%d input: ", sc->sc_if.if_unit); */ pppdumpb(sc->sc_rawin, sc->sc_rawin_count); sc->sc_rawin_count = 0; } } static void pppgetm(sc) register struct ppp_softc *sc; { struct mbuf *m, **mp; int len; mp = &sc->sc_m; for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ if ((m = *mp) == NULL) { MGETHDR(m, M_DONTWAIT, MT_DATA); if (m == NULL) break; *mp = m; MCLGET(m, M_DONTWAIT); } len -= M_DATASIZE(m); mp = &m->m_next; } } int pppinput(c) int c; { register struct ppp_softc *sc=ModemData.t_sc; struct mbuf *m; int ilen, s; if (sc == NULL ) return 0; ++sc->sc_stats.ppp_ibytes; /* if (c & TTY_FE) {*/ /* framing error or overrun on this char - abort packet */ /* if (sc->sc_flags & SC_DEBUG) printf("ppp%d: bad char %x\n", sc->sc_if.if_unit, c); goto flush; }*/ c &= 0xff; /* * Handle software flow control of output. */ /* if (tp->t_iflag & IXON) { if (c == tp->t_cc[VSTOP] ) { if ((tp->t_state & TS_TTSTOP) == 0) { tp->t_state |= TS_TTSTOP; sccppp_stop_transmission(tp); } return 0; } if (c == tp->t_cc[VSTART] ) { tp->t_state &= ~TS_TTSTOP; sccppp_start_transmission(tp); return 0; } } */ if (c & 0x80) sc->sc_flags |= SC_RCV_B7_1; else sc->sc_flags |= SC_RCV_B7_0; if (paritytab[c >> 5] & (1 << (c & 0x1F))) sc->sc_flags |= SC_RCV_ODDP; else sc->sc_flags |= SC_RCV_EVNP; /* if (sc->sc_flags & SC_LOG_RAWIN)*/ // ppplogchar(sc, c); if (c == PPP_FLAG) { ilen = sc->sc_ilen; sc->sc_ilen = 0; if (sc->sc_rawin_count > 0) ppplogchar(sc, -1); /* * If SC_ESCAPED is set, then we've seen the packet * abort sequence */ if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED) || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) { sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */ if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){ if (sc->sc_flags & SC_DEBUG) printf("ppp%d: bad fcs %x, pkt len %d\n", sc->sc_if.if_unit, sc->sc_fcs, ilen); sc->sc_if.if_ierrors++; sc->sc_stats.ppp_ierrors++; } else sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED); return 0; } if (ilen < PPP_HDRLEN + PPP_FCSLEN) { if (ilen) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen); */ sc->sc_if.if_ierrors++; sc->sc_stats.ppp_ierrors++; sc->sc_flags |= SC_PKTLOST; splx(s); } return 0; } /* * Remove FCS trailer. Somewhat painful... */ ilen -= 2; if (--sc->sc_mc->m_len == 0) { for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next) ; sc->sc_mc = m; } sc->sc_mc->m_len--; /* excise this mbuf chain */ m = sc->sc_m; sc->sc_m = sc->sc_mc->m_next; sc->sc_mc->m_next = NULL; ppppktin(sc, m, sc->sc_flags & SC_PKTLOST); if (sc->sc_flags & SC_PKTLOST) { sc->sc_flags &= ~SC_PKTLOST; } pppgetm(sc); return 0; } if (sc->sc_flags & SC_FLUSH) { if (sc->sc_flags & SC_LOG_FLUSH) ppplogchar(sc, c); return 0; } if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) return 0; if (sc->sc_flags & SC_ESCAPED) { sc->sc_flags &= ~SC_ESCAPED; c ^= PPP_TRANS; } else if (c == PPP_ESCAPE) { sc->sc_flags |= SC_ESCAPED; return 0; } /* * Initialize buffer on first octet received. * First octet could be address or protocol (when compressing * address/control). * Second octet is control. * Third octet is first or second (when compressing protocol) * octet of protocol. * Fourth octet is second octet of protocol. */ if (sc->sc_ilen == 0) { /* reset the first input mbuf */ if (sc->sc_m == NULL) { pppgetm(sc); if (sc->sc_m == NULL) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit); */ goto flush; } } m = sc->sc_m; m->m_len = 0; m->m_data = M_DATASTART(sc->sc_m); sc->sc_mc = m; sc->sc_mp = mtod(m, char *); sc->sc_fcs = PPP_INITFCS; if (c != PPP_ALLSTATIONS) { if (sc->sc_flags & SC_REJ_COMP_AC) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: garbage received: 0x%x (need 0xFF)\n", sc->sc_if.if_unit, c);*/ goto flush; } *sc->sc_mp++ = PPP_ALLSTATIONS; *sc->sc_mp++ = PPP_UI; sc->sc_ilen += 2; m->m_len += 2; } } if (sc->sc_ilen == 1 && c != PPP_UI) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: missing UI (0x3), got 0x%x\n", sc->sc_if.if_unit, c); */ goto flush; } if (sc->sc_ilen == 2 && (c & 1) == 1) { /* a compressed protocol */ *sc->sc_mp++ = 0; sc->sc_ilen++; sc->sc_mc->m_len++; } if (sc->sc_ilen == 3 && (c & 1) == 0) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit, (sc->sc_mp[-1] << 8) + c); */ goto flush; } /* packet beyond configured mru? */ if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: packet too big\n", sc->sc_if.if_unit); */ goto flush; } /* is this mbuf full? */ m = sc->sc_mc; if (M_TRAILINGSPACE(m) <= 0) { if (m->m_next == NULL) { pppgetm(sc); if (m->m_next == NULL) { if (sc->sc_flags & SC_DEBUG) /* printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit); */ goto flush; } } sc->sc_mc = m = m->m_next; m->m_len = 0; m->m_data = M_DATASTART(m); sc->sc_mp = mtod(m, char *); } ++m->m_len; *sc->sc_mp++ = c; sc->sc_fcs = PPP_FCS(sc->sc_fcs, c); return 0; flush: if (!(sc->sc_flags & SC_FLUSH)) { sc->sc_if.if_ierrors++; sc->sc_stats.ppp_ierrors++; sc->sc_flags |= SC_FLUSH; if (sc->sc_flags & SC_LOG_FLUSH) ppplogchar(sc, c); } return 0; } void modem_txDaemon (void *arg) { rtems_event_set events; register int level,i,maxonce; while (1) { 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); /* wait for transmit buffer to become empty */ 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); _CPU_ISR_Disable(level); if (*LSR & THRE) //jezeli nie ma transmisji to wyslijmy pierwsze bajty, jezeli jest, same pojda { maxonce=(xmt_len>14)?14:xmt_len; if (maxonce>0) { for (i=0;i<maxonce;i++) { *THR=xmt_buf[xmt_start]; xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH; } xmt_len-=maxonce; } } _CPU_ISR_Enable(level); if ((ModemData.t_line==PPPDISC)) { rtems_bsdnet_semaphore_obtain(); modem_sendpacket(); rtems_bsdnet_semaphore_release(); } } } static void modem_rxDaemon (void *arg) { rtems_event_set events; unsigned char bufor_posr[MODEM_BUFFER_LENGTH]; register unsigned char ch; int level,i,j; while(1) { /* wait for interrupt */ i=0; _CPU_ISR_Disable(level); while(rcv_len>0) { bufor_posr[i++]=rcv_buf[rcv_start]; rcv_start=(rcv_start+1)%MODEM_BUFFER_LENGTH; rcv_len--; } _CPU_ISR_Enable(level); if (ModemData.t_line==PPPDISC) { rtems_bsdnet_semaphore_obtain(); for(j=0;j<i;j++) pppinput(bufor_posr[j]); rtems_bsdnet_semaphore_release(); } else 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); } } #define CLK_FREQ 1843200 void set_modem_speed(int speed) { *LCR = (char)(DLAB); *DLL = (char)((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF); *DLM = (char)(((int)(CLK_FREQ/speed/16.0+0.5) & 0xFF00) >> 8); *LCR = (char)(WL_8 ); /* 8 bitowe slowo */ } static void modem_init (int speed) /* port is the SMC number (i.e. 1 or 2) */ { set_modem_speed(speed); /* Line control setup */ *LCR = (char)(WL_8 ); /* 8 bitowe slowo */ /* bylo NSB - bylo 2 jest 1*/ /* Interrupt setup */ *IER = (char) 0x0f; /* enable transmit, receive, modem stat int */ /* FIFO setup */ *FCR = (char)(FIFO_E | 0xc0); /* Modem control setup */ *MCR = (char) RTS|DTR|OUT2; /* init tx_stop with CTS */ _tx_stop = ( (*MDSR & CTS) ? 0 : 1); } void set_modem_dtr(int how) { unsigned char znak; znak=*MCR; *MCR=(how)?(znak|DTR):(znak&(~DTR)); } void modem_status() { unsigned char status; status=*MDSR; /* printf("Modem Status %x ",status); */ if (status&CTS) { _tx_stop=0; rtems_event_send (modem_tx_task, START_TRANSMIT_EVENT|INTERRUPT_EVENT); } else { _tx_stop=1; } if (status&DCD) _modem_cd=1; else _modem_cd=0; } static rtems_isr modemInterruptHandler (rtems_vector_number v) { register char a,i,ch; register int maxonce; static errcount = 0; for(;;) { a=*IIR & (NIP | IID_MASK); /* read interrupt id register */ switch (a) { case 0x04: case 0x0c: /* * Buffer received? */ while( (*LSR & DR) != 0) { ch=*RBR; rcv_buf[(rcv_start+rcv_len)%MODEM_BUFFER_LENGTH]=ch; rcv_len++; } rtems_event_send (modem_rx_task, INTERRUPT_EVENT); break; case 0x02: /* * Buffer transmitted ? */ if (*LSR & THRE) //jezeli nie ma transmisji (a nie powinno byc) to wyslijmy bajty { maxonce=(xmt_len>14)?14:xmt_len; if (maxonce>0) { for (i=0;i<maxonce;i++) { *THR=xmt_buf[xmt_start]; xmt_start=(xmt_start+1)%MODEM_BUFFER_LENGTH; } xmt_len-=maxonce; } } rtems_event_send (modem_tx_task, INTERRUPT_EVENT); break; case 0x00: modem_status(); break; case 0x01: return; case 0x06: ch=*RBR; errcount++; break; default: break; } } } void modem_flush(int mode) { if (mode&FWRITE) { } if (mode&FREAD) { } } int modemWriteTermios(int minor, const char *buf, int len) { int level; int i,maxonce; if (len<=0) return 0; if (ModemData.t_line!=PPPDISC) { _CPU_ISR_Disable(level); for(i=0;i<len;i++) { if (xmt_len>=MODEM_BUFFER_LENGTH) break; xmt_buf[(xmt_start+xmt_len)%MODEM_BUFFER_LENGTH]=buf[i]; xmt_len++; } _CPU_ISR_Enable(level); } rtems_event_send(modem_tx_task,START_TRANSMIT_EVENT); return i; } /* * Initialize and register the device */ rtems_device_driver modem_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *arg ) { rtems_status_code status; rtems_isr_entry old_handler; rtems_status_code sc; rtems_termios_initialize (); sc = rtems_semaphore_create ( rtems_build_name ('M', 'D', 'M', 'P'), 0, RTEMS_COUNTING_SEMAPHORE, RTEMS_NO_PRIORITY_CEILING, &ModemData.pppsem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); modem_init(9600); sc = rtems_interrupt_catch (modemInterruptHandler, PPC_IRQ_IRQ4, &old_handler); /* * Register the devices */ modem_tx_task=0; modem_rx_task=0; status = rtems_io_register_name ("/dev/modem", major, 0); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (status); return RTEMS_SUCCESSFUL; } rtems_device_driver modem_first_open( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { modem_tty=(struct rtems_termios_tty *)(((rtems_libio_open_close_args_t *)arg)->iop->data1); return RTEMS_SUCCESSFUL; } rtems_device_driver modem_last_close( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { m823.siu.simask &=(~M823_SIMASK_IRM4); /* block the interrupts */ return RTEMS_SUCCESSFUL; } static int modemSetAttr(int minor, const struct termios *t) { int baud; switch (t->c_cflag & CBAUD) { case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 134; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; default: baud = 0; rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR); return 0; } set_modem_speed(baud); return RTEMS_SUCCESSFUL; } /* * Open the device */ rtems_device_driver modem_open( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { int error, s; rtems_status_code status; register struct ppp_softc *sc; static rtems_termios_callbacks cb = { modem_first_open, /* firstOpen */ modem_last_close, /* lastClose */ NULL, /* poll read */ modemWriteTermios, /* write */ modemSetAttr, /* setAttributes */ NULL, /* stopRemoteTx */ NULL, /* startRemoteTx */ 0 /* outputUsesInterrupts */ }; if (ModemData.t_line == PPPDISC) { sc = ModemData.t_sc; if (sc != NULL && sc->sc_devp == (void *) &ModemData) { return (0); } } if ((ModemData.t_sc= sc = pppalloc(1)) == NULL) return 2; if (sc->sc_relinq) (*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */ sc->sc_ilen = 0; sc->sc_m = NULL; bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); sc->sc_asyncmap[0] = 0xffffffff; sc->sc_asyncmap[3] = 0x60000000; sc->sc_rasyncmap = 0; sc->sc_devp = &ModemData; sc->sc_start = pppasyncstart; sc->sc_ctlp = pppasyncctlp; sc->sc_relinq = pppasyncrelinq; sc->sc_outm = NULL; pppgetm(sc); sc->sc_if.if_flags |= IFF_RUNNING; sc->sc_if.if_baudrate = 38400; status = rtems_termios_open (major, minor, arg, &cb); if(status != RTEMS_SUCCESSFUL) { /* printf("Error openning console device\n"); */ return status; } /* init rx and tx task for device */ xmt_start=xmt_len=0; rcv_start=rcv_len=0; if (modem_rx_task==0 && modem_tx_task==0) { rtems_status_code sc; sc = rtems_task_create (rtems_build_name ('M', 'D', 't', 'x'), 101, 16*1024, RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0), RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL, &modem_tx_task); if (sc != RTEMS_SUCCESSFUL) { } sc = rtems_task_start (modem_tx_task, (void *)modem_txDaemon, 0); if (sc != RTEMS_SUCCESSFUL) { } sc = rtems_task_create (rtems_build_name ('M', 'D', 'r', 'x'), 101, 16*1024, RTEMS_PREEMPT|RTEMS_TIMESLICE|RTEMS_NO_ASR|RTEMS_INTERRUPT_LEVEL(0), RTEMS_NO_FLOATING_POINT|RTEMS_LOCAL, &modem_rx_task); if (sc != RTEMS_SUCCESSFUL) { } sc = rtems_task_start (modem_rx_task, (void *)modem_rxDaemon, 0); if (sc != RTEMS_SUCCESSFUL) { } } /* Enable modem interrupts */ m823.siu.simask |= M823_SIMASK_IRM4; return RTEMS_SUCCESSFUL; } /* * Close the device */ rtems_device_driver modem_close( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { register struct ppp_softc *sc; modem_flush( FREAD|FWRITE); ModemData.t_line = 0; sc = ModemData.t_sc; if (sc != NULL) { ModemData.t_sc = NULL; if (&ModemData == (struct tty *) sc->sc_devp) { rtems_bsdnet_semaphore_obtain(); pppasyncrelinq(sc); pppdealloc(sc); rtems_bsdnet_semaphore_release(); } } return RTEMS_SUCCESSFUL; } /* for now works only as serial device */ rtems_device_driver modem_read( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { rtems_libio_rw_args_t *rw_args= (rtems_libio_rw_args_t *)arg; char *buffer; int count=0,maximum; rtems_status_code sc; buffer = rw_args->buffer; maximum = rw_args->count; if (ModemData.t_line==PPPDISC) { struct mbuf *m, *m0; register int s; int error = 0; rtems_status_code status; rtems_interval ticks; register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc; ticks=1000000/rtems_bsdnet_microseconds_per_tick; if (sc == NULL) return 0; /* * Loop waiting for input, checking that nothing disasterous * happens in the meantime. */ for (;;) { if (sc->sc_inq.ifq_head != NULL) { /* printf("Read : Dane sa w buforze\n"); */ break; } /* printf("Read : Czekam na dane\n"); */ status=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks); if (_modem_cd==0) { rw_args->bytes_moved =0; return RTEMS_SUCCESSFUL; } if (status==RTEMS_TIMEOUT) return status; } rtems_bsdnet_semaphore_obtain(); IF_DEQUEUE(&sc->sc_inq, m0); 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 */ { memcpy(buffer,mtod(m, u_char *),m->m_len); count+=m->m_len; buffer+=m->m_len; } m_freem(m0); rw_args->bytes_moved = count; } else sc = rtems_termios_read (arg); count=rw_args->bytes_moved; return (count >= 0) ? RTEMS_SUCCESSFUL : RTEMS_UNSATISFIED; } /* * Write to the device */ rtems_device_driver modem_write( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { int count,len; rtems_libio_rw_args_t *rw_args; char *out_buffer; int n,maximum; rw_args = (rtems_libio_rw_args_t *) arg; out_buffer = rw_args->buffer; maximum = rw_args->count; if (ModemData.t_line==PPPDISC) { register struct ppp_softc *sc = (struct ppp_softc *)ModemData.t_sc; struct sockaddr dst; struct mbuf *m, *m0, **mp; rtems_bsdnet_semaphore_obtain(); for (mp = &m0; maximum; mp = &m->m_next) { MGET(m, M_WAIT, MT_DATA); if ((*mp = m) == NULL) { rtems_bsdnet_semaphore_release(); m_freem(m0); return (ENOBUFS); } m->m_len = 0; if (maximum>= MCLBYTES / 2) MCLGET(m, M_DONTWAIT); len = M_TRAILINGSPACE(m); if (len > maximum) { memcpy(mtod(m, u_char *),out_buffer,maximum); m->m_len=maximum; maximum=0; } else { memcpy(mtod(m, u_char *),out_buffer,len); maximum-=len; m->m_len=len; out_buffer+=len; } } dst.sa_family = AF_UNSPEC; bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN); m0->m_data += PPP_HDRLEN; m0->m_len -= PPP_HDRLEN; /* printf("Wysylam %d bajtow \n",m0->m_len); */ n=pppoutput(&sc->sc_if, m0, &dst, (struct rtentry *)0); rtems_bsdnet_semaphore_release(); return n; } else return rtems_termios_write (arg); } /* * Handle ioctl request. * Should set hardware line speed, bits/char, etc. */ rtems_device_driver modem_control( rtems_device_major_number major, rtems_device_minor_number minor, void * arg ) { rtems_libio_ioctl_args_t *args=(rtems_libio_ioctl_args_t *)arg; struct ppp_softc *sc=ModemData.t_sc; int cmd; caddr_t data; int error=RTEMS_SUCCESSFUL; data=args->buffer; cmd=args->command; switch (cmd) { case RTEMS_IO_GET_ATTRIBUTES: case RTEMS_IO_SET_ATTRIBUTES: case RTEMS_IO_TCDRAIN: return rtems_termios_ioctl (arg); break; case PPPIOCSASYNCMAP: sc->sc_asyncmap[0] = *(u_int *)data; break; case PPPIOCGASYNCMAP: *(u_int *)data = sc->sc_asyncmap[0]; break; case PPPIOCSRASYNCMAP: sc->sc_rasyncmap = *(u_int *)data; break; case TIOCSETD: ModemData.t_line=*(int*)data; break; case TIOCGETD: *(int*)data=ModemData.t_line; break; case TIOCMBIS: if ((*(int*)data)&TIOCM_DTR) set_modem_dtr(1); break; case TIOCMBIC: if ((*(int*)data)&TIOCM_DTR) set_modem_dtr(0); break; case PPPIOCGRASYNCMAP: *(u_int *)data = sc->sc_rasyncmap; break; case PPPIOCSXASYNCMAP: bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); sc->sc_asyncmap[1] = 0; /* mustn't escape 0x20 - 0x3f */ sc->sc_asyncmap[2] &= ~0x40000000; /* mustn't escape 0x5e */ sc->sc_asyncmap[3] |= 0x60000000; /* must escape 0x7d, 0x7e */ break; case PPPIOCGXASYNCMAP: bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap)); break; default: rtems_bsdnet_semaphore_obtain(); error = pppioctl(sc, cmd, data, 0, NULL); if (error == 0 && cmd == PPPIOCSMRU) pppgetm(sc); rtems_bsdnet_semaphore_release(); } return error; } void wait_input(timo) struct timeval *timo; { int n; rtems_event_set events; rtems_interval ticks; rtems_status_code err; int czekaj=1; 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; while (czekaj) { if (sc->sc_inq.ifq_head != NULL) break; /* printf("Wait : Czekam na dane przez %d ticks\n",ticks); */ err=rtems_semaphore_obtain(ModemData.pppsem,RTEMS_WAIT,ticks); if (err==RTEMS_TIMEOUT) { /* printf("TIMEOUT :Brak danych\n"); */ break; } } }
Go to most recent revision | Compare with Previous | Blame | View Log