/* scsi.c - scsi support.  */
/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2008,2009  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT 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 VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/disk.h>
#include <VasEBoot/dl.h>
#include <VasEBoot/kernel.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/types.h>
#include <VasEBoot/scsi.h>
#include <VasEBoot/scsicmd.h>
#include <VasEBoot/time.h>
#include <VasEBoot/i18n.h>

VAS_EBOOT_MOD_LICENSE ("GPLv3+");


static VasEBoot_scsi_dev_t VasEBoot_scsi_dev_list;

const char VasEBoot_scsi_names[VAS_EBOOT_SCSI_NUM_SUBSYSTEMS][5] = {
  [VAS_EBOOT_SCSI_SUBSYSTEM_USBMS] = "usb",
  [VAS_EBOOT_SCSI_SUBSYSTEM_PATA] = "ata",
  [VAS_EBOOT_SCSI_SUBSYSTEM_AHCI] = "ahci"
};

void
VasEBoot_scsi_dev_register (VasEBoot_scsi_dev_t dev)
{
  dev->next = VasEBoot_scsi_dev_list;
  VasEBoot_scsi_dev_list = dev;
}

void
VasEBoot_scsi_dev_unregister (VasEBoot_scsi_dev_t dev)
{
  VasEBoot_scsi_dev_t *p, q;

  for (p = &VasEBoot_scsi_dev_list, q = *p; q; p = &(q->next), q = q->next)
    if (q == dev)
      {
        *p = q->next;
	break;
      }
}


/* Check result of previous operation.  */
static VasEBoot_err_t
VasEBoot_scsi_request_sense (VasEBoot_scsi_t scsi)
{
  struct VasEBoot_scsi_request_sense rs;
  struct VasEBoot_scsi_request_sense_data rsd;
  VasEBoot_err_t err;

  rs.opcode = VasEBoot_scsi_cmd_request_sense;
  rs.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  rs.reserved1 = 0;
  rs.reserved2 = 0;
  rs.alloc_length = 0x12; /* XXX: Hardcoded for now */
  rs.control = 0;
  VasEBoot_memset (rs.pad, 0, sizeof(rs.pad));

  err = scsi->dev->read (scsi, sizeof (rs), (char *) &rs,
			 sizeof (rsd), (char *) &rsd);
  if (err)
    return err;

  return VAS_EBOOT_ERR_NONE;
}
/* Self commenting... */
static VasEBoot_err_t
VasEBoot_scsi_test_unit_ready (VasEBoot_scsi_t scsi)
{
  struct VasEBoot_scsi_test_unit_ready tur;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  tur.opcode = VasEBoot_scsi_cmd_test_unit_ready;
  tur.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  tur.reserved1 = 0;
  tur.reserved2 = 0;
  tur.reserved3 = 0;
  tur.control = 0;
  VasEBoot_memset (tur.pad, 0, sizeof(tur.pad));

  err = scsi->dev->read (scsi, sizeof (tur), (char *) &tur,
			 0, NULL);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  if (err)
    return err;

  return VAS_EBOOT_ERR_NONE;
}

/* Determine if the device is removable and the type of the device
   SCSI.  */
static VasEBoot_err_t
VasEBoot_scsi_inquiry (VasEBoot_scsi_t scsi)
{
  struct VasEBoot_scsi_inquiry iq;
  struct VasEBoot_scsi_inquiry_data iqd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  iq.opcode = VasEBoot_scsi_cmd_inquiry;
  iq.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  iq.page = 0;
  iq.reserved = 0;
  iq.alloc_length = 0x24; /* XXX: Hardcoded for now */
  iq.control = 0;
  VasEBoot_memset (iq.pad, 0, sizeof(iq.pad));

  err = scsi->dev->read (scsi, sizeof (iq), (char *) &iq,
			 sizeof (iqd), (char *) &iqd);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  if (err)
    return err;

  scsi->devtype = iqd.devtype & VAS_EBOOT_SCSI_DEVTYPE_MASK;
  scsi->removable = iqd.rmb >> VAS_EBOOT_SCSI_REMOVABLE_BIT;

  return VAS_EBOOT_ERR_NONE;
}

/* Read the capacity and block size of SCSI.  */
static VasEBoot_err_t
VasEBoot_scsi_read_capacity10 (VasEBoot_scsi_t scsi)
{
  struct VasEBoot_scsi_read_capacity10 rc;
  struct VasEBoot_scsi_read_capacity10_data rcd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  rc.opcode = VasEBoot_scsi_cmd_read_capacity10;
  rc.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  rc.logical_block_addr = 0;
  rc.reserved1 = 0;
  rc.reserved2 = 0;
  rc.PMI = 0;
  rc.control = 0;
  rc.pad = 0;

  err = scsi->dev->read (scsi, sizeof (rc), (char *) &rc,
			 sizeof (rcd), (char *) &rcd);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
/* err_sense is ignored for now and Request Sense Data also... */

  if (err)
    return err;

  scsi->last_block = VasEBoot_be_to_cpu32 (rcd.last_block);
  scsi->blocksize = VasEBoot_be_to_cpu32 (rcd.blocksize);

  return VAS_EBOOT_ERR_NONE;
}

/* Read the capacity and block size of SCSI.  */
static VasEBoot_err_t
VasEBoot_scsi_read_capacity16 (VasEBoot_scsi_t scsi)
{
  struct VasEBoot_scsi_read_capacity16 rc;
  struct VasEBoot_scsi_read_capacity16_data rcd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  rc.opcode = VasEBoot_scsi_cmd_read_capacity16;
  rc.lun = (scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT) | 0x10;
  rc.logical_block_addr = 0;
  rc.alloc_len = VasEBoot_cpu_to_be32_compile_time (sizeof (rcd));
  rc.PMI = 0;
  rc.control = 0;

  err = scsi->dev->read (scsi, sizeof (rc), (char *) &rc,
			 sizeof (rcd), (char *) &rcd);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
/* err_sense is ignored for now and Request Sense Data also... */

  if (err)
    return err;

  scsi->last_block = VasEBoot_be_to_cpu64 (rcd.last_block);
  scsi->blocksize = VasEBoot_be_to_cpu32 (rcd.blocksize);

  return VAS_EBOOT_ERR_NONE;
}

/* Send a SCSI request for DISK: read SIZE sectors starting with
   sector SECTOR to BUF.  */
static VasEBoot_err_t
VasEBoot_scsi_read10 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		  VasEBoot_size_t size, char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_read10 rd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  rd.opcode = VasEBoot_scsi_cmd_read10;
  rd.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  rd.lba = VasEBoot_cpu_to_be32 (sector);
  rd.reserved = 0;
  rd.size = VasEBoot_cpu_to_be16 (size);
  rd.reserved2 = 0;
  rd.pad = 0;

  err = scsi->dev->read (scsi, sizeof (rd), (char *) &rd, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}

/* Send a SCSI request for DISK: read SIZE sectors starting with
   sector SECTOR to BUF.  */
static VasEBoot_err_t
VasEBoot_scsi_read12 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		  VasEBoot_size_t size, char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_read12 rd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  rd.opcode = VasEBoot_scsi_cmd_read12;
  rd.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  rd.lba = VasEBoot_cpu_to_be32 (sector);
  rd.size = VasEBoot_cpu_to_be32 (size);
  rd.reserved = 0;
  rd.control = 0;

  err = scsi->dev->read (scsi, sizeof (rd), (char *) &rd, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}

/* Send a SCSI request for DISK: read SIZE sectors starting with
   sector SECTOR to BUF.  */
static VasEBoot_err_t
VasEBoot_scsi_read16 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		  VasEBoot_size_t size, char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_read16 rd;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  rd.opcode = VasEBoot_scsi_cmd_read16;
  rd.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  rd.lba = VasEBoot_cpu_to_be64 (sector);
  rd.size = VasEBoot_cpu_to_be32 (size);
  rd.reserved = 0;
  rd.control = 0;

  err = scsi->dev->read (scsi, sizeof (rd), (char *) &rd, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}

/* Send a SCSI request for DISK: write the data stored in BUF to SIZE
   sectors starting with SECTOR.  */
static VasEBoot_err_t
VasEBoot_scsi_write10 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		   VasEBoot_size_t size, const char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_write10 wr;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  wr.opcode = VasEBoot_scsi_cmd_write10;
  wr.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  wr.lba = VasEBoot_cpu_to_be32 (sector);
  wr.reserved = 0;
  wr.size = VasEBoot_cpu_to_be16 (size);
  wr.reserved2 = 0;
  wr.pad = 0;

  err = scsi->dev->write (scsi, sizeof (wr), (char *) &wr, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}

#if 0

/* Send a SCSI request for DISK: write the data stored in BUF to SIZE
   sectors starting with SECTOR.  */
static VasEBoot_err_t
VasEBoot_scsi_write12 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		   VasEBoot_size_t size, char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_write12 wr;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  wr.opcode = VasEBoot_scsi_cmd_write12;
  wr.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  wr.lba = VasEBoot_cpu_to_be32 (sector);
  wr.size = VasEBoot_cpu_to_be32 (size);
  wr.reserved = 0;
  wr.control = 0;

  err = scsi->dev->write (scsi, sizeof (wr), (char *) &wr, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}
#endif

/* Send a SCSI request for DISK: write the data stored in BUF to SIZE
   sectors starting with SECTOR.  */
static VasEBoot_err_t
VasEBoot_scsi_write16 (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		   VasEBoot_size_t size, const char *buf)
{
  VasEBoot_scsi_t scsi;
  struct VasEBoot_scsi_write16 wr;
  VasEBoot_err_t err;
  VasEBoot_err_t err_sense;

  scsi = disk->data;

  wr.opcode = VasEBoot_scsi_cmd_write16;
  wr.lun = scsi->lun << VAS_EBOOT_SCSI_LUN_SHIFT;
  wr.lba = VasEBoot_cpu_to_be64 (sector);
  wr.size = VasEBoot_cpu_to_be32 (size);
  wr.reserved = 0;
  wr.control = 0;

  err = scsi->dev->write (scsi, sizeof (wr), (char *) &wr, size * scsi->blocksize, buf);

  /* Each SCSI command should be followed by Request Sense.
     If not so, many devices STALLs or definitely freezes. */
  err_sense = VasEBoot_scsi_request_sense (scsi);
  if (err_sense != VAS_EBOOT_ERR_NONE)
  	VasEBoot_errno = err;
  /* err_sense is ignored for now and Request Sense Data also... */

  return err;
}



/* Context for VasEBoot_scsi_iterate.  */
struct VasEBoot_scsi_iterate_ctx
{
  VasEBoot_disk_dev_iterate_hook_t hook;
  void *hook_data;
};

/* Helper for VasEBoot_scsi_iterate.  */
static int
scsi_iterate (int id, int bus, int luns, void *data)
{
  struct VasEBoot_scsi_iterate_ctx *ctx = data;
  int i;

  /* In case of a single LUN, just return `usbX'.  */
  if (luns == 1)
    {
      char *sname;
      int ret;
      sname = VasEBoot_xasprintf ("%s%d", VasEBoot_scsi_names[id], bus);
      if (!sname)
	return 1;
      ret = ctx->hook (sname, ctx->hook_data);
      VasEBoot_free (sname);
      return ret;
    }

  /* In case of multiple LUNs, every LUN will get a prefix to
     distinguish it.  */
  for (i = 0; i < luns; i++)
    {
      char *sname;
      int ret;
      sname = VasEBoot_xasprintf ("%s%d%c", VasEBoot_scsi_names[id], bus, 'a' + i);
      if (!sname)
	return 1;
      ret = ctx->hook (sname, ctx->hook_data);
      VasEBoot_free (sname);
      if (ret)
	return 1;
    }
  return 0;
}

static int
VasEBoot_scsi_iterate (VasEBoot_disk_dev_iterate_hook_t hook, void *hook_data,
		   VasEBoot_disk_pull_t pull)
{
  struct VasEBoot_scsi_iterate_ctx ctx = { hook, hook_data };
  VasEBoot_scsi_dev_t p;

  for (p = VasEBoot_scsi_dev_list; p; p = p->next)
    if (p->iterate && (p->iterate) (scsi_iterate, &ctx, pull))
      return 1;

  return 0;
}

static VasEBoot_err_t
VasEBoot_scsi_open (const char *name, VasEBoot_disk_t disk)
{
  VasEBoot_scsi_dev_t p;
  VasEBoot_scsi_t scsi;
  VasEBoot_err_t err;
  int lun, bus;
  VasEBoot_uint64_t maxtime;
  const char *nameend;
  unsigned id;

  nameend = name + VasEBoot_strlen (name) - 1;
  /* Try to detect a LUN ('a'-'z'), otherwise just use the first
     LUN.  */
  if (nameend >= name && *nameend >= 'a' && *nameend <= 'z')
    {
      lun = *nameend - 'a';
      nameend--;
    }
  else
    lun = 0;

  while (nameend >= name && VasEBoot_isdigit (*nameend))
    nameend--;

  if (!nameend[1] || !VasEBoot_isdigit (nameend[1]))
    return VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE, "not a SCSI disk");

  bus = VasEBoot_strtoul (nameend + 1, 0, 0);

  scsi = VasEBoot_malloc (sizeof (*scsi));
  if (! scsi)
    return VasEBoot_errno;

  for (id = 0; id < ARRAY_SIZE (VasEBoot_scsi_names); id++)
    if (VasEBoot_strncmp (VasEBoot_scsi_names[id], name, nameend - name) == 0)
      break;

  if (id == ARRAY_SIZE (VasEBoot_scsi_names))
    {
      VasEBoot_free (scsi);
      return VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
    }

  for (p = VasEBoot_scsi_dev_list; p; p = p->next)
    {
      if (p->open (id, bus, scsi))
	{
	  VasEBoot_errno = VAS_EBOOT_ERR_NONE;
	  continue;
	}

      disk->id = VasEBoot_make_scsi_id (id, bus, lun);
      disk->data = scsi;
      scsi->dev = p;
      scsi->lun = lun;
      scsi->bus = bus;

      VasEBoot_dprintf ("scsi", "dev opened\n");

      err = VasEBoot_scsi_inquiry (scsi);
      if (err)
	{
	  VasEBoot_free (scsi);
	  VasEBoot_dprintf ("scsi", "inquiry failed\n");
	  return err;
	}

      VasEBoot_dprintf ("scsi", "inquiry: devtype=0x%02x removable=%d\n",
		    scsi->devtype, scsi->removable);

      /* Try to be conservative about the device types
	 supported.  */
      if (scsi->devtype != VasEBoot_scsi_devtype_direct
	  && scsi->devtype != VasEBoot_scsi_devtype_cdrom)
	{
	  VasEBoot_free (scsi);
	  return VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE,
			     "unknown SCSI device");
	}

      /* According to USB MS tests specification, issue Test Unit Ready
       * until OK */
      maxtime = VasEBoot_get_time_ms () + 5000; /* It is safer value */
      do
        {
	  /* Timeout is necessary - for example in case when we have
	   * universal card reader with more LUNs and we have only
	   * one card inserted (or none), so only one LUN (or none)
	   * will be ready - and we want not to hang... */
	  if (VasEBoot_get_time_ms () > maxtime)
            {
              err = VAS_EBOOT_ERR_READ_ERROR;
              VasEBoot_free (scsi);
              VasEBoot_dprintf ("scsi", "LUN is not ready - timeout\n");
              return err;
            }
          err = VasEBoot_scsi_test_unit_ready (scsi);
        }
      while (err == VAS_EBOOT_ERR_READ_ERROR);
      /* Reset VasEBoot_errno !
       * It is set to some error code in loop before... */
      VasEBoot_errno = VAS_EBOOT_ERR_NONE;

      /* Read capacity of media */
      err = VasEBoot_scsi_read_capacity10 (scsi);
      if (err)
	{
	  VasEBoot_free (scsi);
	  VasEBoot_dprintf ("scsi", "READ CAPACITY10 failed\n");
	  return err;
	}

      if (scsi->last_block == 0xffffffff)
	{
	  err = VasEBoot_scsi_read_capacity16 (scsi);
	  if (err)
	    {
	      VasEBoot_free (scsi);
	      VasEBoot_dprintf ("scsi", "READ CAPACITY16 failed\n");
	      return err;
	    }
	}

      disk->total_sectors = scsi->last_block + 1;
      /* PATA doesn't support more than 32K reads.
	 Not sure about AHCI and USB. If it's confirmed that either of
	 them can do bigger reads reliably this value can be moved to 'scsi'
	 structure.  */
      disk->max_agglomerate = 32768 >> (VAS_EBOOT_DISK_SECTOR_BITS
					+ VAS_EBOOT_DISK_CACHE_BITS);

      if (scsi->blocksize & (scsi->blocksize - 1) || !scsi->blocksize)
	{
	  VasEBoot_error (VAS_EBOOT_ERR_IO, "invalid sector size %d",
		      scsi->blocksize);
	  VasEBoot_free (scsi);
	  return VasEBoot_errno;
	}
      disk->log_sector_size = VasEBoot_log2ull (scsi->blocksize);

      VasEBoot_dprintf ("scsi", "last_block=%" PRIuVAS_EBOOT_UINT64_T ", blocksize=%u\n",
		    scsi->last_block, scsi->blocksize);
      VasEBoot_dprintf ("scsi", "Disk total sectors = %llu\n",
		    (unsigned long long) disk->total_sectors);

      return VAS_EBOOT_ERR_NONE;
    }

  VasEBoot_free (scsi);
  return VasEBoot_error (VAS_EBOOT_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
}

static void
VasEBoot_scsi_close (VasEBoot_disk_t disk)
{
  VasEBoot_scsi_t scsi;

  scsi = disk->data;
  if (scsi->dev->close)
    scsi->dev->close (scsi);
  VasEBoot_free (scsi);
}

static VasEBoot_err_t
VasEBoot_scsi_read (VasEBoot_disk_t disk, VasEBoot_disk_addr_t sector,
		VasEBoot_size_t size, char *buf)
{
  VasEBoot_scsi_t scsi;

  scsi = disk->data;

  VasEBoot_err_t err;
  /* Depending on the type, select a read function.  */
  switch (scsi->devtype)
    {
    case VasEBoot_scsi_devtype_direct:
      if (sector >> 32)
	err = VasEBoot_scsi_read16 (disk, sector, size, buf);
      else
	err = VasEBoot_scsi_read10 (disk, sector, size, buf);
      if (err)
	return err;
      break;

    case VasEBoot_scsi_devtype_cdrom:
      if (sector >> 32)
	err = VasEBoot_scsi_read16 (disk, sector, size, buf);
      else
	err = VasEBoot_scsi_read12 (disk, sector, size, buf);
      if (err)
	return err;
      break;
    }

  return VAS_EBOOT_ERR_NONE;

#if 0 /* Workaround - it works - but very slowly, from some reason
       * unknown to me (specially on OHCI). Do not use it. */
  /* Split transfer requests to device sector size because */
  /* some devices are not able to transfer more than 512-1024 bytes */
  VasEBoot_err_t err = VAS_EBOOT_ERR_NONE;

  for ( ; size; size--)
    {
      /* Depending on the type, select a read function.  */
      switch (scsi->devtype)
        {
          case VasEBoot_scsi_devtype_direct:
            err = VasEBoot_scsi_read10 (disk, sector, 1, buf);
            break;

          case VasEBoot_scsi_devtype_cdrom:
            err = VasEBoot_scsi_read12 (disk, sector, 1, buf);
            break;

          default: /* This should not happen */
            return VAS_EBOOT_ERR_READ_ERROR;
        }
      if (err)
        return err;
      sector++;
      buf += scsi->blocksize;
    }

  return err;
#endif
}

static VasEBoot_err_t
VasEBoot_scsi_write (VasEBoot_disk_t disk,
		 VasEBoot_disk_addr_t sector,
		 VasEBoot_size_t size,
		 const char *buf)
{
  VasEBoot_scsi_t scsi;

  scsi = disk->data;

  if (scsi->devtype == VasEBoot_scsi_devtype_cdrom)
    return VasEBoot_error (VAS_EBOOT_ERR_IO, N_("cannot write to CD-ROM"));

  VasEBoot_err_t err;
  /* Depending on the type, select a read function.  */
  switch (scsi->devtype)
    {
    case VasEBoot_scsi_devtype_direct:
      if (sector >> 32)
	err = VasEBoot_scsi_write16 (disk, sector, size, buf);
      else
	err = VasEBoot_scsi_write10 (disk, sector, size, buf);
      if (err)
	return err;
      break;
    }

  return VAS_EBOOT_ERR_NONE;
}


static struct VasEBoot_disk_dev VasEBoot_scsi_dev =
  {
    .name = "scsi",
    .id = VAS_EBOOT_DISK_DEVICE_SCSI_ID,
    .disk_iterate = VasEBoot_scsi_iterate,
    .disk_open = VasEBoot_scsi_open,
    .disk_close = VasEBoot_scsi_close,
    .disk_read = VasEBoot_scsi_read,
    .disk_write = VasEBoot_scsi_write,
    .next = 0
  };

VAS_EBOOT_MOD_INIT(scsi)
{
  VasEBoot_disk_dev_register (&VasEBoot_scsi_dev);
}

VAS_EBOOT_MOD_FINI(scsi)
{
  VasEBoot_disk_dev_unregister (&VasEBoot_scsi_dev);
}