rom/usb/classes/palmpda/dev.c

   1 /* dev.c - usbpalm.device by Chris Hodges
   2 */
   3
   4 #include "debug.h"
   5
   6 #include "palmpda.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 IOExtSer *, 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 NepClassSerial *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->IOSer.io_Message.mn_Length && (ioreq->IOSer.io_Message.mn_Length < sizeof(struct IOExtSer)))
  65     {
  66         KPRINTF(20, ("devOpen: invalid MN_LENGTH (%ld < %ld)!\n",
  67                 ioreq->IOSer.io_Message.mn_Length, sizeof(struct IOExtSer)));
  68
  69         ioreq->IOSer.io_Error = IOERR_BADLENGTH;
  70     } else {
  71         /* Default to open failure. */
  72         ioreq->IOSer.io_Error = IOERR_OPENFAIL;
  73
  74         ioreq->IOSer.io_Unit = NULL;
  75         ncp = (struct NepClassSerial *) 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->IOSer.io_Error = IOERR_UNITBUSY;
  83                 } else {
  84                     ioreq->IOSer.io_Unit = (struct Unit *) ncp;
  85                 }
  86                 break;
  87             }
  88             ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
  89         }
  90
  91         if(!ioreq->IOSer.io_Unit)
  92         {
  93             /* Deaf opening
  94             */
  95             KPRINTF(20, ("devOpen: unit not allocated, opening anyway!\n"));
  96             //ioreq->IOSer.io_Unit = &base->np_ClsBase->nh_DummyUnit;
  97             ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  98             ioreq->IOSer.io_Error                   = 0;
  99
 100             ioreq->io_CtlChar = SER_DEFAULT_CTLCHAR;
 101             ioreq->io_RBufLen = 2048;
 102             ioreq->io_ExtFlags = 0;
 103             ioreq->io_Baud = 9600;
 104             ioreq->io_BrkTime = 250000;
 105             ioreq->io_TermArray.TermArray0 = 0;
 106             ioreq->io_TermArray.TermArray1 = 0;
 107             ioreq->io_ReadLen = 8;
 108             ioreq->io_WriteLen = 8;
 109             ioreq->io_StopBits = 1;
 110             if(ioreq->io_SerFlags & SERF_RAD_BOOGIE)
 111             {
 112                 ioreq->io_SerFlags |= SERF_XDISABLED;
 113                 ioreq->io_SerFlags &= ~SERF_PARTY_ON|SERF_PARTY_ODD;
 114             }
 115             return base;
 116         } else {
 117             /* Opended ok! */
 118             ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 119             ioreq->IOSer.io_Error                   = 0;
 120             ioreq->IOSer.io_Unit->unit_OpenCnt++;
 121
 122             ioreq->io_CtlChar = SER_DEFAULT_CTLCHAR;
 123             ioreq->io_RBufLen = 2048;
 124             ioreq->io_ExtFlags = 0;
 125             ioreq->io_Baud = 9600;
 126             ioreq->io_BrkTime = 250000;
 127             ioreq->io_TermArray.TermArray0 = 0;
 128             ioreq->io_TermArray.TermArray1 = 0;
 129             ioreq->io_ReadLen = 8;
 130             ioreq->io_WriteLen = 8;
 131             ioreq->io_StopBits = 1;
 132             if(ioreq->io_SerFlags & SERF_RAD_BOOGIE)
 133             {
 134                 ioreq->io_SerFlags |= SERF_XDISABLED;
 135                 ioreq->io_SerFlags &= ~SERF_PARTY_ON|SERF_PARTY_ODD;
 136             }
 137
 138             /* Allow queuing */
 139             ncp->ncp_DenyRequests = FALSE;
 140             /* initial settings */
 141             ioreq->IOSer.io_Command = SDCMD_SETPARAMS;
 142             ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 143             PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 144             while(!GetMsg(&ncp->ncp_Unit.unit_MsgPort))
 145             {
 146                 WaitPort(&ncp->ncp_Unit.unit_MsgPort);
 147             }
 148             return base;
 149         }
 150     }
 151
 152     ioreq->IOSer.io_Unit   = (APTR) -1;
 153     ioreq->IOSer.io_Device = (APTR) -1;
 154     base->np_Library.lib_OpenCnt--;
 155
 156     return(NULL);
 157
 158     AROS_LIBFUNC_EXIT
 159 }
 160
 161
 162 AROS_LH1(BPTR, devClose,
 163          AROS_LHA(struct IOExtSer *, ioreq, A1),
 164          DEVBASETYPEPTR, base, 2, dev)
 165 {
 166     AROS_LIBFUNC_INIT
 167
 168     BPTR ret;
 169     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 170
 171     KPRINTF(10, ("devClose ioreq: 0x%08lx base: 0x%08lx\n", ioreq, base));
 172
 173     ret = BNULL;
 174
 175     if(ncp)//(struct Unit *) ncp != &base->np_ClsBase->nh_DummyUnit)
 176     {
 177         /* Don't allow queuing */
 178         ncp->ncp_DenyRequests = TRUE;
 179         /* close connection */
 180         ioreq->IOSer.io_Command = CMD_INVALID;
 181         ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 182         PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 183         while(!GetMsg(&ncp->ncp_Unit.unit_MsgPort))
 184         {
 185             WaitPort(&ncp->ncp_Unit.unit_MsgPort);
 186         }
 187         ncp->ncp_Unit.unit_OpenCnt--;
 188     }
 189     ioreq->IOSer.io_Unit   = (APTR) -1;
 190     ioreq->IOSer.io_Device = (APTR) -1;
 191
 192     if(--base->np_Library.lib_OpenCnt == 0)
 193     {
 194         if(base->np_Library.lib_Flags & LIBF_DELEXP)
 195         {
 196             KPRINTF(5, ("devClose: calling expunge...\n"));
 197             ret = AROS_LC1(BPTR, devExpunge,
 198                            AROS_LCA(DEVBASETYPEPTR, base, D0),
 199                            DEVBASETYPEPTR, base, 3, dev);
 200         }
 201     }
 202
 203     KPRINTF(5, ("devClose: lib_OpenCnt = %ld\n", base->np_Library.lib_OpenCnt));
 204
 205     return(ret);
 206
 207     AROS_LIBFUNC_EXIT
 208 }
 209
 210
 211 AROS_LH1(BPTR, devExpunge,
 212          AROS_LHA(DEVBASETYPEPTR, extralh, D0),
 213          DEVBASETYPEPTR, base, 3, dev)
 214 {
 215     AROS_LIBFUNC_INIT
 216
 217     BPTR ret;
 218
 219     KPRINTF(10, ("devExpunge base: 0x%08lx\n", base));
 220
 221     ret = BNULL;
 222
 223     if(base->np_Library.lib_OpenCnt == 0)
 224     {
 225         KPRINTF(5, ("devExpunge: Unloading...\n"));
 226
 227         CloseLibrary(base->np_UtilityBase);
 228
 229         ret = base->np_SegList;
 230
 231         KPRINTF(5, ("devExpunge: removing device node 0x%08lx\n",
 232                     &base->np_Library.lib_Node));
 233         Remove(&base->np_Library.lib_Node);
 234
 235         KPRINTF(5, ("devExpunge: FreeMem()...\n"));
 236         FreeMem((char *) base - base->np_Library.lib_NegSize,
 237                 (ULONG) (base->np_Library.lib_NegSize + base->np_Library.lib_PosSize));
 238
 239         KPRINTF(5, ("devExpunge: Unloading done! " DEVNAME " expunged!\n\n"));
 240
 241         return(ret);
 242     }
 243     else
 244     {
 245         KPRINTF(5, ("devExpunge: Could not expunge, LIBF_DELEXP set!\n"));
 246         base->np_Library.lib_Flags |= LIBF_DELEXP;
 247     }
 248
 249     return(BNULL);
 250
 251     AROS_LIBFUNC_EXIT
 252 }
 253
 254 AROS_LH0(DEVBASETYPEPTR, devReserved,
 255          DEVBASETYPEPTR, base, 4, dev)
 256 {
 257     AROS_LIBFUNC_INIT
 258     return NULL;
 259     AROS_LIBFUNC_EXIT
 260 }
 261
 262 AROS_LH1(void, devBeginIO,
 263          AROS_LHA(struct IOExtSer *, ioreq, A1),
 264          DEVBASETYPEPTR, base, 5, dev)
 265 {
 266     AROS_LIBFUNC_INIT
 267
 268     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 269     WORD ret = IOERR_NOCMD;
 270
 271     KPRINTF(1, ("devBeginIO ioreq: 0x%08lx base: 0x%08lx cmd: %lu len: %ld\n", ioreq, base, ioreq->IOSer.io_Command, ioreq->IOSer.io_Length));
 272
 273     ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 274     ioreq->IOSer.io_Error                   = 0;
 275
 276     if(ioreq->IOSer.io_Command < NSCMD_DEVICEQUERY)
 277     {
 278         if(!ncp)//(struct Unit *) ncp == &base->np_ClsBase->nh_DummyUnit)
 279         {
 280             /* see, if unit arrived in the meanwhile? */
 281             ncp = (struct NepClassSerial *) base->np_ClsBase->nh_Units.lh_Head;
 282             while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
 283             {
 284                 if(!ncp->ncp_Unit.unit_OpenCnt)
 285                 {
 286                     ioreq->IOSer.io_Unit = (struct Unit *) ncp;
 287                     ioreq->IOSer.io_Unit->unit_OpenCnt++;
 288                     ncp->ncp_DenyRequests = FALSE;
 289                     /* FIXME: Need call to SDCMD_SETPARAMS */
 290                     break;
 291                 }
 292                 ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
 293             }
 294             ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 295         }
 296         if(ncp)//(struct Unit *) ncp != &base->np_ClsBase->nh_DummyUnit)
 297         {
 298             switch (ioreq->IOSer.io_Command)
 299             {
 300                 case CMD_READ:
 301                     if(ncp->ncp_EPInStream && (!ncp->ncp_DenyRequests))
 302                     {
 303                         ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 304                         Forbid();
 305                         AddTail(&ncp->ncp_ReadQueue, &ioreq->IOSer.io_Message.mn_Node);
 306                         if(ncp->ncp_Task)
 307                         {
 308                             Signal(ncp->ncp_Task, 1UL<<ncp->ncp_TaskMsgPort->mp_SigBit);
 309                         }
 310                         Permit();
 311                         ret = RC_DONTREPLY;
 312                     } else {
 313                         ret = IOERR_ABORTED;
 314                     }
 315                     break;
 316
 317                 case CMD_WRITE:
 318                     if(!ncp->ncp_DenyRequests)
 319                     {
 320                         if(ioreq->IOSer.io_Length == -1)
 321                         {
 322                             ioreq->IOSer.io_Length = strlen(ioreq->IOSer.io_Data);
 323                         }
 324                         ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 325                         Forbid();
 326                         AddTail(&ncp->ncp_WriteQueue, &ioreq->IOSer.io_Message.mn_Node);
 327                         if(ncp->ncp_Task)
 328                         {
 329                             Signal(ncp->ncp_Task, 1UL<<ncp->ncp_TaskMsgPort->mp_SigBit);
 330                         }
 331                         Permit();
 332                         ret = RC_DONTREPLY;
 333                     } else {
 334                         ret = IOERR_ABORTED;
 335                     }
 336                     break;
 337
 338                 case CMD_START:
 339                     ncp->ncp_DevSuspend = FALSE;
 340                     ret = RC_OK;
 341                     break;
 342
 343                 case CMD_STOP:
 344                     ncp->ncp_DevSuspend = TRUE;
 345                     ret = RC_OK;
 346                     break;
 347
 348                 /*case SDCMD_QUERY:
 349                     ioreq->IOSer.io_Actual = 1;
 350                     ioreq->io_Status = 0;*/
 351                 case SDCMD_BREAK:
 352                     ret = RC_OK;
 353                     break;
 354
 355                 case CMD_CLEAR:
 356                                         case CMD_RESET:
 357                         case CMD_FLUSH:
 358                 case SDCMD_QUERY:
 359                                   case SDCMD_SETPARAMS:
 360                     if(!ncp->ncp_DenyRequests)
 361                     {
 362                         ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 363                         ret = RC_DONTREPLY;
 364                         PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 365                     } else {
 366                         ioreq->IOSer.io_Actual = 0;
 367                         ret = IOERR_ABORTED;
 368                     }
 369                     break;
 370
 371                 default:
 372                     ret = IOERR_NOCMD;
 373                     break;
 374             }
 375         } else {
 376             /* deaf mode */
 377             ret = IOERR_ABORTED;
 378         }
 379     } else {
 380         switch(ioreq->IOSer.io_Command)
 381         {
 382             case NSCMD_DEVICEQUERY:
 383                 ret = cmdNSDeviceQuery((struct IOStdReq *) ioreq, ncp, base);
 384                 break;
 385
 386             default:
 387                 ret = IOERR_NOCMD;
 388                 break;
 389         }
 390     }
 391
 392     if(ret != RC_DONTREPLY)
 393     {
 394         KPRINTF(1, ("TermIO\n"));
 395         if (ret != RC_OK)
 396         {
 397             /* Set error codes
 398             */
 399             ioreq->IOSer.io_Error = ret & 0xff;
 400         }
 401         /* Terminate the iorequest
 402         */
 403         TermIO(ioreq, base);
 404     }
 405
 406     AROS_LIBFUNC_EXIT
 407 }
 408
 409 AROS_LH1(LONG, devAbortIO,
 410          AROS_LHA(struct IOExtSer *, ioreq, A1),
 411          DEVBASETYPEPTR, base, 6, dev)
 412 {
 413     AROS_LIBFUNC_INIT
 414
 415     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 416     struct IOExtSer *iocmp;
 417
 418     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
 419
 420     if(!ncp)//(struct Unit *) ncp != &base->np_ClsBase->nh_DummyUnit)
 421     {
 422         return(0);
 423     }
 424
 425     /* Is it pending?
 426     */
 427     Forbid();
 428     if(ioreq->IOSer.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 429     {
 430         /* check if it's the writing pipe */
 431         if(ioreq == ncp->ncp_WritePending)
 432         {
 433             if(ncp->ncp_AbortSignal >= 0)
 434             {
 435                 /* prod the subtask */
 436                 Signal(ncp->ncp_Task, 1UL<<ncp->ncp_AbortSignal);
 437             }
 438             Permit();
 439             return(0);
 440         }
 441         iocmp = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 442         while(iocmp->IOSer.io_Message.mn_Node.ln_Succ)
 443         {
 444             if(iocmp == ioreq)
 445             {
 446                 Remove((struct Node *) ioreq);
 447                 ioreq->IOSer.io_Error = IOERR_ABORTED;
 448                 ReplyMsg(&ioreq->IOSer.io_Message);
 449                 Permit();
 450                 return(0);
 451             }
 452             iocmp = (struct IOExtSer *) iocmp->IOSer.io_Message.mn_Node.ln_Succ;
 453         }
 454         iocmp = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 455         while(iocmp->IOSer.io_Message.mn_Node.ln_Succ)
 456         {
 457             if(iocmp == ioreq)
 458             {
 459                 Remove((struct Node *)ioreq);
 460                 ioreq->IOSer.io_Error = IOERR_ABORTED;
 461                 ReplyMsg(&ioreq->IOSer.io_Message);
 462                 Permit();
 463                 return(0);
 464             }
 465             iocmp = (struct IOExtSer *) iocmp->IOSer.io_Message.mn_Node.ln_Succ;
 466         }
 467     }
 468     Permit();
 469     return(-1);
 470
 471     AROS_LIBFUNC_EXIT
 472 }
 473
 474 /* NSD stuff
 475 */
 476
 477 static
 478 const UWORD NSDSupported[] =
 479 {
 480     CMD_CLEAR, CMD_RESET,
 481     CMD_FLUSH, CMD_READ,
 482     CMD_WRITE, CMD_START,
 483     CMD_STOP,  SDCMD_QUERY,
 484     SDCMD_SETPARAMS,
 485     SDCMD_BREAK,
 486     NSCMD_DEVICEQUERY, 0
 487 };
 488
 489 WORD cmdNSDeviceQuery(struct IOStdReq *ioreq,
 490                       struct NepClassSerial *ncp,
 491                       struct NepSerDevBase *base)
 492 {
 493     struct my_NSDeviceQueryResult *query;
 494
 495     query = (struct my_NSDeviceQueryResult *) ioreq->io_Data;
 496
 497     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%08lx query: 0x%08lx\n", ioreq, query));
 498
 499     /* NULL ptr?
 500        Enough data?
 501        Valid request?
 502     */
 503     if((!query) ||
 504        (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
 505        (query->DevQueryFormat != 0) ||
 506        (query->SizeAvailable != 0))
 507     {
 508         /* Return error. This is special handling, since iorequest is only
 509            guaranteed to be sizeof(struct IOStdReq). If we'd let our
 510            devBeginIO dispatcher return the error, it would trash some
 511            memory past end of the iorequest (ios2_WireError field).
 512          */
 513          ioreq->io_Error = IOERR_NOCMD;
 514          TermIO((struct IOExtSer *) ioreq, base);
 515
 516          /* Don't reply, we already did.
 517          */
 518          return RC_DONTREPLY;
 519     }
 520
 521     ioreq->io_Actual         = query->SizeAvailable
 522                              = sizeof(struct my_NSDeviceQueryResult);
 523     query->DeviceType        = NSDEVTYPE_SERIAL;
 524     query->DeviceSubType     = 0;
 525     query->SupportedCommands = NSDSupported;
 526
 527     /* Return success (note that this will NOT poke ios2_WireError).
 528     */
 529     return RC_OK;
 530 }
 531
 532 /*
 533  *===========================================================
 534  * TermIO(ioreq, base)
 535  *===========================================================
 536  *
 537  * Return completed ioreq to sender.
 538  *
 539  */
 540
 541 void TermIO(struct IOExtSer *ioreq,
 542             struct NepSerDevBase *base)
 543 {
 544     ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_FREEMSG;
 545
 546     /* If not quick I/O, reply the message
 547     */
 548     if(!(ioreq->IOSer.io_Flags & IOF_QUICK))
 549     {
 550         ReplyMsg(&ioreq->IOSer.io_Message);
 551     }
 552 }