rom/usb/classes/bluetooth/dev.c

   1 /* dev.c - usbbluetooth.device by Chris Hodges
   2 */
   3
   4 #include "debug.h"
   5
   6 #include "bluetooth.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 IOBTHCIReq *, 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 NepClassBT *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->iobt_Req.io_Message.mn_Length && (ioreq->iobt_Req.io_Message.mn_Length < sizeof(struct IOBTHCIReq)))
  65     {
  66         KPRINTF(20, ("devOpen: invalid MN_LENGTH (%ld < %ld)!\n",
  67                 ioreq->iobt_Req.io_Message.mn_Length, sizeof(struct IOBTHCIReq)));
  68
  69         ioreq->iobt_Req.io_Error = IOERR_BADLENGTH;
  70     } else {
  71         /* Default to open failure. */
  72         ioreq->iobt_Req.io_Error = IOERR_OPENFAIL;
  73
  74         ioreq->iobt_Req.io_Unit = NULL;
  75         ncp = (struct NepClassBT *) 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->iobt_Req.io_Error = IOERR_UNITBUSY;
  83                 } else {
  84                     ioreq->iobt_Req.io_Unit = (struct Unit *) ncp;
  85                 }
  86                 break;
  87             }
  88             ncp = (struct NepClassBT *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
  89         }
  90
  91         if(!ioreq->iobt_Req.io_Unit)
  92         {
  93             ioreq->iobt_Req.io_Error = IOERR_OPENFAIL;
  94             KPRINTF(20, ("devOpen: could not open unit!\n"));
  95         } else {
  96             /* Opended ok! */
  97             ioreq->iobt_Req.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  98             ioreq->iobt_Req.io_Error                   = 0;
  99             ioreq->iobt_Req.io_Unit->unit_OpenCnt++;
 100
 101             /* Allow queuing */
 102             ncp->ncp_DenyRequests = FALSE;
 103
 104             return base;
 105         }
 106     }
 107
 108     ioreq->iobt_Req.io_Unit   = (APTR) -1;
 109     ioreq->iobt_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 IOBTHCIReq *, ioreq, A1),
 120          DEVBASETYPEPTR, base, 2, dev)
 121 {
 122     AROS_LIBFUNC_INIT
 123
 124     BPTR ret;
 125     struct NepClassBT *ncp = (struct NepClassBT *) ioreq->iobt_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->iobt_Req.io_Unit   = (APTR) -1;
 143     ioreq->iobt_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 IOBTHCIReq *, ioreq, A1),
 217          DEVBASETYPEPTR, base, 5, dev)
 218 {
 219     AROS_LIBFUNC_INIT
 220
 221     struct NepClassBT *ncp = (struct NepClassBT *) ioreq->iobt_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->iobt_Req.io_Command));
 225
 226     ioreq->iobt_Req.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 227     ioreq->iobt_Req.io_Error                   = 0;
 228
 229     if(ioreq->iobt_Req.io_Command < NSCMD_DEVICEQUERY)
 230     {
 231         switch (ioreq->iobt_Req.io_Command)
 232         {
 233             case BTCMD_ADDMSGPORT:
 234                 if(ncp->ncp_EventMsgPort)
 235                 {
 236                     ret = BTIOERR_BADPARAMS;
 237                 } else {
 238                     ncp->ncp_EventMsgPort = ioreq->iobt_Data;
 239                     ret = RC_OK;
 240                 }
 241                 break;
 242
 243             case BTCMD_REMMSGPORT:
 244                 if(ncp->ncp_EventMsgPort != ioreq->iobt_Data)
 245                 {
 246                     ret = BTIOERR_BADPARAMS;
 247                 } else {
 248                     ncp->ncp_EventMsgPort = NULL;
 249                     ret = RC_OK;
 250                 }
 251                 break;
 252
 253             case BTCMD_QUERYDEVICE:
 254                 ret = cmdQueryDevice(ioreq, ncp, base);
 255                 break;
 256
 257             case BTCMD_WRITEHCI:
 258             case BTCMD_READEVENT:
 259             case BTCMD_READACL:
 260             case BTCMD_WRITEACL:
 261             case BTCMD_SETUPSCO:
 262             case BTCMD_READSCO:
 263             case BTCMD_WRITESCO:
 264                     case CMD_FLUSH:
 265             case CMD_RESET:
 266             case CMD_CLEAR:
 267                 if(!ncp->ncp_DenyRequests)
 268                 {
 269                     ioreq->iobt_Req.io_Flags &= ~IOF_QUICK;
 270                     ret = RC_DONTREPLY;
 271                     PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 272                 } else {
 273                     ret = IOERR_ABORTED;
 274                 }
 275                 break;
 276
 277             default:
 278                 ret = IOERR_NOCMD;
 279                 break;
 280         }
 281     } else {
 282         switch(ioreq->iobt_Req.io_Command)
 283         {
 284             case NSCMD_DEVICEQUERY:
 285                 ret = cmdNSDeviceQuery((struct IOStdReq *) ioreq, ncp, base);
 286                 break;
 287
 288             default:
 289                 ret = IOERR_NOCMD;
 290                 break;
 291         }
 292     }
 293
 294     if(ret != RC_DONTREPLY)
 295     {
 296         KPRINTF(1, ("TermIO\n"));
 297         if (ret != RC_OK)
 298         {
 299             /* Set error codes
 300             */
 301             ioreq->iobt_Req.io_Error = ret & 0xff;
 302         }
 303         /* Terminate the iorequest
 304         */
 305         TermIO(ioreq, base);
 306     }
 307
 308     AROS_LIBFUNC_EXIT
 309 }
 310
 311 AROS_LH1(LONG, devAbortIO,
 312          AROS_LHA(struct IOBTHCIReq *, ioreq, A1),
 313          DEVBASETYPEPTR, base, 6, dev)
 314 {
 315     AROS_LIBFUNC_INIT
 316
 317     struct NepClassBT *ncp = (struct NepClassBT *) ioreq->iobt_Req.io_Unit;
 318
 319     struct IOBTHCIReq *iocmp;
 320
 321     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
 322
 323     /* Is it pending?
 324     */
 325     Forbid();
 326     if(ioreq->iobt_Req.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 327     {
 328         if(ncp->ncp_ReadPending == ioreq)
 329         {
 330             ncp->ncp_AbortRead = TRUE;
 331             Signal(ncp->ncp_Task, 1L<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
 332             Permit();
 333             return(0);
 334         }
 335         if(ncp->ncp_WritePending == ioreq)
 336         {
 337             ncp->ncp_AbortWrite = TRUE;
 338             Signal(ncp->ncp_Task, 1L<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
 339             Permit();
 340             return(0);
 341         }
 342         iocmp = (struct IOBTHCIReq *) ncp->ncp_ReadQueue.lh_Head;
 343         while(iocmp->iobt_Req.io_Message.mn_Node.ln_Succ)
 344         {
 345             if(iocmp == ioreq)
 346             {
 347                 Remove((struct Node *) ioreq);
 348                 ioreq->iobt_Req.io_Error = IOERR_ABORTED;
 349                 ReplyMsg(&ioreq->iobt_Req.io_Message);
 350                 Permit();
 351                 return(0);
 352             }
 353             iocmp = (struct IOBTHCIReq *) iocmp->iobt_Req.io_Message.mn_Node.ln_Succ;
 354         }
 355         iocmp = (struct IOBTHCIReq *) ncp->ncp_WriteQueue.lh_Head;
 356         while(iocmp->iobt_Req.io_Message.mn_Node.ln_Succ)
 357         {
 358             if(iocmp == ioreq)
 359             {
 360                 Remove((struct Node *) ioreq);
 361                 ioreq->iobt_Req.io_Error = IOERR_ABORTED;
 362                 ReplyMsg(&ioreq->iobt_Req.io_Message);
 363                 Permit();
 364                 return(0);
 365             }
 366             iocmp = (struct IOBTHCIReq *) iocmp->iobt_Req.io_Message.mn_Node.ln_Succ;
 367         }
 368     }
 369     Permit();
 370     return(-1);
 371
 372     AROS_LIBFUNC_EXIT
 373 }
 374
 375 /* NSD stuff
 376 */
 377
 378 static
 379 const UWORD NSDSupported[] =
 380 {
 381     CMD_RESET, CMD_CLEAR,
 382     CMD_FLUSH, CMD_READ,
 383     CMD_WRITE,
 384     NSCMD_DEVICEQUERY, 0
 385 };
 386
 387 WORD cmdNSDeviceQuery(struct IOStdReq *ioreq,
 388                       struct NepClassBT *ncp,
 389                       struct NepBTDevBase *base)
 390 {
 391     struct my_NSDeviceQueryResult *query;
 392
 393     query = (struct my_NSDeviceQueryResult *) ioreq->io_Data;
 394
 395     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%08lx query: 0x%08lx\n", ioreq, query));
 396
 397     /* NULL ptr?
 398        Enough data?
 399        Valid request?
 400     */
 401     if((!query) ||
 402        (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
 403        (query->DevQueryFormat != 0) ||
 404        (query->SizeAvailable != 0))
 405     {
 406         /* Return error. This is special handling, since iorequest is only
 407            guaranteed to be sizeof(struct IOBTHCIReq). If we'd let our
 408            devBeginIO dispatcher return the error, it would trash some
 409            memory past end of the iorequest (ios2_WireError field).
 410          */
 411          ioreq->io_Error = IOERR_NOCMD;
 412          TermIO((struct IOBTHCIReq *) ioreq, base);
 413
 414          /* Don't reply, we already did.
 415          */
 416          return RC_DONTREPLY;
 417     }
 418
 419     ioreq->io_Actual         = query->SizeAvailable
 420                              = sizeof(struct my_NSDeviceQueryResult);
 421     query->DeviceType        = NSDEVTYPE_UNKNOWN;
 422     query->DeviceSubType     = 0;
 423     query->SupportedCommands = NSDSupported;
 424
 425     /* Return success (note that this will NOT poke ios2_WireError).
 426     */
 427     return RC_OK;
 428 }
 429
 430 /* /// "cmdQueryDevice()" */
 431 /*
 432  *======================================================================
 433  * cmdQueryDevice(ioreq, unit, base)
 434  *======================================================================
 435  *
 436  * This is the device UHCMD_QUERYDEVICE routine.
 437  *
 438  * Returns information about the hardware.
 439  *
 440  */
 441
 442 WORD cmdQueryDevice(struct IOBTHCIReq *ioreq,
 443                     struct NepClassBT *ncp,
 444                     struct NepBTDevBase *base)
 445 {
 446     struct TagItem *taglist = (struct TagItem *) ioreq->iobt_Data;
 447     struct TagItem *tag;
 448
 449     ULONG count = 0;
 450
 451     KPRINTF(10, ("BTCMD_QUERYDEVICE ioreq: 0x%08lx, taglist: 0x%08lx\n", ioreq, taglist));
 452
 453     if((tag = FindTagItem(BTA_Author, taglist)))
 454     {
 455         *((STRPTR *) tag->ti_Data) = "Chris Hodges";
 456         count++;
 457     }
 458     if((tag = FindTagItem(BTA_ProductName, taglist)))
 459     {
 460         *((STRPTR *) tag->ti_Data) = "Bluetooth USB HCI Interface";
 461         count++;
 462     }
 463     if((tag = FindTagItem(BTA_Description, taglist)))
 464     {
 465         *((STRPTR *) tag->ti_Data) = "Interfacing device for USB Bluetooth sticks";
 466         count++;
 467     }
 468     if((tag = FindTagItem(BTA_Copyright, taglist)))
 469     {
 470         *((STRPTR *) tag->ti_Data) = "©2005-2009 Chris Hodges";
 471         count++;
 472     }
 473     if((tag = FindTagItem(BTA_Version, taglist)))
 474     {
 475         *((IPTR *) tag->ti_Data) = VERSION_NUMBER;
 476         count++;
 477     }
 478     if((tag = FindTagItem(BTA_Revision, taglist)))
 479     {
 480         *((IPTR *) tag->ti_Data) = REVISION_NUMBER;
 481         count++;
 482     }
 483     if((tag = FindTagItem(BTA_DriverVersion, taglist)))
 484     {
 485         *((IPTR *) tag->ti_Data) = 0x100;
 486         count++;
 487     }
 488     ioreq->iobt_Actual = count;
 489     return RC_OK;
 490 }
 491 /* \\\ */
 492
 493
 494 /*
 495  *===========================================================
 496  * TermIO(ioreq, base)
 497  *===========================================================
 498  *
 499  * Return completed ioreq to sender.
 500  *
 501  */
 502
 503 void TermIO(struct IOBTHCIReq *ioreq,
 504             struct NepBTDevBase *base)
 505 {
 506     ioreq->iobt_Req.io_Message.mn_Node.ln_Type = NT_FREEMSG;
 507
 508     /* If not quick I/O, reply the message
 509     */
 510     if(!(ioreq->iobt_Req.io_Flags & IOF_QUICK))
 511     {
 512         ReplyMsg(&ioreq->iobt_Req.io_Message);
 513     }
 514 }