disk/usbms.c

   1 /* usbms.c - USB Mass Storage Support.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/dl.h>
  21 #include <grub/mm.h>
  22 #include <grub/usb.h>
  23 #include <grub/scsi.h>
  24 #include <grub/scsicmd.h>
  25 #include <grub/misc.h>
  26
  27 #define GRUB_USBMS_DIRECTION_BIT        7
  28
  29 /* The USB Mass Storage Command Block Wrapper.  */
  30 struct grub_usbms_cbw
  31 {
  32   grub_uint32_t signature;
  33   grub_uint32_t tag;
  34   grub_uint32_t transfer_length;
  35   grub_uint8_t flags;
  36   grub_uint8_t lun;
  37   grub_uint8_t length;
  38   grub_uint8_t cbwcb[16];
  39 } __attribute__ ((packed));
  40
  41 struct grub_usbms_csw
  42 {
  43   grub_uint32_t signature;
  44   grub_uint32_t tag;
  45   grub_uint32_t residue;
  46   grub_uint8_t status;
  47 } __attribute__ ((packed));
  48
  49 struct grub_usbms_dev
  50 {
  51   struct grub_usb_device *dev;
  52
  53   int luns;
  54
  55   int interface;
  56   struct grub_usb_desc_endp *in;
  57   struct grub_usb_desc_endp *out;
  58
  59   int in_maxsz;
  60   int out_maxsz;
  61
  62   struct grub_usbms_dev *next;
  63 };
  64 typedef struct grub_usbms_dev *grub_usbms_dev_t;
  65
  66 static grub_usbms_dev_t grub_usbms_dev_list;
  67
  68 static int devcnt;
  69
  70 static grub_err_t
  71 grub_usbms_reset (grub_usb_device_t dev, int interface)
  72 {
  73   return grub_usb_control_msg (dev, 0x21, 255, 0, interface, 0, 0);
  74 }
  75
  76 static void
  77 grub_usbms_finddevs (void)
  78 {
  79   auto int usb_iterate (grub_usb_device_t dev);
  80
  81   int usb_iterate (grub_usb_device_t usbdev)
  82     {
  83       grub_usb_err_t err;
  84       struct grub_usb_desc_device *descdev = &usbdev->descdev;
  85       int i;
  86
  87       if (descdev->class != 0 || descdev->subclass || descdev->protocol != 0)
  88         return 0;
  89
  90       /* XXX: Just check configuration 0 for now.  */
  91       for (i = 0; i < usbdev->config[0].descconf->numif; i++)
  92         {
  93           struct grub_usbms_dev *usbms;
  94           struct grub_usb_desc_if *interf;
  95           int j;
  96           grub_uint8_t luns;
  97
  98           interf = usbdev->config[0].interf[i].descif;
  99
 100           /* If this is not a USB Mass Storage device with a supported
 101              protocol, just skip it.  */
 102           if (interf->class != GRUB_USB_CLASS_MASS_STORAGE
 103               || interf->subclass != GRUB_USBMS_SUBCLASS_BULK
 104               || interf->protocol != GRUB_USBMS_PROTOCOL_BULK)
 105             {
 106               continue;
 107             }
 108
 109           devcnt++;
 110           usbms = grub_malloc (sizeof (struct grub_usbms_dev));
 111           if (! usbms)
 112             return 1;
 113
 114           usbms->dev = usbdev;
 115           usbms->interface = i;
 116           usbms->in = NULL;
 117           usbms->out = NULL;
 118
 119           /* Iterate over all endpoints of this interface, at least a
 120              IN and OUT bulk endpoint are required.  */
 121           for (j = 0; j < interf->endpointcnt; j++)
 122             {
 123               struct grub_usb_desc_endp *endp;
 124               endp = &usbdev->config[0].interf[i].descendp[j];
 125
 126               if ((endp->endp_addr & 128) && (endp->attrib & 3) == 2)
 127                 {
 128                   /* Bulk IN endpoint.  */
 129                   usbms->in = endp;
 130                   grub_usb_clear_halt (usbdev, endp->endp_addr & 128);
 131                   usbms->in_maxsz = endp->maxpacket;
 132                 }
 133               else if (!(endp->endp_addr & 128) && (endp->attrib & 3) == 2)
 134                 {
 135                   /* Bulk OUT endpoint.  */
 136                   usbms->out = endp;
 137                   grub_usb_clear_halt (usbdev, endp->endp_addr & 128);
 138                   usbms->out_maxsz = endp->maxpacket;
 139                 }
 140             }
 141
 142           if (!usbms->in || !usbms->out)
 143             {
 144               grub_free (usbms);
 145               return 0;
 146             }
 147
 148           /* Query the amount of LUNs.  */
 149           err = grub_usb_control_msg (usbdev, 0xA1, 254,
 150                                       0, i, 1, (char *) &luns);
 151           if (err)
 152             {
 153               /* In case of a stall, clear the stall.  */
 154               if (err == GRUB_USB_ERR_STALL)
 155                 {
 156                   grub_usb_clear_halt (usbdev, usbms->in->endp_addr & 3);
 157                   grub_usb_clear_halt (usbdev, usbms->out->endp_addr & 3);
 158                 }
 159
 160               /* Just set the amount of LUNs to one.  */
 161               grub_errno = GRUB_ERR_NONE;
 162               usbms->luns = 1;
 163             }
 164           else
 165             usbms->luns = luns;
 166
 167           /* XXX: Check the magic values, does this really make
 168              sense?  */
 169           grub_usb_control_msg (usbdev, (1 << 6) | 1, 255,
 170                                 0, i, 0, 0);
 171
 172           /* XXX: To make Qemu work?  */
 173           if (usbms->luns == 0)
 174             usbms->luns = 1;
 175
 176           usbms->next = grub_usbms_dev_list;
 177           grub_usbms_dev_list = usbms;
 178
 179           /* XXX: Activate the first configuration.  */
 180           grub_usb_set_configuration (usbdev, 1);
 181
 182           /* Bulk-Only Mass Storage Reset, after the reset commands
 183              will be accepted.  */
 184           grub_usbms_reset (usbdev, i);
 185
 186           return 0;
 187         }
 188
 189       return 0;
 190     }
 191
 192   grub_usb_iterate (usb_iterate);
 193 }
 194
 195 \f
 196
 197 static int
 198 grub_usbms_iterate (int (*hook) (const char *name, int luns))
 199 {
 200   grub_usbms_dev_t p;
 201   int cnt = 0;
 202
 203   for (p = grub_usbms_dev_list; p; p = p->next)
 204     {
 205       char devname[20];
 206       grub_sprintf (devname, "usb%d", cnt);
 207
 208       if (hook (devname, p->luns))
 209         return 1;
 210       cnt++;
 211     }
 212
 213   return 0;
 214 }
 215
 216 static grub_err_t
 217 grub_usbms_transfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
 218                      grub_size_t size, char *buf, int read_write)
 219 {
 220   struct grub_usbms_cbw cbw;
 221   grub_usbms_dev_t dev = (grub_usbms_dev_t) scsi->data;
 222   struct grub_usbms_csw status;
 223   static grub_uint32_t tag = 0;
 224   grub_usb_err_t err = GRUB_USB_ERR_NONE;
 225   int retrycnt = 3 + 1;
 226
 227  retry:
 228   retrycnt--;
 229   if (retrycnt == 0)
 230     return grub_error (GRUB_ERR_IO, "USB Mass Storage stalled");
 231
 232   /* Setup the request.  */
 233   grub_memset (&cbw, 0, sizeof (cbw));
 234   cbw.signature = grub_cpu_to_le32 (0x43425355);
 235   cbw.tag = tag++;
 236   cbw.transfer_length = grub_cpu_to_le32 (size);
 237   cbw.flags = (!read_write) << GRUB_USBMS_DIRECTION_BIT;
 238   cbw.lun = scsi->lun << GRUB_SCSI_LUN_SHIFT;
 239   cbw.length = cmdsize;
 240   grub_memcpy (cbw.cbwcb, cmd, cmdsize);
 241
 242   /* Write the request.  */
 243   err = grub_usb_bulk_write (dev->dev, dev->out->endp_addr & 15,
 244                              sizeof (cbw), (char *) &cbw);
 245   if (err)
 246     {
 247       if (err == GRUB_USB_ERR_STALL)
 248         {
 249           grub_usb_clear_halt (dev->dev, dev->out->endp_addr);
 250           goto retry;
 251         }
 252       return grub_error (GRUB_ERR_IO, "USB Mass Storage request failed");;
 253     }
 254
 255   /* Read/write the data.  */
 256   if (read_write == 0)
 257     {
 258       err = grub_usb_bulk_read (dev->dev, dev->in->endp_addr & 15, size, buf);
 259       grub_dprintf ("usb", "read: %d %d\n", err, GRUB_USB_ERR_STALL);
 260       if (err)
 261         {
 262           if (err == GRUB_USB_ERR_STALL)
 263             {
 264               grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
 265               goto retry;
 266             }
 267           return grub_error (GRUB_ERR_READ_ERROR,
 268                              "can't read from USB Mass Storage device");
 269         }
 270     }
 271   else
 272     {
 273       err = grub_usb_bulk_write (dev->dev, dev->in->endp_addr & 15, size, buf);
 274       grub_dprintf ("usb", "write: %d %d\n", err, GRUB_USB_ERR_STALL);
 275       if (err)
 276         {
 277           if (err == GRUB_USB_ERR_STALL)
 278             {
 279               grub_usb_clear_halt (dev->dev, dev->out->endp_addr);
 280               goto retry;
 281             }
 282           return grub_error (GRUB_ERR_WRITE_ERROR,
 283                              "can't write to USB Mass Storage device");
 284         }
 285     }
 286
 287   /* Read the status.  */
 288   err = grub_usb_bulk_read (dev->dev, dev->in->endp_addr & 15,
 289                             sizeof (status), (char *) &status);
 290   if (err)
 291     {
 292       if (err == GRUB_USB_ERR_STALL)
 293         {
 294           grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
 295           goto retry;
 296         }
 297       return grub_error (GRUB_ERR_READ_ERROR,
 298                          "can't read status from USB Mass Storage device");
 299     }
 300
 301   /* XXX: Magic and check this code.  */
 302   if (status.status == 2)
 303     {
 304       /* XXX: Phase error, reset device.  */
 305       grub_usbms_reset (dev->dev, dev->interface);
 306       grub_usb_clear_halt (dev->dev, dev->in->endp_addr);
 307       grub_usb_clear_halt (dev->dev, dev->out->endp_addr);
 308
 309       goto retry;
 310     }
 311
 312   if (status.status)
 313     return grub_error (GRUB_ERR_READ_ERROR,
 314                        "error communication with USB Mass Storage device");
 315
 316   return GRUB_ERR_NONE;
 317 }
 318
 319
 320 static grub_err_t
 321 grub_usbms_read (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
 322                  grub_size_t size, char *buf)
 323 {
 324   return grub_usbms_transfer (scsi, cmdsize, cmd, size, buf, 0);
 325 }
 326
 327 static grub_err_t
 328 grub_usbms_write (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
 329                   grub_size_t size, char *buf)
 330 {
 331   return grub_usbms_transfer (scsi, cmdsize, cmd, size, buf, 1);
 332 }
 333
 334 static grub_err_t
 335 grub_usbms_open (const char *name, struct grub_scsi *scsi)
 336 {
 337   grub_usbms_dev_t p;
 338   int devnum;
 339   int i = 0;
 340
 341   if (grub_strncmp (name, "usb", 3))
 342     return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
 343                        "not a USB Mass Storage device");
 344
 345   devnum = grub_strtoul (name + 3, NULL, 10);
 346   for (p = grub_usbms_dev_list; p; p = p->next)
 347     {
 348       /* Check if this is the devnumth device.  */
 349       if (devnum == i)
 350         {
 351           scsi->data = p;
 352           scsi->name = grub_strdup (name);
 353           scsi->luns = p->luns;
 354           if (! scsi->name)
 355             return grub_errno;
 356
 357           return GRUB_ERR_NONE;
 358         }
 359
 360       i++;
 361     }
 362
 363   return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
 364                      "not a USB Mass Storage device");
 365 }
 366
 367 static void
 368 grub_usbms_close (struct grub_scsi *scsi)
 369 {
 370   grub_free (scsi->name);
 371 }
 372
 373 static struct grub_scsi_dev grub_usbms_dev =
 374   {
 375     .name = "usb",
 376     .iterate = grub_usbms_iterate,
 377     .open = grub_usbms_open,
 378     .close = grub_usbms_close,
 379     .read = grub_usbms_read,
 380     .write = grub_usbms_write
 381   };
 382
 383 GRUB_MOD_INIT(usbms)
 384 {
 385   grub_usbms_finddevs ();
 386   grub_scsi_dev_register (&grub_usbms_dev);
 387 }
 388
 389 GRUB_MOD_FINI(usbms)
 390 {
 391   grub_scsi_dev_unregister (&grub_usbms_dev);
 392 }