fd636458a66c39c0138a3ba15cb1d8bf66a9e53a
[people/sha0/gpxe.git] / 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 <byteswap.h>
25 #include <gpxe/blockdev.h>
26 #include <gpxe/ata.h>
27
28 /** @file
29  *
30  * ATA block device
31  *
32  */
33
34 static inline __attribute__ (( always_inline )) struct ata_device *
35 block_to_ata ( struct block_device *blockdev ) {
36         return container_of ( blockdev, struct ata_device, blockdev );
37 }
38
39 /**
40  * Issue ATA command
41  *
42  * @v ata               ATA device
43  * @v command           ATA command
44  * @ret rc              Return status code
45  */
46 static inline __attribute__ (( always_inline )) int
47 ata_command ( struct ata_device *ata, struct ata_command *command ) {
48         DBG ( "ATA cmd %02x dev %02x LBA%s %llx count %04x\n",
49               command->cb.cmd_stat, command->cb.device,
50               ( command->cb.lba48 ? "48" : "" ),
51               ( unsigned long long ) command->cb.lba.native,
52               command->cb.count.native );
53
54         return ata->command ( ata, command );   
55 }
56
57 /**
58  * Read block from ATA device
59  *
60  * @v blockdev          Block device
61  * @v block             LBA block number
62  * @v count             Block count
63  * @v buffer            Data buffer
64  * @ret rc              Return status code
65  */
66 static int ata_read ( struct block_device *blockdev, uint64_t block,
67                       unsigned long count, userptr_t buffer ) {
68         struct ata_device *ata = block_to_ata ( blockdev );
69         struct ata_command command;
70
71         memset ( &command, 0, sizeof ( command ) );
72         command.cb.lba.native = block;
73         command.cb.count.native = count;
74         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
75         command.cb.lba48 = ata->lba48;
76         if ( ! ata->lba48 )
77                 command.cb.device |= command.cb.lba.bytes.low_prev;
78         command.cb.cmd_stat = ( ata->lba48 ? ATA_CMD_READ_EXT : ATA_CMD_READ );
79         command.data_in = buffer;
80         return ata_command ( ata, &command );
81 }
82
83 /**
84  * Write block to ATA device
85  *
86  * @v blockdev          Block device
87  * @v block             LBA block number
88  * @v count             Block count
89  * @v buffer            Data buffer
90  * @ret rc              Return status code
91  */
92 static int ata_write ( struct block_device *blockdev, uint64_t block,
93                        unsigned long count, userptr_t buffer ) {
94         struct ata_device *ata = block_to_ata ( blockdev );
95         struct ata_command command;
96         
97         memset ( &command, 0, sizeof ( command ) );
98         command.cb.lba.native = block;
99         command.cb.count.native = count;
100         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
101         command.cb.lba48 = ata->lba48;
102         if ( ! ata->lba48 )
103                 command.cb.device |= command.cb.lba.bytes.low_prev;
104         command.cb.cmd_stat = ( ata->lba48 ?
105                                 ATA_CMD_WRITE_EXT : ATA_CMD_WRITE );
106         command.data_out = buffer;
107         return ata_command ( ata, &command );
108 }
109
110 /**
111  * Identify ATA device
112  *
113  * @v blockdev          Block device
114  * @ret rc              Return status code
115  */
116 static int ata_identify ( struct block_device *blockdev ) {
117         struct ata_device *ata = block_to_ata ( blockdev );
118         struct ata_command command;
119         struct ata_identity identity;
120         int rc;
121
122         /* Issue IDENTIFY */
123         memset ( &command, 0, sizeof ( command ) );
124         command.cb.count.native = 1;
125         command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
126         command.cb.cmd_stat = ATA_CMD_IDENTIFY;
127         command.data_in = virt_to_user ( &identity );
128         linker_assert ( sizeof ( identity ) == ATA_SECTOR_SIZE,
129                         __ata_identity_bad_size__ );
130         if ( ( rc = ata_command ( ata, &command ) ) != 0 )
131                 return rc;
132
133         /* Fill in block device parameters */
134         blockdev->blksize = ATA_SECTOR_SIZE;
135         if ( identity.supports_lba48 & cpu_to_le16 ( ATA_SUPPORTS_LBA48 ) ) {
136                 ata->lba48 = 1;
137                 blockdev->blocks = le64_to_cpu ( identity.lba48_sectors );
138         } else {
139                 blockdev->blocks = le32_to_cpu ( identity.lba_sectors );
140         }
141         return 0;
142 }
143
144 static struct block_device_operations ata_operations = {
145         .read   = ata_read,
146         .write  = ata_write
147 };
148
149 /**
150  * Initialise ATA device
151  *
152  * @v ata               ATA device
153  * @ret rc              Return status code
154  *
155  * Initialises an ATA device.  The ata_device::command field and the
156  * @c ATA_FL_SLAVE portion of the ata_device::flags field must already
157  * be filled in.  This function will configure ata_device::blockdev,
158  * including issuing an IDENTIFY DEVICE call to determine the block
159  * size and total device size.
160  */
161 int init_atadev ( struct ata_device *ata ) {
162         /** Fill in read and write methods, and get device capacity */
163         ata->blockdev.op = &ata_operations;
164         return ata_identify ( &ata->blockdev );
165 }