MdeModulePkg/Bus/Usb/UsbBotPei/PeiAtapi.c

   1 /** @file
   2 Pei USB ATATPI command implementations.
   3
   4 Copyright (c) 1999 - 2017, Intel Corporation. All rights reserved.<BR>
   5
   6 This program and the accompanying materials
   7 are licensed and made available under the terms and conditions
   8 of the BSD License which accompanies this distribution.  The
   9 full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "UsbBotPeim.h"
  18 #include "BotPeim.h"
  19
  20 #define MAXSENSEKEY 5
  21
  22 /**
  23   Sends out ATAPI Inquiry Packet Command to the specified device. This command will
  24   return INQUIRY data of the device.
  25
  26   @param PeiServices    The pointer of EFI_PEI_SERVICES.
  27   @param PeiBotDevice   The pointer to PEI_BOT_DEVICE instance.
  28
  29   @retval EFI_SUCCESS       Inquiry command completes successfully.
  30   @retval EFI_DEVICE_ERROR  Inquiry command failed.
  31
  32 **/
  33 EFI_STATUS
  34 PeiUsbInquiry (
  35   IN  EFI_PEI_SERVICES  **PeiServices,
  36   IN  PEI_BOT_DEVICE    *PeiBotDevice
  37   )
  38 {
  39   ATAPI_PACKET_COMMAND  Packet;
  40   EFI_STATUS            Status;
  41   ATAPI_INQUIRY_DATA          Idata;
  42
  43   //
  44   // fill command packet
  45   //
  46   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
  47   ZeroMem (&Idata, sizeof (ATAPI_INQUIRY_DATA));
  48
  49   Packet.Inquiry.opcode             = ATA_CMD_INQUIRY;
  50   Packet.Inquiry.page_code          = 0;
  51   Packet.Inquiry.allocation_length  = 36;
  52
  53   //
  54   // Send scsi INQUIRY command packet.
  55   // According to SCSI Primary Commands-2 spec, host only needs to
  56   // retrieve the first 36 bytes for standard INQUIRY data.
  57   //
  58   Status = PeiAtapiCommand (
  59             PeiServices,
  60             PeiBotDevice,
  61             &Packet,
  62             (UINT8) sizeof (ATAPI_PACKET_COMMAND),
  63             &Idata,
  64             36,
  65             EfiUsbDataIn,
  66             2000
  67             );
  68
  69   if (EFI_ERROR (Status)) {
  70     return EFI_DEVICE_ERROR;
  71   }
  72
  73   if ((Idata.peripheral_type & 0x1f) == 0x05) {
  74     PeiBotDevice->DeviceType      = USBCDROM;
  75     PeiBotDevice->Media.BlockSize = 0x800;
  76     PeiBotDevice->Media2.ReadOnly       = TRUE;
  77     PeiBotDevice->Media2.RemovableMedia = TRUE;
  78     PeiBotDevice->Media2.BlockSize      = 0x800;
  79   } else {
  80     PeiBotDevice->DeviceType      = USBFLOPPY;
  81     PeiBotDevice->Media.BlockSize = 0x200;
  82     PeiBotDevice->Media2.ReadOnly       = FALSE;
  83     PeiBotDevice->Media2.RemovableMedia = TRUE;
  84     PeiBotDevice->Media2.BlockSize      = 0x200;
  85   }
  86
  87   return EFI_SUCCESS;
  88 }
  89
  90 /**
  91   Sends out ATAPI Test Unit Ready Packet Command to the specified device
  92   to find out whether device is accessible.
  93
  94   @param PeiServices    The pointer of EFI_PEI_SERVICES.
  95   @param PeiBotDevice   The pointer to PEI_BOT_DEVICE instance.
  96
  97   @retval EFI_SUCCESS        TestUnit command executed successfully.
  98   @retval EFI_DEVICE_ERROR   Device cannot be executed TestUnit command successfully.
  99
 100 **/
 101 EFI_STATUS
 102 PeiUsbTestUnitReady (
 103   IN  EFI_PEI_SERVICES  **PeiServices,
 104   IN  PEI_BOT_DEVICE    *PeiBotDevice
 105   )
 106 {
 107   ATAPI_PACKET_COMMAND  Packet;
 108   EFI_STATUS            Status;
 109
 110   //
 111   // fill command packet
 112   //
 113   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
 114   Packet.TestUnitReady.opcode = ATA_CMD_TEST_UNIT_READY;
 115
 116   //
 117   // send command packet
 118   //
 119   Status = PeiAtapiCommand (
 120             PeiServices,
 121             PeiBotDevice,
 122             &Packet,
 123             (UINT8) sizeof (ATAPI_PACKET_COMMAND),
 124             NULL,
 125             0,
 126             EfiUsbNoData,
 127             2000
 128             );
 129
 130   if (EFI_ERROR (Status)) {
 131     return EFI_DEVICE_ERROR;
 132   }
 133
 134   return EFI_SUCCESS;
 135 }
 136
 137 /**
 138   Sends out ATAPI Request Sense Packet Command to the specified device.
 139
 140   @param PeiServices    The pointer of EFI_PEI_SERVICES.
 141   @param PeiBotDevice   The pointer to PEI_BOT_DEVICE instance.
 142   @param SenseCounts    Length of sense buffer.
 143   @param SenseKeyBuffer Pointer to sense buffer.
 144
 145   @retval EFI_SUCCESS           Command executed successfully.
 146   @retval EFI_DEVICE_ERROR      Some device errors happen.
 147
 148 **/
 149 EFI_STATUS
 150 PeiUsbRequestSense (
 151   IN  EFI_PEI_SERVICES  **PeiServices,
 152   IN  PEI_BOT_DEVICE    *PeiBotDevice,
 153   OUT UINTN             *SenseCounts,
 154   IN  UINT8             *SenseKeyBuffer
 155   )
 156 {
 157   EFI_STATUS                  Status;
 158   ATAPI_PACKET_COMMAND        Packet;
 159   UINT8                       *Ptr;
 160   BOOLEAN                     SenseReq;
 161   ATAPI_REQUEST_SENSE_DATA    *Sense;
 162
 163   *SenseCounts = 0;
 164
 165   //
 166   // fill command packet for Request Sense Packet Command
 167   //
 168   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
 169   Packet.RequestSence.opcode            = ATA_CMD_REQUEST_SENSE;
 170   Packet.RequestSence.allocation_length = (UINT8) sizeof (ATAPI_REQUEST_SENSE_DATA);
 171
 172   Ptr = SenseKeyBuffer;
 173
 174   SenseReq = TRUE;
 175
 176   //
 177   //  request sense data from device continuously
 178   //  until no sense data exists in the device.
 179   //
 180   while (SenseReq) {
 181     Sense = (ATAPI_REQUEST_SENSE_DATA *) Ptr;
 182
 183     //
 184     // send out Request Sense Packet Command and get one Sense
 185     // data form device.
 186     //
 187     Status = PeiAtapiCommand (
 188               PeiServices,
 189               PeiBotDevice,
 190               &Packet,
 191               (UINT8) sizeof (ATAPI_PACKET_COMMAND),
 192               (VOID *) Ptr,
 193               sizeof (ATAPI_REQUEST_SENSE_DATA),
 194               EfiUsbDataIn,
 195               2000
 196               );
 197
 198     //
 199     // failed to get Sense data
 200     //
 201     if (EFI_ERROR (Status)) {
 202       if (*SenseCounts == 0) {
 203         return EFI_DEVICE_ERROR;
 204       } else {
 205         return EFI_SUCCESS;
 206       }
 207     }
 208
 209     if (Sense->sense_key != ATA_SK_NO_SENSE) {
 210
 211       Ptr += sizeof (ATAPI_REQUEST_SENSE_DATA);
 212       //
 213       // Ptr is byte based pointer
 214       //
 215       (*SenseCounts)++;
 216
 217       if (*SenseCounts == MAXSENSEKEY) {
 218         break;
 219       }
 220
 221     } else {
 222       //
 223       // when no sense key, skip out the loop
 224       //
 225       SenseReq = FALSE;
 226     }
 227   }
 228
 229   return EFI_SUCCESS;
 230 }
 231
 232 /**
 233   Sends out ATAPI Read Capacity Packet Command to the specified device.
 234   This command will return the information regarding the capacity of the
 235   media in the device.
 236
 237   @param PeiServices    The pointer of EFI_PEI_SERVICES.
 238   @param PeiBotDevice   The pointer to PEI_BOT_DEVICE instance.
 239
 240   @retval EFI_SUCCESS           Command executed successfully.
 241   @retval EFI_DEVICE_ERROR      Some device errors happen.
 242
 243 **/
 244 EFI_STATUS
 245 PeiUsbReadCapacity (
 246   IN  EFI_PEI_SERVICES  **PeiServices,
 247   IN  PEI_BOT_DEVICE    *PeiBotDevice
 248   )
 249 {
 250   EFI_STATUS                  Status;
 251   ATAPI_PACKET_COMMAND        Packet;
 252   ATAPI_READ_CAPACITY_DATA    Data;
 253   UINT32                      LastBlock;
 254
 255   ZeroMem (&Data, sizeof (ATAPI_READ_CAPACITY_DATA));
 256   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
 257
 258   Packet.Inquiry.opcode = ATA_CMD_READ_CAPACITY;
 259
 260   //
 261   // send command packet
 262   //
 263   Status = PeiAtapiCommand (
 264             PeiServices,
 265             PeiBotDevice,
 266             &Packet,
 267             (UINT8) sizeof (ATAPI_PACKET_COMMAND),
 268             (VOID *) &Data,
 269             sizeof (ATAPI_READ_CAPACITY_DATA),
 270             EfiUsbDataIn,
 271             2000
 272             );
 273
 274   if (EFI_ERROR (Status)) {
 275     return EFI_DEVICE_ERROR;
 276   }
 277   LastBlock = ((UINT32) Data.LastLba3 << 24) | (Data.LastLba2 << 16) | (Data.LastLba1 << 8) | Data.LastLba0;
 278
 279   if (LastBlock == 0xFFFFFFFF) {
 280     DEBUG ((EFI_D_INFO, "The usb device LBA count is larger than 0xFFFFFFFF!\n"));
 281   }
 282
 283   PeiBotDevice->Media.LastBlock    = LastBlock;
 284   PeiBotDevice->Media.MediaPresent = TRUE;
 285
 286   PeiBotDevice->Media2.LastBlock    = LastBlock;
 287   PeiBotDevice->Media2.MediaPresent = TRUE;
 288
 289   return EFI_SUCCESS;
 290 }
 291
 292 /**
 293   Sends out ATAPI Read Format Capacity Data Command to the specified device.
 294   This command will return the information regarding the capacity of the
 295   media in the device.
 296
 297   @param PeiServices    The pointer of EFI_PEI_SERVICES.
 298   @param PeiBotDevice   The pointer to PEI_BOT_DEVICE instance.
 299
 300   @retval EFI_SUCCESS           Command executed successfully.
 301   @retval EFI_DEVICE_ERROR      Some device errors happen.
 302
 303 **/
 304 EFI_STATUS
 305 PeiUsbReadFormattedCapacity (
 306   IN  EFI_PEI_SERVICES  **PeiServices,
 307   IN  PEI_BOT_DEVICE    *PeiBotDevice
 308   )
 309 {
 310   EFI_STATUS                      Status;
 311   ATAPI_PACKET_COMMAND            Packet;
 312   ATAPI_READ_FORMAT_CAPACITY_DATA FormatData;
 313   UINT32                          LastBlock;
 314
 315   ZeroMem (&FormatData, sizeof (ATAPI_READ_FORMAT_CAPACITY_DATA));
 316   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
 317
 318   Packet.ReadFormatCapacity.opcode                = ATA_CMD_READ_FORMAT_CAPACITY;
 319   Packet.ReadFormatCapacity.allocation_length_lo  = 12;
 320
 321   //
 322   // send command packet
 323   //
 324   Status = PeiAtapiCommand (
 325             PeiServices,
 326             PeiBotDevice,
 327             &Packet,
 328             (UINT8) sizeof (ATAPI_PACKET_COMMAND),
 329             (VOID *) &FormatData,
 330             sizeof (ATAPI_READ_FORMAT_CAPACITY_DATA),
 331             EfiUsbDataIn,
 332             2000
 333             );
 334
 335   if (EFI_ERROR (Status)) {
 336     return EFI_DEVICE_ERROR;
 337   }
 338
 339   if (FormatData.DesCode == 3) {
 340     //
 341     // Media is not present
 342     //
 343     PeiBotDevice->Media.MediaPresent  = FALSE;
 344     PeiBotDevice->Media.LastBlock     = 0;
 345     PeiBotDevice->Media2.MediaPresent  = FALSE;
 346     PeiBotDevice->Media2.LastBlock     = 0;
 347
 348   } else {
 349     LastBlock = ((UINT32) FormatData.LastLba3 << 24) | (FormatData.LastLba2 << 16) | (FormatData.LastLba1 << 8) | FormatData.LastLba0;
 350     if (LastBlock == 0xFFFFFFFF) {
 351       DEBUG ((EFI_D_INFO, "The usb device LBA count is larger than 0xFFFFFFFF!\n"));
 352     }
 353
 354     PeiBotDevice->Media.LastBlock = LastBlock;
 355
 356     PeiBotDevice->Media.LastBlock--;
 357
 358     PeiBotDevice->Media.MediaPresent = TRUE;
 359
 360     PeiBotDevice->Media2.MediaPresent = TRUE;
 361     PeiBotDevice->Media2.LastBlock    = PeiBotDevice->Media.LastBlock;
 362   }
 363
 364   return EFI_SUCCESS;
 365 }
 366
 367 /**
 368   Execute Read(10) ATAPI command on a specific SCSI target.
 369
 370   Executes the ATAPI Read(10) command on the ATAPI target specified by PeiBotDevice.
 371
 372   @param PeiServices       The pointer of EFI_PEI_SERVICES.
 373   @param PeiBotDevice      The pointer to PEI_BOT_DEVICE instance.
 374   @param Buffer            The pointer to data buffer.
 375   @param Lba               The start logic block address of reading.
 376   @param NumberOfBlocks    The block number of reading.
 377
 378   @retval EFI_SUCCESS           Command executed successfully.
 379   @retval EFI_DEVICE_ERROR      Some device errors happen.
 380
 381 **/
 382 EFI_STATUS
 383 PeiUsbRead10 (
 384   IN  EFI_PEI_SERVICES  **PeiServices,
 385   IN  PEI_BOT_DEVICE    *PeiBotDevice,
 386   IN  VOID              *Buffer,
 387   IN  EFI_PEI_LBA       Lba,
 388   IN  UINTN             NumberOfBlocks
 389   )
 390 {
 391   ATAPI_PACKET_COMMAND  Packet;
 392   ATAPI_READ10_CMD      *Read10Packet;
 393   UINT16                MaxBlock;
 394   UINT16                BlocksRemaining;
 395   UINT16                SectorCount;
 396   UINT32                Lba32;
 397   UINT32                BlockSize;
 398   UINT32                ByteCount;
 399   VOID                  *PtrBuffer;
 400   EFI_STATUS            Status;
 401   UINT16                TimeOut;
 402
 403   //
 404   // prepare command packet for the Inquiry Packet Command.
 405   //
 406   ZeroMem (&Packet, sizeof (ATAPI_PACKET_COMMAND));
 407   Read10Packet    = &Packet.Read10;
 408   Lba32           = (UINT32) Lba;
 409   PtrBuffer       = Buffer;
 410
 411   BlockSize       = (UINT32) PeiBotDevice->Media.BlockSize;
 412
 413   MaxBlock        = (UINT16) (65535 / BlockSize);
 414   BlocksRemaining = (UINT16) NumberOfBlocks;
 415
 416   Status          = EFI_SUCCESS;
 417   while (BlocksRemaining > 0) {
 418
 419     if (BlocksRemaining <= MaxBlock) {
 420
 421       SectorCount = BlocksRemaining;
 422
 423     } else {
 424
 425       SectorCount = MaxBlock;
 426     }
 427     //
 428     // fill the Packet data structure
 429     //
 430     Read10Packet->opcode = ATA_CMD_READ_10;
 431
 432     //
 433     // Lba0 ~ Lba3 specify the start logical block address of the data transfer.
 434     // Lba0 is MSB, Lba3 is LSB
 435     //
 436     Read10Packet->Lba3  = (UINT8) (Lba32 & 0xff);
 437     Read10Packet->Lba2  = (UINT8) (Lba32 >> 8);
 438     Read10Packet->Lba1  = (UINT8) (Lba32 >> 16);
 439     Read10Packet->Lba0  = (UINT8) (Lba32 >> 24);
 440
 441     //
 442     // TranLen0 ~ TranLen1 specify the transfer length in block unit.
 443     // TranLen0 is MSB, TranLen is LSB
 444     //
 445     Read10Packet->TranLen1  = (UINT8) (SectorCount & 0xff);
 446     Read10Packet->TranLen0  = (UINT8) (SectorCount >> 8);
 447
 448     ByteCount               = SectorCount * BlockSize;
 449
 450     TimeOut                 = (UINT16) (SectorCount * 2000);
 451
 452     //
 453     // send command packet
 454     //
 455     Status = PeiAtapiCommand (
 456               PeiServices,
 457               PeiBotDevice,
 458               &Packet,
 459               (UINT8) sizeof (ATAPI_PACKET_COMMAND),
 460               (VOID *) PtrBuffer,
 461               ByteCount,
 462               EfiUsbDataIn,
 463               TimeOut
 464               );
 465
 466     if (Status != EFI_SUCCESS) {
 467       return Status;
 468     }
 469
 470     Lba32 += SectorCount;
 471     PtrBuffer       = (UINT8 *) PtrBuffer + SectorCount * BlockSize;
 472     BlocksRemaining = (UINT16) (BlocksRemaining - SectorCount);
 473   }
 474
 475   return Status;
 476 }
 477
 478 /**
 479   Check if there is media according to sense data.
 480
 481   @param  SenseData   Pointer to sense data.
 482   @param  SenseCounts Count of sense data.
 483
 484   @retval TRUE    No media
 485   @retval FALSE   Media exists
 486
 487 **/
 488 BOOLEAN
 489 IsNoMedia (
 490   IN  ATAPI_REQUEST_SENSE_DATA *SenseData,
 491   IN  UINTN                    SenseCounts
 492   )
 493 {
 494   ATAPI_REQUEST_SENSE_DATA  *SensePtr;
 495   UINTN                     Index;
 496   BOOLEAN                   NoMedia;
 497
 498   NoMedia   = FALSE;
 499   SensePtr  = SenseData;
 500
 501   for (Index = 0; Index < SenseCounts; Index++) {
 502
 503     switch (SensePtr->sense_key) {
 504
 505     case ATA_SK_NOT_READY:
 506       switch (SensePtr->addnl_sense_code) {
 507       //
 508       // if no media, fill IdeDev parameter with specific info.
 509       //
 510       case ATA_ASC_NO_MEDIA:
 511         NoMedia = TRUE;
 512         break;
 513
 514       default:
 515         break;
 516       }
 517       break;
 518
 519     default:
 520       break;
 521     }
 522
 523     SensePtr++;
 524   }
 525
 526   return NoMedia;
 527 }
 528
 529 /**
 530   Check if there is media error according to sense data.
 531
 532   @param  SenseData   Pointer to sense data.
 533   @param  SenseCounts Count of sense data.
 534
 535   @retval TRUE    Media error
 536   @retval FALSE   No media error
 537
 538 **/
 539 BOOLEAN
 540 IsMediaError (
 541   IN  ATAPI_REQUEST_SENSE_DATA    *SenseData,
 542   IN  UINTN                       SenseCounts
 543   )
 544 {
 545   ATAPI_REQUEST_SENSE_DATA  *SensePtr;
 546   UINTN                     Index;
 547   BOOLEAN                   Error;
 548
 549   SensePtr  = SenseData;
 550   Error     = FALSE;
 551
 552   for (Index = 0; Index < SenseCounts; Index++) {
 553
 554     switch (SensePtr->sense_key) {
 555     //
 556     // Medium error case
 557     //
 558     case ATA_SK_MEDIUM_ERROR:
 559       switch (SensePtr->addnl_sense_code) {
 560       case ATA_ASC_MEDIA_ERR1:
 561         //
 562         // fall through
 563         //
 564       case ATA_ASC_MEDIA_ERR2:
 565         //
 566         // fall through
 567         //
 568       case ATA_ASC_MEDIA_ERR3:
 569         //
 570         // fall through
 571         //
 572       case ATA_ASC_MEDIA_ERR4:
 573         Error = TRUE;
 574         break;
 575
 576       default:
 577         break;
 578       }
 579
 580       break;
 581
 582     //
 583     // Medium upside-down case
 584     //
 585     case ATA_SK_NOT_READY:
 586       switch (SensePtr->addnl_sense_code) {
 587       case ATA_ASC_MEDIA_UPSIDE_DOWN:
 588         Error = TRUE;
 589         break;
 590
 591       default:
 592         break;
 593       }
 594       break;
 595
 596     default:
 597       break;
 598     }
 599
 600     SensePtr++;
 601   }
 602
 603   return Error;
 604 }
 605
 606 /**
 607   Check if media is changed according to sense data.
 608
 609   @param  SenseData   Pointer to sense data.
 610   @param  SenseCounts Count of sense data.
 611
 612   @retval TRUE    There is media change event.
 613   @retval FALSE   media is NOT changed.
 614
 615 **/
 616 BOOLEAN
 617 IsMediaChange (
 618   IN  ATAPI_REQUEST_SENSE_DATA *SenseData,
 619   IN  UINTN                    SenseCounts
 620   )
 621 {
 622   ATAPI_REQUEST_SENSE_DATA  *SensePtr;
 623   UINTN                     Index;
 624   BOOLEAN                   MediaChange;
 625
 626   MediaChange = FALSE;
 627
 628   SensePtr    = SenseData;
 629
 630   for (Index = 0; Index < SenseCounts; Index++) {
 631     //
 632     // catch media change sense key and addition sense data
 633     //
 634     switch (SensePtr->sense_key) {
 635     case ATA_SK_UNIT_ATTENTION:
 636       switch (SensePtr->addnl_sense_code) {
 637       case ATA_ASC_MEDIA_CHANGE:
 638         MediaChange = TRUE;
 639         break;
 640
 641       default:
 642         break;
 643       }
 644       break;
 645
 646     default:
 647       break;
 648     }
 649
 650     SensePtr++;
 651   }
 652
 653   return MediaChange;
 654 }