rom/usb/classes/stir4200/dev.c

   1 /* dev.c - usbstir4200.device by Chris Hodges
   2 */
   3
   4 #include "debug.h"
   5
   6 #include "stir4200.class.h"
   7
   8 AROS_UFH3(DEVBASETYPEPTR, devInit,
   9           AROS_UFHA(DEVBASETYPEPTR, base, D0),
  10           AROS_UFHA(BPTR, seglist, A0),
  11           AROS_UFHA(struct ExecBase *, SysBase, A6))
  12 {
  13     AROS_USERFUNC_INIT
  14
  15     KPRINTF(10, ("devInit base: 0x%08lx seglist: 0x%08lx SysBase: 0x%08lx\n",
  16                  base, seglist, SysBase));
  17
  18     base->np_Library.lib_Node.ln_Type = NT_DEVICE;
  19     base->np_Library.lib_Node.ln_Name = DEVNAME;
  20     base->np_Library.lib_Flags        = LIBF_SUMUSED|LIBF_CHANGED;
  21     base->np_Library.lib_Version      = VERSION_NUMBER;
  22     base->np_Library.lib_Revision     = REVISION_NUMBER;
  23     base->np_Library.lib_IdString     = VERSION_STRING;
  24
  25     /* Store segment */
  26     base->np_SegList = seglist;
  27
  28     if((base->np_UtilityBase = OpenLibrary("utility.library", 0)))
  29     {
  30         KPRINTF(10, ("devInit: Ok\n"));
  31         KPRINTF(10, ("devInit: openCnt = %ld\n", base->np_Library.lib_OpenCnt));
  32         return(base);
  33     }
  34     else
  35     {
  36         return(NULL);
  37     }
  38     return(base);
  39
  40     AROS_USERFUNC_EXIT
  41 }
  42
  43 #undef UtilityBase
  44 #define UtilityBase     base->np_UtilityBase
  45
  46 AROS_LH3(DEVBASETYPEPTR, devOpen,
  47          AROS_LHA(struct IOIrDAReq *, ioreq, A1),
  48          AROS_LHA(ULONG, unit, D0),
  49          AROS_LHA(ULONG, flags, D1),
  50          DEVBASETYPEPTR, base, 1, dev)
  51 {
  52     AROS_LIBFUNC_INIT
  53
  54     struct NepClassSTIr4200 *ncp;
  55
  56     KPRINTF(10, ("devOpen ioreq: 0x%08lx unit: %ld flags: 0x%08lx base: 0x%08lx\n",
  57                  ioreq, unit, flags, base));
  58
  59     ++base->np_Library.lib_OpenCnt;
  60     base->np_Library.lib_Flags &= ~LIBF_DELEXP;
  61
  62     KPRINTF(10, ("devOpen: openCnt = %ld\n", base->np_Library.lib_OpenCnt));
  63     /* Damn f*cking programs which leave this field to zero! */
  64     if(ioreq->ioir_Req.io_Message.mn_Length && (ioreq->ioir_Req.io_Message.mn_Length < sizeof(struct IOIrDAReq)))
  65     {
  66         KPRINTF(20, ("devOpen: invalid MN_LENGTH (%ld < %ld)!\n",
  67                 ioreq->ioir_Req.io_Message.mn_Length, sizeof(struct IOIrDAReq)));
  68
  69         ioreq->ioir_Req.io_Error = IOERR_BADLENGTH;
  70     } else {
  71         /* Default to open failure. */
  72         ioreq->ioir_Req.io_Error = IOERR_OPENFAIL;
  73
  74         ioreq->ioir_Req.io_Unit = NULL;
  75         ncp = (struct NepClassSTIr4200 *) base->np_ClsBase->nh_Units.lh_Head;
  76         while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
  77         {
  78             if(ncp->ncp_UnitNo == unit)
  79             {
  80                 if(ncp->ncp_Unit.unit_OpenCnt)
  81                 {
  82                     ioreq->ioir_Req.io_Error = IOERR_UNITBUSY;
  83                 } else {
  84                     ioreq->ioir_Req.io_Unit = (struct Unit *) ncp;
  85                 }
  86                 break;
  87             }
  88             ncp = (struct NepClassSTIr4200 *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
  89         }
  90
  91         if(!ioreq->ioir_Req.io_Unit)
  92         {
  93             ioreq->ioir_Req.io_Error = IOERR_OPENFAIL;
  94             KPRINTF(20, ("devOpen: could not open unit!\n"));
  95         } else {
  96             /* Opended ok! */
  97             ioreq->ioir_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  98             ioreq->ioir_Req.io_Error                   = 0;
  99             ioreq->ioir_Req.io_Unit->unit_OpenCnt++;
 100
 101             /* Allow queuing */
 102             ncp->ncp_DenyRequests = FALSE;
 103
 104             return base;
 105         }
 106     }
 107
 108     ioreq->ioir_Req.io_Unit   = (APTR) -1;
 109     ioreq->ioir_Req.io_Device = (APTR) -1;
 110     base->np_Library.lib_OpenCnt--;
 111
 112     return(NULL);
 113
 114     AROS_LIBFUNC_EXIT
 115 }
 116
 117
 118 AROS_LH1(BPTR, devClose,
 119          AROS_LHA(struct IOIrDAReq *, ioreq, A1),
 120          DEVBASETYPEPTR, base, 2, dev)
 121 {
 122     AROS_LIBFUNC_INIT
 123
 124     BPTR ret;
 125     struct NepClassSTIr4200 *ncp = (struct NepClassSTIr4200 *) ioreq->ioir_Req.io_Unit;
 126
 127     KPRINTF(10, ("devClose ioreq: 0x%08lx base: 0x%08lx\n", ioreq, base));
 128
 129     ret = BNULL;
 130     /* Try to flush the last buffer */
 131     Forbid();
 132     if(ncp->ncp_Unit.unit_MsgPort.mp_SigTask)
 133     {
 134         Signal(ncp->ncp_Unit.unit_MsgPort.mp_SigTask, 1L<<(ncp->ncp_Unit.unit_MsgPort.mp_SigBit));
 135     }
 136     Permit();
 137
 138     /* Allow queuing */
 139     ncp->ncp_DenyRequests = FALSE;
 140
 141     ncp->ncp_Unit.unit_OpenCnt--;
 142     ioreq->ioir_Req.io_Unit   = (APTR) -1;
 143     ioreq->ioir_Req.io_Device = (APTR) -1;
 144
 145     if(--base->np_Library.lib_OpenCnt == 0)
 146     {
 147         if(base->np_Library.lib_Flags & LIBF_DELEXP)
 148         {
 149             KPRINTF(5, ("devClose: calling expunge...\n"));
 150             ret = AROS_LC1(BPTR, devExpunge,
 151                            AROS_LCA(DEVBASETYPEPTR, base, D0),
 152                            DEVBASETYPEPTR, base, 3, dev);
 153         }
 154     }
 155
 156     KPRINTF(5, ("devClose: lib_OpenCnt = %ld\n", base->np_Library.lib_OpenCnt));
 157
 158     return(ret);
 159
 160     AROS_LIBFUNC_EXIT
 161 }
 162
 163
 164 AROS_LH1(BPTR, devExpunge,
 165          AROS_LHA(DEVBASETYPEPTR, extralh, D0),
 166          DEVBASETYPEPTR, base, 3, dev)
 167 {
 168     AROS_LIBFUNC_INIT
 169
 170     BPTR ret;
 171
 172     KPRINTF(10, ("devExpunge base: 0x%08lx\n", base));
 173
 174     ret = BNULL;
 175
 176     if(base->np_Library.lib_OpenCnt == 0)
 177     {
 178         KPRINTF(5, ("devExpunge: Unloading...\n"));
 179
 180         CloseLibrary(base->np_UtilityBase);
 181
 182         ret = base->np_SegList;
 183
 184         KPRINTF(5, ("devExpunge: removing device node 0x%08lx\n",
 185                     &base->np_Library.lib_Node));
 186         Remove(&base->np_Library.lib_Node);
 187
 188         KPRINTF(5, ("devExpunge: FreeMem()...\n"));
 189         FreeMem((char *) base - base->np_Library.lib_NegSize,
 190                 (ULONG) (base->np_Library.lib_NegSize + base->np_Library.lib_PosSize));
 191
 192         KPRINTF(5, ("devExpunge: Unloading done! " DEVNAME " expunged!\n\n"));
 193
 194         return(ret);
 195     }
 196     else
 197     {
 198         KPRINTF(5, ("devExpunge: Could not expunge, LIBF_DELEXP set!\n"));
 199         base->np_Library.lib_Flags |= LIBF_DELEXP;
 200     }
 201
 202     return(BNULL);
 203
 204     AROS_LIBFUNC_EXIT
 205 }
 206
 207 AROS_LH0(DEVBASETYPEPTR, devReserved,
 208          DEVBASETYPEPTR, base, 4, dev)
 209 {
 210     AROS_LIBFUNC_INIT
 211     return NULL;
 212     AROS_LIBFUNC_EXIT
 213 }
 214
 215 AROS_LH1(void, devBeginIO,
 216          AROS_LHA(struct IOIrDAReq *, ioreq, A1),
 217          DEVBASETYPEPTR, base, 5, dev)
 218 {
 219     AROS_LIBFUNC_INIT
 220
 221     struct NepClassSTIr4200 *ncp = (struct NepClassSTIr4200 *) ioreq->ioir_Req.io_Unit;
 222     WORD ret = IOERR_NOCMD;
 223
 224     KPRINTF(1, ("devBeginIO ioreq: 0x%08lx base: 0x%08lx cmd: %lu\n", ioreq, base, ioreq->ioir_Req.io_Command));
 225
 226     ioreq->ioir_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 227     ioreq->ioir_Req.io_Error                   = 0;
 228
 229     if(ioreq->ioir_Req.io_Command < NSCMD_DEVICEQUERY)
 230     {
 231         switch (ioreq->ioir_Req.io_Command)
 232         {
 233                     case CMD_FLUSH:
 234             case CMD_READ:
 235             case CMD_WRITE:
 236             case CMD_RESET:
 237             case CMD_CLEAR:
 238                 if(!ncp->ncp_DenyRequests)
 239                 {
 240                     ioreq->ioir_Req.io_Flags &= ~IOF_QUICK;
 241                     ret = RC_DONTREPLY;
 242                     PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 243                 } else {
 244                     ret = IOERR_ABORTED;
 245                 }
 246                 break;
 247
 248             case IRCMD_QUERYDEVICE:
 249                 ret = cmdQueryDevice(ioreq, ncp, base);
 250                 break;
 251
 252             default:
 253                 ret = IOERR_NOCMD;
 254                 break;
 255         }
 256     } else {
 257         switch(ioreq->ioir_Req.io_Command)
 258         {
 259             case NSCMD_DEVICEQUERY:
 260                 ret = cmdNSDeviceQuery((struct IOStdReq *) ioreq, ncp, base);
 261                 break;
 262
 263             default:
 264                 ret = IOERR_NOCMD;
 265                 break;
 266         }
 267     }
 268
 269     if(ret != RC_DONTREPLY)
 270     {
 271         KPRINTF(1, ("TermIO\n"));
 272         if (ret != RC_OK)
 273         {
 274             /* Set error codes
 275             */
 276             ioreq->ioir_Req.io_Error = ret & 0xff;
 277         }
 278         /* Terminate the iorequest
 279         */
 280         TermIO(ioreq, base);
 281     }
 282
 283     AROS_LIBFUNC_EXIT
 284 }
 285
 286 AROS_LH1(LONG, devAbortIO,
 287          AROS_LHA(struct IOIrDAReq *, ioreq, A1),
 288          DEVBASETYPEPTR, base, 6, dev)
 289 {
 290     AROS_LIBFUNC_INIT
 291
 292     struct NepClassSTIr4200 *ncp = (struct NepClassSTIr4200 *) ioreq->ioir_Req.io_Unit;
 293
 294     struct IOIrDAReq *iocmp;
 295
 296     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
 297
 298     /* Is it pending?
 299     */
 300     Forbid();
 301     if(ioreq->ioir_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 302     {
 303         iocmp = (struct IOIrDAReq *) ncp->ncp_ReadQueue.lh_Head;
 304         while(iocmp->ioir_Req.io_Message.mn_Node.ln_Succ)
 305         {
 306             if(iocmp == ioreq)
 307             {
 308                 Remove((struct Node *) ioreq);
 309                 ioreq->ioir_Req.io_Error = IOERR_ABORTED;
 310                 ReplyMsg(&ioreq->ioir_Req.io_Message);
 311                 Permit();
 312                 return(0);
 313             }
 314             iocmp = (struct IOIrDAReq *) iocmp->ioir_Req.io_Message.mn_Node.ln_Succ;
 315         }
 316         iocmp = (struct IOIrDAReq *) ncp->ncp_WriteQueue.lh_Head;
 317         while(iocmp->ioir_Req.io_Message.mn_Node.ln_Succ)
 318         {
 319             if(iocmp == ioreq)
 320             {
 321                 Remove((struct Node *) ioreq);
 322                 ioreq->ioir_Req.io_Error = IOERR_ABORTED;
 323                 ReplyMsg(&ioreq->ioir_Req.io_Message);
 324                 Permit();
 325                 return(0);
 326             }
 327             iocmp = (struct IOIrDAReq *) iocmp->ioir_Req.io_Message.mn_Node.ln_Succ;
 328         }
 329     }
 330     Permit();
 331     return(-1);
 332
 333     AROS_LIBFUNC_EXIT
 334 }
 335
 336 /* NSD stuff
 337 */
 338
 339 static
 340 const UWORD NSDSupported[] =
 341 {
 342     CMD_RESET, CMD_CLEAR,
 343     CMD_FLUSH, CMD_READ,
 344     CMD_WRITE,
 345     NSCMD_DEVICEQUERY, 0
 346 };
 347
 348 WORD cmdNSDeviceQuery(struct IOStdReq *ioreq,
 349                       struct NepClassSTIr4200 *ncp,
 350                       struct NepSTIrDevBase *base)
 351 {
 352     struct my_NSDeviceQueryResult *query;
 353
 354     query = (struct my_NSDeviceQueryResult *) ioreq->io_Data;
 355
 356     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%08lx query: 0x%08lx\n", ioreq, query));
 357
 358     /* NULL ptr?
 359        Enough data?
 360        Valid request?
 361     */
 362     if((!query) ||
 363        (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
 364        (query->DevQueryFormat != 0) ||
 365        (query->SizeAvailable != 0))
 366     {
 367         /* Return error. This is special handling, since iorequest is only
 368            guaranteed to be sizeof(struct IOIrDAReq). If we'd let our
 369            devBeginIO dispatcher return the error, it would trash some
 370            memory past end of the iorequest (ios2_WireError field).
 371          */
 372          ioreq->io_Error = IOERR_NOCMD;
 373          TermIO((struct IOIrDAReq *) ioreq, base);
 374
 375          /* Don't reply, we already did.
 376          */
 377          return RC_DONTREPLY;
 378     }
 379
 380     ioreq->io_Actual         = query->SizeAvailable
 381                              = sizeof(struct my_NSDeviceQueryResult);
 382     query->DeviceType        = NSDEVTYPE_UNKNOWN;
 383     query->DeviceSubType     = 0;
 384     query->SupportedCommands = NSDSupported;
 385
 386     /* Return success (note that this will NOT poke ios2_WireError).
 387     */
 388     return RC_OK;
 389 }
 390
 391 /* /// "cmdQueryDevice()" */
 392 /*
 393  *======================================================================
 394  * cmdQueryDevice(ioreq, unit, base)
 395  *======================================================================
 396  *
 397  * This is the device UHCMD_QUERYDEVICE routine.
 398  *
 399  * Returns information about the hardware.
 400  *
 401  */
 402
 403 WORD cmdQueryDevice(struct IOIrDAReq *ioreq,
 404                     struct NepClassSTIr4200 *ncp,
 405                     struct NepSTIrDevBase *base)
 406 {
 407     struct TagItem *taglist = (struct TagItem *) ioreq->ioir_Data;
 408     struct TagItem *tag;
 409
 410     ULONG count = 0;
 411
 412     KPRINTF(10, ("IRCMD_QUERYDEVICE ioreq: 0x%08lx, taglist: 0x%08lx\n", ioreq, taglist));
 413
 414     if((tag = FindTagItem(IRA_Author, taglist)))
 415     {
 416         *((STRPTR *) tag->ti_Data) = "Chris Hodges";
 417         count++;
 418     }
 419     if((tag = FindTagItem(IRA_ProductName, taglist)))
 420     {
 421         *((STRPTR *) tag->ti_Data) = "STIr4200 IrDA USB Interface";
 422         count++;
 423     }
 424     if((tag = FindTagItem(IRA_Description, taglist)))
 425     {
 426         *((STRPTR *) tag->ti_Data) = "Interfacing device for STIr4200 IrDA sticks";
 427         count++;
 428     }
 429     if((tag = FindTagItem(IRA_Copyright, taglist)))
 430     {
 431         *((STRPTR *) tag->ti_Data) = "©2005-2009 Chris Hodges";
 432         count++;
 433     }
 434     if((tag = FindTagItem(IRA_Version, taglist)))
 435     {
 436         *((IPTR *) tag->ti_Data) = VERSION_NUMBER;
 437         count++;
 438     }
 439     if((tag = FindTagItem(IRA_Revision, taglist)))
 440     {
 441         *((IPTR *) tag->ti_Data) = REVISION_NUMBER;
 442         count++;
 443     }
 444     if((tag = FindTagItem(IRA_DriverVersion, taglist)))
 445     {
 446         *((IPTR *) tag->ti_Data) = 0x100;
 447         count++;
 448     }
 449     if((tag = FindTagItem(IRA_SuppBaudRate, taglist)))
 450     {
 451         *((IPTR *) tag->ti_Data) = BRF_2400|BRF_9600|BRF_19200|BRF_38400|BRF_57600|BRF_115200|BRF_4000000;
 452         count++;
 453     }
 454     if((tag = FindTagItem(IRA_SuppDataSize, taglist)))
 455     {
 456         *((IPTR *) tag->ti_Data) = 0x3f; // all sizes up to 2048
 457         count++;
 458     }
 459     ioreq->ioir_Actual = count;
 460     return RC_OK;
 461 }
 462 /* \\\ */
 463
 464 /*
 465  *===========================================================
 466  * TermIO(ioreq, base)
 467  *===========================================================
 468  *
 469  * Return completed ioreq to sender.
 470  *
 471  */
 472
 473 void TermIO(struct IOIrDAReq *ioreq,
 474             struct NepSTIrDevBase *base)
 475 {
 476     ioreq->ioir_Req.io_Message.mn_Node.ln_Type = NT_FREEMSG;
 477
 478     /* If not quick I/O, reply the message
 479     */
 480     if(!(ioreq->ioir_Req.io_Flags & IOF_QUICK))
 481     {
 482         ReplyMsg(&ioreq->ioir_Req.io_Message);
 483     }
 484 }