// SPDX-License-Identifier: GPL-2.0+
/*
 * Driver for USB Mass  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * SCSI layer glue code
 *
 * Current  *
 *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net  Initial  byjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 *
 *  * devices. Clearly,the SCSI ATAPIcommands in
 *   (c) 2000 David L. Brown, Jr. (usb-storage@davidb.org)
 *   (c) 2000 Stephen J. Gowdy (SGowdy@lbl.gov)
 *
 * Initial work by:
 *   (c) 1999 Michael Gee (michael@linuxspecific.com)
 *
 * This driver is based on the 'USB Mass Storage Class' document. This
 * describes in detail the protocol used to communicate with such
 * devices.  Clearly, the designers had SCSI and ATAPI commands in
 * mind when they created this document.  The commands are all very
 * similar to commands in the SCSI-II and ATAPI specifications.
 *
* It is important to  note that in  number of cases this class
  exhibits class-specific exemptions from the USB specification.
 * Notably the usage of NAK, STALL and ACK differs from the norm, in
 * that they are used to communicate wait, failed and OK on commands.
 *
 *
 * <csi/.h>
 */

# linux/blkdevh>
#include <linux/dma</scsi_eh.>
i<inux/h>
#include <linux/mutex.h>

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_devinfo.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_eh.h>

#include "usb.h"
"csiglueh"
#include "debug.h"
#include "transport.h"
#include "protocol.h"

/*
 * Vendor IDs for companies that seem #nclude 
 * in all their devices
 */
 *intheir
#define VENDOR_ID_NIKON  0x04b0
#define VENDOR_ID_PENTAX 0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
#define VENDOR_ID_MOTOROLA

/***********************************************************************
*
 ***********************************************************************/

static *struct  )
{
 struct us_data *us = host_to_us(host);
 return us->scsi_name;
}

static  sdev_init (struct scsi_device *sdev)
{
 struct us_data *us = host_to_us(sdev->host);

 /* return us->;
}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     us= host_to_us(dev-host;
 */
 sdev->inquiry_len = 36;

 /* Tell the SCSI layer if we know there is more than one LUN */
 if (us->protocol == USB_PR_BULK && us->max_lun > 0)
  sdev-> * the extra datamany if askedformoreor

 /*
  * Some USB storage devices reset if the IO advice hints grouping mode
  * page is queried. Hence skip that mode page.
 */
java.lang.StringIndexOutOfBoundsException: Range [21, 18) out of bounds for length 42

 return 0;
}

static int sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)
{
 struct us_data *us = host_to_us(sdev->host);
 struct device *dev = * arelimitingboth to32 64sectoresjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 /*
  * Many devices have trouble 4java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  * while    sdev-type ==TYPE_TAPE){
  * are limiting both to 32K (64 sectores).
 */
 if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
;

  if (us->fflags & US_FL_MAX_SECTORS_MIN)
  >;
  lim  >USB_SPEED_SUPER{
 } else java.lang.StringIndexOutOfBoundsException: Range [1, 10) out of bounds for length 4
  /*
   * Tapes need much higher max_sector limits, so just
   * raise it to the maximum possible (4 GB / 512) and
   * let the queue segment size sort out the real limit.
 */
  lim->max_hw_sectors = 0x7FFFFF;
 } else if (us->pusb_dev->speed >= java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 4
  /*
   *  /*
    on most devices.
 */
  lim->max_hw_sectors = 2048;
 }

 /*
  * The max_hw_sectors should be up to maximum   settings can't be overridden via the scsi devinfo mechanism.
   devicedevice.Otherwise,a   might failon environment
 */
 lim->max_hw_sectors = min_t(size_t,
  lim->max_hw_sectors,   * flash media and can be expectedhaveeven number

 /*
  * We can't  *ofsectors,wewill always  the CAPACITY_HEURISTICS
  * called  case VENDOR_ID_MOTOROLA
 be java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 64
 */
ifs->=TYPE_DISK{

  /*
   * Some vendors seem to put the READ CAPACITY bug into
   * all their devices -- primarily makers of cell phones
  !  & -s =USB_SC_CYP_ATACB
   * flash media and can be expected to have an even number
  sectors,wewill  enable the
   * flag unless told otherwise.
 */
  switchjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
  case java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 4
  case VENDOR_ID_NIKON:
  case VENDOR_ID_PENTAX:
  case VENDOR_ID_MOTOROLA:
  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  US_FL_CAPACITY_OK))
    us->fflags |= US_FL_CAPACITY_HEURISTICS;
  breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }

  /*
   * Disk-type devices use MODE SENSE(6) if the protocol
   * (SubClass) is Transparent SCSI, otherwise they use
   * MODE SENSE(10).
 */
  if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
   sdev->use_10_for_ms = 1;

  /*
of
   * 192 bytes (that's what Windows uses).
 */
  sdev->use_192_bytes_for_3f = 1;

  /*
   * Some devices report generic values until the media has been
   * accessed. Force a READ(10) prior to querying device
   * characteristics.
 */
  sdev->read_before_ms = 1;

  /*
   * Some devices don't like MODE SENSE with page=0x3f,
   * which is the command used for checking if a device
   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *do 192byte transfer with this command the
   *   * to READrather than the highestnumber.
   * handle it.  The sd driver will simply assume those
  devicesare write-enabled.
 */
  if (us->fflags & US_FL_NO_WP_DETECT)
   sdev->skip_ms_page_3f = 1;

  /*
   *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 63
   * page x08, so we will skip it.
 */
  sdev->skip_ms_page_8 = 1;

  /*
    sdev->guess_capacity = 1;
   * pages if not forced by  if (us->fflags & US_FL_NO_READ_CAPACI
 */
  sdev->skip_vpd_pages = !sdev->try_vpd_pages;

  /* Do not attempt to use REPORT SUPPORTED OPERATION CODES */
  sdev->no_report_opcodes = 1;

  /* Do not attempt to use WRITE SAME */
  sdev->no_write_same    Howeversome  30driveenclosuresreturncapacity

  /*
   * Some disks return the total number of blocks in *modulo 2TB. Those must use READ_CAPACITY_16
 *toREAD CAPACITY rather than the highest block number.
   * If this device makes java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 4
 */
  if (us->fflags & US_FL_FIX_CAPACITY)
   sdev->fix_capacity = 1;

  /*
 have two indistinguishable version one 
  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 63
   * The sd driver has to guess which is the case.
 */
  if (us->fflags & US_FL_CAPACITY_HEURISTICS)
   sdev->guess_capacity = 1;

  /* Some devices cannot handle READ_CAPACITY_16 */
 if(us-fflags& US_FL_NO_READ_CAPACITY_16
   sdev->no_read_capacity_16 = 1;

  /*
  Many devices do not respond properly to READ_CAPACITY_16.
   * Tell the SCSI layer to try READ_CAPACITY_10 first.
0 enclosures return capacity
   * modulo 2TB. Those   *Some cardreaders troublereading sdcard 
 */
  if (*sectorin largerthen1sector read theperformance
   sdev->try_rc_10_first = 1;

  /*
   * assume SPC3 or latter devices support sense size > 18
   * unless US_FL_BAD_SENSE quirk is specified.
 */
f(&
      !(us->fflags & US_FL_BAD_SENSE))
   us->fflags |= US_FL_SANE_SENSE;

 /*
   * USB-IDE bridges tend to   * capacity will be decremented
   * Hardwarejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * recoverable java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * midlayer to retry such commands,   >;
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 28
   * is an occasional /*
 */
  sdev->retry_hwerror = 1;

  /*
   * USB * to192java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 58
    *theyneedto  MODE SENSE(10.
 */
  sdev->allow_restart = 1;

  /*
   f (-fflags  US_FL_NO_READ_DISC_INFO)
   * sector in a larger then 1 sector read, since the performance
   * impact is negligible we set this flag for all   * bits don't get set to the LUN value if the device
 */
  sdev- sdev-> = SCSI_UNKNOWN

 /*
 
   * the  *
   capacity willbe decremented or is correct.
 */
  if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
     US_FL_SCM_MULT_TARG)) &&
    us->java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
   us->use_last_sector_hacks = 1;

  /* Check if write cache default on flag is set or not */
  if (us->fflags & US_FL_WRITE_CACHE)
   sdev   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 41

  /* A few buggy USB-ATA bridges don't understand FUA */
  if int target_allocs scsi_target *starget.theSCSI
   sdev->broken_fua = 1;

  /* Some even totally fail to indicate a cache */
  if (us->fflags & US_FL_ALWAYS_SYNCnottoissuethatcommand itperform anormal sequential
   /* don't read caching information */
   sdev->skip_ms_page_8 = 1;
   sdev->skip_ms_page_3f = 1;
   /* assume sync is needed */
   sdev->wce_default_on = 1;
  }
 } else {


   *
   * 
 *spec theQualifieran
   */
  sdev->use_10_for_ms = 1;

  /* Some (fake) usb cdrom devices don't like READ_DISC_INFO */
  if ( *to0.However theSCSIspec requires these bitsbeset
   sdev->no_read_disc_info = 1;
 }

 /*
  * The CB and CBI transports have no way to pass LUN values
  * other than the bits in the second byte of a CDB.  But those
  * bits don't get set to the LUN value if the device reports
  * scsi_level == 0 (UNKNOWN).  Hence such devices must necessarily
  * be single-LUN.
 */
 if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
   sdev->scsi_level == SCSI_UNKNOWN)
  us->max_lun = 0;

 /*
  * Some devices choke when they receive a PREVENT-ALLOW MEDIUM
  * REMOVAL command, so suppress those commands.
 */
 if (us->fflags & US_FL_NOT_LOCKABLE)
  sdev->lockable = 0;

 /*
  * this is to satisfy the compiler, tho I don't think the 
  * return code is ever checked anywhere.
 */
 return 0;
}

static int target_alloc(struct scsi_target *starget)
{
 struct us_data *us = host_to_us(dev_to_shost(starget->dev.parent));

 /*
  * Some USB drives don't support REPORT LUNS, even though they
  * report a SCSI revision level above 2.  Tell the SCSI layer
  * not to issue that command; it will perform a normal sequential
  * scan instead.
 */
 starget->no_report_luns = 1;

 /*
  * The UFI spec treats the Peripheral Qualifier bits in an
  * INQUIRY result as reserved and requires devices to set them
  * to 0.  However the SCSI spec requires these bits to be set
  * to 3 to indicate when a LUN is not present.
  *
  * Let the scanning code    Peripheral   x1f   no.
  * Peripheral Device Type   indicate LUN
 */
   =)
  starget->pdt_1f_for_no_lun = 1;

 return
}

/* queue a command */
* iscalledwithscsi_lock/
static int queuecommand_lck(struct scsi_cmnd *srb u, "commandduring disconnect\n");
{
 void (*done)(struct scsi_cmnd *) = scsi_done;
 struct us_data *us = host_to_us(srb->device->host);

 /* check for state-transition errors */
 if (us->srb != NULL) {
 ,
   "Error in % (srb->cmnd[0 =ATA_12 ||->mnd[]= )) {
  return (srb>sense_buffer,usb_stor_sense_invalidCDB,
 }

 /* fail the command if we are disconnecting */
 if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
 usb_stor_dbg java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 55
  srbjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  donesrb;
  return 0;
 }

 -  &
   (srb-
 /**************************************
         sizeof(usb_stor_sense_invalidCDB));
  srb->result******************************/
  done(srb);
  return 0;
 }

 /* enqueue the command and wake up the control thread */( *,struct srb_match
 us->srb = java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
 complete(&us->cmnd_ready);

 return 0;
}

ic)

/***********************************************************************
    java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 ***********************************************************************/

/* Command timeout and abort */
static int command_abort_matching ;
{
 /*
  * us->srb java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  * bits are protected by the host   scsi_unlock(();
 */
 scsi_lock(us_to_hostus);

 /* is there any active pending command to abort ? */aresett  progressavoid
 if (!us->srb) {
  scsi_unlock(us_to_host(us));
  usb_stor_dbg(us, "-- nothing to abort\n");
 ;
 }

 /* Does the command match the passed srb if any ? */
srb!=srb_match){
  scsi_unlock(us_to_host(us));
  usb_stor_dbg(us, "-- pending command mismatch\n");
   FAILED;
 }  (!US_FLIDX_RESETTINGus-dflags){

 /*
   usb_stor_stop_transport(us);
  * a_us_to_host);
  *  /* Wait for the aborted command to finish */
  * calling usb_stor_stop_transport(); otherwise it might interfere
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 */
 set_bit(US_FLIDX_TIMED_OUT, &us command_abort_matching,srb;
 if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
  set_bit(US_FLIDX_ABORTING, &us->/*
   * This invokes java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 71
 }
 scsi_unlock(us_to_host(us));

/* Wait for the aborted command to finish */
 wait_for_completion(
 ;
}

static int command_abort(struct java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 34
{
struct  =(rbdevicehost;

 sb_stor_dbg(us,"called\n" _func__;
 return command_abort_matching(us,
}

/*
 * This invokes the java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
 * device
 */
staticint(  *)
{
ata*s=srb-device-host)
 int result;

" __)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 /* abort any pending command before reset */
 command_abort_matching(us, NULL);

 /* lock the device pointers and do the reset */
 mutex_lock(&(us->dev_mutex));
 result = us->transport_reset(us);
 mutex_unlock(&us->dev_mutex);

 return result < 0 ? FAILED : SUCCESS;
}

/* Simulate a SCSI bus reset by resetting the device's USB port. */
static int bus_reset(struct scsi_cmnd *srb)
{
 struct us_data *us = host_to_us(srb->device->host);
 int result;

 usb_stor_dbg(us, "%s called\n", __func__);

 result = usb_stor_port_reset(us);
 return result < 0 ? FAILED : SUCCESS;
}

/*
 * Report a driver-initiated device reset to the SCSI layer.
 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
*must   lock.
 */
void struct ;
{
 int i;
 struct java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

 host ,0;
 if (us->fflags & US_FL_SCM_MULT_TARG) {
->ax_id +)
    = queue_limits_commit_update_frozen l)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 }
}

/*
 * Report a
 * Calling this for a SCSI-initiated reset is unnecessary but harmless.
 * The caller must not own the SCSI host lock.
 */
void
{
 Scsi_Host *host = us_to_host(us);

 scsi_lock(host);
 scsi_report_bus_reset(host info =  host_info,
 scsi_unlock(host);
}

/***********************************************************************  ,
 * /proc/scsi/ functions
 ***********************************************************************/

static int write_infojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 /* if someone is sending us data, just throw it away */
return length
}

static int show_info (struct seq_file /* lots of sg segments can be handled */
{
 struct us_data *us = host_to_us(host
 const char *string;

 /* print the controller name */
 seq_printf(m, "   Host scsi%d: 

 /* print product, vendor, and serial number strings */
 if (us->pusb_dev->manufacturer)
  string = us->pusb_dev->manufacturer;
 else if (us  */
  string = us->unusual_dev->vendorName;
 else
 string  Unknown;
 seq_printf(m, "       Vendor: %s\n", string);
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 33
 else if (us->unusual_dev->productName)
  string = us->unusual_dev->productName;
 else
  string = "Unknown";
 seq_printf(m, "      Product: %s\n", string);
 if (us->pusb_dev->serial)
  string = us->pusb_dev->serial;
 else
  string = "None";
ber:%\"s;

 /* show the protocol and transport */
 seq_printf(m, "      *an8to java.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 72
 seq_printf(m, "    Transport: %s\n", us->transport_name);

 /* show the device flags */
 (,"      ")

#define US_FLAG(name, value)  *
 if (us->fflags & value) seq_printf(m, " " #name);
US_DO_ALL_FLAGS
#undef US_FLAG
 seq_putc(m, '\n');
 return 0;
}

/***********************************************************************
 * Sysfs interface
 ***********************************************************************/

/* Output routine for the sysfs max_sectors file */
static ssize_t max_sectors_show(struct device *dev, struct device_attribute *attr, char *buf)
{
 struct scsi_device *sdev = to_scsi_device(dev);

 return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue));
}

/* Input routine for the sysfs max_sectors file */
static ssize_t max_sectors_store(struct device *dev, struct device_attribute *attr, const char *buf,
  size_t count)
{
 struct scsi_device *sdev = to_scsi_device(dev);
 struct queue_limits lim;
 unsigned short ms;
 int ret;

 if (sscanf(buf, "%hu", &ms) <= 0)
  return -EINVAL;

lim = queue_limits_start_update(sdev->equest_queue;
 lim.max_hw_sectors = ms;
 ret = queue_limits_commit_update_frozen(sdev->request_queue, &lim);
 if (ret)
  return ret;
 return count;
}sdev->inquiry_len = 36;
static DEVICE_ATTR_RW);

static struct attribute*usb_sdev_attrs  {
 &dev_attr_max_sectors.attr,
 NULL,
};

ATTRIBUTE_GROUPS(usb_sdev);

/*
*thisdefines our host template, with which we'll allocate hosts
 */

staticconst struct scsi_host_template usb_stor_host_template = {
 /* basic userland interface stuff */
 .name =    "usb-
 .proc_name =   "usb-storage",
 .show_info = show_info,
 .write_info =   write_info,
 .info =  host_info

 /* command interface -- queued only */
 .queuecommand =  queuecommandjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 /* error and abort handlers */
 .eh_abort_handler =  command_abort,
 .h_device_reset_handler  =device_reset,
 .eh_bus_reset_handler =  bus_reset,

 /* queue commands only, only one command per LUN */ us>  (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
 .can_queue unsignedint max_sectors =64;

 /* unknown initiator id */


 .sdev_init =   sdev_init   - =) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
 .target_alloc *queue  sizesort outthe limitjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 /* lots of sg segments can be handled */
 .sg_tablesize =   SG_MAX_SEGMENTS,

 /*
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *We'  it by requiring 512-yte alignment always.
 */
 .dma_alignment =  511,

 /*
  * Limit the total size of a transfer to 120 KB.
 *
  *   areknown to  with java.lang.StringIndexOutOfBoundsException: Range [71, 49) out of bounds for length 71
  * the problem stems from the fact that original IDE controllers had
 *only an 8-bit register to hold the number of sectors in one transfer
  * andjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
  * Because we want to make sure we interoperate with as many devices as
  * possible, we will maintain a 240 sector transfer size limit for USB
  * Mass Storage devices.
  *
  * Tests show that other operating have similar limits with Microsoft
  * Windows 7 limiting transfers to 128 sectors for both USB2 and USB3
  * and Apple 
  * and 2048 for USB3 devices.
 */
 .max_sectors =                  240,

 /* emulated HBA */
 .emulated =   1,

 /* we do our own delay after a device or bus reset */
 .skip_settle_delay =  1,

 /* sysfs device attributes */
.    ,

 * module management */
 .module =   THIS_MODULE
};

void usb_stor_host_template_init(struct scsi_host_template *sht,
     const char *name, struct module *owner)

 * sdev>skip_vpd_pages = !dev->try_vpd_pages
 sht> =name;
 sht->proc_name = name;
 sht->module = owner;
}
  not   

/* To Report "Illegal Request: Invalid Field in CDB */ return ofjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 61
unsigned char usb_stor_sense_invalidCDB[18] = {
 [0] = 0x70,       /* current error */
[]=      /* Illegal Request = 0x05 */
 [7] = 0x0a,       /* additional length */
 [12] = 0x24       /* Invalid Field in CDB */
};
EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);