gpxe/src/drivers/block/scsi.c - platform/external/syslinux - Git at Google

 /*
  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or any later version.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */

 FILE_LICENCE ( GPL2_OR_LATER );

 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <byteswap.h>
 #include <errno.h>
 #include <gpxe/blockdev.h>
 #include <gpxe/process.h>
 #include <gpxe/scsi.h>

 /** @file
  *
  * SCSI block device
  *
  */

 /** Maximum number of dummy "read capacity (10)" operations
  *
  * These are issued at connection setup to draw out various useless
  * power-on messages.
  */
 #define SCSI_MAX_DUMMY_READ_CAP 10

 static inline __attribute__ (( always_inline )) struct scsi_device *
 block_to_scsi ( struct block_device *blockdev ) {
 	return container_of ( blockdev, struct scsi_device, blockdev );
 }

 /**
  * Handle SCSI command with no backing device
  *
  * @v scsi		SCSI device
  * @v command		SCSI command
  * @ret rc		Return status code
  */
 int scsi_detached_command ( struct scsi_device *scsi __unused,
 			    struct scsi_command *command __unused ) {
 	return -ENODEV;
 }

 /**
  * Issue SCSI command
  *
  * @v scsi		SCSI device
  * @v command		SCSI command
  * @ret rc		Return status code
  */
 static int scsi_command ( struct scsi_device *scsi,
 			  struct scsi_command *command ) {
 	int rc;

 	DBGC2 ( scsi, "SCSI %p " SCSI_CDB_FORMAT "\n",
 		scsi, SCSI_CDB_DATA ( command->cdb ) );

 	/* Clear sense response code before issuing command */
 	command->sense_response = 0;

 	/* Flag command as in-progress */
 	command->rc = -EINPROGRESS;

 	/* Issue SCSI command */
 	if ( ( rc = scsi->command ( scsi, command ) ) != 0 ) {
 		/* Something went wrong with the issuing mechanism */
 		DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n",
 		       scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) );
 		return rc;
 	}

 	/* Wait for command to complete */
 	while ( command->rc == -EINPROGRESS )
 		step();
 	if ( ( rc = command->rc ) != 0 ) {
 		/* Something went wrong with the command execution */
 		DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n",
 		       scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) );
 		return rc;
 	}

 	/* Check for SCSI errors */
 	if ( command->status != 0 ) {
 		DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " status %02x sense "
 		       "%02x\n", scsi, SCSI_CDB_DATA ( command->cdb ),
 		       command->status, command->sense_response );
 		return -EIO;
 	}

 	return 0;
 }

 /**
  * Read block from SCSI device using READ (10)
  *
  * @v blockdev		Block device
  * @v block		LBA block number
  * @v count		Block count
  * @v buffer		Data buffer
  * @ret rc		Return status code
  */
 static int scsi_read_10 ( struct block_device *blockdev, uint64_t block,
 			  unsigned long count, userptr_t buffer ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_read_10 *cdb = &command.cdb.read10;

 	/* Issue READ (10) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_READ_10;
 	cdb->lba = cpu_to_be32 ( block );
 	cdb->len = cpu_to_be16 ( count );
 	command.data_in = buffer;
 	command.data_in_len = ( count * blockdev->blksize );
 	return scsi_command ( scsi, &command );
 }

 /**
  * Read block from SCSI device using READ (16)
  *
  * @v blockdev		Block device
  * @v block		LBA block number
  * @v count		Block count
  * @v buffer		Data buffer
  * @ret rc		Return status code
  */
 static int scsi_read_16 ( struct block_device *blockdev, uint64_t block,
 			  unsigned long count, userptr_t buffer ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_read_16 *cdb = &command.cdb.read16;

 	/* Issue READ (16) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_READ_16;
 	cdb->lba = cpu_to_be64 ( block );
 	cdb->len = cpu_to_be32 ( count );
 	command.data_in = buffer;
 	command.data_in_len = ( count * blockdev->blksize );
 	return scsi_command ( scsi, &command );
 }

 /**
  * Write block to SCSI device using WRITE (10)
  *
  * @v blockdev		Block device
  * @v block		LBA block number
  * @v count		Block count
  * @v buffer		Data buffer
  * @ret rc		Return status code
  */
 static int scsi_write_10 ( struct block_device *blockdev, uint64_t block,
 			   unsigned long count, userptr_t buffer ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_write_10 *cdb = &command.cdb.write10;

 	/* Issue WRITE (10) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_WRITE_10;
 	cdb->lba = cpu_to_be32 ( block );
 	cdb->len = cpu_to_be16 ( count );
 	command.data_out = buffer;
 	command.data_out_len = ( count * blockdev->blksize );
 	return scsi_command ( scsi, &command );
 }

 /**
  * Write block to SCSI device using WRITE (16)
  *
  * @v blockdev		Block device
  * @v block		LBA block number
  * @v count		Block count
  * @v buffer		Data buffer
  * @ret rc		Return status code
  */
 static int scsi_write_16 ( struct block_device *blockdev, uint64_t block,
 			   unsigned long count, userptr_t buffer ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_write_16 *cdb = &command.cdb.write16;

 	/* Issue WRITE (16) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_WRITE_16;
 	cdb->lba = cpu_to_be64 ( block );
 	cdb->len = cpu_to_be32 ( count );
 	command.data_out = buffer;
 	command.data_out_len = ( count * blockdev->blksize );
 	return scsi_command ( scsi, &command );
 }

 /**
  * Read capacity of SCSI device via READ CAPACITY (10)
  *
  * @v blockdev		Block device
  * @ret rc		Return status code
  */
 static int scsi_read_capacity_10 ( struct block_device *blockdev ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_read_capacity_10 *cdb = &command.cdb.readcap10;
 	struct scsi_capacity_10 capacity;
 	int rc;

 	/* Issue READ CAPACITY (10) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_READ_CAPACITY_10;
 	command.data_in = virt_to_user ( &capacity );
 	command.data_in_len = sizeof ( capacity );

 	if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
 		return rc;

 	/* Fill in block device fields */
 	blockdev->blksize = be32_to_cpu ( capacity.blksize );
 	blockdev->blocks = ( be32_to_cpu ( capacity.lba ) + 1 );

 	return 0;
 }

 /**
  * Read capacity of SCSI device via READ CAPACITY (16)
  *
  * @v blockdev		Block device
  * @ret rc		Return status code
  */
 static int scsi_read_capacity_16 ( struct block_device *blockdev ) {
 	struct scsi_device *scsi = block_to_scsi ( blockdev );
 	struct scsi_command command;
 	struct scsi_cdb_read_capacity_16 *cdb = &command.cdb.readcap16;
 	struct scsi_capacity_16 capacity;
 	int rc;

 	/* Issue READ CAPACITY (16) */
 	memset ( &command, 0, sizeof ( command ) );
 	cdb->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
 	cdb->service_action = SCSI_SERVICE_ACTION_READ_CAPACITY_16;
 	cdb->len = cpu_to_be32 ( sizeof ( capacity ) );
 	command.data_in = virt_to_user ( &capacity );
 	command.data_in_len = sizeof ( capacity );

 	if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
 		return rc;

 	/* Fill in block device fields */
 	blockdev->blksize = be32_to_cpu ( capacity.blksize );
 	blockdev->blocks = ( be64_to_cpu ( capacity.lba ) + 1 );
 	return 0;
 }

 static struct block_device_operations scsi_operations_16 = {
 	.read	= scsi_read_16,
 	.write	= scsi_write_16,
 };

 static struct block_device_operations scsi_operations_10 = {
 	.read	= scsi_read_10,
 	.write	= scsi_write_10,
 };

 /**
  * Initialise SCSI device
  *
  * @v scsi		SCSI device
  * @ret rc		Return status code
  *
  * Initialises a SCSI device.  The scsi_device::command and
  * scsi_device::lun fields must already be filled in.  This function
  * will configure scsi_device::blockdev, including issuing a READ
  * CAPACITY call to determine the block size and total device size.
  */
 int init_scsidev ( struct scsi_device *scsi ) {
 	unsigned int i;
 	int rc;

 	/* Issue some theoretically extraneous READ CAPACITY (10)
 	 * commands, solely in order to draw out the "CHECK CONDITION
 	 * (power-on occurred)", "CHECK CONDITION (reported LUNs data
 	 * has changed)" etc. that some dumb targets insist on sending
 	 * as an error at start of day.  The precise command that we
 	 * use is unimportant; we just need to provide the target with
 	 * an opportunity to send its responses.
 	 */
 	for ( i = 0 ; i < SCSI_MAX_DUMMY_READ_CAP ; i++ ) {
 		if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) == 0 )
 			break;
 		DBGC ( scsi, "SCSI %p ignoring start-of-day error (#%d)\n",
 		       scsi, ( i + 1 ) );
 	}

 	/* Try READ CAPACITY (10), which is a mandatory command, first. */
 	scsi->blockdev.op = &scsi_operations_10;
 	if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) != 0 ) {
 		DBGC ( scsi, "SCSI %p could not READ CAPACITY (10): %s\n",
 		       scsi, strerror ( rc ) );
 		return rc;
 	}

 	/* If capacity range was exceeded (i.e. capacity.lba was
 	 * 0xffffffff, meaning that blockdev->blocks is now zero), use
 	 * READ CAPACITY (16) instead.  READ CAPACITY (16) is not
 	 * mandatory, so we can't just use it straight off.
 	 */
 	if ( scsi->blockdev.blocks == 0 ) {
 		scsi->blockdev.op = &scsi_operations_16;
 		if ( ( rc = scsi_read_capacity_16 ( &scsi->blockdev ) ) != 0 ){
 			DBGC ( scsi, "SCSI %p could not READ CAPACITY (16): "
 			       "%s\n", scsi, strerror ( rc ) );
 			return rc;
 		}
 	}

 	DBGC ( scsi, "SCSI %p using READ/WRITE (%d) commands\n", scsi,
 	       ( ( scsi->blockdev.op == &scsi_operations_10 ) ? 10 : 16 ) );
 	DBGC ( scsi, "SCSI %p capacity is %ld MB (%#llx blocks)\n", scsi,
 	       ( ( unsigned long ) ( scsi->blockdev.blocks >> 11 ) ),
 	       scsi->blockdev.blocks );

 	return 0;
 }

 /**
  * Parse SCSI LUN
  *
  * @v lun_string	LUN string representation
  * @v lun		LUN to fill in
  * @ret rc		Return status code
  */
 int scsi_parse_lun ( const char *lun_string, struct scsi_lun *lun ) {
 	char *p;
 	int i;

 	memset ( lun, 0, sizeof ( *lun ) );
 	if ( lun_string ) {
 		p = ( char * ) lun_string;
 		for ( i = 0 ; i < 4 ; i++ ) {
 			lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
 			if ( *p == '\0' )
 				break;
 			if ( *p != '-' )
 				return -EINVAL;
 			p++;
 		}
 		if ( *p )
 			return -EINVAL;
 	}

 	return 0;
 }
	/*
	* Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation; either version 2 of the
	* License, or any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	*/

	FILE_LICENCE ( GPL2_OR_LATER );

	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <byteswap.h>
	#include <errno.h>
	#include <gpxe/blockdev.h>
	#include <gpxe/process.h>
	#include <gpxe/scsi.h>

	/** @file
	*
	* SCSI block device
	*
	*/

	/** Maximum number of dummy "read capacity (10)" operations
	*
	* These are issued at connection setup to draw out various useless
	* power-on messages.
	*/
	#define SCSI_MAX_DUMMY_READ_CAP 10

	static inline __attribute__ (( always_inline )) struct scsi_device *
	block_to_scsi ( struct block_device *blockdev ) {
	return container_of ( blockdev, struct scsi_device, blockdev );
	}

	/**
	* Handle SCSI command with no backing device
	*
	* @v scsi SCSI device
	* @v command SCSI command
	* @ret rc Return status code
	*/
	int scsi_detached_command ( struct scsi_device *scsi __unused,
	struct scsi_command *command __unused ) {
	return -ENODEV;
	}

	/**
	* Issue SCSI command
	*
	* @v scsi SCSI device
	* @v command SCSI command
	* @ret rc Return status code
	*/
	static int scsi_command ( struct scsi_device *scsi,
	struct scsi_command *command ) {
	int rc;

	DBGC2 ( scsi, "SCSI %p " SCSI_CDB_FORMAT "\n",
	scsi, SCSI_CDB_DATA ( command->cdb ) );

	/* Clear sense response code before issuing command */
	command->sense_response = 0;

	/* Flag command as in-progress */
	command->rc = -EINPROGRESS;

	/* Issue SCSI command */
	if ( ( rc = scsi->command ( scsi, command ) ) != 0 ) {
	/* Something went wrong with the issuing mechanism */
	DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n",
	scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) );
	return rc;
	}

	/* Wait for command to complete */
	while ( command->rc == -EINPROGRESS )
	step();
	if ( ( rc = command->rc ) != 0 ) {
	/* Something went wrong with the command execution */
	DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " err %s\n",
	scsi, SCSI_CDB_DATA ( command->cdb ), strerror ( rc ) );
	return rc;
	}

	/* Check for SCSI errors */
	if ( command->status != 0 ) {
	DBGC ( scsi, "SCSI %p " SCSI_CDB_FORMAT " status %02x sense "
	"%02x\n", scsi, SCSI_CDB_DATA ( command->cdb ),
	command->status, command->sense_response );
	return -EIO;
	}

	return 0;
	}

	/**
	* Read block from SCSI device using READ (10)
	*
	* @v blockdev Block device
	* @v block LBA block number
	* @v count Block count
	* @v buffer Data buffer
	* @ret rc Return status code
	*/
	static int scsi_read_10 ( struct block_device *blockdev, uint64_t block,
	unsigned long count, userptr_t buffer ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_read_10 *cdb = &command.cdb.read10;

	/* Issue READ (10) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_READ_10;
	cdb->lba = cpu_to_be32 ( block );
	cdb->len = cpu_to_be16 ( count );
	command.data_in = buffer;
	command.data_in_len = ( count * blockdev->blksize );
	return scsi_command ( scsi, &command );
	}

	/**
	* Read block from SCSI device using READ (16)
	*
	* @v blockdev Block device
	* @v block LBA block number
	* @v count Block count
	* @v buffer Data buffer
	* @ret rc Return status code
	*/
	static int scsi_read_16 ( struct block_device *blockdev, uint64_t block,
	unsigned long count, userptr_t buffer ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_read_16 *cdb = &command.cdb.read16;

	/* Issue READ (16) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_READ_16;
	cdb->lba = cpu_to_be64 ( block );
	cdb->len = cpu_to_be32 ( count );
	command.data_in = buffer;
	command.data_in_len = ( count * blockdev->blksize );
	return scsi_command ( scsi, &command );
	}

	/**
	* Write block to SCSI device using WRITE (10)
	*
	* @v blockdev Block device
	* @v block LBA block number
	* @v count Block count
	* @v buffer Data buffer
	* @ret rc Return status code
	*/
	static int scsi_write_10 ( struct block_device *blockdev, uint64_t block,
	unsigned long count, userptr_t buffer ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_write_10 *cdb = &command.cdb.write10;

	/* Issue WRITE (10) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_WRITE_10;
	cdb->lba = cpu_to_be32 ( block );
	cdb->len = cpu_to_be16 ( count );
	command.data_out = buffer;
	command.data_out_len = ( count * blockdev->blksize );
	return scsi_command ( scsi, &command );
	}

	/**
	* Write block to SCSI device using WRITE (16)
	*
	* @v blockdev Block device
	* @v block LBA block number
	* @v count Block count
	* @v buffer Data buffer
	* @ret rc Return status code
	*/
	static int scsi_write_16 ( struct block_device *blockdev, uint64_t block,
	unsigned long count, userptr_t buffer ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_write_16 *cdb = &command.cdb.write16;

	/* Issue WRITE (16) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_WRITE_16;
	cdb->lba = cpu_to_be64 ( block );
	cdb->len = cpu_to_be32 ( count );
	command.data_out = buffer;
	command.data_out_len = ( count * blockdev->blksize );
	return scsi_command ( scsi, &command );
	}

	/**
	* Read capacity of SCSI device via READ CAPACITY (10)
	*
	* @v blockdev Block device
	* @ret rc Return status code
	*/
	static int scsi_read_capacity_10 ( struct block_device *blockdev ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_read_capacity_10 *cdb = &command.cdb.readcap10;
	struct scsi_capacity_10 capacity;
	int rc;

	/* Issue READ CAPACITY (10) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_READ_CAPACITY_10;
	command.data_in = virt_to_user ( &capacity );
	command.data_in_len = sizeof ( capacity );

	if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
	return rc;

	/* Fill in block device fields */
	blockdev->blksize = be32_to_cpu ( capacity.blksize );
	blockdev->blocks = ( be32_to_cpu ( capacity.lba ) + 1 );

	return 0;
	}

	/**
	* Read capacity of SCSI device via READ CAPACITY (16)
	*
	* @v blockdev Block device
	* @ret rc Return status code
	*/
	static int scsi_read_capacity_16 ( struct block_device *blockdev ) {
	struct scsi_device *scsi = block_to_scsi ( blockdev );
	struct scsi_command command;
	struct scsi_cdb_read_capacity_16 *cdb = &command.cdb.readcap16;
	struct scsi_capacity_16 capacity;
	int rc;

	/* Issue READ CAPACITY (16) */
	memset ( &command, 0, sizeof ( command ) );
	cdb->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
	cdb->service_action = SCSI_SERVICE_ACTION_READ_CAPACITY_16;
	cdb->len = cpu_to_be32 ( sizeof ( capacity ) );
	command.data_in = virt_to_user ( &capacity );
	command.data_in_len = sizeof ( capacity );

	if ( ( rc = scsi_command ( scsi, &command ) ) != 0 )
	return rc;

	/* Fill in block device fields */
	blockdev->blksize = be32_to_cpu ( capacity.blksize );
	blockdev->blocks = ( be64_to_cpu ( capacity.lba ) + 1 );
	return 0;
	}

	static struct block_device_operations scsi_operations_16 = {
	.read = scsi_read_16,
	.write = scsi_write_16,
	};

	static struct block_device_operations scsi_operations_10 = {
	.read = scsi_read_10,
	.write = scsi_write_10,
	};

	/**
	* Initialise SCSI device
	*
	* @v scsi SCSI device
	* @ret rc Return status code
	*
	* Initialises a SCSI device. The scsi_device::command and
	* scsi_device::lun fields must already be filled in. This function
	* will configure scsi_device::blockdev, including issuing a READ
	* CAPACITY call to determine the block size and total device size.
	*/
	int init_scsidev ( struct scsi_device *scsi ) {
	unsigned int i;
	int rc;

	/* Issue some theoretically extraneous READ CAPACITY (10)
	* commands, solely in order to draw out the "CHECK CONDITION
	* (power-on occurred)", "CHECK CONDITION (reported LUNs data
	* has changed)" etc. that some dumb targets insist on sending
	* as an error at start of day. The precise command that we
	* use is unimportant; we just need to provide the target with
	* an opportunity to send its responses.
	*/
	for ( i = 0 ; i < SCSI_MAX_DUMMY_READ_CAP ; i++ ) {
	if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) == 0 )
	break;
	DBGC ( scsi, "SCSI %p ignoring start-of-day error (#%d)\n",
	scsi, ( i + 1 ) );
	}

	/* Try READ CAPACITY (10), which is a mandatory command, first. */
	scsi->blockdev.op = &scsi_operations_10;
	if ( ( rc = scsi_read_capacity_10 ( &scsi->blockdev ) ) != 0 ) {
	DBGC ( scsi, "SCSI %p could not READ CAPACITY (10): %s\n",
	scsi, strerror ( rc ) );
	return rc;
	}

	/* If capacity range was exceeded (i.e. capacity.lba was
	* 0xffffffff, meaning that blockdev->blocks is now zero), use
	* READ CAPACITY (16) instead. READ CAPACITY (16) is not
	* mandatory, so we can't just use it straight off.
	*/
	if ( scsi->blockdev.blocks == 0 ) {
	scsi->blockdev.op = &scsi_operations_16;
	if ( ( rc = scsi_read_capacity_16 ( &scsi->blockdev ) ) != 0 ){
	DBGC ( scsi, "SCSI %p could not READ CAPACITY (16): "
	"%s\n", scsi, strerror ( rc ) );
	return rc;
	}
	}

	DBGC ( scsi, "SCSI %p using READ/WRITE (%d) commands\n", scsi,
	( ( scsi->blockdev.op == &scsi_operations_10 ) ? 10 : 16 ) );
	DBGC ( scsi, "SCSI %p capacity is %ld MB (%#llx blocks)\n", scsi,
	( ( unsigned long ) ( scsi->blockdev.blocks >> 11 ) ),
	scsi->blockdev.blocks );

	return 0;
	}

	/**
	* Parse SCSI LUN
	*
	* @v lun_string LUN string representation
	* @v lun LUN to fill in
	* @ret rc Return status code
	*/
	int scsi_parse_lun ( const char lun_string, struct scsi_lun lun ) {
	char *p;
	int i;

	memset ( lun, 0, sizeof ( *lun ) );
	if ( lun_string ) {
	p = ( char * ) lun_string;
	for ( i = 0 ; i < 4 ; i++ ) {
	lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
	if ( *p == '\0' )
	break;
	if ( *p != '-' )
	return -EINVAL;
	p++;
	}
	if ( *p )
	return -EINVAL;
	}

	return 0;
	}