[tcpip] Allow supported address families to be detected at runtime
[ipxe.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., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26 #include <stddef.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <byteswap.h>
30 #include <errno.h>
31 #include <ipxe/list.h>
32 #include <ipxe/process.h>
33 #include <ipxe/xfer.h>
34 #include <ipxe/blockdev.h>
35 #include <ipxe/scsi.h>
36
37 /** @file
38 *
39 * SCSI block device
40 *
41 */
42
43 /** Maximum number of command retries */
44 #define SCSICMD_MAX_RETRIES 10
45
46 /* Error numbers generated by SCSI sense data */
47 #define EIO_NO_SENSE __einfo_error ( EINFO_EIO_NO_SENSE )
48 #define EINFO_EIO_NO_SENSE \
49 __einfo_uniqify ( EINFO_EIO, 0x00, "No sense" )
50 #define EIO_RECOVERED_ERROR __einfo_error ( EINFO_EIO_RECOVERED_ERROR )
51 #define EINFO_EIO_RECOVERED_ERROR \
52 __einfo_uniqify ( EINFO_EIO, 0x01, "Recovered error" )
53 #define EIO_NOT_READY __einfo_error ( EINFO_EIO_NOT_READY )
54 #define EINFO_EIO_NOT_READY \
55 __einfo_uniqify ( EINFO_EIO, 0x02, "Not ready" )
56 #define EIO_MEDIUM_ERROR __einfo_error ( EINFO_EIO_MEDIUM_ERROR )
57 #define EINFO_EIO_MEDIUM_ERROR \
58 __einfo_uniqify ( EINFO_EIO, 0x03, "Medium error" )
59 #define EIO_HARDWARE_ERROR __einfo_error ( EINFO_EIO_HARDWARE_ERROR )
60 #define EINFO_EIO_HARDWARE_ERROR \
61 __einfo_uniqify ( EINFO_EIO, 0x04, "Hardware error" )
62 #define EIO_ILLEGAL_REQUEST __einfo_error ( EINFO_EIO_ILLEGAL_REQUEST )
63 #define EINFO_EIO_ILLEGAL_REQUEST \
64 __einfo_uniqify ( EINFO_EIO, 0x05, "Illegal request" )
65 #define EIO_UNIT_ATTENTION __einfo_error ( EINFO_EIO_UNIT_ATTENTION )
66 #define EINFO_EIO_UNIT_ATTENTION \
67 __einfo_uniqify ( EINFO_EIO, 0x06, "Unit attention" )
68 #define EIO_DATA_PROTECT __einfo_error ( EINFO_EIO_DATA_PROTECT )
69 #define EINFO_EIO_DATA_PROTECT \
70 __einfo_uniqify ( EINFO_EIO, 0x07, "Data protect" )
71 #define EIO_BLANK_CHECK __einfo_error ( EINFO_EIO_BLANK_CHECK )
72 #define EINFO_EIO_BLANK_CHECK \
73 __einfo_uniqify ( EINFO_EIO, 0x08, "Blank check" )
74 #define EIO_VENDOR_SPECIFIC __einfo_error ( EINFO_EIO_VENDOR_SPECIFIC )
75 #define EINFO_EIO_VENDOR_SPECIFIC \
76 __einfo_uniqify ( EINFO_EIO, 0x09, "Vendor specific" )
77 #define EIO_COPY_ABORTED __einfo_error ( EINFO_EIO_COPY_ABORTED )
78 #define EINFO_EIO_COPY_ABORTED \
79 __einfo_uniqify ( EINFO_EIO, 0x0a, "Copy aborted" )
80 #define EIO_ABORTED_COMMAND __einfo_error ( EINFO_EIO_ABORTED_COMMAND )
81 #define EINFO_EIO_ABORTED_COMMAND \
82 __einfo_uniqify ( EINFO_EIO, 0x0b, "Aborted command" )
83 #define EIO_RESERVED __einfo_error ( EINFO_EIO_RESERVED )
84 #define EINFO_EIO_RESERVED \
85 __einfo_uniqify ( EINFO_EIO, 0x0c, "Reserved" )
86 #define EIO_VOLUME_OVERFLOW __einfo_error ( EINFO_EIO_VOLUME_OVERFLOW )
87 #define EINFO_EIO_VOLUME_OVERFLOW \
88 __einfo_uniqify ( EINFO_EIO, 0x0d, "Volume overflow" )
89 #define EIO_MISCOMPARE __einfo_error ( EINFO_EIO_MISCOMPARE )
90 #define EINFO_EIO_MISCOMPARE \
91 __einfo_uniqify ( EINFO_EIO, 0x0e, "Miscompare" )
92 #define EIO_COMPLETED __einfo_error ( EINFO_EIO_COMPLETED )
93 #define EINFO_EIO_COMPLETED \
94 __einfo_uniqify ( EINFO_EIO, 0x0f, "Completed" )
95 #define EIO_SENSE( key ) \
96 EUNIQ ( EINFO_EIO, (key), EIO_NO_SENSE, EIO_RECOVERED_ERROR, \
97 EIO_NOT_READY, EIO_MEDIUM_ERROR, EIO_HARDWARE_ERROR, \
98 EIO_ILLEGAL_REQUEST, EIO_UNIT_ATTENTION, \
99 EIO_DATA_PROTECT, EIO_BLANK_CHECK, EIO_VENDOR_SPECIFIC, \
100 EIO_COPY_ABORTED, EIO_ABORTED_COMMAND, EIO_RESERVED, \
101 EIO_VOLUME_OVERFLOW, EIO_MISCOMPARE, EIO_COMPLETED )
102
103 /******************************************************************************
104 *
105 * Utility functions
106 *
107 ******************************************************************************
108 */
109
110 /**
111 * Parse SCSI LUN
112 *
113 * @v lun_string LUN string representation
114 * @v lun LUN to fill in
115 * @ret rc Return status code
116 */
117 int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ) {
118 char *p;
119 int i;
120
121 memset ( lun, 0, sizeof ( *lun ) );
122 if ( lun_string ) {
123 p = ( char * ) lun_string;
124 for ( i = 0 ; i < 4 ; i++ ) {
125 lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
126 if ( *p == '\0' )
127 break;
128 if ( *p != '-' )
129 return -EINVAL;
130 p++;
131 }
132 if ( *p )
133 return -EINVAL;
134 }
135
136 return 0;
137 }
138
139 /**
140 * Parse SCSI sense data
141 *
142 * @v data Raw sense data
143 * @v len Length of raw sense data
144 * @v sense Descriptor-format sense data to fill in
145 */
146 void scsi_parse_sense ( const void *data, size_t len,
147 struct scsi_sns_descriptor *sense ) {
148 const union scsi_sns *sns = data;
149
150 /* Avoid returning uninitialised data */
151 memset ( sense, 0, sizeof ( *sense ) );
152
153 /* Copy, assuming descriptor-format data */
154 if ( len < sizeof ( sns->desc ) )
155 return;
156 memcpy ( sense, &sns->desc, sizeof ( *sense ) );
157
158 /* Convert fixed-format to descriptor-format, if applicable */
159 if ( len < sizeof ( sns->fixed ) )
160 return;
161 if ( ! SCSI_SENSE_FIXED ( sns->code ) )
162 return;
163 sense->additional = sns->fixed.additional;
164 }
165
166 /******************************************************************************
167 *
168 * Interface methods
169 *
170 ******************************************************************************
171 */
172
173 /**
174 * Issue SCSI command
175 *
176 * @v control SCSI control interface
177 * @v data SCSI data interface
178 * @v command SCSI command
179 * @ret tag Command tag, or negative error
180 */
181 int scsi_command ( struct interface *control, struct interface *data,
182 struct scsi_cmd *command ) {
183 struct interface *dest;
184 scsi_command_TYPE ( void * ) *op =
185 intf_get_dest_op ( control, scsi_command, &dest );
186 void *object = intf_object ( dest );
187 int tap;
188
189 if ( op ) {
190 tap = op ( object, data, command );
191 } else {
192 /* Default is to fail to issue the command */
193 tap = -EOPNOTSUPP;
194 }
195
196 intf_put ( dest );
197 return tap;
198 }
199
200 /**
201 * Report SCSI response
202 *
203 * @v interface SCSI command interface
204 * @v response SCSI response
205 */
206 void scsi_response ( struct interface *intf, struct scsi_rsp *response ) {
207 struct interface *dest;
208 scsi_response_TYPE ( void * ) *op =
209 intf_get_dest_op ( intf, scsi_response, &dest );
210 void *object = intf_object ( dest );
211
212 if ( op ) {
213 op ( object, response );
214 } else {
215 /* Default is to ignore the response */
216 }
217
218 intf_put ( dest );
219 }
220
221 /******************************************************************************
222 *
223 * SCSI devices and commands
224 *
225 ******************************************************************************
226 */
227
228 /** A SCSI device */
229 struct scsi_device {
230 /** Reference count */
231 struct refcnt refcnt;
232 /** Block control interface */
233 struct interface block;
234 /** SCSI control interface */
235 struct interface scsi;
236
237 /** SCSI LUN */
238 struct scsi_lun lun;
239 /** Flags */
240 unsigned int flags;
241
242 /** TEST UNIT READY interface */
243 struct interface ready;
244 /** TEST UNIT READY process */
245 struct process process;
246
247 /** List of commands */
248 struct list_head cmds;
249 };
250
251 /** SCSI device flags */
252 enum scsi_device_flags {
253 /** TEST UNIT READY has been issued */
254 SCSIDEV_UNIT_TESTED = 0x0001,
255 /** TEST UNIT READY has completed successfully */
256 SCSIDEV_UNIT_READY = 0x0002,
257 };
258
259 /** A SCSI command */
260 struct scsi_command {
261 /** Reference count */
262 struct refcnt refcnt;
263 /** SCSI device */
264 struct scsi_device *scsidev;
265 /** List of SCSI commands */
266 struct list_head list;
267
268 /** Block data interface */
269 struct interface block;
270 /** SCSI data interface */
271 struct interface scsi;
272
273 /** Command type */
274 struct scsi_command_type *type;
275 /** Starting logical block address */
276 uint64_t lba;
277 /** Number of blocks */
278 unsigned int count;
279 /** Data buffer */
280 userptr_t buffer;
281 /** Length of data buffer */
282 size_t len;
283 /** Command tag */
284 uint32_t tag;
285
286 /** Retry count */
287 unsigned int retries;
288
289 /** Private data */
290 uint8_t priv[0];
291 };
292
293 /** A SCSI command type */
294 struct scsi_command_type {
295 /** Name */
296 const char *name;
297 /** Additional working space */
298 size_t priv_len;
299 /**
300 * Construct SCSI command IU
301 *
302 * @v scsicmd SCSI command
303 * @v command SCSI command IU
304 */
305 void ( * cmd ) ( struct scsi_command *scsicmd,
306 struct scsi_cmd *command );
307 /**
308 * Handle SCSI command completion
309 *
310 * @v scsicmd SCSI command
311 * @v rc Reason for completion
312 */
313 void ( * done ) ( struct scsi_command *scsicmd, int rc );
314 };
315
316 /**
317 * Get reference to SCSI device
318 *
319 * @v scsidev SCSI device
320 * @ret scsidev SCSI device
321 */
322 static inline __attribute__ (( always_inline )) struct scsi_device *
323 scsidev_get ( struct scsi_device *scsidev ) {
324 ref_get ( &scsidev->refcnt );
325 return scsidev;
326 }
327
328 /**
329 * Drop reference to SCSI device
330 *
331 * @v scsidev SCSI device
332 */
333 static inline __attribute__ (( always_inline )) void
334 scsidev_put ( struct scsi_device *scsidev ) {
335 ref_put ( &scsidev->refcnt );
336 }
337
338 /**
339 * Get reference to SCSI command
340 *
341 * @v scsicmd SCSI command
342 * @ret scsicmd SCSI command
343 */
344 static inline __attribute__ (( always_inline )) struct scsi_command *
345 scsicmd_get ( struct scsi_command *scsicmd ) {
346 ref_get ( &scsicmd->refcnt );
347 return scsicmd;
348 }
349
350 /**
351 * Drop reference to SCSI command
352 *
353 * @v scsicmd SCSI command
354 */
355 static inline __attribute__ (( always_inline )) void
356 scsicmd_put ( struct scsi_command *scsicmd ) {
357 ref_put ( &scsicmd->refcnt );
358 }
359
360 /**
361 * Get SCSI command private data
362 *
363 * @v scsicmd SCSI command
364 * @ret priv Private data
365 */
366 static inline __attribute__ (( always_inline )) void *
367 scsicmd_priv ( struct scsi_command *scsicmd ) {
368 return scsicmd->priv;
369 }
370
371 /**
372 * Free SCSI command
373 *
374 * @v refcnt Reference count
375 */
376 static void scsicmd_free ( struct refcnt *refcnt ) {
377 struct scsi_command *scsicmd =
378 container_of ( refcnt, struct scsi_command, refcnt );
379
380 /* Remove from list of commands */
381 list_del ( &scsicmd->list );
382 scsidev_put ( scsicmd->scsidev );
383
384 /* Free command */
385 free ( scsicmd );
386 }
387
388 /**
389 * Close SCSI command
390 *
391 * @v scsicmd SCSI command
392 * @v rc Reason for close
393 */
394 static void scsicmd_close ( struct scsi_command *scsicmd, int rc ) {
395 struct scsi_device *scsidev = scsicmd->scsidev;
396
397 if ( rc != 0 ) {
398 DBGC ( scsidev, "SCSI %p tag %08x closed: %s\n",
399 scsidev, scsicmd->tag, strerror ( rc ) );
400 }
401
402 /* Shut down interfaces */
403 intf_shutdown ( &scsicmd->scsi, rc );
404 intf_shutdown ( &scsicmd->block, rc );
405 }
406
407 /**
408 * Construct and issue SCSI command
409 *
410 * @ret rc Return status code
411 */
412 static int scsicmd_command ( struct scsi_command *scsicmd ) {
413 struct scsi_device *scsidev = scsicmd->scsidev;
414 struct scsi_cmd command;
415 int tag;
416 int rc;
417
418 /* Construct command */
419 memset ( &command, 0, sizeof ( command ) );
420 memcpy ( &command.lun, &scsidev->lun, sizeof ( command.lun ) );
421 scsicmd->type->cmd ( scsicmd, &command );
422
423 /* Issue command */
424 if ( ( tag = scsi_command ( &scsidev->scsi, &scsicmd->scsi,
425 &command ) ) < 0 ) {
426 rc = tag;
427 DBGC ( scsidev, "SCSI %p could not issue command: %s\n",
428 scsidev, strerror ( rc ) );
429 return rc;
430 }
431
432 /* Record tag */
433 if ( scsicmd->tag ) {
434 DBGC ( scsidev, "SCSI %p tag %08x is now tag %08x\n",
435 scsidev, scsicmd->tag, tag );
436 }
437 scsicmd->tag = tag;
438 DBGC2 ( scsidev, "SCSI %p tag %08x %s " SCSI_CDB_FORMAT "\n",
439 scsidev, scsicmd->tag, scsicmd->type->name,
440 SCSI_CDB_DATA ( command.cdb ) );
441
442 return 0;
443 }
444
445 /**
446 * Handle SCSI command completion
447 *
448 * @v scsicmd SCSI command
449 * @v rc Reason for close
450 */
451 static void scsicmd_done ( struct scsi_command *scsicmd, int rc ) {
452 struct scsi_device *scsidev = scsicmd->scsidev;
453
454 /* Restart SCSI interface */
455 intf_restart ( &scsicmd->scsi, rc );
456
457 /* SCSI targets have an annoying habit of returning occasional
458 * pointless "error" messages such as "power-on occurred", so
459 * we have to be prepared to retry commands.
460 */
461 if ( ( rc != 0 ) && ( scsicmd->retries++ < SCSICMD_MAX_RETRIES ) ) {
462 /* Retry command */
463 DBGC ( scsidev, "SCSI %p tag %08x failed: %s\n",
464 scsidev, scsicmd->tag, strerror ( rc ) );
465 DBGC ( scsidev, "SCSI %p tag %08x retrying (retry %d)\n",
466 scsidev, scsicmd->tag, scsicmd->retries );
467 if ( ( rc = scsicmd_command ( scsicmd ) ) == 0 )
468 return;
469 }
470
471 /* If we didn't (successfully) reissue the command, hand over
472 * to the command completion handler.
473 */
474 scsicmd->type->done ( scsicmd, rc );
475 }
476
477 /**
478 * Handle SCSI response
479 *
480 * @v scsicmd SCSI command
481 * @v response SCSI response
482 */
483 static void scsicmd_response ( struct scsi_command *scsicmd,
484 struct scsi_rsp *response ) {
485 struct scsi_device *scsidev = scsicmd->scsidev;
486 size_t overrun;
487 size_t underrun;
488 int rc;
489
490 if ( response->status == 0 ) {
491 scsicmd_done ( scsicmd, 0 );
492 } else {
493 DBGC ( scsidev, "SCSI %p tag %08x status %02x",
494 scsidev, scsicmd->tag, response->status );
495 if ( response->overrun > 0 ) {
496 overrun = response->overrun;
497 DBGC ( scsidev, " overrun +%zd", overrun );
498 } else if ( response->overrun < 0 ) {
499 underrun = -(response->overrun);
500 DBGC ( scsidev, " underrun -%zd", underrun );
501 }
502 DBGC ( scsidev, " sense %02x key %02x additional %04x\n",
503 ( response->sense.code & SCSI_SENSE_CODE_MASK ),
504 ( response->sense.key & SCSI_SENSE_KEY_MASK ),
505 ntohs ( response->sense.additional ) );
506
507 /* Construct error number from sense data */
508 rc = -EIO_SENSE ( response->sense.key & SCSI_SENSE_KEY_MASK );
509 scsicmd_done ( scsicmd, rc );
510 }
511 }
512
513 /**
514 * Construct SCSI READ command
515 *
516 * @v scsicmd SCSI command
517 * @v command SCSI command IU
518 */
519 static void scsicmd_read_cmd ( struct scsi_command *scsicmd,
520 struct scsi_cmd *command ) {
521
522 if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
523 /* Use READ (16) */
524 command->cdb.read16.opcode = SCSI_OPCODE_READ_16;
525 command->cdb.read16.lba = cpu_to_be64 ( scsicmd->lba );
526 command->cdb.read16.len = cpu_to_be32 ( scsicmd->count );
527 } else {
528 /* Use READ (10) */
529 command->cdb.read10.opcode = SCSI_OPCODE_READ_10;
530 command->cdb.read10.lba = cpu_to_be32 ( scsicmd->lba );
531 command->cdb.read10.len = cpu_to_be16 ( scsicmd->count );
532 }
533 command->data_in = scsicmd->buffer;
534 command->data_in_len = scsicmd->len;
535 }
536
537 /** SCSI READ command type */
538 static struct scsi_command_type scsicmd_read = {
539 .name = "READ",
540 .cmd = scsicmd_read_cmd,
541 .done = scsicmd_close,
542 };
543
544 /**
545 * Construct SCSI WRITE command
546 *
547 * @v scsicmd SCSI command
548 * @v command SCSI command IU
549 */
550 static void scsicmd_write_cmd ( struct scsi_command *scsicmd,
551 struct scsi_cmd *command ) {
552
553 if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
554 /* Use WRITE (16) */
555 command->cdb.write16.opcode = SCSI_OPCODE_WRITE_16;
556 command->cdb.write16.lba = cpu_to_be64 ( scsicmd->lba );
557 command->cdb.write16.len = cpu_to_be32 ( scsicmd->count );
558 } else {
559 /* Use WRITE (10) */
560 command->cdb.write10.opcode = SCSI_OPCODE_WRITE_10;
561 command->cdb.write10.lba = cpu_to_be32 ( scsicmd->lba );
562 command->cdb.write10.len = cpu_to_be16 ( scsicmd->count );
563 }
564 command->data_out = scsicmd->buffer;
565 command->data_out_len = scsicmd->len;
566 }
567
568 /** SCSI WRITE command type */
569 static struct scsi_command_type scsicmd_write = {
570 .name = "WRITE",
571 .cmd = scsicmd_write_cmd,
572 .done = scsicmd_close,
573 };
574
575 /** SCSI READ CAPACITY private data */
576 struct scsi_read_capacity_private {
577 /** Use READ CAPACITY (16) */
578 int use16;
579 /** Data buffer for READ CAPACITY commands */
580 union {
581 /** Data buffer for READ CAPACITY (10) */
582 struct scsi_capacity_10 capacity10;
583 /** Data buffer for READ CAPACITY (16) */
584 struct scsi_capacity_16 capacity16;
585 } capacity;
586 };
587
588 /**
589 * Construct SCSI READ CAPACITY command
590 *
591 * @v scsicmd SCSI command
592 * @v command SCSI command IU
593 */
594 static void scsicmd_read_capacity_cmd ( struct scsi_command *scsicmd,
595 struct scsi_cmd *command ) {
596 struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
597 struct scsi_cdb_read_capacity_16 *readcap16 = &command->cdb.readcap16;
598 struct scsi_cdb_read_capacity_10 *readcap10 = &command->cdb.readcap10;
599 struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
600 struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
601
602 if ( priv->use16 ) {
603 /* Use READ CAPACITY (16) */
604 readcap16->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
605 readcap16->service_action =
606 SCSI_SERVICE_ACTION_READ_CAPACITY_16;
607 readcap16->len = cpu_to_be32 ( sizeof ( *capacity16 ) );
608 command->data_in = virt_to_user ( capacity16 );
609 command->data_in_len = sizeof ( *capacity16 );
610 } else {
611 /* Use READ CAPACITY (10) */
612 readcap10->opcode = SCSI_OPCODE_READ_CAPACITY_10;
613 command->data_in = virt_to_user ( capacity10 );
614 command->data_in_len = sizeof ( *capacity10 );
615 }
616 }
617
618 /**
619 * Handle SCSI READ CAPACITY command completion
620 *
621 * @v scsicmd SCSI command
622 * @v rc Reason for completion
623 */
624 static void scsicmd_read_capacity_done ( struct scsi_command *scsicmd,
625 int rc ) {
626 struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
627 struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
628 struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
629 struct block_device_capacity capacity;
630
631 /* Close if command failed */
632 if ( rc != 0 ) {
633 scsicmd_close ( scsicmd, rc );
634 return;
635 }
636
637 /* Extract capacity */
638 if ( priv->use16 ) {
639 capacity.blocks = ( be64_to_cpu ( capacity16->lba ) + 1 );
640 capacity.blksize = be32_to_cpu ( capacity16->blksize );
641 } else {
642 capacity.blocks = ( be32_to_cpu ( capacity10->lba ) + 1 );
643 capacity.blksize = be32_to_cpu ( capacity10->blksize );
644
645 /* If capacity range was exceeded (i.e. capacity.lba
646 * was 0xffffffff, meaning that blockdev->blocks is
647 * now zero), use READ CAPACITY (16) instead. READ
648 * CAPACITY (16) is not mandatory, so we can't just
649 * use it straight off.
650 */
651 if ( capacity.blocks == 0 ) {
652 priv->use16 = 1;
653 if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 ) {
654 scsicmd_close ( scsicmd, rc );
655 return;
656 }
657 return;
658 }
659 }
660 capacity.max_count = -1U;
661
662 /* Return capacity to caller */
663 block_capacity ( &scsicmd->block, &capacity );
664
665 /* Close command */
666 scsicmd_close ( scsicmd, 0 );
667 }
668
669 /** SCSI READ CAPACITY command type */
670 static struct scsi_command_type scsicmd_read_capacity = {
671 .name = "READ CAPACITY",
672 .priv_len = sizeof ( struct scsi_read_capacity_private ),
673 .cmd = scsicmd_read_capacity_cmd,
674 .done = scsicmd_read_capacity_done,
675 };
676
677 /**
678 * Construct SCSI TEST UNIT READY command
679 *
680 * @v scsicmd SCSI command
681 * @v command SCSI command IU
682 */
683 static void scsicmd_test_unit_ready_cmd ( struct scsi_command *scsicmd __unused,
684 struct scsi_cmd *command ) {
685 struct scsi_cdb_test_unit_ready *testready = &command->cdb.testready;
686
687 testready->opcode = SCSI_OPCODE_TEST_UNIT_READY;
688 }
689
690 /** SCSI TEST UNIT READY command type */
691 static struct scsi_command_type scsicmd_test_unit_ready = {
692 .name = "TEST UNIT READY",
693 .cmd = scsicmd_test_unit_ready_cmd,
694 .done = scsicmd_close,
695 };
696
697 /** SCSI command block interface operations */
698 static struct interface_operation scsicmd_block_op[] = {
699 INTF_OP ( intf_close, struct scsi_command *, scsicmd_close ),
700 };
701
702 /** SCSI command block interface descriptor */
703 static struct interface_descriptor scsicmd_block_desc =
704 INTF_DESC_PASSTHRU ( struct scsi_command, block,
705 scsicmd_block_op, scsi );
706
707 /** SCSI command SCSI interface operations */
708 static struct interface_operation scsicmd_scsi_op[] = {
709 INTF_OP ( intf_close, struct scsi_command *, scsicmd_done ),
710 INTF_OP ( scsi_response, struct scsi_command *, scsicmd_response ),
711 };
712
713 /** SCSI command SCSI interface descriptor */
714 static struct interface_descriptor scsicmd_scsi_desc =
715 INTF_DESC_PASSTHRU ( struct scsi_command, scsi,
716 scsicmd_scsi_op, block );
717
718 /**
719 * Create SCSI command
720 *
721 * @v scsidev SCSI device
722 * @v block Block data interface
723 * @v type SCSI command type
724 * @v lba Starting logical block address
725 * @v count Number of blocks to transfer
726 * @v buffer Data buffer
727 * @v len Length of data buffer
728 * @ret rc Return status code
729 */
730 static int scsidev_command ( struct scsi_device *scsidev,
731 struct interface *block,
732 struct scsi_command_type *type,
733 uint64_t lba, unsigned int count,
734 userptr_t buffer, size_t len ) {
735 struct scsi_command *scsicmd;
736 int rc;
737
738 /* Allocate and initialise structure */
739 scsicmd = zalloc ( sizeof ( *scsicmd ) + type->priv_len );
740 if ( ! scsicmd ) {
741 rc = -ENOMEM;
742 goto err_zalloc;
743 }
744 ref_init ( &scsicmd->refcnt, scsicmd_free );
745 intf_init ( &scsicmd->block, &scsicmd_block_desc, &scsicmd->refcnt );
746 intf_init ( &scsicmd->scsi, &scsicmd_scsi_desc,
747 &scsicmd->refcnt );
748 scsicmd->scsidev = scsidev_get ( scsidev );
749 list_add ( &scsicmd->list, &scsidev->cmds );
750 scsicmd->type = type;
751 scsicmd->lba = lba;
752 scsicmd->count = count;
753 scsicmd->buffer = buffer;
754 scsicmd->len = len;
755
756 /* Issue SCSI command */
757 if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 )
758 goto err_command;
759
760 /* Attach to parent interface, mortalise self, and return */
761 intf_plug_plug ( &scsicmd->block, block );
762 ref_put ( &scsicmd->refcnt );
763 return 0;
764
765 err_command:
766 scsicmd_close ( scsicmd, rc );
767 ref_put ( &scsicmd->refcnt );
768 err_zalloc:
769 return rc;
770 }
771
772 /**
773 * Issue SCSI block read
774 *
775 * @v scsidev SCSI device
776 * @v block Block data interface
777 * @v lba Starting logical block address
778 * @v count Number of blocks to transfer
779 * @v buffer Data buffer
780 * @v len Length of data buffer
781 * @ret rc Return status code
782
783 */
784 static int scsidev_read ( struct scsi_device *scsidev,
785 struct interface *block,
786 uint64_t lba, unsigned int count,
787 userptr_t buffer, size_t len ) {
788 return scsidev_command ( scsidev, block, &scsicmd_read,
789 lba, count, buffer, len );
790 }
791
792 /**
793 * Issue SCSI block write
794 *
795 * @v scsidev SCSI device
796 * @v block Block data interface
797 * @v lba Starting logical block address
798 * @v count Number of blocks to transfer
799 * @v buffer Data buffer
800 * @v len Length of data buffer
801 * @ret rc Return status code
802 */
803 static int scsidev_write ( struct scsi_device *scsidev,
804 struct interface *block,
805 uint64_t lba, unsigned int count,
806 userptr_t buffer, size_t len ) {
807 return scsidev_command ( scsidev, block, &scsicmd_write,
808 lba, count, buffer, len );
809 }
810
811 /**
812 * Read SCSI device capacity
813 *
814 * @v scsidev SCSI device
815 * @v block Block data interface
816 * @ret rc Return status code
817 */
818 static int scsidev_read_capacity ( struct scsi_device *scsidev,
819 struct interface *block ) {
820 return scsidev_command ( scsidev, block, &scsicmd_read_capacity,
821 0, 0, UNULL, 0 );
822 }
823
824 /**
825 * Test to see if SCSI device is ready
826 *
827 * @v scsidev SCSI device
828 * @v block Block data interface
829 * @ret rc Return status code
830 */
831 static int scsidev_test_unit_ready ( struct scsi_device *scsidev,
832 struct interface *block ) {
833 return scsidev_command ( scsidev, block, &scsicmd_test_unit_ready,
834 0, 0, UNULL, 0 );
835 }
836
837 /**
838 * Check SCSI device flow-control window
839 *
840 * @v scsidev SCSI device
841 * @ret len Length of window
842 */
843 static size_t scsidev_window ( struct scsi_device *scsidev ) {
844
845 /* Refuse commands until unit is confirmed ready */
846 if ( ! ( scsidev->flags & SCSIDEV_UNIT_READY ) )
847 return 0;
848
849 return xfer_window ( &scsidev->scsi );
850 }
851
852 /**
853 * Close SCSI device
854 *
855 * @v scsidev SCSI device
856 * @v rc Reason for close
857 */
858 static void scsidev_close ( struct scsi_device *scsidev, int rc ) {
859 struct scsi_command *scsicmd;
860 struct scsi_command *tmp;
861
862 /* Stop process */
863 process_del ( &scsidev->process );
864
865 /* Shut down interfaces */
866 intf_shutdown ( &scsidev->block, rc );
867 intf_shutdown ( &scsidev->scsi, rc );
868 intf_shutdown ( &scsidev->ready, rc );
869
870 /* Shut down any remaining commands */
871 list_for_each_entry_safe ( scsicmd, tmp, &scsidev->cmds, list ) {
872 scsicmd_get ( scsicmd );
873 scsicmd_close ( scsicmd, rc );
874 scsicmd_put ( scsicmd );
875 }
876 }
877
878 /** SCSI device block interface operations */
879 static struct interface_operation scsidev_block_op[] = {
880 INTF_OP ( xfer_window, struct scsi_device *, scsidev_window ),
881 INTF_OP ( block_read, struct scsi_device *, scsidev_read ),
882 INTF_OP ( block_write, struct scsi_device *, scsidev_write ),
883 INTF_OP ( block_read_capacity, struct scsi_device *,
884 scsidev_read_capacity ),
885 INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
886 };
887
888 /** SCSI device block interface descriptor */
889 static struct interface_descriptor scsidev_block_desc =
890 INTF_DESC_PASSTHRU ( struct scsi_device, block,
891 scsidev_block_op, scsi );
892
893 /**
894 * Handle SCSI TEST UNIT READY response
895 *
896 * @v scsidev SCSI device
897 * @v rc Reason for close
898 */
899 static void scsidev_ready ( struct scsi_device *scsidev, int rc ) {
900
901 /* Shut down interface */
902 intf_shutdown ( &scsidev->ready, rc );
903
904 /* Close device on failure */
905 if ( rc != 0 ) {
906 DBGC ( scsidev, "SCSI %p not ready: %s\n",
907 scsidev, strerror ( rc ) );
908 scsidev_close ( scsidev, rc );
909 return;
910 }
911
912 /* Mark device as ready */
913 scsidev->flags |= SCSIDEV_UNIT_READY;
914 xfer_window_changed ( &scsidev->block );
915 DBGC ( scsidev, "SCSI %p unit is ready\n", scsidev );
916 }
917
918 /** SCSI device TEST UNIT READY interface operations */
919 static struct interface_operation scsidev_ready_op[] = {
920 INTF_OP ( intf_close, struct scsi_device *, scsidev_ready ),
921 };
922
923 /** SCSI device TEST UNIT READY interface descriptor */
924 static struct interface_descriptor scsidev_ready_desc =
925 INTF_DESC ( struct scsi_device, ready, scsidev_ready_op );
926
927 /**
928 * SCSI TEST UNIT READY process
929 *
930 * @v scsidev SCSI device
931 */
932 static void scsidev_step ( struct scsi_device *scsidev ) {
933 int rc;
934
935 /* Do nothing if we have already issued TEST UNIT READY */
936 if ( scsidev->flags & SCSIDEV_UNIT_TESTED )
937 return;
938
939 /* Wait until underlying SCSI device is ready */
940 if ( xfer_window ( &scsidev->scsi ) == 0 )
941 return;
942
943 DBGC ( scsidev, "SCSI %p waiting for unit to become ready\n",
944 scsidev );
945
946 /* Mark TEST UNIT READY as sent */
947 scsidev->flags |= SCSIDEV_UNIT_TESTED;
948
949 /* Issue TEST UNIT READY command */
950 if ( ( rc = scsidev_test_unit_ready ( scsidev, &scsidev->ready )) !=0){
951 scsidev_close ( scsidev, rc );
952 return;
953 }
954 }
955
956 /** SCSI device SCSI interface operations */
957 static struct interface_operation scsidev_scsi_op[] = {
958 INTF_OP ( xfer_window_changed, struct scsi_device *, scsidev_step ),
959 INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
960 };
961
962 /** SCSI device SCSI interface descriptor */
963 static struct interface_descriptor scsidev_scsi_desc =
964 INTF_DESC_PASSTHRU ( struct scsi_device, scsi,
965 scsidev_scsi_op, block );
966
967 /** SCSI device process descriptor */
968 static struct process_descriptor scsidev_process_desc =
969 PROC_DESC_ONCE ( struct scsi_device, process, scsidev_step );
970
971 /**
972 * Open SCSI device
973 *
974 * @v block Block control interface
975 * @v scsi SCSI control interface
976 * @v lun SCSI LUN
977 * @ret rc Return status code
978 */
979 int scsi_open ( struct interface *block, struct interface *scsi,
980 struct scsi_lun *lun ) {
981 struct scsi_device *scsidev;
982
983 /* Allocate and initialise structure */
984 scsidev = zalloc ( sizeof ( *scsidev ) );
985 if ( ! scsidev )
986 return -ENOMEM;
987 ref_init ( &scsidev->refcnt, NULL );
988 intf_init ( &scsidev->block, &scsidev_block_desc, &scsidev->refcnt );
989 intf_init ( &scsidev->scsi, &scsidev_scsi_desc, &scsidev->refcnt );
990 intf_init ( &scsidev->ready, &scsidev_ready_desc, &scsidev->refcnt );
991 process_init ( &scsidev->process, &scsidev_process_desc,
992 &scsidev->refcnt );
993 INIT_LIST_HEAD ( &scsidev->cmds );
994 memcpy ( &scsidev->lun, lun, sizeof ( scsidev->lun ) );
995 DBGC ( scsidev, "SCSI %p created for LUN " SCSI_LUN_FORMAT "\n",
996 scsidev, SCSI_LUN_DATA ( scsidev->lun ) );
997
998 /* Attach to SCSI and parent interfaces, mortalise self, and return */
999 intf_plug_plug ( &scsidev->scsi, scsi );
1000 intf_plug_plug ( &scsidev->block, block );
1001 ref_put ( &scsidev->refcnt );
1002 return 0;
1003 }