recipes/robostix-utils/robostix-cmdline/robostix.c

   1 /****************************************************************************
   2 *
   3 *   Copyright (c) 2006 Dave Hylands     <dhylands@gmail.com>
   4 *
   5 *   This program is free software; you can redistribute it and/or modify
   6 *   it under the terms of the GNU General Public License version 2 as
   7 *   published by the Free Software Foundation.
   8 *
   9 *   Alternatively, this software may be distributed under the terms of BSD
  10 *   license.
  11 *
  12 *   See README and COPYING for more details.
  13 *
  14 ****************************************************************************/
  15 /**
  16 *
  17 *  robostix.c
  18 *
  19 *  PURPOSE:
  20 *
  21 *   This implements the usermode program for talking to the robostix.
  22 *
  23 *****************************************************************************/
  24
  25 /* ---- Include Files ---------------------------------------------------- */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31
  32 #include "robostix.h"
  33
  34 /* ---- Public Variables ------------------------------------------------- */
  35
  36 int gFd = -1;
  37
  38 int gVal;
  39
  40 /* ---- Private Constants and Types -------------------------------------- */
  41 /* ---- Private Variables ------------------------------------------------ */
  42
  43 typedef struct
  44 {
  45     const   char   *cmdStr;
  46     const   char   *argStr;
  47     const   char   *helpStr;
  48     int           (*parseArgs)( int argc, char **argv );
  49     void          (*execFunc)( int cmd );
  50     int             cmd;
  51
  52 } Cmd;
  53
  54 int     ParseNone( int argc, char **argv );
  55 int     ParseOnOffArg( int argc, char **argv );
  56 int     ParseOnOffPulseArg( int argc, char **argv );
  57 void    Usage( void );
  58
  59 void    Power( int cmd );
  60 void    ReadIOctl( int cmd );
  61 void    SimpleIOctl( int cmd );
  62
  63 Cmd gCmd[] =
  64 {
  65     { "power",  "on|off",           "Controls the robostix voltage regulators", ParseOnOffArg,      Power, -1 },
  66     { "reset",  "on|off|pulse",     "Resets the robostix",                      ParseOnOffPulseArg, SimpleIOctl, ROBOSTIX_IOCTL_RESET },
  67     { "245",    "on|off",           "Controls the 245 buffer chip",             ParseOnOffArg,      SimpleIOctl, ROBOSTIX_IOCTL_245_ENABLE },
  68
  69     { "sck",    "on|off",           "Sets/clears the SCK line",                 ParseOnOffArg,      SimpleIOctl, ROBOSTIX_IOCTL_SET_SCK },
  70     { "ss",     "on|off",           "Sets/clears the SS line",                  ParseOnOffArg,      SimpleIOctl, ROBOSTIX_IOCTL_SET_SS },
  71     { "txd",    "on|off",           "Sets/clears the IR-TXD line",              ParseOnOffArg,      SimpleIOctl, ROBOSTIX_IOCTL_SET_IR_TXD },
  72     { "mosi",   "on|off",           "Sets/clears the MOSI line",                ParseOnOffArg,      SimpleIOctl, ROBOSTIX_IOCTL_SET_MOSI },
  73
  74     { "rxd",    "",                 "Reads the IR-RXD line",                    ParseNone,          ReadIOctl,   ROBOSTIX_IOCTL_GET_IR_RXD },
  75     { "irq",    "",                 "Reads the TM-IRQ line",                    ParseNone,          ReadIOctl,   ROBOSTIX_IOCTL_GET_IRQ },
  76     { "miso",   "",                 "Reads the MISO line",                      ParseNone,          ReadIOctl,   ROBOSTIX_IOCTL_GET_MISO },
  77
  78     { NULL }
  79 };
  80
  81 /* ---- Private Function Prototypes -------------------------------------- */
  82 /* ---- Functions -------------------------------------------------------- */
  83
  84
  85 /****************************************************************************
  86 *
  87 *  main
  88 *
  89 ***************************************************************************/
  90
  91 int main( int argc, char **argv )
  92 {
  93     char   *cmdStr;
  94     int     argIdx;
  95     Cmd    *cmd;
  96
  97     if ( argc == 1 )
  98     {
  99         Usage( );
 100         exit( 0 );
 101     }
 102
 103     if (( gFd = open( "/dev/robostix",  O_RDWR )) < 0 )
 104     {
 105         perror( "Unable to open /dev/robostix" );
 106         exit( 1 );
 107     }
 108
 109     argIdx = 1;
 110     cmdStr = argv[ argIdx++ ];
 111
 112     for ( cmd = gCmd; cmd->cmdStr != NULL; cmd++ )
 113     {
 114         if ( strcasecmp( cmdStr, cmd->cmdStr ) == 0 )
 115         {
 116             break;
 117         }
 118     }
 119     if ( cmd->cmdStr == NULL )
 120     {
 121         fprintf( stderr, "Unrecognized command: '%s'\n", cmdStr );
 122         exit( 1 );
 123     }
 124
 125     if ( cmd->parseArgs( argc - argIdx, &argv[ argIdx ] ))
 126     {
 127         cmd->execFunc( cmd->cmd );
 128     }
 129
 130     close( gFd );
 131
 132     exit( 0 );
 133     return 0;
 134
 135 } // main
 136
 137 /****************************************************************************
 138 *
 139 *  Checks to see if the argument is on/off (or equivalent)
 140 *
 141 ***************************************************************************/
 142
 143 int IsOnOffArg( int argc, char **argv )
 144 {
 145     if (( strcasecmp( *argv, "on" ) == 0 )
 146     ||  ( strcasecmp( *argv, "t" ) == 0 )
 147     ||  ( strcasecmp( *argv, "1" ) == 0 ))
 148     {
 149         gVal = 1;
 150         return 1;
 151     }
 152
 153     if (( strcasecmp( *argv, "off" ) == 0 )
 154     ||  ( strcasecmp( *argv, "f" ) == 0 )
 155     ||  ( strcasecmp( *argv, "0" ) == 0 ))
 156     {
 157         gVal = 0;
 158         return 1;
 159     }
 160
 161     return 0;
 162
 163 } // IsOnOffArg
 164
 165 /****************************************************************************
 166 *
 167 *  Parses no arguments
 168 *
 169 ***************************************************************************/
 170
 171 int ParseNone( int argc, char **argv )
 172 {
 173     return 1;
 174
 175 } // ParseNone
 176
 177 /****************************************************************************
 178 *
 179 *  Parses a command line argument for legel on/off values
 180 *
 181 ***************************************************************************/
 182
 183 int ParseOnOffArg( int argc, char **argv )
 184 {
 185     if ( IsOnOffArg( argc, argv ))
 186     {
 187         return 1;
 188     }
 189
 190     fprintf( stderr, "Expecting on/off, found: '%s'\n", *argv );
 191     return 0;
 192
 193 } // ParseOnOffArg
 194
 195 /****************************************************************************
 196 *
 197 *  Parses a command line argument for legel on/off values
 198 *
 199 ***************************************************************************/
 200
 201 int ParseOnOffPulseArg( int argc, char **argv )
 202 {
 203     if (( strcasecmp( *argv, "pulse" ) == 0 )
 204     ||  ( strcasecmp( *argv, "2" ) == 0 ))
 205     {
 206         gVal = 2;
 207         return 1;
 208     }
 209
 210     if ( IsOnOffArg( argc, argv ))
 211     {
 212         return 1;
 213     }
 214
 215     fprintf( stderr, "Expecting on/off/pulse, found: '%s'\n", *argv );
 216     return 0;
 217
 218 } // ParseOnoffPulseArg
 219
 220 /****************************************************************************
 221 *
 222 *  Power
 223 *
 224 ***************************************************************************/
 225
 226 void Power( int cmd )
 227 {
 228     SimpleIOctl( ROBOSTIX_IOCTL_POWER_VCC5 );
 229
 230 } // Power
 231
 232 /****************************************************************************
 233 *
 234 *  SimpleIOctl
 235 *
 236 ***************************************************************************/
 237
 238 void SimpleIOctl( int cmd )
 239 {
 240     if ( ioctl( gFd, cmd, gVal ) != 0 )
 241     {
 242         fprintf( stderr, "ioctl call failed: %d\n", errno );
 243     }
 244
 245 } // SimpleIOctl
 246
 247 /****************************************************************************
 248 *
 249 *  SimpleIOctl
 250 *
 251 ***************************************************************************/
 252
 253 void ReadIOctl( int cmd )
 254 {
 255     if ( ioctl( gFd, cmd, &gVal ) != 0 )
 256     {
 257         fprintf( stderr, "ioctl call failed: %d\n", errno );
 258     }
 259
 260 } // ReadIOctl
 261
 262 /****************************************************************************
 263 *
 264 *  Usage
 265 *
 266 ***************************************************************************/
 267
 268 void Usage( void )
 269 {
 270     Cmd *cmd;
 271
 272     for ( cmd = gCmd; cmd->cmdStr != NULL; cmd++ )
 273     {
 274         printf( "%-12s %-12s %s\n", cmd->cmdStr, cmd->argStr, cmd->helpStr );
 275     }
 276
 277 } // Usage
 278