drivers/usb/storage/shuttle_usbat.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable
   4  *
   5  * Current development and maintenance by:
   6  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
   7  *   (c) 2004, 2005 Daniel Drake <dsd@gentoo.org>
   8  *
   9  * Developed with the assistance of:
  10  *   (c) 2002 Alan Stern <stern@rowland.org>
  11  *
  12  * Flash support based on earlier work by:
  13  *   (c) 2002 Thomas Kreiling <usbdev@sm04.de>
  14  *
  15  * Many originally ATAPI devices were slightly modified to meet the USB
  16  * market by using some kind of translation from ATAPI to USB on the host,
  17  * and the peripheral would translate from USB back to ATAPI.
  18  *
  19  * SCM Microsystems (www.scmmicro.com) makes a device, sold to OEM's only,
  20  * which does the USB-to-ATAPI conversion.  By obtaining the data sheet on
  21  * their device under nondisclosure agreement, I have been able to write
  22  * this driver for Linux.
  23  *
  24  * The chip used in the device can also be used for EPP and ISA translation
  25  * as well. This driver is only guaranteed to work with the ATAPI
  26  * translation.
  27  *
  28  * See the Kconfig help text for a list of devices known to be supported by
  29  * this driver.
  30  */
  31
  32 #include <linux/errno.h>
  33 #include <linux/module.h>
  34 #include <linux/slab.h>
  35 #include <linux/cdrom.h>
  36
  37 #include <scsi/scsi.h>
  38 #include <scsi/scsi_cmnd.h>
  39
  40 #include "usb.h"
  41 #include "transport.h"
  42 #include "protocol.h"
  43 #include "debug.h"
  44 #include "scsiglue.h"
  45
  46 #define DRV_NAME "ums-usbat"
  47
  48 MODULE_DESCRIPTION("Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable");
  49 MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>, Robert Baruch <autophile@starband.net>");
  50 MODULE_LICENSE("GPL");
  51
  52 /* Supported device types */
  53 #define USBAT_DEV_HP8200        0x01
  54 #define USBAT_DEV_FLASH         0x02
  55
  56 #define USBAT_EPP_PORT          0x10
  57 #define USBAT_EPP_REGISTER      0x30
  58 #define USBAT_ATA               0x40
  59 #define USBAT_ISA               0x50
  60
  61 /* Commands (need to be logically OR'd with an access type */
  62 #define USBAT_CMD_READ_REG              0x00
  63 #define USBAT_CMD_WRITE_REG             0x01
  64 #define USBAT_CMD_READ_BLOCK    0x02
  65 #define USBAT_CMD_WRITE_BLOCK   0x03
  66 #define USBAT_CMD_COND_READ_BLOCK       0x04
  67 #define USBAT_CMD_COND_WRITE_BLOCK      0x05
  68 #define USBAT_CMD_WRITE_REGS    0x07
  69
  70 /* Commands (these don't need an access type) */
  71 #define USBAT_CMD_EXEC_CMD      0x80
  72 #define USBAT_CMD_SET_FEAT      0x81
  73 #define USBAT_CMD_UIO           0x82
  74
  75 /* Methods of accessing UIO register */
  76 #define USBAT_UIO_READ  1
  77 #define USBAT_UIO_WRITE 0
  78
  79 /* Qualifier bits */
  80 #define USBAT_QUAL_FCQ  0x20    /* full compare */
  81 #define USBAT_QUAL_ALQ  0x10    /* auto load subcount */
  82
  83 /* USBAT Flash Media status types */
  84 #define USBAT_FLASH_MEDIA_NONE  0
  85 #define USBAT_FLASH_MEDIA_CF    1
  86
  87 /* USBAT Flash Media change types */
  88 #define USBAT_FLASH_MEDIA_SAME  0
  89 #define USBAT_FLASH_MEDIA_CHANGED       1
  90
  91 /* USBAT ATA registers */
  92 #define USBAT_ATA_DATA      0x10  /* read/write data (R/W) */
  93 #define USBAT_ATA_FEATURES  0x11  /* set features (W) */
  94 #define USBAT_ATA_ERROR     0x11  /* error (R) */
  95 #define USBAT_ATA_SECCNT    0x12  /* sector count (R/W) */
  96 #define USBAT_ATA_SECNUM    0x13  /* sector number (R/W) */
  97 #define USBAT_ATA_LBA_ME    0x14  /* cylinder low (R/W) */
  98 #define USBAT_ATA_LBA_HI    0x15  /* cylinder high (R/W) */
  99 #define USBAT_ATA_DEVICE    0x16  /* head/device selection (R/W) */
 100 #define USBAT_ATA_STATUS    0x17  /* device status (R) */
 101 #define USBAT_ATA_CMD       0x17  /* device command (W) */
 102 #define USBAT_ATA_ALTSTATUS 0x0E  /* status (no clear IRQ) (R) */
 103
 104 /* USBAT User I/O Data registers */
 105 #define USBAT_UIO_EPAD          0x80 /* Enable Peripheral Control Signals */
 106 #define USBAT_UIO_CDT           0x40 /* Card Detect (Read Only) */
 107                                      /* CDT = ACKD & !UI1 & !UI0 */
 108 #define USBAT_UIO_1             0x20 /* I/O 1 */
 109 #define USBAT_UIO_0             0x10 /* I/O 0 */
 110 #define USBAT_UIO_EPP_ATA       0x08 /* 1=EPP mode, 0=ATA mode */
 111 #define USBAT_UIO_UI1           0x04 /* Input 1 */
 112 #define USBAT_UIO_UI0           0x02 /* Input 0 */
 113 #define USBAT_UIO_INTR_ACK      0x01 /* Interrupt (ATA/ISA)/Acknowledge (EPP) */
 114
 115 /* USBAT User I/O Enable registers */
 116 #define USBAT_UIO_DRVRST        0x80 /* Reset Peripheral */
 117 #define USBAT_UIO_ACKD          0x40 /* Enable Card Detect */
 118 #define USBAT_UIO_OE1           0x20 /* I/O 1 set=output/clr=input */
 119                                      /* If ACKD=1, set OE1 to 1 also. */
 120 #define USBAT_UIO_OE0           0x10 /* I/O 0 set=output/clr=input */
 121 #define USBAT_UIO_ADPRST        0x01 /* Reset SCM chip */
 122
 123 /* USBAT Features */
 124 #define USBAT_FEAT_ETEN 0x80    /* External trigger enable */
 125 #define USBAT_FEAT_U1   0x08
 126 #define USBAT_FEAT_U0   0x04
 127 #define USBAT_FEAT_ET1  0x02
 128 #define USBAT_FEAT_ET2  0x01
 129
 130 struct usbat_info {
 131         int devicetype;
 132
 133         /* Used for Flash readers only */
 134         unsigned long sectors;     /* total sector count */
 135         unsigned long ssize;       /* sector size in bytes */
 136
 137         unsigned char sense_key;
 138         unsigned long sense_asc;   /* additional sense code */
 139         unsigned long sense_ascq;  /* additional sense code qualifier */
 140 };
 141
 142 #define short_pack(LSB,MSB) ( ((u16)(LSB)) | ( ((u16)(MSB))<<8 ) )
 143 #define LSB_of(s) ((s)&0xFF)
 144 #define MSB_of(s) ((s)>>8)
 145
 146 static int transferred = 0;
 147
 148 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
 149 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
 150
 151 static int init_usbat_cd(struct us_data *us);
 152 static int init_usbat_flash(struct us_data *us);
 153
 154
 155 /*
 156  * The table of devices
 157  */
 158 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
 159                     vendorName, productName, useProtocol, useTransport, \
 160                     initFunction, flags) \
 161 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
 162   .driver_info = (flags) }
 163
 164 static struct usb_device_id usbat_usb_ids[] = {
 165 #       include "unusual_usbat.h"
 166         { }             /* Terminating entry */
 167 };
 168 MODULE_DEVICE_TABLE(usb, usbat_usb_ids);
 169
 170 #undef UNUSUAL_DEV
 171
 172 /*
 173  * The flags table
 174  */
 175 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
 176                     vendor_name, product_name, use_protocol, use_transport, \
 177                     init_function, Flags) \
 178 { \
 179         .vendorName = vendor_name,      \
 180         .productName = product_name,    \
 181         .useProtocol = use_protocol,    \
 182         .useTransport = use_transport,  \
 183         .initFunction = init_function,  \
 184 }
 185
 186 static struct us_unusual_dev usbat_unusual_dev_list[] = {
 187 #       include "unusual_usbat.h"
 188         { }             /* Terminating entry */
 189 };
 190
 191 #undef UNUSUAL_DEV
 192
 193 /*
 194  * Convenience function to produce an ATA read/write sectors command
 195  * Use cmd=0x20 for read, cmd=0x30 for write
 196  */
 197 static void usbat_pack_ata_sector_cmd(unsigned char *buf,
 198                                         unsigned char thistime,
 199                                         u32 sector, unsigned char cmd)
 200 {
 201         buf[0] = 0;
 202         buf[1] = thistime;
 203         buf[2] = sector & 0xFF;
 204         buf[3] = (sector >>  8) & 0xFF;
 205         buf[4] = (sector >> 16) & 0xFF;
 206         buf[5] = 0xE0 | ((sector >> 24) & 0x0F);
 207         buf[6] = cmd;
 208 }
 209
 210 /*
 211  * Convenience function to get the device type (flash or hp8200)
 212  */
 213 static int usbat_get_device_type(struct us_data *us)
 214 {
 215         return ((struct usbat_info*)us->extra)->devicetype;
 216 }
 217
 218 /*
 219  * Read a register from the device
 220  */
 221 static int usbat_read(struct us_data *us,
 222                       unsigned char access,
 223                       unsigned char reg,
 224                       unsigned char *content)
 225 {
 226         return usb_stor_ctrl_transfer(us,
 227                 us->recv_ctrl_pipe,
 228                 access | USBAT_CMD_READ_REG,
 229                 0xC0,
 230                 (u16)reg,
 231                 0,
 232                 content,
 233                 1);
 234 }
 235
 236 /*
 237  * Write to a register on the device
 238  */
 239 static int usbat_write(struct us_data *us,
 240                        unsigned char access,
 241                        unsigned char reg,
 242                        unsigned char content)
 243 {
 244         return usb_stor_ctrl_transfer(us,
 245                 us->send_ctrl_pipe,
 246                 access | USBAT_CMD_WRITE_REG,
 247                 0x40,
 248                 short_pack(reg, content),
 249                 0,
 250                 NULL,
 251                 0);
 252 }
 253
 254 /*
 255  * Convenience function to perform a bulk read
 256  */
 257 static int usbat_bulk_read(struct us_data *us,
 258                            void* buf,
 259                            unsigned int len,
 260                            int use_sg)
 261 {
 262         if (len == 0)
 263                 return USB_STOR_XFER_GOOD;
 264
 265         usb_stor_dbg(us, "len = %d\n", len);
 266         return usb_stor_bulk_transfer_sg(us, us->recv_bulk_pipe, buf, len, use_sg, NULL);
 267 }
 268
 269 /*
 270  * Convenience function to perform a bulk write
 271  */
 272 static int usbat_bulk_write(struct us_data *us,
 273                             void* buf,
 274                             unsigned int len,
 275                             int use_sg)
 276 {
 277         if (len == 0)
 278                 return USB_STOR_XFER_GOOD;
 279
 280         usb_stor_dbg(us, "len = %d\n", len);
 281         return usb_stor_bulk_transfer_sg(us, us->send_bulk_pipe, buf, len, use_sg, NULL);
 282 }
 283
 284 /*
 285  * Some USBAT-specific commands can only be executed over a command transport
 286  * This transport allows one (len=8) or two (len=16) vendor-specific commands
 287  * to be executed.
 288  */
 289 static int usbat_execute_command(struct us_data *us,
 290                                                                  unsigned char *commands,
 291                                                                  unsigned int len)
 292 {
 293         return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
 294                                                                   USBAT_CMD_EXEC_CMD, 0x40, 0, 0,
 295                                                                   commands, len);
 296 }
 297
 298 /*
 299  * Read the status register
 300  */
 301 static int usbat_get_status(struct us_data *us, unsigned char *status)
 302 {
 303         int rc;
 304         rc = usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status);
 305
 306         usb_stor_dbg(us, "0x%02X\n", *status);
 307         return rc;
 308 }
 309
 310 /*
 311  * Check the device status
 312  */
 313 static int usbat_check_status(struct us_data *us)
 314 {
 315         unsigned char *reply = us->iobuf;
 316         int rc;
 317
 318         rc = usbat_get_status(us, reply);
 319         if (rc != USB_STOR_XFER_GOOD)
 320                 return USB_STOR_TRANSPORT_FAILED;
 321
 322         /* error/check condition (0x51 is ok) */
 323         if (*reply & 0x01 && *reply != 0x51)
 324                 return USB_STOR_TRANSPORT_FAILED;
 325
 326         /* device fault */
 327         if (*reply & 0x20)
 328                 return USB_STOR_TRANSPORT_FAILED;
 329
 330         return USB_STOR_TRANSPORT_GOOD;
 331 }
 332
 333 /*
 334  * Stores critical information in internal registers in preparation for the execution
 335  * of a conditional usbat_read_blocks or usbat_write_blocks call.
 336  */
 337 static int usbat_set_shuttle_features(struct us_data *us,
 338                                       unsigned char external_trigger,
 339                                       unsigned char epp_control,
 340                                       unsigned char mask_byte,
 341                                       unsigned char test_pattern,
 342                                       unsigned char subcountH,
 343                                       unsigned char subcountL)
 344 {
 345         unsigned char *command = us->iobuf;
 346
 347         command[0] = 0x40;
 348         command[1] = USBAT_CMD_SET_FEAT;
 349
 350         /*
 351          * The only bit relevant to ATA access is bit 6
 352          * which defines 8 bit data access (set) or 16 bit (unset)
 353          */
 354         command[2] = epp_control;
 355
 356         /*
 357          * If FCQ is set in the qualifier (defined in R/W cmd), then bits U0, U1,
 358          * ET1 and ET2 define an external event to be checked for on event of a
 359          * _read_blocks or _write_blocks operation. The read/write will not take
 360          * place unless the defined trigger signal is active.
 361          */
 362         command[3] = external_trigger;
 363
 364         /*
 365          * The resultant byte of the mask operation (see mask_byte) is compared for
 366          * equivalence with this test pattern. If equal, the read/write will take
 367          * place.
 368          */
 369         command[4] = test_pattern;
 370
 371         /*
 372          * This value is logically ANDed with the status register field specified
 373          * in the read/write command.
 374          */
 375         command[5] = mask_byte;
 376
 377         /*
 378          * If ALQ is set in the qualifier, this field contains the address of the
 379          * registers where the byte count should be read for transferring the data.
 380          * If ALQ is not set, then this field contains the number of bytes to be
 381          * transferred.
 382          */
 383         command[6] = subcountL;
 384         command[7] = subcountH;
 385
 386         return usbat_execute_command(us, command, 8);
 387 }
 388
 389 /*
 390  * Block, waiting for an ATA device to become not busy or to report
 391  * an error condition.
 392  */
 393 static int usbat_wait_not_busy(struct us_data *us, int minutes)
 394 {
 395         int i;
 396         int result;
 397         unsigned char *status = us->iobuf;
 398
 399         /*
 400          * Synchronizing cache on a CDR could take a heck of a long time,
 401          * but probably not more than 10 minutes or so. On the other hand,
 402          * doing a full blank on a CDRW at speed 1 will take about 75
 403          * minutes!
 404          */
 405
 406         for (i=0; i<1200+minutes*60; i++) {
 407
 408                 result = usbat_get_status(us, status);
 409
 410                 if (result!=USB_STOR_XFER_GOOD)
 411                         return USB_STOR_TRANSPORT_ERROR;
 412                 if (*status & 0x01) { /* check condition */
 413                         result = usbat_read(us, USBAT_ATA, 0x10, status);
 414                         return USB_STOR_TRANSPORT_FAILED;
 415                 }
 416                 if (*status & 0x20) /* device fault */
 417                         return USB_STOR_TRANSPORT_FAILED;
 418
 419                 if ((*status & 0x80)==0x00) { /* not busy */
 420                         usb_stor_dbg(us, "Waited not busy for %d steps\n", i);
 421                         return USB_STOR_TRANSPORT_GOOD;
 422                 }
 423
 424                 if (i<500)
 425                         msleep(10); /* 5 seconds */
 426                 else if (i<700)
 427                         msleep(50); /* 10 seconds */
 428                 else if (i<1200)
 429                         msleep(100); /* 50 seconds */
 430                 else
 431                         msleep(1000); /* X minutes */
 432         }
 433
 434         usb_stor_dbg(us, "Waited not busy for %d minutes, timing out\n",
 435                      minutes);
 436         return USB_STOR_TRANSPORT_FAILED;
 437 }
 438
 439 /*
 440  * Read block data from the data register
 441  */
 442 static int usbat_read_block(struct us_data *us,
 443                             void* buf,
 444                             unsigned short len,
 445                             int use_sg)
 446 {
 447         int result;
 448         unsigned char *command = us->iobuf;
 449
 450         if (!len)
 451                 return USB_STOR_TRANSPORT_GOOD;
 452
 453         command[0] = 0xC0;
 454         command[1] = USBAT_ATA | USBAT_CMD_READ_BLOCK;
 455         command[2] = USBAT_ATA_DATA;
 456         command[3] = 0;
 457         command[4] = 0;
 458         command[5] = 0;
 459         command[6] = LSB_of(len);
 460         command[7] = MSB_of(len);
 461
 462         result = usbat_execute_command(us, command, 8);
 463         if (result != USB_STOR_XFER_GOOD)
 464                 return USB_STOR_TRANSPORT_ERROR;
 465
 466         result = usbat_bulk_read(us, buf, len, use_sg);
 467         return (result == USB_STOR_XFER_GOOD ?
 468                         USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_ERROR);
 469 }
 470
 471 /*
 472  * Write block data via the data register
 473  */
 474 static int usbat_write_block(struct us_data *us,
 475                              unsigned char access,
 476                              void* buf,
 477                              unsigned short len,
 478                              int minutes,
 479                              int use_sg)
 480 {
 481         int result;
 482         unsigned char *command = us->iobuf;
 483
 484         if (!len)
 485                 return USB_STOR_TRANSPORT_GOOD;
 486
 487         command[0] = 0x40;
 488         command[1] = access | USBAT_CMD_WRITE_BLOCK;
 489         command[2] = USBAT_ATA_DATA;
 490         command[3] = 0;
 491         command[4] = 0;
 492         command[5] = 0;
 493         command[6] = LSB_of(len);
 494         command[7] = MSB_of(len);
 495
 496         result = usbat_execute_command(us, command, 8);
 497
 498         if (result != USB_STOR_XFER_GOOD)
 499                 return USB_STOR_TRANSPORT_ERROR;
 500
 501         result = usbat_bulk_write(us, buf, len, use_sg);
 502         if (result != USB_STOR_XFER_GOOD)
 503                 return USB_STOR_TRANSPORT_ERROR;
 504
 505         return usbat_wait_not_busy(us, minutes);
 506 }
 507
 508 /*
 509  * Process read and write requests
 510  */
 511 static int usbat_hp8200e_rw_block_test(struct us_data *us,
 512                                        unsigned char access,
 513                                        unsigned char *registers,
 514                                        unsigned char *data_out,
 515                                        unsigned short num_registers,
 516                                        unsigned char data_reg,
 517                                        unsigned char status_reg,
 518                                        unsigned char timeout,
 519                                        unsigned char qualifier,
 520                                        int direction,
 521                                        void *buf,
 522                                        unsigned short len,
 523                                        int use_sg,
 524                                        int minutes)
 525 {
 526         int result;
 527         unsigned int pipe = (direction == DMA_FROM_DEVICE) ?
 528                         us->recv_bulk_pipe : us->send_bulk_pipe;
 529
 530         unsigned char *command = us->iobuf;
 531         int i, j;
 532         int cmdlen;
 533         unsigned char *data = us->iobuf;
 534         unsigned char *status = us->iobuf;
 535
 536         BUG_ON(num_registers > US_IOBUF_SIZE/2);
 537
 538         for (i=0; i<20; i++) {
 539
 540                 /*
 541                  * The first time we send the full command, which consists
 542                  * of downloading the SCSI command followed by downloading
 543                  * the data via a write-and-test.  Any other time we only
 544                  * send the command to download the data -- the SCSI command
 545                  * is still 'active' in some sense in the device.
 546                  *
 547                  * We're only going to try sending the data 10 times. After
 548                  * that, we just return a failure.
 549                  */
 550
 551                 if (i==0) {
 552                         cmdlen = 16;
 553                         /*
 554                          * Write to multiple registers
 555                          * Not really sure the 0x07, 0x17, 0xfc, 0xe7 is
 556                          * necessary here, but that's what came out of the
 557                          * trace every single time.
 558                          */
 559                         command[0] = 0x40;
 560                         command[1] = access | USBAT_CMD_WRITE_REGS;
 561                         command[2] = 0x07;
 562                         command[3] = 0x17;
 563                         command[4] = 0xFC;
 564                         command[5] = 0xE7;
 565                         command[6] = LSB_of(num_registers*2);
 566                         command[7] = MSB_of(num_registers*2);
 567                 } else
 568                         cmdlen = 8;
 569
 570                 /* Conditionally read or write blocks */
 571                 command[cmdlen-8] = (direction==DMA_TO_DEVICE ? 0x40 : 0xC0);
 572                 command[cmdlen-7] = access |
 573                                 (direction==DMA_TO_DEVICE ?
 574                                  USBAT_CMD_COND_WRITE_BLOCK : USBAT_CMD_COND_READ_BLOCK);
 575                 command[cmdlen-6] = data_reg;
 576                 command[cmdlen-5] = status_reg;
 577                 command[cmdlen-4] = timeout;
 578                 command[cmdlen-3] = qualifier;
 579                 command[cmdlen-2] = LSB_of(len);
 580                 command[cmdlen-1] = MSB_of(len);
 581
 582                 result = usbat_execute_command(us, command, cmdlen);
 583
 584                 if (result != USB_STOR_XFER_GOOD)
 585                         return USB_STOR_TRANSPORT_ERROR;
 586
 587                 if (i==0) {
 588
 589                         for (j=0; j<num_registers; j++) {
 590                                 data[j<<1] = registers[j];
 591                                 data[1+(j<<1)] = data_out[j];
 592                         }
 593
 594                         result = usbat_bulk_write(us, data, num_registers*2, 0);
 595                         if (result != USB_STOR_XFER_GOOD)
 596                                 return USB_STOR_TRANSPORT_ERROR;
 597
 598                 }
 599
 600                 result = usb_stor_bulk_transfer_sg(us,
 601                         pipe, buf, len, use_sg, NULL);
 602
 603                 /*
 604                  * If we get a stall on the bulk download, we'll retry
 605                  * the bulk download -- but not the SCSI command because
 606                  * in some sense the SCSI command is still 'active' and
 607                  * waiting for the data. Don't ask me why this should be;
 608                  * I'm only following what the Windoze driver did.
 609                  *
 610                  * Note that a stall for the test-and-read/write command means
 611                  * that the test failed. In this case we're testing to make
 612                  * sure that the device is error-free
 613                  * (i.e. bit 0 -- CHK -- of status is 0). The most likely
 614                  * hypothesis is that the USBAT chip somehow knows what
 615                  * the device will accept, but doesn't give the device any
 616                  * data until all data is received. Thus, the device would
 617                  * still be waiting for the first byte of data if a stall
 618                  * occurs, even if the stall implies that some data was
 619                  * transferred.
 620                  */
 621
 622                 if (result == USB_STOR_XFER_SHORT ||
 623                                 result == USB_STOR_XFER_STALLED) {
 624
 625                         /*
 626                          * If we're reading and we stalled, then clear
 627                          * the bulk output pipe only the first time.
 628                          */
 629
 630                         if (direction==DMA_FROM_DEVICE && i==0) {
 631                                 if (usb_stor_clear_halt(us,
 632                                                 us->send_bulk_pipe) < 0)
 633                                         return USB_STOR_TRANSPORT_ERROR;
 634                         }
 635
 636                         /*
 637                          * Read status: is the device angry, or just busy?
 638                          */
 639
 640                         result = usbat_read(us, USBAT_ATA,
 641                                 direction==DMA_TO_DEVICE ?
 642                                         USBAT_ATA_STATUS : USBAT_ATA_ALTSTATUS,
 643                                 status);
 644
 645                         if (result!=USB_STOR_XFER_GOOD)
 646                                 return USB_STOR_TRANSPORT_ERROR;
 647                         if (*status & 0x01) /* check condition */
 648                                 return USB_STOR_TRANSPORT_FAILED;
 649                         if (*status & 0x20) /* device fault */
 650                                 return USB_STOR_TRANSPORT_FAILED;
 651
 652                         usb_stor_dbg(us, "Redoing %s\n",
 653                                      direction == DMA_TO_DEVICE
 654                                      ? "write" : "read");
 655
 656                 } else if (result != USB_STOR_XFER_GOOD)
 657                         return USB_STOR_TRANSPORT_ERROR;
 658                 else
 659                         return usbat_wait_not_busy(us, minutes);
 660
 661         }
 662
 663         usb_stor_dbg(us, "Bummer! %s bulk data 20 times failed\n",
 664                      direction == DMA_TO_DEVICE ? "Writing" : "Reading");
 665
 666         return USB_STOR_TRANSPORT_FAILED;
 667 }
 668
 669 /*
 670  * Write to multiple registers:
 671  * Allows us to write specific data to any registers. The data to be written
 672  * gets packed in this sequence: reg0, data0, reg1, data1, ..., regN, dataN
 673  * which gets sent through bulk out.
 674  * Not designed for large transfers of data!
 675  */
 676 static int usbat_multiple_write(struct us_data *us,
 677                                 unsigned char *registers,
 678                                 unsigned char *data_out,
 679                                 unsigned short num_registers)
 680 {
 681         int i, result;
 682         unsigned char *data = us->iobuf;
 683         unsigned char *command = us->iobuf;
 684
 685         BUG_ON(num_registers > US_IOBUF_SIZE/2);
 686
 687         /* Write to multiple registers, ATA access */
 688         command[0] = 0x40;
 689         command[1] = USBAT_ATA | USBAT_CMD_WRITE_REGS;
 690
 691         /* No relevance */
 692         command[2] = 0;
 693         command[3] = 0;
 694         command[4] = 0;
 695         command[5] = 0;
 696
 697         /* Number of bytes to be transferred (incl. addresses and data) */
 698         command[6] = LSB_of(num_registers*2);
 699         command[7] = MSB_of(num_registers*2);
 700
 701         /* The setup command */
 702         result = usbat_execute_command(us, command, 8);
 703         if (result != USB_STOR_XFER_GOOD)
 704                 return USB_STOR_TRANSPORT_ERROR;
 705
 706         /* Create the reg/data, reg/data sequence */
 707         for (i=0; i<num_registers; i++) {
 708                 data[i<<1] = registers[i];
 709                 data[1+(i<<1)] = data_out[i];
 710         }
 711
 712         /* Send the data */
 713         result = usbat_bulk_write(us, data, num_registers*2, 0);
 714         if (result != USB_STOR_XFER_GOOD)
 715                 return USB_STOR_TRANSPORT_ERROR;
 716
 717         if (usbat_get_device_type(us) == USBAT_DEV_HP8200)
 718                 return usbat_wait_not_busy(us, 0);
 719         else
 720                 return USB_STOR_TRANSPORT_GOOD;
 721 }
 722
 723 /*
 724  * Conditionally read blocks from device:
 725  * Allows us to read blocks from a specific data register, based upon the
 726  * condition that a status register can be successfully masked with a status
 727  * qualifier. If this condition is not initially met, the read will wait
 728  * up until a maximum amount of time has elapsed, as specified by timeout.
 729  * The read will start when the condition is met, otherwise the command aborts.
 730  *
 731  * The qualifier defined here is not the value that is masked, it defines
 732  * conditions for the write to take place. The actual masked qualifier (and
 733  * other related details) are defined beforehand with _set_shuttle_features().
 734  */
 735 static int usbat_read_blocks(struct us_data *us,
 736                              void* buffer,
 737                              int len,
 738                              int use_sg)
 739 {
 740         int result;
 741         unsigned char *command = us->iobuf;
 742
 743         command[0] = 0xC0;
 744         command[1] = USBAT_ATA | USBAT_CMD_COND_READ_BLOCK;
 745         command[2] = USBAT_ATA_DATA;
 746         command[3] = USBAT_ATA_STATUS;
 747         command[4] = 0xFD; /* Timeout (ms); */
 748         command[5] = USBAT_QUAL_FCQ;
 749         command[6] = LSB_of(len);
 750         command[7] = MSB_of(len);
 751
 752         /* Multiple block read setup command */
 753         result = usbat_execute_command(us, command, 8);
 754         if (result != USB_STOR_XFER_GOOD)
 755                 return USB_STOR_TRANSPORT_FAILED;
 756
 757         /* Read the blocks we just asked for */
 758         result = usbat_bulk_read(us, buffer, len, use_sg);
 759         if (result != USB_STOR_XFER_GOOD)
 760                 return USB_STOR_TRANSPORT_FAILED;
 761
 762         return USB_STOR_TRANSPORT_GOOD;
 763 }
 764
 765 /*
 766  * Conditionally write blocks to device:
 767  * Allows us to write blocks to a specific data register, based upon the
 768  * condition that a status register can be successfully masked with a status
 769  * qualifier. If this condition is not initially met, the write will wait
 770  * up until a maximum amount of time has elapsed, as specified by timeout.
 771  * The read will start when the condition is met, otherwise the command aborts.
 772  *
 773  * The qualifier defined here is not the value that is masked, it defines
 774  * conditions for the write to take place. The actual masked qualifier (and
 775  * other related details) are defined beforehand with _set_shuttle_features().
 776  */
 777 static int usbat_write_blocks(struct us_data *us,
 778                               void* buffer,
 779                               int len,
 780                               int use_sg)
 781 {
 782         int result;
 783         unsigned char *command = us->iobuf;
 784
 785         command[0] = 0x40;
 786         command[1] = USBAT_ATA | USBAT_CMD_COND_WRITE_BLOCK;
 787         command[2] = USBAT_ATA_DATA;
 788         command[3] = USBAT_ATA_STATUS;
 789         command[4] = 0xFD; /* Timeout (ms) */
 790         command[5] = USBAT_QUAL_FCQ;
 791         command[6] = LSB_of(len);
 792         command[7] = MSB_of(len);
 793
 794         /* Multiple block write setup command */
 795         result = usbat_execute_command(us, command, 8);
 796         if (result != USB_STOR_XFER_GOOD)
 797                 return USB_STOR_TRANSPORT_FAILED;
 798
 799         /* Write the data */
 800         result = usbat_bulk_write(us, buffer, len, use_sg);
 801         if (result != USB_STOR_XFER_GOOD)
 802                 return USB_STOR_TRANSPORT_FAILED;
 803
 804         return USB_STOR_TRANSPORT_GOOD;
 805 }
 806
 807 /*
 808  * Read the User IO register
 809  */
 810 static int usbat_read_user_io(struct us_data *us, unsigned char *data_flags)
 811 {
 812         int result;
 813
 814         result = usb_stor_ctrl_transfer(us,
 815                 us->recv_ctrl_pipe,
 816                 USBAT_CMD_UIO,
 817                 0xC0,
 818                 0,
 819                 0,
 820                 data_flags,
 821                 USBAT_UIO_READ);
 822
 823         usb_stor_dbg(us, "UIO register reads %02X\n", *data_flags);
 824
 825         return result;
 826 }
 827
 828 /*
 829  * Write to the User IO register
 830  */
 831 static int usbat_write_user_io(struct us_data *us,
 832                                unsigned char enable_flags,
 833                                unsigned char data_flags)
 834 {
 835         return usb_stor_ctrl_transfer(us,
 836                 us->send_ctrl_pipe,
 837                 USBAT_CMD_UIO,
 838                 0x40,
 839                 short_pack(enable_flags, data_flags),
 840                 0,
 841                 NULL,
 842                 USBAT_UIO_WRITE);
 843 }
 844
 845 /*
 846  * Reset the device
 847  * Often needed on media change.
 848  */
 849 static int usbat_device_reset(struct us_data *us)
 850 {
 851         int rc;
 852
 853         /*
 854          * Reset peripheral, enable peripheral control signals
 855          * (bring reset signal up)
 856          */
 857         rc = usbat_write_user_io(us,
 858                                                          USBAT_UIO_DRVRST | USBAT_UIO_OE1 | USBAT_UIO_OE0,
 859                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
 860         if (rc != USB_STOR_XFER_GOOD)
 861                 return USB_STOR_TRANSPORT_ERROR;
 862
 863         /*
 864          * Enable peripheral control signals
 865          * (bring reset signal down)
 866          */
 867         rc = usbat_write_user_io(us,
 868                                                          USBAT_UIO_OE1  | USBAT_UIO_OE0,
 869                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
 870         if (rc != USB_STOR_XFER_GOOD)
 871                 return USB_STOR_TRANSPORT_ERROR;
 872
 873         return USB_STOR_TRANSPORT_GOOD;
 874 }
 875
 876 /*
 877  * Enable card detect
 878  */
 879 static int usbat_device_enable_cdt(struct us_data *us)
 880 {
 881         int rc;
 882
 883         /* Enable peripheral control signals and card detect */
 884         rc = usbat_write_user_io(us,
 885                                                          USBAT_UIO_ACKD | USBAT_UIO_OE1  | USBAT_UIO_OE0,
 886                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
 887         if (rc != USB_STOR_XFER_GOOD)
 888                 return USB_STOR_TRANSPORT_ERROR;
 889
 890         return USB_STOR_TRANSPORT_GOOD;
 891 }
 892
 893 /*
 894  * Determine if media is present.
 895  */
 896 static int usbat_flash_check_media_present(struct us_data *us,
 897                                            unsigned char *uio)
 898 {
 899         if (*uio & USBAT_UIO_UI0) {
 900                 usb_stor_dbg(us, "no media detected\n");
 901                 return USBAT_FLASH_MEDIA_NONE;
 902         }
 903
 904         return USBAT_FLASH_MEDIA_CF;
 905 }
 906
 907 /*
 908  * Determine if media has changed since last operation
 909  */
 910 static int usbat_flash_check_media_changed(struct us_data *us,
 911                                            unsigned char *uio)
 912 {
 913         if (*uio & USBAT_UIO_0) {
 914                 usb_stor_dbg(us, "media change detected\n");
 915                 return USBAT_FLASH_MEDIA_CHANGED;
 916         }
 917
 918         return USBAT_FLASH_MEDIA_SAME;
 919 }
 920
 921 /*
 922  * Check for media change / no media and handle the situation appropriately
 923  */
 924 static int usbat_flash_check_media(struct us_data *us,
 925                                    struct usbat_info *info)
 926 {
 927         int rc;
 928         unsigned char *uio = us->iobuf;
 929
 930         rc = usbat_read_user_io(us, uio);
 931         if (rc != USB_STOR_XFER_GOOD)
 932                 return USB_STOR_TRANSPORT_ERROR;
 933
 934         /* Check for media existence */
 935         rc = usbat_flash_check_media_present(us, uio);
 936         if (rc == USBAT_FLASH_MEDIA_NONE) {
 937                 info->sense_key = 0x02;
 938                 info->sense_asc = 0x3A;
 939                 info->sense_ascq = 0x00;
 940                 return USB_STOR_TRANSPORT_FAILED;
 941         }
 942
 943         /* Check for media change */
 944         rc = usbat_flash_check_media_changed(us, uio);
 945         if (rc == USBAT_FLASH_MEDIA_CHANGED) {
 946
 947                 /* Reset and re-enable card detect */
 948                 rc = usbat_device_reset(us);
 949                 if (rc != USB_STOR_TRANSPORT_GOOD)
 950                         return rc;
 951                 rc = usbat_device_enable_cdt(us);
 952                 if (rc != USB_STOR_TRANSPORT_GOOD)
 953                         return rc;
 954
 955                 msleep(50);
 956
 957                 rc = usbat_read_user_io(us, uio);
 958                 if (rc != USB_STOR_XFER_GOOD)
 959                         return USB_STOR_TRANSPORT_ERROR;
 960
 961                 info->sense_key = UNIT_ATTENTION;
 962                 info->sense_asc = 0x28;
 963                 info->sense_ascq = 0x00;
 964                 return USB_STOR_TRANSPORT_FAILED;
 965         }
 966
 967         return USB_STOR_TRANSPORT_GOOD;
 968 }
 969
 970 /*
 971  * Determine whether we are controlling a flash-based reader/writer,
 972  * or a HP8200-based CD drive.
 973  * Sets transport functions as appropriate.
 974  */
 975 static int usbat_identify_device(struct us_data *us,
 976                                  struct usbat_info *info)
 977 {
 978         int rc;
 979         unsigned char status;
 980
 981         if (!us || !info)
 982                 return USB_STOR_TRANSPORT_ERROR;
 983
 984         rc = usbat_device_reset(us);
 985         if (rc != USB_STOR_TRANSPORT_GOOD)
 986                 return rc;
 987         msleep(500);
 988
 989         /*
 990          * In attempt to distinguish between HP CDRW's and Flash readers, we now
 991          * execute the IDENTIFY PACKET DEVICE command. On ATA devices (i.e. flash
 992          * readers), this command should fail with error. On ATAPI devices (i.e.
 993          * CDROM drives), it should succeed.
 994          */
 995         rc = usbat_write(us, USBAT_ATA, USBAT_ATA_CMD, 0xA1);
 996         if (rc != USB_STOR_XFER_GOOD)
 997                 return USB_STOR_TRANSPORT_ERROR;
 998
 999         rc = usbat_get_status(us, &status);
1000         if (rc != USB_STOR_XFER_GOOD)
1001                 return USB_STOR_TRANSPORT_ERROR;
1002
1003         /* Check for error bit, or if the command 'fell through' */
1004         if (status == 0xA1 || !(status & 0x01)) {
1005                 /* Device is HP 8200 */
1006                 usb_stor_dbg(us, "Detected HP8200 CDRW\n");
1007                 info->devicetype = USBAT_DEV_HP8200;
1008         } else {
1009                 /* Device is a CompactFlash reader/writer */
1010                 usb_stor_dbg(us, "Detected Flash reader/writer\n");
1011                 info->devicetype = USBAT_DEV_FLASH;
1012         }
1013
1014         return USB_STOR_TRANSPORT_GOOD;
1015 }
1016
1017 /*
1018  * Set the transport function based on the device type
1019  */
1020 static int usbat_set_transport(struct us_data *us,
1021                                struct usbat_info *info,
1022                                int devicetype)
1023 {
1024
1025         if (!info->devicetype)
1026                 info->devicetype = devicetype;
1027
1028         if (!info->devicetype)
1029                 usbat_identify_device(us, info);
1030
1031         switch (info->devicetype) {
1032         default:
1033                 return USB_STOR_TRANSPORT_ERROR;
1034
1035         case  USBAT_DEV_HP8200:
1036                 us->transport = usbat_hp8200e_transport;
1037                 break;
1038
1039         case USBAT_DEV_FLASH:
1040                 us->transport = usbat_flash_transport;
1041                 break;
1042         }
1043
1044         return 0;
1045 }
1046
1047 /*
1048  * Read the media capacity
1049  */
1050 static int usbat_flash_get_sector_count(struct us_data *us,
1051                                         struct usbat_info *info)
1052 {
1053         unsigned char registers[3] = {
1054                 USBAT_ATA_SECCNT,
1055                 USBAT_ATA_DEVICE,
1056                 USBAT_ATA_CMD,
1057         };
1058         unsigned char  command[3] = { 0x01, 0xA0, 0xEC };
1059         unsigned char *reply;
1060         unsigned char status;
1061         int rc;
1062
1063         if (!us || !info)
1064                 return USB_STOR_TRANSPORT_ERROR;
1065
1066         reply = kmalloc(512, GFP_NOIO);
1067         if (!reply)
1068                 return USB_STOR_TRANSPORT_ERROR;
1069
1070         /* ATA command : IDENTIFY DEVICE */
1071         rc = usbat_multiple_write(us, registers, command, 3);
1072         if (rc != USB_STOR_XFER_GOOD) {
1073                 usb_stor_dbg(us, "Gah! identify_device failed\n");
1074                 rc = USB_STOR_TRANSPORT_ERROR;
1075                 goto leave;
1076         }
1077
1078         /* Read device status */
1079         if (usbat_get_status(us, &status) != USB_STOR_XFER_GOOD) {
1080                 rc = USB_STOR_TRANSPORT_ERROR;
1081                 goto leave;
1082         }
1083
1084         msleep(100);
1085
1086         /* Read the device identification data */
1087         rc = usbat_read_block(us, reply, 512, 0);
1088         if (rc != USB_STOR_TRANSPORT_GOOD)
1089                 goto leave;
1090
1091         info->sectors = ((u32)(reply[117]) << 24) |
1092                 ((u32)(reply[116]) << 16) |
1093                 ((u32)(reply[115]) <<  8) |
1094                 ((u32)(reply[114])      );
1095
1096         rc = USB_STOR_TRANSPORT_GOOD;
1097
1098  leave:
1099         kfree(reply);
1100         return rc;
1101 }
1102
1103 /*
1104  * Read data from device
1105  */
1106 static int usbat_flash_read_data(struct us_data *us,
1107                                                                  struct usbat_info *info,
1108                                                                  u32 sector,
1109                                                                  u32 sectors)
1110 {
1111         unsigned char registers[7] = {
1112                 USBAT_ATA_FEATURES,
1113                 USBAT_ATA_SECCNT,
1114                 USBAT_ATA_SECNUM,
1115                 USBAT_ATA_LBA_ME,
1116                 USBAT_ATA_LBA_HI,
1117                 USBAT_ATA_DEVICE,
1118                 USBAT_ATA_STATUS,
1119         };
1120         unsigned char command[7];
1121         unsigned char *buffer;
1122         unsigned char  thistime;
1123         unsigned int totallen, alloclen;
1124         int len, result;
1125         unsigned int sg_offset = 0;
1126         struct scatterlist *sg = NULL;
1127
1128         result = usbat_flash_check_media(us, info);
1129         if (result != USB_STOR_TRANSPORT_GOOD)
1130                 return result;
1131
1132         /*
1133          * we're working in LBA mode.  according to the ATA spec,
1134          * we can support up to 28-bit addressing.  I don't know if Jumpshot
1135          * supports beyond 24-bit addressing.  It's kind of hard to test
1136          * since it requires > 8GB CF card.
1137          */
1138
1139         if (sector > 0x0FFFFFFF)
1140                 return USB_STOR_TRANSPORT_ERROR;
1141
1142         totallen = sectors * info->ssize;
1143
1144         /*
1145          * Since we don't read more than 64 KB at a time, we have to create
1146          * a bounce buffer and move the data a piece at a time between the
1147          * bounce buffer and the actual transfer buffer.
1148          */
1149
1150         alloclen = min(totallen, 65536u);
1151         buffer = kmalloc(alloclen, GFP_NOIO);
1152         if (buffer == NULL)
1153                 return USB_STOR_TRANSPORT_ERROR;
1154
1155         do {
1156                 /*
1157                  * loop, never allocate or transfer more than 64k at once
1158                  * (min(128k, 255*info->ssize) is the real limit)
1159                  */
1160                 len = min(totallen, alloclen);
1161                 thistime = (len / info->ssize) & 0xff;
1162
1163                 /* ATA command 0x20 (READ SECTORS) */
1164                 usbat_pack_ata_sector_cmd(command, thistime, sector, 0x20);
1165
1166                 /* Write/execute ATA read command */
1167                 result = usbat_multiple_write(us, registers, command, 7);
1168                 if (result != USB_STOR_TRANSPORT_GOOD)
1169                         goto leave;
1170
1171                 /* Read the data we just requested */
1172                 result = usbat_read_blocks(us, buffer, len, 0);
1173                 if (result != USB_STOR_TRANSPORT_GOOD)
1174                         goto leave;
1175
1176                 usb_stor_dbg(us, "%d bytes\n", len);
1177
1178                 /* Store the data in the transfer buffer */
1179                 usb_stor_access_xfer_buf(buffer, len, us->srb,
1180                                          &sg, &sg_offset, TO_XFER_BUF);
1181
1182                 sector += thistime;
1183                 totallen -= len;
1184         } while (totallen > 0);
1185
1186         kfree(buffer);
1187         return USB_STOR_TRANSPORT_GOOD;
1188
1189 leave:
1190         kfree(buffer);
1191         return USB_STOR_TRANSPORT_ERROR;
1192 }
1193
1194 /*
1195  * Write data to device
1196  */
1197 static int usbat_flash_write_data(struct us_data *us,
1198                                                                   struct usbat_info *info,
1199                                                                   u32 sector,
1200                                                                   u32 sectors)
1201 {
1202         unsigned char registers[7] = {
1203                 USBAT_ATA_FEATURES,
1204                 USBAT_ATA_SECCNT,
1205                 USBAT_ATA_SECNUM,
1206                 USBAT_ATA_LBA_ME,
1207                 USBAT_ATA_LBA_HI,
1208                 USBAT_ATA_DEVICE,
1209                 USBAT_ATA_STATUS,
1210         };
1211         unsigned char command[7];
1212         unsigned char *buffer;
1213         unsigned char  thistime;
1214         unsigned int totallen, alloclen;
1215         int len, result;
1216         unsigned int sg_offset = 0;
1217         struct scatterlist *sg = NULL;
1218
1219         result = usbat_flash_check_media(us, info);
1220         if (result != USB_STOR_TRANSPORT_GOOD)
1221                 return result;
1222
1223         /*
1224          * we're working in LBA mode.  according to the ATA spec,
1225          * we can support up to 28-bit addressing.  I don't know if the device
1226          * supports beyond 24-bit addressing.  It's kind of hard to test
1227          * since it requires > 8GB media.
1228          */
1229
1230         if (sector > 0x0FFFFFFF)
1231                 return USB_STOR_TRANSPORT_ERROR;
1232
1233         totallen = sectors * info->ssize;
1234
1235         /*
1236          * Since we don't write more than 64 KB at a time, we have to create
1237          * a bounce buffer and move the data a piece at a time between the
1238          * bounce buffer and the actual transfer buffer.
1239          */
1240
1241         alloclen = min(totallen, 65536u);
1242         buffer = kmalloc(alloclen, GFP_NOIO);
1243         if (buffer == NULL)
1244                 return USB_STOR_TRANSPORT_ERROR;
1245
1246         do {
1247                 /*
1248                  * loop, never allocate or transfer more than 64k at once
1249                  * (min(128k, 255*info->ssize) is the real limit)
1250                  */
1251                 len = min(totallen, alloclen);
1252                 thistime = (len / info->ssize) & 0xff;
1253
1254                 /* Get the data from the transfer buffer */
1255                 usb_stor_access_xfer_buf(buffer, len, us->srb,
1256                                          &sg, &sg_offset, FROM_XFER_BUF);
1257
1258                 /* ATA command 0x30 (WRITE SECTORS) */
1259                 usbat_pack_ata_sector_cmd(command, thistime, sector, 0x30);
1260
1261                 /* Write/execute ATA write command */
1262                 result = usbat_multiple_write(us, registers, command, 7);
1263                 if (result != USB_STOR_TRANSPORT_GOOD)
1264                         goto leave;
1265
1266                 /* Write the data */
1267                 result = usbat_write_blocks(us, buffer, len, 0);
1268                 if (result != USB_STOR_TRANSPORT_GOOD)
1269                         goto leave;
1270
1271                 sector += thistime;
1272                 totallen -= len;
1273         } while (totallen > 0);
1274
1275         kfree(buffer);
1276         return result;
1277
1278 leave:
1279         kfree(buffer);
1280         return USB_STOR_TRANSPORT_ERROR;
1281 }
1282
1283 /*
1284  * Squeeze a potentially huge (> 65535 byte) read10 command into
1285  * a little ( <= 65535 byte) ATAPI pipe
1286  */
1287 static int usbat_hp8200e_handle_read10(struct us_data *us,
1288                                        unsigned char *registers,
1289                                        unsigned char *data,
1290                                        struct scsi_cmnd *srb)
1291 {
1292         int result = USB_STOR_TRANSPORT_GOOD;
1293         unsigned char *buffer;
1294         unsigned int len;
1295         unsigned int sector;
1296         unsigned int sg_offset = 0;
1297         struct scatterlist *sg = NULL;
1298
1299         usb_stor_dbg(us, "transfersize %d\n", srb->transfersize);
1300
1301         if (scsi_bufflen(srb) < 0x10000) {
1302
1303                 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1304                         registers, data, 19,
1305                         USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1306                         (USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1307                         DMA_FROM_DEVICE,
1308                         scsi_sglist(srb),
1309                         scsi_bufflen(srb), scsi_sg_count(srb), 1);
1310
1311                 return result;
1312         }
1313
1314         /*
1315          * Since we're requesting more data than we can handle in
1316          * a single read command (max is 64k-1), we will perform
1317          * multiple reads, but each read must be in multiples of
1318          * a sector.  Luckily the sector size is in srb->transfersize
1319          * (see linux/drivers/scsi/sr.c).
1320          */
1321
1322         if (data[7+0] == GPCMD_READ_CD) {
1323                 len = short_pack(data[7+9], data[7+8]);
1324                 len <<= 16;
1325                 len |= data[7+7];
1326                 usb_stor_dbg(us, "GPCMD_READ_CD: len %d\n", len);
1327                 srb->transfersize = scsi_bufflen(srb)/len;
1328         }
1329
1330         if (!srb->transfersize)  {
1331                 srb->transfersize = 2048; /* A guess */
1332                 usb_stor_dbg(us, "transfersize 0, forcing %d\n",
1333                              srb->transfersize);
1334         }
1335
1336         /*
1337          * Since we only read in one block at a time, we have to create
1338          * a bounce buffer and move the data a piece at a time between the
1339          * bounce buffer and the actual transfer buffer.
1340          */
1341
1342         len = (65535/srb->transfersize) * srb->transfersize;
1343         usb_stor_dbg(us, "Max read is %d bytes\n", len);
1344         len = min(len, scsi_bufflen(srb));
1345         buffer = kmalloc(len, GFP_NOIO);
1346         if (buffer == NULL) /* bloody hell! */
1347                 return USB_STOR_TRANSPORT_FAILED;
1348         sector = short_pack(data[7+3], data[7+2]);
1349         sector <<= 16;
1350         sector |= short_pack(data[7+5], data[7+4]);
1351         transferred = 0;
1352
1353         while (transferred != scsi_bufflen(srb)) {
1354
1355                 if (len > scsi_bufflen(srb) - transferred)
1356                         len = scsi_bufflen(srb) - transferred;
1357
1358                 data[3] = len&0xFF;       /* (cylL) = expected length (L) */
1359                 data[4] = (len>>8)&0xFF;  /* (cylH) = expected length (H) */
1360
1361                 /* Fix up the SCSI command sector and num sectors */
1362
1363                 data[7+2] = MSB_of(sector>>16); /* SCSI command sector */
1364                 data[7+3] = LSB_of(sector>>16);
1365                 data[7+4] = MSB_of(sector&0xFFFF);
1366                 data[7+5] = LSB_of(sector&0xFFFF);
1367                 if (data[7+0] == GPCMD_READ_CD)
1368                         data[7+6] = 0;
1369                 data[7+7] = MSB_of(len / srb->transfersize); /* SCSI command */
1370                 data[7+8] = LSB_of(len / srb->transfersize); /* num sectors */
1371
1372                 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1373                         registers, data, 19,
1374                         USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1375                         (USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1376                         DMA_FROM_DEVICE,
1377                         buffer,
1378                         len, 0, 1);
1379
1380                 if (result != USB_STOR_TRANSPORT_GOOD)
1381                         break;
1382
1383                 /* Store the data in the transfer buffer */
1384                 usb_stor_access_xfer_buf(buffer, len, srb,
1385                                  &sg, &sg_offset, TO_XFER_BUF);
1386
1387                 /* Update the amount transferred and the sector number */
1388
1389                 transferred += len;
1390                 sector += len / srb->transfersize;
1391
1392         } /* while transferred != scsi_bufflen(srb) */
1393
1394         kfree(buffer);
1395         return result;
1396 }
1397
1398 static int usbat_select_and_test_registers(struct us_data *us)
1399 {
1400         int selector;
1401         unsigned char *status = us->iobuf;
1402
1403         /* try device = master, then device = slave. */
1404         for (selector = 0xA0; selector <= 0xB0; selector += 0x10) {
1405                 if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
1406                                 USB_STOR_XFER_GOOD)
1407                         return USB_STOR_TRANSPORT_ERROR;
1408
1409                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_STATUS, status) !=
1410                                 USB_STOR_XFER_GOOD)
1411                         return USB_STOR_TRANSPORT_ERROR;
1412
1413                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_DEVICE, status) !=
1414                                 USB_STOR_XFER_GOOD)
1415                         return USB_STOR_TRANSPORT_ERROR;
1416
1417                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1418                                 USB_STOR_XFER_GOOD)
1419                         return USB_STOR_TRANSPORT_ERROR;
1420
1421                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1422                                 USB_STOR_XFER_GOOD)
1423                         return USB_STOR_TRANSPORT_ERROR;
1424
1425                 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_ME, 0x55) !=
1426                                 USB_STOR_XFER_GOOD)
1427                         return USB_STOR_TRANSPORT_ERROR;
1428
1429                 if (usbat_write(us, USBAT_ATA, USBAT_ATA_LBA_HI, 0xAA) !=
1430                                 USB_STOR_XFER_GOOD)
1431                         return USB_STOR_TRANSPORT_ERROR;
1432
1433                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1434                                 USB_STOR_XFER_GOOD)
1435                         return USB_STOR_TRANSPORT_ERROR;
1436
1437                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1438                                 USB_STOR_XFER_GOOD)
1439                         return USB_STOR_TRANSPORT_ERROR;
1440         }
1441
1442         return USB_STOR_TRANSPORT_GOOD;
1443 }
1444
1445 /*
1446  * Initialize the USBAT processor and the storage device
1447  */
1448 static int init_usbat(struct us_data *us, int devicetype)
1449 {
1450         int rc;
1451         struct usbat_info *info;
1452         unsigned char subcountH = USBAT_ATA_LBA_HI;
1453         unsigned char subcountL = USBAT_ATA_LBA_ME;
1454         unsigned char *status = us->iobuf;
1455
1456         us->extra = kzalloc(sizeof(struct usbat_info), GFP_NOIO);
1457         if (!us->extra)
1458                 return 1;
1459
1460         info = (struct usbat_info *) (us->extra);
1461
1462         /* Enable peripheral control signals */
1463         rc = usbat_write_user_io(us,
1464                                  USBAT_UIO_OE1 | USBAT_UIO_OE0,
1465                                  USBAT_UIO_EPAD | USBAT_UIO_1);
1466         if (rc != USB_STOR_XFER_GOOD)
1467                 return USB_STOR_TRANSPORT_ERROR;
1468
1469         usb_stor_dbg(us, "INIT 1\n");
1470
1471         msleep(2000);
1472
1473         rc = usbat_read_user_io(us, status);
1474         if (rc != USB_STOR_TRANSPORT_GOOD)
1475                 return rc;
1476
1477         usb_stor_dbg(us, "INIT 2\n");
1478
1479         rc = usbat_read_user_io(us, status);
1480         if (rc != USB_STOR_XFER_GOOD)
1481                 return USB_STOR_TRANSPORT_ERROR;
1482
1483         rc = usbat_read_user_io(us, status);
1484         if (rc != USB_STOR_XFER_GOOD)
1485                 return USB_STOR_TRANSPORT_ERROR;
1486
1487         usb_stor_dbg(us, "INIT 3\n");
1488
1489         rc = usbat_select_and_test_registers(us);
1490         if (rc != USB_STOR_TRANSPORT_GOOD)
1491                 return rc;
1492
1493         usb_stor_dbg(us, "INIT 4\n");
1494
1495         rc = usbat_read_user_io(us, status);
1496         if (rc != USB_STOR_XFER_GOOD)
1497                 return USB_STOR_TRANSPORT_ERROR;
1498
1499         usb_stor_dbg(us, "INIT 5\n");
1500
1501         /* Enable peripheral control signals and card detect */
1502         rc = usbat_device_enable_cdt(us);
1503         if (rc != USB_STOR_TRANSPORT_GOOD)
1504                 return rc;
1505
1506         usb_stor_dbg(us, "INIT 6\n");
1507
1508         rc = usbat_read_user_io(us, status);
1509         if (rc != USB_STOR_XFER_GOOD)
1510                 return USB_STOR_TRANSPORT_ERROR;
1511
1512         usb_stor_dbg(us, "INIT 7\n");
1513
1514         msleep(1400);
1515
1516         rc = usbat_read_user_io(us, status);
1517         if (rc != USB_STOR_XFER_GOOD)
1518                 return USB_STOR_TRANSPORT_ERROR;
1519
1520         usb_stor_dbg(us, "INIT 8\n");
1521
1522         rc = usbat_select_and_test_registers(us);
1523         if (rc != USB_STOR_TRANSPORT_GOOD)
1524                 return rc;
1525
1526         usb_stor_dbg(us, "INIT 9\n");
1527
1528         /* At this point, we need to detect which device we are using */
1529         if (usbat_set_transport(us, info, devicetype))
1530                 return USB_STOR_TRANSPORT_ERROR;
1531
1532         usb_stor_dbg(us, "INIT 10\n");
1533
1534         if (usbat_get_device_type(us) == USBAT_DEV_FLASH) {
1535                 subcountH = 0x02;
1536                 subcountL = 0x00;
1537         }
1538         rc = usbat_set_shuttle_features(us, (USBAT_FEAT_ETEN | USBAT_FEAT_ET2 | USBAT_FEAT_ET1),
1539                                                                         0x00, 0x88, 0x08, subcountH, subcountL);
1540         if (rc != USB_STOR_XFER_GOOD)
1541                 return USB_STOR_TRANSPORT_ERROR;
1542
1543         usb_stor_dbg(us, "INIT 11\n");
1544
1545         return USB_STOR_TRANSPORT_GOOD;
1546 }
1547
1548 /*
1549  * Transport for the HP 8200e
1550  */
1551 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
1552 {
1553         int result;
1554         unsigned char *status = us->iobuf;
1555         unsigned char registers[32];
1556         unsigned char data[32];
1557         unsigned int len;
1558         int i;
1559
1560         len = scsi_bufflen(srb);
1561
1562         /*
1563          * Send A0 (ATA PACKET COMMAND).
1564          * Note: I guess we're never going to get any of the ATA
1565          * commands... just ATA Packet Commands.
1566          */
1567
1568         registers[0] = USBAT_ATA_FEATURES;
1569         registers[1] = USBAT_ATA_SECCNT;
1570         registers[2] = USBAT_ATA_SECNUM;
1571         registers[3] = USBAT_ATA_LBA_ME;
1572         registers[4] = USBAT_ATA_LBA_HI;
1573         registers[5] = USBAT_ATA_DEVICE;
1574         registers[6] = USBAT_ATA_CMD;
1575         data[0] = 0x00;
1576         data[1] = 0x00;
1577         data[2] = 0x00;
1578         data[3] = len&0xFF;             /* (cylL) = expected length (L) */
1579         data[4] = (len>>8)&0xFF;        /* (cylH) = expected length (H) */
1580         data[5] = 0xB0;                 /* (device sel) = slave */
1581         data[6] = 0xA0;                 /* (command) = ATA PACKET COMMAND */
1582
1583         for (i=7; i<19; i++) {
1584                 registers[i] = 0x10;
1585                 data[i] = (i-7 >= srb->cmd_len) ? 0 : srb->cmnd[i-7];
1586         }
1587
1588         result = usbat_get_status(us, status);
1589         usb_stor_dbg(us, "Status = %02X\n", *status);
1590         if (result != USB_STOR_XFER_GOOD)
1591                 return USB_STOR_TRANSPORT_ERROR;
1592         if (srb->cmnd[0] == TEST_UNIT_READY)
1593                 transferred = 0;
1594
1595         if (srb->sc_data_direction == DMA_TO_DEVICE) {
1596
1597                 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA,
1598                         registers, data, 19,
1599                         USBAT_ATA_DATA, USBAT_ATA_STATUS, 0xFD,
1600                         (USBAT_QUAL_FCQ | USBAT_QUAL_ALQ),
1601                         DMA_TO_DEVICE,
1602                         scsi_sglist(srb),
1603                         len, scsi_sg_count(srb), 10);
1604
1605                 if (result == USB_STOR_TRANSPORT_GOOD) {
1606                         transferred += len;
1607                         usb_stor_dbg(us, "Wrote %08X bytes\n", transferred);
1608                 }
1609
1610                 return result;
1611
1612         } else if (srb->cmnd[0] == READ_10 ||
1613                    srb->cmnd[0] == GPCMD_READ_CD) {
1614
1615                 return usbat_hp8200e_handle_read10(us, registers, data, srb);
1616
1617         }
1618
1619         if (len > 0xFFFF) {
1620                 usb_stor_dbg(us, "Error: len = %08X... what do I do now?\n",
1621                              len);
1622                 return USB_STOR_TRANSPORT_ERROR;
1623         }
1624
1625         result = usbat_multiple_write(us, registers, data, 7);
1626
1627         if (result != USB_STOR_TRANSPORT_GOOD)
1628                 return result;
1629
1630         /*
1631          * Write the 12-byte command header.
1632          *
1633          * If the command is BLANK then set the timer for 75 minutes.
1634          * Otherwise set it for 10 minutes.
1635          *
1636          * NOTE: THE 8200 DOCUMENTATION STATES THAT BLANKING A CDRW
1637          * AT SPEED 4 IS UNRELIABLE!!!
1638          */
1639
1640         result = usbat_write_block(us, USBAT_ATA, srb->cmnd, 12,
1641                                    srb->cmnd[0] == GPCMD_BLANK ? 75 : 10, 0);
1642
1643         if (result != USB_STOR_TRANSPORT_GOOD)
1644                 return result;
1645
1646         /* If there is response data to be read in then do it here. */
1647
1648         if (len != 0 && (srb->sc_data_direction == DMA_FROM_DEVICE)) {
1649
1650                 /* How many bytes to read in? Check cylL register */
1651
1652                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) !=
1653                         USB_STOR_XFER_GOOD) {
1654                         return USB_STOR_TRANSPORT_ERROR;
1655                 }
1656
1657                 if (len > 0xFF) { /* need to read cylH also */
1658                         len = *status;
1659                         if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
1660                                     USB_STOR_XFER_GOOD) {
1661                                 return USB_STOR_TRANSPORT_ERROR;
1662                         }
1663                         len += ((unsigned int) *status)<<8;
1664                 }
1665                 else
1666                         len = *status;
1667
1668
1669                 result = usbat_read_block(us, scsi_sglist(srb), len,
1670                                                            scsi_sg_count(srb));
1671         }
1672
1673         return result;
1674 }
1675
1676 /*
1677  * Transport for USBAT02-based CompactFlash and similar storage devices
1678  */
1679 static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
1680 {
1681         int rc;
1682         struct usbat_info *info = (struct usbat_info *) (us->extra);
1683         unsigned long block, blocks;
1684         unsigned char *ptr = us->iobuf;
1685         static unsigned char inquiry_response[36] = {
1686                 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00
1687         };
1688
1689         if (srb->cmnd[0] == INQUIRY) {
1690                 usb_stor_dbg(us, "INQUIRY - Returning bogus response\n");
1691                 memcpy(ptr, inquiry_response, sizeof(inquiry_response));
1692                 fill_inquiry_response(us, ptr, 36);
1693                 return USB_STOR_TRANSPORT_GOOD;
1694         }
1695
1696         if (srb->cmnd[0] == READ_CAPACITY) {
1697                 rc = usbat_flash_check_media(us, info);
1698                 if (rc != USB_STOR_TRANSPORT_GOOD)
1699                         return rc;
1700
1701                 rc = usbat_flash_get_sector_count(us, info);
1702                 if (rc != USB_STOR_TRANSPORT_GOOD)
1703                         return rc;
1704
1705                 /* hard coded 512 byte sectors as per ATA spec */
1706                 info->ssize = 0x200;
1707                 usb_stor_dbg(us, "READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
1708                              info->sectors, info->ssize);
1709
1710                 /*
1711                  * build the reply
1712                  * note: must return the sector number of the last sector,
1713                  * *not* the total number of sectors
1714                  */
1715                 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
1716                 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
1717                 usb_stor_set_xfer_buf(ptr, 8, srb);
1718
1719                 return USB_STOR_TRANSPORT_GOOD;
1720         }
1721
1722         if (srb->cmnd[0] == MODE_SELECT_10) {
1723                 usb_stor_dbg(us, "Gah! MODE_SELECT_10\n");
1724                 return USB_STOR_TRANSPORT_ERROR;
1725         }
1726
1727         if (srb->cmnd[0] == READ_10) {
1728                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1729                                 ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1730
1731                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
1732
1733                 usb_stor_dbg(us, "READ_10: read block 0x%04lx  count %ld\n",
1734                              block, blocks);
1735                 return usbat_flash_read_data(us, info, block, blocks);
1736         }
1737
1738         if (srb->cmnd[0] == READ_12) {
1739                 /*
1740                  * I don't think we'll ever see a READ_12 but support it anyway
1741                  */
1742                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1743                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1744
1745                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
1746                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
1747
1748                 usb_stor_dbg(us, "READ_12: read block 0x%04lx  count %ld\n",
1749                              block, blocks);
1750                 return usbat_flash_read_data(us, info, block, blocks);
1751         }
1752
1753         if (srb->cmnd[0] == WRITE_10) {
1754                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1755                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1756
1757                 blocks = ((u32)(srb->cmnd[7]) << 8) | ((u32)(srb->cmnd[8]));
1758
1759                 usb_stor_dbg(us, "WRITE_10: write block 0x%04lx  count %ld\n",
1760                              block, blocks);
1761                 return usbat_flash_write_data(us, info, block, blocks);
1762         }
1763
1764         if (srb->cmnd[0] == WRITE_12) {
1765                 /*
1766                  * I don't think we'll ever see a WRITE_12 but support it anyway
1767                  */
1768                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
1769                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
1770
1771                 blocks = ((u32)(srb->cmnd[6]) << 24) | ((u32)(srb->cmnd[7]) << 16) |
1772                          ((u32)(srb->cmnd[8]) <<  8) | ((u32)(srb->cmnd[9]));
1773
1774                 usb_stor_dbg(us, "WRITE_12: write block 0x%04lx  count %ld\n",
1775                              block, blocks);
1776                 return usbat_flash_write_data(us, info, block, blocks);
1777         }
1778
1779
1780         if (srb->cmnd[0] == TEST_UNIT_READY) {
1781                 usb_stor_dbg(us, "TEST_UNIT_READY\n");
1782
1783                 rc = usbat_flash_check_media(us, info);
1784                 if (rc != USB_STOR_TRANSPORT_GOOD)
1785                         return rc;
1786
1787                 return usbat_check_status(us);
1788         }
1789
1790         if (srb->cmnd[0] == REQUEST_SENSE) {
1791                 usb_stor_dbg(us, "REQUEST_SENSE\n");
1792
1793                 memset(ptr, 0, 18);
1794                 ptr[0] = 0xF0;
1795                 ptr[2] = info->sense_key;
1796                 ptr[7] = 11;
1797                 ptr[12] = info->sense_asc;
1798                 ptr[13] = info->sense_ascq;
1799                 usb_stor_set_xfer_buf(ptr, 18, srb);
1800
1801                 return USB_STOR_TRANSPORT_GOOD;
1802         }
1803
1804         if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
1805                 /*
1806                  * sure.  whatever.  not like we can stop the user from popping
1807                  * the media out of the device (no locking doors, etc)
1808                  */
1809                 return USB_STOR_TRANSPORT_GOOD;
1810         }
1811
1812         usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n",
1813                      srb->cmnd[0], srb->cmnd[0]);
1814         info->sense_key = 0x05;
1815         info->sense_asc = 0x20;
1816         info->sense_ascq = 0x00;
1817         return USB_STOR_TRANSPORT_FAILED;
1818 }
1819
1820 static int init_usbat_cd(struct us_data *us)
1821 {
1822         return init_usbat(us, USBAT_DEV_HP8200);
1823 }
1824
1825 static int init_usbat_flash(struct us_data *us)
1826 {
1827         return init_usbat(us, USBAT_DEV_FLASH);
1828 }
1829
1830 static struct scsi_host_template usbat_host_template;
1831
1832 static int usbat_probe(struct usb_interface *intf,
1833                          const struct usb_device_id *id)
1834 {
1835         struct us_data *us;
1836         int result;
1837
1838         result = usb_stor_probe1(&us, intf, id,
1839                         (id - usbat_usb_ids) + usbat_unusual_dev_list,
1840                         &usbat_host_template);
1841         if (result)
1842                 return result;
1843
1844         /*
1845          * The actual transport will be determined later by the
1846          * initialization routine; this is just a placeholder.
1847          */
1848         us->transport_name = "Shuttle USBAT";
1849         us->transport = usbat_flash_transport;
1850         us->transport_reset = usb_stor_CB_reset;
1851         us->max_lun = 0;
1852
1853         result = usb_stor_probe2(us);
1854         return result;
1855 }
1856
1857 static struct usb_driver usbat_driver = {
1858         .name =         DRV_NAME,
1859         .probe =        usbat_probe,
1860         .disconnect =   usb_stor_disconnect,
1861         .suspend =      usb_stor_suspend,
1862         .resume =       usb_stor_resume,
1863         .reset_resume = usb_stor_reset_resume,
1864         .pre_reset =    usb_stor_pre_reset,
1865         .post_reset =   usb_stor_post_reset,
1866         .id_table =     usbat_usb_ids,
1867         .soft_unbind =  1,
1868         .no_dynamic_id = 1,
1869 };
1870
1871 module_usb_stor_driver(usbat_driver, usbat_host_template, DRV_NAME);