rom/devs/ata/ata.c

   1 /*
   2     Copyright © 2004-2019, The AROS Development Team. All rights reserved
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include <aros/debug.h>
  10
  11 #include <proto/exec.h>
  12
  13 /* We want all other bases obtained from our base */
  14 #define __NOLIBBASE__
  15
  16 #include <proto/oop.h>
  17
  18 #include <exec/exec.h>
  19 #include <exec/resident.h>
  20 #include <hidd/hidd.h>
  21 #include <utility/utility.h>
  22 #include <utility/tagitem.h>
  23 #include <oop/oop.h>
  24 #include <dos/bptr.h>
  25
  26 #include <devices/ata.h>
  27
  28 #include "timer.h"
  29 #include "ata.h"
  30 #include LC_LIBDEFS_FILE
  31
  32 #define DINIT(x)
  33
  34 //---------------------------IO Commands---------------------------------------
  35
  36 /* Invalid comand does nothing, complains only. */
  37 static void cmd_Invalid(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  38 {
  39     D(bug("[ATA%02ld] %s(%d)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, io->io_Command));
  40     io->io_Error = IOERR_NOCMD;
  41 }
  42
  43 /* Don't need to reset the drive? */
  44 static void cmd_Reset(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  45 {
  46     IOStdReq(io)->io_Actual = 0;
  47 }
  48
  49 /* CMD_READ implementation */
  50 static void cmd_Read32(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
  51 {
  52     struct ata_Unit *unit = (struct ata_Unit *)IOStdReq(io)->io_Unit;
  53
  54     if (AF_Removable == (unit->au_Flags & (AF_Removable | AF_DiscPresent)))
  55     {
  56         D(bug("[ATA%02ld] %s: USUALLY YOU'D WANT TO CHECK IF DISC IS PRESENT FIRST\n", unit->au_UnitNum, __func__));
  57         io->io_Error = TDERR_DiskChanged;
  58         return;
  59     }
  60
  61     ULONG block = IOStdReq(io)->io_Offset;
  62     ULONG count = IOStdReq(io)->io_Length;
  63
  64     D(bug("[ATA%02ld] %s(%08x, %08x)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block, count));
  65
  66     ULONG mask = (1 << unit->au_SectorShift) - 1;
  67
  68     /*
  69         During this IO call it should be sure that both offset and
  70         length are already aligned properly to sector boundaries.
  71     */
  72     if ((block & mask) | (count & mask))
  73     {
  74         D(bug("[ATA%02ld] %s: offset or length not sector-aligned.\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
  75         cmd_Invalid(io, LIBBASE);
  76     }
  77     else
  78     {
  79         block >>= unit->au_SectorShift;
  80         count >>= unit->au_SectorShift;
  81         ULONG cnt = 0;
  82
  83         if ((0 == (unit->au_XferModes & AF_XFER_PACKET)) && ((block + count) > unit->au_Capacity))
  84         {
  85             bug("[ATA%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block, count, unit->au_Capacity);
  86             io->io_Error = IOERR_BADADDRESS;
  87             return;
  88         }
  89
  90         /* Call the Unit's access funtion */
  91         io->io_Error = unit->au_Read32(unit, block, count,
  92             IOStdReq(io)->io_Data, &cnt);
  93
  94         IOStdReq(io)->io_Actual = cnt;
  95     }
  96 }
  97
  98 /*
  99     NSCMD_TD_READ64, TD_READ64 implementation. Basically the same, just packs
 100     the 64 bit offset in both io_Offset (31:0) and io_Actual (63:32)
 101 */
 102 static void cmd_Read64(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 103 {
 104     struct ata_Unit *unit = (struct ata_Unit *)IOStdReq(io)->io_Unit;
 105
 106     if (AF_Removable == (unit->au_Flags & (AF_Removable | AF_DiscPresent)))
 107     {
 108         D(bug("[ATA%02ld] %s: USUALLY YOU'D WANT TO CHECK IF DISC IS PRESENT FIRST\n", unit->au_UnitNum, __func__));
 109         io->io_Error = TDERR_DiskChanged;
 110         return;
 111     }
 112
 113     UQUAD block = IOStdReq(io)->io_Offset | (UQUAD)(IOStdReq(io)->io_Actual) << 32;
 114     ULONG count = IOStdReq(io)->io_Length;
 115
 116     D(bug("[ATA%02ld] %s(%08x-%08x, %08x)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, IOStdReq(io)->io_Actual, IOStdReq(io)->io_Offset, count));
 117
 118     ULONG mask = (1 << unit->au_SectorShift) - 1;
 119
 120     if ((block & (UQUAD)mask) | (count & mask) | (count == 0))
 121     {
 122         D(bug("[ATA%02ld] %s: offset or length not sector-aligned.\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 123         cmd_Invalid(io, LIBBASE);
 124     }
 125     else
 126     {
 127         block >>= unit->au_SectorShift;
 128         count >>= unit->au_SectorShift;
 129         ULONG cnt = 0;
 130
 131         /*
 132             If the sum of sector offset and the sector count doesn't overflow
 133             the 28-bit LBA address, use 32-bit access for speed and simplicity.
 134             Otherwise do the 48-bit LBA addressing.
 135         */
 136         if ((block + count) < 0x0fffffff)
 137         {
 138             if ((0 == (unit->au_XferModes & AF_XFER_PACKET)) && ((block + count) > unit->au_Capacity))
 139             {
 140                 bug("[ATA%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block, count, unit->au_Capacity);
 141                 io->io_Error = IOERR_BADADDRESS;
 142                 return;
 143             }
 144             io->io_Error = unit->au_Read32(unit, (ULONG)(block & 0x0fffffff), count, IOStdReq(io)->io_Data, &cnt);
 145         }
 146         else
 147         {
 148             if ((0 == (unit->au_XferModes & AF_XFER_PACKET)) && ((block + count) > unit->au_Capacity48))
 149             {
 150                 bug("[ATA%02ld] %s: Requested block (%lx:%08lx;%ld) outside disk range (%lx:%08lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block>>32, block&0xfffffffful, count, unit->au_Capacity48>>32, unit->au_Capacity48 & 0xfffffffful);
 151                 io->io_Error = IOERR_BADADDRESS;
 152                 return;
 153             }
 154
 155             io->io_Error = unit->au_Read64(unit, block, count, IOStdReq(io)->io_Data, &cnt);
 156         }
 157
 158         IOStdReq(io)->io_Actual = cnt;
 159     }
 160 }
 161
 162 /* CMD_WRITE implementation */
 163 static void cmd_Write32(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 164 {
 165     struct ata_Unit *unit = (struct ata_Unit *)IOStdReq(io)->io_Unit;
 166
 167     if (AF_Removable == (unit->au_Flags & (AF_Removable | AF_DiscPresent)))
 168     {
 169         D(bug("[ATA%02ld] %s: USUALLY YOU'D WANT TO CHECK IF DISC IS PRESENT FIRST\n", unit->au_UnitNum, __func__));
 170         io->io_Error = TDERR_DiskChanged;
 171         return;
 172     }
 173
 174     ULONG block = IOStdReq(io)->io_Offset;
 175     ULONG count = IOStdReq(io)->io_Length;
 176
 177     D(bug("[ATA%02ld] %s(%08x, %08x)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block, count));
 178
 179     ULONG mask = (1 << unit->au_SectorShift) - 1;
 180
 181     /*
 182         During this IO call it should be sure that both offset and
 183         length are already aligned properly to sector boundaries.
 184     */
 185     if ((block & mask) | (count & mask))
 186     {
 187         D(bug("[ATA%02ld] %s: offset or length not sector-aligned.\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 188         cmd_Invalid(io, LIBBASE);
 189     }
 190     else
 191     {
 192         block >>= unit->au_SectorShift;
 193         count >>= unit->au_SectorShift;
 194         ULONG cnt = 0;
 195
 196         if ((0 == (unit->au_XferModes & AF_XFER_PACKET))
 197             && ((block + count) > unit->au_Capacity))
 198         {
 199             bug("[ATA%02ld] %s: Requested block (%lx;%ld) outside disk range (%lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum,
 200                 __func__,
 201                 block, count, unit->au_Capacity);
 202             io->io_Error = IOERR_BADADDRESS;
 203             return;
 204         }
 205
 206         /* Call the Unit's access funtion */
 207         io->io_Error = unit->au_Write32(unit, block, count,
 208             IOStdReq(io)->io_Data, &cnt);
 209
 210         IOStdReq(io)->io_Actual = cnt;
 211     }
 212 }
 213
 214 /*
 215     NSCMD_TD_WRITE64, TD_WRITE64 implementation. Basically the same, just packs
 216     the 64 bit offset in both io_Offset (31:0) and io_Actual (63:32)
 217 */
 218 static void cmd_Write64(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 219 {
 220     struct ata_Unit *unit = (struct ata_Unit *)IOStdReq(io)->io_Unit;
 221
 222     if (AF_Removable == (unit->au_Flags & (AF_Removable | AF_DiscPresent)))
 223     {
 224         D(bug("[ATA%02ld] %s: USUALLY YOU'D WANT TO CHECK IF DISC IS PRESENT FIRST\n", unit->au_UnitNum, __func__));
 225         io->io_Error = TDERR_DiskChanged;
 226         return;
 227     }
 228
 229     UQUAD block = IOStdReq(io)->io_Offset | (UQUAD)(IOStdReq(io)->io_Actual) << 32;
 230     ULONG count = IOStdReq(io)->io_Length;
 231
 232     D(bug("[ATA%02ld] %s(%08x-%08x, %08x)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, IOStdReq(io)->io_Actual, IOStdReq(io)->io_Offset, count));
 233
 234     ULONG mask = (1 << unit->au_SectorShift) - 1;
 235
 236     if ((block & mask) | (count & mask) | (count==0))
 237     {
 238         D(bug("[ATA%02ld] %s: offset or length not sector-aligned.\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 239         cmd_Invalid(io, LIBBASE);
 240     }
 241     else
 242     {
 243         block >>= unit->au_SectorShift;
 244         count >>= unit->au_SectorShift;
 245         ULONG cnt = 0;
 246
 247         /*
 248             If the sum of sector offset and the sector count doesn't overflow
 249             the 28-bit LBA address, use 32-bit access for speed and simplicity.
 250             Otherwise do the 48-bit LBA addressing.
 251         */
 252         if ((block + count) < 0x0fffffff)
 253         {
 254             if ((0 == (unit->au_XferModes & AF_XFER_PACKET))
 255                 && ((block + count) > unit->au_Capacity))
 256             {
 257                 bug("[ATA%02ld] %s: Requested block (%lx;%ld) outside disk range "
 258                     "(%lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, block, count, unit->au_Capacity);
 259                 io->io_Error = IOERR_BADADDRESS;
 260                 return;
 261             }
 262             io->io_Error = unit->au_Write32(unit, (ULONG)(block & 0x0fffffff),
 263                 count, IOStdReq(io)->io_Data, &cnt);
 264         }
 265         else
 266         {
 267             if ((0 == (unit->au_XferModes & AF_XFER_PACKET))
 268                 && ((block + count) > unit->au_Capacity48))
 269             {
 270                 bug("[ATA%02ld] %s: Requested block (%lx:%08lx;%ld) outside disk "
 271                     "range (%lx:%08lx)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum,
 272                      __func__,
 273                      block>>32, block&0xfffffffful,
 274                      count, unit->au_Capacity48>>32,
 275                      unit->au_Capacity48 & 0xfffffffful);
 276                 io->io_Error = IOERR_BADADDRESS;
 277                 return;
 278             }
 279
 280             io->io_Error = unit->au_Write64(unit, block, count,
 281                 IOStdReq(io)->io_Data, &cnt);
 282         }
 283         IOStdReq(io)->io_Actual = cnt;
 284    }
 285 }
 286
 287
 288 /* use CMD_FLUSH to force all IO waiting commands to abort */
 289 static void cmd_Flush(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 290 {
 291     struct IORequest *msg;
 292     struct ata_Bus *bus = ((struct ata_Unit *)io->io_Unit)->au_Bus;
 293
 294     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 295
 296     Forbid();
 297
 298     while((msg = (struct IORequest *)GetMsg((struct MsgPort *)bus->ab_MsgPort)))
 299     {
 300         msg->io_Error = IOERR_ABORTED;
 301         ReplyMsg((struct Message *)msg);
 302     }
 303
 304     Permit();
 305 }
 306
 307 /*
 308     Internal command used to check whether the media in drive has been changed
 309     since last call. If so, the handlers given by user are called.
 310 */
 311 static void cmd_TestChanged(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 312 {
 313     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 314     struct IORequest *msg;
 315
 316     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 317
 318     if ((unit->au_XferModes & AF_XFER_PACKET) && (unit->au_Flags & AF_Removable))
 319     {
 320         atapi_TestUnitOK(unit);
 321         if (unit->au_Flags & AF_DiscChanged)
 322         {
 323             unit->au_ChangeNum++;
 324
 325             Forbid();
 326
 327             /* old-fashioned RemoveInt call first */
 328             if (unit->au_RemoveInt)
 329                 Cause(unit->au_RemoveInt);
 330
 331             /* And now the whole list of possible calls */
 332             ForeachNode(&unit->au_SoftList, msg)
 333             {
 334                 Cause((struct Interrupt *)IOStdReq(msg)->io_Data);
 335             }
 336
 337             unit->au_Flags &= ~AF_DiscChanged;
 338
 339             Permit();
 340         }
 341     }
 342 }
 343
 344 static void cmd_Update(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 345 {
 346     /* Do nothing now. In near future there should be drive cache flush though */
 347     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 348 }
 349
 350 static void cmd_Remove(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 351 {
 352     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 353
 354     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 355
 356     if (unit->au_RemoveInt)
 357         io->io_Error = TDERR_DriveInUse;
 358     else
 359         unit->au_RemoveInt = IOStdReq(io)->io_Data;
 360 }
 361
 362 static void cmd_ChangeNum(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 363 {
 364     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 365
 366     IOStdReq(io)->io_Actual = ((struct ata_Unit *)io->io_Unit)->au_ChangeNum;
 367 }
 368
 369 static void cmd_ChangeState(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 370 {
 371     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 372
 373     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 374
 375     if (unit->au_Flags & AF_DiscPresent)
 376         IOStdReq(io)->io_Actual = 0;
 377     else
 378         IOStdReq(io)->io_Actual = 1;
 379
 380     D(bug("[ATA%02ld] %s: Media %s\n", unit->au_UnitNum, __func__, IOStdReq(io)->io_Actual ? "ABSENT" : "PRESENT"));
 381 }
 382
 383 static void cmd_ProtStatus(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 384 {
 385     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 386
 387     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 388
 389     if (unit->au_DevType)
 390         IOStdReq(io)->io_Actual = -1;
 391     else
 392         IOStdReq(io)->io_Actual = 0;
 393
 394 }
 395
 396 static void cmd_GetNumTracks(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 397 {
 398     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 399
 400     IOStdReq(io)->io_Actual = ((struct ata_Unit *)io->io_Unit)->au_Cylinders;
 401 }
 402
 403 static void cmd_AddChangeInt(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 404 {
 405     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 406
 407     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 408
 409     Forbid();
 410     AddHead(&unit->au_SoftList, (struct Node *)io);
 411     Permit();
 412
 413     io->io_Flags &= ~IOF_QUICK;
 414     unit->au_Unit.unit_flags &= ~UNITF_ACTIVE;
 415 }
 416
 417 static void cmd_RemChangeInt(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 418 {
 419     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 420
 421     Forbid();
 422     Remove((struct Node *)io);
 423     Permit();
 424 }
 425
 426 static void cmd_Eject(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 427 {
 428     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 429
 430     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 431
 432     IOStdReq(io)->io_Error = unit->au_Eject(unit);
 433     cmd_TestChanged(io, LIBBASE);
 434 }
 435
 436 static void cmd_GetGeometry(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 437 {
 438     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 439
 440     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 441
 442     if (IOStdReq(io)->io_Length == sizeof(struct DriveGeometry))
 443     {
 444         struct DriveGeometry *dg = (struct DriveGeometry *)IOStdReq(io)->io_Data;
 445
 446         dg->dg_SectorSize       = 1 << unit->au_SectorShift;
 447
 448         if (unit->au_Capacity48 != 0)
 449         {
 450             if ((unit->au_Capacity48 >> 32) != 0)
 451                 dg->dg_TotalSectors     = 0xffffffff;
 452             else
 453                 dg->dg_TotalSectors     = unit->au_Capacity48;
 454         }
 455         else
 456             dg->dg_TotalSectors         = unit->au_Capacity;
 457
 458         dg->dg_Cylinders                = unit->au_Cylinders;
 459         dg->dg_CylSectors               = unit->au_Sectors * unit->au_Heads;
 460         dg->dg_Heads                    = unit->au_Heads;
 461         dg->dg_TrackSectors             = unit->au_Sectors;
 462         dg->dg_BufMemType               = MEMF_PUBLIC;
 463         dg->dg_DeviceType               = unit->au_DevType;
 464         if (dg->dg_DeviceType != DG_DIRECT_ACCESS)
 465             dg->dg_Flags                    = (unit->au_Flags & AF_Removable) ? DGF_REMOVABLE : 0;
 466         else
 467             dg->dg_Flags                = 0;
 468         dg->dg_Reserved                 = 0;
 469
 470         IOStdReq(io)->io_Actual = sizeof(struct DriveGeometry);
 471     }
 472     else if (IOStdReq(io)->io_Length == 514)
 473     {
 474         CopyMemQuick(unit->au_Drive, IOStdReq(io)->io_Data, 512);
 475     }
 476     else io->io_Error = TDERR_NotSpecified;
 477 }
 478
 479 static void cmd_DirectScsi(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 480 {
 481     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 482
 483     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 484
 485     IOStdReq(io)->io_Actual = sizeof(struct SCSICmd);
 486     if (unit->au_XferModes & AF_XFER_PACKET)
 487     {
 488         io->io_Error = unit->au_DirectSCSI(unit, (struct SCSICmd *)IOStdReq(io)->io_Data);
 489     }
 490     else if (unit->au_DevType == DG_DIRECT_ACCESS)
 491     {
 492         io->io_Error = SCSIEmu(unit, (struct SCSICmd *)IOStdReq(io)->io_Data);
 493     }
 494     else io->io_Error = IOERR_BADADDRESS;
 495 }
 496
 497 static BOOL ValidSMARTCmd(struct IORequest *io)
 498 {
 499 #if (0)
 500     if ((IOStdReq(io)->io_Reserved1) != (IOStdReq(io)->io_Reserved2))
 501         return FALSE;
 502
 503     switch (IOStdReq(io)->io_Reserved1)
 504     {
 505         case SMARTC_TEST_AVAIL:
 506         case SMARTC_READ_VALUES:
 507         case SMARTC_READ_THRESHOLDS:
 508                     if (!IOStdReq(io)->io_Data)
 509                     {
 510                         D(bug("[ATA%02ld] %s: invalid io_Data (%p)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, IOStdReq(io)->io_Data));
 511                         io->io_Error = IOERR_BADADDRESS;
 512                         return FALSE;
 513                     }
 514                     if ((IOStdReq(io)->io_Offset != SMARTC_TEST_AVAIL) && (IOStdReq(io)->io_Length != SMART_DATA_LENGTH))
 515                     {
 516                         D(bug("[ATA%02ld] %s: invalid io_Length (%d)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, IOStdReq(io)->io_Length));
 517                         io->io_Error = IOERR_BADLENGTH;
 518                         return FALSE;
 519                     }
 520                     break;
 521
 522             case SMARTC_ENABLE:
 523             case SMARTC_DISABLE:
 524             case SMARTC_STATUS:
 525                     break;
 526
 527             default:
 528                     D(bug("[ATA%02ld] %s: invalid SMART command (%d)\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, IOStdReq(io)->io_Offset));
 529                     io->io_Error = IOERR_NOCMD;
 530                     return FALSE;
 531         }
 532 #endif
 533         return TRUE;
 534 }
 535
 536 static void cmd_SMART(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 537 {
 538     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 539 #if (0)
 540     struct ata_Bus *bus = unit->au_Bus;
 541     UBYTE u;
 542 #endif
 543     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 544
 545     if (unit->au_Flags & AF_DiscPresent)
 546     {
 547         io->io_Error = IOERR_OPENFAIL;
 548         return;
 549     }
 550
 551     if (!ValidSMARTCmd(io))
 552         return;
 553 #if (0)
 554     u = unit->au_UnitNum & 1;
 555
 556     if (bus->ab_Dev[u] == DEV_ATA || bus->ab_Dev[u] == DEV_SATA)
 557     {
 558         if (IOStdReq(io)->io_Reserved1 == ATAFEATURE_TEST_AVAIL)
 559         {
 560             if (IOStdReq(io)->io_Length >= sizeof(ULONG))
 561             {
 562                 *((ULONG *)IOStdReq(io)->io_Data) = SMART_MAGIC_ID;
 563                 IOStdReq(io)->io_Actual = sizeof(ULONG);
 564             }
 565             io->io_Error = 0;
 566             return;
 567         }
 568         ata_SMARTCmd(IOStdReq(io));
 569     }
 570     else
 571 #endif
 572         io->io_Error = IOERR_NOCMD;
 573 }
 574
 575 static void cmd_TRIM(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 576 {
 577     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 578
 579     D(bug("[ATA%02ld] %s()\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 580
 581     if ((unit->au_Drive->id_ATAVersion >= 7) && (unit->au_Drive->id_DSManagement & 1))
 582     {
 583         D(bug("[ATA%02ld] %s: Unit supports TRIM\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 584 #if (0)
 585         if (IOStdReq(io)->io_Reserved1 == ATAFEATURE_TEST_AVAIL)
 586         {
 587             if (IOStdReq(io)->io_Length >= sizeof(ULONG))
 588             {
 589                 *((ULONG *)IOStdReq(io)->io_Data) = TRIM_MAGIC_ID;
 590                 IOStdReq(io)->io_Actual = sizeof(ULONG);
 591             }
 592             io->io_Error = 0;
 593             return;
 594         }
 595         ata_TRIMCmd(IOStdReq(io));
 596 #endif
 597     }
 598     else
 599         io->io_Error = IOERR_NOCMD;
 600 }
 601
 602 //-----------------------------------------------------------------------------
 603
 604 /*
 605     command translation tables - used to call proper IO functions.
 606 */
 607
 608 #define N_TD_READ64     0
 609 #define N_TD_WRITE64    1
 610 #define N_TD_SEEK64     2
 611 #define N_TD_FORMAT64   3
 612
 613 typedef void (*mapfunc)(struct IORequest *, LIBBASETYPEPTR);
 614
 615 static mapfunc const map64[]= {
 616     [N_TD_READ64]   = cmd_Read64,
 617     [N_TD_WRITE64]  = cmd_Write64,
 618     [N_TD_SEEK64]   = cmd_Reset,
 619     [N_TD_FORMAT64] = cmd_Write64
 620 };
 621
 622 static mapfunc const map32[] = {
 623     [CMD_INVALID]   = cmd_Invalid,
 624     [CMD_RESET]     = cmd_Reset,
 625     [CMD_READ]      = cmd_Read32,
 626     [CMD_WRITE]     = cmd_Write32,
 627     [CMD_UPDATE]    = cmd_Update,
 628     [CMD_CLEAR]     = cmd_Reset,
 629     [CMD_STOP]      = cmd_Reset,
 630     [CMD_START]     = cmd_Reset,
 631     [CMD_FLUSH]     = cmd_Flush,
 632     [TD_MOTOR]      = cmd_Reset,
 633     [TD_SEEK]       = cmd_Reset,
 634     [TD_FORMAT]     = cmd_Write32,
 635     [TD_REMOVE]     = cmd_Remove,
 636     [TD_CHANGENUM]  = cmd_ChangeNum,
 637     [TD_CHANGESTATE]= cmd_ChangeState,
 638     [TD_PROTSTATUS] = cmd_ProtStatus,
 639     [TD_RAWREAD]    = cmd_Invalid,
 640     [TD_RAWWRITE]   = cmd_Invalid,
 641     [TD_GETNUMTRACKS]       = cmd_GetNumTracks,
 642     [TD_ADDCHANGEINT]       = cmd_AddChangeInt,
 643     [TD_REMCHANGEINT]       = cmd_RemChangeInt,
 644     [TD_GETGEOMETRY]= cmd_GetGeometry,
 645     [TD_EJECT]      = cmd_Eject,
 646     [TD_READ64]     = cmd_Read64,
 647     [TD_WRITE64]    = cmd_Write64,
 648     [TD_SEEK64]     = cmd_Reset,
 649     [TD_FORMAT64]   = cmd_Write64,
 650     [HD_SCSICMD]    = cmd_DirectScsi,
 651     [HD_SCSICMD+1]  = cmd_TestChanged,
 652     [HD_SMARTCMD]    = cmd_SMART,
 653     [HD_TRIMCMD]    = cmd_TRIM
 654 };
 655
 656 static UWORD const NSDSupported[] = {
 657     CMD_RESET,
 658     CMD_READ,
 659     CMD_WRITE,
 660     CMD_UPDATE,
 661     CMD_CLEAR,
 662     CMD_STOP,
 663     CMD_START,
 664     CMD_FLUSH,
 665     TD_MOTOR,
 666     TD_SEEK,
 667     TD_FORMAT,
 668     TD_REMOVE,
 669     TD_CHANGENUM,
 670     TD_CHANGESTATE,
 671     TD_PROTSTATUS,
 672     TD_GETNUMTRACKS,
 673     TD_ADDCHANGEINT,
 674     TD_REMCHANGEINT,
 675     TD_GETGEOMETRY,
 676     TD_EJECT,
 677     TD_READ64,
 678     TD_WRITE64,
 679     TD_SEEK64,
 680     TD_FORMAT64,
 681     HD_SCSICMD,
 682     TD_GETDRIVETYPE,
 683     NSCMD_DEVICEQUERY,
 684     NSCMD_TD_READ64,
 685     NSCMD_TD_WRITE64,
 686     NSCMD_TD_SEEK64,
 687     NSCMD_TD_FORMAT64,
 688     HD_SMARTCMD,
 689     HD_TRIMCMD,
 690     0
 691 };
 692
 693 /*
 694     Do proper IO actions depending on the request. It's called from the bus
 695     tasks and from BeginIO in case of immediate commands.
 696 */
 697 static void HandleIO(struct IORequest *io, LIBBASETYPEPTR LIBBASE)
 698 {
 699     io->io_Error = 0;
 700
 701     /* Handle few commands directly here */
 702     switch (io->io_Command)
 703     {
 704         /*
 705             New Style Devices query. Introduce self as trackdisk and provide list of
 706             commands supported
 707         */
 708         case NSCMD_DEVICEQUERY:
 709             {
 710                 struct NSDeviceQueryResult *nsdq = (struct NSDeviceQueryResult *)IOStdReq(io)->io_Data;
 711                 nsdq->DevQueryFormat    = 0;
 712                 nsdq->SizeAvailable     = sizeof(struct NSDeviceQueryResult);
 713                 nsdq->DeviceType        = NSDEVTYPE_TRACKDISK;
 714                 nsdq->DeviceSubType     = 0;
 715                 nsdq->SupportedCommands = (UWORD *)NSDSupported;
 716             }
 717             IOStdReq(io)->io_Actual = sizeof(struct NSDeviceQueryResult);
 718             break;
 719
 720         /*
 721             New Style Devices report here the 'NSTY' - only if such value is
 722             returned here, the NSCMD_DEVICEQUERY might be called. Otherwice it should
 723             report error.
 724         */
 725         case TD_GETDRIVETYPE:
 726             IOStdReq(io)->io_Actual = DRIVE_NEWSTYLE;
 727             break;
 728
 729         /*
 730             Call all other commands using the command pointer tables for 32- and
 731             64-bit accesses. If requested function is defined call it, otherwise
 732             make the function cmd_Invalid.
 733         */
 734         default:
 735             if ((io->io_Command <= (HD_SCSICMD+1)) || (io->io_Command >= HD_SMARTCMD && io->io_Command <= HD_TRIMCMD))
 736             {
 737                 if (map32[io->io_Command])
 738                     map32[io->io_Command](io, LIBBASE);
 739                 else
 740                     cmd_Invalid(io, LIBBASE);
 741             }
 742             else if (io->io_Command >= NSCMD_TD_READ64 && io->io_Command <= NSCMD_TD_FORMAT64)
 743             {
 744                 if (map64[io->io_Command - NSCMD_TD_READ64])
 745                     map64[io->io_Command - NSCMD_TD_READ64](io, LIBBASE);
 746                 else
 747                     cmd_Invalid(io, LIBBASE);
 748             }
 749             else cmd_Invalid(io, LIBBASE);
 750             break;
 751     }
 752 }
 753
 754
 755 static const ULONG IMMEDIATE_COMMANDS = 0x803ff1e3; // 10000000001111111111000111100011
 756
 757 /* See whether the command can be done quick */
 758 static BOOL isSlow(struct IORequest *io)
 759 {
 760     BOOL slow = TRUE;   /* Assume always slow command */
 761
 762     /* For commands with numbers <= 31 check the mask */
 763     if (io->io_Command <= 31)
 764     {
 765         if (IMMEDIATE_COMMANDS & (1 << io->io_Command))
 766             slow = FALSE;
 767     }
 768 #if(0)
 769     else if ((io->io_Command >= HD_SMARTCMD && io->io_Command <= HD_TRIMCMD) &&
 770                 (IOStdReq(io)->io_Reserved1 == ATAFEATURE_TEST_AVAIL)) slow = FALSE;
 771 #endif
 772     else if (io->io_Command == NSCMD_TD_SEEK64 || io->io_Command == NSCMD_DEVICEQUERY) slow = FALSE;
 773
 774     return slow;
 775 }
 776
 777 /*
 778     Try to do IO commands. All commands which require talking with ata devices
 779     will be handled slow, that is they will be passed to bus task which will
 780     execute them as soon as hardware will be free.
 781 */
 782 AROS_LH1(void, BeginIO,
 783     AROS_LHA(struct IORequest *, io, A1),
 784     LIBBASETYPEPTR, LIBBASE, 5, ata)
 785 {
 786     AROS_LIBFUNC_INIT
 787
 788     struct ata_Unit *unit = (struct ata_Unit *)io->io_Unit;
 789
 790     io->io_Message.mn_Node.ln_Type = NT_MESSAGE;
 791
 792     /* Disable interrupts for a while to modify message flags */
 793     Disable();
 794
 795     D(bug("[ATA%02ld] %s: Executing IO Command %lx\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__, io->io_Command));
 796
 797     /*
 798         If the command is not-immediate, or presence of disc is still unknown,
 799         let the bus task do the job.
 800     */
 801     if (isSlow(io))
 802     {
 803         unit->au_Unit.unit_flags |= UNITF_ACTIVE | UNITF_INTASK;
 804         io->io_Flags &= ~IOF_QUICK;
 805         Enable();
 806
 807         /* Put the message to the bus */
 808         PutMsg(unit->au_Bus->ab_MsgPort, (struct Message *)io);
 809     }
 810     else
 811     {
 812         D(bug("[ATA%02ld] %s: ->Fast command\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 813
 814         /* Immediate command. Mark unit as active and do the command directly */
 815         unit->au_Unit.unit_flags |= UNITF_ACTIVE;
 816         Enable();
 817         HandleIO(io, LIBBASE);
 818
 819         unit->au_Unit.unit_flags &= ~UNITF_ACTIVE;
 820
 821         /*
 822             If the command was not intended to be immediate and it was not the
 823             TD_ADDCHANGEINT, reply to confirm command execution now.
 824         */
 825         if (!(io->io_Flags & IOF_QUICK) && (io->io_Command != TD_ADDCHANGEINT))
 826         {
 827             ReplyMsg((struct Message *)io);
 828         }
 829     }
 830
 831     D(bug("[ATA%02ld] %s: Done\n", ((struct ata_Unit*)io->io_Unit)->au_UnitNum, __func__));
 832     AROS_LIBFUNC_EXIT
 833 }
 834
 835 AROS_LH1(LONG, AbortIO,
 836     AROS_LHA(struct IORequest *, io, A1),
 837     LIBBASETYPEPTR, LIBBASE, 6, ata)
 838 {
 839     AROS_LIBFUNC_INIT
 840
 841     /* Cannot Abort IO */
 842     return 0;
 843
 844     AROS_LIBFUNC_EXIT
 845 }
 846
 847 AROS_LH1(ULONG, GetRdskLba,
 848     AROS_LHA(struct IORequest *, io, A1),
 849     LIBBASETYPEPTR, LIBBASE, 7, ata)
 850 {
 851     AROS_LIBFUNC_INIT
 852
 853     return 0;
 854
 855     AROS_LIBFUNC_EXIT
 856 }
 857
 858 AROS_LH1(ULONG, GetBlkSize,
 859     AROS_LHA(struct IORequest *, io, A1),
 860     LIBBASETYPEPTR, LIBBASE, 8, ata)
 861 {
 862     AROS_LIBFUNC_INIT
 863
 864     return Unit(io)->au_SectorShift;
 865
 866     AROS_LIBFUNC_EXIT
 867 }
 868
 869 /*
 870  * The daemon of ata.device first opens all ATAPI devices and then enters
 871  * endless loop. Every 2 seconds it tells ATAPI units to check the media
 872  * presence. In case of any state change they will rise user-specified
 873  * functions.
 874  * The check is done by sending HD_SCSICMD+1 command (internal testchanged
 875  * command). ATAPI units should already handle the command further.
 876  */
 877 void DaemonCode(struct ataBase *ATABase)
 878 {
 879     struct IORequest *timer;    // timer
 880     UBYTE b = 0;
 881     ULONG sigs;
 882
 883     D(bug("[ATA**] You woke up DAEMON\n"));
 884
 885     /*
 886      * Prepare message ports and timer.device's request
 887      */
 888     timer  = ata_OpenTimer(ATABase);
 889     if (!timer)
 890     {
 891         D(bug("[ATA++] Failed to open timer!\n"));
 892
 893         Forbid();
 894         Signal(ATABase->daemonParent, SIGF_SINGLE);
 895         return;
 896     }
 897
 898     /* Calibrate 400ns delay */
 899     if (!ata_Calibrate(timer, ATABase))
 900     {
 901         ata_CloseTimer(timer);
 902         Forbid();
 903         Signal(ATABase->daemonParent, SIGF_SINGLE);
 904         return;
 905     }
 906
 907     /* This also signals that we have initialized successfully */
 908     ATABase->ata_Daemon = FindTask(NULL);
 909     Signal(ATABase->daemonParent, SIGF_SINGLE);
 910
 911     D(bug("[ATA++] Starting sweep medium presence detection\n"));
 912
 913     /*
 914      * Endless loop
 915      */
 916     do
 917     {
 918         /*
 919          * call separate IORequest for every ATAPI device
 920          * we're calling HD_SCSICMD+1 command here -- anything like test unit ready?
 921          * FIXME: This is not a very nice approach in terms of performance.
 922          * This inserts own command into command queue every 2 seconds, so
 923          * this would give periodic performance drops under high loads.
 924          * It would be much better if unit tasks ping their devices by themselves,
 925          * when idle. This would also save us from lots of headaches with dealing
 926          * with list of these requests. Additionally i start disliking all these
 927          * semaphores.
 928          */
 929         if (0 == (b & 1))
 930         {
 931             struct IOStdReq *ios;
 932
 933             DB2(bug("[ATA++] Detecting media presence\n"));
 934             ObtainSemaphore(&ATABase->DaemonSem);
 935
 936             ForeachNode(&ATABase->Daemon_ios, ios)
 937             {
 938                 /* Using the request will clobber its Node. Save links. */
 939                 struct Node *s = ios->io_Message.mn_Node.ln_Succ;
 940                 struct Node *p = ios->io_Message.mn_Node.ln_Pred;
 941
 942                 DoIO((struct IORequest *)ios);
 943
 944                 ios->io_Message.mn_Node.ln_Succ = s;
 945                 ios->io_Message.mn_Node.ln_Pred = p;
 946             }
 947
 948             ReleaseSemaphore(&ATABase->DaemonSem);
 949         }
 950
 951         /*
 952          * And then hide and wait for 1 second
 953          */
 954         DB2(bug("[ATA++] 1 second delay, timer 0x%p...\n", timer));
 955         sigs = ata_WaitTO(timer, 1, 0, SIGBREAKF_CTRL_C);
 956
 957         DB2(bug("[ATA++] Delay completed\n"));
 958         b++;
 959     } while (!sigs);
 960
 961     D(bug("[ATA++] Daemon quits\n"));
 962
 963     ata_CloseTimer(timer);
 964
 965     Forbid();
 966     Signal(ATABase->daemonParent, SIGF_SINGLE);
 967 }
 968
 969 /*
 970     Bus task body. It doesn't really do much. It receives simply all IORequests
 971     in endless loop and calls proper handling function. The IO is Semaphore-
 972     protected within a bus.
 973 */
 974 void BusTaskCode(struct ata_Bus *bus, struct ataBase *ATABase)
 975 {
 976     ULONG sig;
 977     int iter;
 978     struct IORequest *msg;
 979     OOP_Object *unitObj;
 980     struct ata_Unit *unit;
 981
 982     DINIT(bug("[ATA**] Task started (bus: %u)\n", bus->ab_BusNum));
 983
 984     bus->ab_Timer = ata_OpenTimer(ATABase);
 985     bus->ab_BounceBufferPool = CreatePool(MEMF_CLEAR | MEMF_31BIT, 131072, 65536);
 986
 987     /* Get the signal used for sleeping */
 988     bus->ab_Task = FindTask(0);
 989     bus->ab_SleepySignal = AllocSignal(-1);
 990     /* Failed to get it? Use SIGBREAKB_CTRL_E instead */
 991     if (bus->ab_SleepySignal < 0)
 992         bus->ab_SleepySignal = SIGBREAKB_CTRL_E;
 993
 994     sig = 1L << bus->ab_MsgPort->mp_SigBit;
 995
 996     for (iter = 0; iter < MAX_BUSUNITS; ++iter)
 997     {
 998         DINIT(bug("[ATA**] Device %u type %d\n", iter, bus->ab_Dev[iter]));
 999
1000         if (bus->ab_Dev[iter] > DEV_UNKNOWN)
1001         {
1002             unitObj = OOP_NewObject(ATABase->unitClass, NULL, NULL);
1003             if (unitObj)
1004             {
1005                 unit = OOP_INST_DATA(ATABase->unitClass, unitObj);
1006                 ata_init_unit(bus, unit, iter);
1007                 if (ata_setup_unit(bus, unit))
1008                 {
1009                     /*
1010                      * Add unit to the bus.
1011                      * At this point it becomes visible to OpenDevice().
1012                      */
1013                     bus->ab_Units[iter] = unitObj;
1014
1015                     if (unit->au_XferModes & AF_XFER_PACKET)
1016                     {
1017                         ata_RegisterVolume(0, 0, unit);
1018
1019                         /* For ATAPI device we also submit media presence detection request */
1020                         unit->DaemonReq = (struct IOStdReq *)CreateIORequest(ATABase->DaemonPort, sizeof(struct IOStdReq));
1021                         if (unit->DaemonReq)
1022                         {
1023                             /*
1024                              * We don't want to keep stalled open count of 1, so we
1025                              * don't call OpenDevice() here. Instead we fill in the needed
1026                              * fields manually.
1027                              */
1028                             unit->DaemonReq->io_Device = &ATABase->ata_Device;
1029                             unit->DaemonReq->io_Unit   = &unit->au_Unit;
1030                             unit->DaemonReq->io_Command = HD_SCSICMD+1;
1031
1032                             ObtainSemaphore(&ATABase->DaemonSem);
1033                             AddTail((struct List *)&ATABase->Daemon_ios,
1034                                     &unit->DaemonReq->io_Message.mn_Node);
1035                             ReleaseSemaphore(&ATABase->DaemonSem);
1036                         }
1037                     }
1038                     else
1039                     {
1040                         ata_RegisterVolume(0, unit->au_Cylinders - 1, unit);
1041                     }
1042                 }
1043                 else
1044                 {
1045                     /* Destroy unit that couldn't be initialised */
1046                     OOP_DisposeObject((OOP_Object *)unit);
1047                     bus->ab_Dev[iter] = DEV_NONE;
1048                 }
1049             }
1050         }
1051     }
1052
1053     D(bug("[ATA--] Bus %u scan finished\n", bus->ab_BusNum));
1054     ReleaseSemaphore(&ATABase->DetectionSem);
1055
1056     /* Wait forever and process messages */
1057     for (;;)
1058     {
1059         Wait(sig);
1060
1061         /* Even if you get new signal, do not process it until Unit is not active */
1062         if (!(bus->ab_Flags & UNITF_ACTIVE))
1063         {
1064             bus->ab_Flags |= UNITF_ACTIVE;
1065
1066             /* Empty the request queue */
1067             while ((msg = (struct IORequest *)GetMsg(bus->ab_MsgPort)))
1068             {
1069                 /* And do IO's */
1070                 HandleIO(msg, ATABase);
1071                 /* TD_ADDCHANGEINT doesn't require reply */
1072                 if (msg->io_Command != TD_ADDCHANGEINT)
1073                 {
1074                     ReplyMsg((struct Message *)msg);
1075                 }
1076             }
1077
1078             bus->ab_Flags &= ~(UNITF_INTASK | UNITF_ACTIVE);
1079         }
1080     }
1081 }