rom/usb/shellapps/PowManTool.c

   1 /*
   2  *----------------------------------------------------------------------------
   3  *                     Power Management Tool for Poseidon
   4  *----------------------------------------------------------------------------
   5  *                   By Chris Hodges <chrisly@platon42.de>
   6  */
   7
   8 #include "debug.h"
   9
  10 #include <devices/usb_hid.h>
  11
  12 #include <proto/dos.h>
  13 #include <proto/exec.h>
  14 #include <proto/poseidon.h>
  15
  16 #include "PowManTool.h"
  17 #include <string.h>
  18
  19 #define ARGS_OUTLET         0
  20 #define ARGS_ON             1
  21 #define ARGS_OFF            2
  22 #define ARGS_TOGGLE         3
  23 #define ARGS_STATUS         4
  24 #define ARGS_UNIT           5
  25 #define ARGS_SIZEOF         6
  26
  27 const char PowManTool_prgname[] = "PowManTool";
  28 static const char *template = "SOCKET=OUTLET/N,ON/S,OFF/S,TOGGLE/S,STATUS/S,UNIT/N/K";
  29 const char PowManTool_version[] = "$VER: PowManTool 1.0 (12.06.09) by Chris Hodges <chrisly@platon42.de>";
  30 static IPTR ArgsArray[ARGS_SIZEOF];
  31 static struct RDArgs *ArgsHook = NULL;
  32
  33 struct Library *ps;
  34
  35 AROS_UFP3(void, releasehook,
  36           AROS_UFPA(struct Hook *, hook, A0),
  37           AROS_UFPA(APTR, pab, A2),
  38           AROS_UFPA(struct NepClassUPS *, nch, A1));
  39
  40 struct NepClassUPS * SetupUPS(void);
  41 struct NepClassUPS * AllocUPS(struct NepClassUPS *nch);
  42 void FreeUPS(struct NepClassUPS *nch);
  43
  44 AROS_UFH3(void, releasehook,
  45           AROS_UFHA(struct Hook *, hook, A0),
  46           AROS_UFHA(APTR, pab, A2),
  47           AROS_UFHA(struct NepClassUPS *, nch, A1))
  48 {
  49     AROS_USERFUNC_INIT
  50     /*psdAddErrorMsg(RETURN_WARN, (STRPTR) prgname,
  51                    "PowMan killed!");*/
  52     Signal(nch->nch_Task, SIGBREAKF_CTRL_C);
  53     AROS_USERFUNC_EXIT
  54 }
  55
  56 struct NepClassUPS * SetupUPS(void)
  57 {
  58     struct NepClassUPS *nch;
  59     struct PsdDevice *pd = NULL;
  60     struct PsdAppBinding *pab;
  61     ULONG unit;
  62
  63     if(ArgsArray[ARGS_UNIT])
  64     {
  65         unit = *((ULONG *) ArgsArray[ARGS_UNIT]);
  66     } else {
  67         unit = 0;
  68     }
  69     do
  70     {
  71         do
  72         {
  73             pd = psdFindDevice(pd,
  74                                DA_VendorID, 0x04b4,
  75                                DA_ProductID, 0xfd11,
  76                                TAG_END);
  77
  78         } while(pd && (unit--));
  79
  80         if(!pd)
  81         {
  82             PutStr("No GemBird PowerManager found!\n");
  83             return(NULL);
  84         }
  85         if((nch = psdAllocVec(sizeof(struct NepClassUPS))))
  86         {
  87             nch->nch_Device = pd;
  88             nch->nch_ReleaseHook.h_Entry = (APTR) releasehook;
  89
  90             pab = psdClaimAppBinding(ABA_Device, pd,
  91                                      ABA_ReleaseHook, &nch->nch_ReleaseHook,
  92                                      ABA_UserData, nch,
  93                                      ABA_ForceRelease, TRUE,
  94                                      TAG_END);
  95             if(pab)
  96             {
  97                 if(AllocUPS(nch))
  98                 {
  99                     return(nch);
 100                 } else {
 101                     PutStr("Couldn't allocate PowerManager...\n");
 102                 }
 103                 psdReleaseAppBinding(pab);
 104             } else {
 105                 PutStr("Couldn't claim binding!\n");
 106             }
 107             psdFreeVec(nch);
 108         }
 109         PutStr("Hohum...\n");
 110     } while(TRUE);
 111     return(NULL);
 112 }
 113
 114 struct NepClassUPS * AllocUPS(struct NepClassUPS *nch)
 115 {
 116     nch->nch_Task = FindTask(NULL);
 117
 118     if((nch->nch_TaskMsgPort = CreateMsgPort()))
 119     {
 120         if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL)))
 121         {
 122             return(nch);
 123         } else {
 124             PutStr("Couldn't allocate default pipe\n");
 125         }
 126         DeleteMsgPort(nch->nch_TaskMsgPort);
 127     }
 128     return(NULL);
 129 }
 130
 131
 132 void FreeUPS(struct NepClassUPS *nch)
 133 {
 134     APTR pab;
 135
 136     psdGetAttrs(PGA_DEVICE, nch->nch_Device,
 137                 DA_Binding, &pab,
 138                 TAG_END);
 139     psdReleaseAppBinding(pab);
 140     psdFreePipe(nch->nch_EP0Pipe);
 141     DeleteMsgPort(nch->nch_TaskMsgPort);
 142     psdFreeVec(nch);
 143 }
 144
 145 BOOL SendCommand(struct NepClassUPS *nch, ULONG outlet, ULONG cmd)
 146 {
 147     LONG ioerr;
 148     UBYTE buf[2];
 149     buf[0] = outlet*3;
 150     buf[1] = cmd;
 151     psdPipeSetup(nch->nch_EP0Pipe, URTF_OUT|URTF_CLASS|URTF_INTERFACE, UHR_SET_REPORT, (ULONG) 0x0300|buf[0], 0);
 152     ioerr = psdDoPipe(nch->nch_EP0Pipe, buf, 2);
 153     if(ioerr)
 154     {
 155         Printf("Error sending cmd %s: %s (%ld)\n",
 156                cmd,
 157                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 158         return(FALSE);
 159     }
 160     return(TRUE);
 161 }
 162
 163 BOOL GetStatus(struct NepClassUPS *nch, ULONG outlet)
 164 {
 165     LONG ioerr;
 166     UBYTE buf[2];
 167     psdPipeSetup(nch->nch_EP0Pipe, URTF_IN|URTF_CLASS|URTF_INTERFACE, UHR_GET_REPORT, 0x0300|(outlet*3), 0);
 168     ioerr = psdDoPipe(nch->nch_EP0Pipe, buf, 2);
 169     if(ioerr)
 170     {
 171         Printf("Error getting status: %s (%ld)\n",
 172                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 173         return(FALSE);
 174     }
 175     return(buf[1]);
 176 }
 177
 178 /**************************************************************************/
 179
 180 int main(int argc, char *argv[])
 181 {
 182     struct NepClassUPS *nch;
 183     ULONG ret;
 184     LONG outlet = 0;
 185     BOOL all = FALSE;
 186     if(!(ArgsHook = ReadArgs(template, ArgsArray, NULL)))
 187     {
 188         PutStr("Wrong arguments!\n");
 189         return(RETURN_FAIL);
 190     }
 191     if(ArgsArray[ARGS_OUTLET])
 192     {
 193         outlet = *((LONG *) ArgsArray[ARGS_OUTLET]);
 194         if((outlet < 1) || (outlet > 4))
 195         {
 196             PutStr("Only outlets from 1 to 4 are supported!\n");
 197             FreeArgs(ArgsHook);
 198             return(RETURN_ERROR);
 199         }
 200     }
 201     ps = OpenLibrary("poseidon.library", 4);
 202     if(!ps)
 203     {
 204         FreeArgs(ArgsHook);
 205         return(RETURN_FAIL);
 206     }
 207     if(!(nch = SetupUPS()))
 208     {
 209         FreeArgs(ArgsHook);
 210         CloseLibrary(ps);
 211         return(RETURN_ERROR);
 212     }
 213     if(!outlet)
 214     {
 215         all = TRUE;
 216         outlet = 1;
 217     }
 218     ret = RETURN_OK;
 219     do
 220     {
 221         if(ArgsArray[ARGS_TOGGLE])
 222         {
 223             if(GetStatus(nch, outlet))
 224             {
 225                 SendCommand(nch, outlet, 0x00);
 226             } else {
 227                 SendCommand(nch, outlet, 0x03);
 228             }
 229         }
 230         if(ArgsArray[ARGS_STATUS])
 231         {
 232             if(ArgsArray[ARGS_OFF])
 233             {
 234                 ret |= GetStatus(nch, outlet) ? RETURN_WARN : RETURN_OK;
 235             } else {
 236                 ret |= GetStatus(nch, outlet) ? RETURN_OK : RETURN_WARN;
 237             }
 238         } else {
 239             if(ArgsArray[ARGS_ON])
 240             {
 241                 SendCommand(nch, outlet, 0x03);
 242             }
 243             else if(ArgsArray[ARGS_OFF])
 244             {
 245                 SendCommand(nch, outlet, 0x00);
 246             }
 247         }
 248         outlet++;
 249     } while(all && (outlet <= 4));
 250
 251     FreeUPS(nch);
 252     FreeArgs(ArgsHook);
 253     CloseLibrary(ps);
 254     return(ret);
 255 }