boot/freeldr/freeldr/arch/i386/pcdisk.c

   1 /*
   2  *  FreeLoader
   3  *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <freeldr.h>
  21
  22 #define NDEBUG
  23 #include <debug.h>
  24
  25 #include <pshpack2.h>
  26 typedef struct
  27 {
  28         UCHAR           PacketSize;                             // 00h - Size of packet (10h or 18h)
  29         UCHAR           Reserved;                               // 01h - Reserved (0)
  30         USHORT          LBABlockCount;                  // 02h - Number of blocks to transfer (max 007Fh for Phoenix EDD)
  31         USHORT          TransferBufferOffset;   // 04h - Transfer buffer offset (seg:off)
  32         USHORT          TransferBufferSegment;  //       Transfer buffer segment (seg:off)
  33         ULONGLONG               LBAStartBlock;                  // 08h - Starting absolute block number
  34         //ULONGLONG             TransferBuffer64;               // 10h - (EDD-3.0, optional) 64-bit flat address of transfer buffer
  35                                                                         //       used if DWORD at 04h is FFFFh:FFFFh
  36                                                                         //       Commented since some earlier BIOSes refuse to work with
  37                                                                         //       such extended structure
  38 } I386_DISK_ADDRESS_PACKET, *PI386_DISK_ADDRESS_PACKET;
  39 #include <poppack.h>
  40
  41 /////////////////////////////////////////////////////////////////////////////////////////////
  42 // FUNCTIONS
  43 /////////////////////////////////////////////////////////////////////////////////////////////
  44
  45 static BOOLEAN PcDiskResetController(ULONG DriveNumber)
  46 {
  47         REGS    RegsIn;
  48         REGS    RegsOut;
  49
  50         DPRINTM(DPRINT_DISK, "PcDiskResetController(0x%x) DISK OPERATION FAILED -- RESETTING CONTROLLER\n", DriveNumber);
  51
  52         // BIOS Int 13h, function 0 - Reset disk system
  53         // AH = 00h
  54         // DL = drive (if bit 7 is set both hard disks and floppy disks reset)
  55         // Return:
  56         // AH = status
  57         // CF clear if successful
  58         // CF set on error
  59         RegsIn.b.ah = 0x00;
  60         RegsIn.b.dl = DriveNumber;
  61
  62         // Reset the disk controller
  63         Int386(0x13, &RegsIn, &RegsOut);
  64
  65         return INT386_SUCCESS(RegsOut);
  66 }
  67
  68 static BOOLEAN PcDiskReadLogicalSectorsLBA(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
  69 {
  70         REGS                                            RegsIn;
  71         REGS                                            RegsOut;
  72         ULONG                                                   RetryCount;
  73         PI386_DISK_ADDRESS_PACKET       Packet = (PI386_DISK_ADDRESS_PACKET)(BIOSCALLBUFFER);
  74
  75         DPRINTM(DPRINT_DISK, "PcDiskReadLogicalSectorsLBA() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer);
  76
  77         // BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
  78         RegsIn.b.ah = 0x42;                                     // Subfunction 42h
  79         RegsIn.b.dl = DriveNumber;                      // Drive number in DL (0 - floppy, 0x80 - harddisk)
  80         RegsIn.x.ds = BIOSCALLBUFSEGMENT;       // DS:SI -> disk address packet
  81         RegsIn.w.si = BIOSCALLBUFOFFSET;
  82
  83         // Setup disk address packet
  84         RtlZeroMemory(Packet, sizeof(I386_DISK_ADDRESS_PACKET));
  85         Packet->PacketSize = sizeof(I386_DISK_ADDRESS_PACKET);
  86         Packet->Reserved = 0;
  87         Packet->LBABlockCount = SectorCount;
  88         Packet->TransferBufferOffset = ((ULONG_PTR)Buffer) & 0x0F;
  89         Packet->TransferBufferSegment = ((ULONG_PTR)Buffer) >> 4;
  90         Packet->LBAStartBlock = SectorNumber;
  91
  92         // BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
  93         // Return:
  94         // CF clear if successful
  95         // AH = 00h
  96         // CF set on error
  97         // AH = error code
  98         // disk address packet's block count field set to the
  99         // number of blocks successfully transferred
 100
 101         // Retry 3 times
 102         for (RetryCount=0; RetryCount<3; RetryCount++)
 103         {
 104                 Int386(0x13, &RegsIn, &RegsOut);
 105
 106                 // If it worked return TRUE
 107                 if (INT386_SUCCESS(RegsOut))
 108                 {
 109                         return TRUE;
 110                 }
 111                 // If it was a corrected ECC error then the data is still good
 112                 else if (RegsOut.b.ah == 0x11)
 113                 {
 114                         return TRUE;
 115                 }
 116                 // If it failed the do the next retry
 117                 else
 118                 {
 119                         PcDiskResetController(DriveNumber);
 120
 121                         continue;
 122                 }
 123         }
 124
 125         // If we get here then the read failed
 126         DiskError("Disk Read Failed in LBA mode", RegsOut.b.ah);
 127
 128         return FALSE;
 129 }
 130
 131 static BOOLEAN PcDiskReadLogicalSectorsCHS(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
 132 {
 133         ULONG                   PhysicalSector;
 134         ULONG                   PhysicalHead;
 135         ULONG                   PhysicalTrack;
 136         GEOMETRY        DriveGeometry;
 137         ULONG                   NumberOfSectorsToRead;
 138         REGS            RegsIn;
 139         REGS            RegsOut;
 140         ULONG                   RetryCount;
 141
 142         DPRINTM(DPRINT_DISK, "PcDiskReadLogicalSectorsCHS()\n");
 143
 144         //
 145         // Get the drive geometry
 146         //
 147         if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry) ||
 148             DriveGeometry.Sectors == 0 ||
 149             DriveGeometry.Heads == 0)
 150         {
 151                 return FALSE;
 152         }
 153
 154         while (SectorCount)
 155         {
 156
 157                 //
 158                 // Calculate the physical disk offsets
 159                 //
 160                 PhysicalSector = 1 + (SectorNumber % DriveGeometry.Sectors);
 161                 PhysicalHead = (SectorNumber / DriveGeometry.Sectors) % DriveGeometry.Heads;
 162                 PhysicalTrack = (SectorNumber / DriveGeometry.Sectors) / DriveGeometry.Heads;
 163
 164                 //
 165                 // Calculate how many sectors we need to read this round
 166                 //
 167                 if (PhysicalSector > 1)
 168                 {
 169                         if (SectorCount >= (DriveGeometry.Sectors - (PhysicalSector - 1)))
 170                                 NumberOfSectorsToRead = (DriveGeometry.Sectors - (PhysicalSector - 1));
 171                         else
 172                                 NumberOfSectorsToRead = SectorCount;
 173                 }
 174                 else
 175                 {
 176                         if (SectorCount >= DriveGeometry.Sectors)
 177                                 NumberOfSectorsToRead = DriveGeometry.Sectors;
 178                         else
 179                                 NumberOfSectorsToRead = SectorCount;
 180                 }
 181
 182                 //
 183                 // Make sure the read is within the geometry boundaries
 184                 //
 185                 if ((PhysicalHead >= DriveGeometry.Heads) ||
 186                         (PhysicalTrack >= DriveGeometry.Cylinders) ||
 187                         ((NumberOfSectorsToRead + PhysicalSector) > (DriveGeometry.Sectors + 1)) ||
 188                         (PhysicalSector > DriveGeometry.Sectors))
 189                 {
 190                         DiskError("Disk read exceeds drive geometry limits.", 0);
 191                         return FALSE;
 192                 }
 193
 194                 // BIOS Int 13h, function 2 - Read Disk Sectors
 195                 // AH = 02h
 196                 // AL = number of sectors to read (must be nonzero)
 197                 // CH = low eight bits of cylinder number
 198                 // CL = sector number 1-63 (bits 0-5)
 199                 //      high two bits of cylinder (bits 6-7, hard disk only)
 200                 // DH = head number
 201                 // DL = drive number (bit 7 set for hard disk)
 202                 // ES:BX -> data buffer
 203                 // Return:
 204                 // CF set on error
 205                 // if AH = 11h (corrected ECC error), AL = burst length
 206                 // CF clear if successful
 207                 // AH = status
 208                 // AL = number of sectors transferred
 209                 //  (only valid if CF set for some BIOSes)
 210                 RegsIn.b.ah = 0x02;
 211                 RegsIn.b.al = NumberOfSectorsToRead;
 212                 RegsIn.b.ch = (PhysicalTrack & 0xFF);
 213                 RegsIn.b.cl = (PhysicalSector + ((PhysicalTrack & 0x300) >> 2));
 214                 RegsIn.b.dh = PhysicalHead;
 215                 RegsIn.b.dl = DriveNumber;
 216                 RegsIn.w.es = ((ULONG_PTR)Buffer) >> 4;
 217                 RegsIn.w.bx = ((ULONG_PTR)Buffer) & 0x0F;
 218
 219                 //
 220                 // Perform the read
 221                 // Retry 3 times
 222                 //
 223                 for (RetryCount=0; RetryCount<3; RetryCount++)
 224                 {
 225                         Int386(0x13, &RegsIn, &RegsOut);
 226
 227                         // If it worked break out
 228                         if (INT386_SUCCESS(RegsOut))
 229                         {
 230                                 break;
 231                         }
 232                         // If it was a corrected ECC error then the data is still good
 233                         else if (RegsOut.b.ah == 0x11)
 234                         {
 235                                 break;
 236                         }
 237                         // If it failed the do the next retry
 238                         else
 239                         {
 240                                 PcDiskResetController(DriveNumber);
 241
 242                                 continue;
 243                         }
 244                 }
 245
 246                 // If we retried 3 times then fail
 247                 if (RetryCount >= 3)
 248                 {
 249                         DiskError("Disk Read Failed in CHS mode, after retrying 3 times", RegsOut.b.ah);
 250                         return FALSE;
 251                 }
 252
 253                 // I have learned that not all bioses return
 254                 // the sector read count in the AL register (at least mine doesn't)
 255                 // even if the sectors were read correctly. So instead
 256                 // of checking the sector read count we will rely solely
 257                 // on the carry flag being set on error
 258
 259                 Buffer = (PVOID)((ULONG_PTR)Buffer + (NumberOfSectorsToRead * DriveGeometry.BytesPerSector));
 260                 SectorCount -= NumberOfSectorsToRead;
 261                 SectorNumber += NumberOfSectorsToRead;
 262         }
 263
 264         return TRUE;
 265 }
 266
 267 BOOLEAN PcDiskReadLogicalSectors(ULONG DriveNumber, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
 268 {
 269
 270         DPRINTM(DPRINT_DISK, "PcDiskReadLogicalSectors() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer);
 271
 272         //
 273         // Check to see if it is a fixed disk drive
 274         // If so then check to see if Int13 extensions work
 275         // If they do then use them, otherwise default back to BIOS calls
 276         //
 277         if ((DriveNumber >= 0x80) && DiskInt13ExtensionsSupported(DriveNumber))
 278         {
 279                 DPRINTM(DPRINT_DISK, "Using Int 13 Extensions for read. DiskInt13ExtensionsSupported(%d) = %s\n", DriveNumber, DiskInt13ExtensionsSupported(DriveNumber) ? "TRUE" : "FALSE");
 280
 281                 //
 282                 // LBA is easy, nothing to calculate
 283                 // Just do the read
 284                 //
 285                 return PcDiskReadLogicalSectorsLBA(DriveNumber, SectorNumber, SectorCount, Buffer);
 286         }
 287         else
 288         {
 289                 // LBA is not supported default to the CHS calls
 290                 return PcDiskReadLogicalSectorsCHS(DriveNumber, SectorNumber, SectorCount, Buffer);
 291         }
 292
 293         return TRUE;
 294 }
 295
 296 BOOLEAN
 297 PcDiskGetDriveGeometry(ULONG DriveNumber, PGEOMETRY Geometry)
 298 {
 299   REGS RegsIn;
 300   REGS RegsOut;
 301   ULONG Cylinders;
 302
 303   DPRINTM(DPRINT_DISK, "DiskGetDriveGeometry()\n");
 304
 305   /* BIOS Int 13h, function 08h - Get drive parameters
 306    * AH = 08h
 307    * DL = drive (bit 7 set for hard disk)
 308    * ES:DI = 0000h:0000h to guard against BIOS bugs
 309    * Return:
 310    * CF set on error
 311    * AH = status (07h)
 312    * CF clear if successful
 313    * AH = 00h
 314    * AL = 00h on at least some BIOSes
 315    * BL = drive type (AT/PS2 floppies only)
 316    * CH = low eight bits of maximum cylinder number
 317    * CL = maximum sector number (bits 5-0)
 318    *      high two bits of maximum cylinder number (bits 7-6)
 319    * DH = maximum head number
 320    * DL = number of drives
 321    * ES:DI -> drive parameter table (floppies only)
 322    */
 323   RegsIn.b.ah = 0x08;
 324   RegsIn.b.dl = DriveNumber;
 325   RegsIn.w.es = 0x0000;
 326   RegsIn.w.di = 0x0000;
 327
 328   /* Get drive parameters */
 329   Int386(0x13, &RegsIn, &RegsOut);
 330
 331   if (! INT386_SUCCESS(RegsOut))
 332     {
 333       return FALSE;
 334     }
 335
 336   Cylinders = (RegsOut.b.cl & 0xC0) << 2;
 337   Cylinders += RegsOut.b.ch;
 338   Cylinders++;
 339   Geometry->Cylinders = Cylinders;
 340   Geometry->Heads = RegsOut.b.dh + 1;
 341   Geometry->Sectors = RegsOut.b.cl & 0x3F;
 342   Geometry->BytesPerSector = 512;            /* Just assume 512 bytes per sector */
 343
 344   return TRUE;
 345 }
 346
 347 ULONG
 348 PcDiskGetCacheableBlockCount(ULONG DriveNumber)
 349 {
 350   GEOMETRY      Geometry;
 351
 352   /* If LBA is supported then the block size will be 64 sectors (32k)
 353    * If not then the block size is the size of one track */
 354   if (DiskInt13ExtensionsSupported(DriveNumber))
 355     {
 356       return 64;
 357     }
 358   /* Get the disk geometry
 359    * If this fails then we will just return 1 sector to be safe */
 360   else if (! PcDiskGetDriveGeometry(DriveNumber, &Geometry))
 361     {
 362       return 1;
 363     }
 364   else
 365     {
 366       return Geometry.Sectors;
 367     }
 368 }
 369
 370 BOOLEAN
 371 PcDiskGetBootPath(char *BootPath, unsigned Size)
 372 {
 373   if (PxeInit())
 374     {
 375       strcpy(BootPath, "net(0)");
 376       return 0;
 377     }
 378   return DiskGetBootPath(BootPath, Size);
 379 }
 380
 381 /* EOF */