/* usbms.c - USB Mass Storage Support.  */
/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2008  Free Software Foundation, Inc.
 *
 *  GRUB 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.
 *
 *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <grub/dl.h>
#include <grub/mm.h>
#include <grub/usb.h>
#include <grub/scsi.h>
#include <grub/scsicmd.h>
#include <grub/misc.h>

#define GRUB_USBMS_DIRECTION_BIT	7

/* The USB Mass Storage Command Block Wrapper.  */
struct grub_usbms_cbw
{
  grub_uint32_t signature;
  grub_uint32_t tag;
  grub_uint32_t transfer_length;
  grub_uint8_t flags;
  grub_uint8_t lun;
  grub_uint8_t length;
  grub_uint8_t cbwcb[16];
} __attribute__ ((packed));

struct grub_usbms_csw
{
  grub_uint32_t signature;
  grub_uint32_t tag;
  grub_uint32_t residue;
  grub_uint8_t status;
} __attribute__ ((packed));

struct grub_usbms_dev
{
  struct grub_usb_device *dev;

  int luns;

  int interface;
  struct grub_usb_desc_endp *in;
  struct grub_usb_desc_endp *out;

  int in_maxsz;
  int out_maxsz;

  struct grub_usbms_dev *next;
};
typedef struct grub_usbms_dev *grub_usbms_dev_t;

static grub_usbms_dev_t grub_usbms_dev_list;

static int devcnt;

static grub_err_t
grub_usbms_reset (grub_usb_device_t dev, int interface)
{
  return grub_usb_control_msg (dev, 0x21, 255, 0, interface, 0, 0);
}

static void
grub_usbms_finddevs (void)
{
  auto int usb_iterate (grub_usb_device_t dev);

  int usb_iterate (grub_usb_device_t usbdev)
    {
      grub_usb_err_t err;
      struct grub_usb_desc_device *descdev = &usbdev->descdev;
      int i;

      if (descdev->class != 0 || descdev->subclass || descdev->protocol != 0)
	return 0;

      /* XXX: Just check configuration 0 for now.  */
      for (i = 0; i < usbdev->config[0].descconf->numif; i++)
	{
	  struct grub_usbms_dev *usbms;
	  struct grub_usb_desc_if *interf;
	  int j;
	  grub_uint8_t luns;

	  interf = usbdev->config[0].interf[i].descif;

	  /* If this is not a USB Mass Storage device with a supported
	     protocol, just skip it.  */
	  if (interf->class != GRUB_USB_CLASS_MASS_STORAGE
	      || interf->subclass != GRUB_USBMS_SUBCLASS_BULK
	      || interf->protocol != GRUB_USBMS_PROTOCOL_BULK)
	    {
	      continue;
	    }

	  devcnt++;
	  usbms = grub_malloc (sizeof (struct grub_usbms_dev));
	  if (! usbms)
	    return 1;

	  usbms->dev = usbdev;
	  usbms->interface = i;
	  usbms->in = NULL;
	  usbms->out = NULL;

	  /* Iterate over all endpoints of this interface, at least a
	     IN and OUT bulk endpoint are required.  */
	  for (j = 0; j < interf->endpointcnt; j++)
	    {
	      struct grub_usb_desc_endp *endp;
	      endp = &usbdev->config[0].interf[i].descendp[j];

	      if ((endp->endp_addr & 128) && (endp->attrib & 3) == 2)
		{
		  /* Bulk IN endpoint.  */
		  usbms->in = endp;
		  grub_usb_clear_halt (usbdev, endp->endp_addr & 128);
		  usbms->in_maxsz = endp->maxpacket;
		}
	      else if (!(endp->endp_addr & 128) && (endp->attrib & 3) == 2)
		{
		  /* Bulk OUT endpoint.  */
		  usbms->out = endp;
		  grub_usb_clear_halt (usbdev, endp->endp_addr & 128);
		  usbms->out_maxsz = endp->maxpacket;
		}
	    }

	  if (!usbms->in || !usbms->out)
	    {
	      grub_free (usbms);
	      return 0;
	    }

	  /* Query the amount of LUNs.  */
	  err = grub_usb_control_msg (usbdev, 0xA1, 254,
				      0, i, 1, (char *) &luns);
	  if (err)
	    {
	      /* In case of a stall, clear the stall.  */
	      if (err == GRUB_USB_ERR_STALL)
		{
		  grub_usb_clear_halt (usbdev, usbms->in->endp_addr & 3);
		  grub_usb_clear_halt (usbdev, usbms->out->endp_addr & 3);
		}

	      /* Just set the amount of LUNs to one.  */
	      grub_errno = GRUB_ERR_NONE;
	      usbms->luns = 1;
	    }
	  else
	    usbms->luns = luns;

	  /* XXX: Check the magic values, does this really make
	     sense?  */
	  grub_usb_control_msg (usbdev, (1 << 6) | 1, 255,
				0, i, 0, 0);

	  /* XXX: To make Qemu work?  */
	  if (usbms->luns == 0)
	    usbms->luns = 1;

	  usbms->next = grub_usbms_dev_list;
	  grub_usbms_dev_list = usbms;

	  /* XXX: Activate the first configuration.  */
	  grub_usb_set_configuration (usbdev, 1);

	  /* Bolk-Only Mass Storage Reset, after the reset commands
	     will be accepted.  */
	  grub_usbms_reset (usbdev, i);

	  return 0;
	}

      return 0;
    }

  grub_usb_iterate (usb_iterate);
}



static int
grub_usbms_iterate (int (*hook) (const char *name, int luns))
{
  grub_usbms_dev_t p;
  int cnt = 0;

  for (p = grub_usbms_dev_list; p; p = p->next)
    {
      char devname[20];
      grub_sprintf (devname, "usb%d", cnt);

      if (hook (devname, p->luns))
	return 1;
      cnt++;
    }

  return 0;
}

static grub_err_t
grub_usbms_tranfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
		    grub_size_t size, char *buf, int read_write)
{
  struct grub_usbms_cbw cbw;
  grub_usbms_dev_t dev = (grub_usbms_dev_t) scsi->data;
  struct grub_usbms_csw status;
  static grub_uint32_t tag = 0;
  grub_usb_err_t err;
  int retrycnt = 3;

 retry:
  if (retrycnt == 0)
    return err;

  /* Setup the request.  */
  grub_memset (&cbw, 0, sizeof (cbw));
  cbw.signature = grub_cpu_to_le32 (0x43425355);
  cbw.tag = tag++;
  cbw.transfer_length = grub_cpu_to_le32 (size);
  cbw.flags = (!read_write) << GRUB_USBMS_DIRECTION_BIT;
  cbw.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
  cbw.length = cmdsize;
  grub_memcpy (cbw.cbwcb, cmd, cmdsize);

  /* Write the request.  */
  err = grub_usb_bulk_write (dev->dev, dev->out->endp_addr & 15,
			     sizeof (cbw), (char *) &cbw);
  if (err)
    {
      if (err == GRUB_USB_ERR_STALL)
	{
	  grub_usb_clear_halt (dev->dev, dev->out->endp_addr);
	  goto retry;
	}
      return grub_error (GRUB_ERR_IO, "USB Mass Storage request failed");;
    }

  /* Read/write the data.  */
  if (read_write == 0)
    {
      err = grub_usb_bulk_read (dev->dev, dev->in->endp_addr & 15, size, buf);
      grub_dprintf ("usb", "read: %d %d\n", err, GRUB_USB_ERR_STALL);
      if (err)
	{
	  if (err == GRUB_USB_ERR_STALL)
	    {
	      grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
	      goto retry;
	    }
	  return grub_error (GRUB_ERR_READ_ERROR,
			     "can't read from USB Mass Storage device");
	}
    }
  else 
    {
      err = grub_usb_bulk_write (dev->dev, dev->in->endp_addr & 15, size, buf);
      grub_dprintf ("usb", "write: %d %d\n", err, GRUB_USB_ERR_STALL);
      if (err)
	{
	  if (err == GRUB_USB_ERR_STALL)
	    {
	      grub_usb_clear_halt (dev->dev, dev->out->endp_addr);
	      goto retry;
	    }
	  return grub_error (GRUB_ERR_WRITE_ERROR,
			     "can't write to USB Mass Storage device");
	}
    }

  /* Read the status.  */
  err = grub_usb_bulk_read (dev->dev, dev->in->endp_addr & 15,
			    sizeof (status), (char *) &status);
  if (err)
    {
      if (err == GRUB_USB_ERR_STALL)
	{
	  grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
	  goto retry;
	}
      return grub_error (GRUB_ERR_READ_ERROR,
			 "can't read status from USB Mass Storage device");
    }

  /* XXX: Magic and check this code.  */
  if (status.status == 2)
    {
      /* XXX: Phase error, reset device.  */
      grub_usbms_reset (dev->dev, dev->interface);
      grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
      grub_usb_clear_halt (dev->dev, dev->out->endp_addr);

      retrycnt--;
      if (retrycnt)
	goto retry;
    }

  if (status.status)
    return grub_error (GRUB_ERR_READ_ERROR,
		       "error communication with USB Mass Storage device");

  return GRUB_ERR_NONE;
}


static grub_err_t
grub_usbms_read (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
		 grub_size_t size, char *buf)
{
  return grub_usbms_tranfer (scsi, cmdsize, cmd, size, buf, 0);
}

static grub_err_t
grub_usbms_write (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
		  grub_size_t size, char *buf)
{
  return grub_usbms_tranfer (scsi, cmdsize, cmd, size, buf, 1);
}

static grub_err_t
grub_usbms_open (const char *name, struct grub_scsi *scsi)
{
  grub_usbms_dev_t p;
  int devnum;
  int i = 0;

  if (grub_strncmp (name, "usb", 3))
    return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
		       "not a USB Mass Storage device");

  devnum = grub_strtoul (name + 3, NULL, 10);
  for (p = grub_usbms_dev_list; p; p = p->next)
    {
      /* Check if this is the devnumth device.  */
      if (devnum == i)
	{
	  scsi->data = p;
	  scsi->name = grub_strdup (name);
	  scsi->luns = p->luns;
	  if (! scsi->name)
	    return grub_errno;

	  return GRUB_ERR_NONE;
	}

      i++;
    }

  return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
		     "not a USB Mass Storage device");
}

static void
grub_usbms_close (struct grub_scsi *scsi)
{
  grub_free (scsi->name);
}

static struct grub_scsi_dev grub_usbms_dev =
  {
    .name = "usb",
    .iterate = grub_usbms_iterate,
    .open = grub_usbms_open,
    .close = grub_usbms_close,
    .read = grub_usbms_read,
    .write = grub_usbms_write
  }; 

GRUB_MOD_INIT(usbms)
{
  grub_usbms_finddevs ();
  grub_scsi_dev_register (&grub_usbms_dev);
}

GRUB_MOD_FINI(usbms)
{
  grub_scsi_dev_unregister (&grub_usbms_dev);
}