Changeset fd9fb21 in rtems


Ignore:
Timestamp:
Feb 1, 2017, 3:48:51 PM (3 years ago)
Author:
Martin Aberg <maberg@…>
Branches:
master
Children:
1fefc719
Parents:
7cb93250
git-author:
Martin Aberg <maberg@…> (02/01/17 15:48:51)
git-committer:
Daniel Hellstrom <daniel@…> (05/02/17 10:34:46)
Message:

leon, cons: drvmgr cons interface uses new TERMIOS

LEON driver manager console driver interface (cons) and the APBUART cons driver
(apbuart_cons) have been updated for recent TERMIOS interface changes. The
legacy callback API is not used anymore and deprecated functions are
eliminated.

This new implementation is based on RTEMS BSP and Device Driver Development
Guide, chapter named "Console Driver".

  • Functions marked as deprecated (rtems_termios_open() and rtems_termios_close()) have been updated with the present-day versions.
  • The legacy "callback" interface is replaced with the "handler" interface.
  • Implementation is inspired by the documentation example, the non-driver manager driver for APBUART (apbuart_termios).
  • Polled, interrupt and task mode is supported.
Location:
c/src/lib/libbsp/sparc/shared
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/sparc/shared/include/cons.h

    r7cb93250 rfd9fb21  
    1717#define __CONS_H__
    1818
     19#include <rtems/termiostypes.h>
     20
    1921struct console_dev;
    2022
    2123#define CONSOLE_FLAG_SYSCON      0x01
    2224
    23 struct console_cons_ops {
    24         void (*get_uart_attrs)(struct console_dev *, struct termios *t);
    25 };
    26 
    2725struct console_dev {
    28         /* Set to non-zero if this UART should be system console and/or
     26        rtems_termios_device_context base;
     27        /* Set to CONSOLE_FLAG_SYSCON if this UART should be system console and/or
    2928         * debug console.
    3029         */
    3130        int flags;
    3231        char *fsname; /* File system prefix */
    33         const struct rtems_termios_callbacks *callbacks; /* TERMIOS Callbacks */
    34         struct console_cons_ops ops;
     32        const rtems_termios_device_handler *handler;
    3533};
    3634
  • c/src/lib/libbsp/sparc/shared/uart/apbuart_cons.c

    r7cb93250 rfd9fb21  
    1919/******************* Driver manager interface ***********************/
    2020#include <bsp.h>
    21 #include <rtems/libio.h>
    2221#include <stdlib.h>
    2322#include <assert.h>
     
    5655        struct drvmgr_dev *dev;
    5756        struct apbuart_regs *regs;
     57        struct rtems_termios_tty *tty;
    5858        char devName[32];
    59         void *cookie;
    60         int sending;
     59        volatile int sending;
    6160        int mode;
    6261};
    6362
     63/* Getters for different interfaces. It happens to be just casting which we do
     64 * in one place to avoid getting cast away. */
     65static struct console_dev *base_get_condev(rtems_termios_device_context *base)
     66{
     67        return (struct console_dev *) base;
     68}
     69
     70static struct apbuart_priv *condev_get_priv(struct console_dev *condev)
     71{
     72        return (struct apbuart_priv *) condev;
     73}
     74
     75static struct apbuart_priv *base_get_priv(rtems_termios_device_context *base)
     76{
     77        return condev_get_priv(base_get_condev(base));
     78}
     79
    6480/* TERMIOS Layer Callback functions */
    65 void apbuart_get_attributes(struct console_dev *condev, struct termios *t);
    66 int apbuart_set_attributes(int minor, const struct termios *t);
    67 ssize_t apbuart_write_polled(int minor, const char *buf, size_t len);
    68 int apbuart_pollRead(int minor);
    69 ssize_t apbuart_write_intr(int minor, const char *buf, size_t len);
    70 int apbuart_pollRead_task(int minor);
    71 int apbuart_firstOpen(int major, int minor, void *arg);
    72 int apbuart_lastClose(int major, int minor, void *arg);
    73 
    74 void apbuart_isr(void *arg);
     81static bool first_open(
     82  rtems_termios_tty *tty,
     83  rtems_termios_device_context *base,
     84  struct termios *term,
     85  rtems_libio_open_close_args_t *args
     86);
     87static void last_close(
     88  rtems_termios_tty *tty,
     89  rtems_termios_device_context *base,
     90  rtems_libio_open_close_args_t *args
     91);
     92static void write_interrupt(
     93  rtems_termios_device_context *base,
     94  const char *buf,
     95  size_t len
     96);
     97static bool set_attributes(
     98        rtems_termios_device_context *base,
     99        const struct termios *t
     100);
     101static void get_attributes(
     102        rtems_termios_device_context *base,
     103        struct termios *t
     104);
     105static int read_polled(rtems_termios_device_context *base);
     106static int read_task(rtems_termios_device_context *base);
     107static void write_polled(
     108  rtems_termios_device_context *base,
     109  const char *buf,
     110  size_t len
     111);
     112
     113static void apbuart_cons_isr(void *arg);
    75114int apbuart_get_baud(struct apbuart_priv *uart);
    76115
     
    122161}
    123162
    124 /* Interrupt mode routines */
    125 static const rtems_termios_callbacks Callbacks_intr = {
    126     apbuart_firstOpen,           /* firstOpen */
    127     apbuart_lastClose,           /* lastClose */
    128     NULL,                        /* pollRead */
    129     apbuart_write_intr,          /* write */
    130     apbuart_set_attributes,      /* setAttributes */
    131     NULL,                        /* stopRemoteTx */
    132     NULL,                        /* startRemoteTx */
    133     TERMIOS_IRQ_DRIVEN           /* outputUsesInterrupts */
    134 };
    135 
    136 /* Polling mode routines */
    137 static const rtems_termios_callbacks Callbacks_task = {
    138     apbuart_firstOpen,           /* firstOpen */
    139     apbuart_lastClose,           /* lastClose */
    140     apbuart_pollRead_task,       /* pollRead */
    141     apbuart_write_intr,          /* write */
    142     apbuart_set_attributes,      /* setAttributes */
    143     NULL,                        /* stopRemoteTx */
    144     NULL,                        /* startRemoteTx */
    145     TERMIOS_TASK_DRIVEN          /* outputUsesInterrupts */
    146 };
    147 
    148 /* Polling mode routines */
    149 static const rtems_termios_callbacks Callbacks_poll = {
    150     apbuart_firstOpen,           /* firstOpen */
    151     apbuart_lastClose,           /* lastClose */
    152     apbuart_pollRead,            /* pollRead */
    153     apbuart_write_polled,        /* write */
    154     apbuart_set_attributes,      /* setAttributes */
    155     NULL,                        /* stopRemoteTx */
    156     NULL,                        /* startRemoteTx */
    157     TERMIOS_POLLED               /* outputUsesInterrupts */
     163static const rtems_termios_device_handler handler_interrupt = {
     164        .first_open     = first_open,
     165        .last_close     = last_close,
     166        .write          = write_interrupt,
     167        .set_attributes = set_attributes,
     168        .mode           = TERMIOS_IRQ_DRIVEN
     169};
     170
     171static const rtems_termios_device_handler handler_task = {
     172        .first_open     = first_open,
     173        .last_close     = last_close,
     174        .poll_read      = read_task,
     175        .write          = write_interrupt,
     176        .set_attributes = set_attributes,
     177        .mode           = TERMIOS_TASK_DRIVEN
     178};
     179
     180static const rtems_termios_device_handler handler_polled = {
     181        .first_open     = first_open,
     182        .last_close     = last_close,
     183        .poll_read      = read_polled,
     184        .write          = write_polled,
     185        .set_attributes = set_attributes,
     186        .mode           = TERMIOS_POLLED
    158187};
    159188
     
    248277
    249278        priv->condev.fsname = NULL;
    250         priv->condev.ops.get_uart_attrs = apbuart_get_attributes;
    251279
    252280        /* Select 0=Polled, 1=IRQ, 2=Task-Driven UART Mode */
     
    256284        else
    257285                priv->mode = TERMIOS_POLLED;
     286        /* TERMIOS device handlers */
    258287        if (priv->mode == TERMIOS_IRQ_DRIVEN) {
    259                 priv->condev.callbacks = &Callbacks_intr;
     288                priv->condev.handler = &handler_interrupt;
    260289        } else if (priv->mode == TERMIOS_TASK_DRIVEN) {
    261                 priv->condev.callbacks = &Callbacks_task;
     290                priv->condev.handler = &handler_task;
    262291        } else {
    263                 priv->condev.callbacks = &Callbacks_poll;
     292                priv->condev.handler = &handler_polled;
    264293        }
    265294
     
    368397#endif
    369398
    370 int apbuart_firstOpen(int major, int minor, void *arg)
    371 {
    372         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
    373         rtems_libio_open_close_args_t *ioarg = arg;
    374 
    375         if ( ioarg && ioarg->iop )
    376                 uart->cookie = ioarg->iop->data1;
    377         else
    378                 uart->cookie = NULL;
     399static bool first_open(
     400        rtems_termios_tty *tty,
     401        rtems_termios_device_context *base,
     402        struct termios *term,
     403        rtems_libio_open_close_args_t *args
     404)
     405{
     406        struct apbuart_priv *uart = base_get_priv(base);
     407
     408        uart->tty = tty;
     409
     410        /* Preserve values set by bootloader */
     411        get_attributes(base, term);
     412        term->c_oflag |= ONLCR;
     413        set_attributes(base, term);
    379414
    380415        /* Enable TX/RX */
    381         uart->regs->ctrl |= LEON_REG_UART_CTRL_RE | LEON_REG_UART_CTRL_TE;
     416        uart->regs->ctrl |= APBUART_CTRL_RE | APBUART_CTRL_TE;
    382417
    383418        if (uart->mode != TERMIOS_POLLED) {
     419                int ret;
     420
    384421                /* Register interrupt and enable it */
    385                 drvmgr_interrupt_register(uart->dev, 0, "apbuart",
    386                                                 apbuart_isr, uart);
     422                ret = drvmgr_interrupt_register(
     423                        uart->dev, 0, "apbuart", apbuart_cons_isr, tty
     424                );
     425                if (ret) {
     426                        return false;
     427                }
    387428
    388429                uart->sending = 0;
    389430                /* Turn on RX interrupts */
    390                 uart->regs->ctrl |= LEON_REG_UART_CTRL_RI;
    391         }
    392 
    393         return 0;
    394 }
    395 
    396 int apbuart_lastClose(int major, int minor, void *arg)
    397 {
    398         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
     431                uart->regs->ctrl |= APBUART_CTRL_RI;
     432        }
     433
     434        return true;
     435}
     436
     437static void last_close(
     438        rtems_termios_tty *tty,
     439        rtems_termios_device_context *base,
     440        rtems_libio_open_close_args_t *args
     441)
     442{
     443        struct apbuart_priv *uart = base_get_priv(base);
     444        rtems_interrupt_lock_context lock_context;
    399445
    400446        if (uart->mode != TERMIOS_POLLED) {
    401447                /* Turn off RX interrupts */
    402                 uart->regs->ctrl &= ~(LEON_REG_UART_CTRL_RI);
     448                rtems_termios_device_lock_acquire(base, &lock_context);
     449                uart->regs->ctrl &= ~(APBUART_CTRL_RI);
     450                rtems_termios_device_lock_release(base, &lock_context);
    403451
    404452                /**** Flush device ****/
     
    408456
    409457                /* Disable and unregister interrupt handler */
    410                 drvmgr_interrupt_unregister(uart->dev, 0, apbuart_isr, uart);
     458                drvmgr_interrupt_unregister(uart->dev, 0, apbuart_cons_isr, tty);
    411459        }
    412460
     
    414462        /* Disable TX/RX if not used for DEBUG */
    415463        if (uart->regs != dbg_uart)
    416                 uart->regs->ctrl &= ~(LEON_REG_UART_CTRL_RE | LEON_REG_UART_CTRL_TE);
     464                uart->regs->ctrl &= ~(APBUART_CTRL_RE | APBUART_CTRL_TE);
    417465#endif
    418 
    419         return 0;
    420 }
    421 
    422 int apbuart_pollRead(int minor)
    423 {
    424         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
     466}
     467
     468static int read_polled(rtems_termios_device_context *base)
     469{
     470        struct apbuart_priv *uart = base_get_priv(base);
    425471
    426472        return apbuart_inbyte_nonblocking(uart->regs);
    427473}
    428474
    429 int apbuart_pollRead_task(int minor)
    430 {
    431         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
     475static int read_task(rtems_termios_device_context *base)
     476{
     477        struct apbuart_priv *uart = base_get_priv(base);
    432478        int c, tot;
    433479        char buf[32];
    434 
     480        struct rtems_termios_tty *tty;
     481
     482        tty = uart->tty;
    435483        tot = 0;
    436484        while ((c=apbuart_inbyte_nonblocking(uart->regs)) != EOF) {
     
    438486                tot++;
    439487                if (tot > 31) {
    440                         rtems_termios_enqueue_raw_characters(uart->cookie, buf, tot);
     488                        rtems_termios_enqueue_raw_characters(tty, buf, tot);
    441489                        tot = 0;
    442490                }
    443491        }
    444492        if (tot > 0)
    445                 rtems_termios_enqueue_raw_characters(uart->cookie, buf, tot);
     493                rtems_termios_enqueue_raw_characters(tty, buf, tot);
    446494
    447495        return EOF;
     
    518566}
    519567
    520 int apbuart_set_attributes(int minor, const struct termios *t)
     568static bool set_attributes(
     569        rtems_termios_device_context *base,
     570        const struct termios *t
     571)
    521572{
    522573        unsigned int core_clk_hz;
     
    524575        unsigned int ctrl;
    525576        int baud;
    526         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
     577        struct apbuart_priv *uart = base_get_priv(base);
     578        rtems_interrupt_lock_context lock_context;
    527579
    528580        switch(t->c_cflag & CSIZE) {
     
    532584                case CS7:
    533585                        /* Hardware doesn't support other than CS8 */
    534                         return -1;
     586                        return false;
    535587                case CS8:
    536588                        break;
    537589        }
     590
     591        rtems_termios_device_lock_acquire(base, &lock_context);
    538592
    539593        /* Read out current value */
     
    567621        uart->regs->ctrl = ctrl;
    568622
     623        rtems_termios_device_lock_release(base, &lock_context);
     624
    569625        /* Baud rate */
    570626  baud = apbuart_baud_num2baud(t->c_ospeed);
     
    580636        }
    581637
    582         return 0;
    583 }
    584 
    585 void apbuart_get_attributes(struct console_dev *condev, struct termios *t)
    586 {
    587         struct apbuart_priv *uart = (struct apbuart_priv *)condev;
     638        return true;
     639}
     640
     641static void get_attributes(
     642        rtems_termios_device_context *base,
     643        struct termios *t
     644)
     645{
     646        struct apbuart_priv *uart = base_get_priv(base);
    588647        unsigned int ctrl;
    589648        struct apbuart_baud *baud;
     
    610669}
    611670
    612 ssize_t apbuart_write_polled(int minor, const char *buf, size_t len)
    613 {
     671static void write_polled(
     672        rtems_termios_device_context *base,
     673        const char *buf,
     674        size_t len
     675)
     676{
     677        struct apbuart_priv *uart = base_get_priv(base);
    614678        int nwrite = 0;
    615         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
    616679
    617680        while (nwrite < len) {
     
    619682                nwrite++;
    620683        }
    621         return nwrite;
    622 }
    623 
    624 ssize_t apbuart_write_intr(int minor, const char *buf, size_t len)
    625 {
    626         struct apbuart_priv *uart = (struct apbuart_priv *)minor;
    627         unsigned int oldLevel;
     684}
     685
     686static void write_interrupt(
     687        rtems_termios_device_context *base,
     688        const char *buf,
     689        size_t len
     690)
     691{
     692        struct apbuart_priv *uart = base_get_priv(base);
     693        struct apbuart_regs *regs = uart->regs;
     694        int sending;
    628695        unsigned int ctrl;
    629696
    630         rtems_interrupt_disable(oldLevel);
    631 
    632         /* Enable TX interrupt */
    633         ctrl = uart->regs->ctrl;
    634         uart->regs->ctrl = ctrl | LEON_REG_UART_CTRL_TI;
    635 
    636         if (ctrl & LEON_REG_UART_CTRL_FA) {
    637                 /* APBUART with FIFO.. Fill as many as FIFO allows */
    638                 uart->sending = 0;
    639                 while (((uart->regs->status & LEON_REG_UART_STATUS_TF) == 0) &&
    640                        (uart->sending < len)) {
    641                         uart->regs->data = *buf;
    642                         buf++;
    643                         uart->sending++;
     697        ctrl = regs->ctrl;
     698
     699        if (len > 0) {
     700                /*
     701                 * sending is used to remember how much we have outstanding so
     702                 * we can tell termios later.
     703                 */
     704                /* Enable TX interrupt (interrupt is edge-triggered) */
     705                regs->ctrl = ctrl | APBUART_CTRL_TI;
     706
     707                if (ctrl & APBUART_CTRL_FA) {
     708                        /* APBUART with FIFO.. Fill as many as FIFO allows */
     709                        sending = 0;
     710                        while (
     711                                ((regs->status & APBUART_STATUS_TF) == 0) &&
     712                                (sending < len)
     713                        ) {
     714                                regs->data = *buf;
     715                                buf++;
     716                                sending++;
     717                        }
     718                } else {
     719                        /* start UART TX, this will result in an interrupt when done */
     720                        regs->data = *buf;
     721
     722                        sending = 1;
    644723                }
    645724        } else {
    646                 /* start UART TX, this will result in an interrupt when done */
    647                 uart->regs->data = *buf;
    648 
    649                 uart->sending = 1;
    650         }
    651 
    652         rtems_interrupt_enable(oldLevel);
    653 
    654         return 0;
     725                /* No more to send, disable TX interrupts */
     726                regs->ctrl = ctrl & ~APBUART_CTRL_TI;
     727
     728                /* Tell close that we sent everything */
     729                sending = 0;
     730        }
     731
     732        uart->sending = sending;
    655733}
    656734
    657735/* Handle UART interrupts */
    658 void apbuart_isr(void *arg)
    659 {
    660         struct apbuart_priv *uart = arg;
     736static void apbuart_cons_isr(void *arg)
     737{
     738        rtems_termios_tty *tty = arg;
     739        struct console_dev *condev = rtems_termios_get_device_context(tty);
     740        struct apbuart_priv *uart = condev_get_priv(condev);
     741        struct apbuart_regs *regs = uart->regs;
    661742        unsigned int status;
    662743        char data;
    663744        int cnt;
    664745
    665         /* Get all received characters */
    666746        if (uart->mode == TERMIOS_TASK_DRIVEN) {
    667                 if ((status=uart->regs->status) & LEON_REG_UART_STATUS_DR)
    668                         rtems_termios_rxirq_occured(uart->cookie);
     747                if ((status=regs->status) & APBUART_STATUS_DR) {
     748                        /* Activate termios RX daemon task */
     749                        rtems_termios_rxirq_occured(tty);
     750                }
    669751        } else {
    670                 while ((status=uart->regs->status) & LEON_REG_UART_STATUS_DR) {
     752                /* Get all received characters */
     753                while ((status=regs->status) & APBUART_STATUS_DR) {
    671754                        /* Data has arrived, get new data */
    672                         data = uart->regs->data;
     755                        data = regs->data;
    673756
    674757                        /* Tell termios layer about new character */
    675                         rtems_termios_enqueue_raw_characters(uart->cookie, &data, 1);
     758                        rtems_termios_enqueue_raw_characters(tty, &data, 1);
    676759                }
    677760        }
    678761
    679         if (uart->sending && (status & LEON_REG_UART_STATUS_THE)) {
    680                 /* Sent the one char, we disable TX interrupts */
    681                 uart->regs->ctrl &= ~LEON_REG_UART_CTRL_TI;
    682 
     762        if (uart->sending && (status & APBUART_STATUS_TE)) {
    683763                /* Tell close that we sent everything */
    684764                cnt = uart->sending;
    685765                uart->sending = 0;
    686766
    687                 /* apbuart_write_intr() will get called from this function */
    688                 rtems_termios_dequeue_characters(uart->cookie, cnt);
    689         }
    690 }
     767                /*
     768                 * Tell termios how much we have sent. dequeue() may call
     769                 * write_interrupt() to refill the transmitter.
     770                 * write_interrupt() will eventually be called with 0 len to
     771                 * disable TX interrupts.
     772                 */
     773                rtems_termios_dequeue_characters(tty, cnt);
     774        }
     775}
     776
  • c/src/lib/libbsp/sparc/shared/uart/cons.c

    r7cb93250 rfd9fb21  
    1515#include <bsp.h>
    1616#include <stdlib.h>
    17 #include <rtems/libio.h>
    18 #include <rtems/bspIo.h>
    1917#include <bsp/cons.h>
     18#include <rtems/console.h>
    2019
    2120#ifdef RTEMS_DRVMGR_STARTUP
     
    2726 */
    2827
    29 int console_initialized = 0;
    30 rtems_device_major_number console_major = 0;
     28static int console_initialized = 0;
    3129
    3230#define FLAG_SYSCON 0x01
    3331struct console_priv {
    34         unsigned char flags; /* 0x1=SystemConsole */
    35         unsigned char minor;
     32        int flags; /* 0x1=SystemConsole */
     33        int minor;
    3634        struct console_dev *dev;
    3735};
     
    4038struct console_priv cons[CONSOLE_MAX] = {{0,0},};
    4139
    42 /* Register Console to TERMIOS layer and initialize it */
    43 static void console_dev_init(struct console_priv *con, int minor)
     40/* Install Console in TERMIOS layer */
     41static void console_dev_init(struct console_priv *con)
    4442{
    4543        char name[16], *fsname;
    4644        rtems_status_code status;
     45        int minor;
    4746
     47        minor = con->minor;
    4848        if (!con->dev->fsname) {
    4949                strcpy(name, "/dev/console_a");
     
    5656                fsname = con->dev->fsname;
    5757        }
    58         status = rtems_io_register_name(fsname, console_major, minor);
    59         if ((minor == 0) && (status != RTEMS_SUCCESSFUL))
     58        status = rtems_termios_device_install(
     59                fsname,
     60                con->dev->handler,
     61                NULL,
     62                &con->dev->base
     63        );
     64        if (status != RTEMS_SUCCESSFUL) {
    6065                rtems_fatal_error_occurred(status);
     66        }
    6167}
    6268
     69/* Called by device driver to register itself to the cons interface. */
    6370void console_dev_register(struct console_dev *dev)
    6471{
     
    8895        con->minor = minor;
    8996
    90         /* Console layer is already initialized, that means that we can
    91          * register termios interface directly.
    92          */
    93         if (console_initialized)
    94                 console_dev_init(con, minor);
     97        if (console_initialized) {
     98                /* Console layer is already initialized, that means that we can
     99                 * register termios interface directly.
     100                 */
     101                console_dev_init(con);
     102        }
    95103}
    96104
     
    109117        int i;
    110118
    111         console_major = major;
    112 
    113119        rtems_termios_initialize();
    114120
     
    116122        for (i=0; i<CONSOLE_MAX; i++) {
    117123                if (cons[i].dev)
    118                         console_dev_init(&cons[i], i);
     124                        console_dev_init(&cons[i]);
    119125        }
    120126
     
    124130}
    125131
    126 rtems_device_driver console_open(
    127         rtems_device_major_number       major,
    128         rtems_device_minor_number       minor,
    129         void                            *arg)
    130 {
    131         rtems_status_code status;
    132         struct termios term;
    133 
    134         if ((minor >= CONSOLE_MAX) || !cons[minor].dev)
    135                 return RTEMS_INVALID_NUMBER;
    136 
    137         status = rtems_termios_open(
    138                         major,
    139                         (int)cons[minor].dev,
    140                         arg,
    141                         cons[minor].dev->callbacks);
    142 
    143         /* Inherit UART hardware parameters from bootloader on system console */
    144         if ((status == RTEMS_SUCCESSFUL) && (cons[minor].flags & FLAG_SYSCON) &&
    145             (cons[minor].dev->ops.get_uart_attrs != NULL)) {
    146                 if (tcgetattr(STDIN_FILENO, &term) >= 0) {
    147                         cons[minor].dev->ops.get_uart_attrs(cons[minor].dev,
    148                                                                 &term);
    149                         term.c_oflag |= ONLCR;
    150                         tcsetattr(STDIN_FILENO, TCSANOW, &term);
    151                 }
    152         }
    153 
    154         return status;
    155 }
    156 
    157 rtems_device_driver console_close(
    158         rtems_device_major_number       major,
    159         rtems_device_minor_number       minor,
    160         void                            *arg)
    161 {
    162         return rtems_termios_close(arg);
    163 }
    164 
    165 rtems_device_driver console_read(
    166         rtems_device_major_number       major,
    167         rtems_device_minor_number       minor,
    168         void                            *arg)
    169 {
    170         return rtems_termios_read(arg);
    171 }
    172 
    173 rtems_device_driver console_write(
    174         rtems_device_major_number       major,
    175         rtems_device_minor_number       minor,
    176         void                            *arg)
    177 {
    178         return rtems_termios_write(arg);
    179 }
    180 
    181 rtems_device_driver console_control(
    182         rtems_device_major_number       major,
    183         rtems_device_minor_number       minor,
    184         void                            *arg)
    185 {
    186         return rtems_termios_ioctl(arg);
    187 }
    188 
    189132#endif
Note: See TracChangeset for help on using the changeset viewer.