src/drivers/block/ata.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 FILE_LICENCE ( GPL2_OR_LATER );
  20
  21 #include <stddef.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <errno.h>
  25 #include <byteswap.h>
  26 #include <gpxe/blockdev.h>
  27 #include <gpxe/process.h>
  28 #include <gpxe/ata.h>
  29
  30 /** @file
  31  *
  32  * ATA block device
  33  *
  34  */
  35
  36 static inline __attribute__ (( always_inline )) struct ata_device *
  37 block_to_ata ( struct block_device *blockdev ) {
  38         return container_of ( blockdev, struct ata_device, blockdev );
  39 }
  40
  41 /**
  42  * Issue ATA command
  43  *
  44  * @v ata               ATA device
  45  * @v command           ATA command
  46  * @ret rc              Return status code
  47  */
  48 static inline __attribute__ (( always_inline )) int
  49 ata_command ( struct ata_device *ata, struct ata_command *command ) {
  50         int rc;
  51
  52         DBG ( "ATA cmd %02x dev %02x LBA%s %llx count %04x\n",
  53               command->cb.cmd_stat, command->cb.device,
  54               ( command->cb.lba48 ? "48" : "" ),
  55               ( unsigned long long ) command->cb.lba.native,
  56               command->cb.count.native );
  57
  58         /* Flag command as in-progress */
  59         command->rc = -EINPROGRESS;
  60
  61         /* Issue ATA command */
  62         if ( ( rc = ata->command ( ata, command ) ) != 0 ) {
  63                 /* Something went wrong with the issuing mechanism */
  64                 DBG ( "ATA could not issue command: %s\n", strerror ( rc ) );
  65                 return rc;
  66         }
  67
  68         /* Wait for command to complete */
  69         while ( command->rc == -EINPROGRESS )
  70                 step();
  71         if ( ( rc = command->rc ) != 0 ) {
  72                 /* Something went wrong with the command execution */
  73                 DBG ( "ATA command failed: %s\n", strerror ( rc ) );
  74                 return rc;
  75         }
  76
  77         return 0;
  78 }
  79
  80 /**
  81  * Read block from ATA device
  82  *
  83  * @v blockdev          Block device
  84  * @v block             LBA block number
  85  * @v count             Block count
  86  * @v buffer            Data buffer
  87  * @ret rc              Return status code
  88  */
  89 static int ata_read ( struct block_device *blockdev, uint64_t block,
  90                       unsigned long count, userptr_t buffer ) {
  91         struct ata_device *ata = block_to_ata ( blockdev );
  92         struct ata_command command;
  93
  94         memset ( &command, 0, sizeof ( command ) );
  95         command.cb.lba.native = block;
  96         command.cb.count.native = count;
  97         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
  98         command.cb.lba48 = ata->lba48;
  99         if ( ! ata->lba48 )
 100                 command.cb.device |= command.cb.lba.bytes.low_prev;
 101         command.cb.cmd_stat = ( ata->lba48 ? ATA_CMD_READ_EXT : ATA_CMD_READ );
 102         command.data_in = buffer;
 103         return ata_command ( ata, &command );
 104 }
 105
 106 /**
 107  * Write block to ATA device
 108  *
 109  * @v blockdev          Block device
 110  * @v block             LBA block number
 111  * @v count             Block count
 112  * @v buffer            Data buffer
 113  * @ret rc              Return status code
 114  */
 115 static int ata_write ( struct block_device *blockdev, uint64_t block,
 116                        unsigned long count, userptr_t buffer ) {
 117         struct ata_device *ata = block_to_ata ( blockdev );
 118         struct ata_command command;
 119
 120         memset ( &command, 0, sizeof ( command ) );
 121         command.cb.lba.native = block;
 122         command.cb.count.native = count;
 123         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
 124         command.cb.lba48 = ata->lba48;
 125         if ( ! ata->lba48 )
 126                 command.cb.device |= command.cb.lba.bytes.low_prev;
 127         command.cb.cmd_stat = ( ata->lba48 ?
 128                                 ATA_CMD_WRITE_EXT : ATA_CMD_WRITE );
 129         command.data_out = buffer;
 130         return ata_command ( ata, &command );
 131 }
 132
 133 /**
 134  * Identify ATA device
 135  *
 136  * @v blockdev          Block device
 137  * @ret rc              Return status code
 138  */
 139 static int ata_identify ( struct block_device *blockdev ) {
 140         struct ata_device *ata = block_to_ata ( blockdev );
 141         struct ata_command command;
 142         struct ata_identity identity;
 143         int rc;
 144
 145         /* Issue IDENTIFY */
 146         memset ( &command, 0, sizeof ( command ) );
 147         command.cb.count.native = 1;
 148         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
 149         command.cb.cmd_stat = ATA_CMD_IDENTIFY;
 150         command.data_in = virt_to_user ( &identity );
 151         linker_assert ( sizeof ( identity ) == ATA_SECTOR_SIZE,
 152                         __ata_identity_bad_size__ );
 153         if ( ( rc = ata_command ( ata, &command ) ) != 0 )
 154                 return rc;
 155
 156         /* Fill in block device parameters */
 157         blockdev->blksize = ATA_SECTOR_SIZE;
 158         if ( identity.supports_lba48 & cpu_to_le16 ( ATA_SUPPORTS_LBA48 ) ) {
 159                 ata->lba48 = 1;
 160                 blockdev->blocks = le64_to_cpu ( identity.lba48_sectors );
 161         } else {
 162                 blockdev->blocks = le32_to_cpu ( identity.lba_sectors );
 163         }
 164         return 0;
 165 }
 166
 167 static struct block_device_operations ata_operations = {
 168         .read   = ata_read,
 169         .write  = ata_write
 170 };
 171
 172 /**
 173  * Initialise ATA device
 174  *
 175  * @v ata               ATA device
 176  * @ret rc              Return status code
 177  *
 178  * Initialises an ATA device.  The ata_device::command field and the
 179  * @c ATA_FL_SLAVE portion of the ata_device::flags field must already
 180  * be filled in.  This function will configure ata_device::blockdev,
 181  * including issuing an IDENTIFY DEVICE call to determine the block
 182  * size and total device size.
 183  */
 184 int init_atadev ( struct ata_device *ata ) {
 185         /** Fill in read and write methods, and get device capacity */
 186         ata->blockdev.op = &ata_operations;
 187         return ata_identify ( &ata->blockdev );
 188 }