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 *
block_to_ata(struct block_device * blockdev)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
ata_command(struct ata_device * ata,struct ata_command * command)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 */
ata_read(struct block_device * blockdev,uint64_t block,unsigned long count,userptr_t buffer)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 */
ata_write(struct block_device * blockdev,uint64_t block,unsigned long count,userptr_t buffer)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 */
ata_identify(struct block_device * blockdev)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 */
init_atadev(struct ata_device * ata)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 }
189