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