sravan/system76-coreboot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libpayload: New AHCI, ATA and ATAPI drivers

Browse Source 
This adds a new interface for storage devices. A driver for ATA and
ATAPI drives on AHCI host controllers comes along.

The interface is very simple and was designed to match FILO's needs.
It consists of three functions:

  void storage_initialize(void);
  Initializes controllers. Should be called once at startup.

  storage_poll_t storage_probe(size_t dev_num);
     with typedef enum {
            POLL_NO_DEVICE      = -2,
            POLL_ERROR          = -1,
            POLL_NO_MEDIUM      =  0,
            POLL_MEDIUM_PRESENT =  1,
          } storage_poll_t;
  Looks for a drive with number dev_num (drives are counted from
  zero) and polls for a medium in the drive if appropriate.

  int storage_read_blocks512(size_t dev_num,
                             u64 start, size_t count,
                             unsigned char *buf);
  Reads count blocks of 512 bytes from block start of drive dev_num
  into buf.

Change-Id: I1c85796b7f8e379ff3817a61b1837636b57e182b
Signed-off-by: Nico Huber <nico.huber@secunet.com>
Reviewed-on: http://review.coreboot.org/1622
Tested-by: build bot (Jenkins)
Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
Reviewed-by: Peter Stuge <peter@stuge.se>
This commit is contained in:
Nico Huber
2012-08-30 15:36:57 +02:00
committed by Peter Stuge
parent 7baadac403
commit 1f6bd94fa8
13 changed files with 1628 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

233
payloads/libpayload/drivers/storage/ata.c Normal file
View File

@@ -0,0 +1,233 @@
/*
* This file is part of the libpayload project.
*
* Copyright (C) 2012 secunet Security Networks AG
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <libpayload.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <storage/ata.h>
/** Reads non-sector-aligned blocks of 512 bytes. */
static ssize_t ata_read_unaligned(ata_dev_t *const dev,
const lba_t blk_start, size_t blk_count,
u8 *blk_buf)
{
ssize_t ret = 0;
lba_t sec_start;
size_t blk_residue;
u8 *const sec_buf = malloc(dev->sector_size);
if (sec_buf == NULL)
return -1;
const size_t shift = dev->sector_size_shift - 9;
const size_t mask = (dev->sector_size >> 9) - 1;
/* Sector aligned start block. */
const lba_t blk_aligned = blk_start & ~mask;
/* First sector to read from. */
sec_start = blk_aligned >> shift;
/* Calculate and read residue before sector aligned blocks. */
blk_residue = MIN(blk_start - blk_aligned, blk_count);
if (blk_residue) {
if (dev->read_sectors(dev, sec_start, 1, sec_buf) != 1)
goto _free_ret;
const size_t bytes = blk_residue << 9;
memcpy(blk_buf, sec_buf + (dev->sector_size - bytes), bytes);
blk_count -= blk_residue;
blk_buf += bytes;
++sec_start;
ret = blk_residue;
if (blk_count == 0)
goto _free_ret;
}
/* Read all sector aligned blocks. */
const size_t sec_count = (blk_count & ~mask) >> shift;
const int sec_read = dev->read_sectors(
dev, sec_start, sec_count, blk_buf);
if (sec_read < 0)
goto _free_ret;
ret += sec_read << shift;
if (sec_read != sec_count)
goto _free_ret;
/* Calculate and read residue. */
blk_residue = blk_count & mask;
if (blk_residue) {
sec_start += sec_read;
blk_buf += sec_read << dev->sector_size_shift;
if (dev->read_sectors(dev, sec_start, 1, sec_buf) != 1)
goto _free_ret;
const size_t bytes = blk_residue << 9;
memcpy(blk_buf, sec_buf, bytes);
ret += blk_residue;
}
_free_ret:
free(sec_buf);
return ret;
}
static ssize_t ata_read512(storage_dev_t *_dev,
const lba_t start, const size_t count,
unsigned char *const buf)
{
ata_dev_t *const dev = (ata_dev_t *)_dev;
if (dev->read_sectors == NULL) {
printf("ata: No read support implemented.\n");
return -1;
}
if (dev->sector_size == 512) {
return dev->read_sectors(dev, start, count, buf);
} else if (dev->sector_size > 512) {
/* Sector size has to be a power of two. */
const size_t mask = (dev->sector_size >> 9) - 1;
if (!(start & mask) && !(count & mask)) {
const size_t shift = dev->sector_size_shift - 9;
const ssize_t ret = dev->read_sectors(dev,
start >> shift, count >> shift, buf);
if (ret < 0)
return ret;
else
return ret << shift;
} else {
return ata_read_unaligned(dev, start, count, buf);
}
} else {
printf("ata: No support for sectors smaller than 512 bytes.\n");
return -1;
}
}
static ssize_t ata_write512(storage_dev_t *const dev,
const lba_t start, const size_t count,
const unsigned char *const buf)
{
printf("ata: No write support implemented.\n");
return -1;
}
void ata_initialize_storage_ops(ata_dev_t *const dev)
{
dev->storage_dev.read_blocks512 = ata_read512;
dev->storage_dev.write_blocks512 = ata_write512;
}
int ata_set_sector_size(ata_dev_t *const dev, u32 sector_size)
{
if (!sector_size || (sector_size & (sector_size - 1))) {
printf("ata: Sector size is not a power of two (%u).\n",
sector_size);
return -1;
}
dev->sector_size = sector_size;
dev->sector_size_shift = 0;
while (sector_size >>= 1)
++dev->sector_size_shift;
return 0;
}
static int ata_decode_sector_size(ata_dev_t *const dev, const u16 *const id)
{
u32 size;
if ((id[ATA_ID_SECTOR_SIZE] & ((3 << 14) | (1 << 12)))
!= ((1 << 14) | (1 << 12)))
size = DEFAULT_ATA_SECTOR_SIZE;
else
size = (id[ATA_ID_LOGICAL_SECTOR_SIZE] |
(id[ATA_ID_LOGICAL_SECTOR_SIZE + 1] << 16)) << 1;
return ata_set_sector_size(dev, size);
}
/**
* Copies n-1 bytes from src to dest swapping each two bytes, removes
* trailing spaces and terminates dest with '\0'.
*/
char *ata_strncpy(char *const dest, const u16 *const src, const size_t n)
{
int i;
for (i = 0; i < (n - 1); i += 2) {
dest[i] = ((const char *)src)[i + 1];
dest[i + 1] = ((const char *)src)[i];
}
for (i = n - 2; i >= 0; --i)
if (dest[i] != ' ')
break;
dest[i + 1] = '\0';
return dest;
}
int ata_attach_device(ata_dev_t *const dev, const storage_port_t port_type)
{
u16 id[256];
dev->identify_cmd = ATA_IDENTIFY_DEVICE;
if (dev->identify(dev, (u8 *)id))
return -1;
char fw[9], model[41];
ata_strncpy(fw, id + 23, sizeof(fw));
ata_strncpy(model, id + 27, sizeof(model));
printf("ata: Identified %s [%s]\n", model, fw);
#ifdef CONFIG_STORAGE_64BIT_LBA
if (id[ATA_CMDS_AND_FEATURE_SETS + 1] & (1 << 10)) {
printf("ata: Support for LBA-48 enabled.\n");
dev->read_cmd = ATA_READ_DMA_EXT;
} else {
dev->read_cmd = ATA_READ_DMA;
}
#else
dev->read_cmd = ATA_READ_DMA;
#endif
if (ata_decode_sector_size(dev, id))
return -1;
dev->storage_dev.port_type = port_type;
ata_initialize_storage_ops(dev);
return storage_attach_device(&dev->storage_dev);
}