workbench/devs/parallel/parallel_init.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Parallel device
   6     Lang: English
   7 */
   8
   9 /****************************************************************************************/
  10
  11
  12 #include <string.h>
  13
  14 #include <exec/resident.h>
  15 #include <exec/interrupts.h>
  16 #include <exec/semaphores.h>
  17 #include <exec/initializers.h>
  18 #include <devices/parallel.h>
  19 #include <devices/newstyle.h>
  20 #include <proto/exec.h>
  21 #include <proto/dos.h>
  22 #include <proto/input.h>
  23 #include <proto/oop.h>
  24 #include <proto/utility.h>
  25 #include <exec/memory.h>
  26 #include <exec/errors.h>
  27 #include <oop/oop.h>
  28 #include <hidd/parallel.h>
  29 #include <utility/tagitem.h>
  30 #include <aros/libcall.h>
  31 #include <aros/symbolsets.h>
  32 #include <exec/lists.h>
  33 #if defined(__GNUC__) || defined(__INTEL_COMPILER)
  34 #    include "parallel_intern.h"
  35 #endif
  36
  37 #include <aros/debug.h>
  38
  39 #include LC_LIBDEFS_FILE
  40
  41 /****************************************************************************************/
  42
  43 #define NEWSTYLE_DEVICE 1
  44
  45 struct parallelbase * pubParallelBase;
  46
  47 /****************************************************************************************/
  48
  49 #if NEWSTYLE_DEVICE
  50
  51 static const UWORD SupportedCommands[] =
  52 {
  53     CMD_READ,
  54     CMD_WRITE,
  55     CMD_CLEAR,
  56     CMD_RESET,
  57     CMD_FLUSH,
  58     PDCMD_QUERY,
  59     PDCMD_SETPARAMS,
  60     NSCMD_DEVICEQUERY,
  61     0
  62 };
  63
  64 #endif
  65
  66 /****************************************************************************************/
  67
  68 static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR ParallelDevice)
  69 {
  70   D(bug("parallel device: init\n"));
  71
  72   pubParallelBase = ParallelDevice;
  73
  74   /* open the parallel hidd */
  75   if (NULL == ParallelDevice->ParallelHidd)
  76   {
  77     ParallelDevice->ParallelHidd = OpenLibrary("DRIVERS:parallel.hidd",0);
  78     D(bug("parallel.hidd base: 0x%x\n",ParallelDevice->ParallelHidd));
  79
  80     if (NULL == ParallelDevice->ParallelHidd)
  81         return FALSE;
  82
  83     if (NULL == ParallelDevice->oopBase)
  84       ParallelDevice->oopBase = OpenLibrary(AROSOOP_NAME, 0);
  85     if (NULL == ParallelDevice->oopBase)
  86     {
  87         CloseLibrary(ParallelDevice->ParallelHidd);
  88         ParallelDevice->ParallelHidd = NULL;
  89         return FALSE;
  90     }
  91
  92     ParallelDevice->ParallelObject = OOP_NewObject(NULL, CLID_Hidd_Parallel, NULL);
  93
  94     if (NULL == ParallelDevice->ParallelObject)
  95     {
  96         CloseLibrary(ParallelDevice->oopBase);
  97         ParallelDevice->oopBase = NULL;
  98         CloseLibrary(ParallelDevice->ParallelHidd);
  99         ParallelDevice->ParallelHidd = NULL;
 100         return FALSE;
 101     }
 102   }
 103
 104   NEWLIST(&ParallelDevice->UnitList);
 105   return TRUE;
 106 }
 107
 108
 109 /****************************************************************************************/
 110
 111 static int GM_UNIQUENAME(Open)
 112 (
 113     LIBBASETYPEPTR ParallelDevice,
 114     struct IORequest *ioreq,
 115     ULONG unitnum,
 116     ULONG flags
 117 )
 118 {
 119   struct ParallelUnit * PU = NULL;
 120
 121   D(bug("parallel device: Open unit %d\n",unitnum));
 122
 123   if (ioreq->io_Message.mn_Length < sizeof(struct IOExtPar))
 124   {
 125       D(bug("parallel.device/open: IORequest structure passed to OpenDevice is too small!\n"));
 126       ioreq->io_Error = IOERR_OPENFAIL;
 127       return FALSE;
 128   }
 129
 130   ioreq->io_Message.mn_Node.ln_Type = NT_REPLYMSG;
 131
 132   /* In the list of available units look for the one with the same
 133      UnitNumber as the given one  */
 134   if (0 == ioreq->io_Error)
 135   {
 136     PU = findUnit(ParallelDevice, unitnum);
 137
 138     /* If there is no such unit, yet, then create it */
 139     if (NULL == PU)
 140     {
 141       D(bug("Creating Unit %d\n",unitnum));
 142       PU = AllocMem(sizeof(struct ParallelUnit), MEMF_CLEAR|MEMF_PUBLIC);
 143       if (NULL != PU)
 144       {
 145         PU->pu_OpenerCount      = 1;
 146         PU->pu_UnitNum          = unitnum;
 147         PU->pu_Flags            = ioreq->io_Flags;
 148
 149         /*
 150         ** Initialize the message ports
 151         */
 152         NEWLIST(&PU->pu_QReadCommandPort.mp_MsgList);
 153         PU->pu_QReadCommandPort.mp_Node.ln_Type = NT_MSGPORT;
 154
 155         NEWLIST(&PU->pu_QWriteCommandPort.mp_MsgList);
 156         PU->pu_QWriteCommandPort.mp_Node.ln_Type= NT_MSGPORT;
 157
 158         InitSemaphore(&PU->pu_Lock);
 159         /* do further initilization here. Like getting the ParallelUnit Object etc. */
 160
 161         PU->pu_Unit  = HIDD_Parallel_NewUnit(ParallelDevice->ParallelObject, unitnum);
 162         if (NULL != PU->pu_Unit)
 163         {
 164           HIDD_ParallelUnit_Init(PU->pu_Unit, RBF_InterruptHandler, NULL, WBE_InterruptHandler, NULL);
 165           ioreq->io_Device = (struct Device *)ParallelDevice;
 166           ioreq->io_Unit   = (struct Unit *)PU;
 167
 168           /*
 169           ** put it in the list of open units
 170           */
 171           AddHead(&ParallelDevice->UnitList, (struct Node *)PU);
 172
 173           ioreq->io_Error  = 0;
 174
 175           D(bug("%s: Unit %d opened\n", __func__, unitnum));
 176           return TRUE;
 177         }
 178
 179         D(bug("ParallelUnit could not be created!\n"));
 180
 181         FreeMem(PU, sizeof(struct ParallelUnit));
 182
 183         ioreq->io_Error = ParErr_DevBusy;
 184       }
 185     }
 186     else
 187     {
 188       /* the unit does already exist. */
 189       /*
 190       ** Check whether one more opener to this unit is tolerated
 191       */
 192       if (0 != (PU->pu_Flags & PARF_SHARED))
 193       {
 194         /*
 195         ** This unit is in shared mode and one more opener
 196         ** won't hurt.
 197         */
 198         ioreq->io_Device = (struct Device *)ParallelDevice;
 199         ioreq->io_Unit   = (struct Unit *)PU;
 200         ioreq->io_Error  = 0;
 201
 202         PU->pu_OpenerCount++;
 203       }
 204       else
 205       {
 206         /*
 207         ** I don't allow another opener
 208         */
 209         ioreq->io_Error = ParErr_DevBusy;
 210         D(bug("%s: Unit %d already busy\n", __func__, unitnum));
 211       }
 212     }
 213   }
 214
 215   return TRUE;
 216 }
 217
 218
 219 /****************************************************************************************/
 220
 221 static int GM_UNIQUENAME(Close)
 222 (
 223     LIBBASETYPEPTR ParallelDevice,
 224     struct IORequest *ioreq
 225 )
 226 {
 227   struct ParallelUnit * PU = (struct ParallelUnit *)ioreq->io_Unit;
 228
 229   /*
 230   ** Check whether I am the last opener to this unit
 231   */
 232   if (1 == PU->pu_OpenerCount)
 233   {
 234     /*
 235     ** I was the last opener. So let's get rid of it.
 236     */
 237     /*
 238     ** Remove the unit from the list
 239     */
 240     Remove((struct Node *)&PU->pu_Node);
 241
 242     HIDD_Parallel_DisposeUnit(ParallelDevice->ParallelObject, PU->pu_Unit);
 243
 244     FreeMem(PU, sizeof(struct ParallelUnit));
 245
 246   }
 247   else
 248   {
 249     /*
 250     ** There are still openers. Decrease the counter.
 251     */
 252     PU->pu_OpenerCount--;
 253   }
 254
 255   return TRUE;
 256 }
 257
 258 /****************************************************************************************/
 259
 260 static int GM_UNIQUENAME(Expunge)(LIBBASETYPEPTR ParallelDevice)
 261 {
 262     if (NULL != ParallelDevice->ParallelObject)
 263     {
 264       /*
 265       ** Throw away the HIDD object and close the library
 266       */
 267       OOP_DisposeObject(ParallelDevice->ParallelObject);
 268       CloseLibrary(ParallelDevice->ParallelHidd);
 269       ParallelDevice->ParallelHidd   = NULL;
 270       ParallelDevice->ParallelObject = NULL;
 271     }
 272     if (ParallelDevice->oopBase) CloseLibrary(ParallelDevice->oopBase);
 273
 274     return TRUE;
 275 }
 276
 277 /****************************************************************************************/
 278
 279 ADD2INITLIB(GM_UNIQUENAME(Init), 0)
 280 ADD2EXPUNGELIB(GM_UNIQUENAME(Expunge), 0)
 281 ADD2OPENDEV(GM_UNIQUENAME(Open), 0)
 282 ADD2CLOSEDEV(GM_UNIQUENAME(Close), 0)
 283
 284 /****************************************************************************************/
 285
 286 #define ioStd(x)  ((struct IOStdReq *)x)
 287 AROS_LH1(void, beginio,
 288  AROS_LHA(struct IOExtPar *, ioreq, A1),
 289            struct parallelbase *, ParallelDevice, 5, Parallel)
 290 {
 291   AROS_LIBFUNC_INIT
 292
 293   struct ParallelUnit * PU = (struct ParallelUnit *)ioreq->IOPar.io_Unit;
 294
 295   D(bug("parallel device: beginio(ioreq=%p)\n", ioreq));
 296
 297   /* WaitIO will look into this */
 298   ioreq->IOPar.io_Message.mn_Node.ln_Type=NT_MESSAGE;
 299
 300   /*
 301   ** As a lot of "public" data can be modified in the following lines
 302   ** I protect it from other tasks by this semaphore
 303   */
 304   ObtainSemaphore(&PU->pu_Lock);
 305
 306   switch (ioreq->IOPar.io_Command)
 307   {
 308 #if NEWSTYLE_DEVICE
 309   case NSCMD_DEVICEQUERY:
 310     if(ioreq->IOPar.io_Length < ((IPTR)OFFSET(NSDeviceQueryResult, SupportedCommands)) + sizeof(UWORD *))
 311     {
 312       ioreq->IOPar.io_Error = IOERR_BADLENGTH;
 313     }
 314     else
 315     {
 316       struct NSDeviceQueryResult *d;
 317
 318       d = (struct NSDeviceQueryResult *)ioreq->IOPar.io_Data;
 319
 320       d->DevQueryFormat         = 0;
 321       d->SizeAvailable          = sizeof(struct NSDeviceQueryResult);
 322       d->DeviceType             = NSDEVTYPE_PARALLEL;
 323       d->DeviceSubType          = 0;
 324       d->SupportedCommands      = (UWORD *)SupportedCommands;
 325
 326       ioreq->IOPar.io_Actual = sizeof(struct NSDeviceQueryResult);
 327       ioreq->IOPar.io_Error  = 0;
 328
 329       /*
 330       ** The request could be completed immediately.
 331       ** Check if I have to reply the message
 332       */
 333       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 334         ReplyMsg(&ioreq->IOPar.io_Message);
 335     }
 336     break;
 337 #endif
 338
 339     /*******************************************************************/
 340     case CMD_READ:
 341       /*
 342       **  Let me see whether I can copy any data at all and
 343       **  whether nobody else is using this device now
 344        */
 345       ioreq->IOPar.io_Actual = 0;
 346
 347       Disable();
 348
 349       PU->pu_Status |= STATUS_READS_PENDING;
 350       D(bug("Queuing the read request.\n"));
 351       /*
 352       **  Everything that falls down here could not be completely
 353       **  satisfied
 354       */
 355       if (NULL == PU->pu_ActiveRead)
 356         PU->pu_ActiveRead = &ioreq->IOPar.io_Message;
 357       else
 358         PutMsg(&PU->pu_QReadCommandPort,
 359                &ioreq->IOPar.io_Message);
 360
 361       Enable();
 362       /*
 363       ** As I am returning immediately I will tell that this
 364       ** could not be done QUICK
 365       */
 366       ioreq->IOPar.io_Flags &= ~IOF_QUICK;
 367     break;
 368
 369     /*******************************************************************/
 370
 371     case CMD_WRITE:
 372       /* Write data to the ParallelUnit */
 373       ioreq->IOPar.io_Actual = 0;
 374
 375       Disable();
 376
 377       /* Check whether I can write some data immediately */
 378       if (0 == (PU->pu_Status & STATUS_WRITES_PENDING))
 379       {
 380         ULONG writtenbytes;
 381         BOOL complete = FALSE;
 382         /*
 383            Writing the first few bytes to the UART has to have the
 384            effect that whenever the UART can receive new data
 385            a HW interrupt must happen. So this writing to the
 386            UART should get the sequence of HW-interrupts going
 387            until there is no more data to write
 388         */
 389         if (-1 == ioreq->IOPar.io_Length)
 390         {
 391           int stringlen = strlen(ioreq->IOPar.io_Data);
 392           D(bug("Transmitting NULL termninated string.\n"));
 393           /*
 394           ** Supposed to write the buffer to the port until a '\0'
 395           ** is encountered.
 396           */
 397
 398           writtenbytes = HIDD_ParallelUnit_Write(PU->pu_Unit,
 399                                                  ioreq->IOPar.io_Data,
 400                                                  stringlen);
 401           if (writtenbytes == stringlen)
 402             complete = TRUE;
 403           else
 404             PU->pu_WriteLength = stringlen-writtenbytes;
 405         }
 406         else
 407         {
 408           writtenbytes = HIDD_ParallelUnit_Write(PU->pu_Unit,
 409                                                  ioreq->IOPar.io_Data,
 410                                                  ioreq->IOPar.io_Length);
 411           if (writtenbytes == ioreq->IOPar.io_Length)
 412             complete = TRUE;
 413           else
 414             PU->pu_WriteLength = ioreq->IOPar.io_Length-writtenbytes;
 415         }
 416         /*
 417         ** A consistency check between the STATUS_WRITES_PENDING flag
 418         ** and the pointer PU->pu_ActiveWrite which both have to be
 419         ** set or cleared at the same time.
 420         */
 421         if (NULL != PU->pu_ActiveWrite)
 422         {
 423           D(bug("error!!"));
 424         }
 425
 426         if (complete == TRUE)
 427         {
 428           D(bug("completely sended the stream!\n"));
 429           /*
 430           ** The request could be completed immediately.
 431           ** Check if I have to reply the message
 432           */
 433           if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 434             ReplyMsg(&ioreq->IOPar.io_Message);
 435         }
 436         else
 437         {
 438           /*
 439           ** The request could not be completed immediately
 440           ** Clear the flag.
 441           */
 442           ioreq->IOPar.io_Flags &= ~IOF_QUICK;
 443           PU->pu_ActiveWrite = (struct Message *)ioreq;
 444           PU->pu_Status |= STATUS_WRITES_PENDING;
 445           PU->pu_NextToWrite = writtenbytes;
 446         }
 447       }
 448       else
 449       {
 450         /*
 451            I could not write the data immediately as another request
 452            is already there. So I will make this
 453            the responsibility of the interrupt handler to use this
 454            request once it is done with the active request.
 455         */
 456         PutMsg(&PU->pu_QWriteCommandPort,
 457                (struct Message *)ioreq);
 458         PU->pu_Status |= STATUS_WRITES_PENDING;
 459         /*
 460         ** As I am returning immediately I will tell that this
 461         ** could not be done QUICK
 462         */
 463         ioreq->IOPar.io_Flags &= ~IOF_QUICK;
 464       }
 465
 466       Enable();
 467     break;
 468
 469     case CMD_CLEAR:
 470       /* Simply reset the input buffer pointer no matter what */
 471       ioreq->IOPar.io_Error = 0;
 472       /*
 473       ** The request could be completed immediately.
 474       ** Check if I have to reply the message
 475       */
 476       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 477         ReplyMsg(&ioreq->IOPar.io_Message);
 478     break;
 479
 480     /*******************************************************************/
 481
 482     case CMD_RESET:
 483       Disable();
 484       /* All IORequests, including the active ones, are aborted */
 485
 486       /* Abort the active IORequests */
 487       PU->pu_Status &= ~(STATUS_READS_PENDING|STATUS_WRITES_PENDING);
 488
 489       if (NULL != PU->pu_ActiveRead)
 490       {
 491         ((struct IOStdReq *)PU->pu_ActiveRead)->io_Error = IOERR_ABORTED;
 492         ReplyMsg(PU->pu_ActiveRead);
 493       }
 494
 495       if (NULL != PU->pu_ActiveWrite)
 496       {
 497         ((struct IOStdReq *)PU->pu_ActiveWrite)->io_Error = IOERR_ABORTED;
 498         ReplyMsg(PU->pu_ActiveWrite);
 499       }
 500       Enable();
 501
 502     /*******************************************************************/
 503
 504     case CMD_FLUSH:
 505       /*
 506       ** Clear all queued IO request for the given parallel unit except
 507       ** for the active ones.
 508        */
 509       Disable();
 510
 511       while (TRUE)
 512       {
 513         struct IOStdReq * iopreq =
 514                   (struct IOStdReq *)GetMsg(&PU->pu_QReadCommandPort);
 515         if (NULL == iopreq)
 516           break;
 517         iopreq->io_Error = IOERR_ABORTED;
 518         ReplyMsg((struct Message *)iopreq);
 519       }
 520
 521       while (TRUE)
 522       {
 523         struct IOStdReq * iopreq =
 524                   (struct IOStdReq *)GetMsg(&PU->pu_QWriteCommandPort);
 525         if (NULL == iopreq)
 526           break;
 527         iopreq->io_Error = IOERR_ABORTED;
 528         ReplyMsg((struct Message *)iopreq);
 529       }
 530       ioreq->IOPar.io_Error = 0;
 531
 532       Enable();
 533       /*
 534       ** The request could be completed immediately.
 535       ** Check if I have to reply the message
 536       */
 537       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 538         ReplyMsg(&ioreq->IOPar.io_Message);
 539     break;
 540
 541     /*******************************************************************/
 542
 543     case CMD_START:
 544     break;
 545
 546     /*******************************************************************/
 547
 548     case CMD_STOP:
 549     break;
 550
 551     /*******************************************************************/
 552
 553     case PDCMD_QUERY:
 554
 555       PU->pu_Status = 0;
 556
 557       /*
 558       ** set the io_Status to the status of the parallel port
 559       */
 560       // !!! missing code
 561       ioreq->io_Status = 0;
 562
 563       /*
 564       ** The request could be completed immediately.
 565       ** Check if I have to reply the message
 566       */
 567       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 568         ReplyMsg(&ioreq->IOPar.io_Message);
 569
 570     break;
 571
 572     /*******************************************************************/
 573
 574     case PDCMD_SETPARAMS:
 575
 576       /* Change of buffer size for input buffer? */
 577
 578
 579       /* Copy the Flags from the iorequest to the Unit's Flags */
 580       PU->pu_Flags = ioreq->io_ParFlags;
 581
 582       /* Copy the TermArray */
 583       PU->pu_PTermArray = ioreq->io_PTermArray;
 584
 585       /*
 586       ** The request could be completed immediately.
 587       ** Check if I have to reply the message
 588       */
 589       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 590         ReplyMsg(&ioreq->IOPar.io_Message);
 591     break;
 592
 593     /*******************************************************************/
 594
 595     default:
 596       /* unknown command */
 597       ioreq->IOPar.io_Error = IOERR_NOCMD;
 598
 599       /*
 600       ** The request could be completed immediately.
 601       ** Check if I have to reply the message
 602       */
 603       if (0 == (ioreq->IOPar.io_Flags & IOF_QUICK))
 604         ReplyMsg(&ioreq->IOPar.io_Message);
 605
 606   } /* switch () */
 607
 608   ReleaseSemaphore(&PU->pu_Lock);
 609
 610   D(bug("id: Return from BeginIO()\n"));
 611
 612   AROS_LIBFUNC_EXIT
 613 }
 614
 615 /****************************************************************************************/
 616
 617 AROS_LH1(LONG, abortio,
 618  AROS_LHA(struct IORequest *, ioreq, A1),
 619            struct parallelbase *, ParallelDevice, 6, Parallel)
 620 {
 621   AROS_LIBFUNC_INIT
 622
 623   struct ParallelUnit  * PU = (struct ParallelUnit *)ioreq->io_Unit;
 624
 625   /*
 626   ** is it the active request?
 627   */
 628
 629   Disable();
 630   if ((struct Message *)ioreq == PU->pu_ActiveRead)
 631   {
 632     /*
 633     ** It's the active reuquest. I make the next available
 634     ** one the active request.
 635     */
 636     PU->pu_ActiveRead = GetMsg(&PU->pu_QReadCommandPort);
 637     ReplyMsg(&ioreq->io_Message);
 638   }
 639   else
 640   {
 641     /*
 642     ** It's not the active request. So I'll take it out of the
 643     ** list of queued messages and reply the message.
 644     */
 645     Remove(&ioreq->io_Message.mn_Node);
 646     ReplyMsg(&ioreq->io_Message);
 647   }
 648   Enable();
 649
 650   return 0;
 651   AROS_LIBFUNC_EXIT
 652 }
 653
 654 /****************************************************************************************/