rom/usb/classes/printer/dev.c

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