rom/usb/classes/serialpl2303/dev.c

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