00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 #include "netif/slipif.h"
00059 #include "lwip/opt.h"
00060
00061 #if LWIP_HAVE_SLIPIF
00062
00063 #include "lwip/def.h"
00064 #include "lwip/pbuf.h"
00065 #include "lwip/stats.h"
00066 #include "lwip/snmp.h"
00067 #include "lwip/sio.h"
00068 #include "lwip/sys.h"
00069
00070 #define SLIP_END 0xC0
00071 #define SLIP_ESC 0xDB
00072 #define SLIP_ESC_END 0xDC
00073 #define SLIP_ESC_ESC 0xDD
00074
00075
00076 #ifndef SLIP_MAX_SIZE
00077 #define SLIP_MAX_SIZE 1500
00078 #endif
00079
00080
00081
00082
00083
00084 #ifndef SLIP_SIO_SPEED
00085 #define SLIP_SIO_SPEED(sio_fd) 0
00086 #endif
00087
00088 enum slipif_recv_state {
00089 SLIP_RECV_NORMAL,
00090 SLIP_RECV_ESCAPE,
00091 };
00092
00093 struct slipif_priv {
00094 sio_fd_t sd;
00095
00096 struct pbuf *p, *q;
00097 u8_t state;
00098 u16_t i, recved;
00099 #if SLIP_RX_FROM_ISR
00100 struct pbuf *rxpackets;
00101 #endif
00102 };
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114 err_t
00115 slipif_output(struct netif *netif, struct pbuf *p, ip_addr_t *ipaddr)
00116 {
00117 struct slipif_priv *priv;
00118 struct pbuf *q;
00119 u16_t i;
00120 u8_t c;
00121
00122 LWIP_ASSERT("netif != NULL", (netif != NULL));
00123 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00124 LWIP_ASSERT("p != NULL", (p != NULL));
00125
00126 LWIP_UNUSED_ARG(ipaddr);
00127
00128 LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output(%"U16_F"): sending %"U16_F" bytes\n", (u16_t)netif->num, p->tot_len));
00129 priv = netif->state;
00130
00131
00132
00133 sio_send(SLIP_END, priv->sd);
00134
00135 for (q = p; q != NULL; q = q->next) {
00136 for (i = 0; i < q->len; i++) {
00137 c = ((u8_t *)q->payload)[i];
00138 switch (c) {
00139 case SLIP_END:
00140
00141 sio_send(SLIP_ESC, priv->sd);
00142 sio_send(SLIP_ESC_END, priv->sd);
00143 break;
00144 case SLIP_ESC:
00145
00146 sio_send(SLIP_ESC, priv->sd);
00147 sio_send(SLIP_ESC_ESC, priv->sd);
00148 break;
00149 default:
00150
00151 sio_send(c, priv->sd);
00152 break;
00153 }
00154 }
00155 }
00156
00157 sio_send(SLIP_END, priv->sd);
00158 return ERR_OK;
00159 }
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169 static struct pbuf*
00170 slipif_rxbyte(struct netif *netif, u8_t c)
00171 {
00172 struct slipif_priv *priv;
00173 struct pbuf *t;
00174
00175 LWIP_ASSERT("netif != NULL", (netif != NULL));
00176 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00177
00178 priv = netif->state;
00179
00180 switch (priv->state) {
00181 case SLIP_RECV_NORMAL:
00182 switch (c) {
00183 case SLIP_END:
00184 if (priv->recved > 0) {
00185
00186
00187 pbuf_realloc(priv->q, priv->recved);
00188
00189 LINK_STATS_INC(link.recv);
00190
00191 LWIP_DEBUGF(SLIP_DEBUG, ("slipif: Got packet (%"U16_F" bytes)\n", priv->recved));
00192 t = priv->q;
00193 priv->p = priv->q = NULL;
00194 priv->i = priv->recved = 0;
00195 return t;
00196 }
00197 return NULL;
00198 case SLIP_ESC:
00199 priv->state = SLIP_RECV_ESCAPE;
00200 return NULL;
00201 }
00202 break;
00203 case SLIP_RECV_ESCAPE:
00204
00205
00206 switch (c) {
00207 case SLIP_ESC_END:
00208 c = SLIP_END;
00209 break;
00210 case SLIP_ESC_ESC:
00211 c = SLIP_ESC;
00212 break;
00213 }
00214 priv->state = SLIP_RECV_NORMAL;
00215 break;
00216 }
00217
00218
00219 if (priv->p == NULL) {
00220
00221 LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: alloc\n"));
00222 priv->p = pbuf_alloc(PBUF_LINK, (PBUF_POOL_BUFSIZE - PBUF_LINK_HLEN), PBUF_POOL);
00223
00224 if (priv->p == NULL) {
00225 LINK_STATS_INC(link.drop);
00226 LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n"));
00227
00228 return NULL;
00229 }
00230
00231 if (priv->q != NULL) {
00232
00233 pbuf_cat(priv->q, priv->p);
00234 } else {
00235
00236 priv->q = priv->p;
00237 }
00238 }
00239
00240
00241 if ((priv->p != NULL) && (priv->recved <= SLIP_MAX_SIZE)) {
00242 ((u8_t *)priv->p->payload)[priv->i] = c;
00243 priv->recved++;
00244 priv->i++;
00245 if (priv->i >= priv->p->len) {
00246
00247 priv->i = 0;
00248 if (priv->p->next != NULL && priv->p->next->len > 0) {
00249
00250 priv->p = priv->p->next;
00251 } else {
00252
00253
00254 priv->p = NULL;
00255 }
00256 }
00257 }
00258 return NULL;
00259 }
00260
00261
00262
00263
00264
00265
00266 static void
00267 slipif_rxbyte_input(struct netif *netif, u8_t c)
00268 {
00269 struct pbuf *p;
00270 p = slipif_rxbyte(netif, c);
00271 if (p != NULL) {
00272 if (netif->input(p, netif) != ERR_OK) {
00273 pbuf_free(p);
00274 }
00275 }
00276 }
00277
00278 #if SLIP_USE_RX_THREAD
00279
00280
00281
00282
00283
00284
00285
00286 static void
00287 slipif_loop_thread(void *nf)
00288 {
00289 u8_t c;
00290 struct netif *netif = (struct netif *)nf;
00291 struct slipif_priv *priv = (struct slipif_priv *)netif->state;
00292
00293 while (1) {
00294 if (sio_read(priv->sd, &c, 1) > 0) {
00295 slipif_rxbyte_input(netif, c);
00296 }
00297 }
00298 }
00299 #endif
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317 err_t
00318 slipif_init(struct netif *netif)
00319 {
00320 struct slipif_priv *priv;
00321 u8_t sio_num;
00322
00323 LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)netif->num));
00324
00325
00326 priv = (struct slipif_priv *)mem_malloc(sizeof(struct slipif_priv));
00327 if (!priv) {
00328 return ERR_MEM;
00329 }
00330
00331 netif->name[0] = 's';
00332 netif->name[1] = 'l';
00333 netif->output = slipif_output;
00334 netif->mtu = SLIP_MAX_SIZE;
00335 netif->flags |= NETIF_FLAG_POINTTOPOINT;
00336
00337
00338 if (netif->state != NULL) {
00339 sio_num = *(u8_t*)netif->state;
00340 } else {
00341 sio_num = netif->num;
00342 }
00343
00344 priv->sd = sio_open(sio_num);
00345 if (!priv->sd) {
00346
00347 mem_free(priv);
00348 return ERR_IF;
00349 }
00350
00351
00352 priv->p = NULL;
00353 priv->q = NULL;
00354 priv->state = SLIP_RECV_NORMAL;
00355 priv->i = 0;
00356 priv->recved = 0;
00357 #if SLIP_RX_FROM_ISR
00358 priv->rxpackets = NULL;
00359 #endif
00360
00361 netif->state = priv;
00362
00363
00364 NETIF_INIT_SNMP(netif, snmp_ifType_slip, SLIP_SIO_SPEED(priv->sd));
00365
00366 #if SLIP_USE_RX_THREAD
00367
00368 sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif,
00369 SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);
00370 #endif
00371 return ERR_OK;
00372 }
00373
00374
00375
00376
00377
00378
00379 void
00380 slipif_poll(struct netif *netif)
00381 {
00382 u8_t c;
00383 struct slipif_priv *priv;
00384
00385 LWIP_ASSERT("netif != NULL", (netif != NULL));
00386 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00387
00388 priv = (struct slipif_priv *)netif->state;
00389
00390 while (sio_tryread(priv->sd, &c, 1) > 0) {
00391 slipif_rxbyte_input(netif, c);
00392 }
00393 }
00394
00395 #if SLIP_RX_FROM_ISR
00396
00397
00398
00399
00400
00401 void
00402 slipif_process_rxqueue(struct netif *netif)
00403 {
00404 struct slipif_priv *priv;
00405 SYS_ARCH_DECL_PROTECT(old_level);
00406
00407 LWIP_ASSERT("netif != NULL", (netif != NULL));
00408 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00409
00410 priv = (struct slipif_priv *)netif->state;
00411
00412 SYS_ARCH_PROTECT(old_level);
00413 while (priv->rxpackets != NULL) {
00414 struct pbuf *p = priv->rxpackets;
00415 #if SLIP_RX_QUEUE
00416
00417 struct pbuf *q = p;
00418 while ((q->len != q->tot_len) && (q->next != NULL)) {
00419 q = q->next;
00420 }
00421 priv->rxpackets = q->next;
00422 q->next = NULL;
00423 #else
00424 priv->rxpackets = NULL;
00425 #endif
00426 SYS_ARCH_UNPROTECT(old_level);
00427 if (netif->input(p, netif) != ERR_OK) {
00428 pbuf_free(p);
00429 }
00430 SYS_ARCH_PROTECT(old_level);
00431 }
00432 }
00433
00434
00435
00436
00437
00438
00439 static void
00440 slipif_rxbyte_enqueue(struct netif *netif, u8_t data)
00441 {
00442 struct pbuf *p;
00443 struct slipif_priv *priv = (struct slipif_priv *)netif->state;
00444 SYS_ARCH_DECL_PROTECT(old_level);
00445
00446 p = slipif_rxbyte(netif, data);
00447 if (p != NULL) {
00448 SYS_ARCH_PROTECT(old_level);
00449 if (priv->rxpackets != NULL) {
00450 #if SLIP_RX_QUEUE
00451
00452 struct pbuf *q = p;
00453 while(q->next != NULL) {
00454 q = q->next;
00455 }
00456 q->next = p;
00457 } else {
00458 #else
00459 pbuf_free(priv->rxpackets);
00460 }
00461 {
00462 #endif
00463 priv->rxpackets = p;
00464 }
00465 SYS_ARCH_UNPROTECT(old_level);
00466 }
00467 }
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477
00478 void
00479 slipif_received_byte(struct netif *netif, u8_t data)
00480 {
00481 LWIP_ASSERT("netif != NULL", (netif != NULL));
00482 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00483 slipif_rxbyte_enqueue(netif, data);
00484 }
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496 void
00497 slipif_received_bytes(struct netif *netif, u8_t *data, u8_t len)
00498 {
00499 u8_t i;
00500 u8_t *rxdata = data;
00501 LWIP_ASSERT("netif != NULL", (netif != NULL));
00502 LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
00503
00504 for (i = 0; i < len; i++, rxdata++) {
00505 slipif_rxbyte_enqueue(netif, *rxdata);
00506 }
00507 }
00508 #endif
00509
00510 #endif