rom/usb/shellapps/UPSTool.c

   1 /*
   2  *----------------------------------------------------------------------------
   3  *                     UPS Launcher Tool for Poseidon
   4  *----------------------------------------------------------------------------
   5  *                   By Chris Hodges <chrisly@platon42.de>
   6  */
   7
   8 #include "debug.h"
   9
  10 #include <proto/dos.h>
  11 #include <proto/exec.h>
  12 #include <proto/poseidon.h>
  13
  14 #include <devices/usb_hid.h>
  15
  16 #include "UPSTool.h"
  17 #include <string.h>
  18
  19 #define ARGS_RAW            0
  20 #define ARGS_ID             1
  21 #define ARGS_QUERY          2
  22 #define ARGS_TOGGLE_BEEPER  3
  23 #define ARGS_SHUTDOWN       4
  24 #define ARGS_START_BT       5
  25 #define ARGS_STOP_BT        6
  26 #define ARGS_UNIT           7
  27 #define ARGS_SIZEOF         8
  28
  29 const char UPSTool_prgname[] = "UPSTool";
  30 static const char *template = "RAW/K,ID/S,QUERY/S,TOGGLEBEEPER=TG/S,SHUTDOWN/S,STARTBATTERYTEST=STARTBT/S,STOPBATTERYTEST=STOPBT/S,UNIT/N/K";
  31 const char UPSTool_version[] = "$VER: UPSTool 1.0 (12.06.09) by Chris Hodges <chrisly@platon42.de>";
  32 static IPTR ArgsArray[ARGS_SIZEOF];
  33 static struct RDArgs *ArgsHook = NULL;
  34
  35 struct Library *ps;
  36
  37 AROS_UFP3(void, releasehook,
  38           AROS_UFPA(struct Hook *, hook, A0),
  39           AROS_UFPA(APTR, pab, A2),
  40           AROS_UFPA(struct NepClassUPS *, nch, A1));
  41
  42 struct NepClassUPS * SetupUPS(void);
  43 struct NepClassUPS * AllocUPS(struct NepClassUPS *nch);
  44 void FreeUPS(struct NepClassUPS *nch);
  45
  46 AROS_UFH3(void, releasehook,
  47           AROS_UFHA(struct Hook *, hook, A0),
  48           AROS_UFHA(APTR, pab, A2),
  49           AROS_UFHA(struct NepClassUPS *, nch, A1))
  50 {
  51     AROS_USERFUNC_INIT
  52     /*psdAddErrorMsg(RETURN_WARN, (STRPTR) prgname,
  53                    "UPS killed!");*/
  54     Signal(nch->nch_Task, SIGBREAKF_CTRL_C);
  55     AROS_USERFUNC_EXIT
  56 }
  57
  58 struct NepClassUPS * SetupUPS(void)
  59 {
  60     struct NepClassUPS *nch;
  61     struct PsdDevice *pd = NULL;
  62     struct PsdAppBinding *pab;
  63     ULONG unit;
  64
  65     if(ArgsArray[ARGS_UNIT])
  66     {
  67         unit = *((ULONG *) ArgsArray[ARGS_UNIT]);
  68     } else {
  69         unit = 0;
  70     }
  71     do
  72     {
  73         do
  74         {
  75             pd = psdFindDevice(pd,
  76                                DA_VendorID, 0x0F03,
  77                                DA_ProductID, 0x0001,
  78                                TAG_END);
  79
  80         } while(pd && (unit--));
  81
  82         if(!pd)
  83         {
  84             PutStr("No UPS found!\n");
  85             return(NULL);
  86         }
  87         if((nch = psdAllocVec(sizeof(struct NepClassUPS))))
  88         {
  89             nch->nch_Device = pd;
  90             nch->nch_ReleaseHook.h_Entry = (APTR) releasehook;
  91             pab = psdClaimAppBinding(ABA_Device, pd,
  92                                      ABA_ReleaseHook, &nch->nch_ReleaseHook,
  93                                      ABA_UserData, nch,
  94                                      ABA_ForceRelease, TRUE,
  95                                      TAG_END);
  96             if(pab)
  97             {
  98                 if(AllocUPS(nch))
  99                 {
 100                     return(nch);
 101                 } else {
 102                     PutStr("Couldn't allocate UPS...\n");
 103                 }
 104                 psdReleaseAppBinding(pab);
 105             } else {
 106                 PutStr("Couldn't claim binding!\n");
 107             }
 108             psdFreeVec(nch);
 109         }
 110         PutStr("Hohum...\n");
 111     } while(TRUE);
 112     return(NULL);
 113 }
 114
 115 struct NepClassUPS * AllocUPS(struct NepClassUPS *nch)
 116 {
 117     nch->nch_Task = FindTask(NULL);
 118
 119     if((nch->nch_TaskMsgPort = CreateMsgPort()))
 120     {
 121         nch->nch_IF0 = psdFindInterface(nch->nch_Device, NULL, TAG_END);
 122         if(nch->nch_IF0)
 123         {
 124             nch->nch_IntEP = psdFindEndpoint(nch->nch_IF0, NULL,
 125                                              EA_IsIn, TRUE,
 126                                              EA_TransferType, USEAF_INTERRUPT,
 127                                              TAG_END);
 128             if(nch->nch_IntEP)
 129             {
 130                 if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL)))
 131                 {
 132                     if((nch->nch_IntPipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, nch->nch_IntEP)))
 133                     {
 134                         psdSetAttrs(PGA_PIPE, nch->nch_IntPipe,
 135                                     PPA_AllowRuntPackets, TRUE,
 136                                     PPA_NakTimeout, TRUE,
 137                                     PPA_NakTimeoutTime, 5000,
 138                                     TAG_END);
 139                         return(nch);
 140                     }
 141                     psdFreePipe(nch->nch_EP0Pipe);
 142                     PutStr("Couldn't allocate int pipe\n");
 143                 } else {
 144                     PutStr("Couldn't allocate default pipe\n");
 145                 }
 146             } else {
 147                 PutStr("Couldn't find endpoint\n");
 148             }
 149         } else {
 150             PutStr("Couldn't find interface\n");
 151         }
 152         DeleteMsgPort(nch->nch_TaskMsgPort);
 153     }
 154     return(NULL);
 155 }
 156
 157
 158 void FreeUPS(struct NepClassUPS *nch)
 159 {
 160     APTR pab;
 161
 162     psdGetAttrs(PGA_DEVICE, nch->nch_Device,
 163                 DA_Binding, &pab,
 164                 TAG_END);
 165     psdReleaseAppBinding(pab);
 166     psdFreePipe(nch->nch_IntPipe);
 167     psdFreePipe(nch->nch_EP0Pipe);
 168     DeleteMsgPort(nch->nch_TaskMsgPort);
 169     psdFreeVec(nch);
 170 }
 171
 172 BOOL SendCommand(struct NepClassUPS *nch, STRPTR cmd)
 173 {
 174     LONG ioerr;
 175     psdSafeRawDoFmt(nch->nch_Buf, 64, "%s\r", cmd);
 176     psdPipeSetup(nch->nch_EP0Pipe, URTF_OUT|URTF_CLASS|URTF_INTERFACE, UHR_SET_REPORT, 0x0200, 0);
 177     ioerr = psdDoPipe(nch->nch_EP0Pipe, nch->nch_Buf, (ULONG) ((strlen(nch->nch_Buf)+7) & ~7));
 178     if(ioerr)
 179     {
 180         Printf("Error sending cmd %s: %s (%ld)\n",
 181                cmd,
 182                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 183         return(FALSE);
 184     }
 185     return(TRUE);
 186 }
 187
 188 STRPTR GetReply(struct NepClassUPS *nch)
 189 {
 190     LONG ioerr;
 191     ULONG len;
 192     ioerr = psdDoPipe(nch->nch_IntPipe, nch->nch_Reply, 63);
 193     if(ioerr)
 194     {
 195         Printf("Error receiving reply: %s (%ld)\n",
 196                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 197         return(NULL);
 198     }
 199     len = psdGetPipeActual(nch->nch_IntPipe);
 200     if((len > 0) && (nch->nch_Reply[len-1] == '\r'))
 201     {
 202         len--; // eliminate trailing cr
 203     }
 204     nch->nch_Reply[len] = 0; // string termination
 205     return(nch->nch_Reply);
 206 }
 207 /**************************************************************************/
 208
 209 int main(int argc, char *argv[])
 210 {
 211     struct NepClassUPS *nch;
 212     ULONG ret = RETURN_ERROR;
 213     STRPTR replymsg;
 214
 215     if(!(ArgsHook = ReadArgs(template, ArgsArray, NULL)))
 216     {
 217         PutStr("Wrong arguments!\n");
 218         return(RETURN_FAIL);
 219     }
 220     ps = OpenLibrary("poseidon.library", 4);
 221     if(!ps)
 222     {
 223         FreeArgs(ArgsHook);
 224         return(RETURN_FAIL);
 225     }
 226     if(!(nch = SetupUPS()))
 227     {
 228         FreeArgs(ArgsHook);
 229         CloseLibrary(ps);
 230         return(RETURN_ERROR);
 231     }
 232     if(ArgsArray[ARGS_RAW])
 233     {
 234         if(SendCommand(nch, (STRPTR) ArgsArray[ARGS_RAW]))
 235         {
 236             if((replymsg = GetReply(nch)))
 237             {
 238                 Printf("%s\n", replymsg);
 239                 ret = RETURN_OK;
 240             }
 241         }
 242     }
 243     else if(ArgsArray[ARGS_ID])
 244     {
 245         if(SendCommand(nch, "I"))
 246         {
 247             if((replymsg = GetReply(nch)))
 248             {
 249                 if(replymsg[0] == '#')
 250                 {
 251                     Printf("%s\n", replymsg+1);
 252                     ret = RETURN_OK;
 253                 } else {
 254                     PutStr("Bogus reply!\n");
 255                 }
 256             }
 257         }
 258     }
 259     else if(ArgsArray[ARGS_QUERY])
 260     {
 261         if(SendCommand(nch, "Q1"))
 262         {
 263             if((replymsg = GetReply(nch)))
 264             {
 265                 if(replymsg[0] == '(')
 266                 {
 267                     Printf("%s\n", replymsg+1);
 268                     ret = RETURN_OK;
 269                 } else {
 270                     PutStr("Bogus reply!\n");
 271                 }
 272             }
 273         }
 274     }
 275     else if(ArgsArray[ARGS_TOGGLE_BEEPER])
 276     {
 277         if(SendCommand(nch, "Q"))
 278         {
 279             if((replymsg = GetReply(nch)))
 280             {
 281                 PutStr("Beeper toggled!\n");
 282                 ret = RETURN_OK;
 283             }
 284         }
 285     }
 286     else if(ArgsArray[ARGS_SHUTDOWN])
 287     {
 288         if(SendCommand(nch, "S01"))
 289         {
 290             PutStr("Shutting down UPS!\n");
 291             ret = RETURN_OK;
 292         }
 293     }
 294     else if(ArgsArray[ARGS_START_BT])
 295     {
 296         if(SendCommand(nch, "TL"))
 297         {
 298             PutStr("Battery Test started!\n");
 299             ret = RETURN_OK;
 300         }
 301     }
 302     else if(ArgsArray[ARGS_STOP_BT])
 303     {
 304         if(SendCommand(nch, "CT"))
 305         {
 306             PutStr("Battery Test stopped!\n");
 307             ret = RETURN_OK;
 308         }
 309     } else {
 310         if(SendCommand(nch, "Q1"))
 311         {
 312             if((replymsg = GetReply(nch)))
 313             {
 314                 if(*replymsg++ == '(')
 315                 {
 316                     UWORD cnt = 7;
 317                     // get status fields
 318                     while(*replymsg)
 319                     {
 320                         if(*replymsg++ == ' ')
 321                         {
 322                             if(!(--cnt))
 323                             {
 324                                 break;
 325                             }
 326                         }
 327                     }
 328                     if(*replymsg)
 329                     {
 330                         if((*replymsg == '0') && (replymsg[5] == '0'))
 331                         {
 332                             PutStr("On line.\n");
 333                             ret = RETURN_OK;
 334                         } else {
 335                             PutStr("On battery!\n");
 336                             ret = RETURN_WARN;
 337                         }
 338                     }
 339                 } else {
 340                     PutStr("Bogus reply!\n");
 341                 }
 342             }
 343         }
 344     }
 345     FreeUPS(nch);
 346     FreeArgs(ArgsHook);
 347     CloseLibrary(ps);
 348     return(ret);
 349 }