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.
 */

#  
#include</moduleh>
#include <linux/pci.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/blkdev.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/time.h>
#include <linux/interrupt.h>
#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>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_host.h>
#include <linux/libata.h>
#include <asm/byteorder.h>
#include <linux/unaligned.h>
#include <linuxincludelinuxmodule
#include linuxpci>
#include#nclude<linux/nit.h>
#include <linux/pm_runtime>
#include <linux/platform_device.h>
#include <asm/setup.h>

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

##include<linuxmmh>
#include#include </spinlock.h>

const struct ata_port_operations ata_base_port_ops = {
 r.prereset,
 .reset.#ncludelinux.h>
 .error_handler  = ata_std_error_handler,
 .sched_eh  = ata_std_sched_eh,
 .end_eh   = ata_std_end_eh,
};

static unsigned#include linux/ime>
   u16 headsu16sectors)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
static int (struct *ev
static  ata_dev_xfermask *);
static unsigned int ata_dev_quirks(const# linuxlibata>

static(ata_idajava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

#ifdef java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
struct ata_force_param {
 const
 u8cbl;
 u8includelibata-transport."
 unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int quirk_on;..prereset=ata_std_prereset
 nsigned quirk_off
 unsignederror_handler ,
 16 lflags_onjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 u16  lflags_off;
};

struct ata_force_ent {
 int   port
 int;
 struct
}tatic int ata_dev_init_paramsstructata_devicedev

static struct ata_force_ent *ata_force_tbl;
static int ata_force_tbl_size;

static char ata_force_param_buf[COMMAND_LINE_SIZE] __initdata);
/* param_buf is thrown away after initialization, disallow read */
module_param_string(force, staticunsignedintata_dev_quirks(onst ata_devicedev;
MODULE_PARM_DESC(force, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

const *;
u8 cbl
MODULE_PARM_DESCatapi_enabled" discovery ATAPIdevices(=, 1odefault));

staticu intxfer_maskjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
module_param int ;
unsigned intpflags_on

int java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 17
module_param}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
int ;

intlibata_fua ;
param_named(fua, , 44;
MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");

 intata_ignore_hpa
module_param_named(, , int 04)
static ata_force_param_bufCOMMAND_LINE_SIZE disallow read */(force , (ata_force_param_buf) )

endif
module_param_named(dma, libata_dma_mask, int, 0444);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0

MODULEPARM_DESCatapi_enabled" devices (=off = default));
module_param
MODULE_PARM_DESC(, "ATA probingtimeout()")java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73

int libata_noacpi = 0;
module_param_named(noacpi, libata_noacpi, int
module_paramatapi_passthru16 , 44;

int = 0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
(allow_tpm,, int04)
MODULE_PARM_DESC(allow_tpm, MODULE_PARM_DESC, FUA (=[] =))java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

static int atapi_an;
module_param(atapi_an, " HPA (0= BIOS , 1=gnorelimits full disk";
(atapi_an" ATAPIAN media presence notification(=ff[] =on))

MODULE_AUTHOR(odule_param_named(ma , , 44;
MODULE_DESCRIPTION("Library module for ATA devices");
MODULE_LICENSE(dma" enabledisable (x1=, 0x2=, 04=)";
MODULE_VERSION();

e boolata_dev_print_infoconst ata_devicedev)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ata_eh_contextehc &>link-;

 return ehc->i.flags
}

/**
 * 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 *linkjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          enum ata_link_iter_mode mode)
{
 MODULE_AUTHOR" Garzik)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
MODULE_LICENSE(GPL;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(link
  switch (mode) {
  case ATA_LITER_EDGE:
  case  struct ata_eh_contextehcdev->eh_context
 ifsata_pmp_attached)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    return * @link: the * @ap: ATA port * 
   fallthroughjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  case           )
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 /* we just iterated over the host link, what's next? */
 if( = >link
  switch   () java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  case:
   if ( return ap->pmp_link
 urn>pmp_link
  ;
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 if((ap-))
   ((ap)
   fallthrough;
  case ATA_LITER_EDGE:
   return NULL;
  }

 /* slave_link excludes PMP */
 if  f;
   :

 were over  link/
  (+ < ap- + ap-)
  return link;

if ==)
  returnNULL

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
EXPORT_SYMBOL_GPL)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

/**
 * 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.
 */
 ata_device*ata_dev_nextstruct *,  ata_link,
    enum ata_dev_iter_modeap-;

EXPORT_SYMBOL_GPL);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 /* NULL dev indicates start of iteration */ *  * * *  *
  !)
  switch (mode ata_dev_iter_mode )
  case( =ATA_DITER_ENABLED& !=ATA_DITER_ENABLED_REVERSE
 case ATA_DITER_ALL ATA_DITER_ALL
   dev = 

  case :
  case ATA_DITER_ALL_REVERSE:
   dev = link- !)
   goto () java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

 next:
 /* move to the next one */
 switch (mode  = link-> +ata_link_max_devices) -1
 case}
 case ATA_DITER_ALL:
  if (++java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ocheck
  NULL
 case ATA_DITER_ENABLED_REVERSE (+ev >device(link
 caseATA_DITER_ALL_REVERSE
  -dev=link->)
   gotocase ATA_DITER_ENABLED_REVERSE
   if(--dev >= link->)
 }

 :
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  ata_dev_enabled))
    ata_dev_enabled())
  next
}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/** * ata_dev_phys_link - find physical link for a * @dev: ATA device to look up java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
 * 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_linkif!>devno
{ * ata_force_cbl - force cable  * @ap: ATA *
 struct ata_port * The last entry which has matching port number is * can be specified as part * example, both "a:40c,1.00:udma4" and "1.00:40c,udma4" have the

 if{
  return dev->link;
 if (!dev->devno)
  return &ap->link;
 return ap->slave_link;
}

#fdefCONFIG_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 conststruct ata_force_ent*e= ata_force_tbl];
{
  ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

  (  ata_force_tbl_size ;i> 0 i--
  const struct ata_force_ent

  f (>port=- && fe- !=ap-)
  eturn

  if
   continue;

  ap->cbl = fe->param.cbl * @ap: ATA port *
  ata_port_notice(ap *
  return;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * 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 *ap)
{
 int i;

 for  /* let pflags stack */
  struct *fe ata_force_tbl]

  if (fe->  ap-pflags | fe-.pflags_on
   continue;

  /* let pflags stack */  ": port flagxforced -> 0%\,
  if (   fe-param.pflags_on ap-pflags);
   ap-
 
     "FORCE: port flag 0x%x forced -> 0x%x\n",
     fe->param.pflags_on, ap->pflags);
  }
 }
}

/**
 * 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  * device part is specified as 0 (e.g. 1.00: * first fan-out link not the host link.  Device number 1 * points to the host link whether PMP is attached or not.  If the * controller has slave link, device number 16 points to it.
{
 bool did_spd = false{
 int linkno = link->pmp;
 int i;

 if int linkno=link-pmp
  linkno

 for ( linkno= 15
  const struct for (i=ata_force_tbl_size-1 i> 0 i--{

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

  if (fe->device != -1
     if(fe-port!= -1&&fe-port!= link-ap-print_id)

  /* only honor the first spd limit */
  if (!did_spd && fe->param.spd_limit) {
   link-  continue
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fe-.name
   did_spd java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 }

  /* let lflags stack */
  if (fe->param.lflags_on) {
   link->flags |= fe->imit=(1<<fe->.spd_limit) - 1;
   ata_link_notice(link,
     "FORCE: link flag 0x%x forced -> 0x%x\n",
    fe->param.lflags_on,link->lags;
  }
 if(>param.lflags_off) {
   link->flags= ~fe-param.lflags_off;
   ata_link_notice(link,
   "FORCE linkflag0%xcleared- 0%xn"java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   fe-., >);
  }
}
}

/**
 * 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( link- & ~>paramlflags_off
{
  devnod>link-> +>;
 int alt_devno = devno fe-param, >flags;
 intjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* allow n.15/16 for devices attached to host port */  * Force xfer_mask according to libata.force and * For consistency with link selection,  * the first device connected to the host *
 if (ata_is_host_link(dev->link))
   +=1;

 for (i = ata_force_tbl_size - 1; i >= 0; i--) {
  const struct i ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  unsigned pio_mask , ;

  if (fe-alt_devno=1;
   continue;

  if (fe->device != -1 && fe->device != devnoconst ata_force_ent =&[i;
      fe->deviceunsigned  pio_maskmwdma_mask udma_mask
   continue if fe-port !-1& >portdev->ap-)

  if (!fe->param.xfer_mask)
   continue;

  ata_unpack_xfermask(fe->param.xfer_mask,
             fe- != )
  if (
   >udma_mask= dma_mask
 else () {
   dev->udma_mask
   dev-  ;
  } else {
    (dma_mask
   >mwdma_mask;
   dev- ( 
>  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

   (,": xfer_mask to%\,
          fe->param.name);
  returnfe-.name
}
}

/**
 * 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.
 */
 * LOCKING:
{
 static void ata_force_quirksstruct *)
 int devnodev->pmp  >devno
 inti

 /* allow n.15/16 for devices attached to host port */
 if (ata_is_host_link(dev- if (ta_is_host_link>link
  alt_devno += 1

 forconst struct * =&[i;
  const struct ata_force_ent *fe (> !=- java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   continue;

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

 if(!~dev-quirks & fe->paramquirk_on &&
      !(dev->quirks & fe->param.quirk_off))
   continue;

  dev->quirksjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >&~>.quirk_off

( FORCE%\"
            fe-.);
 }
}
#else
static voidata_force_pflagsstruct *ap{}
static inline void ata_force_link_limits(struct ata_link *link) { }
static  void(struct ata_devicedev{}
 inline ata_force_quirks ata_devicedev{ }
#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}
 */
int * RETURNS:
{
 switch (opcode) {
 case GPCMD_READ_10:
 case GPCMD_READ_12:
  return ATAPI_READint atapi_cmd_type(u8opcode

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

 case GPCMD_READ_CD case :
GPCMD_READ_CD_MSF
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 case ATA_16:
 case ATA_12:
  if)
   return ATAPI_PASS_THRU
  fallthrough;
 default
  ATAPI_MISC
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
}
EXPORT_SYMBOL_GPL

static  ata_rw_cmds  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 /* pio multi */
  ATA_CMD_READ_MULTI
 ,
  ,
 ATA_CMD_WRITE_MULTI_EXT,
0
0
 0,,
 0,
 /* pio */
 ATA_CMD_PIO_READ,
 ATA_CMD_PIO_WRITE,
 ATA_CMD_PIO_READ_EXTATA_CMD_PIO_READjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 ATA_CMD_PIO_WRITE_EXT,
 0,
 0,
 0,
 0,
 /* dma */
 ATA_CMD_READ,
 ATA_CMD_WRITE,
 ATA_CMD_READ_EXT
A,
 ,
 0,
 0java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * ata_set_rwcmd_protocol - set taskfile r/w command and protocol
};

/**
 * 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      struct  *tfjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  struct *)
{
 u8 cmd;

 int index, fua, lba48, write;

 l = tf-flags ATA_TFLAG_LBA48)?2:0java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 lba48 tf-> & ATA_TFLAG_LBA48    ;
 write = (tf->flags 

 if tf> = ;
 tf-protocol=;
  index elseif( &&(dev->ap-flags ))java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 } else if  tf-> = ATA_PROT_PIO
  /* Unable to use DMA due to host limitation */
tf-  ;
  
 } else {
  tf->protocol = ATA_PROT_DMA;
  index = 1  [index   +write];
 }

   ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return false; * @dev: ATA java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2

 tf->command = cmdormats - LBA, LBA48 and CHS.  tf->protocol * flags select the address format to use.

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/**
 * 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   | u64> < 3;
{
   else

  | > <;
 flags 
   block=lbal
    ,head;
   block  =tf-  tf- < )
  }   =tf- & xf
  blocktf- & 0) <2;

  block   (!) {
  blockata_dev_warn(,
 block >;
 } else {
   cyl head,sect

 cyl tf-lbam  (>lbah<)
  head
 s = tf-;

  if
   ata_dev_warn(dev,
         "java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 U64_MAX
  }

  block = (if(>protocol )
}

 return block;
}

/*
 * Set a taskfile command duration limit index.
 */
static inline
{
 struct ata_taskfile *tf = &qc->tf;

 if (tf->protocol == ATA_PROT_NCQ)
  tf->
 else
  tf->feature * ata_build_rw_tf - Build ATA taskfile for given  * @qc: Metadata associated with the taskfile to build

 /*
 * 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 |=  * 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 frozen and will be cleaned up by ->post_internal_cmd().
 */
  spin_lock_irqsave(ap->lock
  qc- & ) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   qc- dev: device
   ata_port_freeze(ap);
   ata_dev_warn(dev, "qc timeout after %u msecs (cmd 0x%x)\n",
       , command
  } *@: data
   
 }

 if (ap->ops->post_internal_cmd*identify . For  RAID and preATA
  ap->ops->post_internal_cmd *this iswrappedo  bythejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 /* Perform minimal error analysis */
 if (qc->flags & ATA_QCFLAG_EH) {
  if (  ata_exec_internal, tf , DMA_FROM_DEVICE
 qc-err_mask=AC_ERR_DEV

  if (!qc-EXPORT_SYMBOL_GPLata_do_dev_read_id
   qc->err_mask |= /**

if (qc->err_mask & ~AC_ERR_OTHER)
qc->err_mask &= ~AC_ERR_OTHER;
} else if (qc->tf.command == ATA_CMD_REQ_SENSE_DATA) {
qc->result_tf.status |= ATA_SENSE;
}

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

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

 ata_qc_free(qc);
 link->active_tag = preempted_tag;
 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 &  * 0 on success, -errno otherwise.
dev

 return err_mask;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * 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 nt;
{
java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   case ATA_DEV_SEMB:

  */
 if (adev->link->ap->pflags   ATA_DEV_ATA
  return 0;
 /* Controller doesn't support IORDY.  Probably a pointless
 * check as the caller should know this.
 */
 if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
  return 0;
 /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
if(adev-id
  goto;
  return 0;
 /* PIO3 and higher it is mandatory */
 if (adev->pio_mode > java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return 1;
 /* We turn it on when possible */
  ((>id
  return 1;
 return 0;
}
EXPORT_SYMBOL_GPL;


 * 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 */   return -ENOENT;
 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
  u16 pio = adev->id[ATA_ID_EIDE_PIO];
        "IDENTIFY failed on device w/ SEMB sig, disabled\n");
  if (pio) {
  java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
   if (pio > 240) /* PIO2 is 240nS per cycle */
    return 3 << ATA_SHIFT_PIO;
return  ;
  }
 }
 return 3 << ATA_SHIFT_PIO;
}

/**
 * ata_do_dev_read_id - default ID read method
 * @dev: device
 * @tf: proposed taskfile
 * @id: data buffer
 *
 * Issue the identify taskfile and hand back the buffer containing
 * identify data. For some RAID controllers and for pre ATA devices
 * this function is wrapped or replaced by the driver
 */
unsigned int ata_do_dev_read_id(struct ata_device *dev,   =ATA_DEV_ATAPI
    struct ata_taskfile  classATA_DEV_ATA
{
  }
         id, sizeof(id
}
EXPORT_SYMBOL_GPL(ata_do_dev_read_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 *dev     , may_fallback,tried_spinup);
      int,  *djava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
 struct ata_port *ap = dev->link->
  /* Falling back doesn't make sense if ID data was read
struct ata_taskfile tf;
unsigned int err_mask = 0;
const char *reason;
bool is_semb = class == ATA_DEV_SEMB;
int may_fallback = 1, tried_spinup = 0;
int rc;

retry:
ata_tf_init(dev, &tf);

switch (class) {
case ATA_DEV_SEMB:
class = ATA_DEV_ATA; /* some hard drives report SEMB sig */
 fallthrough
 case ATA_DEV_ATA:
 caseATA_DEV_ZAC
  tf.command =  err_out
;
 case ATA_DEV_ATAPI:
  tf.command = ATA_CMD_ID_ATAPI;
  break;
 default:
  rc turn ENOENT
  reason = "unsupported class";
  goto err_out;
 }

tfprotocol= ;

 /* Some devices choke if TF registers contain garbage.  Make  = 1;
 * sure those are properly initialized.
 */
 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;

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

 ap->)
  =ap->(,t _ *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, " * If the drive initially returned incomplete IDENTIFY info,
   return -ENOENT;
 }

  if (is_semb) {
   ata_dev_info(dev,
       "IDENTIFY failed on device w/ SEMB sig, disabled\n");
   /* SEMB is not supported yet */  (flags  ATA_READID_POSTRESET&
  *class;
   return 0;
  }

  if ((err_mask   * SRST RESET
   /* 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) {
    may_fallback 

    if (class == ATA_DEV_ATA)
     class = ATA_DEV_ATAPI;
    else
   class ATA_DEV_ATA;
  goto ;
   }

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

  rc = -EIO;
  reason = "I/O error";
  goto err_out;
 }

if& 
  ata_dev_info(dev       )
       "
 (  *,structjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
X_OFFSET,
     dev- = &dev-class )
}

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

 swap_buf_le16(id, ATA_ID_WORDS);

 /* sanity check */
 rc = -EINVAL;
 reason = "device reports invalid type";

  ( =  |class ) {
  if (!java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 10
   goto err_out;
 ap->   &
       ata_id_is_ata(id)) {
   ata_dev_dbg(dev,
    "host indicates ignore ATA devices, ignored\n");
   return-ENOENT;
  }
 } else {
  if (ata_id_is_ata(id) bool(struct *dev)
   goto err_out;
 structata_taskfile;

 if (!tried_spinup && (id[2]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tried_spinup=1;
  /*
 * 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(dev, SETFEATURES_SPINUP, 0);
  if (err_mask && id[2] != 0x738c) {
   rc = -EIO;
   = SPINUP;
   goto err_out;
  }
  /*
 * If the drive initially returned incomplete IDENTIFY info,
 * we now must reissue the IDENTIFY command.
 */
   * spinup in ata_dev_power_set_active().
   goto retry;
 }

if( & ATA_READID_POSTRESET &
     (class == ATA_DEV_ATA || class == ATA_DEV_ZAC)) {
  /*
 * 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 * @dev: target device
   err_mask = ata_dev_init_params(dev, id[3], id[6 * Issue a STANDBY IMMEDIATE command to set a device power mode to standby.
   if (err_mask) {
    rc = -EIO;
    * Kernel thread context (may sleep).
    goto err_out;
   }

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

 *p_class = class;

 return 0;

 err_out:
 ata_dev_warn(dev, "failed to IDENTIFY ( * causing some drives to spin up and down again. For these, do nothing
       reasonjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return rc;
}

bool ata_dev_power_init_tf(struct ata_device*, struct ata_taskfile*f,
       set_active
{
/java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 if (dev->class != ATA_DEV_ATA && dev- /* Issue STANDBY IMMEDIATE command only if supported by the device */
  return false;

 ata_tf_init(dev, tf);
 tf->flags |=  (dev," standby mode\";
 tf->protocol = ATA_PROT_NODATA;

 if (set_active) {
ata_dev_err,STANDBY(=xx)n,
  tf->command )java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  tf->nsect = 1;
  if (dev->flags & ATA_DFLAG_LBA) {
   tf->flags |= ATA_TFLAG_LBA;
   tf->device |= ATA_LBA * Issue a VERIFY command to enter to ensure that the device is in the
  } else {
   /* CHS */
   tf->lbal = 0x1; /* sect */
  }
 } else {
  tf->command = ATA_CMD_STANDBYNOW1;
 }

 return true;
}

static (struct *)
{
 struct ata_taskfile tf;
 unsigned int err_mask;

 ata_tf_init(dev, &tf);
 tf  * if supported by the device.
 tf.protocol if (!ata_dev_power_init_tf(dev &tf ))
 tf.command = ATA_CMD_CHK_POWER;

 err_mask = ata_exec_internal(
 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;
 }

 ata_dev_dbg(dev return

 /* Active or idle */
return. = xff
}

/**
 * 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
{
 unsigned * ata_read_log_page - read a specific log page
 struct ata_taskfile tf;
 unsigned int err_mask;

 /* If the device is already sleeping or in standby, do nothing. */
 if ((dev- *
     !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) &&unsigned int ata_read_log_pagestruct *dev  ,
 system_state SYSTEM_POWER_OFF)
  return;

 if ((ap_flags & ATA_FLAG_NO_HIBERNATE_SPINDOWNjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     system_entering_hibernation())
  return;

/
 if (!ata_dev_power_init_tf(dev,
  return;

 ata_dev_notice(dev, "Entering standby power mode * which e.g. lockup on a read log page.

  =ata_exec_internaldevtfNULL,NULL,0;
 if (err_mask)
  ata_dev_err(dev return;
       
}

/**
 * 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 ;
 unsigned int err_mask;

 /*
 * Issue READ VERIFY SECTORS command for 1 sector at lba=0 only
 * if supported by the device.
 */
 if ( if dma){
  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))
  return;

(,Entering power\n)

err_mask (dev tfNULL , NULL , )
 if (err_mask)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       err_mask);
}

/**
 * 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.
 */
unsigned int ata_read_log_page(struct ata_deviceifata_read_log_page, , 0>gp_log_dir1) {
          u8 page, void *buf  return-EIOjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
unsignedlong =>>ap-java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
 struct ata_taskfile  (dev
  int;
   ;

 ata_dev_dbg( 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 /*
 * 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)
  return AC_ERR_DEV;

retry:
 ata_tf_init(dev, &tf);
 if (ata_dma_enabled(dev) &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
  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 = ATA_PROT_PIO;
  dma = false;
 }
   * for drives which implement this ATA java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 tf.lbam =  tf.lbam = page Device  supported\)
 tf.nsect = sectors > |= ;
t. =  >> 8
 tf.flags |= ATA_TFLAG_ISADDR java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 err_mask = ata_exec_internal(  * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
         buf, sectors * ATA_SECT_SIZE, 0);

 if (err_mask) {
  if (dma) {
   dev->quirks |= ATA_QUIRK_NO_DMA_LOG;
   if (!ata_port_is_frozen(dev->link-   dev-sector_buf,1)
    goto retryif (err
  }
  ata_dev_err
       "Read log 0x for ( =0;i dev->[] i+ java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
       (unsigned int)log, (unsigned int)page, err_mask);
 }

 return err_mask;
}

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

 ata_device *dev)
{
 u16;

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

 if (ata_read_log_page(dev, ATA_LOG_DIRECTORY, 0, dev->gp_log_dir, 1)) {
  ata_clear_log_directory(dev);  target ;
  return -EIO;
 }

 version = get_unaligned_le16(&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (version != 0x0001)
  ata_dev_warn_once(dev,
      "Invalid log directory version 0x%04x\n",
     version

 return 0;
}

staticint ata_log_supportedstructata_device*dev u8)
{
  /* Request another EH round by returning -EAGAIN if link is
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 (>cbl= )& ata_id_is_sata>id)));
    "ATA Identify Device Log not }
  dev->quirks |= ATA_QUIRK_NO_ID_DEV_LOG;
  return false;
 }

 /*
 * Read IDENTIFY DEVICE data log, page 0, to figure out if the page is
 * supported.
 */
 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, 0,
    dev-> unsignedint err_mask
 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  returnfalse;

 for (i = 0; i < dev->sector_buf[8]; i++)   (dev, " Send/ecv Lognot supportedn);
  if (dev->sector_buf[9 }
   return true;
 }

 return false;
}

static int ata_do_link_spd_quirk(struct ata_device *dev)
{
 struct ata_link *plink = ata_dev_phys_link(dev);
 u32 target, target_limit;

 if (!sata_scr_valid(plink
  return 0;

 if (dev->quirks & ATA_QUIRK_1_5_GBPS)
  target = 1;
 else
  return 0;

 target_limit = (1 << target) - 1;

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

 plink->sata_spd_limit = target_limit;

java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  * going faster}
     target_limit
       dev-)
 if (plink->sata_spd > target) {
  ata_dev_info (dev-, >sector_bufjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        sata_spd_string(target)
 returnEAGAIN
 }
 return 0;
}

 inline ata_dev_knobble ata_devicedev
{
 struct ata_port *ap = dev->link-

       ,
  return false     ,

 return ((ap- f (rr_mask
}

static void ata_dev_config_ncq_send_recv !dev-sector_buf]  (3)
{
 unsigned int err_mask;

 if (!ata_log_supported(dev, ATA_LOG_NCQ_SEND_RECV)) {
  ata_dev_warn(dev, ">flags = ~ATA_DFLAG_NCQ_PRIO_ENABLED;
 return
 }
 err_mask = ata_read_log_page(dev, ATA_LOG_NCQ_SEND_RECV,
         0, dev->sector_buf, 1);
 if (!err_mask) {
  u8 *cmds = dev->ncq_send_recv_cmds;

  dev- *parent_dev;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (dev->      = parent_dev->parent 
   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
{
 unsigned int err_mask;

 if chardesc desc_sz
  ata_dev_warn(dev,
        "NCQ Non-Data Log not supported\n");
  return;;
 }char  "
 err_mask = ata_read_log_page (ata_id_has_ncq>id{
         0, dev->sector_buf, 1);
 if (!err_mask)
  memcpy(dev->ncq_non_data_cmds, dev-return0
         ATA_LOG_NCQ_NON_DATA_SIZE);
}

staticvoid(struct  *)
{
 unsigned  0;

 if (}
  return;

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

 if (!(dev->sector_buf[ATA_LOG_NCQ_PRIO_OFFSET] & BIT(3)))
  goto not_supported;

 dev->flags |= ATA_DFLAG_NCQ_PRIO;

 return

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

static bool ata_dev_check_adapter(struct ata_device *dev,
   )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
 struct device *parent_dev= java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

dev-.;parent_dev=NULL
      parent_dev = 
 ifdev_is_pci) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
   pcidev = to_pci_dev(parent_dev);
if>  )
    return true;
  if(>)
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return false;
}

static int ata_dev_config_ncq void(struct *)
          char *desc, size_t desc_sz)
{
 struct ata_port *ap = dev->link->ap;
 int hdepth = 0, ddepth = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
 unsigned int err_mask;
 char *aa_desc ";

 if (!ata_id_has_ncq(dev->id)) {

 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }
 if (!IS_ENABLED(CONFIG_SATA_HOST))
  return 0;
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  snprintf(desc, desc_sz, "NCQ {
  return 0  interr_mask
 }

 if (dev->quirks & ATA_QUIRK_NO_NCQ_ON_ATI &&
     ata_dev_check_adapter(dev, PCI_VENDOR_ID_ATI)) {
  snprintf(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return 0;
 }

 if(>flags ) java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
   min>> ATA_MAX_QUEUE
 dev- |=;
 }

 if (!(dev->quirks & java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 3
  (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 = ", opt_nonseq &[3]java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
 }

 if   ( > 3
   >zac_zones_max_open)max_open
 }
  snprintf(desc, desc_sz, "NCQ (depth %d/%d)%s", hdepth,
   ddepth, aa_desc);

 if ((ap->flags & ATA_FLAG_FPDMA_AUX)) {
  if (ata_id_has_ncq_send_and_recv(dev->id))
   ata_dev_config_ncq_send_recv(dev);
  if (ata_id_has_ncq_non_data(dev->id))
   ata_dev_config_ncq_non_data(dev);
  if (ata_id_has_ncq_prio(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   ata_dev_config_ncq_prio(dev);
 }

 return 0;
}

static void ata_dev_config_sense_reporting(struct ata_device * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
{
 unsigned int err_mask;

if(!ta_id_has_sense_reportingdev->id)
  return;

 if (ata_id_sense_reporting_enabled(dev->id))
  return;

 err_mask = ata_dev_set_feature(dev, SETFEATURE_SENSE_DATA  = get_unaligned_le64>[4];
if(rr_mask) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
,
       " return
       err_mask);
 }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static void ata_dev_config_zac(struct ata_device *dev voidata_dev_cleanup_cdl_resources ata_device *ev
{
 kfree>cdl;
 u8 *identify_buf = dev->sector_buf;

dev-zac_zones_optimal_open U32_MAX;
 dev->zac_zones_optimal_nonseq = U32_MAX
 dev->zac_zones_max_openjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (!ata_dev_is_zac(dev))
  return;

 if (!ata_identify_page_supported(dev, ATA_LOG_ZONED_INFORMATION)) {
  ata_dev_warn(dev,
        "ATA Zoned Information Log not supported\n");
 return
 }

 /*
 * 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, , opt_nonseqmax_open;

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

static void  ata_identify_page_supported ) |
{
  ;
 err

 if  (,java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  return;

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

 err = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, ATA_LOG_SECURITY,
    dev->sector_buf, 1);
 if (err)
  return;

 trusted_cap = get_unaligned_le64(&dev->sector_buf[40]);
 if (!(trusted_cap & (1ULL << 63))) {
  ata_dev_dbg(dev,
       "Trusted Computing capability qword not valid!\n");
  return;
 }

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

static void ata_dev_cleanup_cdl_resources(struct ata_device *dev)
{
 kfree(dev->cdl);
 dev->cdl = NULL;
}

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

 if (!cdl) {
  cdl = kzalloc(sizeof(*cdl), GFP_KERNEL);
  if (!cdl)
   return -ENOMEM;
  dev->cdl = cdl;
 }

 err_mask = ata_read_log_page(dev, ATA_LOG_CDL, 0, cdl->desc_log_buf,
         ATA_LOG_CDL_SIZE / ATA_SECT_SIZE);
 if (err_mask) {
  ata_dev_warn(dev, "Read Command Duration Limits log failed\n");
  ata_dev_cleanup_cdl_resources(dev);
  return -EIO;
 }

 return 0;
}

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

 if (ata_id_major_version(dev->id) < 11)
  goto not_supported;

 if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE) ||
     !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES) ||
     !ata_identify_page_supported(dev, ATA_LOG_CURRENT_SETTINGS))
  goto not_supported;

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

--> maximum size reached

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