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