1 | /* Author: Magnus Ivarsson <magnus.ivarsson@volvo.com> */
|
---|
2 |
|
---|
3 | /* to get rid of implicit function declarations */
|
---|
4 | #define _XOPEN_SOURCE 600
|
---|
5 | #define _GNU_SOURCE
|
---|
6 |
|
---|
7 | /* build with Darwin C extensions not part of POSIX, i.e. FASYNC, SIGIO.
|
---|
8 | we can't use LWIP_UNIX_MACH because extensions need to be turned
|
---|
9 | on before any system headers (which are pulled in through cc.h)
|
---|
10 | are included */
|
---|
11 | #if defined(__APPLE__)
|
---|
12 | #define _DARWIN_C_SOURCE
|
---|
13 | #endif
|
---|
14 |
|
---|
15 | #include "netif/sio.h"
|
---|
16 | #include "netif/fifo.h"
|
---|
17 | #include "lwip/debug.h"
|
---|
18 | #include "lwip/def.h"
|
---|
19 | #include "lwip/sys.h"
|
---|
20 | #include "lwip/arch.h"
|
---|
21 | #include "lwip/sio.h"
|
---|
22 | #include "netif/ppp/ppp_opts.h"
|
---|
23 |
|
---|
24 | /* Following #undefs are here to keep compiler from issuing warnings
|
---|
25 | about them being double defined. (They are defined in lwip/inet.h
|
---|
26 | as well as the Unix #includes below.) */
|
---|
27 | #undef htonl
|
---|
28 | #undef ntohl
|
---|
29 | #undef htons
|
---|
30 | #undef ntohs
|
---|
31 | #undef HTONL
|
---|
32 | #undef NTOHL
|
---|
33 | #undef HTONS
|
---|
34 | #undef NTOHS
|
---|
35 |
|
---|
36 | #include <stdlib.h>
|
---|
37 | #include <stdio.h>
|
---|
38 | #if defined(LWIP_UNIX_OPENBSD)
|
---|
39 | #include <util.h>
|
---|
40 | #endif
|
---|
41 | #include <termios.h>
|
---|
42 | #include <stdio.h>
|
---|
43 | #include <unistd.h>
|
---|
44 | #include <fcntl.h>
|
---|
45 | #include <signal.h>
|
---|
46 | #include <string.h>
|
---|
47 | #include <sys/signal.h>
|
---|
48 | #include <sys/types.h>
|
---|
49 |
|
---|
50 | #ifndef LWIP_HAVE_SLIPIF
|
---|
51 | #define LWIP_HAVE_SLIPIF 0
|
---|
52 | #endif
|
---|
53 |
|
---|
54 | #if (PPP_SUPPORT || LWIP_HAVE_SLIPIF) && defined(LWIP_UNIX_LINUX)
|
---|
55 | #include <pty.h>
|
---|
56 | #endif
|
---|
57 |
|
---|
58 | /*#define BAUDRATE B19200 */
|
---|
59 | /*#define BAUDRATE B57600 */
|
---|
60 | #define BAUDRATE B115200
|
---|
61 |
|
---|
62 | #ifndef TRUE
|
---|
63 | #define TRUE 1
|
---|
64 | #endif
|
---|
65 | #ifndef FALSE
|
---|
66 | #define FALSE 0
|
---|
67 | #endif
|
---|
68 |
|
---|
69 | /* for all of you who dont define SIO_DEBUG in debug.h */
|
---|
70 | #ifndef SIO_DEBUG
|
---|
71 | #define SIO_DEBUG 0
|
---|
72 | #endif
|
---|
73 |
|
---|
74 |
|
---|
75 | /* typedef struct siostruct_t */
|
---|
76 | /* { */
|
---|
77 | /* sio_status_t *sio; */
|
---|
78 | /* } siostruct_t; */
|
---|
79 |
|
---|
80 | /** array of ((siostruct*)netif->state)->sio structs */
|
---|
81 | static sio_status_t statusar[4];
|
---|
82 |
|
---|
83 | #if ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
84 | /* --private-functions----------------------------------------------------------------- */
|
---|
85 | /**
|
---|
86 | * Signal handler for ttyXX0 to indicate bytes received
|
---|
87 | * one per interface is needed since we cannot send a instance number / pointer as callback argument (?)
|
---|
88 | */
|
---|
89 | static void signal_handler_IO_0( int status )
|
---|
90 | {
|
---|
91 | LWIP_UNUSED_ARG(status);
|
---|
92 | LWIP_DEBUGF(SIO_DEBUG, ("SigHand: rxSignal channel 0\n"));
|
---|
93 | fifoPut( &statusar[0].myfifo, statusar[0].fd );
|
---|
94 | }
|
---|
95 |
|
---|
96 | /**
|
---|
97 | * Signal handler for ttyXX1 to indicate bytes received
|
---|
98 | * one per interface is needed since we cannot send a instance number / pointer as callback argument (?)
|
---|
99 | */
|
---|
100 | static void signal_handler_IO_1( int status )
|
---|
101 | {
|
---|
102 | LWIP_UNUSED_ARG(status);
|
---|
103 | LWIP_DEBUGF(SIO_DEBUG, ("SigHand: rxSignal channel 1\n"));
|
---|
104 | fifoPut( &statusar[1].myfifo, statusar[1].fd );
|
---|
105 | }
|
---|
106 | #endif /* ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF) */
|
---|
107 |
|
---|
108 | /**
|
---|
109 | * Initiation of serial device
|
---|
110 | * @param device string with the device name and path, eg. "/dev/ttyS0"
|
---|
111 | * @param devnum device number
|
---|
112 | * @param siostat status
|
---|
113 | * @return file handle to serial dev.
|
---|
114 | */
|
---|
115 | static int sio_init( char * device, int devnum, sio_status_t * siostat )
|
---|
116 | {
|
---|
117 | struct termios oldtio,newtio;
|
---|
118 | #if ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
119 | struct sigaction saio; /* definition of signal action */
|
---|
120 | #endif
|
---|
121 | int fd;
|
---|
122 | LWIP_UNUSED_ARG(siostat);
|
---|
123 | LWIP_UNUSED_ARG(devnum);
|
---|
124 |
|
---|
125 | /* open the device to be non-blocking (read will return immediately) */
|
---|
126 | fd = open( device, O_RDWR | O_NOCTTY | O_NONBLOCK );
|
---|
127 | if ( fd < 0 )
|
---|
128 | {
|
---|
129 | perror( device );
|
---|
130 | exit( -1 );
|
---|
131 | }
|
---|
132 |
|
---|
133 | #if ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
134 | /* install the signal handler before making the device asynchronous */
|
---|
135 | switch ( devnum )
|
---|
136 | {
|
---|
137 | case 0:
|
---|
138 | LWIP_DEBUGF( SIO_DEBUG, ("sioinit, signal_handler_IO_0\n") );
|
---|
139 | saio.sa_handler = signal_handler_IO_0;
|
---|
140 | break;
|
---|
141 | case 1:
|
---|
142 | LWIP_DEBUGF( SIO_DEBUG, ("sioinit, signal_handler_IO_1\n") );
|
---|
143 | saio.sa_handler = signal_handler_IO_1;
|
---|
144 | break;
|
---|
145 | default:
|
---|
146 | LWIP_DEBUGF( SIO_DEBUG,("sioinit, devnum not allowed\n") );
|
---|
147 | break;
|
---|
148 | }
|
---|
149 |
|
---|
150 | saio.sa_flags = 0;
|
---|
151 | #if defined(LWIP_UNIX_LINUX)
|
---|
152 | saio.sa_restorer = NULL;
|
---|
153 | #endif /* LWIP_UNIX_LINUX */
|
---|
154 | sigaction( SIGIO,&saio,NULL );
|
---|
155 |
|
---|
156 | /* allow the process to receive SIGIO */
|
---|
157 | if ( fcntl( fd, F_SETOWN, getpid( ) ) != 0)
|
---|
158 | {
|
---|
159 | perror( device );
|
---|
160 | exit( -1 );
|
---|
161 | }
|
---|
162 | /* Make the file descriptor asynchronous (the manual page says only
|
---|
163 | O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
|
---|
164 | if ( fcntl( fd, F_SETFL, FASYNC ) != 0)
|
---|
165 | {
|
---|
166 | perror( device );
|
---|
167 | exit( -1 );
|
---|
168 | }
|
---|
169 | #else
|
---|
170 | if ( fcntl( fd, F_SETFL, 0 ) != 0)
|
---|
171 | {
|
---|
172 | perror( device );
|
---|
173 | exit( -1 );
|
---|
174 | }
|
---|
175 |
|
---|
176 | #endif /* ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF) */
|
---|
177 |
|
---|
178 | tcgetattr( fd,&oldtio ); /* save current port settings */
|
---|
179 | /* set new port settings */
|
---|
180 | /* see 'man termios' for further settings */
|
---|
181 | memset(&newtio, 0, sizeof(newtio));
|
---|
182 | newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD | CRTSCTS;
|
---|
183 | newtio.c_iflag = 0;
|
---|
184 | newtio.c_oflag = 0;
|
---|
185 | newtio.c_lflag = 0; /*ECHO; */
|
---|
186 | newtio.c_cc[VMIN] = 1; /* Read 1 byte at a time, no timer */
|
---|
187 | newtio.c_cc[VTIME] = 0;
|
---|
188 |
|
---|
189 | tcsetattr( fd,TCSANOW,&newtio );
|
---|
190 | tcflush( fd, TCIOFLUSH );
|
---|
191 |
|
---|
192 | return fd;
|
---|
193 | }
|
---|
194 |
|
---|
195 | /**
|
---|
196 | *
|
---|
197 | */
|
---|
198 | static void sio_speed( int fd, int speed )
|
---|
199 | {
|
---|
200 | struct termios oldtio,newtio;
|
---|
201 | /* int fd; */
|
---|
202 |
|
---|
203 | LWIP_DEBUGF(SIO_DEBUG, ("sio_speed[%d]: baudcode:%d enter\n", fd, speed));
|
---|
204 |
|
---|
205 | if ( fd < 0 )
|
---|
206 | {
|
---|
207 | LWIP_DEBUGF(SIO_DEBUG, ("sio_speed[%d]: fd ERROR\n", fd));
|
---|
208 | exit( -1 );
|
---|
209 | }
|
---|
210 |
|
---|
211 | tcgetattr( fd,&oldtio ); /* get current port settings */
|
---|
212 |
|
---|
213 | /* set new port settings
|
---|
214 | * see 'man termios' for further settings */
|
---|
215 | memset(&newtio, 0, sizeof(newtio));
|
---|
216 | newtio.c_cflag = speed | CS8 | CLOCAL | CREAD; /* | CRTSCTS; */
|
---|
217 | newtio.c_iflag = 0;
|
---|
218 | newtio.c_oflag = 0;
|
---|
219 | newtio.c_lflag = 0; /*ECHO; */
|
---|
220 | newtio.c_cc[VMIN] = 1; /* Read 1 byte at a time, no timer */
|
---|
221 | newtio.c_cc[VTIME] = 0;
|
---|
222 |
|
---|
223 | tcsetattr( fd,TCSANOW,&newtio );
|
---|
224 | tcflush( fd, TCIOFLUSH );
|
---|
225 |
|
---|
226 | LWIP_DEBUGF(SIO_DEBUG, ("sio_speed[%d]: leave\n", fd));
|
---|
227 | }
|
---|
228 |
|
---|
229 | /* --public-functions----------------------------------------------------------------------------- */
|
---|
230 | void sio_send( u8_t c, sio_status_t * siostat )
|
---|
231 | {
|
---|
232 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio; */
|
---|
233 |
|
---|
234 | if ( write( siostat->fd, &c, 1 ) <= 0 )
|
---|
235 | {
|
---|
236 | LWIP_DEBUGF(SIO_DEBUG, ("sio_send[%d]: write refused\n", siostat->fd));
|
---|
237 | }
|
---|
238 | }
|
---|
239 |
|
---|
240 | void sio_send_string( u8_t *str, sio_status_t * siostat )
|
---|
241 | {
|
---|
242 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio; */
|
---|
243 | int len = strlen( (const char *)str );
|
---|
244 |
|
---|
245 | if ( write( siostat->fd, str, len ) <= 0 )
|
---|
246 | {
|
---|
247 | LWIP_DEBUGF(SIO_DEBUG, ("sio_send_string[%d]: write refused\n", siostat->fd));
|
---|
248 | }
|
---|
249 | LWIP_DEBUGF(SIO_DEBUG, ("sio_send_string[%d]: sent: %s\n", siostat->fd, str));
|
---|
250 | }
|
---|
251 |
|
---|
252 |
|
---|
253 | void sio_flush( sio_status_t * siostat )
|
---|
254 | {
|
---|
255 | LWIP_UNUSED_ARG(siostat);
|
---|
256 | /* not implemented in unix as it is not needed */
|
---|
257 | /*sio_status_t * siostat = ((siostruct_t*)netif->state)->sio; */
|
---|
258 | }
|
---|
259 |
|
---|
260 |
|
---|
261 | #if ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
262 | /*u8_t sio_recv( struct netif * netif )*/
|
---|
263 | u8_t sio_recv( sio_status_t * siostat )
|
---|
264 | {
|
---|
265 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio; */
|
---|
266 | return fifoGet( &(siostat->myfifo) );
|
---|
267 | }
|
---|
268 |
|
---|
269 | s16_t sio_poll(sio_status_t * siostat)
|
---|
270 | {
|
---|
271 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio;*/
|
---|
272 | return fifoGetNonBlock( &(siostat->myfifo) );
|
---|
273 | }
|
---|
274 |
|
---|
275 |
|
---|
276 | void sio_expect_string( u8_t *str, sio_status_t * siostat )
|
---|
277 | {
|
---|
278 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio;*/
|
---|
279 | u8_t c;
|
---|
280 | int finger=0;
|
---|
281 |
|
---|
282 | LWIP_DEBUGF(SIO_DEBUG, ("sio_expect_string[%d]: %s\n", siostat->fd, str));
|
---|
283 | while ( 1 )
|
---|
284 | {
|
---|
285 | c=fifoGet( &(siostat->myfifo) );
|
---|
286 | LWIP_DEBUGF(SIO_DEBUG, ("_%c", c));
|
---|
287 | if ( c==str[finger] )
|
---|
288 | {
|
---|
289 | finger++;
|
---|
290 | } else if ( finger > 0 )
|
---|
291 | {
|
---|
292 | /*it might fit in the beginning? */
|
---|
293 | if ( str[0] == c )
|
---|
294 | {
|
---|
295 | finger = 1;
|
---|
296 | }
|
---|
297 | }
|
---|
298 | if ( 0 == str[finger] )
|
---|
299 | break; /* done, we have a match */
|
---|
300 | }
|
---|
301 | LWIP_DEBUGF(SIO_DEBUG, ("sio_expect_string[%d]: [match]\n", siostat->fd));
|
---|
302 | }
|
---|
303 | #endif /* ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF) */
|
---|
304 |
|
---|
305 | #if (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
306 | u32_t sio_write(sio_status_t * siostat, u8_t *buf, u32_t size)
|
---|
307 | {
|
---|
308 | ssize_t wsz = write( siostat->fd, buf, size );
|
---|
309 | return wsz < 0 ? 0 : wsz;
|
---|
310 | }
|
---|
311 |
|
---|
312 | u32_t sio_read(sio_status_t * siostat, u8_t *buf, u32_t size)
|
---|
313 | {
|
---|
314 | ssize_t rsz = read( siostat->fd, buf, size );
|
---|
315 | return rsz < 0 ? 0 : rsz;
|
---|
316 | }
|
---|
317 |
|
---|
318 | void sio_read_abort(sio_status_t * siostat)
|
---|
319 | {
|
---|
320 | LWIP_UNUSED_ARG(siostat);
|
---|
321 | printf("sio_read_abort[%d]: not yet implemented for unix\n", siostat->fd);
|
---|
322 | }
|
---|
323 | #endif /* (PPP_SUPPORT || LWIP_HAVE_SLIPIF) */
|
---|
324 |
|
---|
325 | sio_fd_t sio_open(u8_t devnum)
|
---|
326 | {
|
---|
327 | char dev[20];
|
---|
328 |
|
---|
329 | /* would be nice with dynamic memory alloc */
|
---|
330 | sio_status_t * siostate = &statusar[ devnum ];
|
---|
331 | /* siostruct_t * tmp; */
|
---|
332 |
|
---|
333 |
|
---|
334 | /* tmp = (siostruct_t*)(netif->state); */
|
---|
335 | /* tmp->sio = siostate; */
|
---|
336 |
|
---|
337 | /* tmp = (siostruct_t*)(netif->state); */
|
---|
338 |
|
---|
339 | /* ((sio_status_t*)(tmp->sio))->fd = 0; */
|
---|
340 |
|
---|
341 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open: for devnum %d\n", devnum));
|
---|
342 |
|
---|
343 | #if ! (PPP_SUPPORT || LWIP_HAVE_SLIPIF)
|
---|
344 | fifoInit( &siostate->myfifo );
|
---|
345 | #endif /* ! PPP_SUPPORT */
|
---|
346 |
|
---|
347 | snprintf( dev, sizeof(dev), "/dev/ttyS%d", devnum );
|
---|
348 |
|
---|
349 | if ( (devnum == 1) || (devnum == 0) )
|
---|
350 | {
|
---|
351 | if ( ( siostate->fd = sio_init( dev, devnum, siostate ) ) == 0 )
|
---|
352 | {
|
---|
353 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open: ERROR opening serial device dev=%s\n", dev));
|
---|
354 | abort( );
|
---|
355 | return NULL;
|
---|
356 | }
|
---|
357 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open[%d]: dev=%s open.\n", siostate->fd, dev));
|
---|
358 | }
|
---|
359 | #if PPP_SUPPORT
|
---|
360 | else if (devnum == 2) {
|
---|
361 | pid_t childpid;
|
---|
362 | char name[256];
|
---|
363 | childpid = forkpty(&siostate->fd, name, NULL, NULL);
|
---|
364 | if(childpid < 0) {
|
---|
365 | perror("forkpty");
|
---|
366 | exit (1);
|
---|
367 | }
|
---|
368 | if(childpid == 0) {
|
---|
369 | execl("/usr/sbin/pppd", "pppd",
|
---|
370 | "ms-dns", "198.168.100.7",
|
---|
371 | "local", "crtscts",
|
---|
372 | "debug",
|
---|
373 | #ifdef LWIP_PPP_CHAP_TEST
|
---|
374 | "auth",
|
---|
375 | "require-chap",
|
---|
376 | "remotename", "lwip",
|
---|
377 | #else
|
---|
378 | "noauth",
|
---|
379 | #endif
|
---|
380 | #if LWIP_IPV6
|
---|
381 | "+ipv6",
|
---|
382 | #endif
|
---|
383 | "192.168.1.1:192.168.1.2",
|
---|
384 | NULL);
|
---|
385 | perror("execl pppd");
|
---|
386 | exit (1);
|
---|
387 | } else {
|
---|
388 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open[%d]: spawned pppd pid %d on %s\n",
|
---|
389 | siostate->fd, childpid, name));
|
---|
390 | }
|
---|
391 |
|
---|
392 | }
|
---|
393 | #endif
|
---|
394 | #if LWIP_HAVE_SLIPIF
|
---|
395 | else if (devnum == 3) {
|
---|
396 | pid_t childpid;
|
---|
397 | /* create PTY pair */
|
---|
398 | siostate->fd = posix_openpt(O_RDWR | O_NOCTTY);
|
---|
399 | if (siostate->fd < 0) {
|
---|
400 | perror("open pty master");
|
---|
401 | exit (1);
|
---|
402 | }
|
---|
403 | if (grantpt(siostate->fd) != 0) {
|
---|
404 | perror("grant pty master");
|
---|
405 | exit (1);
|
---|
406 | }
|
---|
407 | if (unlockpt(siostate->fd) != 0) {
|
---|
408 | perror("unlock pty master");
|
---|
409 | exit (1);
|
---|
410 | }
|
---|
411 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open[%d]: for %s\n",
|
---|
412 | siostate->fd, ptsname(siostate->fd)));
|
---|
413 | /* fork for slattach */
|
---|
414 | childpid = fork();
|
---|
415 | if(childpid < 0) {
|
---|
416 | perror("fork");
|
---|
417 | exit (1);
|
---|
418 | }
|
---|
419 | if(childpid == 0) {
|
---|
420 | /* esteblish SLIP interface on host side connected to PTY slave */
|
---|
421 | execl("/sbin/slattach", "slattach",
|
---|
422 | "-d", "-v", "-L", "-p", "slip",
|
---|
423 | ptsname(siostate->fd),
|
---|
424 | NULL);
|
---|
425 | perror("execl slattach");
|
---|
426 | exit (1);
|
---|
427 | } else {
|
---|
428 | int ret;
|
---|
429 | char buf[1024];
|
---|
430 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open[%d]: spawned slattach pid %d on %s\n",
|
---|
431 | siostate->fd, childpid, ptsname(siostate->fd)));
|
---|
432 | /* wait a moment for slattach startup */
|
---|
433 | sleep(1);
|
---|
434 | /* configure SLIP interface on host side as P2P interface */
|
---|
435 | snprintf(buf, sizeof(buf),
|
---|
436 | "/sbin/ifconfig sl0 mtu %d %s pointopoint %s up",
|
---|
437 | SLIP_MAX_SIZE, "192.168.2.1", "192.168.2.2");
|
---|
438 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open[%d]: system(\"%s\");\n", siostate->fd, buf));
|
---|
439 | ret = system(buf);
|
---|
440 | if (ret < 0) {
|
---|
441 | perror("ifconfig failed");
|
---|
442 | exit(1);
|
---|
443 | }
|
---|
444 | }
|
---|
445 | }
|
---|
446 | #endif /* LWIP_HAVE_SLIPIF */
|
---|
447 | else
|
---|
448 | {
|
---|
449 | LWIP_DEBUGF(SIO_DEBUG, ("sio_open: device %s (%d) is not supported\n", dev, devnum));
|
---|
450 | return NULL;
|
---|
451 | }
|
---|
452 |
|
---|
453 | return siostate;
|
---|
454 | }
|
---|
455 |
|
---|
456 | /**
|
---|
457 | *
|
---|
458 | */
|
---|
459 | void sio_change_baud( sioBaudrates baud, sio_status_t * siostat )
|
---|
460 | {
|
---|
461 | /* sio_status_t * siostat = ((siostruct_t*)netif->state)->sio;*/
|
---|
462 |
|
---|
463 | LWIP_DEBUGF(SIO_DEBUG, ("sio_change_baud[%d]\n", siostat->fd));
|
---|
464 |
|
---|
465 | switch ( baud )
|
---|
466 | {
|
---|
467 | case SIO_BAUD_9600:
|
---|
468 | sio_speed( siostat->fd, B9600 );
|
---|
469 | break;
|
---|
470 | case SIO_BAUD_19200:
|
---|
471 | sio_speed( siostat->fd, B19200 );
|
---|
472 | break;
|
---|
473 | case SIO_BAUD_38400:
|
---|
474 | sio_speed( siostat->fd, B38400 );
|
---|
475 | break;
|
---|
476 | case SIO_BAUD_57600:
|
---|
477 | sio_speed( siostat->fd, B57600 );
|
---|
478 | break;
|
---|
479 | case SIO_BAUD_115200:
|
---|
480 | sio_speed( siostat->fd, B115200 );
|
---|
481 | break;
|
---|
482 |
|
---|
483 | default:
|
---|
484 | LWIP_DEBUGF(SIO_DEBUG, ("sio_change_baud[%d]: Unknown baudrate, code:%d\n",
|
---|
485 | siostat->fd, baud));
|
---|
486 | break;
|
---|
487 | }
|
---|
488 | }
|
---|
489 |
|
---|