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