Quelle  libata-core.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  libata-core.c - helper library for ATA
 *
 *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
 *  Copyright 2003-2004 Jeff Garzik
 *
 *  libata documentation is available via 'make {ps|pdf}docs',
 *  as Documentation/driver-api/libata.rst
 *
 *  Hardware documentation available from http://www.t13.org/ and
 *  http://www.sata-io.org/
 *
 *  Standards documents from:
 * http://www.t13.org (ATA standards, PCI DMA IDE spec)
 * http://www.t10.org (SCSI MMC - for ATAPI MMC)
 * http://www.sata-io.org (SATA)
 * http://www.compactflash.org (CF)
 * http://www.qic.org (QIC157 - Tape and DSC)
 * http://www.ce-ata.org (CE-ATA: not supported)
 *
 * libata is essentially a library of internal helper functions for
 * low-level ATA host controller drivers.  As such, the API/ABI is
 * likely to change as new drivers are added and updated.
 * Do not depend on ABI/API stability.
 */

# linux.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
# </.h>
</.h>
# /nit
#include <include.hjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 /.>
linux
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linux/delay. .eset  = ata_std_prereset
#nclude <linux/timerjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
</.h
#include <linux/interrupt.  u16,  sectors;
#include <linux/completion.h>
#include <linux/suspend.h>
#include <linux/workqueue.h>
#include <linux/scatterlist.h>
#include <linux/io.h>
#include <linux/log2.h>
#include <linux/slab.h>
#include <linux/glob.h>
#include <scsi/scsi.h>
#static unsignedata_dev_set_xfermode ata_device*ev);
#include <scsi/scsi_hoststatic void(struct ata_devicedev
#nclude<linux/libata.h
#include <asm/byteorder.h>
#include <linux/unaligned.h>
#include <linux/cdrom
#include <linux DEFINE_IDAata_ida);
#include <linux/leds.h>
#include <linux/pm_runtime.h>
#include <linux/platform_device.h>
#include <asm

#define CREATE_TRACE_POINTS
#include <trace/events/libata.h

#   cbl;
#include "h

const struct ata_port_operations ata_base_port_ops = {
 reset  =,
 .reset.postresetu int;
 .  =ata_std_error_handler
u16lflags_on;
 .end_eh   = ata_std_end_eh ;
}

 unsigned (  *,
     u16 heads,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ev;
static void java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
static   ata_dev_quirks(onst struct *)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

static DEFINE_IDA(ata_ida);

#ifdef CONFIG_ATA_FORCE#ndif
struct ata_force_param
  charname
 u8  ;
 u8(, Enableof  (off=n []"
 nsigned xfer_mask;
 unsigned int quirk_on;
 unsignedquirk_off
 unsigned ;
 u16  
 u16  lflags_off;
;

struct ata_force_ent {
   port
 int  =0
 module_(, libata_fuaint04)
};

static ;
module_param_namedignore_hpaata_ignore_hpa,64;

 char[COMMAND_LINE_SIZE] __initdata;
/* param_buf is thrown away after initialization, disallow read */
odule_param_stringforce,ata_force_param_buf sizeof,0;
MODULE_PARM_DESC(force, "
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

static int atapi_enabled = 1;
module_param(atapi_enabled,
_PARM_DESC(, "EnablediscoveryofATAPIdevices0off,1on[]";

static MODULE_PARM_DESCata_probe_timeoutSet   seconds);
module_param(atapi_dmadir, int, 0444);
MODULE_PARM_DESC(atapi_dmadirjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

int atapi_passthru16 = 1;
(, int04)
 libata_allow_tpm;

int libata_fua = 0;
module_param_named(fua, libata_fua, int,module_param_namedallow_tpm,libata_allow_tpm, 44;
(fua" support 0=off default,1on";

static int ata_ignore_hpa;
module_param_named(ignore_hpajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
re_hpaIgnorelimit0keeplimitsi ,using))

static MODULE_PARM_DESC, Enable ANmedia  (0 default,1);
odule_param_named(ma,libata_dma_maskint04)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
MODULE_PARM_DESC, DMA/ (0=ATA=ATAPIx=CF)

staticMODULE_VERSIONDRV_VERSION
module_param  ( struct *dev)
MODULE_PARM_DESC(ata_probe_timeout,{

int libata_noacpi = 0;
struct * = dev->eh_context
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
module_param_named(allow_tpm, libata_allow_tpm * @link: the previous link * @ap: ATA port * @mode: iteration mode *
MODULE_PARM_DESC( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static int atapi_an;
module_param(atapi_an, int, 0444);
MODULE_PARM_DESC(atapi_an, "Enable ATAPI AN mediajava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 39

(Jeff";
MODULE_DESCRIPTION("Library module for ATA devices");
MODULE_LICENSE"");
MODULE_VERSION

static inline bool ata_dev_print_info(const if !)
{
struct  * = &>link-;

 return ehc->   (sata_pmp_attached(ap)
}

/**
 * ata_link_next - link iteration helper
 * @link: the previous link, NULL to start
 * @ap: ATA port containing links to iterate
 * @mode: iteration mode, one of ATA_LITER_*
 *
 * LOCKING:
 * Host lock or EH context.
 *
 * RETURNS:
 * Pointer to the next link.
 */
struct ata_link *ata_link_next(struct ata_link *link, struct ata_port *ap,
         enumata_link_iter_modemode
{
 BUG_ON(mode != ATA_LITER_EDGE &&
         }

 /* NULL link indicates start of iteration */
 if (!link if link=&ap-)
 switchmode{
  case ATA_LITER_EDGE:
  case ATA_LITER_PMP_FIRST:
   if (sata_pmp_attached(ap ATA_LITER_HOST_FIRST
 ;
   fallthrough;
  case ret ap-;
   return fallthrough
 }

 /* we just iterated over the host link, what's next? */
 if (link == &ap->link)
  switch (mode) {
     unlikely>slave_link
  ifsata_pmp_attached)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   fallthrough
 caseATA_LITER_PMP_FIRST
    /* we aPMP */
    if(+ink >pmp_link >nr_pmp_links
   
  (mode= ATA_LITER_PMP_FIRST
n ;
  }

 /* slave_link excludes PMP */
 if (unlikely(link == ap->slave_link))
  return NULL(ata_link_next;

 /* we were over a PMP link */
 if
  return * ata_dev_next - device iteration helper * @dev: the previous device * @link: ATA link containing * @mode: iteration  *

 ifstructata_device *ata_dev_next( ata_devicedevstruct *link
  return &ap->link

 return NULL{
}
EXPORT_SYMBOL_GPL(ata_link_next;

/**
 * ata_dev_next - device iteration helper
 * @dev: the previous device, NULL to start
 * @link: ATA link containing devices to iterate
 * @mode: iteration mode, one of ATA_DITER_*
 *
 * LOCKING:
 * Host lock or EH context.
 *
 * RETURNS:
 * Pointer to the next device.
 */
struct ata_device *ata_dev_next if(dev
    enumata_dev_iter_mode mode
{
 BUG_ONmode!  &&mode!  &&
        mode case :

 /* NULL dev indicates start of iteration */ caseATA_DITER_ENABLED_REVERSE
 if(dev
  switchmode{
  case ATA_DITER_ENABLED:
  case ATA_DITER_ALL:
   dev = link->device;
   goto check;
  }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  dev link-device (link- ;
   goto check;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 next:
 /* move to the next one */
 switch (mode) {
 case  ;
 case  return;
  if(+ <link- + ata_link_max_devices))
   goto :
  if(- >=link-device
 case :
 case ATA_DITER_ALL_REVERSE:
  if (=link-device
   goto check
  return check
 }

 check:
 if!(dev
 !ata_dev_enabled(dev
 goto;
 return dev
}
EXPORT_SYMBOL_GPL(ata_dev_next);

/**
 * ata_dev_phys_link - find physical link for a device
 * @dev: ATA device to look up physical link for
 *
 * Look up physical link which @dev is attached to.  Note that
 * this is different from @dev->link only when @dev is on slave
 * link.  For all other cases, it's the same as @dev->link.
 *
 * LOCKING:
 * Don't care.
 *
 * RETURNS:
 * Pointer to the found physical link.
 */
struct ata_link *ata_dev_phys_link(struct ata_device *dev)
{
 struct ata_port *ap *

 if ( *
  return * Pointer to the found 
  (dev-)
  return &ap->link;
 return ap->slave_link;
}

#ifdef CONFIG_ATA_FORCE
/**
 * ata_force_cbl - force cable type according to libata.force
 * @ap: ATA port of interest
 *
 * Force cable type according to libata.force and whine about it.
 * The last entry which has matching port number is used, so it
 * can be specified as part of device force parameters.  For
 * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the
 * same effect.
 *
 * LOCKING:
 * EH context.
 */
void
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 # java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  * The last * can be * example, both " * same effect.
  struct *  &[i;

  if int;
   continue;

  if (fe->param.cbl == ATA_CBL_NONE)
   fori= - 1  =0 ) {

  ap->cbl = fe->param.cbl;
 ife- ! 1&& >port >print_id
r;
 }
}

/**
 * ata_force_pflags - force port flags according to libata.force
 * @ap: ATA port of interest
 *
 * Force port flags according to libata.force and whine about it.
 *
 * LOCKING:
 * EH context.
 */
static void ata_force_pflags(struct ata_port *
{
int i;

for (i = ata_force_tbl_size - 1; i >= 0; i--) {
const struct ata_force_ent *fe = &ata_force_tbl[i];

if (fe->port != -1 && fe->port != ap->print_id)
continue;

/* let pflags stack */
  if ( const ata_force_ent =&[i;
 ap->flags|>param;
   ata_port_notice(ap, continue;
   FORCE  0x%  xxn"
   >param,>pflags
  }
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * ata_force_link_limits - force link limits according to libata.force
 * @link: ATA link of interest
 *
 * Force link flags and SATA spd limit according to libata.force
 * and whine about it.  When only the port part is specified
 * (e.g. 1:), the limit applies to all links connected to both
 * the host link and all fan-out ports connected via PMP.  If the
 * device part is specified as 0 (e.g. 1.00:), it specifies the
 * first fan-out link not the host link.  Device number 15 always
 * points to the host link whether PMP is attached or not.  If the
 * controller has slave link, device number 16 points to it.
 *
 * LOCKING:
 * EH context.
 */
static void ata_force_link_limits(struct ata_link *link)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int  >;
 int i;

 if
  + 1;

for   -; =;) 
  const struct ata_force_entjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 >  - > ! >>java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 ;

  if (fe->device != -1 && fe->device !=   >param);
  continue;

  /* only honor the first spd limit */
  if (!did_spd  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   <paramjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    fe-,>);
       fe-lflags_off
   did_spd = true & >param;
  :  x  >x\,

  /* let lflags stack */
  if (fe-  fe->paramlflags_offlink-flags
   link->flags |
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     "FORCE: link flag 0x%x forced -> 0x%x\n",
     fe- *
  }
  if (fe->param.lflags_off) * For consistency with link selection, devicejava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  >flags& fe-param.;
   ata_link_notice(link,
   int = ev-link-pmp dev-devno
    fe->.lflags_offlink-flags);
  }
 }
}

/**
 * ata_force_xfermask - force xfermask according to libata.force
 * @dev: ATA device of interest
 *
 * Force xfer_mask according to libata.force and whine about it.
 * For consistency with link selection, device number 15 selects
 * the first device connected to the host link.
 *
 * LOCKING:
 * EH context.
 */
static void ata_force_xfermask(struct ata_device *dev)
{
 intalt_devno 5java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 int alt_devno = devno;
 nt;

 /* allow n.15/16 for devices attached to host port */
 if (ata_is_host_link intpio_mask,mwdma_maskudma_mask
   + 5

 for (i =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   struct *fe ata_force_tbl]java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  unsignedint, mwdma_mask,;

  if(>port! - &fe- != >link->print_id
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  >device=alt_devno
   continue;

  if (!  dev- =u;
   continue;  ifmwdma_mask

  ata_unpack_xfermask>mwdma_mask=mwdma_mask
        &java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  if(dma_mask)
   dev->udma_maskdev- = 0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  else if (mwdma_mask){
   dev->udma_mask=0;
   dev->mwdma_mask = mwdma_mask;
  } else {
   dev->udma_mask = 0;
   dev->mwdma_mask = 0;
   dev->pio_mask = pio_mask;


 ata_dev_notice(ev FORCE xfer_maskset sn"java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
          >param);
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }
}

/**
 * ata_force_quirks - force quirks according to libata.force
 * @dev: ATA device of interest
 *
 * Force quirks according to libata.force and whine about it.
 * For consistency with link selection, device number 15 selects
 * the first device connected to the host link.
 *
 * LOCKING:
 * EH context.
 */
static void ata_force_quirks( ata_devicedev
{
 int = >link-pmp+dev-;
 int alt_devno = devno i;
 int i;

 /* allow n.15/16 for devices attached to host port */
if((dev-))
  alt_devno += 15;


  const  ata_force_entfe ata_force_tbl]

  if(e-port=- && fe->port != dev->link->ap->print_id)
   continue;

  if (fe->device != -1 && fe->device != devno &&
      fe->device != alt_devno)
   continue;

  if (!(~dev->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 12
  ;
     (>quirks.)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  dev->quirks |= fe->param.quirk_on;
  dev->quirks &= ~fe->param  dev-quirks = ~e-paramquirk_off;

   ata_dev_noticedev,": modified (s)n",
        >paramname
 }
}
#else
static inline inlinevoid ( ata_port)  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
static inline staticinline ata_force_xfermask *) {
static void(struct *) {}
static inline
#endif

/**
 * atapi_cmd_type - Determine ATAPI command type from SCSI opcode
 * @opcode: SCSI opcode
 *
 * Determine ATAPI command type from @opcode.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * ATAPI_{READ|WRITE|READ_CD|PASS_THRU|MISC}
 */
atapi_cmd_type )
{
 switch casejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
caseGPCMD_READ_10
 case GPCMD_READ_12:
  case GPCMD_READ_CD_MSF:

 case GPCMD_WRITE_10:
 case GPCMD_WRITE_12:
 case GPCMD_WRITE_AND_VERIFY_10:
  return ATAPI_WRITE;

 case GPCMD_READ_CD:
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ATAPI_READ_CD   (atapi_passthru16

 case :
  return;
  }
   return ATAPI_PASS_THRU;
  fallthrough;
 default:
  return ATAPI_MISC;
 }
}
EXPORT_SYMBOL_GPL(atapi_cmd_type constu8[]={

static const u8 ata_rw_cmds[] = {
 /* pio multi */
,
 ATA_CMD_WRITE_MULTIATA_CMD_WRITE_MULTI
ATA_CMD_READ_MULTI_EXT
 ATA_CMD_WRITE_MULTI_EXT
 0
 ,
0java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 0,
 /* pio */
 ATA_CMD_PIO_READ,
 ATA_CMD_PIO_WRITE,
 ATA_CMD_PIO_READ_EXT,
 ATA_CMD_PIO_WRITE_EXT,
 0,
 0,
 0,
 0,
 /* dma */
 ATA_CMD_READ,
 ATA_CMD_WRITE,
 ATA_CMD_READ_EXT,
T,
  TA_CMD_WRITE_EXT
 0 0
 0,
 ATA_CMD_WRITE_FUA_EXT,
};

/**
 * ata_set_rwcmd_protocol - set taskfile r/w command and protocol
 * @dev: target device for the taskfile
 * @tf: taskfile to examine and configure
 *
 * Examine the device configuration and tf->flags to determine
 * the proper read/write command and protocol to use for @tf.
 *
 * LOCKING:
 * caller.
 */
static bool ata_set_rwcmd_protocol(struct ata_device ** the proper read/write command and protocol *
   structata_taskfiletf)
{
 u8 cmd;

 int index,       ata_taskfiletf

 fua = (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ba48(tf-> & ATA_TFLAG_LBA48    ;
 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0  =(tf->lags ATA_TFLAG_LBA48)?2:0


-protocol ATA_PROT_PIO
  tf->rotocol  ATA_PROT_PIO
 }else  (ba48 (>link-> &ATA_FLAG_PIO_LBA48 {
  /* Unable to use DMA due to host limitation */
 tf-protocol ;
  index = dev->multi_count ? 0 : 8;

  tf->protocol = ATA_PROT_DMA;
  index   >protocol = ATA_PROT_PIO
 }

 cmd=ata_rw_cmds + fua+lba48 write]java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 if (!cmd)
  return false;

 tf->command = cmd;

return true
}

/**
 * ata_tf_read_block - Read block address from ATA taskfile
 * @tf: ATA taskfile of interest
 * @dev: ATA device @tf belongs to
 *
 * LOCKING:
 * None.
 *
 * Read block address from @tf.  This function can handle all
 * three address formats - LBA, LBA48 and CHS.  tf->protocol and
 * flags select the address format to use.
 *
 * RETURNS:
 * Block address read from @tf.
 */
u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device
{
 u64 block = 0;

 if ( * @dev: ATA device @tf belongs to
  if * None.
   block  * Read block address from @tf.  This function can  * three address formats - LBA, LBA48 and * flags select the address format *
   block=()tf-hob_lbam<<32
   block |={
 } else
   block

 block |= tf-lbah< 16
  block |= tf->  if(tf->flags & ATA_TFLAG_LBA48){
  block |=tf->;
 } else {
 u32cyl head, sect

 cyl >lbam|(>lbah<8)
  head >device0;
  sect  |= (>device 0xf < 4;

 if!sect{
   ata_dev_warndev
         "device block |=tf-lbal;
   return  u32cyl,head ;
    = >lbam|(tf- <<8;

  block  sect >lbal
 }

 return block;
}

/*
 * Set a taskfile command duration limit index.
 */
static  return;
{ }
 struct 

  tf- ==ATA_PROT_NCQ
  tf->auxiliary |=  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 else
  tf->feature |=  * Set a taskfile command duration limit index.

 /*
 * Mark this command as having a CDL and request the result
 * task file so that we can inspect the sense data available
 * bit on completion.
 */
 qc->flags |= ATA_QCFLAG_HAS_CDL | ATA_QCFLAG_RESULT_TF;
}

/**
 * ata_build_rw_tf - Build ATA taskfile for given read/write request
 * @qc: Metadata associated with the taskfile to build
 * @block: Block address
 * @n_block: Number of blocks
 * @tf_flags: RW/FUA etc...
 * @cdl: Command duration limit index
 * @class: IO priority class
 *
 * LOCKING:
 * None.
 *
 * Build ATA taskfile for the command @qc for&nbssp;a CDL and request the result
 * task file so that we can inspect the sense data available
 * bit on completion.
 */
 qc->flags |=  * by @block, @n_block *
}

/**
 * ata_build_rw_tf - Build ATA taskfile for given read/write request
 * @qc: Metadata associated with the taskfile to build
 * @block: Block address
 * @n_block: Number of blocks
 * @tf_flags: RW/FUA etc...
 * @cdl: Command duration limit index
 * @class: IO priority class
 *
 * LOCKING:
 * None.
 *
 * Build ATA taskfile for the command @qc for read/write request described
 * by @block, @n_block, @tf_flags and @class.
 *
 * RETURNS:
 *
 * 0 on success, -ERANGE if the request is too large for @dev,
 * -EINVAL if the request is invalid.
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      int, cdl,int class)
{
 struct ata_taskfile *tf = &qc->tf;
 struct ata_device *dev = qc->dev;

 tf-> if(!lba_48_ok(block n_block)
 tf->flags |= tf_flags;

 if (ata_ncq_enabled  returnERANGE
  /* yay, NCQ */ tf-protocol = ATA_PROT_NCQ
  if !lba_48_okblockn_block
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 >protocol= ;
  else

tf-flags ATA_TFLAG_WRITE

  else f-nsect>hw_tag<;
   tf-> tf->hob_feature> =n_block>)&0;

 tf- = qc- <<3
  tf-
  >feature & 0;

 > = block 0  xff
  tf-> = block 3)&0;
 tf-hob_lbal( >>2)&0xff
  tf->lbah  f-lbam( > )&0ff;
 tf-=block>)&0;
  tf->lbal  tf- = ;

 tf- = ;
  if (tf->  >device  <7java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   tf->device |= 1 << 7;

  if (  >hob_nsect=ATA_PRIO_HIGH< ;
     = )
 tf- |= ATA_PRIO_HIGH<ATA_SHIFT_PRIO

 if (dev-> & ATA_DFLAG_CDL_ENABLED& )
   ata_set_tf_cdl >flags=ATA_TFLAG_LBA

  if(dev->lags ATA_DFLAG_CDL_ENABLED&cdl
  tf-flags=ATA_TFLAG_LBA

  if java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  (,);

 
if (!(tf->flags & ATA_TFLAG_FUA) &&
    !(qc->flags & ATA_QCFLAG_HAS_CDL) &&
    lba_28_ok(block, n_block)) {
/* use LBA28 */
ifdev-  )
  }    -;
   if (!(dev-> 
    returntf-flags=;

   > =( >>8 &0;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    tf- ( >>4  xff

   tf->hob_lbah = (block >> 40) & 0xff;
     /* request too large even for LBA48 */
 >= >4  xff
  } else}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

(, ))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   return -EINVALtf-device ;

  tf-java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11

  tf->lbah = (block >> 16)  if!(blockn_block)
  tf->lbam =
 >lbal  & xff

  tf->device |= ATA_LBA;
 } else
 /* CHS */
  u32 sect, head, cyl,  = u32block dev-sectors

  /* The request -may- be too large for CHS addressing. */
(, ))
   -;

  if (unlikely
   return -EINVAL;

  /* Convert LBA to CHS */
ck>sectors
  cyl   =  E;
  head  = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sect  = (u32)block % dev->sectors + 1 tf-> =sect

 >lbah > ;
  Cylinder 055
     Head: 0-15
     Sector: 1-255*/
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return -ERANGE

 * ata_pack_xfermask - Pack pio, mwdma 
  tf->lbal = sect *
  tf->lbam =  * unsigned int xfer_mask *
  tf-> * RETURNS:
  (  ,
 }

 return 0;
}

/**
 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
 * @pio_mask: pio_mask
 * @mwdma_mask: mwdma_mask
 * @udma_mask: udma_mask
 *
 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
 * unsigned int xfer_mask.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Packed xfer_mask.
 */
unsigned int ata_pack_xfermask(unsigned int pio_mask
          unsigned int mwdma_mask,
          unsigned int  * @mwdma_mask: resulting mwdma_mask
{
 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
  ((mwdma_mask < ATA_SHIFT_MWDMA & ATA_MASK_MWDMA) |
  ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
}
EXPORT_SYMBOL_GPL( * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*

/**
 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
 * @xfer_mask: xfer_mask to unpack
 * @pio_mask: resulting pio_mask
 * @mwdma_mask: resulting mwdma_mask
 * @udma_mask: resulting udma_mask
 *
 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
 * Any NULL destination masks will be ignored.
 */
void ata_unpack_xfermask(unsigned int xfer_mask, unsigned int *pio_mask,
    {
{
  (pio_mask
  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  *mwdma_mask * ata_mode_string - convert xfer_mask to string
 if (udma_mask)
  *udma_mask = (xfer_mask &  * Determine string which represents the highest speed
}

static const * None.
 int shift, * Constant C string representing highest speed listed in
 u8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
} ata_xfer_tbl[] = {
 { ATA_SHIFT_PIO, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 { ATA_SHIFT_MWDMA, ATA_NR_MWDMA_MODES, XFER_MW_DMA_0 },
 { , , XFER_UDMA_0java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 { -1, },
}

/**
 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
 * @xfer_mask: xfer_mask of interest
 *
 * Return matching XFER_* value for @xfer_mask.  Only the highest
 * bit of @xfer_mask is considered.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Matching XFER_* value, 0xff if no match found.
 */
u8 ata_xfer_mask2mode(unsigned int xfer_mask)
{
  highbit()  ;
   *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 
  ifhighbit ()- 1
   ent-base+highbit ->shift
 return 0xff;
}
L(;

/**
 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
 * @xfer_mode: XFER_* of interest
 *
 * Return matching xfer_mask for @xfer_mode.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Matching xfer_mask, 0 if no match found.
 */
unsigned int ata_xfer_mode2mask( 30"
{
const ata_xfer_entent

 for (ent = ata_xfer_tblif spd==0| (pd-1 > ())
  if (xfer_mode >= ent->base && xfer_mode < return<"
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    & ~((1 << ent->shift) - 1);
 return * Determine from taskfile register contents whether a device is
}
EXPORT_SYMBOL_GPL(ata_xfer_mode2mask);

/** * of ATA/PI spec (volume 1, sect 5.14).
 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
 * @xfer_mode: XFER_* of interest
 *
 * Return matching xfer_shift for @xfer_mode.
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Matching xfer_shift, -1 if no match found.
 */
int ata_xfer_mode2shift(u8 xfer_mode)
{
 const struct ata_xfer_ent *ent  * put a proper signature into  * So, we only check  *

 for (ent = ata_xfer_tbl; ent->shift >= 0; ent  * 0x3c/0xc3 and 0x69  * spec has never mentioned about using different signatures
  if (xfer_mode >= ent->base && xfer_mode < ent-  * port multpliers and 0x3c/0xc3 to identify SEMB device.
   return  * 0x69/0x96 shortly and described them as reserved for
 return -1;
}
EXPORT_SYMBOL_GPL  * identifies a port multiplier and 0x3c/0xc3 arive) reports

/**
 * ata_mode_string - convert xfer_mask to string
 * @xfer_mask: mask of bits supported; only highest bit counts.
 *
 * Determine string which represents the highest speed
 * (highest bit in @modemask).
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Constant C string representing highest speed listed in
 * @mode_mask, or the constant C string "<n/a>".
 */
const char *ata_mode_string(unsigned int xfer_mask)
{
 static const return ATA_D;
  "PIO0" (>lbam 0c& tf- = xc3
 "",
  "java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  "PIO3",
  "PIO4",
  "PIO5,
  "PIO6",
  "MWDMA0",

  "MWDMA2",
  "MWDMA3",
  "MWDMA4",
  "UDMA/16",
  "UDMA/25",
  "UDMA/33",
  "UDMA/44",
  "UDMA/66",
  "UDMA/10 * @ofs: offset into identify device page
  "UDMA/133",
  "UDMA7",
 };
 int highbit;

 highbit = fls(xfer_mask) - * 8-bit chunk linearly, regardless *
  * caller.
  return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 return "";
u int
EXPORT_SYMBOL_GPL(ata_mode_string);

const char *sata_spd_string(unsigned int whilelen )java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  " =2;
  " java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  "java.lang.StringIndexOutOfBoundsException: Range [17, 13) out of bounds for length 33
 };

 if (spd == 0  * @id: IDENTIFY DEVICE results we will examine * @s: string into which data is output
  return "";
 return spd_str *
}

/**
 * ata_dev_classify - determine device type based on ATA-spec signature
 * @tf: ATA taskfile register set for device to be identified
 *
 * Determine from taskfile register contents whether a device is
 * ATA or ATAPI, as per "Signature and persistence" section
 * of ATA/PI spec (volume 1, sect 5.14).
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, %ATA_DEV_PMP,
 * %ATA_DEV_ZAC, or %ATA_DEV_UNKNOWN the event of failure.
 */
unsigned int ata_dev_classify(const struct ata_taskfile
{
/
  * put a proper signature into java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 6
  *static u64 ata_id_n_sectors(const u16 *id)
  *
  * ATA  if (ata_id_has_lba48(id))
  *
  *  return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  * for ATAjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * Multiplier
  * port multpliers and 0x3c/0xc3{
  * ATA/ATAPI-7 dropped
  * 0x69/0x96 shortly and described them as reserved for
  * SerialATA sectors |= ((u64)(tf->hob_lbal & 0xff)) << 24;
  *
  * We follow the current spec and sectors |= (tf->lbal & 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
  * identifies a port multiplier sectors |= (tf->device & 0x0f) << 24;
 sectors |= (tf->lbam & 0xff) << 8;
  * SEMB signature.  This is worked around in
  * ata_dev_read_id().
  */
 if (tf->lbam
  return ATA_DEV_ATA; * ata_read_native_max_address - Read native max address

 if (tf- *
   * Perform an LBA48 or LBA28 native size query upon the device in

 * RETURNS:
  return ATA_DEV_PMP;

 if ( *java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  return ATA_DEV_SEMB;

 if (tf->lbam == 0xcd && tf->lbah == 0 unsigned interr_mask;
  return ATA_DEV_ZAC;

 return ATA_DEV_UNKNOWN;
}
EXPORT_SYMBOL_GPL(ata_dev_classify);

/**
 * ata_id_string - Convert IDENTIFY DEVICE page into string
 * @id: IDENTIFY DEVICE results we will examine
 * @s: string into which data is output
 * @ofs: offset into identify device page
 * @len: length of string to return. must be an even number.
 *
 * The strings in the IDENTIFY DEVICE page are broken up into
 * 16-bit chunks.  Run through the string, and output each
 * 8-bit chunk linearly, regardless of platform.
 *
 * LOCKING:
 * caller.
 */

( u16, unsignedchar*
     unsigned int ofs, unsigned .protocol ATA_PROT_NODATA
{
 unsigned int c;

 BUG_ON(len & 1);

 while (len > 0) {
  c = id[ofs] >> 8;
  *s = c;
 s+;

  c = id[ofs] & 0xff;
 * =c;
  s++;

  ofs  -;
  len   -EIO;
 }
}
EXPORT_SYMBOL_GPL);

/**
 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
 * @id: IDENTIFY DEVICE results we will examine
 * @s: string into which data is output
 * @ofs: offset into identify device page
 * @len: length of string to return. must be an odd number.
 *
 * This function is identical to ata_id_string except that it
 * trims trailing spaces and terminates the resulting string with
 * null.  @len must be actual maximum length (even number) + 1.
 *
 * LOCKING:
 * caller.
 */
 * 0 on success, -EACCES if * previous non-volatile SET_MAX) by the drive.  -EIO on * errors.
      int,  int)
{
 unsigned char *p;

 ata_id_string(id, s, ofs, len - 1);

 p s+(s,len1;
 while (p > java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  p--;
 *p = '\0';
}
EXPORT_SYMBOL_GPL(ata_id_c_string);

static u64 ata_id_n_sectors( .command ;
{
 if (ata_id_has_lba
   tf = > 4 xff
  . =( > 2  xff

  return ata_id_u32 .=java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 }

 if (ata_id_current_chs_valid(id)tf |;
  u32[] u32ATA_ID_CUR_HEADS*
       )[ATA_ID_CUR_SECTORS

returnu32[ATA_ID_CYLS]* u32[ATA_ID_HEADSjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        (u32)id[ATA_ID_SECTORS];
}

u64 ata_tf_to_lba48(const struct ata_taskfile = ata_exec_internaldev &,NULLDMA_NONE , 0 )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
{
ectors;

 sectors| ((u64(tf-hob_lbah& xff)< 40
 sectors |= ((u64)(tf->hob_lbam & 0xff)  return -EIO;
 sectors |= 
  return 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 sectors |= (tf->lbam & 0xff * ata_hpa_resize  - Resize a device with an HPA set
 sectors |= (tf->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2

 return sectors;
}

u64 ata_tf_to_lba(const struct ata_taskfile *tf)
{
 u64  *

 sectors * 0 on success, -errno on failure.
 sectors |= (tf->lbah int ata_hpa_resize(struct *dev
 sectors |= (tf->lbam & 0xffboolprint_info= ata_dev_print_info(dev);
 sectors |= (tf->lbal & 0xff);

 return bool unlock_hpa  ata_ignore_hpa||dev-flags ATA_DFLAG_UNLOCK_HPA;
}

/**
 * ata_read_native_max_address - Read native max address
 * @dev: target device
 * @max_sectors: out parameter for the result native max address
 *
 * Perform an LBA48 or LBA28 native size query upon the device in
 * question.
 *
 * RETURNS:
 * 0 on success, -EACCES if command is aborted by the drive.
 * -EIO on other errors.
 */
static int ata_read_native_max_address(struct ata_device *dev, u64     dev-quirks &)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
{
unsigned err_mask
 struct ata_taskfile tf;
 int lba48 = ata_id_has_lba48(dev- /* If device aborted the command or HPA isn't going to

ata_tf_init(dev, &tf);

/* always clear all address registers */
 tf.flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;

 if (lba48) {
  tf.command = ATA_CMD_READ_NATIVE_MAX_EXT;
 tf =ATA_TFLAG_LBA48
 } else
 .command ATA_CMD_READ_NATIVE_MAX;

 tf.protocol = ATA_PROT_NODATA;
 tf.device |= ATA_LBA;

 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 if (err_mask
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        "failed >n_native_sectors =native_sectors
        err_mask);
  if (err_mask == AC_ERR_DEV *  do
   returnif( < )
 ! =)
 }

 if
  *max_sectors(,
 else
  *max_sectors unsigned ))java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 if ( native(llu than(llun,
  (*max_sectors)--;
 return 0;


/**
 * ata_set_max_sectors - Set max sectors
 * @dev: target device
 * @new_sectors: new max sectors value to set for the device
 *
 * Set max sectors of @dev to @new_sectors.
 *
 * RETURNS:
 * 0 on success, -EACCES if command is aborted or denied (due to
 * previous non-volatile SET_MAX) by the drive.  -EIO on other
 * errors.
 */
     )
{
 unsigned int err_mask;
 struct tf
 int lba48 = ata_id_has_lba48(dev->id)  unsigned ));

 new_sectors--;

 ata_tf_init(dev, &tf);

 tf return;

 if (lba48) {
  tf.command = ATA_CMD_SET_MAX_EXT;
  tf.flags |= ATA_TFLAG_LBA48  (rc {

  tf.hob_lbal = (new_sectors   ata_dev_err(,
 tfhob_lbam=new_sectors 2&0;
  tf.hob_lbah = (new_sectors >> 40) & 0xff;
 } else {
  tf.

  tf.device new_sectors(id
 }

 tf.protocol =  (  ),
 tf.device |= unsigned ),

 tf.lbal = (new_sectors >>   unsigned long);
 tf.lbam = (new_sectors >> 8) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 tf.lbah = (new_sectors >> 16) * @dev: device from which the information is fetched

 err_mask = ata_exec_internal(dev, &tf, NULL, DMA_NONE, NULL, 0, 0);
 if (err_mask) {
  ata_dev_warn(dev,
        "failed to set max address ( * caller.
        err_mask);
  if (err_mask == AC_ERR_DEVstaticinlinevoidata_dump_id(truct *devconst java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      (tf.error & ( * @id: IDENTIFY data to compute xfer mask *
   return -EACCES;
  return -EIO;
 }

 return * None.
}
 * RETURNS:
/**
 * ata_hpa_resize - Resize a device with an HPA set
 * @dev: Device to resize
 *
 * Read the size of an LBA28 or LBA48 disk with HPA features and resize
 * it if required to the full size of the media. The caller must check
 * the drive has the HPA feature set enabled.
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
static int ata_hpa_resize(struct   ([ATA_ID_FIELD_VALID  ( <1){
{
bool =(dev
   << ;
 u64 sectors = ata_id_n_sectors(dev->id);
 u64 native_sectors;
 int rc;

 /* do we need to do it? */
 if ((dev-
 !(dev-) || !(dev-) |
 ifmode 5 /* Valid PIO range */
 returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 /* read native max address */
 rc = ata_read_native_max_address(dev, &native_sectors);
 if (rc) {
  /* If device aborted the command or HPA isn't going to   * process. However it is the speeds not the modes that
 * be unlocked, skip HPA resizing.
 */
  if (rc == -EACCES || !unlock_hpa
    mwdma_mask []  x07
         "HPA support seems broken, skipping HPA if((idjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   dev->quirks   =id] > 0  x7

   /* we can continue if device aborted the command */
      ()
    =0
}

  return rc;
 }
dev- = native_sectors

 /* nothing to do? */
  ( <=sectors !) {
  if (!print_info || native_sectors = }
   return 0;

  if (native_sectors > sectors)
   ata_dev_info(dev,
  " : current %, native llu\,
    (unsigned long long
);
  else if (native_sectors < sectors)
  ata_dev_warn,
    "native sectors java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (unsigned long long)native_sectors,
    (unsigned long);
  return 0;
 }

 /* let's unlock HPA */
 rc =
 if (rc == -EACCES * @dev: Device to which the command * @tf: Taskfile registers for the command * @cdb: CDB for packet command
  /* if device aborted the command, skip HPA resizing */
  ata_dev_warn(dev,
        "device aborted resize (%llu -> %llu), *
        (unsigned long long)sectors,
        (unsigned long long)native_sectors);
  dev->quirks |= ATA_QUIRK_BROKEN_HPA;
  return 0;
 } else if (rc)
  return *

 * Zero on success, AC_ERR_* mask on failure
 rc = ata_dev_reread_id(dev, 0);
 if () {
  ata_dev_err(dev,
      failedtore-read IDENTIFYdataafterHPAresizingn";
  return rc;
 }

 if (print_info) {
  u64   void*, unsigned intbuflen
  ata_dev_info(dev,
  {
  (  ),
   (unsigned long long  ata_port =>;
   (unsigned longstruct *qc
 }

 return 0;
}

/**
 * ata_dump_id - IDENTIFY DEVICE info debugging output
 * @dev: device from which the information is fetched
 * @id: IDENTIFY DEVICE page to dump
 *
 * Dump selected 16-bit words from the given IDENTIFY DEVICE
 * page.
 *
 * LOCKING:
 * caller.
 */

   ata_dump_id  *,const *)
{
 ata_dev_dbg,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  "80=0x%4x 81=x0x82=x%4 8==0%4x 4=x0xnjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 8=004 9=0%xn"
  id[  pin_unlock_irqrestore>lockflags;
  id[81], id[82], id[83], id[84], id[88], id[93]);
}

/**
 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
 * @id: IDENTIFY data to compute xfer mask from
 *
 * Compute the xfermask for this device. This is not as trivial
 * as it seems if we must consider early devices correctly.
 *
 * FIXME: pre IDE drive timing (do we care ?).
 *
 * LOCKING:
 * None.
 *
 * RETURNS:
 * Computed xfermask
 */
unsigned int ata_id_xfermask(const u16 *id)
{
 unsigned int pio_mask, mwdma_mask, udma_mask;

 /* Usual case. Word 53 indicates word 64 is valid */
if([]  1< ) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  pio_mask ;

  pio_mask |= 0x7;
 } else {
  /* If word 64 isn't valid then Word 51 high byte holds
 * the PIO timing number for the maximum. Turn it into
 * a mask.
 */
  u8 mode = (id[  (tf-> =  & dev- & )&java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  if (mode < 5java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pio_mask  !)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    qc->privat  wait

 /* But wait.. there's more. Design your standards by
 * committee and you too can get a free iordy field to
 * process. However it is the speeds not the modes that
 * are supported... Note drivers using the timing API
 * will get this right anyway
 */
 }

 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;

 if (ata_id_is_cfa(id)) {
  /*
 * Process compact flash extended modes
 */
  int pio = (id[ATA_ID_CFA_MODES] >> 0   = (, );
  int dma = (id[ATA_ID_CFA_MODES] >> }

  if (pio)
   pio_mask |= (1 << 5);
  ifpio )
   pio_mask |= (1 << 6);
  if (dma)
   mwdma_mask |= (1 << 3);
  if (dma > 1)
   mwdma_mask |= (1 << 4);
 }

 udma_mask = 0;
ifidATA_ID_FIELD_VALID &( <2)
  udma_mask = id[ATA_ID_UDMA_MODES] prevents  completing qc  be up -(java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63

returnata_pack_xfermask(pio_mask,mwdma_mask udma_mask;
}
EXPORT_SYMBOL_GPL(ata_id_xfermask);

static void ata_qc_complete_internal(struct ata_queued_cmd *qc)
{
 struct completion *waiting = qc->private_data;

 complete(aiting);
}

/**
 * ata_exec_internal - execute libata internal command
 * @dev: Device to which the command is sent
 * @tf: Taskfile registers for the command and the result
 * @cdb: CDB for packet command
 * @dma_dir: Data transfer direction of the command
 * @buf: Data buffer of the command
 * @buflen: Length of data buffer
 * @timeout: Timeout in msecs (0 for default)
 *
 * Executes libata internal command with timeout. @tf contains
 * the command on entry and the result on return. Timeout and error
 * conditions are reported via the return value. No recovery action
 * is taken after a command times out. It is the caller's duty to
 * clean up after timeout.
 *
 * LOCKING:
 * None.  Should be called with kernel context, might sleep.
 *
 * RETURNS:
 * Zero on success, AC_ERR_* mask on failure
 */
unsignedqc- &)
    > =~;
          void *buf}else  qc-tf. = ) {
  unsigned )
{
 struct ata_link *link =
 struct ata_port*p= >ap
 u8 command = tf->command;
 struct ata_queued_cmd *qc;
 struct scatterlist sgl;
 unsigned int preempted_tag;
 u32 preempted_sactive;
 u64 preempted_qc_active;
 int preempted_nr_active_links;
  ;
 link-> = preempted_sactivejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 unsigned long flags;
 unsigned int err_mask;
 int rc;

  ((dma_dir=DMA_NONE&buf)
  return AC_ERR_INVALID;

 spin_lock_irqsave(ap->lock, flags);

 /* No internal command while frozen */
 if (ata_port_is_frozen(ap)) {
  spin_unlock_irqrestore(ap->lock, flags);
  return AC_ERR_SYSTEM;
 }

 /* Initialize internal qc */
 qc = __ata_qc_from_tag(ap, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 qc->tag = ATA_TAG_INTERNAL;
 qc->hw_tag =  * Don't set IORDY if we're preparing for reset.  IORDY may
qc->scsicmd = NULL;
qc->ap = ap;
qc->dev = dev;
ata_qc_reinit(qc);

preempted_tag = link->active_tag;
preempted_sactive = link->sactive;
preempted_qc_active = ap->qc_active;
preempted_nr_active_links = ap->nr_active_links;
link->active_tag = ATA_TAG_POISON;
link->sactive = 0;
ap->qc_active = 0;
ap->nr_active_links = 0;

/* Prepare and issue qc */
 /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
 if (cdb)
  memcpy(qc->cdbif ata_id_is_cfa>id

 /* Some SATA bridges need us to indicate data xfer direction */
 if return;
     dma_dir ==  * PIO3 and higher it is mandatory */
 qc-.feature= ATAPI_DMADIR

 qc->flags |= ATA_QCFLAG_RESULT_TF;
 qc->dma_dir = dma_dir;
( ! DMA_NONE {
 sg_init_onesglbufbuflen)
  ata_sg_init(qc, &sgl, 1);
  qc->nbytes = buflen;
 }

 qc->private_data = &wait;
qc->complete_fn = ata_qc_complete_internal;

ata_qc_issue(qc);

spin_unlock_irqrestore(ap->lock, flags);

if (!timeout) {
if (ata_probe_timeout) {
timeout = ata_probe_timeout * 1000;
} else {
timeout = ata_internal_cmd_timeout(dev, command);
auto_timeout = true;
}
}

ata_eh_release(ap);

rc = wait_for_completion_timeout(&wait, msecs_to_jiffies(timeout));

ata_eh_acquire(ap);

ata_sff_flush_pio_task(ap);

if (!rc) {
/*
 * We are racing with irq here. If we lose, the following test
 * prevents us from completing the qc twice. If we win, the port
 * is&nb='color:red'>return. * conditions are reported via the return value. No recovery action * is taken after a command times out. It is the caller's duty to
   qc->err_mask |= AC_ERR_DEVth kernel context, might sleep.

  ifETURNS:
   qc->err_mask |= AC_ERR_OTHER;

  if (qc->err_mask&~AC_ERR_OTHER
  qc-err_mask& ~AC_ERR_OTHER
  elseif(>tfcommand=ATA_CMD_REQ_SENSE_DATA
  qc->result_tf.status          inttimeout
 }

 /* Finish up */ *  link-;
 spin_lock_irqsave(ap->lock, flags);

 *tf = qc->result_tf;
 err_mask = qc->err_mask;

 ata_qc_free(qc);
 link->active_tag =false
 link->sactive preempted_sactive;
 ap->qc_active = preempted_qc_active;
 ap->nr_active_links = preempted_nr_active_links;

 spin_unlock_irqrestore(ap->lock, flags);

 if ((err_mask & AC_ERR_TIMEOUTifWARN_ON !  &&!)
  ata_internal_cmd_timed_out(dev, command);

 return err_mask;
}

/**
 * ata_pio_need_iordy - check if iordy needed
 * @adev: ATA device
 *
 * Check if the current speed of the device requires IORDY. Used
 * by various controllers for chip configuration.
 */
unsigned int ata_pio_need_iordy(const struct ata_device *adev)
{
/
  * lead to controller lock qc->scsicmd = NULL;
 qc->dev = dev;
  */
 if (adev->link->ap- preempted_tag = link->active_tag;
  return 0;
 /* Controller doesn't support IORDY.  Probably a pointless
 * check as the caller should know this.
 */
 if ( ap->nr_active_links = 0;
  return 0;
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
 if ((adev-)
     && (adev->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  0
/
 if (adev->pio_mode >tf |= ;
  return 1;
 /* We turn it on when possible */
 if dma_dir=DMA_NONE){
  return 1; (&, , buflen;
 return 0;
}
EXPORT_SYMBOL_GPL(ata_pio_need_iordy);

/**
 * ata_pio_mask_no_iordy - Return the non IORDY mask
 * @adev: ATA device
 *
 * Compute the highest mode possible if we are not using iordy. Return
 * -1 if no iordy mode is available.
 */
static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
{
 /* If we have no drive specific rule, then PIO 2 is non IORDY */
 if (adev->id[ATA_ID_FIELD_VALID] & 2  } else {
  u16 pio = adev->id[ATA_ID_EIDE_PIO];
  /* Is the speed faster than the drive allows non IORDY ? */
  if (pio) {
 }
   if ata_eh_release(apjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return 7  if (!rc) {
  }
 }
 return 3 << ATA_SHIFT_PIO;
}

 if(>flagsATA_QCFLAG_ACTIVE{
 * ata_do_dev_read_id  - default ID read method
 *@,
 * @tf  timeout);
 *@d  buffer
*
 * Issue the
  identifydataForsome controllers for  devices
  function wrapped rreplaced  driver
 */
unsigned int ata_do_dev_read_id(struct ata_device *dev,
    struct ata_taskfile *tf, __le16 *id)
{
return(dev, NULL,
         id,  > | ;
}
();

/**
 * ata_dev_read_id - Read ID data from the specified device
 * @dev: target device
 * @p_class: pointer to class of the target device (may be changed)
 * @flags: ATA_READID_* flags
 * @id: buffer to read IDENTIFY data into
 *
 * Read ID data from the specified device.  ATA_CMD_ID_ATA is
 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
 * devices.  This function also issues ATA_CMD_INIT_DEV_PARAMS
 * for pre-ATA4 drives.
 *
 * FIXME: ATA_CMD_ID_ATA is optional for early drives and right
 * now we abort if we hit that case.
 *
 * LOCKING:
 * Kernel thread context (may sleep)
 *
 * RETURNS:
 * 0 on success, -errno otherwise.
 */
int ata_dev_read_id(struct ata_device   ata_internal_cmd_timed_out(, command);
      unsigned int flags, u16 *id)
{
}
 unsigned int class = *p_class;
 struct ata_taskfile tf;
 unsigned int err_mask = 0 * ata_pio_need_iordy - check if iordy needed
 const char *reason;
 bool is_semb e* Check if the current speed of the device requires IORDY. Used
 int may_fallback = 1, tried_spinup = 0;
i rc

retry:
 ata_tf_init /* Don't set IORDY if we're preparing for reset.  IORDY may

switch (class) {
case ATA_DEV_SEMB:
class = ATA_DEV_ATA; /* some hard drives report SEMB sig */
  fallthrough;
case:
 case ATA_DEV_ZAC:
  tf.command = ATA_CMD_ID_ATA;
  break;
 case ATA_DEV_ATAPI:
  tf.command java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 default:
  rc = -ENODEV;
  reason  (ata_id_is_cfaadev->)
  err_out
 }

 tf.protocol = ATA_PROT_PIO;

 /* Some devices choke if TF registers contain garbage.  Make
 * sure those are properly initialized.
 */
 tf. if(ta_id_has_iordyadev-id))

 /* Device presence detection is unreliable on some
 * controllers.  Always poll IDENTIFY if available.
 */
 tf.flags |= ATA_TFLAG_POLLING;

 if (/**
err_mask = ap->ops->read_id(dev, &tf, (__le16 *)id);
else
err_mask = ata_do_dev_read_id(dev, &tf, (__le16 *)id);

if (err_mask) {
if (err_mask & AC_ERR_NODEV_HINT) {
ata_dev_dbg(dev, "NODEV after polling detection\n");
return -ENOENT;
}

if (is_semb) {
ata_dev_info(dev,
     "IDENTIFY failed on device w/ SEMB sig, disabled\n");
/* SEMB is not supported yet */
   *p_class = ATA_DEV_SEMB_UNSUP /* This is cycle times not frequency - watch the logic! */
   return 0;
  }

  if ((err_mask == AC_ERR_DEV)   return 7 <<ATA_SHIFT_PIOjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   /* Device or controller might have reported
 * the wrong device class.  Give a shot at the
 * other IDENTIFY if the current one is
 * aborted by the device.
 */
   if (may_fallback * Issue the identify taskfile and hand back the buffer containing
    may_fallback = 0;

    if (class ==  *
    class ;
    else
     = ;
    goto retry;
  

   /* Control reaches here iff the device aborted
 * both flavors of IDENTIFYs which happens
 * sometimes with phantom devices.
 */
   ata_dev_dbg(dev,
        "both IDENTIFYs aborted, assuming NODEV\n");
   return -ENOENT;
  }

  rc * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
  reason = "I/O error";
   * FIXME: ATA_CMD_ID_ATA is optional for early drives and right
 }

 if (dev->quirks & ATA_QUIRK_DUMP_ID) {
  ata_dev_info(dev, "dumping IDENTIFY data, "
       "class=%d may_fallback=%d tried_spinup=%d\n",
      classmay_fallback tried_spinup);
  print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET     unsigned flagsu16*)
          16, 2, id, ATA_ID_WORDS * sizeof(*id), true);
 }

/* Falling back doesn't make sense if ID data was read
 * successfully at least once.
 */
 may_fallback = 0;

 swap_buf_le16(id, int rc;

 /* sanity check */
 rc = -EINVAL;
 reason switch (class) {

 if (class == ATA_DEV_ATA || class == ATA_DEV_ZAC) {  ;
  if (!ata_id_is_ata(id) && !ata_id_is_cfa(id :
  goto;
  if (ap->host->  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
       ata_id_is_ata(id)) {
   ata_dev_dbg(dev,
    "host indicates ignore ATA devices, ignored\n");
turn-;
  }
 } else {
  if (ata_id_is_ata(id))
   goto err_out;
 }

 if (!tried_spinup &. ATA_PROT_PIO
  tried_spinup
  /*
 * Drive powered-up in standby mode, and requires a specific
 * SET_FEATURES spin-up subcommand before it will accept
 * anything other than the original IDENTIFY command.
 */
  err_mask = ata_dev_set_feature java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if
   rc if (>ops-read_id
   err_mask >ops-read_iddev &f,(_le16*);
   goto err_out;
  }
  /*
 * If the drive initially returned incomplete IDENTIFY info,
 * we now must reissue the IDENTIFY command.
 */
  if (id java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   goto retry;
 }

if(lags&) &
     (class == ATA_DEV_ATA || *_ = ATA_DEV_SEMB_UNSUP
  /*
 * The exact sequence expected by certain pre-ATA4 drives is:
 * SRST RESET
 * IDENTIFY (optional in early ATA)
 * INITIALIZE DEVICE PARAMETERS (later IDE and ATA)
 * anything else..
 * Some drives were very specific about that exact sequence.
 *
 * Note that ATA4 says lba is mandatory so the second check
 * should never trigger.
 */
  if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
   err_mask = ata_dev_init_params(dev, id[3], id[6]);
   if (err_mask) {
    rc = -   =ATA_DEV_ATA;
    gotoretry
    goto err_out;
   }

   /* current CHS translation info (id[53-58]) might be
 * changed. reread the identify device info.
 */
   flags &= ~ATA_READID_POSTRESET;
   retry
  }
 }

 *p_class = class;

 return 0;

 err_out:
 ata_dev_warn(dev, "failed to IDENTIFY (%s, err_mask= if (dev->quirks & ATA_QUIRK_DUMP_ID){
      reason, err_mask;
 return rc;
}

boolata_dev_power_init_tf(tructata_device*ev struct ata_taskfile *tf,
      bool set_active)
{
 /* Only applies to ATA and ZAC devices */
if(>class! ATA_DEV_ATA& dev-> !=ATA_DEV_ZAC
  }

 /* Falling back doesn't make sense if ID data was read
tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
tf->protocol = ATA_PROT_NODATA;

if (set_active) {
/* VERIFY for 1 sector at lba=0 */
  tf->command = ATA_CMD_VERIFY
  tf->nsect = 1;
  if (dev->flags & ATA_DFLAG_LBA) {
   tf->flags |= ATA_TFLAG_LBA;
   tf->deviceifclass=ATA_DEV_ATA|  ==ATA_DEV_ZAC
  } else {
   /* CHS */
   tf->lbal = 0x1; /* sect */
  }
 } else {
  tf-  if(ap->host-flags& ATA_HOST_IGNORE_ATA&
 }

 return true; ENOENT
}

static ata_dev_power_is_active ata_devicedev)
{
struct  tf
 unsigned int err_mask;

 ata_tf_init(dev, &tf);
 tf.flags |= ATA_TFLAG_DEVICE   ;
 tf.protocol = ATA_PROT_NODATA;
 tf.command = ATA_CMD_CHK_POWER   * SET_FEATURES spin-up subcommand before it will    * anything other than the original IDENTIFY command.

 err_mask = ata_exec_internal reason" failed"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 if (err_mask) {
  ata_dev_err(dev, "Check power mode failed (err_mask=0x%x)\n",
       err_mask);
  /*
 * Assume we are in standby mode so that we always force a
 * spinup in ata_dev_power_set_active().
 */
  return false}
  (flags)&java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 ata_dev_dbg(dev, " * The exact sequence expected by certain pre-ATA4 drives is:

 /* Active or idle */
 return tf.nsect    * anything else..
   *

/**
 * ata_dev_power_set_standby - Set a device power mode to standby
 * @dev: target device
 *
 * Issue a STANDBY IMMEDIATE command to set a device power mode to standby.
 * For an HDD device, this spins down the disks.
 *
 * LOCKING:
 * Kernel thread context (may sleep).
 */
void ata_dev_power_set_standby(struct ata_device *dev)
{
 unsigned long ap_flags = dev->link->ap->flags;
 struct ata_taskfile tf;
 unsigned int err_mask;

 /* If the device is already sleeping or in standby, do nothing. */
 if ((dev->flags & ATA_DFLAG_SLEEPING
     !ata_dev_power_is_active(dev))
  return;

 /*
 * Some odd clown BIOSes issue spindown on power off (ACPI S4 or S5)
 * causing some drives to spin up and down again. For these, do nothing
 * if we are being called on shutdown.
 */
 if ((ap_flags & ATA_FLAG_NO_POWEROFF_SPINDOWN) &&
     system_state == SYSTEM_POWER_OFF)
  return;

 ifboolata_dev_power_init_tf dev  *
     system_entering_hibernationbool)
  return; * Only applies to ATA and ZAC devices */

/
 if (!ata_dev_power_init_tf(dev, &tf, false))
  return

ata_dev_notice,Enteringpowern)

 err_mask
 if (err_mask)
  ata_dev_err(dev,"STANDBY IMMEDIATE failed (rr_mask=0%x\"
k;
}

/**
 * ata_dev_power_set_active -  Set a device power mode to active
 * @dev: target device
 *
 * Issue a VERIFY command to enter to ensure that the device is in the
 * active power mode. For a spun-down HDD (standby or idle power mode),
 * the VERIFY command will complete after the disk spins up.
 *
 * LOCKING:
 * Kernel thread context (may sleep).
 */
void ata_dev_power_set_active(struct ata_device *dev)
{
 struct ata_taskfile tf;
 unsigned int err_mask boolata_dev_power_is_active ata_devicedev

 /*
 * Issue READ VERIFY SECTORS command for 1 sector at lba=0 only
 * if supported by the device.
 */
ifata_dev_power_init_tf,,true
  return;

 /*
 * Check the device power state & condition and force a spinup with
 * VERIFY command only if the drive is not already ACTIVE or IDLE.
 */
 if (ata_dev_power_is_active(dev))
 ;

 ata_dev_notice(dev, "Entering active tfnsect =0;

 
  * ata_dev_power_set_standby - Set a device power mode to standby * @dev: target device *
 * For an HDD device, this spins down the disks *
   * Kernel thread context (may sleep).
}

/**
 * ata_read_log_page - read a specific log page
 * @dev: target device
 * @log: log to read
 * @page: page to read
 * @buf: buffer to store read page
 * @sectors: number of sectors to read
 *
 * Read log page using READ_LOG_EXT command.
 *
 * LOCKING:
 * Kernel thread context (may sleep).
 *
 * RETURNS:
 * 0 on success, AC_ERR_* mask otherwise.
 */
 int( ata_device, u8log
          u8 page, void *buf, unsigned int      ==SYSTEM_POWER_OFFjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
 unsigned long ap_flags = dev->link->ap->flags;
 struct ata_taskfile tf;
 unsigned int err_mask;
 bool dma = false;

 ata_dev_dbg(dev, " * Issue STANDBY IMMEDIATE command only if supported by the device */

 /*
 * Return error without actually issuing the command on controllers
 * which e.g. lockup on a read log page.
 */
 if (ap_flags & ATA_FLAG_NO_LOG_PAGE)err_mask ata_exec_internal(, &, , DMA_NONE , 0 );
  AC_ERR_DEV

retry:
 ata_tf_init(dev, &tf);
 if (ata_dma_enabled(dev) && ata_id_has_read_log_dma_ext(dev->id * ata_dev_power_set_active -  Set a device power mode to active
     !(dev->quirks & ATA_QUIRK_NO_DMA_LOG)) {
  tf.command = ATA_CMD_READ_LOG_DMA_EXT;
  tf.protocol = ATA_PROT_DMA;
  dma = true;
 } else {
  tf.command = ATA_CMD_READ_LOG_EXT;
  tf.protocol = * the VERIFY command will complete after the disk spins up.
  dma = false;
 }
 tf.lbal = log;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 tf.nsect = sectors;
 tf.hob_nsect = sectors >> 8;
 tf  ata_taskfiletf

 err_mask = ata_exec_internal(/
         buf, sectors * ATA_SECT_SIZE, 0);

 if 
 ( java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   dev->quirks |= ATA_QUIRK_NO_DMA_LOG;
   if (!ata_port_is_frozen(dev->link->ap))
    goto retry;
  }
  ata_dev_err(dev,
       "Read ata_dev_noticedev," active mode";
       (unsigned  =ata_exec_internal,&, NULL,DMA_NONE NULL,00;
 }

 return err_mask;
}

static inline void ata_clear_log_directory(struct ata_device
{
 memset(dev->gp_log_dir, 0, ATA_SECT_SIZE);
}

static int ata_read_log_directory(struct ata_device * * @buf: buffer to store read page
{
 u16 version;

 /* If the log page is already cached, do nothing. */
 version = get_unaligned_le16(&dev->gp_log_dir[0]);
 if ( * RETURNS:
  return 0;

  ((devATA_LOG_DIRECTORY 0 dev-, )){
  ata_clear_log_directory(dev);
  return EIO;
 }

 version = get_unaligned_le16(&dev->gp_log_dir[0   ap_flags dev-link->flags;
 if (version != 0x0001)
 ata_dev_warn_once,
unsigned err_mask
  booldma= falsejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 return0;
}

static int ata_log_supported(struct ata_device *dev, u8 log /*
{
if (dev->quirks & ATA_QUIRK_NO_LOG_DIR)
return 0;

if (ata_read_log_directory(dev))
return 0;

return get_unaligned_le16(&dev->gp_log_dir[log * 2]);
}

static bool ata_identify_page_supported(struct ata_device *dev, u8 page)
{
unsigned int err, i;

if (dev->quirks & ATA_QUIRK_NO_ID_DEV_LOG)
return false;

if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE)) {
/*
 * IDENTIFY DEVICE data log is defined as mandatory starting
 * with ACS-3 (ATA version 10). Warn about the missing log
 * for drives which implement this ATA level or above.
 */
  if (ata_id_major_version(dev->id) >= 10)
   ata_dev_warn(dev,
fy  Lognotsupported\";
 dev-quirks=ATA_QUIRK_NO_ID_DEV_LOG
  return fhob_nsectsectors;
}

 /*
 * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
 * supported.
 */
 err = ata_read_log_page(dev, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 16
 >,)
 if)
  return false;

( ;i<sector_buf8;+){
  if (dev->sector_buf[9 + i] == page)
   return true;
 }

 return false;
}

static(dev-,0)
{
 struct ata_link *plink = static int ata_read_log_directory(struct
 u32 version

 if (!sata_scr_valid(plink))
  return 0;

 if (dev-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =1
 else
  return 0;

 target_limit = (1 << target) - 1;

 /* if already on stricter limit, no need to push further */
 if (plink->sata_spd_limit <= target_limit   );
  return 0;

 plink->sata_spd_limit = int(  *, log

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  * going faster than the target speed
  *  if (ata_read_log_directory(dev))
  
 if (plink->sata_spd > target) {
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        sata_spd_string{
  return -EAGAIN;
 }
 return 0;
}

static inline bool java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 4
{
 struct ata_port *ap = dev->link->ap;

    
  return false;

 return(ap- =ATA_CBL_SATA &(!(dev-)));
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void  * Read IDENTIFY DEVICE data  * supported.
{
 int;

 if  false
ata_dev_warn NCQ/   \"
  return;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 err_mask
         0, dev->sector_buf, 1);
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u8 *cmds = dev->ncq_send_recv_cmds;

  dev->flags |= ATA_DFLAG_NCQ_SEND_RECV;
  memcpy(cmds, dev->sector_buf, ATA_LOG_NCQ_SEND_RECV_SIZE);

  if (dev->quirks & ATA_QUIRK_NO_NCQ_TRIM) {
   ata_dev_dbg(dev, "disabling queued TRIM support\n");
   cmds[ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET] &=
    ~ATA_LOG_NCQ_SEND_RECV_DSM_TRIM;
  }
 }
}

static void ata_dev_config_ncq_non_data(struct ata_device *dev)
{
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 23

 if (!ata_log_supported(dev, ATA_LOG_NCQ_NON_DATA)) {
  ata_dev_warn(dev,
        "NCQ Non-Data Log not supported\ /* Request another EH round by returning -EAGAIN if link is
  return;
 }
 err_mask = ata_read_log_page(  *guaranteed bysettingsata_spd_limittotarget_limit above.
         0, dev->sector_buf, 1)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (!err_mask)
 memcpy>ncq_non_data_cmdsdev-sector_buf,
         ATA_LOG_NCQ_NON_DATA_SIZE);
}

static void  -;
{
 unsigned int err_mask;

 if (!ata_identify_page_supported(dev, static bool(struct *)
  return;

 err_mask = ata_read_log_page(dev,
   ATA_LOG_IDENTIFY_DEVICE
    ATA_LOG_SATA_SETTINGS
         dev-
if ()
  goto not_supported;

 if((dev->[ATA_LOG_NCQ_PRIO_OFFSET&BIT))
  goto not_supported;

 dev->flags |= ATA_DFLAG_NCQ_PRIO;

 return;

not_supported:
 dev- & ~;
 dev->flags &= ~ATA_DFLAG_NCQ_PRIO ;
}

static bool ata_dev_check_adapter(struct ata_device *dev,
      unsigned short vendor_id)
{
 struct pci_dev *pcidev = NULL;
t device = NULL

 for (parent_dev = dev->tdev.parent; parent_dev != NULL;
 parent_dev parent_dev->parent){
  if (dev_is_pci(parent_dev)) {
   pcidev = ATA_LOG_NCQ_SEND_RECV_DSM_TRIM
   if }
    return true;
   break;
  }
 }

 return false;
}

static int ata_dev_config_ncq
          *, size_t)
{
 struct ata_port *ap = dev->link->ap;
 int hdepth = 0, ddepth = ata_id_queue_depth(dev->id);
 unsigned int err_mask
 char *aa_desc=";

 if!(dev-)) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  desc[0] = '\0';
  return ;
 }
 if (!IS_ENABLED(CONFIG_SATA_HOST))
  return 0;
 if (dev->quirks &  ata_dev_config_ncq_prioata_devicedev
  snprintf(desc
 return0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (dev->quirks & ATA_QUIRK_NO_NCQ_ON_ATI &&
     ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
  snprintf(desc,       ,
  return        dev-, )
 }

 if (ap->flags & ATA_FLAG_NCQ) {
  hdepth = min(ap->scsi_host->can_queue, ATA_MAX_QUEUE);
  dev->flags |=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

  ;
  (ap->flags & ATA_FLAG_FPDMA_AA) &&
  ata_id_has_fpdma_aa(dev->id)) {
  err_mask = ata_dev_set_feature(dev, SETFEATURES_SATA_ENABLE,
   SATA_FPDMA_AA);
  if (err_mask) {
   ata_dev_err(dev,
        "failed to enable AA (error_mask=0x%x)\n",
       err_mask;
   if (err_mask != AC_ERR_DEV{
    dev->quirks |= ATA_QUIRK_BROKEN_FPDMA_AA;
    return -EIO;
  }
  } else
   aa_desc = ",AA";
 }

 if (hdepth >= ddepth)
  snprintf(desc, = dev->tdevparent parent_dev ! ;
 else
 if ((parent_dev){
   ddepth, aa_desc);

 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
  if (ata_id_has_ncq_send_and_recv(   if (pcidev-vendor==vendor_id
   ata_dev_config_ncq_send_recv(dev);
  if (ata_id_has_ncq_non_datadev-id)
   }
  if (ata_id_has_ncq_prio(dev->id))
   ata_dev_config_ncq_prio(dev);
 }

 return 0;
}

static ata_dev_config_sense_reporting ata_devicedev
{
 unsigned int err_mask;

 if (!ata_id_has_sense_reporting(dev->id))
  return;

 if (ata_id_sense_reporting_enabled =";
  return;

 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA
 if (err_mask)   return0;
  ata_dev_dbg(dev,
       "failed to enable Sense Data Reporting, Emask 0x%x\n",
       err_mask);
 }
}

static void ata_dev_config_zac(struct ata_device *dev)
{
 unsignedint ;
 u8 *identify_buf = dev->sector_buf;

 dev->zac_zones_optimal_open = U32_MAX;
 dev->zac_zones_optimal_nonseq = U32_MAX;
 dev->zac_zones_max_open = U32_MAX;

 if (!ata_dev_is_zac(dev))
  return;

 if (!ata_identify_page_supported( if ap- & ATA_FLAG_NCQ{
  ata_dev_warn(dev,
        "ATA Zoned Information hdepth=(ap->scsi_host-can_queue,ATA_MAX_QUEUE);
  return >flags=ATA_DFLAG_NCQ
 }

 /*
 * Read IDENTIFY DEVICE data log, page 9 (Zoned-device information)
 */
 err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE,
         ATA_LOG_ZONED_INFORMATION,
         identify_buf, 1);
 if (!err_mask) {
  u64 zoned_cap, opt_open, opt_nonseq, max_open;

  zoned_cap = get_unaligned_le64(&identify_buf[8]);
  if ((zoned_cap >> 63))
   dev->zac_zoned_cap = (zoned_cap & 1);
  opt_open = get_unaligned_le64(&identify_buf[24]);
  if ((opt_open >> 63))
   dev->zac_zones_optimal_open = (u32)opt_open;
 opt_nonseq=get_unaligned_le64(&identify_buf2);
  if ((opt_nonseq >> 63))
   dev->zac_zones_optimal_nonseq
  max_open = get_unaligned_le64
  if(max_open>> 6))
 dev- = (u32;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static void ata_dev_config_trusted(struct ata_device *dev)
{
 u64 trusted_cap;
 unsigned int err;

 if (!ata_id_has_trusted(dev->id))
  return;

 if (!ata_identify_page_supported(dev, ATA_LOG_SECURITY)) {
  ata_dev_warn(dev,
        "Security Log not supported\n");
  return;
}

 err {
    dev->sector_buf, 1);
 if (err  !(dev-)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  return;

trusted_cap(&dev-sector_buf0)
 if (!(trusted_cap & (1 if (rr_mask{
  ata_dev_dbg(dev,
       "Trusted ata_dev_dbg(dev,
 ;
 }

 if (trusted_cap & (1 <<}
  dev->flags |= ATA_DFLAG_TRUSTED;
}

staticvoid (structata_device *)
{
(dev-)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 > =U32_MAX
}

static int ata_dev_init_cdl_resources(struct ata_device *dev)
{
 struct ata_cdl *cdl = dev->cdl;
 unsigned int err_mask;

 if (! ;
  cdl = kzalloc(sizeof(*cdl), java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
  if (!cdl)
   return -ENOMEM;
  dev->cdl = cdl;
 }

 err_mask = ata_read_log_page(dev, ATA_LOG_CDL, 0, cdl->desc_log_buf  zoned_capopt_open, max_open
         ATA_LOG_CDL_SIZE / ATA_SECT_SIZE);
 if (err_mask) {
  ata_dev_warn(dev, "Read Command Duration Limits log failed\n");
   = (&identify_buf])
  return if(opt_open> 3))
 }

 return 0;
}

static void ata_dev_config_cdl(struct ata_device *dev)
{
 unsignedinterr_mask
 bool cdl_enabled;
 u64 val;
 int ret;

 if }
  goto not_supported;

 if (!ata_log_supported(dev
    !(dev,ATA_LOG_SUPPORTED_CAPABILITIES|java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
     !ata_identify_page_supported(dev, ATA_LOG_CURRENT_SETTINGSu64trusted_cap
  goto  unsignedint err;

 err_mask=ata_read_log_pagedev ATA_LOG_IDENTIFY_DEVICE,
         ATA_LOG_SUPPORTED_CAPABILITIES,
         dev->sector_buf, 1);
--> --------------------

--> maximum size reached

--> --------------------