device.c

Go to the documentation of this file.

/***************************************************************************
 * device.c
 * (C) 2010 Ivan Meleca
 * Based on original code written by Ruben Meleca
 * www.milos.it

#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 of the License, or
#   (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program; if not, write to the Free Software
#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#include "device.h"
#include <core/system.h>
#include <core/dbgterm.h>
#include <common/string.h>

#define __DEV_INITIALIZED   0x80    
#define __DEV_OPENED        0x40    
#define __DEV_EOL           0x00    
#define __DEV_CR            0x0D    
#define __DEV_LF            0x0A    
#define __DEV_RD_CRLFMASK   0x03    
#define __DEV_WR_CRLFMASK   0x0C    
__STATIC __PDEVICE __deviceChain = __NULL;  
__PDEVICE __deviceFind(__CONST __PSTRING name)
{
    __PDEVICE   dv = __deviceChain;

    while(dv)
    {
        if (__strCmp(dv->dv_name,name) == 0) return(dv);
        dv = dv->dv_next;
    }
    return(__NULL);
}


i32 __deviceInit(__PDEVICE dv, __PVOID params, u32 flags)
{

    if (!dv) return __DEV_ERROR;

    /* Check if already initialized */
    if (!dv->dv_initd)
    {
        /* Check if device has an init function */
        if (dv->dv_init != __NULL)
        {
            if ((*dv->dv_init)(dv, params) != __DEV_OK) return __DEV_ERROR;
            dv->dv_initd = 1;
        }
    }

    dv->dv_flags = flags;
    return __DEV_OK;
}

i32 __deviceDeinit(__PDEVICE dv)
{
    i32 ret;

    /* Check initialized */
    if (dv->dv_initd == 0) return __DEV_ERROR;

    /* Check if device has a destroy function */
    if (dv->dv_deinit == __NULL) {
        dv->dv_initd = 0;
        return __DEV_OK;
    }

    ret = (*dv->dv_deinit)(dv);

    if (ret == __DEV_OK) dv->dv_initd = 0;

    return ret;
}

i32 __deviceOpen(__PDEVICE dv, u32 param)
{
    i32 ret;

    /* Must be called from inside a thread */
    if (__threadGetCurrent()) {
        /* Check initialized */
        if (dv->dv_initd == 0) return __DEV_ERROR;

        /* Check if already opened */
        if (dv->dv_opcnt == 0)
        {
            /* Check for an open function */
            if (dv->dv_open != __NULL)
            {
                ret = (*dv->dv_open)(dv, param);

                if (ret == __DEV_OK)
                {
                    dv->dv_owner = __threadGetCurrent();
                    ++dv->dv_opcnt;
                }

                return ret;
            }
        } else {
            ++dv->dv_opcnt;
            return __DEV_OK;
        }
    }

    return __DEV_ERROR;
}

i32 __deviceClose(__PDEVICE dv)
{

    i32 ret;

    /* Must be called from within a thread */
    if (__threadGetCurrent())
    {
        if (dv->dv_opcnt == 1)
        {
            /* Check for a close function */
            if (dv->dv_close != __NULL)
            {
                ret = (*dv->dv_close)(dv);

                if (ret == __DEV_OK)
                {
                    dv->dv_owner = __NULL;
                    dv->dv_opcnt = 0;
                }

                return ret;
            }
        } else
        {
            --dv->dv_opcnt;
            return __DEV_OK;
        }
    }

    return __DEV_ERROR;
}

i32 __deviceIOCtl(__PDEVICE dv, u32 cmd, u32 param, __PVOID data, u32 len)
{
    /* Check for initialized */
    if (!dv->dv_initd) return __DEV_ERROR;

    if (dv->dv_ioctl) return((*dv->dv_ioctl)(dv,cmd,param,data,len));

    return __DEV_ERROR;
}

i32 __deviceRead(__PDEVICE dv, __PVOID buf, u16 qty)
{
    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv->dv_owner != __NULL)
    {
        /* Check for a read function */
        if (dv->dv_read != __NULL)
        {
            return((*dv->dv_read)(dv,buf,qty));
        }
    }

    return __DEV_ERROR;
}

i32 __deviceWrite(__PDEVICE dv, __CONST __PVOID buf, u16 qty)
{
    i32 res;

    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv->dv_owner != __NULL)
    {
        if (dv->dv_write != __NULL)
        {
            res = ((*dv->dv_write)(dv,buf,qty));

            if (res > __DEV_OK) {
                if (dv->dv_flags & __DEV_AUTOFLUSH)
                {
                    if (__deviceFlush(dv) == __DEV_OK)
                        return res;
                }
            }

            return res;
        }
    }
    return __DEV_ERROR;
}

i32 __deviceFlush(__PDEVICE dv)
{

    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv->dv_owner != __NULL)
    {
        if (dv->dv_flush != __NULL)
        {
            return((*dv->dv_flush)(dv));
        }
    }

    return __DEV_ERROR;
}

i32 __deviceSize(__PDEVICE dv, u8 mode)
{
    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv->dv_owner != __NULL) {
        if (dv->dv_size != __NULL) {
            return((*dv->dv_size)(dv,mode));
        }
    }

    return __DEV_ERROR;
}

i32 __deviceReadLine(__PDEVICE dv, __PSTRING buf, u16 qty)
{
    u16     i;
    u8      c, cr = 0;

    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv == __NULL || dv->dv_read == __NULL || dv->dv_owner == __NULL) return __DEV_ERROR;

    for (i = 0; i < (qty - 1); i++)
    {
        if ((*dv->dv_read)(dv,&c,1) != 1)
        {
            *buf = __DEV_EOL;
            return __DEV_ERROR;
        }

        if (c == __DEV_CR || c == __DEV_LF)
        {
            --i;
            if (dv->dv_flags & __DEV_RD_CR)
            {
                if (!(dv->dv_flags &    __DEV_RD_LF))
                {
                    *buf = __DEV_EOL;
                    return i;
                }
                cr = c;
            }

            if (dv->dv_flags & __DEV_RD_LF)
            {
                if (!(dv->dv_flags &    __DEV_RD_CR))
                {
                    *buf = __DEV_EOL;
                    return i;
                }

                if (cr == __DEV_CR)
                {
                    *buf = __DEV_EOL;
                    return i;
                }
                cr = 0;
            }
        } else
        {
            *buf++ = c;
            cr = 0;
        }
    }

    return i;
}

i32 __deviceWriteLine(__PDEVICE dv, __CONST __PSTRING buf)
{
    i16         qty = 0;
    u8          c;

    /* Check for initialized or opened */
    if (!dv->dv_initd || !dv->dv_opcnt) return __DEV_ERROR;

    if (dv == __NULL || dv->dv_write == __NULL || dv->dv_owner == __NULL) return __DEV_ERROR;

    if (buf == __NULL) return __DEV_ERROR;

    if ((*dv->dv_write)(dv, buf, __strLen(buf)) != __strLen(buf)) {
        return __DEV_ERROR;
    }
    
    qty = __strLen(buf);
    
    if (dv->dv_flags & __DEV_WR_CR) {
        c = __DEV_CR;
        if ((*dv->dv_write)(dv,&c,1) != 1)
        {
            return __DEV_ERROR;
        }
        ++qty;
    }

    if (dv->dv_flags & __DEV_WR_LF)
    {
        c = __DEV_LF;
        if ((*dv->dv_write)(dv,&c,1) != 1)
        {
            return __DEV_ERROR;
        }
        ++qty;
    }

    if (dv->dv_flags & __DEV_AUTOFLUSH)
    {
        if (dv->dv_flush) (*dv->dv_flush)(dv);
    }

    return qty;
}

__VOID __deviceAdd(__PDEVICE dv, u8 count)
{
    u8 i;

    for (i = 0; i < count; i++)
    {
        dv->dv_next = __deviceChain;
        __deviceChain = dv;
        dv++;
    }
}

__VOID __deviceRemove(__PDEVICE dv)
{
    __PDEVICE list;

    __systemDisableScheduler();

    list = __deviceChain;

    if (list == dv)
    {
        __deviceChain = dv->dv_next;
    } else {
        while (list)
        {

            if (list->dv_next == dv)
            {
                list->dv_next = dv->dv_next;
                break;
            }

            list = list->dv_next;
        }
    }

    __systemEnableScheduler();
}

__PDEVICE __deviceGetList(__VOID)
{
    return __deviceChain;
}