5431233f968c7f364e4fe5fe216a41617f31f3b2
[people/sha0/gpxe.git] / src / drivers / block / scsi.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 <byteswap.h>
24 #include <errno.h>
25 #include <gpxe/blockdev.h>
26 #include <gpxe/scsi.h>
27
28 /** @file
29  *
30  * SCSI block device
31  *
32  */
33
34 /** Maximum number of dummy "read capacity (10)" operations
35  *
36  * These are issued at connection setup to draw out various useless
37  * power-on messages.
38  */
39 #define SCSI_MAX_DUMMY_READ_CAP 10
40
41 static inline __attribute__ (( always_inline )) struct scsi_device *
42 block_to_scsi ( struct block_device *blockdev ) {
43         return container_of ( blockdev, struct scsi_device, blockdev );
44 }
45
46 /**
47  * Issue SCSI command
48  *
49  * @v scsi              SCSI device
50  * @v command           SCSI command
51  * @ret rc              Return status code
52  */
53 static int scsi_command ( struct scsi_device *scsi,
54                           struct scsi_command *command ) {
55         int rc;
56
57         /* Clear sense response code before issuing command */
58         command->sense_response = 0;
59
60         /* Issue SCSI command */
61         if ( ( rc = scsi->command ( scsi, command ) ) != 0 ) {
62                 /* Something went wrong with the issuing mechanism,
63                  * (rather than with the command itself)
64                  */
65                 DBG ( "SCSI %p " SCSI_CDB_FORMAT " err %s\n",
66                       scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) );
67                 return rc;
68         }
69
70         /* Check for SCSI errors */
71         if ( command->status != 0 ) {
72                 DBG ( "SCSI %p " SCSI_CDB_FORMAT " status %02x sense %02x\n",
73                       scsi, SCSI_CDB_DATA ( command->cdb ),
74                       command->status, command->sense_response );
75                 return -EIO;
76         }
77
78         return 0;
79 }
80
81 /**
82  * Read block from SCSI device using READ (10)
83  *
84  * @v blockdev          Block device
85  * @v block             LBA block number
86  * @v count             Block count
87  * @v buffer            Data buffer
88  * @ret rc              Return status code
89  */
90 static int scsi_read_10 ( struct block_device *blockdev, uint64_t block,
91                           unsigned long count, userptr_t buffer ) {
92         struct scsi_device *scsi = block_to_scsi ( blockdev );
93         struct scsi_command command;
94         struct scsi_cdb_read_10 *cdb = &command.cdb.read10;
95
96         /* Issue READ (10) */
97         memset ( &command, 0, sizeof ( command ) );
98         cdb->opcode = SCSI_OPCODE_READ_10;
99         cdb->lba = cpu_to_be32 ( block );
100         cdb->len = cpu_to_be16 ( count );
101         command.data_in = buffer;
102         command.data_in_len = ( count * blockdev->blksize );
103         return scsi_command ( scsi, &command );
104 }
105
106 /**
107  * Read block from SCSI device using READ (16)
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 scsi_read_16 ( struct block_device *blockdev, uint64_t block,
116                           unsigned long count, userptr_t buffer ) {
117         struct scsi_device *scsi = block_to_scsi ( blockdev );
118         struct scsi_command command;
119         struct scsi_cdb_read_16 *cdb = &command.cdb.read16;
120
121         /* Issue READ (16) */
122         memset ( &command, 0, sizeof ( command ) );
123         cdb->opcode = SCSI_OPCODE_READ_16;
124         cdb->lba = cpu_to_be64 ( block );
125         cdb->len = cpu_to_be32 ( count );
126         command.data_in = buffer;
127         command.data_in_len = ( count * blockdev->blksize );
128         return scsi_command ( scsi, &command );
129 }
130
131 /**
132  * Write block to SCSI device using WRITE (10)
133  *
134  * @v blockdev          Block device
135  * @v block             LBA block number
136  * @v count             Block count
137  * @v buffer            Data buffer
138  * @ret rc              Return status code
139  */
140 static int scsi_write_10 ( struct block_device *blockdev, uint64_t block,
141                            unsigned long count, userptr_t buffer ) {
142         struct scsi_device *scsi = block_to_scsi ( blockdev );
143         struct scsi_command command;
144         struct scsi_cdb_write_10 *cdb = &command.cdb.write10;
145
146         /* Issue WRITE (10) */
147         memset ( &command, 0, sizeof ( command ) );
148         cdb->opcode = SCSI_OPCODE_WRITE_10;
149         cdb->lba = cpu_to_be32 ( block );
150         cdb->len = cpu_to_be16 ( count );
151         command.data_out = buffer;
152         command.data_out_len = ( count * blockdev->blksize );
153         return scsi_command ( scsi, &command );
154 }
155
156 /**
157  * Write block to SCSI device using WRITE (16)
158  *
159  * @v blockdev          Block device
160  * @v block             LBA block number
161  * @v count             Block count
162  * @v buffer            Data buffer
163  * @ret rc              Return status code
164  */
165 static int scsi_write_16 ( struct block_device *blockdev, uint64_t block,
166                            unsigned long count, userptr_t buffer ) {
167         struct scsi_device *scsi = block_to_scsi ( blockdev );
168         struct scsi_command command;
169         struct scsi_cdb_write_16 *cdb = &command.cdb.write16;
170
171         /* Issue WRITE (16) */
172         memset ( &command, 0, sizeof ( command ) );
173         cdb->opcode = SCSI_OPCODE_WRITE_16;
174         cdb->lba = cpu_to_be64 ( block );
175         cdb->len = cpu_to_be32 ( count );
176         command.data_out = buffer;
177         command.data_out_len = ( count * blockdev->blksize );
178         return scsi_command ( scsi, &command );
179 }
180
181 /**
182  * Read capacity of SCSI device via READ CAPACITY (10)
183  *
184  * @v blockdev          Block device
185  * @ret rc              Return status code
186  */
187 static int scsi_read_capacity_10 ( struct block_device *blockdev ) {
188         struct scsi_device *scsi = block_to_scsi ( blockdev );
189         struct scsi_command command;
190         struct scsi_cdb_read_capacity_10 *cdb = &command.cdb.readcap10;
191         struct scsi_capacity_10 capacity;
192         int rc;
193
194         /* Issue READ CAPACITY (10) */
195         memset ( &command, 0, sizeof ( command ) );
196         cdb->opcode = SCSI_OPCODE_READ_CAPACITY_10;
197         command.data_in = virt_to_user ( &capacity );
198         command.data_in_len = sizeof ( capacity );
199
200         if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
201                 return rc;
202
203         /* Fill in block device fields */
204         blockdev->blksize = be32_to_cpu ( capacity.blksize );
205         blockdev->blocks = ( be32_to_cpu ( capacity.lba ) + 1 );
206
207         return 0;
208 }
209
210 /**
211  * Read capacity of SCSI device via READ CAPACITY (16)
212  *
213  * @v blockdev          Block device
214  * @ret rc              Return status code
215  */
216 static int scsi_read_capacity_16 ( struct block_device *blockdev ) {
217         struct scsi_device *scsi = block_to_scsi ( blockdev );
218         struct scsi_command command;
219         struct scsi_cdb_read_capacity_16 *cdb = &command.cdb.readcap16;
220         struct scsi_capacity_16 capacity;
221         int rc;
222
223         /* Issue READ CAPACITY (16) */
224         memset ( &command, 0, sizeof ( command ) );
225         cdb->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
226         cdb->service_action = SCSI_SERVICE_ACTION_READ_CAPACITY_16;
227         cdb->len = cpu_to_be32 ( sizeof ( capacity ) );
228         command.data_in = virt_to_user ( &capacity );
229         command.data_in_len = sizeof ( capacity );
230
231         if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
232                 return rc;
233
234         /* Fill in block device fields */
235         blockdev->blksize = be32_to_cpu ( capacity.blksize );
236         blockdev->blocks = ( be64_to_cpu ( capacity.lba ) + 1 );
237         return 0;
238 }
239
240 static struct block_device_operations scsi_operations_16 = {
241         .read   = scsi_read_16,
242         .write  = scsi_write_16,
243 };
244
245 static struct block_device_operations scsi_operations_10 = {
246         .read   = scsi_read_10,
247         .write  = scsi_write_10,
248 };
249
250 /**
251  * Initialise SCSI device
252  *
253  * @v scsi              SCSI device
254  * @ret rc              Return status code
255  *
256  * Initialises a SCSI device.  The scsi_device::command and
257  * scsi_device::lun fields must already be filled in.  This function
258  * will configure scsi_device::blockdev, including issuing a READ
259  * CAPACITY call to determine the block size and total device size.
260  */
261 int init_scsidev ( struct scsi_device *scsi ) {
262         unsigned int i;
263         int rc;
264
265         /* Issue some theoretically extraneous READ CAPACITY (10)
266          * commands, solely in order to draw out the "CHECK CONDITION
267          * (power-on occurred)", "CHECK CONDITION (reported LUNs data
268          * has changed)" etc. that some dumb targets insist on sending
269          * as an error at start of day.  The precise command that we
270          * use is unimportant; we just need to provide the target with
271          * an opportunity to send its responses.
272          */
273         for ( i = 0 ; i < SCSI_MAX_DUMMY_READ_CAP ; i++ ) {
274                 if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) == 0 )
275                         break;
276         }
277
278         /* Try READ CAPACITY (10), which is a mandatory command, first. */
279         scsi->blockdev.op = &scsi_operations_10;
280         if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) != 0 )
281                 return rc;
282
283         /* If capacity range was exceeded (i.e. capacity.lba was
284          * 0xffffffff, meaning that blockdev->blocks is now zero), use
285          * READ CAPACITY (16) instead.  READ CAPACITY (16) is not
286          * mandatory, so we can't just use it straight off.
287          */
288         if ( scsi->blockdev.blocks == 0 ) {
289                 scsi->blockdev.op = &scsi_operations_16;
290                 if ( ( rc = scsi_read_capacity_16 ( &scsi->blockdev ) ) != 0 )
291                         return rc;
292         }
293
294         return 0;
295 }