rom/usb/classes/serialpl2303/serialpl2303.class.c

   1 /*
   2  *----------------------------------------------------------------------------
   3  *                         serialpl2303 class for poseidon
   4  *----------------------------------------------------------------------------
   5  *                   By Chris Hodges <chrisly@platon42.de>
   6  */
   7
   8 #include "debug.h"
   9
  10 #include "serialpl2303.class.h"
  11
  12 /* /// "Lib Stuff" */
  13 static const STRPTR libname = MOD_NAME_STRING;
  14
  15 static
  16 const APTR DevFuncTable[] =
  17 {
  18     &AROS_SLIB_ENTRY(devOpen, dev, 1),
  19     &AROS_SLIB_ENTRY(devClose, dev, 2),
  20     &AROS_SLIB_ENTRY(devExpunge, dev, 3),
  21     &AROS_SLIB_ENTRY(devReserved, dev, 4),
  22     &AROS_SLIB_ENTRY(devBeginIO, dev, 5),
  23     &AROS_SLIB_ENTRY(devAbortIO, dev, 6),
  24     (APTR) -1,
  25 };
  26
  27 static int libInit(LIBBASETYPEPTR nh)
  28 {
  29     struct NepSerialBase *ret = NULL;
  30
  31     KPRINTF(10, ("libInit nh: 0x%08lx SysBase: 0x%08lx\n", nh, SysBase));
  32
  33     nh->nh_UtilityBase = OpenLibrary("utility.library", 39);
  34
  35 #define UtilityBase     nh->nh_UtilityBase
  36
  37     if(UtilityBase)
  38     {
  39         NewList(&nh->nh_Units);
  40
  41         if((nh->nh_DevBase = (struct NepSerDevBase *) MakeLibrary((APTR) DevFuncTable, NULL, (APTR) devInit,
  42            sizeof(struct NepSerDevBase), NULL)))
  43         {
  44             nh->nh_DevBase->np_ClsBase = nh;
  45             Forbid();
  46             AddDevice((struct Device *) nh->nh_DevBase);
  47             nh->nh_DevBase->np_Library.lib_OpenCnt++;
  48             Permit();
  49             ret = nh;
  50         } else {
  51             KPRINTF(20, ("failed to create serialpl2303.device\n"));
  52         }
  53         if(!ret)
  54         {
  55             CloseLibrary(UtilityBase);
  56         }
  57     } else {
  58         KPRINTF(20, ("libInit: OpenLibrary(\"utility.library\", 39) failed!\n"));
  59     }
  60
  61     KPRINTF(10, ("libInit: Ok\n"));
  62     return(ret ? TRUE : FALSE);
  63 }
  64
  65 static int libExpunge(LIBBASETYPEPTR nh)
  66 {
  67     struct NepClassSerial *ncp;
  68
  69     KPRINTF(10, ("libExpunge nh: 0x%08lx\n", nh));
  70
  71     if(nh->nh_DevBase->np_Library.lib_OpenCnt == 1)
  72     {
  73         KPRINTF(1, ("libExpunge: closelibrary utilitybase 0x%08lx\n",
  74                     UtilityBase));
  75         CloseLibrary((struct Library *) UtilityBase);
  76
  77         ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
  78         while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
  79         {
  80             Remove((struct Node *) ncp);
  81             FreeVec(ncp);
  82             ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
  83         }
  84
  85         nh->nh_DevBase->np_Library.lib_OpenCnt--;
  86         RemDevice((struct Device *) nh->nh_DevBase);
  87
  88         KPRINTF(5, ("libExpunge: Unloading done! serialpl2303.class expunged!\n\n"));
  89     } else {
  90         KPRINTF(5, ("libExpunge: Could not expunge, LIBF_DELEXP set!\n"));
  91         return(FALSE);
  92     }
  93
  94     return(TRUE);
  95 }
  96
  97 ADD2INITLIB(libInit, 0)
  98 ADD2EXPUNGELIB(libExpunge, 0)
  99 /* \\\ */
 100
 101 /*
 102  * ***********************************************************************
 103  * * Library functions                                                   *
 104  * ***********************************************************************
 105  */
 106
 107 struct AutoBindData
 108 {
 109     UWORD abd_VendID;
 110     UWORD abd_ProdID;
 111 };
 112
 113 struct AutoBindData ClassBinds[] =
 114 {
 115     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID },
 116     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID_RSAQ2 },
 117     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID_RSAQ3 },
 118     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID_DCU11 },
 119     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID_PHAROS },
 120     { PL2303_VENDOR_ID      , PL2303_PRODUCT_ID_ALDIGA },
 121     { ATEN_VENDOR_ID        , ATEN_PRODUCT_ID },
 122     { ATEN_VENDOR_ID2       , ATEN_PRODUCT_ID },
 123     { IODATA_VENDOR_ID      , IODATA_PRODUCT_ID },
 124     { IODATA_VENDOR_ID      , IODATA_PRODUCT_ID_RSAQ5 },
 125     { ELCOM_VENDOR_ID       , ELCOM_PRODUCT_ID },
 126     { ELCOM_VENDOR_ID       , ELCOM_PRODUCT_ID_UCSGT },
 127     { ITEGNO_VENDOR_ID      , ITEGNO_PRODUCT_ID },
 128     { ITEGNO_VENDOR_ID      , ITEGNO_PRODUCT_ID_2 },
 129     { MA620_VENDOR_ID       , MA620_PRODUCT_ID },
 130     { RATOC_VENDOR_ID       , RATOC_PRODUCT_ID },
 131     { RATOC_VENDOR_ID       , RATOC_PRODUCT_ID_USB60F },
 132     { TRIPP_VENDOR_ID       , TRIPP_PRODUCT_ID },
 133     { RADIOSHACK_VENDOR_ID  , RADIOSHACK_PRODUCT_ID },
 134     { DCU10_VENDOR_ID       , DCU10_PRODUCT_ID },
 135     { ALCATEL_VENDOR_ID     , ALCATEL_PRODUCT_ID },
 136     { SITECOM_VENDOR_ID     , SITECOM_PRODUCT_ID },
 137     { SAMSUNG_VENDOR_ID     , SAMSUNG_PRODUCT_ID },
 138     { SIEMENS_VENDOR_ID     , SIEMENS_PRODUCT_ID_SX1 },
 139     { SIEMENS_VENDOR_ID     , SIEMENS_PRODUCT_ID_X65 },
 140     { SIEMENS_VENDOR_ID     , SIEMENS_PRODUCT_ID_X75 },
 141     { SIEMENS_VENDOR_ID     , SIEMENS_PRODUCT_ID_EF81 },
 142     { SYNTECH_VENDOR_ID     , SYNTECH_PRODUCT_ID },
 143     { NOKIA_CA42_VENDOR_ID  , NOKIA_CA42_PRODUCT_ID },
 144     { CA_42_CA42_VENDOR_ID  , CA_42_CA42_PRODUCT_ID },
 145     { SAGEM_VENDOR_ID       , SAGEM_PRODUCT_ID },
 146     { LEADTEK_VENDOR_ID     , LEADTEK_9531_PRODUCT_ID },
 147     { SPEEDDRAGON_VENDOR_ID , SPEEDDRAGON_PRODUCT_ID },
 148     { OTI_VENDOR_ID         , OTI_PRODUCT_ID },
 149     { DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID },
 150     { BELKIN_VENDOR_ID      , BELKIN_PRODUCT_ID },
 151     { ALCOR_VENDOR_ID       , ALCOR_PRODUCT_ID },
 152     { WS002IN_VENDOR_ID     , WS002IN_PRODUCT_ID },
 153     { COREGA_VENDOR_ID      , COREGA_PRODUCT_ID },
 154     { HL340_VENDOR_ID       , HL340_PRODUCT_ID },
 155     { YCCABLE_VENDOR_ID     , YCCABLE_PRODUCT_ID },
 156     { 0, 0 }
 157 };
 158
 159 /* /// "usbAttemptDeviceBinding()" */
 160 struct NepClassSerial * usbAttemptDeviceBinding(struct NepSerialBase *nh, struct PsdDevice *pd)
 161 {
 162     struct Library *ps;
 163     struct AutoBindData *abd = ClassBinds;
 164     IPTR prodid;
 165     IPTR vendid;
 166
 167     KPRINTF(1, ("nepSerialAttemptDeviceBinding(%08lx)\n", pd));
 168     if((ps = OpenLibrary("poseidon.library", 4)))
 169     {
 170         psdGetAttrs(PGA_DEVICE, pd,
 171                     DA_VendorID, &vendid,
 172                     DA_ProductID, &prodid,
 173                     TAG_END);
 174         CloseLibrary(ps);
 175         while(abd->abd_VendID)
 176         {
 177             if((vendid == abd->abd_VendID) && (prodid == abd->abd_ProdID))
 178             {
 179                 return(usbForceDeviceBinding(nh, pd));
 180             }
 181             abd++;
 182         }
 183     }
 184     return(NULL);
 185 }
 186 /* \\\ */
 187
 188 /* /// "usbForceDeviceBinding()" */
 189 struct NepClassSerial * usbForceDeviceBinding(struct NepSerialBase *nh, struct PsdDevice *pd)
 190 {
 191     struct Library *ps;
 192     struct NepClassSerial *ncp;
 193     STRPTR devname;
 194     IPTR prodid;
 195     IPTR vendid;
 196     ULONG unitno;
 197     BOOL  unitfound;
 198     UBYTE buf[64];
 199     struct Task *tmptask;
 200
 201     KPRINTF(1, ("nepSerialForceDeviceBinding(%08lx)\n", pd));
 202     if((ps = OpenLibrary("poseidon.library", 4)))
 203     {
 204         psdGetAttrs(PGA_DEVICE, pd,
 205                     DA_ProductID, &prodid,
 206                     DA_VendorID, &vendid,
 207                     DA_ProductName, &devname,
 208                     TAG_END);
 209         Forbid();
 210         /* Find next free unit number */
 211         unitno = 0;
 212         ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
 213         while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
 214         {
 215             if(ncp->ncp_UnitNo == unitno)
 216             {
 217                 unitno++;
 218                 ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
 219             } else {
 220                 ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
 221             }
 222         }
 223         unitfound = FALSE;
 224         ncp = (struct NepClassSerial *) nh->nh_Units.lh_Head;
 225         while(ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ)
 226         {
 227             if((ncp->ncp_UnitProdID == prodid) && (ncp->ncp_UnitVendorID == vendid))
 228             {
 229                 unitno = ncp->ncp_UnitNo;
 230                 unitfound = TRUE;
 231                 break;
 232             }
 233             ncp = (struct NepClassSerial *) ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Succ;
 234         }
 235         if(!unitfound)
 236         {
 237             /* as units are freed in the expunge-vector, the memory is
 238                outside the scope of the poseidon library */
 239             if(!(ncp = AllocVec(sizeof(struct NepClassSerial), MEMF_PUBLIC|MEMF_CLEAR)))
 240             {
 241                 Permit();
 242                 CloseLibrary(ps);
 243                 return(NULL);
 244             }
 245             /* IORequests may be queued even if the task is gone. */
 246             NewList(&ncp->ncp_Unit.unit_MsgPort.mp_MsgList);
 247             NewList(&ncp->ncp_ReadQueue);
 248             NewList(&ncp->ncp_WriteQueue);
 249             AddTail(&nh->nh_Units, &ncp->ncp_Unit.unit_MsgPort.mp_Node);
 250             ncp->ncp_DenyRequests = TRUE;
 251         }
 252         ncp->ncp_UnitNo = unitno;
 253         ncp->ncp_Device = pd;
 254         ncp->ncp_UnitProdID = prodid;
 255         ncp->ncp_UnitVendorID = vendid;
 256         Permit();
 257
 258         psdSafeRawDoFmt(buf, 64, "serialpl2303.class<%08lx>", ncp);
 259         ncp->ncp_ReadySignal = SIGB_SINGLE;
 260         ncp->ncp_ReadySigTask = FindTask(NULL);
 261         SetSignal(0, SIGF_SINGLE);
 262         if((tmptask = psdSpawnSubTask(buf, nSerialTask, ncp)))
 263         {
 264             psdBorrowLocksWait(tmptask, 1UL<<ncp->ncp_ReadySignal);
 265             if(ncp->ncp_Task)
 266             {
 267                 ncp->ncp_ReadySigTask = NULL;
 268                 //FreeSignal(ncp->ncp_ReadySignal);
 269                 psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 270                                "Another serial killer '%s' at %s unit %ld!",
 271                                devname, nh->nh_DevBase->np_Library.lib_Node.ln_Name,
 272                                ncp->ncp_UnitNo);
 273
 274                 CloseLibrary(ps);
 275                 return(ncp);
 276             }
 277         }
 278         ncp->ncp_ReadySigTask = NULL;
 279         //FreeSignal(ncp->ncp_ReadySignal);
 280         /* Get rid of unit structure */
 281         /*Forbid();
 282         Remove((struct Node *) ncp);
 283         FreeVec(ncp);
 284         Permit();*/
 285         CloseLibrary(ps);
 286     }
 287     return(NULL);
 288 }
 289 /* \\\ */
 290
 291 /* /// "usbReleaseDeviceBinding()" */
 292 void usbReleaseDeviceBinding(struct NepSerialBase *nh, struct NepClassSerial *ncp)
 293 {
 294     struct Library *ps;
 295     STRPTR devname;
 296
 297     KPRINTF(1, ("nepSerialReleaseDeviceBinding(%08lx)\n", ncp));
 298     if((ps = OpenLibrary("poseidon.library", 4)))
 299     {
 300         Forbid();
 301         ncp->ncp_ReadySignal = SIGB_SINGLE;
 302         ncp->ncp_ReadySigTask = FindTask(NULL);
 303         if(ncp->ncp_Task)
 304         {
 305             Signal(ncp->ncp_Task, SIGBREAKF_CTRL_C);
 306         }
 307         Permit();
 308         while(ncp->ncp_Task)
 309         {
 310             Wait(1L<<ncp->ncp_ReadySignal);
 311         }
 312         //FreeSignal(ncp->ncp_ReadySignal);
 313         psdGetAttrs(PGA_DEVICE, ncp->ncp_Device, DA_ProductName, &devname, TAG_END);
 314         psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 315                        "Lost the wire on '%s'.",
 316                        devname);
 317         /*psdFreeVec(ncp);*/
 318         CloseLibrary(ps);
 319     }
 320 }
 321 /* \\\ */
 322
 323 /* /// "usbGetAttrsA()" */
 324 AROS_LH3(LONG, usbGetAttrsA,
 325          AROS_LHA(ULONG, type, D0),
 326          AROS_LHA(APTR, usbstruct, A0),
 327          AROS_LHA(struct TagItem *, tags, A1),
 328          LIBBASETYPEPTR, nh, 5, nep)
 329 {
 330     AROS_LIBFUNC_INIT
 331
 332     struct TagItem *ti;
 333     LONG count = 0;
 334
 335     KPRINTF(1, ("nepHidGetAttrsA(%ld, %08lx, %08lx)\n", type, usbstruct, tags));
 336     switch(type)
 337     {
 338         case UGA_CLASS:
 339              if((ti = FindTagItem(UCCA_Priority, tags)))
 340              {
 341                  *((SIPTR *) ti->ti_Data) = 0;
 342                  count++;
 343              }
 344              if((ti = FindTagItem(UCCA_Description, tags)))
 345              {
 346                  *((STRPTR *) ti->ti_Data) = "PL2303 serial adapter via serialpl2303.device";
 347                  count++;
 348              }
 349              if((ti = FindTagItem(UCCA_HasClassCfgGUI, tags)))
 350              {
 351                  *((IPTR *) ti->ti_Data) = FALSE;
 352                  count++;
 353              }
 354              if((ti = FindTagItem(UCCA_HasBindingCfgGUI, tags)))
 355              {
 356                  *((IPTR *) ti->ti_Data) = FALSE;
 357                  count++;
 358              }
 359              if((ti = FindTagItem(UCCA_AfterDOSRestart, tags)))
 360              {
 361                  *((IPTR *) ti->ti_Data) = FALSE;
 362                  count++;
 363              }
 364              if((ti = FindTagItem(UCCA_UsingDefaultCfg, tags)))
 365              {
 366                  *((IPTR *) ti->ti_Data) = TRUE;
 367                  count++;
 368              }
 369              break;
 370
 371          case UGA_BINDING:
 372              if((ti = FindTagItem(UCBA_UsingDefaultCfg, tags)))
 373              {
 374                  *((IPTR *) ti->ti_Data) = TRUE;
 375                  count++;
 376              }
 377              break;
 378     }
 379     return(count);
 380     AROS_LIBFUNC_EXIT
 381 }
 382 /* \\\ */
 383
 384 /* /// "usbSetAttrsA()" */
 385 AROS_LH3(LONG, usbSetAttrsA,
 386          AROS_LHA(ULONG, type, D0),
 387          AROS_LHA(APTR, usbstruct, A0),
 388          AROS_LHA(struct TagItem *, tags, A1),
 389          LIBBASETYPEPTR, nh, 6, nep)
 390 {
 391     AROS_LIBFUNC_INIT
 392     return(0);
 393     AROS_LIBFUNC_EXIT
 394 }
 395 /* \\\ */
 396
 397 /* /// "usbDoMethodA()" */
 398 AROS_LH2(IPTR, usbDoMethodA,
 399          AROS_LHA(ULONG, methodid, D0),
 400          AROS_LHA(IPTR *, methoddata, A1),
 401          LIBBASETYPEPTR, nh, 7, nep)
 402 {
 403     AROS_LIBFUNC_INIT
 404
 405     KPRINTF(10, ("Do Method %ld\n", methodid));
 406     switch(methodid)
 407     {
 408         case UCM_AttemptDeviceBinding:
 409             return((IPTR) usbAttemptDeviceBinding(nh, (struct PsdDevice *) methoddata[0]));
 410
 411         case UCM_ForceDeviceBinding:
 412             return((IPTR) usbForceDeviceBinding(nh, (struct PsdDevice *) methoddata[0]));
 413
 414         case UCM_ReleaseDeviceBinding:
 415             usbReleaseDeviceBinding(nh, (struct NepClassSerial *) methoddata[0]);
 416             return(TRUE);
 417
 418         default:
 419             break;
 420     }
 421     return(0);
 422     AROS_LIBFUNC_EXIT
 423 }
 424 /* \\\ */
 425
 426 /**************************************************************************/
 427
 428 #undef  ps
 429 #define ps ncp->ncp_Base
 430
 431 /* /// "nSetSerialMode()" */
 432 void nSetSerialMode(struct NepClassSerial *ncp, struct IOExtSer *ioreq)
 433 {
 434     struct UsbCDCLineCoding ulc;
 435     LONG ioerr;
 436     ULONG bufsize = ioreq->io_RBufLen / NUMREADPIPES;
 437
 438     if(bufsize < 1024)
 439     {
 440         bufsize = 1024;
 441     }
 442     bufsize = (bufsize + 127) & (~127);
 443
 444     psdSetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 445                 PSA_BufferSize, bufsize,
 446                 TAG_END);
 447     if(ioreq->io_SerFlags & SERF_EOFMODE)
 448     {
 449         psdSetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 450                     PSA_TermArray, &ioreq->io_TermArray,
 451                     TAG_END);
 452         psdSetAttrs(PGA_PIPESTREAM, ncp->ncp_EPOutStream,
 453                     PSA_TermArray, &ioreq->io_TermArray,
 454                     TAG_END);
 455     } else {
 456         psdSetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 457                     PSA_TermArray, NULL,
 458                     TAG_END);
 459         psdSetAttrs(PGA_PIPESTREAM, ncp->ncp_EPOutStream,
 460                     PSA_TermArray, NULL,
 461                     TAG_END);
 462     }
 463     ulc.dwDTERate = AROS_LONG2LE(ioreq->io_Baud);
 464     if(ioreq->io_StopBits == 1)
 465     {
 466         ulc.bCharFormat = 0;
 467     }
 468     else if(ioreq->io_StopBits == 2)
 469     {
 470         ulc.bCharFormat = 2;
 471     } else {
 472         ioreq->IOSer.io_Error = SerErr_InvParam;
 473         ulc.bCharFormat = 0;
 474     }
 475     ulc.bParityType = 0; /* no parity */
 476     if(ioreq->io_SerFlags & SERF_PARTY_ON)
 477     {
 478         if(ioreq->io_SerFlags & SERF_PARTY_ODD)
 479         {
 480             ulc.bParityType = 1; /* odd parity */
 481         } else {
 482             ulc.bParityType = 2; /* even parity */
 483         }
 484     }
 485     if(ioreq->io_ExtFlags & SEXTF_MSPON)
 486     {
 487         ioreq->io_SerFlags |= SERF_PARTY_ON;
 488         if(ioreq->io_ExtFlags & SEXTF_MARK)
 489         {
 490             ulc.bParityType = 3; /* mark parity */
 491         } else {
 492             ulc.bParityType = 4; /* space parity */
 493         }
 494     }
 495     ulc.bDataBits = ioreq->io_ReadLen;
 496     if(ioreq->io_SerFlags & SERF_RAD_BOOGIE)
 497     {
 498         ulc.bCharFormat = 0; /* 1 stop bit */
 499         ulc.bParityType = 0; /* no parity */
 500         ulc.bDataBits = 8; /* 8 data bits */
 501     }
 502
 503     if(ncp->ncp_SiemensCrap)
 504     {
 505         // the siemens thing supports none of these...
 506         return;
 507     }
 508
 509     psdPipeSetup(ncp->ncp_EP0Pipe, URTF_CLASS|URTF_INTERFACE,
 510                  UCDCR_SET_LINE_CODING, 0, 0);
 511     ioerr = psdDoPipe(ncp->ncp_EP0Pipe, &ulc, 7);
 512     if(ioerr)
 513     {
 514         psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 515                        "SET_LINE_CODING failed: %s (%ld)",
 516                        psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 517         ioreq->IOSer.io_Error = SerErr_LineErr;
 518     }
 519     /* Activate RTS/CTS */
 520     psdPipeSetup(ncp->ncp_EP0Pipe, URTF_CLASS|URTF_INTERFACE,
 521                  UCDCR_SET_CONTROL_LINE_STATE, (ULONG) ((ioreq->io_SerFlags & SERF_7WIRE) ? 0 : UPLF_CONTROL_RTS|UPLF_CONTROL_DTR), 0);
 522     ioerr = psdDoPipe(ncp->ncp_EP0Pipe, NULL, 0);
 523     if(ioerr)
 524     {
 525         psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 526                        "SET_CONTROL_LINE_STATE failed: %s (%ld)",
 527                        psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 528         ioreq->IOSer.io_Error = SerErr_LineErr;
 529     }
 530     if(ioreq->io_SerFlags & SERF_7WIRE) /* Activate RTS/CTS */
 531     {
 532         psdPipeSetup(ncp->ncp_EP0Pipe, URTF_VENDOR|URTF_DEVICE,
 533                      UPLR_WRITE, 0, (ULONG) (ncp->ncp_HXChipset ? 0x61 : 0x41));
 534         ioerr = psdDoPipe(ncp->ncp_EP0Pipe, NULL, 0);
 535         if(ioerr)
 536         {
 537             psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 538                            "SET_RTS/CTS failed: %s (%ld)",
 539                            psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 540             ioreq->IOSer.io_Error = SerErr_LineErr;
 541         }
 542     }
 543 }
 544 /* \\\ */
 545
 546 /* /// "nSerialTask()" */
 547 AROS_UFH0(void, nSerialTask)
 548 {
 549     AROS_USERFUNC_INIT
 550
 551     struct NepClassSerial *ncp;
 552     struct PsdPipe *pp;
 553     ULONG sigmask;
 554     ULONG sigs;
 555     LONG ioerr;
 556     LONG len;
 557     struct IOExtSer *ioreq;
 558     struct IOExtSer *ioreq2;
 559     UWORD serstate;
 560     IPTR pending;
 561     UBYTE buf[8];
 562     ULONG seqnr;
 563     UWORD *seqptr;
 564     UWORD initseq[] = { URTF_IN , 0x8484, 0,
 565                         URTF_OUT, 0x0404, 0,
 566                         URTF_IN , 0x8484, 0,
 567                         URTF_IN , 0x8383, 0,
 568                         URTF_IN , 0x8484, 0,
 569                         URTF_OUT, 0x0404, 1,
 570                         URTF_IN , 0x8484, 0,
 571                         URTF_IN , 0x8383, 0,
 572                         URTF_OUT, 0x0000, 1,
 573                         URTF_OUT, 0x0001, 0,
 574                         //URTF_OUT, 0x0001, 0xc0,
 575                         URTF_OUT, 0x0002, 0x24,
 576                         0xffff };
 577
 578     UWORD inithxs[] = { URTF_IN , 0x8484, 0,
 579                         URTF_OUT, 0x0404, 0,
 580                         URTF_IN , 0x8484, 0,
 581                         URTF_IN , 0x8383, 0,
 582                         URTF_IN , 0x8484, 0,
 583                         URTF_OUT, 0x0404, 1,
 584                         URTF_IN , 0x8484, 0,
 585                         URTF_IN , 0x8383, 0,
 586                         URTF_OUT, 0x0000, 1,
 587                         URTF_OUT, 0x0002, 0x44,
 588                         URTF_OUT, 0x0008, 0,
 589                         URTF_OUT, 0x0009, 0,
 590                         0xffff };
 591
 592     if((ncp = nAllocSerial()))
 593     {
 594         Forbid();
 595         if(ncp->ncp_ReadySigTask)
 596         {
 597             Signal(ncp->ncp_ReadySigTask, 1L<<ncp->ncp_ReadySignal);
 598         }
 599         Permit();
 600
 601         /* HX Chipset speciality: clear endpoint stalls */
 602         if(!ncp->ncp_HXChipset)
 603         {
 604             psdPipeSetup(ncp->ncp_EP0Pipe, URTF_STANDARD|URTF_ENDPOINT,
 605                          USR_CLEAR_FEATURE, UFS_ENDPOINT_HALT, (ULONG) ncp->ncp_EPInNum|URTF_IN);
 606             ioerr = psdDoPipe(ncp->ncp_EP0Pipe, NULL, 0);
 607             if(ioerr)
 608             {
 609                 psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 610                                "CLEAR_ENDPOINT_HALT %ld failed: %s (%ld)",
 611                                ncp->ncp_EPInNum, psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 612             }
 613             psdPipeSetup(ncp->ncp_EP0Pipe, URTF_STANDARD|URTF_ENDPOINT,
 614                          USR_CLEAR_FEATURE, UFS_ENDPOINT_HALT, (ULONG) ncp->ncp_EPOutNum);
 615             ioerr = psdDoPipe(ncp->ncp_EP0Pipe, NULL, 0);
 616             if(ioerr)
 617             {
 618                 psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 619                                "CLEAR_ENDPOINT_HALT %ld failed: %s (%ld)",
 620                                ncp->ncp_EPOutNum, psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 621             }
 622             seqptr = initseq;
 623         } else {
 624             psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 625                            "Using HX chipset init sequence...");
 626             seqptr = inithxs;
 627         }
 628
 629         pp = ncp->ncp_EP0Pipe;
 630         if(ncp->ncp_SiemensCrap)
 631         {
 632             /* The siemens thing is probably not even a PL2303 chipset, it needs
 633                very different initalisation! */
 634             psdAddErrorMsg(RETURN_OK, (STRPTR) libname,
 635                            "Using Siemens chipset init sequence...");
 636             psdPipeSetup(pp, URTF_OUT|URTF_VENDOR|URTF_INTERFACE, 0x02, 0, 0);
 637             ioerr = psdDoPipe(pp, NULL, 0);
 638             if(ioerr)
 639             {
 640                 psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 641                                "Error during Siemens sequence cmd %ld: %s (%ld)",
 642                                1,
 643                                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 644             }
 645             psdPipeSetup(pp, URTF_IN|URTF_VENDOR|URTF_INTERFACE, 0x01, 0, 0);
 646             ioerr = psdDoPipe(pp, buf, 1);
 647             if(ioerr)
 648             {
 649                 psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 650                                "Error during Siemens sequence cmd %ld: %s (%ld)",
 651                                2,
 652                                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 653             }
 654
 655             psdPipeSetup(pp, URTF_IN|URTF_VENDOR|URTF_INTERFACE, 0x04, 0x0800, 0);
 656             ioerr = psdDoPipe(pp, buf, 2);
 657             if(ioerr)
 658             {
 659                 psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 660                                "Error during Siemens sequence cmd %ld: %s (%ld)",
 661                                3,
 662                                psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 663             }
 664             psdSendPipe(ncp->ncp_EPIntPipe, ncp->ncp_SerialStateReq, 10);
 665         } else {
 666             /* Output init sequence */
 667             seqnr = 1;
 668             while(*seqptr != 0xffff)
 669             {
 670                 UWORD dir, idx, val;
 671                 dir = *seqptr++;
 672                 val = *seqptr++;
 673                 idx = *seqptr++;
 674                 if(dir == URTF_IN)
 675                 {
 676                     psdPipeSetup(pp, URTF_IN|URTF_VENDOR|URTF_DEVICE, UPLR_READ,
 677                                  (ULONG) val, (ULONG) idx);
 678                     ioerr = psdDoPipe(pp, buf, 1);
 679                 } else {
 680                     psdPipeSetup(pp, URTF_OUT|URTF_VENDOR|URTF_DEVICE, UPLR_WRITE,
 681                                  (ULONG) val, (ULONG) idx);
 682                     ioerr = psdDoPipe(pp, NULL, 0);
 683                 }
 684                 if(ioerr)
 685                 {
 686                     psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 687                                    "Error during init sequence cmd %ld: %s (%ld)",
 688                                    seqnr,
 689                                    psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 690                 }
 691                 seqnr++;
 692             }
 693             psdSendPipe(ncp->ncp_EPIntPipe, &ncp->ncp_SerialStateReq[UART_STATE], 1);
 694         }
 695
 696         sigmask = (1UL<<ncp->ncp_Unit.unit_MsgPort.mp_SigBit)|(1UL<<ncp->ncp_TaskMsgPort->mp_SigBit)|SIGBREAKF_CTRL_C;
 697         {
 698             struct MsgPort *tmpmp = NULL;
 699             psdGetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream, PSA_MessagePort, &tmpmp, TAG_END);
 700             if(tmpmp)
 701             {
 702                 sigmask |= (1UL<<tmpmp->mp_SigBit);
 703             }
 704         }
 705         do
 706         {
 707             psdStreamRead(ncp->ncp_EPInStream, NULL, 0);
 708             while((pp = (struct PsdPipe *) GetMsg(ncp->ncp_TaskMsgPort)))
 709             {
 710                 KPRINTF(1, ("Pipe back %08lx\n", pp));
 711                 if(pp == ncp->ncp_EPIntPipe)
 712                 {
 713                     KPRINTF(5, ("Int serial state back %04lx\n", ncp->ncp_SerialStateReq[UART_STATE]));
 714                     ioerr = psdGetPipeError(pp);
 715                     len = psdGetPipeActual(pp);
 716                     if(ioerr && (ioerr != UHIOERR_RUNTPACKET))
 717                     {
 718                         psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 719                                        "Serial state failed: %s (%ld), len=%d",
 720                                        psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr, (int)len);
 721                         psdDelayMS(100);
 722                     }
 723                     if(ncp->ncp_SiemensCrap)
 724                     {
 725                         psdSendPipe(ncp->ncp_EPIntPipe, &ncp->ncp_SerialStateReq[UART_STATE], 1);
 726                     } else {
 727                         psdSendPipe(ncp->ncp_EPIntPipe, ncp->ncp_SerialStateReq, 10);
 728                     }
 729                     break;
 730                 }
 731             }
 732             while((ioreq = (struct IOExtSer *) GetMsg(&ncp->ncp_Unit.unit_MsgPort)))
 733             {
 734                 KPRINTF(5, ("command ioreq: 0x%08lx cmd: %lu len: %ld\n",
 735                         ioreq, ioreq->IOSer.io_Command, ioreq->IOSer.io_Length));
 736                 switch(ioreq->IOSer.io_Command)
 737                 {
 738                     case CMD_CLEAR:
 739                         psdStreamFlush(ncp->ncp_EPOutStream);
 740                         ReplyMsg((struct Message *) ioreq);
 741                         break;
 742
 743                     case CMD_RESET:
 744                         /* Reset does a flush too */
 745                     case CMD_FLUSH:
 746                         Forbid();
 747                         ioreq2 = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 748                         while(ioreq2->IOSer.io_Message.mn_Node.ln_Succ)
 749                         {
 750                             Remove((struct Node *) ioreq2);
 751                             ioreq2->IOSer.io_Error = IOERR_ABORTED;
 752                             ReplyMsg((struct Message *) ioreq2);
 753                             ioreq2 = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 754                         }
 755                         ioreq2 = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 756                         while(ioreq2->IOSer.io_Message.mn_Node.ln_Succ)
 757                         {
 758                             Remove((struct Node *) ioreq2);
 759                             ioreq2->IOSer.io_Error = IOERR_ABORTED;
 760                             ReplyMsg((struct Message *) ioreq2);
 761                             ioreq2 = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 762                         }
 763                         ReplyMsg((struct Message *) ioreq);
 764                         Permit();
 765                         break;
 766
 767                     case SDCMD_QUERY:
 768                         serstate = 0;
 769                         if(!(ncp->ncp_SerialStateReq[UART_STATE] & UART_DCD)) /* Carrier Detect */
 770                             serstate |= (1<<5);
 771                         if(!(ncp->ncp_SerialStateReq[UART_STATE] & UART_DSR)) /* DSR */
 772                             serstate |= (1<<3);
 773                         if(!(ncp->ncp_SerialStateReq[UART_STATE] & UART_CTS)) /* ClearToSend */
 774                             serstate |= (1<<4);
 775                         if(ncp->ncp_SerialStateReq[UART_STATE] & UART_BREAK) /* Break */
 776                             serstate |= (1<<10);
 777                         if(ncp->ncp_SerialStateReq[UART_STATE] & UART_RING) /* Ring */
 778                             serstate |= (1<<2);
 779                         if(ncp->ncp_SerialStateReq[UART_STATE] & (UART_FRAME_ERROR|UART_PARITY_ERROR|UART_OVERRUN_ERROR)) /* Framing, Parity, Hardware error */
 780                             serstate |= (1<<8);
 781
 782                         ioreq->io_Status = serstate;
 783                         pending = 0;
 784                         psdGetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 785                                     PSA_BytesPending, &pending,
 786                                     TAG_END);
 787                         ioreq->IOSer.io_Actual = pending;
 788                         ReplyMsg((struct Message *) ioreq);
 789                         break;
 790
 791                     case SDCMD_SETPARAMS:
 792                         nSetSerialMode(ncp, ioreq);
 793                         ReplyMsg((struct Message *) ioreq);
 794                         break;
 795
 796                     case SDCMD_BREAK:
 797                         psdPipeSetup(ncp->ncp_EP0Pipe, URTF_CLASS|URTF_INTERFACE,
 798                                      UCDCR_SEND_BREAK, ioreq->io_BrkTime, (ULONG) ncp->ncp_UnitIfNum);
 799                         ioerr = psdDoPipe(ncp->ncp_EP0Pipe, NULL, 0);
 800                         if(ioerr)
 801                         {
 802                             psdAddErrorMsg(RETURN_WARN, (STRPTR) libname,
 803                                            "SEND_BREAK failed: %s (%ld)",
 804                                            psdNumToStr(NTS_IOERR, ioerr, "unknown"), ioerr);
 805                             ioreq->IOSer.io_Error = SerErr_LineErr;
 806                         }
 807                         ReplyMsg((struct Message *) ioreq);
 808                         break;
 809
 810                     default:
 811                         ioreq->IOSer.io_Error = IOERR_NOCMD;
 812                         ReplyMsg((struct Message *) ioreq);
 813                         break;
 814                 }
 815             }
 816             if(!ncp->ncp_DevSuspend)
 817             {
 818                 pending = 0;
 819                 psdGetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 820                             PSA_BytesPending, &pending,
 821                             TAG_END);
 822                 Forbid();
 823                 ioreq = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 824                 while(ioreq->IOSer.io_Message.mn_Node.ln_Succ && pending)
 825                 {
 826                     Remove((struct Node *) ioreq);
 827                     Permit();
 828                     ioreq->IOSer.io_Actual = psdStreamRead(ncp->ncp_EPInStream, ioreq->IOSer.io_Data, ioreq->IOSer.io_Length);
 829                     ioerr = psdGetStreamError(ncp->ncp_EPInStream);
 830                     if(ioerr == UHIOERR_NAKTIMEOUT)
 831                     {
 832                         Forbid();
 833                         AddHead(&ncp->ncp_ReadQueue, &ioreq->IOSer.io_Message.mn_Node);
 834                         break;
 835                     } else {
 836                         if(ioerr > 0)
 837                         {
 838                             ioreq->IOSer.io_Error = SerErr_LineErr;
 839                         } else {
 840                             ioreq->IOSer.io_Error = ioerr;
 841                         }
 842                         ReplyMsg((struct Message *) ioreq);
 843                     }
 844                     psdGetAttrs(PGA_PIPESTREAM, ncp->ncp_EPInStream,
 845                                 PSA_BytesPending, &pending,
 846                                 TAG_END);
 847                     Forbid();
 848                     ioreq = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 849                 }
 850                 ioreq = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 851                 while(ioreq->IOSer.io_Message.mn_Node.ln_Succ)
 852                 {
 853                     Remove((struct Node *) ioreq);
 854                     ncp->ncp_WritePending = ioreq;
 855                     Permit();
 856                     ioreq->IOSer.io_Actual = psdStreamWrite(ncp->ncp_EPOutStream, ioreq->IOSer.io_Data, ioreq->IOSer.io_Length);
 857                     ncp->ncp_WritePending = NULL;
 858                     ioerr = psdGetStreamError(ncp->ncp_EPInStream);
 859                     if(ioerr > 0)
 860                     {
 861                         ioreq->IOSer.io_Error = SerErr_LineErr;
 862                     } else {
 863                         ioreq->IOSer.io_Error = ioerr;
 864                     }
 865                     ReplyMsg((struct Message *) ioreq);
 866                     Forbid();
 867                     ioreq = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 868                 }
 869                 Permit();
 870             }
 871             sigs = Wait(sigmask);
 872         } while(!(sigs & SIGBREAKF_CTRL_C));
 873         KPRINTF(1, ("Going down...\n"));
 874         /* Now remove all requests still pending *anywhere* */
 875         ncp->ncp_DenyRequests = TRUE;
 876
 877         psdAbortPipe(ncp->ncp_EPIntPipe);
 878         psdWaitPipe(ncp->ncp_EPIntPipe);
 879
 880         /* Read/Write queues */
 881         Forbid();
 882         ioreq = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 883         while(ioreq->IOSer.io_Message.mn_Node.ln_Succ)
 884         {
 885             Remove((struct Node *) ioreq);
 886             ioreq->IOSer.io_Error = IOERR_ABORTED;
 887             ReplyMsg((struct Message *) ioreq);
 888             ioreq = (struct IOExtSer *) ncp->ncp_WriteQueue.lh_Head;
 889         }
 890         ioreq = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 891         while(ioreq->IOSer.io_Message.mn_Node.ln_Succ)
 892         {
 893             Remove((struct Node *) ioreq);
 894             ioreq->IOSer.io_Error = IOERR_ABORTED;
 895             ReplyMsg((struct Message *) ioreq);
 896             ioreq = (struct IOExtSer *) ncp->ncp_ReadQueue.lh_Head;
 897         }
 898         /* Command queue */
 899         while((ioreq = (struct IOExtSer *) GetMsg(&ncp->ncp_Unit.unit_MsgPort)))
 900         {
 901             ioreq->IOSer.io_Error = IOERR_ABORTED;
 902             ReplyMsg((struct Message *) ioreq);
 903         }
 904         Permit();
 905         KPRINTF(20, ("Going down the river!\n"));
 906         nFreeSerial(ncp);
 907     }
 908
 909     AROS_USERFUNC_EXIT
 910 }
 911 /* \\\ */
 912
 913 /* /// "nAllocSerial()" */
 914 struct NepClassSerial * nAllocSerial(void)
 915 {
 916     struct Task *thistask;
 917     struct NepClassSerial *ncp;
 918     IPTR maxpkt0 = 0;
 919     IPTR epnum;
 920
 921     thistask = FindTask(NULL);
 922     ncp = thistask->tc_UserData;
 923     do
 924     {
 925         if(!(ncp->ncp_Base = OpenLibrary("poseidon.library", 4)))
 926         {
 927             Alert(AG_OpenLib);
 928             break;
 929         }
 930
 931         ncp->ncp_Interface = psdFindInterface(ncp->ncp_Device, NULL, TAG_END);
 932
 933         if(!ncp->ncp_Interface)
 934         {
 935             KPRINTF(1, ("Ooops!?! No interfaces defined?\n"));
 936             break;
 937         }
 938
 939         ncp->ncp_EPInt = psdFindEndpoint(ncp->ncp_Interface, NULL,
 940                                          EA_IsIn, TRUE,
 941                                          EA_TransferType, USEAF_INTERRUPT,
 942                                          TAG_END);
 943         if(!ncp->ncp_EPInt)
 944         {
 945             psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname, "No notify endpoint?!?");
 946             KPRINTF(1, ("Ooops!?! No notify endpoint defined?\n"));
 947             break;
 948         }
 949
 950         ncp->ncp_EPIn = psdFindEndpoint(ncp->ncp_Interface, NULL,
 951                                         EA_IsIn, TRUE,
 952                                         EA_TransferType, USEAF_BULK,
 953                                         TAG_END);
 954         ncp->ncp_EPOut = psdFindEndpoint(ncp->ncp_Interface, NULL,
 955                                          EA_IsIn, FALSE,
 956                                          EA_TransferType, USEAF_BULK,
 957                                          TAG_END);
 958
 959         if(!(ncp->ncp_EPIn && ncp->ncp_EPOut))
 960         {
 961             psdAddErrorMsg(RETURN_FAIL, (STRPTR) libname, "IN or OUT endpoint missing!");
 962             break;
 963         }
 964
 965         psdGetAttrs(PGA_ENDPOINT, ncp->ncp_EPIn,
 966                     EA_EndpointNum, &epnum,
 967                     TAG_END);
 968         ncp->ncp_EPInNum = epnum;
 969         psdGetAttrs(PGA_ENDPOINT, ncp->ncp_EPOut,
 970                     EA_EndpointNum, &epnum,
 971                     TAG_END);
 972         ncp->ncp_EPOutNum = epnum;
 973
 974         ncp->ncp_Unit.unit_MsgPort.mp_SigBit = AllocSignal(-1);
 975         ncp->ncp_Unit.unit_MsgPort.mp_SigTask = thistask;
 976         ncp->ncp_Unit.unit_MsgPort.mp_Node.ln_Type = NT_MSGPORT;
 977         ncp->ncp_Unit.unit_MsgPort.mp_Flags = PA_SIGNAL;
 978         ncp->ncp_WritePending = NULL;
 979
 980         if((ncp->ncp_TaskMsgPort = CreateMsgPort()))
 981         {
 982             if((ncp->ncp_EP0Pipe = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, NULL)))
 983             {
 984
 985                 /* Check for HX Chipset */
 986                 psdGetAttrs(PGA_PIPE, ncp->ncp_EP0Pipe, PPA_MaxPktSize, &maxpkt0, TAG_END);
 987                 if(maxpkt0 == 64)
 988                 {
 989                     ncp->ncp_HXChipset = TRUE;
 990                 }
 991                 if(ncp->ncp_UnitVendorID == SIEMENS_VENDOR_ID)
 992                 {
 993                     ncp->ncp_SiemensCrap = TRUE;
 994                 }
 995
 996                 ncp->ncp_AbortSignal = AllocSignal(-1);
 997                 if((ncp->ncp_EPOutStream = psdOpenStream(ncp->ncp_EPOut,
 998                                                         PSA_BufferedWrite, FALSE,
 999                                                         PSA_NoZeroPktTerm, FALSE,
1000                                                         PSA_NakTimeout, TRUE,
1001                                                         PSA_NakTimeoutTime, 5000,
1002                                                         PSA_AbortSigMask, (1UL<<ncp->ncp_AbortSignal)|SIGBREAKF_CTRL_C,
1003                                                         TAG_END)))
1004                 {
1005                     if((ncp->ncp_EPInStream = psdOpenStream(ncp->ncp_EPIn,
1006                                                            PSA_ReadAhead, TRUE,
1007                                                            PSA_BufferedRead, TRUE,
1008                                                            PSA_NumPipes, NUMREADPIPES,
1009                                                            PSA_BufferSize, DEFREADBUFLEN,
1010                                                            PSA_AllowRuntPackets, TRUE,
1011                                                            PSA_DoNotWait, TRUE,
1012                                                            PSA_AbortSigMask, SIGBREAKF_CTRL_C,
1013                                                            TAG_END)))
1014                     {
1015                         if((ncp->ncp_EPIntPipe = psdAllocPipe(ncp->ncp_Device, ncp->ncp_TaskMsgPort, ncp->ncp_EPInt)))
1016                         {
1017                             ncp->ncp_Task = thistask;
1018                             return(ncp);
1019                         }
1020                         psdCloseStream(ncp->ncp_EPInStream);
1021                     }
1022                     psdCloseStream(ncp->ncp_EPOutStream);
1023                 }
1024                 FreeSignal(ncp->ncp_AbortSignal);
1025                 psdFreePipe(ncp->ncp_EP0Pipe);
1026             }
1027             DeleteMsgPort(ncp->ncp_TaskMsgPort);
1028         }
1029         FreeSignal((LONG) ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
1030     } while(FALSE);
1031     CloseLibrary(ncp->ncp_Base);
1032     Forbid();
1033     ncp->ncp_Task = NULL;
1034     if(ncp->ncp_ReadySigTask)
1035     {
1036         Signal(ncp->ncp_ReadySigTask, 1L<<ncp->ncp_ReadySignal);
1037     }
1038     return(NULL);
1039 }
1040 /* \\\ */
1041
1042 /* /// "nFreeSerial()" */
1043 void nFreeSerial(struct NepClassSerial *ncp)
1044 {
1045     struct IOStdReq *ioreq;
1046     Forbid();
1047     FreeSignal(ncp->ncp_AbortSignal);
1048     ncp->ncp_AbortSignal = -1;
1049     /* Disable the message port, messages may still be queued */
1050     ncp->ncp_Unit.unit_MsgPort.mp_SigTask = NULL;
1051     ncp->ncp_Unit.unit_MsgPort.mp_Flags = PA_IGNORE;
1052     FreeSignal((LONG) ncp->ncp_Unit.unit_MsgPort.mp_SigBit);
1053     // get rid of all messages that still have appeared here
1054     while((ioreq = (struct IOStdReq *) GetMsg(&ncp->ncp_Unit.unit_MsgPort)))
1055     {
1056         ioreq->io_Error = IOERR_ABORTED;
1057         ReplyMsg((struct Message *) ioreq);
1058     }
1059     Permit();
1060
1061     psdCloseStream(ncp->ncp_EPInStream);
1062     psdCloseStream(ncp->ncp_EPOutStream);
1063     psdFreePipe(ncp->ncp_EPIntPipe);
1064     psdFreePipe(ncp->ncp_EP0Pipe);
1065
1066     DeleteMsgPort(ncp->ncp_TaskMsgPort);
1067     CloseLibrary(ncp->ncp_Base);
1068     Forbid();
1069     ncp->ncp_Task = NULL;
1070     if(ncp->ncp_ReadySigTask)
1071     {
1072         Signal(ncp->ncp_ReadySigTask, 1UL<<ncp->ncp_ReadySignal);
1073     }
1074 }
1075 /* \\\ */