source: rtems/c/src/lib/libbsp/m68k/mvme162/consolex/consolex.c @ 6693a68

4.104.114.84.95
Last change on this file since 6693a68 was 60b791ad, checked in by Joel Sherrill <joel.sherrill@…>, on Feb 17, 1998 at 11:46:28 PM

updated copyright to 1998

  • Property mode set to 100644
File size: 18.8 KB
Line 
1/*
2 *  This file contains the MVME162LX extended console IO package.
3 *
4 *  This file was created originally by
5 *  On-Line Applications Research Corporation (OAR)
6 *  and modified by:
7 *
8 *  Katsutoshi Shibuya - BU-Denken Co.,Ltd. - Sapporo, JAPAN
9 *
10 *  featuring support of:
11 *
12 *     - Multi-SCC chip handling
13 *     - Non-blocking I/O (O_NDELAY flag in libc)
14 *     - Raw mode device (no CR/LF detection)
15 *     - RTS/CTS flow control
16 *
17 *  REMARKS: This routine requires multiple interrupt vectors
18 *           from SCC_VECTOR (normaly 0x40)
19 *           to SCC_VECTOR+(number of SCC chips)
20 *
21 *  The original copyright follows;
22 *
23 *  COPYRIGHT (c) 1989-1998.
24 *  On-Line Applications Research Corporation (OAR).
25 *  Copyright assigned to U.S. Government, 1994.
26 *
27 *  The license and distribution terms for this file may be
28 *  found in the file LICENSE in this distribution or at
29 *  http://www.OARcorp.com/rtems/license.html.
30 *
31 *  Modifications of respective RTEMS file: COPYRIGHT (c) 1994.
32 *  EISCAT Scientific Association. M.Savitski
33 *
34 *  This material is a part of the MVME162 Board Support Package
35 *  for the RTEMS executive. Its licensing policies are those of the
36 *  RTEMS above.
37 *
38 *  $Id$
39 */
40
41#define M162_INIT
42
43#include "consolex.h"
44#include <bsp.h>
45#include <rtems/libio.h>
46#include <stdio.h>
47#include <string.h>
48#include <ctype.h>
49
50#define NPORTS  4       /* Number of ports */
51#define DEVICEPREFIX    "tty"
52#define RAWDEVICEPREFIX "rtty"
53#define CONSOLEPORT 0   /* port# of console:
54                           undef this if you do not want /dev/console */
55#define READRETRY 1     /* Maximum retry count for read one char */
56#define WRITERETRY 8    /* Maximum retry count for write one char */
57
58#define PORTFROM 0      /* for debug */
59
60static unsigned char    opencount[NPORTS];
61
62/***********************************************************************
63   Ring buffer for device
64 ***********************************************************************/
65
66#define QUEUE_LENGTH 128        /* Must be 2^n number */
67
68typedef struct {
69  char buffer[QUEUE_LENGTH];
70  volatile int  head;
71  volatile int  tail;
72} ReceiverBuffer;
73
74#define ReceiverBufferInitialize( _buffer ) \
75  do { \
76    (_buffer)->head = (_buffer)->tail = 0; \
77  } while ( 0 )
78 
79#define ReceiverBufferIsEmpty( _buffer ) \
80   ( (_buffer)->tail == (_buffer)->head )
81
82#define ReceiverBufferIsNearEmpty( _buffer ) \
83   ( (_buffer)->tail == (((_buffer)->head + 3) & (QUEUE_LENGTH-1)) )
84
85#define ReceiverBufferIsFull( _buffer ) \
86   ( (_buffer)->head == (((_buffer)->tail + 1) & (QUEUE_LENGTH-1)) )
87
88#define ReceiverBufferIsNearFull( _buffer ) \
89   ( (_buffer)->head == (((_buffer)->tail + 3) & (QUEUE_LENGTH-1)) )
90
91#define ReceiverBufferAdd( _buffer, _ch ) \
92  do { \
93    rtems_unsigned32 isrlevel; \
94    \
95    rtems_interrupt_disable( isrlevel ); \
96      (_buffer)->tail = ((_buffer)->tail+1) & (QUEUE_LENGTH-1); \
97      (_buffer)->buffer[ (_buffer)->tail ] = (_ch); \
98    rtems_interrupt_enable( isrlevel ); \
99  } while ( 0 )
100
101#define ReceiverBufferRemove( _buffer, _ch ) \
102  do { \
103    rtems_unsigned32 isrlevel; \
104    \
105    rtems_interrupt_disable( isrlevel ); \
106      (_buffer)->head = ((_buffer)->head+1) & (QUEUE_LENGTH-1); \
107      (_ch) = (_buffer)->buffer[ (_buffer)->head ]; \
108    rtems_interrupt_enable( isrlevel ); \
109  } while ( 0 )
110
111
112/***********************************************************************
113   DEVICE DEPENDED PART
114 ***********************************************************************/
115
116
117/* Time constant parameters
118   CAUTION: These parameters are for MVME162LX-213 board.
119 */
120
121#define TC38400 0x0006
122#define TC19200 0x000e
123#define TC9600  0x001e
124
125/* Re-defining SCC register control macros
126   to support Multi SCC chips */
127
128#undef  scc
129#if defined(mvme162lx)
130static scc_regs *scc[NPORTS] = {
131    ((scc_regs * const) 0xFFF45004),
132    ((scc_regs * const) 0xFFF45000),
133    ((scc_regs * const) 0xFFF45804),
134    ((scc_regs * const) 0xFFF45800)
135};
136#else
137/* XXX fix me */
138#warning "MVME162 BSP -- unknown address for SCC's"
139static scc_regs *scc[NPORTS] = {
140    ((scc_regs * const) 0xFFF45004),
141    ((scc_regs * const) 0xFFF45000),
142    ((scc_regs * const) 0xFFF45804),
143    ((scc_regs * const) 0xFFF45800)
144};
145#endif
146
147#undef  ZWRITE0
148#define ZWRITE0(port, v)  (scc[port]->csr = (unsigned char)(v))
149#undef  ZREAD0
150#define ZREAD0(port)  (scc[port]->csr)
151
152#undef  ZREAD
153#define ZREAD(port, n)  (ZWRITE0(port, n), (scc[port]->csr))
154#undef  ZREADD
155#define ZREADD(port)  (scc[port]->csr=0x08, scc[port]->csr )
156
157#undef  ZWRITE
158#define ZWRITE(port, n, v) (ZWRITE0(port, n), ZWRITE0(port, v))
159#undef  ZWRITED
160#define ZWRITED(port, v)  (scc[port]->csr = 0x08, \
161                           scc[port]->csr = (unsigned char)(v))
162
163static ReceiverBuffer   receiverBuffer[NPORTS];
164
165/*
166 *  Control flags (DTR/DCD/RTS/CTS)
167 */
168
169static unsigned char    wr4[NPORTS];
170static unsigned char    wr5[NPORTS];
171#define SCCSetDTR(port) ZWRITE(port, 5, (wr5[port] |= 0x80))
172#define SCCResetDTR(port) ZWRITE(port, 5, (wr5[port] &= ~0x80))
173#define SCCSetRTS(port) ZWRITE(port, 5, (wr5[port] |= 0x02))
174#define SCCResetRTS(port) ZWRITE(port,5, (wr5[port] &= ~0x02))
175#define SCCGetDCD(port) (ZREAD0(port)&0x08)
176#define SCCGetCTS(port) (ZREAD0(port)&0x20)
177
178
179/*
180 *  Interrupt handler for receiver interrupts
181 */
182
183static rtems_isr        SCCReceiverISR(rtems_vector_number vector)
184{
185    register int    ipend, port;
186
187    port = (vector-SCC_VECTOR)*2;
188    ZWRITE0(port, 0x38);        /* reset highest IUS */
189
190    ipend = ZREAD(port, 3);     /* read int pending from A side */
191
192    if(ipend == 0x04)
193        port++; /* channel B intr pending */
194    else if(ipend == 0x20)
195        ;       /* channel A intr pending */
196    else
197        return;
198   
199    ReceiverBufferAdd(&receiverBuffer[port], ZREADD(port));
200   
201    if(ZREAD(port,1) & 0x70){ /* check error stat */
202        ZWRITE0(port, 0x30);    /* reset error */
203    }
204
205    if(ReceiverBufferIsNearFull(&receiverBuffer[port]))
206        SCCResetRTS(port);
207}
208
209/*
210 * Initialize
211 */
212
213void    SCCInitialize()
214{
215    int     i;
216
217    for(i = PORTFROM; i < NPORTS; i+=2)
218        ZWRITE(i, 9,0xc0);      /* Reset SCC Chip */
219   
220    for(i = PORTFROM; i < NPORTS; i++){
221        ReceiverBufferInitialize(&(receiverBuffer[i]));
222        wr4[i] = 0x44;
223        ZWRITE(i, 4, wr4[i]);   /* x16 clock, 1 stop, parity none */
224        ZWRITE(i, 1, 0);        /* disable interrupts */
225        ZWRITE(i, 2, SCC_VECTOR+(i/2));
226        ZWRITE(i, 3, 0xc1);     /* receiver enable, 8bits */
227        wr5[i] = 0x68;
228        ZWRITE(i, 5, wr5[i]);   /* transmitter enable, 8bits, DTR&RTS off */
229        ZWRITE(i,14, 0);        /* stop baudrate gen. */
230        ZWRITE(i,11,0x50);      /* use baurate gen. */
231        ZWRITE(i,15, 1);        /* Select WR7' */
232        ZWRITE(i, 7, 0);        /* Disable all special interrupts */
233        ZWRITE(i,10, 0);
234        ZWRITE(i, 1, 0x10);     /* int on all Rx chars or special condition */
235        set_vector(SCCReceiverISR, SCC_VECTOR+(i/2), 1); /* install ISR */
236        ZWRITE(i, 9, 8);        /* master interrupt enable */
237        ZWRITE(i,12,TC38400&0xff);      /* set 38400 baud */
238        ZWRITE(i,13,TC38400>>8);
239        ZWRITE(i,14, 3);        /* start baudrate gen. */
240                                /* CAUTION: If your SCC use XTAL on RTxC,
241                                   write 1 */
242    }
243    mcchip->vector_base = 0;
244    mcchip->gen_control = 2;    /* MIEN */
245    mcchip->SCC_int_ctl = 0x13; /* SCC IEN, IPL3 */
246}
247
248/*
249 *   Non-blocking char input
250 */
251
252rtems_boolean   SCCGetOne(int port, char *ch)
253{
254    int retry = READRETRY;
255    while(ReceiverBufferIsEmpty(&receiverBuffer[port]))
256        if(--retry <= 0)
257            return FALSE;
258
259    ReceiverBufferRemove(&receiverBuffer[port],*ch);
260
261    if(ReceiverBufferIsNearEmpty(&receiverBuffer[port]))
262        SCCSetRTS(port);
263    return TRUE;
264}
265
266/*
267 *   Blocking char input
268 */
269
270char    SCCGetOneBlocked(int port)
271{
272    unsigned char tmp_char;
273 
274    while (!SCCGetOne(port, &tmp_char))
275        rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
276    return tmp_char;
277}
278
279/*
280 *   Non-blocking char input
281 *   No longer supports XON/XOFF flow control.
282 */
283
284rtems_boolean   SCCSendOne(int port, char ch)
285{
286    int retry = WRITERETRY;
287
288    if(!SCCGetCTS(port))
289        return FALSE;
290    while(!(ZREAD0(port) & TX_BUFFER_EMPTY))
291        if(--retry <= 0)
292            return FALSE;
293    ZWRITED(port, ch);
294    return TRUE;
295}
296
297
298/* 
299 *   Blocking char output
300 *   No longer supports XON/XOFF flow control.
301 */
302
303void    SCCSendOneBlocked(int port, char ch)
304{
305    while(!SCCSendOne(port, ch))
306        rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
307}
308
309/*
310 * Set parameters for transmission
311 */
312
313unsigned32      SCCSetAttributes(int port, struct termios *t)
314{
315    unsigned char       wr3;
316   
317    ZWRITE(port,1,0);   /* Disable interrupt */
318    ZWRITE(port,3,0);   /* Disable receiver */
319    /* Baud */
320    switch(t->c_cflag & CBAUD){
321    case B38400:
322        ZWRITE(port,12,TC38400&0xff);
323        ZWRITE(port,13,TC38400>>8);
324        break;
325    case B19200:
326        ZWRITE(port,12,TC19200&0xff);
327        ZWRITE(port,13,TC19200>>8);
328        break;
329    case B9600:
330        ZWRITE(port,12,TC9600&0xff);
331        ZWRITE(port,13,TC9600>>8);
332        break;
333    }
334   
335    /* Code size */
336    wr5[port] &= 0x8f;
337    wr3 = 0;    /* receiver control */
338    switch(t->c_cflag & CSIZE){
339    case CS8:
340        wr5[port] |= 0x60;
341        wr3 |= 0xc0;
342        break;
343    case CS7:
344        wr5[port] |= 0x20;
345        wr3 |= 0x40;
346        break;
347    }
348
349    /* Parity */
350    wr4[port] &= 0xf0;
351    if(t->c_cflag & PARENB)
352        wr4[port] |= 0x01;
353    if(!(t->c_cflag & PARODD))
354        wr4[port] |= 0x02;
355    /* ZWRITE(port,4,wr4[port]);*/
356
357    /* Stop bits */
358    /* wr4[port] = ZREAD(port,4) & 0xfc;*/
359    if(t->c_cflag & CSTOPB)
360        wr4[port] |= 0x0c;
361    else
362        wr4[port] |= 0x04;
363   
364    ZWRITE(port,4,wr4[port]);   /* TxRx parameters */
365    ZWRITE(port,5,wr5[port]);   /* Transmission parameters */
366    ZWRITE(port,3,wr3|0x01);    /* Enable receiver */
367    ZWRITE(port,1,0x10);        /* Enable interrupt */
368
369    return 0;
370}
371
372/*
373 * Get parameters for transmission
374 */
375
376unsigned32      SCCGetAttributes(int port, struct termios *t)
377{
378    unsigned32  b;
379
380    t->c_cflag = 0;
381   
382    /* Baud */
383    b = ZREAD(port,13);
384    b <<= 8;
385    b |= ZREAD(port,12);
386    switch(b){
387    case TC38400:
388        t->c_cflag |= B38400;
389        break;
390    case TC19200:
391        t->c_cflag |= B19200;
392        break;
393    case TC9600:
394        t->c_cflag |= B9600;
395        break;
396    }
397   
398    /* Code size */
399    /* wr = ZREAD(port,5);*/
400    t->c_cflag &= ~CSIZE;
401    switch(wr5[port]&0x60){
402    case 0x60:
403        t->c_cflag |= CS8;
404        break;
405    case 0x20:
406        t->c_cflag |= CS7;
407        break;
408    }
409
410    /* Parity */
411    /* wr = ZREAD(port,4);*/
412    if(wr4[port] & 0x01)
413        t->c_cflag |= PARENB;
414    else
415        t->c_cflag &= ~PARENB;
416    if(wr4[port] & 0x02)
417        t->c_cflag &= ~PARODD;
418    else
419        t->c_cflag |= PARODD;
420
421    /* Stop bits */
422    /* wr = ZREAD(port,4);*/
423    if((wr4[port]&0xc0) == 0xc0)
424        t->c_cflag |= CSTOPB;
425    else
426        t->c_cflag &= ~CSTOPB;
427
428    return 0;
429}
430
431/***********************************************************************
432   DEVICE INDEPENDED PART
433 ***********************************************************************/
434
435#define LOCAL_ISTRIP    0x0001
436#define LOCAL_INLCR     0x0002
437#define LOCAL_IGNCR     0x0004
438#define LOCAL_ICRNL     0x0008
439#define LOCAL_IUCLC     0x0010
440#define LOCAL_OLCUC     0x0020
441#define LOCAL_ONLCR     0x0040
442#define LOCAL_OCRNL     0x0080
443#define LOCAL_ICANON    0x0100
444#define LOCAL_ECHO      0x0200
445
446/*
447 *  Device initialize entry point
448 */
449
450rtems_device_driver consolex_initialize(rtems_device_major_number  major,
451                                        rtems_device_minor_number  minor,
452                                        void *arg)
453{
454    rtems_status_code   status;
455    char        devname[16];
456    int         i;
457   
458    SCCInitialize();
459
460#ifdef  CONSOLEPORT
461    status = rtems_io_register_name("/dev/console",major,
462                                    (rtems_device_minor_number) CONSOLEPORT);
463    if (status != RTEMS_SUCCESSFUL)
464        rtems_fatal_error_occurred(status);
465#endif
466   
467    for(i = PORTFROM; i < NPORTS; i++){
468        /* Register cooked ttys */
469        sprintf(devname,"/dev/%s%02d",DEVICEPREFIX,i);
470        status = rtems_io_register_name(strdup(devname),major,
471                                        (rtems_device_minor_number) i);
472        if (status != RTEMS_SUCCESSFUL)
473            rtems_fatal_error_occurred(status);
474        /* Register raw ttys */
475        sprintf(devname,"/dev/%s%02d",RAWDEVICEPREFIX,i);
476        status = rtems_io_register_name(strdup(devname),major,
477                                        (rtems_device_minor_number) i+NPORTS);
478        if (status != RTEMS_SUCCESSFUL)
479            rtems_fatal_error_occurred(status);
480    }
481
482    for(i = 0; i < NPORTS; i++){
483        opencount[i] = 0;
484    }
485   
486    return RTEMS_SUCCESSFUL;
487}
488
489/*
490 *  Open entry point
491 */
492
493rtems_device_driver consolex_open(rtems_device_major_number major,
494                                  rtems_device_minor_number minor,
495                                  void *arg)
496{
497    rtems_libio_open_close_args_t *openargs = (rtems_libio_open_close_args_t *) arg;
498    if(minor >= NPORTS)
499        minor -= NPORTS;
500    if(minor >= NPORTS)
501        return RTEMS_INVALID_NUMBER;
502
503    if(opencount[minor]++ == 0){
504        /* first open */
505        SCCSetDTR(minor);
506        SCCSetRTS(minor);
507    }
508    openargs->iop->data0 = LOCAL_ICRNL|LOCAL_ONLCR|LOCAL_ICANON|LOCAL_ECHO;
509    return RTEMS_SUCCESSFUL;
510}
511
512/*
513 *  Close entry point
514 */
515
516rtems_device_driver consolex_close(rtems_device_major_number major,
517                                   rtems_device_minor_number minor,
518                                   void *arg)
519{
520    if(minor >= NPORTS)
521        minor -= NPORTS;
522    if(minor >= NPORTS)
523        return RTEMS_INVALID_NUMBER;
524
525    if(--(opencount[minor]) == 0){
526        /* closed all */
527        SCCResetRTS(minor);
528        SCCResetDTR(minor);
529    }
530    return RTEMS_SUCCESSFUL;
531}
532
533/*
534 * read bytes from the serial port.
535 */
536
537rtems_device_driver consolex_read_raw(rtems_device_major_number major,
538                                      rtems_device_minor_number minor,
539                                      void *arg)
540{
541    rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) arg;
542    char *buffer;
543    int count;
544
545    if(minor >= NPORTS)
546        return RTEMS_INVALID_NUMBER;
547
548    buffer = rw_args->buffer;
549    count = rw_args->count;
550
551    if(rw_args->flags & LIBIO_FLAGS_NO_DELAY){
552        /* Non blocking read */
553        while(count){
554            if(!SCCGetOne(minor,buffer))
555                break;
556            buffer++;
557            count--;
558        }
559    }else{
560        /* Blocking read */
561        while(count){
562            *buffer = SCCGetOneBlocked(minor);
563            buffer++;
564            count--;
565        }
566    }
567
568    rw_args->bytes_moved = rw_args->count-count;
569    return count ? RTEMS_UNSATISFIED : RTEMS_SUCCESSFUL;
570}
571
572rtems_device_driver consolex_read(rtems_device_major_number major,
573                                      rtems_device_minor_number minor,
574                                      void *arg)
575{
576    rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) arg;
577    char *buffer;
578    int count;
579    unsigned32  mode;
580
581    if(minor >= NPORTS)
582        return consolex_read_raw(major,minor-NPORTS,arg);
583
584    buffer = rw_args->buffer;
585    count = rw_args->count;
586    mode = rw_args->iop->data0;
587   
588    /* Cooked read */
589    while(count){
590        if(rw_args->flags & LIBIO_FLAGS_NO_DELAY){
591            /* Non blocking read */
592            if(!SCCGetOne(minor,buffer))
593                break;
594        }else{
595            /* Blocking read */
596            *buffer = SCCGetOneBlocked(minor);
597        }
598        if((mode&LOCAL_ICANON) && (*buffer == '\b')){
599            if(buffer > (char *)(rw_args->buffer)){
600                buffer--;
601                count++;
602                if(mode&LOCAL_ECHO){
603                    SCCSendOneBlocked(minor,'\b');
604                    SCCSendOneBlocked(minor,' ');
605                    SCCSendOneBlocked(minor,'\b');
606                }
607            }
608            continue;
609        }
610        if((mode&LOCAL_IGNCR) && (*buffer == '\r'))
611            continue;
612        if((mode&LOCAL_INLCR) && (*buffer == '\n'))
613            *buffer = '\r';
614        if((mode&LOCAL_ICRNL) && (*buffer == '\r'))
615            *buffer = '\n';
616        if((mode&LOCAL_IUCLC) && isupper((int)*buffer))
617            *buffer = tolower(*buffer);
618        if(mode&LOCAL_ISTRIP)
619            *buffer &= 0x7f;
620        if(mode&LOCAL_ECHO){
621            /* Caution: Echo back is blocking output */
622            SCCSendOneBlocked(minor,*buffer);
623        }
624        if((mode&LOCAL_ICANON) && (*buffer == '\n')){
625            buffer++;
626            count--;
627            if(count)
628                *buffer = 0;
629            if((mode&LOCAL_ECHO)&&(mode&LOCAL_ONLCR))
630                SCCSendOneBlocked(minor,'\r');
631            break;      /* finish reading */
632        }
633        buffer++;
634        count--;
635    }
636    rw_args->bytes_moved = rw_args->count-count;
637    return count ? RTEMS_UNSATISFIED : RTEMS_SUCCESSFUL;
638}
639
640/*
641 * write bytes to the serial port.
642 */
643
644rtems_device_driver consolex_write_raw(rtems_device_major_number major,
645                                       rtems_device_minor_number minor,
646                                       void * arg)
647{
648    rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) arg;
649    char *buffer;
650    int count;
651
652    if(minor >= NPORTS)
653        return RTEMS_INVALID_NUMBER;
654
655    buffer = rw_args->buffer;
656    count = rw_args->count;
657
658    if(rw_args->flags & LIBIO_FLAGS_NO_DELAY){
659        /* Non blocking write */
660        while(count){
661            if(!SCCSendOne(minor,*buffer))
662                break;
663            buffer++;
664            count--;
665        }
666    }else{
667        /* Blocking write */
668        while(count){
669            SCCSendOneBlocked(minor,*buffer);
670            buffer++;
671            count--;
672        }
673    }
674   
675    rw_args->bytes_moved = rw_args->count-count;
676    return count ? RTEMS_UNSATISFIED : RTEMS_SUCCESSFUL;
677}
678
679rtems_device_driver consolex_write(rtems_device_major_number major,
680                                   rtems_device_minor_number minor,
681                                   void * arg)
682{
683    rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) arg;
684    char *buffer;
685    int count;
686    char        ch;
687    unsigned32  mode;
688
689    if(minor >= NPORTS)
690        return consolex_write_raw(major,minor-NPORTS,arg);
691
692    buffer = rw_args->buffer;
693    count = rw_args->count;
694    mode = rw_args->iop->data0;
695
696    /* Cooked write */
697    while(count){
698        ch = *buffer;
699        if((mode&LOCAL_ONLCR) && (ch == '\n')){ /* Output CRLF */
700            if(rw_args->flags & LIBIO_FLAGS_NO_DELAY){
701                /* Non blocking write */
702                if(!SCCSendOne(minor,'\r'))
703                    break;
704            }else{
705                SCCSendOneBlocked(minor,'\r');
706            }
707        }
708        if((mode&LOCAL_OCRNL) && (ch == '\r'))
709            ch = '\n';
710        if((mode&OLCUC) && (islower((int)ch)))
711            ch = toupper(ch);
712        if(rw_args->flags & LIBIO_FLAGS_NO_DELAY){
713            /* Non blocking write */
714            if(!SCCSendOne(minor,ch))
715                break;
716        }else{
717            SCCSendOneBlocked(minor,ch);
718        }
719        buffer++;
720        count--;
721    }
722   
723    rw_args->bytes_moved = rw_args->count-count;
724    return count ? RTEMS_UNSATISFIED : RTEMS_SUCCESSFUL;
725}
726
727/*
728 *  IO Control entry point
729 */
730
731rtems_device_driver consolex_control(rtems_device_major_number major,
732                                     rtems_device_minor_number minor,
733                                     void * arg)
734{
735    rtems_libio_ioctl_args_t    *ioarg = (rtems_libio_ioctl_args_t *)arg;
736    struct termios      *tm = ioarg->buffer;
737    unsigned32  *mode = &(ioarg->iop->data0);
738
739    if(minor >= NPORTS)
740        minor -= NPORTS;
741    if(minor >= NPORTS)
742        return RTEMS_INVALID_NUMBER;
743
744    switch(ioarg->command){
745    case RTEMS_IO_GET_ATTRIBUTES:
746        tm->c_iflag = tm->c_oflag = tm->c_cflag = tm->c_lflag = 0;
747        if(*mode & LOCAL_ISTRIP)
748            tm->c_iflag |= ISTRIP;
749        if(*mode & LOCAL_INLCR)
750            tm->c_iflag |= INLCR;
751        if(*mode & LOCAL_IGNCR)
752            tm->c_iflag |= IGNCR;
753        if(*mode & LOCAL_ICRNL)
754            tm->c_iflag |= ICRNL;
755        if(*mode & LOCAL_IUCLC)
756            tm->c_iflag |= IUCLC;
757        if(*mode & LOCAL_OLCUC)
758            tm->c_oflag |= OLCUC;
759        if(*mode & LOCAL_ONLCR)
760            tm->c_oflag |= ONLCR;
761        if(*mode & LOCAL_OCRNL)
762            tm->c_oflag |= OCRNL;
763        if(*mode & LOCAL_ICANON)
764            tm->c_lflag |= ICANON;
765        if(*mode & LOCAL_ECHO)
766            tm->c_lflag |= ECHO;
767        ioarg->ioctl_return = SCCGetAttributes(minor,tm);
768        break;
769    case RTEMS_IO_SET_ATTRIBUTES:
770        *mode = 0;
771        if(tm->c_iflag & ISTRIP)
772            *mode |= LOCAL_ISTRIP;
773        if(tm->c_iflag & INLCR)
774            *mode |= LOCAL_INLCR;
775        if(tm->c_iflag & IGNCR)
776            *mode |= LOCAL_IGNCR;
777        if(tm->c_iflag & ICRNL)
778            *mode |= LOCAL_ICRNL;
779        if(tm->c_iflag & IUCLC)
780            *mode |= LOCAL_IUCLC;
781        if(tm->c_oflag & OLCUC)
782            *mode |= LOCAL_OLCUC;
783        if(tm->c_oflag & ONLCR)
784            *mode |= LOCAL_ONLCR;
785        if(tm->c_oflag & OCRNL)
786            *mode |= LOCAL_OCRNL;
787        if(tm->c_lflag & ICANON)
788            *mode |= LOCAL_ICANON;
789        if(tm->c_lflag & ECHO)
790            *mode |= LOCAL_ECHO;
791        ioarg->ioctl_return = SCCSetAttributes(minor,tm);
792        break;
793    default:
794        return RTEMS_NOT_DEFINED;
795    }
796   
797    return RTEMS_SUCCESSFUL;
798}
Note: See TracBrowser for help on using the repository browser.