rom/usb/classes/massstorage/dev.c

   1 /* dev.c - usbscsi.device by Chris Hodges
   2 */
   3
   4 #include "debug.h"
   5
   6 #include "massstorage.class.h"
   7
   8 AROS_UFH3(DEVBASETYPEPTR, GM_UNIQUENAME(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     return(base);
  29
  30     AROS_USERFUNC_EXIT
  31 }
  32
  33 AROS_LH3(DEVBASETYPEPTR, devOpen,
  34          AROS_LHA(struct IORequest *, ioreq, A1),
  35          AROS_LHA(ULONG, unitnum, D0),
  36          AROS_LHA(ULONG, flags, D1),
  37          DEVBASETYPEPTR, base, 1, usbscsidev)
  38 {
  39     AROS_LIBFUNC_INIT
  40
  41     struct NepClassMS *ncm;
  42
  43     KPRINTF(10, ("devOpen ioreq: 0x%08lx unit: %ld flags: 0x%08lx base: 0x%08lx\n",
  44                  ioreq, unitnum, flags, base));
  45
  46     if(!base->np_UtilityBase)
  47     {
  48         if(!(base->np_UtilityBase = OpenLibrary("utility.library", 0)))
  49         {
  50             ioreq->io_Error = IOERR_OPENFAIL;
  51             return(NULL);
  52         }
  53     }
  54
  55     ++base->np_Library.lib_OpenCnt;
  56     base->np_Library.lib_Flags &= ~LIBF_DELEXP;
  57
  58     KPRINTF(10, ("devOpen: openCnt = %ld\n", base->np_Library.lib_OpenCnt));
  59
  60     /* Damn f*cking programs which leave this field to zero! */
  61     if(ioreq->io_Message.mn_Length &&
  62        (ioreq->io_Message.mn_Length < sizeof(struct IOStdReq)))
  63     {
  64         KPRINTF(20, ("devOpen: invalid MN_LENGTH (%ld < %ld)!\n",
  65                 ioreq->io_Message.mn_Length, sizeof(struct IOStdReq)));
  66
  67         ioreq->io_Error = IOERR_BADLENGTH;
  68     } else {
  69         /* Default to open failure. */
  70         ioreq->io_Error = IOERR_OPENFAIL;
  71
  72         ioreq->io_Unit = NULL;
  73         ncm = (struct NepClassMS *) base->np_ClsBase->nh_Units.lh_Head;
  74         while(ncm->ncm_Unit.unit_MsgPort.mp_Node.ln_Succ)
  75         {
  76             if(ncm->ncm_UnitNo == unitnum)
  77             {
  78                 if(!ncm->ncm_DenyRequests)
  79                 {
  80                     ioreq->io_Unit = (struct Unit *) ncm;
  81                     break;
  82                 }
  83             }
  84             ncm = (struct NepClassMS *) ncm->ncm_Unit.unit_MsgPort.mp_Node.ln_Succ;
  85         }
  86
  87         if(!ioreq->io_Unit)
  88         {
  89             ioreq->io_Error = IOERR_OPENFAIL;
  90             KPRINTF(20, ("devOpen: could not open unit!\n"));
  91         } else {
  92             /* Opended ok! */
  93             ioreq->io_Message.mn_Node.ln_Type = NT_REPLYMSG;
  94             ioreq->io_Error                   = 0;
  95             ioreq->io_Unit->unit_OpenCnt++;
  96
  97             return base;
  98         }
  99     }
 100
 101     ioreq->io_Unit   = (APTR) -1;
 102     ioreq->io_Device = (APTR) -1;
 103     base->np_Library.lib_OpenCnt--;
 104
 105     return(NULL);
 106
 107     AROS_LIBFUNC_EXIT
 108 }
 109
 110
 111 AROS_LH1(BPTR, devClose,
 112          AROS_LHA(struct IORequest *, ioreq, A1),
 113          DEVBASETYPEPTR, base, 2, usbscsidev)
 114 {
 115     AROS_LIBFUNC_INIT
 116
 117     BPTR ret;
 118     struct NepClassMS *unit = (struct NepClassMS *) ioreq->io_Unit;
 119
 120     KPRINTF(10, ("devClose ioreq: 0x%08lx base: 0x%08lx\n", ioreq, base));
 121
 122     ret = BNULL;
 123     unit->ncm_Unit.unit_OpenCnt--;
 124     ioreq->io_Unit   = (APTR) -1;
 125     ioreq->io_Device = (APTR) -1;
 126
 127     if(--base->np_Library.lib_OpenCnt == 0)
 128     {
 129         if(base->np_Library.lib_Flags & LIBF_DELEXP)
 130         {
 131             KPRINTF(5, ("devClose: calling expunge...\n"));
 132             ret = AROS_LC1(BPTR, devExpunge,
 133                            AROS_LCA(DEVBASETYPEPTR, base, D0),
 134                            DEVBASETYPEPTR, base, 3, dev);
 135         }
 136     }
 137
 138     KPRINTF(5, ("devClose: lib_OpenCnt = %ld\n", base->np_Library.lib_OpenCnt));
 139
 140     return(ret);
 141
 142     AROS_LIBFUNC_EXIT
 143 }
 144
 145
 146 AROS_LH1(BPTR, devExpunge,
 147          AROS_LHA(DEVBASETYPEPTR, extralh, D0),
 148          DEVBASETYPEPTR, base, 3,usbscsidev)
 149 {
 150     AROS_LIBFUNC_INIT
 151
 152     BPTR ret;
 153
 154     KPRINTF(10, ("devExpunge base: 0x%08lx\n", base));
 155
 156     ret = BNULL;
 157
 158     if(base->np_Library.lib_OpenCnt == 0)
 159     {
 160         KPRINTF(5, ("devExpunge: Unloading...\n"));
 161
 162         CloseLibrary(base->np_UtilityBase);
 163
 164         ret = base->np_SegList;
 165
 166         KPRINTF(5, ("devExpunge: removing device node 0x%08lx\n",
 167                     &base->np_Library.lib_Node));
 168         Remove(&base->np_Library.lib_Node);
 169
 170         KPRINTF(5, ("devExpunge: FreeMem()...\n"));
 171         FreeMem((char *) base - base->np_Library.lib_NegSize,
 172                 (ULONG) (base->np_Library.lib_NegSize + base->np_Library.lib_PosSize));
 173
 174         KPRINTF(5, ("devExpunge: Unloading done! " DEVNAME " expunged!\n\n"));
 175
 176         return(ret);
 177     }
 178     else
 179     {
 180         KPRINTF(5, ("devExpunge: Could not expunge, LIBF_DELEXP set!\n"));
 181         base->np_Library.lib_Flags |= LIBF_DELEXP;
 182     }
 183
 184     return(BNULL);
 185
 186     AROS_LIBFUNC_EXIT
 187 }
 188
 189 AROS_LH0(DEVBASETYPEPTR, devReserved,
 190          DEVBASETYPEPTR, base, 4, usbscsidev)
 191 {
 192     AROS_LIBFUNC_INIT
 193     return NULL;
 194     AROS_LIBFUNC_EXIT
 195 }
 196
 197 AROS_LH1(void, devBeginIO,
 198          AROS_LHA(struct IOStdReq *, ioreq, A1),
 199          DEVBASETYPEPTR, base, 5, usbscsidev)
 200 {
 201     AROS_LIBFUNC_INIT
 202
 203     struct NepClassMS *unit = (struct NepClassMS *) ioreq->io_Unit;
 204     WORD ret = IOERR_NOCMD;
 205
 206     KPRINTF(5, ("devBeginIO ioreq: 0x%08lx base: 0x%08lx cmd: %lu\n", ioreq, base, ioreq->io_Command));
 207
 208     ioreq->io_Message.mn_Node.ln_Type = NT_MESSAGE;
 209     ioreq->io_Error                   = 0;
 210
 211     if(ioreq->io_Command < NSCMD_DEVICEQUERY)
 212     {
 213         switch (ioreq->io_Command)
 214         {
 215             case TD_ADDCHANGEINT:
 216                 Forbid();
 217                 AddTail(&unit->ncm_DCInts, (struct Node *) ioreq);
 218                 Permit();
 219                 ret = RC_DONTREPLY;
 220                 break;
 221
 222             case TD_REMCHANGEINT:
 223                 Forbid();
 224                 Remove((struct Node *) ioreq);
 225                 Permit();
 226                 ret = 0;
 227                 ioreq->io_Flags &= ~IOF_QUICK;
 228                 break;
 229
 230             case TD_CHANGENUM:
 231                 ioreq->io_Actual = unit->ncm_ChangeCount;
 232                 ret = 0;
 233                 break;
 234
 235             case TD_CHANGESTATE:
 236                 ioreq->io_Actual = unit->ncm_UnitReady ? 0 : ~0;
 237                 ret = 0;
 238                 break;
 239
 240             case TD_PROTSTATUS:
 241                 ioreq->io_Actual = unit->ncm_WriteProtect ? ~0 : 0;
 242                 ret = 0;
 243                 break;
 244
 245             case CMD_START:
 246             case CMD_STOP:
 247             case CMD_RESET:
 248                 case CMD_FLUSH:
 249             case CMD_READ:
 250             case CMD_WRITE:
 251             case TD_SEEK:
 252             case TD_FORMAT:
 253             case TD_GETGEOMETRY:
 254             case TD_EJECT:
 255             case TD_READ64:
 256             case TD_WRITE64:
 257             case TD_SEEK64:
 258             case TD_FORMAT64:
 259             case HD_SCSICMD:
 260                 if(unit->ncm_DenyRequests)
 261                 {
 262                     ret = TDERR_DiskChanged;
 263                 } else {
 264                     ioreq->io_Flags &= ~IOF_QUICK;
 265                     ret = RC_DONTREPLY;
 266                     PutMsg(&unit->ncm_Unit.unit_MsgPort, (struct Message *) ioreq);
 267                 }
 268                 break;
 269
 270             /* NOPs */
 271             case CMD_CLEAR:
 272             case CMD_UPDATE:
 273             case TD_MOTOR:
 274                 ret = 0;
 275                 break;
 276
 277             default:
 278                 ret = IOERR_NOCMD;
 279                 break;
 280         }
 281     } else {
 282         switch(ioreq->io_Command)
 283         {
 284             case NSCMD_DEVICEQUERY:
 285                 ret = GM_UNIQUENAME(cmdNSDeviceQuery)((struct IOStdReq *) ioreq, unit, base);
 286                 break;
 287
 288             case NSCMD_TD_READ64:
 289             case NSCMD_TD_WRITE64:
 290             case NSCMD_TD_FORMAT64:
 291             case NSCMD_TD_SEEK64:
 292                 if(unit->ncm_DenyRequests)
 293                 {
 294                     ret = IOERR_ABORTED;
 295                 } else {
 296                     ioreq->io_Flags &= ~IOF_QUICK;
 297                     ret = RC_DONTREPLY;
 298                     PutMsg(&unit->ncm_Unit.unit_MsgPort, (struct Message *) ioreq);
 299                 }
 300                 break;
 301
 302             default:
 303                 ret = IOERR_NOCMD;
 304                 break;
 305         }
 306     }
 307
 308     if(ret != RC_DONTREPLY)
 309     {
 310         KPRINTF(1, ("GM_UNIQUENAME(TermIO)\n"));
 311         if (ret != RC_OK)
 312         {
 313             /* Set error codes  */
 314             ioreq->io_Error = ret & 0xff;
 315         }
 316         /* Terminate the iorequest */
 317         GM_UNIQUENAME(TermIO)(ioreq, base);
 318     }
 319
 320     AROS_LIBFUNC_EXIT
 321 }
 322
 323 AROS_LH1(LONG, devAbortIO,
 324          AROS_LHA(struct IOStdReq *, ioreq, A1),
 325          DEVBASETYPEPTR, base, 6, usbscsidev)
 326 {
 327     AROS_LIBFUNC_INIT
 328
 329     struct NepClassMS *unit = (struct NepClassMS *) ioreq->io_Unit;
 330     struct IOStdReq *iocmp;
 331
 332     KPRINTF(5, ("devAbortIO ioreq: 0x%08lx\n", ioreq));
 333
 334     /* Is it pending? */
 335     if(ioreq->io_Message.mn_Node.ln_Type == NT_MESSAGE)
 336     {
 337         if(unit->ncm_XFerPending == ioreq)
 338         {
 339             unit->ncm_XFerPending = NULL;
 340             ioreq->io_Error = IOERR_ABORTED;
 341             ReplyMsg(&ioreq->io_Message);
 342             return(0);
 343         }
 344         iocmp = (struct IOStdReq *) unit->ncm_XFerQueue.lh_Head;
 345         while(iocmp->io_Message.mn_Node.ln_Succ)
 346         {
 347             if(iocmp == ioreq)
 348             {
 349                 Remove((struct Node *) ioreq);
 350                 ioreq->io_Error = IOERR_ABORTED;
 351                 ReplyMsg(&ioreq->io_Message);
 352                 return(0);
 353             }
 354             iocmp = (struct IOStdReq *) iocmp->io_Message.mn_Node.ln_Succ;
 355         }
 356     }
 357     return(-1);
 358
 359     AROS_LIBFUNC_EXIT
 360 }
 361
 362 /* NSD stuff */
 363
 364 static
 365 const UWORD GM_UNIQUENAME(NSDSupported)[] =
 366 {
 367     CMD_CLEAR, CMD_RESET,
 368     CMD_FLUSH, CMD_READ,
 369     CMD_WRITE, CMD_START,
 370     CMD_STOP, CMD_UPDATE,
 371     TD_SEEK,
 372     TD_MOTOR, TD_EJECT,
 373     TD_CHANGENUM, TD_PROTSTATUS,
 374     TD_CHANGESTATE,
 375     TD_FORMAT,
 376     TD_GETGEOMETRY,
 377     TD_ADDCHANGEINT, TD_REMCHANGEINT,
 378     TD_READ64, TD_WRITE64, TD_SEEK64,
 379     TD_FORMAT64,
 380     HD_SCSICMD,
 381     NSCMD_TD_READ64,
 382     NSCMD_TD_WRITE64,
 383     NSCMD_TD_FORMAT64,
 384     NSCMD_TD_SEEK64,
 385     NSCMD_DEVICEQUERY, 0
 386 };
 387
 388 WORD GM_UNIQUENAME(cmdNSDeviceQuery)(struct IOStdReq *ioreq,
 389                       struct NepClassMS *unit,
 390                       struct NepMSDevBase *base)
 391 {
 392     struct my_NSDeviceQueryResult *query;
 393
 394     query = (struct my_NSDeviceQueryResult *) ioreq->io_Data;
 395
 396     KPRINTF(10, ("NSCMD_DEVICEQUERY ioreq: 0x%08lx query: 0x%08lx\n", ioreq, query));
 397
 398     /* NULL ptr?
 399        Enough data?
 400        Valid request?
 401     */
 402     if((!query) ||
 403        (ioreq->io_Length < sizeof(struct my_NSDeviceQueryResult)) ||
 404        (query->DevQueryFormat != 0) ||
 405        (query->SizeAvailable != 0))
 406     {
 407         /* Return error. This is special handling, since iorequest is only
 408            guaranteed to be sizeof(struct IOStdReq). If we'd let our
 409            devBeginIO dispatcher return the error, it would trash some
 410            memory past end of the iorequest (ios2_WireError field).
 411          */
 412          ioreq->io_Error = IOERR_NOCMD;
 413          GM_UNIQUENAME(TermIO)((struct IOStdReq *) ioreq, base);
 414
 415          /* Don't reply, we already did. */
 416          return RC_DONTREPLY;
 417     }
 418
 419     ioreq->io_Actual         = query->SizeAvailable
 420                              = sizeof(struct my_NSDeviceQueryResult);
 421     query->DeviceType        = NSDEVTYPE_TRACKDISK;
 422     query->DeviceSubType     = 0;
 423     query->SupportedCommands = GM_UNIQUENAME(NSDSupported);
 424
 425     /* Return success (note that this will NOT poke ios2_WireError).
 426     */
 427     return RC_OK;
 428 }
 429
 430 void GM_UNIQUENAME(TermIO)(struct IOStdReq *ioreq,
 431             struct NepMSDevBase *base)
 432 {
 433     ioreq->io_Message.mn_Node.ln_Type = NT_FREEMSG;
 434
 435     /* If not quick I/O, reply the message */
 436     if(!(ioreq->io_Flags & IOF_QUICK))
 437     {
 438         ReplyMsg(&ioreq->io_Message);
 439     }
 440 }