rom/devs/sdcard/sdcard_device.c

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <proto/exec.h>
  10 #include <proto/oop.h>
  11
  12 #include <exec/types.h>
  13 #include <exec/exec.h>
  14 #include <exec/resident.h>
  15 #include <exec/io.h>
  16 #include <dos/bptr.h>
  17 #include <devices/trackdisk.h>
  18 #include <devices/scsidisk.h>
  19 #include <devices/newstyle.h>
  20 #include <utility/utility.h>
  21 #include <utility/tagitem.h>
  22 #include <oop/oop.h>
  23
  24 #include "sdcard_base.h"
  25 #include "sdcard_unit.h"
  26 #include "timer.h"
  27
  28 #include LC_LIBDEFS_FILE
  29
  30 //---------------------------IO Commands---------------------------------------
  31
  32 /* Invalid comand does nothing, complains only. */
  33 static void cmd_Invalid(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  34 {
  35     D(bug("[SDCard%02ld] %s: %d\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__, io->io_Command));
  36     io->io_Error = IOERR_NOCMD;
  37 }
  38
  39 /* Don't need to reset the drive? */
  40 static void cmd_Reset(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  41 {
  42     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
  43     IOStdReq(io)->io_Actual = 0;
  44 }
  45
  46 /* CMD_READ implementation */
  47 static void cmd_Read32(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  48 {
  49     struct sdcard_Unit *unit = (struct sdcard_Unit *)IOStdReq(io)->io_Unit;
  50     ULONG block = IOStdReq(io)->io_Offset;
  51     ULONG count = IOStdReq(io)->io_Length;
  52     ULONG mask;
  53
  54     D(bug("[SDCard%02ld] %s(%08x, %08x)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, block, count));
  55
  56     if (!(unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaPresent))
  57     {
  58         bug("[SDCard%02ld] %s: Error: No Media present\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
  59         io->io_Error = TDERR_DiskChanged;
  60         return;
  61     }
  62
  63     mask = (1 << unit->sdcu_Bus->sdcb_SectorShift) - 1;
  64
  65     /*
  66         During this IO call it should be sure that both offset and
  67         length are already aligned properly to sector boundaries.
  68     */
  69     if ((block & mask) | (count & mask))
  70     {
  71         bug("[SDCard%02ld] %s: offset or length not sector-aligned.\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
  72         cmd_Invalid(io, LIBBASE);
  73     }
  74     else
  75     {
  76         block >>= unit->sdcu_Bus->sdcb_SectorShift;
  77         count >>= unit->sdcu_Bus->sdcb_SectorShift;
  78         ULONG cnt = 0;
  79
  80         if ((block + count) > (ULONG)(unit->sdcu_Capacity & 0xFFFFFFFFul))
  81         {
  82             bug("[SDCard%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, block, count, (ULONG)(unit->sdcu_Capacity & 0xFFFFFFFFul));
  83             io->io_Error = IOERR_BADADDRESS;
  84             return;
  85         }
  86
  87         /* Call the Unit's access funtion */
  88         io->io_Error = unit->sdcu_Read32(unit, block, count,
  89             IOStdReq(io)->io_Data, &cnt);
  90
  91         IOStdReq(io)->io_Actual = cnt;
  92     }
  93 }
  94
  95 /*
  96     NSCMD_TD_READ64, TD_READ64 implementation. Basically the same, just packs
  97     the 64 bit offset in both io_Offset (31:0) and io_Actual (63:32)
  98 */
  99 static void cmd_Read64(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 100 {
 101     struct sdcard_Unit *unit = (struct sdcard_Unit *)IOStdReq(io)->io_Unit;
 102     UQUAD block = IOStdReq(io)->io_Offset | (UQUAD)(IOStdReq(io)->io_Actual) << 32;
 103     ULONG count = IOStdReq(io)->io_Length;
 104     ULONG mask;
 105
 106     D(bug("[SDCard%02ld] %s(%08x%08x, %08x)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, IOStdReq(io)->io_Actual, IOStdReq(io)->io_Offset, count));
 107
 108     if (!(unit->sdcu_Flags & AF_Card_HighCapacity))
 109     {
 110         /* 64bit commands are only used with high capacity devices .. */
 111         D(bug("[SDCard%02ld] %s: 64bit IO called on 32bit unit\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 112         io->io_Error = IOERR_NOCMD;
 113         return;
 114     }
 115
 116     if (!(unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaPresent))
 117     {
 118         bug("[SDCard%02ld] %s: Error: No Media present\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 119         io->io_Error = TDERR_DiskChanged;
 120         return;
 121     }
 122
 123     mask = (1 << unit->sdcu_Bus->sdcb_SectorShift) - 1;
 124
 125     if ((block & (UQUAD)mask) | (count & mask) | (count == 0))
 126     {
 127         D(bug("[SDCard%02ld] %s: offset or length not sector-aligned.\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 128         cmd_Invalid(io, LIBBASE);
 129     }
 130     else
 131     {
 132         block >>= unit->sdcu_Bus->sdcb_SectorShift;
 133         count >>= unit->sdcu_Bus->sdcb_SectorShift;
 134         ULONG cnt = 0;
 135
 136         if (((block + count) > unit->sdcu_Capacity))
 137         {
 138             bug("[SDCard%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, block, count, unit->sdcu_Capacity);
 139             io->io_Error = IOERR_BADADDRESS;
 140             return;
 141         }
 142         io->io_Error = unit->sdcu_Read64(unit, block, count, IOStdReq(io)->io_Data, &cnt);
 143
 144         IOStdReq(io)->io_Actual = cnt;
 145     }
 146 }
 147
 148 /* CMD_WRITE implementation */
 149 static void cmd_Write32(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 150 {
 151     struct sdcard_Unit *unit = (struct sdcard_Unit *)IOStdReq(io)->io_Unit;
 152     ULONG block = IOStdReq(io)->io_Offset;
 153     ULONG count = IOStdReq(io)->io_Length;
 154     ULONG mask;
 155
 156     D(bug("[SDCard%02ld] %s(%08x, %08x)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, block, count));
 157
 158     if (!(unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaPresent))
 159     {
 160         bug("[SDCard%02ld] %s: Error: No Media present\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 161         io->io_Error = TDERR_DiskChanged;
 162         return;
 163     }
 164
 165     if (unit->sdcu_Flags & (AF_Card_WriteProtect|AF_Card_Locked))
 166     {
 167         bug("[SDCard%02ld] %s: Error: Card is Locked/Write Protected\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 168         io->io_Error = IOERR_ABORTED;
 169         return;
 170     }
 171
 172     mask = (1 << unit->sdcu_Bus->sdcb_SectorShift) - 1;
 173
 174     /*
 175         During this IO call it should be sure that both offset and
 176         length are already aligned properly to sector boundaries.
 177     */
 178     if ((block & mask) | (count & mask))
 179     {
 180         D(bug("[SDCard%02ld] %s: offset or length not sector-aligned.\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 181         cmd_Invalid(io, LIBBASE);
 182     }
 183     else
 184     {
 185         block >>= unit->sdcu_Bus->sdcb_SectorShift;
 186         count >>= unit->sdcu_Bus->sdcb_SectorShift;
 187         ULONG cnt = 0;
 188
 189         if (((block + count) > unit->sdcu_Capacity))
 190         {
 191             bug("[SDCard%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__,
 192                 block, count, unit->sdcu_Capacity);
 193             io->io_Error = IOERR_BADADDRESS;
 194             return;
 195         }
 196
 197         /* Call the Unit's access funtion */
 198         io->io_Error = unit->sdcu_Write32(unit, block, count,
 199             IOStdReq(io)->io_Data, &cnt);
 200
 201         IOStdReq(io)->io_Actual = cnt;
 202     }
 203 }
 204
 205 /*
 206     NSCMD_TD_WRITE64, TD_WRITE64 implementation. Basically the same, just packs
 207     the 64 bit offset in both io_Offset (31:0) and io_Actual (63:32)
 208 */
 209 static void cmd_Write64(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 210 {
 211     struct sdcard_Unit *unit = (struct sdcard_Unit *)IOStdReq(io)->io_Unit;
 212     UQUAD block = IOStdReq(io)->io_Offset | (UQUAD)(IOStdReq(io)->io_Actual) << 32;
 213     ULONG count = IOStdReq(io)->io_Length;
 214     ULONG mask;
 215
 216     D(bug("[SDCard%02ld] %s(%08x-%08x, %08x)\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, IOStdReq(io)->io_Actual, IOStdReq(io)->io_Offset, count));
 217
 218     if (!(unit->sdcu_Flags & AF_Card_HighCapacity))
 219     {
 220         /* 64bit commands are only used with high capacity devices .. */
 221         D(bug("[SDCard%02ld] %s: 64bit IO called on 32bit unit\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 222         io->io_Error = IOERR_NOCMD;
 223         return;
 224     }
 225
 226     if (!(unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaPresent))
 227     {
 228         bug("[SDCard%02ld] %s: Error: No Media present\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 229         io->io_Error = TDERR_DiskChanged;
 230         return;
 231     }
 232
 233     if (unit->sdcu_Flags & (AF_Card_WriteProtect|AF_Card_Locked))
 234     {
 235         bug("[SDCard%02ld] %s: Error: Card is Locked/Write Protected\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 236         io->io_Error = IOERR_ABORTED;
 237         return;
 238     }
 239
 240     mask = (1 << unit->sdcu_Bus->sdcb_SectorShift) - 1;
 241
 242     if ((block & mask) | (count & mask) | (count==0))
 243     {
 244         D(bug("[SDCard%02ld] %s: offset or length not sector-aligned.\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 245         cmd_Invalid(io, LIBBASE);
 246     }
 247     else
 248     {
 249         block >>= unit->sdcu_Bus->sdcb_SectorShift;
 250         count >>= unit->sdcu_Bus->sdcb_SectorShift;
 251         ULONG cnt = 0;
 252
 253         if (((block + count) > unit->sdcu_Capacity))
 254         {
 255             bug("[SDCard%02ld] %s: Requested block (%lx:%08lx;%ld) outside disk "
 256                 "range (%lx:%08lx)\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__,
 257                  block>>32, block&0xfffffffful,
 258                  count, unit->sdcu_Capacity>>32,
 259                  unit->sdcu_Capacity & 0xfffffffful);
 260             io->io_Error = IOERR_BADADDRESS;
 261             return;
 262         }
 263
 264         io->io_Error = unit->sdcu_Write64(unit, block, count,
 265             IOStdReq(io)->io_Data, &cnt);
 266
 267         IOStdReq(io)->io_Actual = cnt;
 268    }
 269 }
 270
 271
 272 /* use CMD_FLUSH to force all IO waiting commands to abort */
 273 static void cmd_Flush(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 274 {
 275     struct IORequest *msg;
 276     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 277
 278     Forbid();
 279
 280     while((msg = (struct IORequest *)GetMsg((struct MsgPort *)((struct sdcard_Unit *)io->io_Unit)->sdcu_Bus->sdcb_MsgPort)))
 281     {
 282         msg->io_Error = IOERR_ABORTED;
 283         ReplyMsg((struct Message *)msg);
 284     }
 285
 286     Permit();
 287 }
 288
 289 /*
 290     Internal command used to check whether the media in drive has been changed
 291     since last call. If so, the handlers given by user are called.
 292 */
 293 static void cmd_TestChanged(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 294 {
 295     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 296     struct IORequest *msg;
 297
 298     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 299
 300     if (unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaChanged)
 301     {
 302         unit->sdcu_ChangeNum++;
 303
 304         Forbid();
 305
 306         /* old-fashioned RemoveInt call first */
 307         if (unit->sdcu_RemoveInt)
 308             Cause(unit->sdcu_RemoveInt);
 309
 310         /* And now the whole list of possible calls */
 311         ForeachNode(&unit->sdcu_SoftList, msg)
 312         {
 313             Cause((struct Interrupt *)IOStdReq(msg)->io_Data);
 314         }
 315
 316         unit->sdcu_Bus->sdcb_BusFlags &= ~AF_Bus_MediaChanged;
 317
 318         Permit();
 319     }
 320 }
 321
 322 static void cmd_Update(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 323 {
 324     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 325
 326     /* Do nothing now. In near future there should be drive cache flush though */
 327 }
 328
 329 static void cmd_Remove(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 330 {
 331     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 332
 333     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 334
 335     if (unit->sdcu_RemoveInt)
 336         io->io_Error = TDERR_DriveInUse;
 337     else
 338         unit->sdcu_RemoveInt = IOStdReq(io)->io_Data;
 339 }
 340
 341 static void cmd_ChangeNum(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 342 {
 343     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 344
 345     IOStdReq(io)->io_Actual = ((struct sdcard_Unit *)io->io_Unit)->sdcu_ChangeNum;
 346 }
 347
 348 static void cmd_ChangeState(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 349 {
 350     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 351
 352     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 353
 354     if (unit->sdcu_Bus->sdcb_BusFlags & AF_Bus_MediaPresent)
 355         IOStdReq(io)->io_Actual = 0;
 356     else
 357         IOStdReq(io)->io_Actual = 1;
 358
 359     D(bug("[SDCard%02ld] %s: Media %s\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, IOStdReq(io)->io_Actual ? "ABSENT" : "PRESENT"));
 360 }
 361
 362 static void cmd_ProtStatus(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 363 {
 364     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 365
 366     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 367
 368     if ((unit->sdcu_Flags & (AF_Card_WriteProtect|AF_Card_Locked)) != 0)
 369         IOStdReq(io)->io_Actual = -1;
 370     else
 371         IOStdReq(io)->io_Actual = 0;
 372 }
 373
 374 static void cmd_GetNumTracks(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 375 {
 376     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 377
 378     IOStdReq(io)->io_Actual = ((struct sdcard_Unit *)io->io_Unit)->sdcu_Cylinders;
 379 }
 380
 381 static void cmd_AddChangeInt(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 382 {
 383     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 384
 385     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 386
 387     Forbid();
 388     AddHead(&unit->sdcu_SoftList, (struct Node *)io);
 389     Permit();
 390
 391     io->io_Flags &= ~IOF_QUICK;
 392     unit->sdcu_Unit.unit_flags &= ~UNITF_ACTIVE;
 393 }
 394
 395 static void cmd_RemChangeInt(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 396 {
 397     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 398
 399     Forbid();
 400     Remove((struct Node *)io);
 401     Permit();
 402 }
 403
 404 static void cmd_Eject(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 405 {
 406     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 407
 408     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 409
 410     IOStdReq(io)->io_Error = unit->sdcu_Eject(unit);
 411     cmd_TestChanged(io, LIBBASE);
 412 }
 413
 414 static void cmd_GetGeometry(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 415 {
 416     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 417
 418     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 419
 420     if (IOStdReq(io)->io_Length == sizeof(struct DriveGeometry))
 421     {
 422         struct DriveGeometry *dg = (struct DriveGeometry *)IOStdReq(io)->io_Data;
 423
 424         dg->dg_SectorSize       = 1 << unit->sdcu_Bus->sdcb_SectorShift;
 425
 426         if ((ULONG)((unit->sdcu_Capacity >> 32) & 0xFFFFFFFFul) != 0)
 427             dg->dg_TotalSectors     = 0xFFFFFFFF;
 428         else
 429             dg->dg_TotalSectors     = (ULONG)(unit->sdcu_Capacity & 0xFFFFFFFFul);
 430
 431         dg->dg_Cylinders                = unit->sdcu_Cylinders;
 432         dg->dg_CylSectors               = unit->sdcu_Sectors * unit->sdcu_Heads;
 433         dg->dg_Heads                    = unit->sdcu_Heads;
 434         dg->dg_TrackSectors             = unit->sdcu_Sectors;
 435         dg->dg_BufMemType               = MEMF_PUBLIC;
 436         dg->dg_DeviceType               = DG_DIRECT_ACCESS;
 437         dg->dg_Flags                    = DGF_REMOVABLE;
 438         dg->dg_Reserved                 = 0;
 439
 440         IOStdReq(io)->io_Actual = sizeof(struct DriveGeometry);
 441     }
 442     else io->io_Error = TDERR_NotSpecified;
 443 }
 444
 445 static void cmd_DirectSCSI(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 446 {
 447     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 448
 449     IOStdReq(io)->io_Actual = sizeof(struct SCSICmd);
 450     io->io_Error = IOERR_BADADDRESS;
 451 }
 452
 453 //-----------------------------------------------------------------------------
 454
 455 /*
 456     command translation tables - used to call proper IO functions.
 457 */
 458
 459 #define N_TD_READ64     0
 460 #define N_TD_WRITE64    1
 461 #define N_TD_SEEK64     2
 462 #define N_TD_FORMAT64   3
 463
 464 typedef void (*mapfunc)(struct IORequest *, LIBBASETYPEPTR);
 465
 466 static mapfunc const map64[]= {
 467     [N_TD_READ64]   = cmd_Read64,
 468     [N_TD_WRITE64]  = cmd_Write64,
 469     [N_TD_SEEK64]   = cmd_Reset,
 470     [N_TD_FORMAT64] = cmd_Write64
 471 };
 472
 473 static mapfunc const map32[] = {
 474     [CMD_INVALID]   = cmd_Invalid,
 475     [CMD_RESET]     = cmd_Reset,
 476     [CMD_READ]      = cmd_Read32,
 477     [CMD_WRITE]     = cmd_Write32,
 478     [CMD_UPDATE]    = cmd_Update,
 479     [CMD_CLEAR]     = cmd_Reset,
 480     [CMD_STOP]      = cmd_Reset,
 481     [CMD_START]     = cmd_Reset,
 482     [CMD_FLUSH]     = cmd_Flush,
 483     [TD_MOTOR]      = cmd_Reset,
 484     [TD_SEEK]       = cmd_Reset,
 485     [TD_FORMAT]     = cmd_Write32,
 486     [TD_REMOVE]     = cmd_Remove,
 487     [TD_CHANGENUM]  = cmd_ChangeNum,
 488     [TD_CHANGESTATE]= cmd_ChangeState,
 489     [TD_PROTSTATUS] = cmd_ProtStatus,
 490     [TD_RAWREAD]    = cmd_Invalid,
 491     [TD_RAWWRITE]   = cmd_Invalid,
 492     [TD_GETNUMTRACKS]       = cmd_GetNumTracks,
 493     [TD_ADDCHANGEINT]       = cmd_AddChangeInt,
 494     [TD_REMCHANGEINT]       = cmd_RemChangeInt,
 495     [TD_GETGEOMETRY]= cmd_GetGeometry,
 496     [TD_EJECT]      = cmd_Eject,
 497     [TD_READ64]     = cmd_Read64,
 498     [TD_WRITE64]    = cmd_Write64,
 499     [TD_SEEK64]     = cmd_Reset,
 500     [TD_FORMAT64]   = cmd_Write64,
 501     [HD_SCSICMD]    = cmd_DirectSCSI,
 502     [HD_SCSICMD+1]  = cmd_TestChanged,
 503 };
 504
 505 static UWORD const NSDSupported[] = {
 506     TD_READ64,
 507     TD_WRITE64,
 508     TD_SEEK64,
 509     TD_FORMAT64,
 510     NSCMD_TD_READ64,
 511     NSCMD_TD_WRITE64,
 512     NSCMD_TD_SEEK64,
 513     NSCMD_TD_FORMAT64,
 514     CMD_RESET,
 515     CMD_READ,
 516     CMD_WRITE,
 517     CMD_UPDATE,
 518     CMD_CLEAR,
 519     CMD_STOP,
 520     CMD_START,
 521     CMD_FLUSH,
 522     TD_MOTOR,
 523     TD_SEEK,
 524     TD_FORMAT,
 525     TD_REMOVE,
 526     TD_CHANGENUM,
 527     TD_CHANGESTATE,
 528     TD_PROTSTATUS,
 529     TD_GETNUMTRACKS,
 530     TD_ADDCHANGEINT,
 531     TD_REMCHANGEINT,
 532     TD_GETGEOMETRY,
 533     TD_EJECT,
 534     HD_SCSICMD,
 535     TD_GETDRIVETYPE,
 536     NSCMD_DEVICEQUERY,
 537     0
 538 };
 539
 540 /*
 541     Do proper IO actions depending on the request. It's called from the bus
 542     tasks and from BeginIO in case of immediate commands.
 543 */
 544 BOOL FNAME_SDC(HandleIO)(struct IORequest *io)
 545 {
 546     BOOL retval = TRUE;
 547     LIBBASETYPEPTR LIBBASE = ((struct sdcard_Unit*)io->io_Unit)->sdcu_Bus->sdcb_DeviceBase;
 548
 549     io->io_Error = 0;
 550
 551     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 552
 553     /* Handle few commands directly here */
 554     switch (io->io_Command)
 555     {
 556         /*
 557             New Style Devices query. Introduce self as trackdisk and provide list of
 558             commands supported
 559         */
 560         case NSCMD_DEVICEQUERY:
 561             {
 562                 struct NSDeviceQueryResult *nsdq = (struct NSDeviceQueryResult *)IOStdReq(io)->io_Data;
 563                 nsdq->DevQueryFormat    = 0;
 564                 nsdq->SizeAvailable     = sizeof(struct NSDeviceQueryResult);
 565                 nsdq->DeviceType        = NSDEVTYPE_TRACKDISK;
 566                 nsdq->DeviceSubType     = 0;
 567                 nsdq->SupportedCommands = (((struct sdcard_Unit*)io->io_Unit)->sdcu_Flags & AF_Card_HighCapacity) ? (UWORD *)NSDSupported : (UWORD *)&NSDSupported[8];
 568             }
 569             IOStdReq(io)->io_Actual = sizeof(struct NSDeviceQueryResult);
 570             break;
 571
 572         /*
 573             New Style Devices report here the 'NSTY' - only if such value is
 574             returned here, the NSCMD_DEVICEQUERY might be called. Otherwice it should
 575             report error.
 576         */
 577         case TD_GETDRIVETYPE:
 578             IOStdReq(io)->io_Actual = DRIVE_NEWSTYLE;
 579             break;
 580
 581         case TD_ADDCHANGEINT:
 582             retval = FALSE;
 583         /*
 584             Call all other commands using the command pointer tables for 32- and
 585             64-bit accesses. If requested function is defined call it, otherwise
 586             make the function cmd_Invalid.
 587         */
 588         default:
 589             if (io->io_Command <= (HD_SCSICMD + 1))
 590             {
 591                 if (map32[io->io_Command])
 592                     map32[io->io_Command](io, LIBBASE);
 593                 else
 594                     cmd_Invalid(io, LIBBASE);
 595             }
 596             else if (io->io_Command >= NSCMD_TD_READ64 && io->io_Command <= NSCMD_TD_FORMAT64)
 597             {
 598                 if (map64[io->io_Command - NSCMD_TD_READ64])
 599                     map64[io->io_Command - NSCMD_TD_READ64](io, LIBBASE);
 600                 else
 601                     cmd_Invalid(io, LIBBASE);
 602             }
 603             else cmd_Invalid(io, LIBBASE);
 604             break;
 605     }
 606     return retval;
 607 }
 608
 609
 610 static const ULONG IMMEDIATE_COMMANDS = 0x803ff1e3; // 10000000001111111111000111100011
 611
 612 /* See whether the command can be done quick */
 613 BOOL isSlow(ULONG comm)
 614 {
 615     BOOL slow = TRUE;   /* Assume always slow command */
 616
 617     /* For commands with numbers <= 31 check the mask */
 618     if (comm <= 31)
 619     {
 620         if (IMMEDIATE_COMMANDS & (1 << comm))
 621             slow = FALSE;
 622     }
 623     else if (comm == NSCMD_TD_SEEK64) slow = FALSE;
 624
 625     return slow;
 626 }
 627
 628 /*
 629     Try to do IO commands. All commands which require talking with mci devices
 630     will be handled slow, that is they will be passed to bus task which will
 631     execute them as soon as hardware will be free.
 632 */
 633 AROS_LH1(void, BeginIO,
 634     AROS_LHA(struct IORequest *, io, A1),
 635     LIBBASETYPEPTR, LIBBASE, 5, sdcard)
 636 {
 637     AROS_LIBFUNC_INIT
 638
 639     struct sdcard_Unit *unit = (struct sdcard_Unit *)io->io_Unit;
 640
 641     io->io_Message.mn_Node.ln_Type = NT_MESSAGE;
 642
 643     /* Disable interrupts for a while to modify message flags */
 644     Disable();
 645
 646     D(bug("[SDCard%02ld] %s: Executing IO Command %lx\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__, io->io_Command));
 647
 648     /*
 649         If the command is not-immediate, or presence of disc is still unknown,
 650         let the bus task do the job.
 651     */
 652     if (isSlow(io->io_Command))
 653     {
 654         unit->sdcu_Unit.unit_flags |= UNITF_ACTIVE | UNITF_INTASK;
 655         io->io_Flags &= ~IOF_QUICK;
 656         Enable();
 657
 658         /* Put the message to the bus */
 659         PutMsg(unit->sdcu_Bus->sdcb_MsgPort, (struct Message *)io);
 660     }
 661     else
 662     {
 663         D(bug("[SDCard%02ld] %s: Fast command\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 664
 665         /* Immediate command. Mark unit as active and do the command directly */
 666         unit->sdcu_Unit.unit_flags |= UNITF_ACTIVE;
 667         Enable();
 668         if (FNAME_SDC(HandleIO)(io))
 669         {
 670             unit->sdcu_Unit.unit_flags &= ~UNITF_ACTIVE;
 671             if (!(io->io_Flags & IOF_QUICK))
 672                 ReplyMsg((struct Message *)io);
 673         }
 674         else
 675             unit->sdcu_Unit.unit_flags &= ~UNITF_ACTIVE;
 676     }
 677
 678     D(bug("[SDCard%02ld] %s: Done\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 679
 680     AROS_LIBFUNC_EXIT
 681 }
 682
 683 AROS_LH1(LONG, AbortIO,
 684     AROS_LHA(struct IORequest *, io, A1),
 685     LIBBASETYPEPTR, LIBBASE, 6, sdcard)
 686 {
 687     AROS_LIBFUNC_INIT
 688
 689     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 690
 691     /* Cannot Abort IO */
 692     return 0;
 693
 694     AROS_LIBFUNC_EXIT
 695 }
 696
 697 AROS_LH1(ULONG, GetRdskLba,
 698     AROS_LHA(struct IORequest *, io, A1),
 699     LIBBASETYPEPTR, LIBBASE, 7, sdcard)
 700 {
 701     AROS_LIBFUNC_INIT
 702
 703     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 704
 705     return 0;
 706
 707     AROS_LIBFUNC_EXIT
 708 }
 709
 710 AROS_LH1(ULONG, GetBlkSize,
 711     AROS_LHA(struct IORequest *, io, A1),
 712     LIBBASETYPEPTR, LIBBASE, 8, sdcard)
 713 {
 714     AROS_LIBFUNC_INIT
 715
 716     D(bug("[SDCard%02ld] %s()\n", ((struct sdcard_Unit*)io->io_Unit)->sdcu_UnitNum, __PRETTY_FUNCTION__));
 717
 718     return Unit(io)->sdcu_Bus->sdcb_SectorShift;
 719
 720     AROS_LIBFUNC_EXIT
 721 }