gps.c

Go to the documentation of this file.

/***************************************************************************
 * gps.c
 * (C) 2011 Ivan 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 "gps.h"
#include <core/thread.h>
#include <core/system.h>
#include <core/heap.h>
#include <common/nmea.h>
#include <common/mem.h>
#include <core/dbgterm.h>

#if __CONFIG_COMPILE_GPS

__STATIC __VOID __gpsThread(__VOID)
{
    __PDEVICE dv = __threadGetParameter();
    __PGPS_PDB pd = dv->dv_pdb;
    __BOOL res;

    for (;;)
    {
        /* Read a line of text (if the device is opened) */
        while (pd->pd_dv->dv_opcnt && __deviceReadLine(pd->pd_dv, pd->pd_buf, __GPS_MAX_LINE_LEN) != __DEV_ERROR)
        {
            /* Lock, we are about to write in the shared pd_data structure */
            if (__lockOwn(pd->pd_lock, 1000))
            {
                /* Parse the read line with the NMEA parser */
                res = __nmeaParseLine(pd->pd_buf, &pd->pd_data);

                /* Release the lock */
                __lockRelease(pd->pd_lock);

                /* If the sentence is OK, output to terminal */
                if (res) {
                    DBGMSG(pd->pd_terminal, (pd->pd_buf));
                } else {
                    DBGMSG(pd->pd_terminal, ("GPS checksum error"));
                }

            }
        }

        /* Give up the remaining time-to-live */
        __threadSleep(10);
    }
}

i32 __gpsInit(__PDEVICE dv, __PVOID params)
{
    __PGPS_PDB pd = dv->dv_pdb;

    pd->pd_dv = (__PDEVICE) params;

    if (pd->pd_dv == __NULL)
    {
        /* Give a chance the platform to initialize a default
         * device for us.
         */

        if (((dv->dv_plat_ioctl) (dv, __GPS_PLAT_INIT_DEFAULTS, 0, __NULL, 0, __NULL, 0)) != __DEV_OK)
            return __DEV_ERROR;

        if (pd->pd_dv == __NULL)
            return __DEV_ERROR;
    }

    /* Allocate buffer for reception */
    pd->pd_buf = __heapAllocZero(__GPS_MAX_LINE_LEN);
    if (!pd->pd_buf) return __DEV_ERROR;

    /* Create a lock to protect pd->pd_data */
    pd->pd_lock = __lockCreate();
    if (!pd->pd_lock)
    {
        __heapFree(pd->pd_buf);
        return __DEV_ERROR;
    }

    /*  Init hardware */
    (dv->dv_plat_ioctl)(dv, __GPS_PLAT_INIT_HW, 0, __NULL, 0, __NULL, 0);

    return __DEV_OK;
}

i32 __gpsDeinit(__PDEVICE dv)
{
    __PGPS_PDB pd = dv->dv_pdb;

    /* Check for still opened */
    if (dv->dv_opcnt != 0) return __DEV_ERROR;

    /* Destroy lock */
    __lockDestroy(pd->pd_lock);

    /* Free buffers */
    __heapFree(pd->pd_buf);

    /*  De-init hardware */
    if (dv->dv_plat_ioctl)
        (dv->dv_plat_ioctl)(dv, __GPS_PLAT_DEINIT_HW,   0, __NULL, 0, __NULL, 0);

    return __DEV_OK;
}

i32 __gpsIOCtl(__PDEVICE dv, u32 cmd, u32 param, __PVOID data, u32 len)
{
    __PGPS_PDB pd = dv->dv_pdb;

    switch (cmd)
    {
        case __IOCTL_GET_POWER_STATUS:
            if (dv->dv_plat_ioctl)
                return (dv->dv_plat_ioctl)(dv, __GPS_PLAT_GET_POWER, 0, __NULL, 0, __NULL, 0);
            break;

        case __IOCTL_SET_POWER_STATUS:
            if (dv->dv_plat_ioctl)
                return (dv->dv_plat_ioctl)(dv, __GPS_PLAT_SET_POWER, (u8) param, __NULL, 0, __NULL, 0);
            break;

        case __IOCTL_GET_FIX_FLAG:
            if (dv->dv_plat_ioctl)
                return (dv->dv_plat_ioctl)(dv, __GPS_PLAT_GET_FIX_FLAG, 0, __NULL, 0, __NULL, 0);
            break;

        case __IOCTL_TERMINAL_OUTPUT:
            pd->pd_terminal = (u8) param;
            break;
    }

    return __DEV_UNK_IOCTL;
}

i32 __gpsOpen(__PDEVICE dv, u32 mode)
{

    __PGPS_PDB pd = dv->dv_pdb;

    if (pd->pd_thread == __NULL)
    {
        /* Create a thread for GPS reception */
        pd->pd_thread = __threadCreate("gps", __gpsThread, 150, __GPS_THREAD_STACK, 10, dv);
        if (pd->pd_thread == __NULL) {
            return __DEV_ERROR;
        }
    }

    (dv->dv_plat_ioctl)(dv, __GPS_PLAT_SET_POWER, 1, __NULL, 0, __NULL, 0);

    return __DEV_OK;
}

i32 __gpsClose(__PDEVICE dv)
{
    (dv->dv_plat_ioctl)(dv, __GPS_PLAT_SET_POWER, 0, __NULL, 0, __NULL, 0);
    return __DEV_OK;
}

i32 __gpsSize(__PDEVICE dv, u8 mode)
{
    return __DEV_OK;
}

i32 __gpsFlush(__PDEVICE dv)
{
    __PGPS_PDB pd = dv->dv_pdb;

    return __deviceFlush(pd->pd_dv);
}

i32 __gpsRead(__PDEVICE dv, __PVOID buf, u16 qty)
{
    __PGPS_PDB pd = dv->dv_pdb;

    if (qty != sizeof(__GPS_DATA) || !buf) return __DEV_ERROR;

    if (__lockOwn(pd->pd_lock, 1500))
    {
        __memCpy(buf, &pd->pd_data, sizeof(__GPS_DATA));
        __lockRelease(pd->pd_lock);

        return __DEV_OK;
    }

    return __DEV_ERROR;
}

i32 __gpsWrite(__PDEVICE dv, __CONST __PVOID buf, u16 qty)
{
    __PGPS_PDB pd = dv->dv_pdb;

    return __deviceWrite(pd->pd_dv, buf, qty);
}

#endif /* __CONFIG_COMPILE_GPS */