rom/usb/classes/serialcp210x/dev.c

   1 /* dev.c - serialcp210x.device by Chris Hodges
   2 */
   3
   4 #include "debug.h"
   5
   6 #include "serialcp210x.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             ioreq->IOSer.io_Error = IOERR_OPENFAIL;
  94             KPRINTF(20, ("devOpen: could not open unit!\n"));
  95         } else {
  96             /* Opended ok! */
  97             ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  98             ioreq->IOSer.io_Error                   = 0;
  99             ioreq->IOSer.io_Unit->unit_OpenCnt++;
 100
 101             ioreq->io_CtlChar = SER_DEFAULT_CTLCHAR;
 102             ioreq->io_RBufLen = DEFREADBUFLEN;
 103             ioreq->io_ExtFlags = 0;
 104             ioreq->io_Baud = 9600;
 105             ioreq->io_BrkTime = 250000;
 106             ioreq->io_TermArray.TermArray0 = 0;
 107             ioreq->io_TermArray.TermArray1 = 0;
 108             ioreq->io_ReadLen = 8;
 109             ioreq->io_WriteLen = 8;
 110             ioreq->io_StopBits = 1;
 111             if(ioreq->io_SerFlags & SERF_RAD_BOOGIE)
 112             {
 113                 ioreq->io_SerFlags |= SERF_XDISABLED;
 114                 ioreq->io_SerFlags &= ~SERF_PARTY_ON|SERF_PARTY_ODD;
 115             }
 116
 117             /* Allow queuing */
 118             ncp->ncp_DenyRequests = FALSE;
 119
 120             /* initial settings */
 121             ioreq->IOSer.io_Command = SDCMD_SETPARAMS;
 122             ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 123             PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 124             while(!GetMsg(&ncp->ncp_Unit.unit_MsgPort))
 125             {
 126                 WaitPort(&ncp->ncp_Unit.unit_MsgPort);
 127             }
 128
 129             return base;
 130         }
 131     }
 132
 133     ioreq->IOSer.io_Unit   = (APTR) -1;
 134     ioreq->IOSer.io_Device = (APTR) -1;
 135     base->np_Library.lib_OpenCnt--;
 136
 137     return(NULL);
 138
 139     AROS_LIBFUNC_EXIT
 140 }
 141
 142
 143 AROS_LH1(BPTR, devClose,
 144          AROS_LHA(struct IOExtSer *, ioreq, A1),
 145          DEVBASETYPEPTR, base, 2, dev)
 146 {
 147     AROS_LIBFUNC_INIT
 148
 149     BPTR ret;
 150     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 151
 152     KPRINTF(10, ("devClose ioreq: 0x%08lx base: 0x%08lx\n", ioreq, base));
 153
 154     ret = BNULL;
 155
 156     /* Don't allow queuing */
 157     ncp->ncp_DenyRequests = TRUE;
 158
 159     ncp->ncp_Unit.unit_OpenCnt--;
 160     ioreq->IOSer.io_Unit   = (APTR) -1;
 161     ioreq->IOSer.io_Device = (APTR) -1;
 162
 163     if(--base->np_Library.lib_OpenCnt == 0)
 164     {
 165         if(base->np_Library.lib_Flags & LIBF_DELEXP)
 166         {
 167             KPRINTF(5, ("devClose: calling expunge...\n"));
 168             ret = AROS_LC1(BPTR, devExpunge,
 169                            AROS_LCA(DEVBASETYPEPTR, base, D0),
 170                            DEVBASETYPEPTR, base, 3, dev);
 171         }
 172     }
 173
 174     KPRINTF(5, ("devClose: lib_OpenCnt = %ld\n", base->np_Library.lib_OpenCnt));
 175
 176     return(ret);
 177
 178     AROS_LIBFUNC_EXIT
 179 }
 180
 181
 182 AROS_LH1(BPTR, devExpunge,
 183          AROS_LHA(DEVBASETYPEPTR, extralh, D0),
 184          DEVBASETYPEPTR, base, 3, dev)
 185 {
 186     AROS_LIBFUNC_INIT
 187
 188     BPTR ret;
 189
 190     KPRINTF(10, ("devExpunge base: 0x%08lx\n", base));
 191
 192     ret = BNULL;
 193
 194     if(base->np_Library.lib_OpenCnt == 0)
 195     {
 196         KPRINTF(5, ("devExpunge: Unloading...\n"));
 197
 198         CloseLibrary(base->np_UtilityBase);
 199
 200         ret = base->np_SegList;
 201
 202         KPRINTF(5, ("devExpunge: removing device node 0x%08lx\n",
 203                     &base->np_Library.lib_Node));
 204         Remove(&base->np_Library.lib_Node);
 205
 206         KPRINTF(5, ("devExpunge: FreeMem()...\n"));
 207         FreeMem((char *) base - base->np_Library.lib_NegSize,
 208                 (ULONG) (base->np_Library.lib_NegSize + base->np_Library.lib_PosSize));
 209
 210         KPRINTF(5, ("devExpunge: Unloading done! " DEVNAME " expunged!\n\n"));
 211
 212         return(ret);
 213     }
 214     else
 215     {
 216         KPRINTF(5, ("devExpunge: Could not expunge, LIBF_DELEXP set!\n"));
 217         base->np_Library.lib_Flags |= LIBF_DELEXP;
 218     }
 219
 220     return(BNULL);
 221
 222     AROS_LIBFUNC_EXIT
 223 }
 224
 225 AROS_LH0(DEVBASETYPEPTR, devReserved,
 226          DEVBASETYPEPTR, base, 4, dev)
 227 {
 228     AROS_LIBFUNC_INIT
 229     return NULL;
 230     AROS_LIBFUNC_EXIT
 231 }
 232
 233 AROS_LH1(void, devBeginIO,
 234          AROS_LHA(struct IOExtSer *, ioreq, A1),
 235          DEVBASETYPEPTR, base, 5, dev)
 236 {
 237     AROS_LIBFUNC_INIT
 238
 239     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 240     WORD ret = IOERR_NOCMD;
 241
 242     //KPRINTF(1, ("devBeginIO ioreq: 0x%08lx base: 0x%08lx cmd: %lu\n", ioreq, base, ioreq->IOSer.io_Command));
 243
 244     ioreq->IOSer.io_Message.mn_Node.ln_Type = NT_MESSAGE;
 245     ioreq->IOSer.io_Error                   = 0;
 246
 247     if(ioreq->IOSer.io_Command < NSCMD_DEVICEQUERY)
 248     {
 249         switch (ioreq->IOSer.io_Command)
 250         {
 251             case CMD_READ:
 252                 if(ncp->ncp_EPInStream && (!ncp->ncp_DenyRequests))
 253                 {
 254                     ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 255                     Forbid();
 256                     AddTail(&ncp->ncp_ReadQueue, &ioreq->IOSer.io_Message.mn_Node);
 257                     if(ncp->ncp_Task)
 258                     {
 259                         Signal(ncp->ncp_Task, 1UL<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
 260                     }
 261                     Permit();
 262                     ret = RC_DONTREPLY;
 263                 } else {
 264                     ret = IOERR_ABORTED;
 265                 }
 266                 break;
 267
 268             case CMD_WRITE:
 269                 if(!ncp->ncp_DenyRequests)
 270                 {
 271                     if(ioreq->IOSer.io_Length == -1)
 272                     {
 273                         ioreq->IOSer.io_Length = strlen(ioreq->IOSer.io_Data);
 274                     }
 275                     ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 276                     Forbid();
 277                     AddTail(&ncp->ncp_WriteQueue, &ioreq->IOSer.io_Message.mn_Node);
 278                     if(ncp->ncp_Task)
 279                     {
 280                         Signal(ncp->ncp_Task, 1UL<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
 281                     }
 282                     Permit();
 283                     ret = RC_DONTREPLY;
 284                 } else {
 285                     ret = IOERR_ABORTED;
 286                 }
 287                 break;
 288
 289             case CMD_START:
 290                 ncp->ncp_DevSuspend = FALSE;
 291                 ret = RC_OK;
 292                 break;
 293
 294             case CMD_STOP:
 295                 ncp->ncp_DevSuspend = TRUE;
 296                 ret = RC_OK;
 297                 break;
 298
 299             case CMD_CLEAR:
 300             case CMD_RESET:
 301             case CMD_FLUSH:
 302             case SDCMD_QUERY:
 303             case SDCMD_SETPARAMS:
 304             case SDCMD_BREAK:
 305                 if(!ncp->ncp_DenyRequests)
 306                 {
 307                     ioreq->IOSer.io_Flags &= ~IOF_QUICK;
 308                     ret = RC_DONTREPLY;
 309                     PutMsg(&ncp->ncp_Unit.unit_MsgPort, (struct Message *) ioreq);
 310                 } else {
 311                     ioreq->IOSer.io_Actual = 0;
 312                     ret = IOERR_ABORTED;
 313                 }
 314                 break;
 315
 316             default:
 317                 ret = IOERR_NOCMD;
 318                 break;
 319         }
 320     } else {
 321         switch(ioreq->IOSer.io_Command)
 322         {
 323             case NSCMD_DEVICEQUERY:
 324                 ret = cmdNSDeviceQuery((struct IOStdReq *) ioreq, ncp, base);
 325                 break;
 326
 327             default:
 328                 ret = IOERR_NOCMD;
 329                 break;
 330         }
 331     }
 332
 333     if(ret != RC_DONTREPLY)
 334     {
 335         KPRINTF(1, ("TermIO\n"));
 336         if (ret != RC_OK)
 337         {
 338             /* Set error codes
 339             */
 340             ioreq->IOSer.io_Error = ret & 0xff;
 341         }
 342         /* Terminate the iorequest
 343         */
 344         TermIO(ioreq, base);
 345     }
 346
 347     AROS_LIBFUNC_EXIT
 348 }
 349
 350 AROS_LH1(LONG, devAbortIO,
 351          AROS_LHA(struct IOExtSer *, ioreq, A1),
 352          DEVBASETYPEPTR, base, 6, dev)
 353 {
 354     AROS_LIBFUNC_INIT
 355
 356     struct NepClassSerial *ncp = (struct NepClassSerial *) ioreq->IOSer.io_Unit;
 357
 358     struct IOExtSer *iocmp;
 359
 360     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
 361
 362     /* Is it pending?
 363     */
 364     Forbid();
 365     if(ioreq->IOSer.io_Message.mn_Node.ln_Type == NT_MESSAGE)
 366     {
 367         /* check if it's the writing pipe */
 368         if(ioreq == ncp->ncp_WritePending)
 369         {
 370             if(ncp->ncp_AbortSignal >= 0)
 371             {
 372                 /* prod the subtask */
 373                 Signal(ncp->ncp_Task, 1UL<<ncp->ncp_AbortSignal);
 374             }
 375             Permit();
 376             return(0);
 377         }
 378         iocmp = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 379         while(iocmp->IOSer.io_Message.mn_Node.ln_Succ)
 380         {
 381             if(iocmp == ioreq)
 382             {
 383                 Remove((struct Node *) ioreq);
 384                 ioreq->IOSer.io_Error = IOERR_ABORTED;
 385                 ReplyMsg(&ioreq->IOSer.io_Message);
 386                 Permit();
 387                 return(0);
 388             }
 389             iocmp = (struct IOExtSer *) iocmp->IOSer.io_Message.mn_Node.ln_Succ;
 390         }
 391         iocmp = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 392         while(iocmp->IOSer.io_Message.mn_Node.ln_Succ)
 393         {
 394             if(iocmp == ioreq)
 395             {
 396                 Remove((struct Node *)ioreq);
 397                 ioreq->IOSer.io_Error = IOERR_ABORTED;
 398                 ReplyMsg(&ioreq->IOSer.io_Message);
 399                 Permit();
 400                 return(0);
 401             }
 402             iocmp = (struct IOExtSer *) iocmp->IOSer.io_Message.mn_Node.ln_Succ;
 403         }
 404     }
 405     Permit();
 406     return(-1);
 407
 408     AROS_LIBFUNC_EXIT
 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 }