OSDev.org

BOOL read(HBA_PORT *port, DWORD startl, DWORD starth, DWORD count, WORD *buf)
{
   port->is = (DWORD)-1;      // Clear pending interrupt bits
   int spin = 0; // Spin lock timeout counter
   int slot = find_cmdslot(port);
   term::writeline((size_t)slot, 16);
   if (slot == -1)
   {
      return FALSE;
   }

   HBA_CMD_HEADER *cmdheader = (HBA_CMD_HEADER*)phystovirt(port->clb);
   term::writeline((size_t)cmdheader, 16);
   cmdheader += slot;
   cmdheader->cfl = sizeof(FIS_REG_H2D)/sizeof(DWORD);   // Command FIS size
   cmdheader->w = 0;      // Read from device
   cmdheader->prdtl = (WORD)((count-1)>>4) + 1;   // PRDT entries count

   HBA_CMD_TBL *cmdtbl = (HBA_CMD_TBL*)phystovirt(cmdheader->ctba);
   memset(cmdtbl, 0, sizeof(HBA_CMD_TBL) + (cmdheader->prdtl-1)*sizeof(HBA_PRDT_ENTRY));

   // 8K bytes (16 sectors) per PRDT
   for (int i = 0; i < cmdheader->prdtl-1; i++)   
   {
      cmdtbl->prdt_entry[i].dba = (DWORD)virttophys(buf);
      cmdtbl->prdt_entry[i].dbc = 8*1024;   // 8K bytes
      cmdtbl->prdt_entry[i].i = 1;
      buf += 4*1024;   // 4K words
      count -= 16;   // 16 sectors
   }

   // Last entry
   cmdtbl->prdt_entry[cmdheader->prdtl-1].dba = (DWORD)virttophys(buf);
   cmdtbl->prdt_entry[cmdheader->prdtl-1].dbc = count<<9;   // 512 bytes per sector
   cmdtbl->prdt_entry[cmdheader->prdtl-1].i = 1;

   // Setup command
   FIS_REG_H2D *cmdfis = (FIS_REG_H2D*)phystovirt(&cmdtbl->cfis);

   cmdfis->fis_type = FIS_TYPE_REG_H2D;
   cmdfis->c = 1;   // Command
   cmdfis->command = ATA_CMD_READ_DMA_EX;

   cmdfis->lba0 = (BYTE)startl;
   cmdfis->lba1 = (BYTE)(startl>>8);
   cmdfis->lba2 = (BYTE)(startl>>16);
   cmdfis->device = 1<<6;   // LBA mode

   cmdfis->lba3 = (BYTE)(startl>>24);
   cmdfis->lba4 = (BYTE)starth;
   cmdfis->lba5 = (BYTE)(starth>>8);

    cmdfis->countl = (BYTE)count;
   cmdfis->counth = (BYTE)(count>>8);

   // The below loop waits until the port is no longer busy before issuing a new command
   while ((port->tfd & (ATA_DEV_BUSY | ATA_DEV_DRQ)) && spin < 1000000)
   {
      spin++;
   }
   if (spin == 1000000)
   {
      trace_ahci("Port is hung");
      return FALSE;
   }

   port->ci = 1<<slot;   // Issue command

   // Wait for completion
   while (1)
   {
      // In some longer duration reads, it may be helpful to spin on the DPS bit
      // in the PxIS port field as well (1 << 5)
      if ((port->ci & (1<<slot)) == 0)
         break;
      if (port->is & HBA_PxIS_TFES)   // Task file error
      {
         trace_ahci("Read disk error");
         return FALSE;
      }
   }

   // Check again
   if (port->is & HBA_PxIS_TFES)
   {
      trace_ahci("Read disk error");
      return FALSE;
   }

   return TRUE;
}

// Build PRDT entries
   BufferPointer = Transaction->Address;
   while (BytesLeft > 0) {
      AHCIPrdtEntry_t *Prdt = &CommandTable->PrdtEntry[PrdtIndex];
      size_t TransferLength = MIN(AHCI_PRDT_MAX_LENGTH, BytesLeft);

      // Set buffer information and transfer sizes
      Prdt->DataBaseAddress = LODWORD(BufferPointer);
      Prdt->DataBaseAddressUpper = (sizeof(void*) > 4) ? HIDWORD(BufferPointer) : 0;
      Prdt->Descriptor = (TransferLength - 1); // N - 1

      // Adjust counters
      BufferPointer += TransferLength;
      BytesLeft -= TransferLength;
      PrdtIndex++;

      // If this is the last PRDT packet, set IOC
      if (BytesLeft == 0) {
         Prdt->Descriptor |= AHCI_PRDT_IOC;
      }
   }

   // Update command table to the new command
   Transaction->Device->Port->CommandList->Headers[Transaction->Slot].TableLength = (uint16_t)PrdtIndex;
   Transaction->Device->Port->CommandList->Headers[Transaction->Slot].Flags = (uint16_t)(CommandLength / 4);