rom/usb/shellapps/RocketTool.c

   1 /*
   2  *----------------------------------------------------------------------------
   3  *                     Rocket 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 #include <proto/intuition.h>
  14 #include <proto/graphics.h>
  15 #include <proto/diskfont.h>
  16 #include <proto/lowlevel.h>
  17
  18 #include <libraries/lowlevel.h>
  19 #include <devices/usb_hid.h>
  20
  21 #include "RocketTool.h"
  22 #include <string.h>
  23
  24 #define ARGS_LEFT     0
  25 #define ARGS_RIGHT    1
  26 #define ARGS_UP       2
  27 #define ARGS_DOWN     3
  28 #define ARGS_FIRE     4
  29 #define ARGS_TIME     5
  30 #define ARGS_JOYPORT  6
  31 #define ARGS_UNIT     7
  32 #define ARGS_SIZEOF   8
  33
  34 const char RocketTool_prgname[] = "RocketTool";
  35 static const char *template = "LEFT/S,RIGHT/S,UP/S,DOWN/S,FIRE/S,TIME/N/K,JOYPORT/N/K,UNIT/N/K";
  36 const char RocketTool_version[] = "$VER: RocketTool 1.1 (12.06.09) by Chris Hodges <chrisly@platon42.de>";
  37 static IPTR ArgsArray[ARGS_SIZEOF];
  38 static struct RDArgs *ArgsHook = NULL;
  39
  40 struct Library *ps;
  41 struct Library *LowLevelBase;
  42
  43 AROS_UFP3(void, releasehook,
  44           AROS_UFPA(struct Hook *, hook, A0),
  45           AROS_UFPA(APTR, pab, A2),
  46           AROS_UFPA(struct NepClassRocket *, nch, A1));
  47
  48 struct NepClassRocket * SetupRocket(void);
  49 struct NepClassRocket * AllocRocket(struct NepClassRocket *nch);
  50 void FreeRocket(struct NepClassRocket *nch);
  51
  52 AROS_UFH3(void, releasehook,
  53           AROS_UFHA(struct Hook *, hook, A0),
  54           AROS_UFHA(APTR, pab, A2),
  55           AROS_UFHA(struct NepClassRocket *, nch, A1))
  56 {
  57     AROS_USERFUNC_INIT
  58     /*psdAddErrorMsg(RETURN_WARN, (STRPTR) prgname,
  59                    "Rocket killed!");*/
  60     Signal(nch->nch_Task, SIGBREAKF_CTRL_C);
  61     AROS_USERFUNC_EXIT
  62 }
  63
  64 struct NepClassRocket * SetupRocket(void)
  65 {
  66     struct NepClassRocket *nch;
  67     struct PsdDevice *pd = NULL;
  68     struct PsdAppBinding *pab;
  69     ULONG unit;
  70
  71     if(ArgsArray[ARGS_UNIT])
  72     {
  73         unit = *((ULONG *) ArgsArray[ARGS_UNIT]);
  74     } else {
  75         unit = 0;
  76     }
  77     do
  78     {
  79         do
  80         {
  81             pd = psdFindDevice(pd,
  82                                DA_VendorID, 0x1130,
  83                                DA_ProductID, 0x0202,
  84                                TAG_END);
  85         } while(pd && (unit--));
  86
  87         if(!pd)
  88         {
  89             PutStr("No USB Rocket Launcher found!\n");
  90             return(NULL);
  91         }
  92         if((nch = psdAllocVec(sizeof(struct NepClassRocket))))
  93         {
  94             nch->nch_Device = pd;
  95             nch->nch_ReleaseHook.h_Entry = (APTR) releasehook;
  96
  97             pab = psdClaimAppBinding(ABA_Device, pd,
  98                                      ABA_ReleaseHook, &nch->nch_ReleaseHook,
  99                                      ABA_UserData, nch,
 100                                      ABA_ForceRelease, TRUE,
 101                                      TAG_END);
 102             if(pab)
 103             {
 104                 if(AllocRocket(nch))
 105                 {
 106                     return(nch);
 107                 } else {
 108                     PutStr("Couldn't allocate Rocket Laucher...\n");
 109                 }
 110                 psdReleaseAppBinding(pab);
 111             } else {
 112                 PutStr("Couldn't claim binding!\n");
 113             }
 114             psdFreeVec(nch);
 115         }
 116         PutStr("Hohum...\n");
 117     } while(TRUE);
 118     return(NULL);
 119 }
 120
 121 struct NepClassRocket * AllocRocket(struct NepClassRocket *nch)
 122 {
 123     nch->nch_Task = FindTask(NULL);
 124
 125     if((nch->nch_TaskMsgPort = CreateMsgPort()))
 126     {
 127         nch->nch_IF0 = psdFindInterface(nch->nch_Device, NULL,
 128                                         IFA_InterfaceNum, 0,
 129                                         TAG_END);
 130         nch->nch_IF1 = psdFindInterface(nch->nch_Device, NULL,
 131                                         IFA_InterfaceNum, 1,
 132                                         TAG_END);
 133         if(nch->nch_IF0 && nch->nch_IF1)
 134         {
 135             if((nch->nch_EP0Pipe = psdAllocPipe(nch->nch_Device, nch->nch_TaskMsgPort, NULL)))
 136             {
 137                 return(nch);
 138             } else {
 139                 PutStr("Couldn't allocate default pipe\n");
 140             }
 141         } else {
 142             PutStr("Couldn't find interfaces\n");
 143         }
 144         DeleteMsgPort(nch->nch_TaskMsgPort);
 145     }
 146     return(NULL);
 147 }
 148
 149
 150 void FreeRocket(struct NepClassRocket *nch)
 151 {
 152     APTR pab;
 153
 154     psdGetAttrs(PGA_DEVICE, nch->nch_Device,
 155                 DA_Binding, &pab,
 156                 TAG_END);
 157     psdReleaseAppBinding(pab);
 158     psdFreePipe(nch->nch_EP0Pipe);
 159     DeleteMsgPort(nch->nch_TaskMsgPort);
 160     psdFreeVec(nch);
 161 }
 162
 163 BOOL SendInit(struct NepClassRocket *nch)
 164 {
 165     UBYTE cmd0[8] = { 0x55, 0x53, 0x42, 0x43, 0x00, 0x00, 0x04, 0x00 };
 166     UBYTE cmd1[8] = { 0x55, 0x53, 0x42, 0x43, 0x00, 0x40, 0x02, 0x00 };
 167     LONG ioerr;
 168
 169     psdPipeSetup(nch->nch_EP0Pipe, URTF_OUT|URTF_CLASS|URTF_INTERFACE, UHR_SET_REPORT, 0x0200, 1);
 170     ioerr = psdDoPipe(nch->nch_EP0Pipe, cmd0, 8);
 171     if(ioerr)
 172     {
 173         Printf("Error sending init cmd 0: %s (%ld)\n",
 174                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 175         return FALSE;
 176     }
 177     psdPipeSetup(nch->nch_EP0Pipe, URTF_OUT|URTF_CLASS|URTF_INTERFACE, UHR_SET_REPORT, 0x0200, 1);
 178     ioerr = psdDoPipe(nch->nch_EP0Pipe, cmd1, 8);
 179     if(ioerr)
 180     {
 181         Printf("Error sending init cmd 1: %s (%ld)\n",
 182                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 183         return FALSE;
 184     }
 185     return TRUE;
 186 }
 187
 188 BOOL SendCommand(struct NepClassRocket *nch)
 189 {
 190     LONG ioerr;
 191
 192     psdPipeSetup(nch->nch_EP0Pipe, URTF_OUT|URTF_CLASS|URTF_INTERFACE, UHR_SET_REPORT, 0x0200, 0);
 193     ioerr = psdDoPipe(nch->nch_EP0Pipe, nch->nch_Buf, 64);
 194     if(ioerr)
 195     {
 196         Printf("Error sending command: %s (%ld)\n",
 197                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 198         return FALSE;
 199     }
 200     return TRUE;
 201 }
 202
 203 /**************************************************************************/
 204
 205 int main(int argc, char *argv[])
 206 {
 207     struct NepClassRocket *nch;
 208     ULONG ret = RETURN_OK;
 209     ULONG joyport;
 210
 211     if(!(ArgsHook = ReadArgs(template, ArgsArray, NULL)))
 212     {
 213         PutStr("Wrong arguments!\n");
 214         return(RETURN_FAIL);
 215     }
 216     ps = OpenLibrary("poseidon.library", 4);
 217     if(!ps)
 218     {
 219         FreeArgs(ArgsHook);
 220         return(RETURN_FAIL);
 221     }
 222     if(!(nch = SetupRocket()))
 223     {
 224         FreeArgs(ArgsHook);
 225         CloseLibrary(ps);
 226         return(RETURN_ERROR);
 227     }
 228     if(ArgsArray[ARGS_JOYPORT])
 229     {
 230         // interactive mode
 231         joyport = *((ULONG *) ArgsArray[ARGS_JOYPORT]);
 232         if((LowLevelBase = OpenLibrary("lowlevel.library", 1)))
 233         {
 234             ULONG val;
 235             Printf("Interactive mode using joyport %ld. Press Ctrl-C to abort.\n", joyport);
 236
 237             // FIXME this seems to be not implemented in AROS yet
 238             //SetJoyPortAttrs(joyport, SJA_Reinitialize, TRUE, TAG_END);
 239             //SetJoyPortAttrs(joyport, SJA_Type, SJA_TYPE_AUTOSENSE, TAG_END);
 240             do
 241             {
 242                 if(SetSignal(0,0) & SIGBREAKF_CTRL_C)
 243                 {
 244                     break;
 245                 }
 246                 val = ReadJoyPort(joyport);
 247                 if(((val & JP_TYPE_MASK) == JP_TYPE_JOYSTK) || ((val & JP_TYPE_MASK) == JP_TYPE_GAMECTLR))
 248                 {
 249                     nch->nch_Buf[1] = (val & JPF_JOY_LEFT) ? 1 : 0;
 250                     nch->nch_Buf[2] = (val & JPF_JOY_RIGHT) ? 1 : 0;
 251                     nch->nch_Buf[3] = (val & JPF_JOY_UP) ? 1 : 0;
 252                     nch->nch_Buf[4] = (val & JPF_JOY_DOWN) ? 1 : 0;
 253                     nch->nch_Buf[5] = (val & JPF_BUTTON_RED) ? 1 : 0;
 254                 }
 255                 if(SendInit(nch))
 256                 {
 257                     SendCommand(nch);
 258                 } else {
 259                     ret = RETURN_WARN;
 260                     break;
 261                 }
 262                 Delay(10);
 263             } while(TRUE);
 264             //SetJoyPortAttrs(1, SJA_Reinitialize, TRUE, TAG_END);
 265
 266             CloseLibrary(LowLevelBase);
 267         } else {
 268             ret = RETURN_FAIL;
 269         }
 270     } else {
 271         if(ArgsArray[ARGS_LEFT])
 272         {
 273             nch->nch_Buf[1] = 1;
 274         }
 275         if(ArgsArray[ARGS_RIGHT])
 276         {
 277             nch->nch_Buf[2] = 1;
 278         }
 279         if(ArgsArray[ARGS_UP])
 280         {
 281             nch->nch_Buf[3] = 1;
 282         }
 283         if(ArgsArray[ARGS_DOWN])
 284         {
 285             nch->nch_Buf[4] = 1;
 286         }
 287         if(ArgsArray[ARGS_FIRE])
 288         {
 289             nch->nch_Buf[5] = 1;
 290         }
 291         nch->nch_Buf[6] = 0x08;
 292         nch->nch_Buf[7] = 0x08;
 293         if(SendInit(nch))
 294         {
 295             SendCommand(nch);
 296             if(ArgsArray[ARGS_TIME])
 297             {
 298                 Delay(*((ULONG *) ArgsArray[ARGS_TIME]));
 299                 memset(nch->nch_Buf, 0x00, 6);
 300                 SendInit(nch);
 301                 SendCommand(nch);
 302             }
 303         } else {
 304             ret = RETURN_WARN;
 305         }
 306     }
 307     FreeRocket(nch);
 308     FreeArgs(ArgsHook);
 309     CloseLibrary(ps);
 310     return(ret);
 311 }