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