genchar.c

Go to the documentation of this file.

/*
 * Copyright (C) 2006 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 */

#include <cfg/os.h>
#include <stdlib.h>
#include <string.h>
#include <sys/file.h>
#include <sys/event.h>
#include <sys/timer.h>
#include <dev/irqreg.h>
#include <dev/genchar.h>


/* Sample hardware status port. */
#ifndef GENDEV_SPORT
#define GENDEV_SPORT    0x100
#endif

/* Sample hardware data port. */
#ifndef GENDEV_DPORT
#define GENDEV_DPORT    0x104
#endif

/* Sample hardware interrupt. */
#ifndef GENDEV_SIGNAL
#define GENDEV_SIGNAL   sig_INTERRUPT1
#endif

typedef struct {
    HANDLE dcb_rrdy;        
    volatile int dcb_rcnt;  
    uint8_t dcb_rbuff[16];   
    uint32_t dcb_rtimeout;    
    HANDLE dcb_trdy;        
    int    dcb_tlen;        
    volatile int dcb_tcnt;  
    uint8_t dcb_tbuff[16];   
    uint32_t dcb_ttimeout;    
} DEVDCB;

static DEVDCB devdcb;

static void GenCharInterrupt(void *arg)
{
    NUTDEVICE *dev = (NUTDEVICE *)arg;
    DEVDCB *dcb = dev->dev_dcb;
    uint8_t st = inr(GENDEV_SPORT);

    /* Receive interrupt. */
    if (st) {
        /* Avoid buffer overflow. */
        if (dcb->dcb_rcnt < sizeof(dcb->dcb_rbuff)) {
            /* Get byte from device and increment receive counter. */
            dcb->dcb_rbuff[dcb->dcb_rcnt] = inr(GENDEV_DPORT);
            dcb->dcb_rcnt++;
        }
        /* Send event on first character. */
        if (dcb->dcb_rcnt == 1) {
            NutEventPostFromIrq(&dcb->dcb_rrdy);
        }
    }

    /* Transmit interrupt. */
    else {
        if (dcb->dcb_tcnt < dcb->dcb_tlen) {
            /* Send byte to device and increment transmit counter. */
            outr(GENDEV_DPORT, dcb->dcb_tbuff[dcb->dcb_tcnt]);
            dcb->dcb_tcnt++;
        }
        /* Transmit buffer empty, send event. */
        else {
            NutEventPostFromIrq(&dcb->dcb_trdy);
            /* Optionally disable further transmit interrupts. */
        }
    }
}

static int GenCharIOCtl(NUTDEVICE * dev, int req, void *conf)
{
    int rc = 0;
    DEVDCB *dcb = dev->dev_dcb;
    uint32_t *lvp = (uint32_t *) conf;

    switch (req) {
    case DEV_SETREADTIMEOUT:
        /* Set read timeout. */
        dcb->dcb_rtimeout = *lvp;
        break;
    case DEV_GETREADTIMEOUT:
        /* Query read timeout. */
        *lvp = dcb->dcb_rtimeout;
        break;

    case DEV_SETWRITETIMEOUT:
        /* Set write timeout. */
        dcb->dcb_ttimeout = *lvp;
        break;
    case DEV_GETWRITETIMEOUT:
        /* Query write timeout. */
        *lvp = dcb->dcb_ttimeout;
        break;

        /* Add attional ioctl functions here. */

    default:
        /* Unknown function. */
        rc = -1;
        break;
    }
    return rc;
}

static int GenCharInit(NUTDEVICE * dev)
{
    /* Add hardware initialization here. */

    /* Register interrupt handler, if required. */
    if (NutRegisterIrqHandler(&GENDEV_SIGNAL, GenCharInterrupt, dev)) {
        return -1;
    }
    /* Set interrupt mode and enable interrupts. */
    NutIrqSetMode(&GENDEV_SIGNAL, NUT_IRQMODE_LOWLEVEL);
    NutIrqEnable(&GENDEV_SIGNAL);

    return 0;
}

static int GenCharRead(NUTFILE * fp, void *buffer, int size)
{
    int rc;
    int i;
    NUTDEVICE *dev = fp->nf_dev;
    DEVDCB *dcb = dev->dev_dcb;

    /* Call without data pointer discards receive buffer. */
    if (buffer == 0) {
        /* Atomic access to the receive counter. */
        NutIrqDisable(&GENDEV_SIGNAL);
        dcb->dcb_rcnt = 0;
        NutIrqEnable(&GENDEV_SIGNAL);

        return 0;
    }

    /*
     * Wait until at least one character is buffered or until a read
     * timeout occured.
     */
    for (;;) {
        /* Atomic access to the receive counter. */
        NutIrqDisable(&GENDEV_SIGNAL);
        rc = dcb->dcb_rcnt;
        NutIrqEnable(&GENDEV_SIGNAL);
        if (rc) {
            break;
        }

        if (NutEventWait(&dcb->dcb_rrdy, dcb->dcb_rtimeout)) {
            return 0; /* Timeout. */
        }
    }

    if (rc > size) {
        rc = size;
    }

    if (rc) {
        memcpy(buffer, dcb->dcb_rbuff, rc);
        /* 
         * This sample driver simply moves remaining bytes to the front 
         * of the buffer. A more sophisticated driver may use a circular 
         * buffer.
         */
        NutIrqDisable(&GENDEV_SIGNAL);
        dcb->dcb_rcnt -= rc;
        for (i = 0; i < dcb->dcb_rcnt; i++) {
            dcb->dcb_rbuff[i] = dcb->dcb_rbuff[rc + i];
        }
        NutIrqEnable(&GENDEV_SIGNAL);
    }
    return rc;
}

static int GenCharWrite(NUTFILE * fp, CONST void *buffer, int len)
{
    int rc = 0;
    int cnt;
    int pend;
    CONST char *cp = buffer;
    NUTDEVICE *dev = fp->nf_dev;
    DEVDCB *dcb = dev->dev_dcb;

    while (rc < len) {

        /*
         * This sample driver waits on each output until all characters 
         * had been tranmitted. A more sophisticated driver may add
         * new characters as soon as there is room left in the tranmit
         * buffer.
         */
        for (;;) {
            /* Atomic access to the transmit counter. */
            NutIrqDisable(&GENDEV_SIGNAL);
            pend = dcb->dcb_tlen - dcb->dcb_tcnt;
            NutIrqEnable(&GENDEV_SIGNAL);
            
            if (pend == 0) {
                break; /* All characters tranmitted. */
            }
            if (NutEventWait(&dcb->dcb_trdy, dcb->dcb_ttimeout)) {
                return rc; /* Timeout. */
            }
        }

        /* Call without data pointer flushes the buffer. */
        if (buffer == 0) {
            return 0;
        }

        /* Determine the number of bytes left to transmit. */
        cnt = len - rc;
        if (cnt > sizeof(dcb->dcb_tbuff)) {
            cnt = sizeof(dcb->dcb_tbuff);
        }

        /* Fill the tranmit buffer. */
        NutIrqDisable(&GENDEV_SIGNAL);
        dcb->dcb_tcnt = cnt;
        memcpy(dcb->dcb_tbuff, cp + rc, cnt);
        /* Add code here to enable tranmit interrupts. */
        NutIrqEnable(&GENDEV_SIGNAL);
        rc += cnt;
    }
    return rc;
}

#ifdef __HARVARD_ARCH__

int GenCharWrite_P(NUTFILE * fp, PGM_P buffer, int len)
{
    /* Our sample driver doesn't support this. */
    return -1;
}
#endif

static NUTFILE *GenCharOpen(NUTDEVICE * dev, CONST char *name, int mode, int acc)
{
    NUTFILE *fp = (NUTFILE *) (dev->dev_dcb);

    if ((fp = malloc(sizeof(NUTFILE))) == 0) {
        return NUTFILE_EOF; /* No memory. */
    }

    fp->nf_next = 0;
    fp->nf_dev = dev;
    fp->nf_fcb = 0;

    return fp;
}

static int GenCharClose(NUTFILE * fp)
{
    /* We may optionally flush our output and discard our input buffers. */

    /* Release all resources which we allocated in the open function. */
    if (fp) {
        free(fp);
    }
    return 0;
}

long GenCharSize (NUTFILE *fp)
{
    long rc;
    NUTDEVICE *dev = fp->nf_dev;
    DEVDCB *dcb = dev->dev_dcb;

    /* Atomic access to the receive buffer counter. */
    NutIrqDisable(&GENDEV_SIGNAL);
    rc = dcb->dcb_rcnt;
    NutIrqEnable(&GENDEV_SIGNAL);

    return rc;
}

NUTDEVICE devGenChar = {
    0,

    {'g', 'e', 'n', 'c', 'h', 'a', 'r', 0, 0},

    IFTYP_CHAR,

    0,

    0,

    0,

    &devdcb,

    GenCharInit,

    GenCharIOCtl,

    GenCharRead,

    GenCharWrite,

#ifdef __HARVARD_ARCH__

    GenCharWrite_P,
#endif

    GenCharOpen,

    GenCharClose,

    GenCharSize
};