/[lwip]/lwip/src/netif/slipif.c
ViewVC logotype

Diff of /lwip/src/netif/slipif.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by likewise, Tue Oct 22 12:32:58 2002 UTC revision 1.2 by adamdunkels, Sat Nov 2 20:40:06 2002 UTC
# Line 28  Line 28 
28   *   *
29   * This file is built upon the file: src/arch/rtxc/netif/sioslip.c   * This file is built upon the file: src/arch/rtxc/netif/sioslip.c
30   *   *
31   * Author: Magnus Ivarsson <magnus.ivarsson(at)volvo.com>   * Author: Magnus Ivarsson <magnus.ivarsson(at)volvo.com>
32   */   */
33    
34  #include "netif/slipif.h"  #include "netif/slipif.h"
# Line 55  typedef struct slip_status_t { Line 55  typedef struct slip_status_t {
55  static slip_status_t statusar[SLIPIF_NUM_OF_INTERFACES];  static slip_status_t statusar[SLIPIF_NUM_OF_INTERFACES];
56    
57  /*-----------------------------------------------------------------------------------*/  /*-----------------------------------------------------------------------------------*/
58  err_t slipif_output(struct netif *netif, struct pbuf *p, struct ip_addr *ipaddr)  err_t
59    slipif_output(struct netif *netif, struct pbuf *p, struct ip_addr *ipaddr)
60  {  {
61          slip_status_t *slipState = (slip_status_t *) netif->state;    slip_status_t *slipState = (slip_status_t *)netif->state;
62          struct pbuf *q;    struct pbuf *q;
63          int i;    int i;
64          u8_t c;    u8_t c;
65    
66          /* Send pbuf out on the serial I/O device. */    /* Send pbuf out on the serial I/O device. */
67          sio_send(SLIP_END, slipState->sio);    sio_send(SLIP_END, slipState->sio);
68    
69          for(q = p; q != NULL; q = q->next) {    for(q = p; q != NULL; q = q->next) {
70                  for(i = 0; i < q->len; i++) {      for(i = 0; i < q->len; i++) {
71                          c = ((u8_t *)q->payload)[i];        c = ((u8_t *)q->payload)[i];
72                          switch(c) {        switch(c) {
73                          case SLIP_END:        case SLIP_END:
74                                  sio_send(SLIP_ESC, slipState->sio);          sio_send(SLIP_ESC, slipState->sio);
75                                  sio_send(SLIP_ESC_END, slipState->sio);          sio_send(SLIP_ESC_END, slipState->sio);
76                                  break;          break;
77                          case SLIP_ESC:        case SLIP_ESC:
78                                  sio_send(SLIP_ESC, slipState->sio);          sio_send(SLIP_ESC, slipState->sio);
79                                  sio_send(SLIP_ESC_ESC, slipState->sio);          sio_send(SLIP_ESC_ESC, slipState->sio);
80                                  break;          break;
81                          default:        default:
82                                  sio_send(c, slipState->sio);          sio_send(c, slipState->sio);
83                                  break;          break;
84                          }        }
85                  }      }
86          }    }
87          sio_send(SLIP_END, slipState->sio);    sio_send(SLIP_END, slipState->sio);
88          return 0;    return 0;
89  }  }
90  /*-----------------------------------------------------------------------------------*/  /*-----------------------------------------------------------------------------------*/
91    static struct pbuf *
92  static struct pbuf * slipif_input( struct netif * netif )  slipif_input( struct netif * netif )
93  {  {
94          slip_status_t *slipState = (slip_status_t *) netif->state;    slip_status_t *slipState = (slip_status_t *)netif->state;
95      u8_t c;
96          u8_t c;    struct pbuf *p, *q;
97          struct pbuf *p, *q;    int recved;
98          int recved;    int i;
99          int i;  
100      q = p = NULL;
101          q = p = NULL;    recved = i = 0;
102          recved = i = 0;    c = 0;
103          c = 0;  
104      while(1) {
105          while ( 1 )      c = sio_recv(slipState->sio);
106          {      switch(c) {
107                  c = sio_recv( slipState->sio );      case SLIP_END:
108                  switch ( c )        if(p == NULL) {
109                  {          return slipif_input(netif);
110                  case SLIP_END:        }
111                          if ( p == NULL )        if(recved > 0) {
112                          {          /* Received whole packet. */
113                                  return slipif_input( netif );          pbuf_realloc(q, recved);
114                          }          
115                          if ( recved > 0 )  #ifdef LINK_STATS
116                          {          ++stats.link.recv;
117                                  /* Received whole packet. */  #endif /* LINK_STATS */        
118                                  pbuf_realloc( q, recved );          
119            DEBUGF(SLIP_DEBUG, ("slipif: Got packet\n"));
120                      #ifdef LINK_STATS          return q;
121                                  stats.link.recv++;        }
122                      #endif /* LINK_STATS */                break;
123    
124                                  DEBUGF( SLIP_DEBUG, ("slipif: Got packet\n") );      case SLIP_ESC:
125                                  return q;        c = sio_recv(slipState->sio);
126                          }        switch(c) {
127                          break;        case SLIP_ESC_END:
128            c = SLIP_END;
129                  case SLIP_ESC:          break;
130                          c = sio_recv( slipState->sio );        case SLIP_ESC_ESC:
131                          switch ( c )          c = SLIP_ESC;
132                          {          break;
133                          case SLIP_ESC_END:        }
134                                  c = SLIP_END;        /* FALLTHROUGH */
135                                  break;        
136                          case SLIP_ESC_ESC:      default:
137                                  c = SLIP_ESC;        if(p == NULL) {
138                                  break;          DEBUGF(SLIP_DEBUG, ("slipif_input: alloc\n"));
139                          }          p = pbuf_alloc(PBUF_LINK, 128, PBUF_POOL);
140                          /* FALLTHROUGH */  
141    #ifdef LINK_STATS          
142                  default:          if(p == NULL) {
143                          if ( p == NULL )            ++stats.link.drop;
144                          {            DEBUGF(SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n"));
145                                  DEBUGF( SLIP_DEBUG, ("slipif_input: alloc\n") );          }
146                                  p = pbuf_alloc( PBUF_LINK, 128, PBUF_POOL );  #endif /* LINK_STATS */                  
147            
148                                          #ifdef LINK_STATS                    if(q != NULL) {
149                                  if ( p == NULL )            pbuf_chain(q, p);
150                                  {          } else {
151                                          stats.link.drop++;            q = p;
152                                          DEBUGF( SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n") );          }
153                                  }        }
154                                          #endif /* LINK_STATS */                          if(p != NULL && recved < MAX_SIZE) {
155            ((u8_t *)p->payload)[i] = c;
156                                  if ( q != NULL )          recved++;
157                                  {          i++;
158                                          pbuf_chain( q, p );          if(i >= p->len) {
159                                  }            i = 0;
160                                  else            p = NULL;
                                 {  
                                         q = p;  
                                 }  
                         }  
                         if ( p != NULL && recved < MAX_SIZE )  
                         {  
                                 ((u8_t *)p->payload)[i] = c;  
                                 recved++;  
                                 i++;  
                                 if ( i >= p->len )  
                                 {  
                                         i = 0;  
                                         p = NULL;  
                                 }  
                         }  
                         break;  
                 }  
   
161          }          }
162          return NULL;        }
163          break;
164        }
165        
166      }
167      return NULL;
168  }  }
169  /*-----------------------------------------------------------------------------------*/  /*-----------------------------------------------------------------------------------*/
170  static void slipif_loop(void *nf)  static void
171    slipif_loop(void *nf)
172  {  {
173          struct pbuf *p;    struct pbuf *p;
174          struct netif *netif = (struct netif *) nf;    struct netif *netif = (struct netif *)nf;
175  //      slip_status_t *slipState = (slip_status_t *) netif->state;    /*    slip_status_t *slipState = (slip_status_t *) netif->state; */
176    
177          while(1) {    while(1) {
178                  p = slipif_input( netif );      p = slipif_input(netif);
179                  netif->input(p, netif);      netif->input(p, netif);
180          }    }
181  }                          }                        
182  /*-----------------------------------------------------------------------------------*/  /*-----------------------------------------------------------------------------------*/
183  // void  void
184  // sioslipif_init0(struct netif *netif)  slipif_init(struct netif *netif)
 // {  
 //   slip_status_t * ss;  
 //   printf("slipif_init0: netif->num=%x\n", (int)netif->num);  
 //  
 //   netif->state = &statusar[0];  
 //   netif->name[0] = 's';  
 //   netif->name[1] = 'l';  
 //   netif->output = sioslipif_output;  
 //   netif->num = 0;  
 //  
 //   sio_open( netif );  
 //      ss = (slip_status_t*)(netif->state);  
 //   printf("slipif_init0: netif=%x sio=0x%x\n", (int)netif, (int)(ss->sio));  
 //   sys_thread_new((void *)slipif_loop, netif);  
 // }  
   
 /*-----------------------------------------------------------------------------------*/  
 void slipif_init(struct netif *netif)  
185  {  {
186          slip_status_t *slipState;    slip_status_t *slipState;
187                    
188          DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%x\n", (int)netif->num));    DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%x\n", (int)netif->num));
189          if ( netif->num >= SLIPIF_NUM_OF_INTERFACES )    if(netif->num >= SLIPIF_NUM_OF_INTERFACES) {
190          {      DEBUGF( SLIP_DEBUG, ("ERROR: To many slipifs"));
191                  DEBUGF( SLIP_DEBUG, ("ERROR: To many slipifs"));      return;
192                  return;    }
193          }  
194      /* dynamic allocation would be nice */
195          /* dynamic allocation would be nice */    netif->state = &statusar[netif->num];
196          netif->state = &statusar[ netif->num ];    netif->name[0] = 's';
197          netif->name[0] = 's';    netif->name[1] = 'l';
198          netif->name[1] = 'l';    netif->output = slipif_output;
         netif->output = slipif_output;  
199    
200          slipState = (slip_status_t *) netif->state;    slipState = (slip_status_t *)netif->state;
201          slipState->sio = sio_open( netif->num );    slipState->sio = sio_open(netif->num);
202    
203          sys_thread_new(slipif_loop, netif);    sys_thread_new(slipif_loop, netif);
204  }  }
205  /*-----------------------------------------------------------------------------------*/  /*-----------------------------------------------------------------------------------*/

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26