git.oblomov.eu Git - linux-2.6/blob - drivers/ata/libata-scsi.c

   1 /*
   2  *  libata-scsi.c - helper library for ATA
   3  *
   4  *  Maintained by:  Jeff Garzik <jgarzik@pobox.com>
   5  *                  Please ALWAYS copy linux-ide@vger.kernel.org
   6  *                  on emails.
   7  *
   8  *  Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   9  *  Copyright 2003-2004 Jeff Garzik
  10  *
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2, or (at your option)
  15  *  any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; see the file COPYING.  If not, write to
  24  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  25  *
  26  *
  27  *  libata documentation is available via 'make {ps|pdf}docs',
  28  *  as Documentation/DocBook/libata.*
  29  *
  30  *  Hardware documentation available from
  31  *  - http://www.t10.org/
  32  *  - http://www.t13.org/
  33  *
  34  */
  35
  36 #include <linux/kernel.h>
  37 #include <linux/blkdev.h>
  38 #include <linux/spinlock.h>
  39 #include <scsi/scsi.h>
  40 #include <scsi/scsi_host.h>
  41 #include <scsi/scsi_cmnd.h>
  42 #include <scsi/scsi_eh.h>
  43 #include <scsi/scsi_device.h>
  44 #include <scsi/scsi_tcq.h>
  45 #include <scsi/scsi_transport.h>
  46 #include <linux/libata.h>
  47 #include <linux/hdreg.h>
  48 #include <asm/uaccess.h>
  49
  50 #include "libata.h"
  51
  52 #define SECTOR_SIZE     512
  53
  54 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
  55
  56 static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
  57                                         const struct scsi_device *scsidev);
  58 static struct ata_device * ata_scsi_find_dev(struct ata_port *ap,
  59                                             const struct scsi_device *scsidev);
  60 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
  61                               unsigned int id, unsigned int lun);
  62
  63
  64 #define RW_RECOVERY_MPAGE 0x1
  65 #define RW_RECOVERY_MPAGE_LEN 12
  66 #define CACHE_MPAGE 0x8
  67 #define CACHE_MPAGE_LEN 20
  68 #define CONTROL_MPAGE 0xa
  69 #define CONTROL_MPAGE_LEN 12
  70 #define ALL_MPAGES 0x3f
  71 #define ALL_SUB_MPAGES 0xff
  72
  73
  74 static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = {
  75         RW_RECOVERY_MPAGE,
  76         RW_RECOVERY_MPAGE_LEN - 2,
  77         (1 << 7),       /* AWRE */
  78         0,              /* read retry count */
  79         0, 0, 0, 0,
  80         0,              /* write retry count */
  81         0, 0, 0
  82 };
  83
  84 static const u8 def_cache_mpage[CACHE_MPAGE_LEN] = {
  85         CACHE_MPAGE,
  86         CACHE_MPAGE_LEN - 2,
  87         0,              /* contains WCE, needs to be 0 for logic */
  88         0, 0, 0, 0, 0, 0, 0, 0, 0,
  89         0,              /* contains DRA, needs to be 0 for logic */
  90         0, 0, 0, 0, 0, 0, 0
  91 };
  92
  93 static const u8 def_control_mpage[CONTROL_MPAGE_LEN] = {
  94         CONTROL_MPAGE,
  95         CONTROL_MPAGE_LEN - 2,
  96         2,      /* DSENSE=0, GLTSD=1 */
  97         0,      /* [QAM+QERR may be 1, see 05-359r1] */
  98         0, 0, 0, 0, 0xff, 0xff,
  99         0, 30   /* extended self test time, see 05-359r1 */
 100 };
 101
 102 /*
 103  * libata transport template.  libata doesn't do real transport stuff.
 104  * It just needs the eh_timed_out hook.
 105  */
 106 static struct scsi_transport_template ata_scsi_transport_template = {
 107         .eh_strategy_handler    = ata_scsi_error,
 108         .eh_timed_out           = ata_scsi_timed_out,
 109         .user_scan              = ata_scsi_user_scan,
 110 };
 111
 112
 113 static void ata_scsi_invalid_field(struct scsi_cmnd *cmd,
 114                                    void (*done)(struct scsi_cmnd *))
 115 {
 116         ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x24, 0x0);
 117         /* "Invalid field in cbd" */
 118         done(cmd);
 119 }
 120
 121 /**
 122  *      ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
 123  *      @sdev: SCSI device for which BIOS geometry is to be determined
 124  *      @bdev: block device associated with @sdev
 125  *      @capacity: capacity of SCSI device
 126  *      @geom: location to which geometry will be output
 127  *
 128  *      Generic bios head/sector/cylinder calculator
 129  *      used by sd. Most BIOSes nowadays expect a XXX/255/16  (CHS)
 130  *      mapping. Some situations may arise where the disk is not
 131  *      bootable if this is not used.
 132  *
 133  *      LOCKING:
 134  *      Defined by the SCSI layer.  We don't really care.
 135  *
 136  *      RETURNS:
 137  *      Zero.
 138  */
 139 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
 140                        sector_t capacity, int geom[])
 141 {
 142         geom[0] = 255;
 143         geom[1] = 63;
 144         sector_div(capacity, 255*63);
 145         geom[2] = capacity;
 146
 147         return 0;
 148 }
 149
 150 /**
 151  *      ata_get_identity - Handler for HDIO_GET_IDENTITY ioctl
 152  *      @sdev: SCSI device to get identify data for
 153  *      @arg: User buffer area for identify data
 154  *
 155  *      LOCKING:
 156  *      Defined by the SCSI layer.  We don't really care.
 157  *
 158  *      RETURNS:
 159  *      Zero on success, negative errno on error.
 160  */
 161 static int ata_get_identity(struct scsi_device *sdev, void __user *arg)
 162 {
 163         struct ata_port *ap = ata_shost_to_port(sdev->host);
 164         struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
 165         u16 __user *dst = arg;
 166         char buf[40];
 167
 168         if (!dev)
 169                 return -ENOMSG;
 170
 171         if (copy_to_user(dst, dev->id, ATA_ID_WORDS * sizeof(u16)))
 172                 return -EFAULT;
 173
 174         ata_id_string(dev->id, buf, ATA_ID_PROD, ATA_ID_PROD_LEN);
 175         if (copy_to_user(dst + ATA_ID_PROD, buf, ATA_ID_PROD_LEN))
 176                 return -EFAULT;
 177
 178         ata_id_string(dev->id, buf, ATA_ID_FW_REV, ATA_ID_FW_REV_LEN);
 179         if (copy_to_user(dst + ATA_ID_FW_REV, buf, ATA_ID_FW_REV_LEN))
 180                 return -EFAULT;
 181
 182         ata_id_string(dev->id, buf, ATA_ID_SERNO, ATA_ID_SERNO_LEN);
 183         if (copy_to_user(dst + ATA_ID_SERNO, buf, ATA_ID_SERNO_LEN))
 184                 return -EFAULT;
 185
 186         return 0;
 187 }
 188
 189 /**
 190  *      ata_cmd_ioctl - Handler for HDIO_DRIVE_CMD ioctl
 191  *      @scsidev: Device to which we are issuing command
 192  *      @arg: User provided data for issuing command
 193  *
 194  *      LOCKING:
 195  *      Defined by the SCSI layer.  We don't really care.
 196  *
 197  *      RETURNS:
 198  *      Zero on success, negative errno on error.
 199  */
 200 int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
 201 {
 202         int rc = 0;
 203         u8 scsi_cmd[MAX_COMMAND_SIZE];
 204         u8 args[4], *argbuf = NULL, *sensebuf = NULL;
 205         int argsize = 0;
 206         enum dma_data_direction data_dir;
 207         int cmd_result;
 208
 209         if (arg == NULL)
 210                 return -EINVAL;
 211
 212         if (copy_from_user(args, arg, sizeof(args)))
 213                 return -EFAULT;
 214
 215         sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
 216         if (!sensebuf)
 217                 return -ENOMEM;
 218
 219         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 220
 221         if (args[3]) {
 222                 argsize = SECTOR_SIZE * args[3];
 223                 argbuf = kmalloc(argsize, GFP_KERNEL);
 224                 if (argbuf == NULL) {
 225                         rc = -ENOMEM;
 226                         goto error;
 227                 }
 228
 229                 scsi_cmd[1]  = (4 << 1); /* PIO Data-in */
 230                 scsi_cmd[2]  = 0x0e;     /* no off.line or cc, read from dev,
 231                                             block count in sector count field */
 232                 data_dir = DMA_FROM_DEVICE;
 233         } else {
 234                 scsi_cmd[1]  = (3 << 1); /* Non-data */
 235                 scsi_cmd[2]  = 0x20;     /* cc but no off.line or data xfer */
 236                 data_dir = DMA_NONE;
 237         }
 238
 239         scsi_cmd[0] = ATA_16;
 240
 241         scsi_cmd[4] = args[2];
 242         if (args[0] == WIN_SMART) { /* hack -- ide driver does this too... */
 243                 scsi_cmd[6]  = args[3];
 244                 scsi_cmd[8]  = args[1];
 245                 scsi_cmd[10] = 0x4f;
 246                 scsi_cmd[12] = 0xc2;
 247         } else {
 248                 scsi_cmd[6]  = args[1];
 249         }
 250         scsi_cmd[14] = args[0];
 251
 252         /* Good values for timeout and retries?  Values below
 253            from scsi_ioctl_send_command() for default case... */
 254         cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
 255                                   sensebuf, (10*HZ), 5, 0);
 256
 257         if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
 258                 u8 *desc = sensebuf + 8;
 259                 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
 260
 261                 /* If we set cc then ATA pass-through will cause a
 262                  * check condition even if no error. Filter that. */
 263                 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
 264                         struct scsi_sense_hdr sshdr;
 265                         scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
 266                                               &sshdr);
 267                         if (sshdr.sense_key==0 &&
 268                             sshdr.asc==0 && sshdr.ascq==0)
 269                                 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
 270                 }
 271
 272                 /* Send userspace a few ATA registers (same as drivers/ide) */
 273                 if (sensebuf[0] == 0x72 &&     /* format is "descriptor" */
 274                     desc[0] == 0x09 ) {        /* code is "ATA Descriptor" */
 275                         args[0] = desc[13];    /* status */
 276                         args[1] = desc[3];     /* error */
 277                         args[2] = desc[5];     /* sector count (0:7) */
 278                         if (copy_to_user(arg, args, sizeof(args)))
 279                                 rc = -EFAULT;
 280                 }
 281         }
 282
 283
 284         if (cmd_result) {
 285                 rc = -EIO;
 286                 goto error;
 287         }
 288
 289         if ((argbuf)
 290          && copy_to_user(arg + sizeof(args), argbuf, argsize))
 291                 rc = -EFAULT;
 292 error:
 293         kfree(sensebuf);
 294         kfree(argbuf);
 295         return rc;
 296 }
 297
 298 /**
 299  *      ata_task_ioctl - Handler for HDIO_DRIVE_TASK ioctl
 300  *      @scsidev: Device to which we are issuing command
 301  *      @arg: User provided data for issuing command
 302  *
 303  *      LOCKING:
 304  *      Defined by the SCSI layer.  We don't really care.
 305  *
 306  *      RETURNS:
 307  *      Zero on success, negative errno on error.
 308  */
 309 int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
 310 {
 311         int rc = 0;
 312         u8 scsi_cmd[MAX_COMMAND_SIZE];
 313         u8 args[7], *sensebuf = NULL;
 314         int cmd_result;
 315
 316         if (arg == NULL)
 317                 return -EINVAL;
 318
 319         if (copy_from_user(args, arg, sizeof(args)))
 320                 return -EFAULT;
 321
 322         sensebuf = kzalloc(SCSI_SENSE_BUFFERSIZE, GFP_NOIO);
 323         if (!sensebuf)
 324                 return -ENOMEM;
 325
 326         memset(scsi_cmd, 0, sizeof(scsi_cmd));
 327         scsi_cmd[0]  = ATA_16;
 328         scsi_cmd[1]  = (3 << 1); /* Non-data */
 329         scsi_cmd[2]  = 0x20;     /* cc but no off.line or data xfer */
 330         scsi_cmd[4]  = args[1];
 331         scsi_cmd[6]  = args[2];
 332         scsi_cmd[8]  = args[3];
 333         scsi_cmd[10] = args[4];
 334         scsi_cmd[12] = args[5];
 335         scsi_cmd[13] = args[6] & 0x4f;
 336         scsi_cmd[14] = args[0];
 337
 338         /* Good values for timeout and retries?  Values below
 339            from scsi_ioctl_send_command() for default case... */
 340         cmd_result = scsi_execute(scsidev, scsi_cmd, DMA_NONE, NULL, 0,
 341                                 sensebuf, (10*HZ), 5, 0);
 342
 343         if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
 344                 u8 *desc = sensebuf + 8;
 345                 cmd_result &= ~(0xFF<<24); /* DRIVER_SENSE is not an error */
 346
 347                 /* If we set cc then ATA pass-through will cause a
 348                  * check condition even if no error. Filter that. */
 349                 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
 350                         struct scsi_sense_hdr sshdr;
 351                         scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
 352                                                 &sshdr);
 353                         if (sshdr.sense_key==0 &&
 354                                 sshdr.asc==0 && sshdr.ascq==0)
 355                                 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
 356                 }
 357
 358                 /* Send userspace ATA registers */
 359                 if (sensebuf[0] == 0x72 &&      /* format is "descriptor" */
 360                                 desc[0] == 0x09) {/* code is "ATA Descriptor" */
 361                         args[0] = desc[13];     /* status */
 362                         args[1] = desc[3];      /* error */
 363                         args[2] = desc[5];      /* sector count (0:7) */
 364                         args[3] = desc[7];      /* lbal */
 365                         args[4] = desc[9];      /* lbam */
 366                         args[5] = desc[11];     /* lbah */
 367                         args[6] = desc[12];     /* select */
 368                         if (copy_to_user(arg, args, sizeof(args)))
 369                                 rc = -EFAULT;
 370                 }
 371         }
 372
 373         if (cmd_result) {
 374                 rc = -EIO;
 375                 goto error;
 376         }
 377
 378  error:
 379         kfree(sensebuf);
 380         return rc;
 381 }
 382
 383 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 384 {
 385         int val = -EINVAL, rc = -EINVAL;
 386
 387         switch (cmd) {
 388         case ATA_IOC_GET_IO32:
 389                 val = 0;
 390                 if (copy_to_user(arg, &val, 1))
 391                         return -EFAULT;
 392                 return 0;
 393
 394         case ATA_IOC_SET_IO32:
 395                 val = (unsigned long) arg;
 396                 if (val != 0)
 397                         return -EINVAL;
 398                 return 0;
 399
 400         case HDIO_GET_IDENTITY:
 401                 return ata_get_identity(scsidev, arg);
 402
 403         case HDIO_DRIVE_CMD:
 404                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 405                         return -EACCES;
 406                 return ata_cmd_ioctl(scsidev, arg);
 407
 408         case HDIO_DRIVE_TASK:
 409                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
 410                         return -EACCES;
 411                 return ata_task_ioctl(scsidev, arg);
 412
 413         default:
 414                 rc = -ENOTTY;
 415                 break;
 416         }
 417
 418         return rc;
 419 }
 420
 421 /**
 422  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
 423  *      @dev: ATA device to which the new command is attached
 424  *      @cmd: SCSI command that originated this ATA command
 425  *      @done: SCSI command completion function
 426  *
 427  *      Obtain a reference to an unused ata_queued_cmd structure,
 428  *      which is the basic libata structure representing a single
 429  *      ATA command sent to the hardware.
 430  *
 431  *      If a command was available, fill in the SCSI-specific
 432  *      portions of the structure with information on the
 433  *      current command.
 434  *
 435  *      LOCKING:
 436  *      spin_lock_irqsave(host lock)
 437  *
 438  *      RETURNS:
 439  *      Command allocated, or %NULL if none available.
 440  */
 441 static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
 442                                               struct scsi_cmnd *cmd,
 443                                               void (*done)(struct scsi_cmnd *))
 444 {
 445         struct ata_queued_cmd *qc;
 446
 447         qc = ata_qc_new_init(dev);
 448         if (qc) {
 449                 qc->scsicmd = cmd;
 450                 qc->scsidone = done;
 451
 452                 qc->__sg = scsi_sglist(cmd);
 453                 qc->n_elem = scsi_sg_count(cmd);
 454         } else {
 455                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
 456                 done(cmd);
 457         }
 458
 459         return qc;
 460 }
 461
 462 /**
 463  *      ata_dump_status - user friendly display of error info
 464  *      @id: id of the port in question
 465  *      @tf: ptr to filled out taskfile
 466  *
 467  *      Decode and dump the ATA error/status registers for the user so
 468  *      that they have some idea what really happened at the non
 469  *      make-believe layer.
 470  *
 471  *      LOCKING:
 472  *      inherited from caller
 473  */
 474 static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
 475 {
 476         u8 stat = tf->command, err = tf->feature;
 477
 478         printk(KERN_WARNING "ata%u: status=0x%02x { ", id, stat);
 479         if (stat & ATA_BUSY) {
 480                 printk("Busy }\n");     /* Data is not valid in this case */
 481         } else {
 482                 if (stat & 0x40)        printk("DriveReady ");
 483                 if (stat & 0x20)        printk("DeviceFault ");
 484                 if (stat & 0x10)        printk("SeekComplete ");
 485                 if (stat & 0x08)        printk("DataRequest ");
 486                 if (stat & 0x04)        printk("CorrectedError ");
 487                 if (stat & 0x02)        printk("Index ");
 488                 if (stat & 0x01)        printk("Error ");
 489                 printk("}\n");
 490
 491                 if (err) {
 492                         printk(KERN_WARNING "ata%u: error=0x%02x { ", id, err);
 493                         if (err & 0x04)         printk("DriveStatusError ");
 494                         if (err & 0x80) {
 495                                 if (err & 0x04) printk("BadCRC ");
 496                                 else            printk("Sector ");
 497                         }
 498                         if (err & 0x40)         printk("UncorrectableError ");
 499                         if (err & 0x10)         printk("SectorIdNotFound ");
 500                         if (err & 0x02)         printk("TrackZeroNotFound ");
 501                         if (err & 0x01)         printk("AddrMarkNotFound ");
 502                         printk("}\n");
 503                 }
 504         }
 505 }
 506
 507 /**
 508  *      ata_to_sense_error - convert ATA error to SCSI error
 509  *      @id: ATA device number
 510  *      @drv_stat: value contained in ATA status register
 511  *      @drv_err: value contained in ATA error register
 512  *      @sk: the sense key we'll fill out
 513  *      @asc: the additional sense code we'll fill out
 514  *      @ascq: the additional sense code qualifier we'll fill out
 515  *      @verbose: be verbose
 516  *
 517  *      Converts an ATA error into a SCSI error.  Fill out pointers to
 518  *      SK, ASC, and ASCQ bytes for later use in fixed or descriptor
 519  *      format sense blocks.
 520  *
 521  *      LOCKING:
 522  *      spin_lock_irqsave(host lock)
 523  */
 524 static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
 525                                u8 *asc, u8 *ascq, int verbose)
 526 {
 527         int i;
 528
 529         /* Based on the 3ware driver translation table */
 530         static const unsigned char sense_table[][4] = {
 531                 /* BBD|ECC|ID|MAR */
 532                 {0xd1,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 533                 /* BBD|ECC|ID */
 534                 {0xd0,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
 535                 /* ECC|MC|MARK */
 536                 {0x61,          HARDWARE_ERROR, 0x00, 0x00},    // Device fault                 Hardware error
 537                 /* ICRC|ABRT */         /* NB: ICRC & !ABRT is BBD */
 538                 {0x84,          ABORTED_COMMAND, 0x47, 0x00},   // Data CRC error               SCSI parity error
 539                 /* MC|ID|ABRT|TRK0|MARK */
 540                 {0x37,          NOT_READY, 0x04, 0x00},         // Unit offline                 Not ready
 541                 /* MCR|MARK */
 542                 {0x09,          NOT_READY, 0x04, 0x00},         // Unrecovered disk error       Not ready
 543                 /*  Bad address mark */
 544                 {0x01,          MEDIUM_ERROR, 0x13, 0x00},      // Address mark not found       Address mark not found for data field
 545                 /* TRK0 */
 546                 {0x02,          HARDWARE_ERROR, 0x00, 0x00},    // Track 0 not found              Hardware error
 547                 /* Abort & !ICRC */
 548                 {0x04,          ABORTED_COMMAND, 0x00, 0x00},   // Aborted command              Aborted command
 549                 /* Media change request */
 550                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change request   FIXME: faking offline
 551                 /* SRV */
 552                 {0x10,          ABORTED_COMMAND, 0x14, 0x00},   // ID not found                 Recorded entity not found
 553                 /* Media change */
 554                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change           FIXME: faking offline
 555                 /* ECC */
 556                 {0x40,          MEDIUM_ERROR, 0x11, 0x04},      // Uncorrectable ECC error      Unrecovered read error
 557                 /* BBD - block marked bad */
 558                 {0x80,          MEDIUM_ERROR, 0x11, 0x04},      // Block marked bad               Medium error, unrecovered read error
 559                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 560         };
 561         static const unsigned char stat_table[][4] = {
 562                 /* Must be first because BUSY means no other bits valid */
 563                 {0x80,          ABORTED_COMMAND, 0x47, 0x00},   // Busy, fake parity for now
 564                 {0x20,          HARDWARE_ERROR,  0x00, 0x00},   // Device fault
 565                 {0x08,          ABORTED_COMMAND, 0x47, 0x00},   // Timed out in xfer, fake parity for now
 566                 {0x04,          RECOVERED_ERROR, 0x11, 0x00},   // Recovered ECC error    Medium error, recovered
 567                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
 568         };
 569
 570         /*
 571          *      Is this an error we can process/parse
 572          */
 573         if (drv_stat & ATA_BUSY) {
 574                 drv_err = 0;    /* Ignore the err bits, they're invalid */
 575         }
 576
 577         if (drv_err) {
 578                 /* Look for drv_err */
 579                 for (i = 0; sense_table[i][0] != 0xFF; i++) {
 580                         /* Look for best matches first */
 581                         if ((sense_table[i][0] & drv_err) ==
 582                             sense_table[i][0]) {
 583                                 *sk = sense_table[i][1];
 584                                 *asc = sense_table[i][2];
 585                                 *ascq = sense_table[i][3];
 586                                 goto translate_done;
 587                         }
 588                 }
 589                 /* No immediate match */
 590                 if (verbose)
 591                         printk(KERN_WARNING "ata%u: no sense translation for "
 592                                "error 0x%02x\n", id, drv_err);
 593         }
 594
 595         /* Fall back to interpreting status bits */
 596         for (i = 0; stat_table[i][0] != 0xFF; i++) {
 597                 if (stat_table[i][0] & drv_stat) {
 598                         *sk = stat_table[i][1];
 599                         *asc = stat_table[i][2];
 600                         *ascq = stat_table[i][3];
 601                         goto translate_done;
 602                 }
 603         }
 604         /* No error?  Undecoded? */
 605         if (verbose)
 606                 printk(KERN_WARNING "ata%u: no sense translation for "
 607                        "status: 0x%02x\n", id, drv_stat);
 608
 609         /* We need a sensible error return here, which is tricky, and one
 610            that won't cause people to do things like return a disk wrongly */
 611         *sk = ABORTED_COMMAND;
 612         *asc = 0x00;
 613         *ascq = 0x00;
 614
 615  translate_done:
 616         if (verbose)
 617                 printk(KERN_ERR "ata%u: translated ATA stat/err 0x%02x/%02x "
 618                        "to SCSI SK/ASC/ASCQ 0x%x/%02x/%02x\n",
 619                        id, drv_stat, drv_err, *sk, *asc, *ascq);
 620         return;
 621 }
 622
 623 /*
 624  *      ata_gen_passthru_sense - Generate check condition sense block.
 625  *      @qc: Command that completed.
 626  *
 627  *      This function is specific to the ATA descriptor format sense
 628  *      block specified for the ATA pass through commands.  Regardless
 629  *      of whether the command errored or not, return a sense
 630  *      block. Copy all controller registers into the sense
 631  *      block. Clear sense key, ASC & ASCQ if there is no error.
 632  *
 633  *      LOCKING:
 634  *      None.
 635  */
 636 static void ata_gen_passthru_sense(struct ata_queued_cmd *qc)
 637 {
 638         struct scsi_cmnd *cmd = qc->scsicmd;
 639         struct ata_taskfile *tf = &qc->result_tf;
 640         unsigned char *sb = cmd->sense_buffer;
 641         unsigned char *desc = sb + 8;
 642         int verbose = qc->ap->ops->error_handler == NULL;
 643
 644         memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
 645
 646         cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
 647
 648         /*
 649          * Use ata_to_sense_error() to map status register bits
 650          * onto sense key, asc & ascq.
 651          */
 652         if (qc->err_mask ||
 653             tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
 654                 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
 655                                    &sb[1], &sb[2], &sb[3], verbose);
 656                 sb[1] &= 0x0f;
 657         }
 658
 659         /*
 660          * Sense data is current and format is descriptor.
 661          */
 662         sb[0] = 0x72;
 663
 664         desc[0] = 0x09;
 665
 666         /* set length of additional sense data */
 667         sb[7] = 14;
 668         desc[1] = 12;
 669
 670         /*
 671          * Copy registers into sense buffer.
 672          */
 673         desc[2] = 0x00;
 674         desc[3] = tf->feature;  /* == error reg */
 675         desc[5] = tf->nsect;
 676         desc[7] = tf->lbal;
 677         desc[9] = tf->lbam;
 678         desc[11] = tf->lbah;
 679         desc[12] = tf->device;
 680         desc[13] = tf->command; /* == status reg */
 681
 682         /*
 683          * Fill in Extend bit, and the high order bytes
 684          * if applicable.
 685          */
 686         if (tf->flags & ATA_TFLAG_LBA48) {
 687                 desc[2] |= 0x01;
 688                 desc[4] = tf->hob_nsect;
 689                 desc[6] = tf->hob_lbal;
 690                 desc[8] = tf->hob_lbam;
 691                 desc[10] = tf->hob_lbah;
 692         }
 693 }
 694
 695 /**
 696  *      ata_gen_ata_sense - generate a SCSI fixed sense block
 697  *      @qc: Command that we are erroring out
 698  *
 699  *      Generate sense block for a failed ATA command @qc.  Descriptor
 700  *      format is used to accomodate LBA48 block address.
 701  *
 702  *      LOCKING:
 703  *      None.
 704  */
 705 static void ata_gen_ata_sense(struct ata_queued_cmd *qc)
 706 {
 707         struct ata_device *dev = qc->dev;
 708         struct scsi_cmnd *cmd = qc->scsicmd;
 709         struct ata_taskfile *tf = &qc->result_tf;
 710         unsigned char *sb = cmd->sense_buffer;
 711         unsigned char *desc = sb + 8;
 712         int verbose = qc->ap->ops->error_handler == NULL;
 713         u64 block;
 714
 715         memset(sb, 0, SCSI_SENSE_BUFFERSIZE);
 716
 717         cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
 718
 719         /* sense data is current and format is descriptor */
 720         sb[0] = 0x72;
 721
 722         /* Use ata_to_sense_error() to map status register bits
 723          * onto sense key, asc & ascq.
 724          */
 725         if (qc->err_mask ||
 726             tf->command & (ATA_BUSY | ATA_DF | ATA_ERR | ATA_DRQ)) {
 727                 ata_to_sense_error(qc->ap->print_id, tf->command, tf->feature,
 728                                    &sb[1], &sb[2], &sb[3], verbose);
 729                 sb[1] &= 0x0f;
 730         }
 731
 732         block = ata_tf_read_block(&qc->result_tf, dev);
 733
 734         /* information sense data descriptor */
 735         sb[7] = 12;
 736         desc[0] = 0x00;
 737         desc[1] = 10;
 738
 739         desc[2] |= 0x80;        /* valid */
 740         desc[6] = block >> 40;
 741         desc[7] = block >> 32;
 742         desc[8] = block >> 24;
 743         desc[9] = block >> 16;
 744         desc[10] = block >> 8;
 745         desc[11] = block;
 746 }
 747
 748 static void ata_scsi_sdev_config(struct scsi_device *sdev)
 749 {
 750         sdev->use_10_for_rw = 1;
 751         sdev->use_10_for_ms = 1;
 752
 753         /* Schedule policy is determined by ->qc_defer() callback and
 754          * it needs to see every deferred qc.  Set dev_blocked to 1 to
 755          * prevent SCSI midlayer from automatically deferring
 756          * requests.
 757          */
 758         sdev->max_device_blocked = 1;
 759 }
 760
 761 static void ata_scsi_dev_config(struct scsi_device *sdev,
 762                                 struct ata_device *dev)
 763 {
 764         /* configure max sectors */
 765         blk_queue_max_sectors(sdev->request_queue, dev->max_sectors);
 766
 767         /* SATA DMA transfers must be multiples of 4 byte, so
 768          * we need to pad ATAPI transfers using an extra sg.
 769          * Decrement max hw segments accordingly.
 770          */
 771         if (dev->class == ATA_DEV_ATAPI) {
 772                 struct request_queue *q = sdev->request_queue;
 773                 blk_queue_max_hw_segments(q, q->max_hw_segments - 1);
 774         }
 775
 776         if (dev->flags & ATA_DFLAG_NCQ) {
 777                 int depth;
 778
 779                 depth = min(sdev->host->can_queue, ata_id_queue_depth(dev->id));
 780                 depth = min(ATA_MAX_QUEUE - 1, depth);
 781                 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, depth);
 782         }
 783 }
 784
 785 /**
 786  *      ata_scsi_slave_config - Set SCSI device attributes
 787  *      @sdev: SCSI device to examine
 788  *
 789  *      This is called before we actually start reading
 790  *      and writing to the device, to configure certain
 791  *      SCSI mid-layer behaviors.
 792  *
 793  *      LOCKING:
 794  *      Defined by SCSI layer.  We don't really care.
 795  */
 796
 797 int ata_scsi_slave_config(struct scsi_device *sdev)
 798 {
 799         struct ata_port *ap = ata_shost_to_port(sdev->host);
 800         struct ata_device *dev = __ata_scsi_find_dev(ap, sdev);
 801
 802         ata_scsi_sdev_config(sdev);
 803
 804         sdev->manage_start_stop = 1;
 805
 806         if (dev)
 807                 ata_scsi_dev_config(sdev, dev);
 808
 809         return 0;       /* scsi layer doesn't check return value, sigh */
 810 }
 811
 812 /**
 813  *      ata_scsi_slave_destroy - SCSI device is about to be destroyed
 814  *      @sdev: SCSI device to be destroyed
 815  *
 816  *      @sdev is about to be destroyed for hot/warm unplugging.  If
 817  *      this unplugging was initiated by libata as indicated by NULL
 818  *      dev->sdev, this function doesn't have to do anything.
 819  *      Otherwise, SCSI layer initiated warm-unplug is in progress.
 820  *      Clear dev->sdev, schedule the device for ATA detach and invoke
 821  *      EH.
 822  *
 823  *      LOCKING:
 824  *      Defined by SCSI layer.  We don't really care.
 825  */
 826 void ata_scsi_slave_destroy(struct scsi_device *sdev)
 827 {
 828         struct ata_port *ap = ata_shost_to_port(sdev->host);
 829         unsigned long flags;
 830         struct ata_device *dev;
 831
 832         if (!ap->ops->error_handler)
 833                 return;
 834
 835         spin_lock_irqsave(ap->lock, flags);
 836         dev = __ata_scsi_find_dev(ap, sdev);
 837         if (dev && dev->sdev) {
 838                 /* SCSI device already in CANCEL state, no need to offline it */
 839                 dev->sdev = NULL;
 840                 dev->flags |= ATA_DFLAG_DETACH;
 841                 ata_port_schedule_eh(ap);
 842         }
 843         spin_unlock_irqrestore(ap->lock, flags);
 844 }
 845
 846 /**
 847  *      ata_scsi_change_queue_depth - SCSI callback for queue depth config
 848  *      @sdev: SCSI device to configure queue depth for
 849  *      @queue_depth: new queue depth
 850  *
 851  *      This is libata standard hostt->change_queue_depth callback.
 852  *      SCSI will call into this callback when user tries to set queue
 853  *      depth via sysfs.
 854  *
 855  *      LOCKING:
 856  *      SCSI layer (we don't care)
 857  *
 858  *      RETURNS:
 859  *      Newly configured queue depth.
 860  */
 861 int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 862 {
 863         struct ata_port *ap = ata_shost_to_port(sdev->host);
 864         struct ata_device *dev;
 865         unsigned long flags;
 866
 867         if (queue_depth < 1 || queue_depth == sdev->queue_depth)
 868                 return sdev->queue_depth;
 869
 870         dev = ata_scsi_find_dev(ap, sdev);
 871         if (!dev || !ata_dev_enabled(dev))
 872                 return sdev->queue_depth;
 873
 874         /* NCQ enabled? */
 875         spin_lock_irqsave(ap->lock, flags);
 876         dev->flags &= ~ATA_DFLAG_NCQ_OFF;
 877         if (queue_depth == 1 || !ata_ncq_enabled(dev)) {
 878                 dev->flags |= ATA_DFLAG_NCQ_OFF;
 879                 queue_depth = 1;
 880         }
 881         spin_unlock_irqrestore(ap->lock, flags);
 882
 883         /* limit and apply queue depth */
 884         queue_depth = min(queue_depth, sdev->host->can_queue);
 885         queue_depth = min(queue_depth, ata_id_queue_depth(dev->id));
 886         queue_depth = min(queue_depth, ATA_MAX_QUEUE - 1);
 887
 888         if (sdev->queue_depth == queue_depth)
 889                 return -EINVAL;
 890
 891         scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
 892         return queue_depth;
 893 }
 894
 895 /* XXX: for spindown warning */
 896 static void ata_delayed_done_timerfn(unsigned long arg)
 897 {
 898         struct scsi_cmnd *scmd = (void *)arg;
 899
 900         scmd->scsi_done(scmd);
 901 }
 902
 903 /* XXX: for spindown warning */
 904 static void ata_delayed_done(struct scsi_cmnd *scmd)
 905 {
 906         static struct timer_list timer;
 907
 908         setup_timer(&timer, ata_delayed_done_timerfn, (unsigned long)scmd);
 909         mod_timer(&timer, jiffies + 5 * HZ);
 910 }
 911
 912 /**
 913  *      ata_scsi_start_stop_xlat - Translate SCSI START STOP UNIT command
 914  *      @qc: Storage for translated ATA taskfile
 915  *
 916  *      Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
 917  *      (to start). Perhaps these commands should be preceded by
 918  *      CHECK POWER MODE to see what power mode the device is already in.
 919  *      [See SAT revision 5 at www.t10.org]
 920  *
 921  *      LOCKING:
 922  *      spin_lock_irqsave(host lock)
 923  *
 924  *      RETURNS:
 925  *      Zero on success, non-zero on error.
 926  */
 927 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
 928 {
 929         struct scsi_cmnd *scmd = qc->scsicmd;
 930         struct ata_taskfile *tf = &qc->tf;
 931         const u8 *cdb = scmd->cmnd;
 932
 933         if (scmd->cmd_len < 5)
 934                 goto invalid_fld;
 935
 936         tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
 937         tf->protocol = ATA_PROT_NODATA;
 938         if (cdb[1] & 0x1) {
 939                 ;       /* ignore IMMED bit, violates sat-r05 */
 940         }
 941         if (cdb[4] & 0x2)
 942                 goto invalid_fld;       /* LOEJ bit set not supported */
 943         if (((cdb[4] >> 4) & 0xf) != 0)
 944                 goto invalid_fld;       /* power conditions not supported */
 945
 946         if (qc->dev->horkage & ATA_HORKAGE_SKIP_PM) {
 947                 /* the device lacks PM support, finish without doing anything */
 948                 scmd->result = SAM_STAT_GOOD;
 949                 return 1;
 950         }
 951
 952         if (cdb[4] & 0x1) {
 953                 tf->nsect = 1;  /* 1 sector, lba=0 */
 954
 955                 if (qc->dev->flags & ATA_DFLAG_LBA) {
 956                         tf->flags |= ATA_TFLAG_LBA;
 957
 958                         tf->lbah = 0x0;
 959                         tf->lbam = 0x0;
 960                         tf->lbal = 0x0;
 961                         tf->device |= ATA_LBA;
 962                 } else {
 963                         /* CHS */
 964                         tf->lbal = 0x1; /* sect */
 965                         tf->lbam = 0x0; /* cyl low */
 966                         tf->lbah = 0x0; /* cyl high */
 967                 }
 968
 969                 tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
 970         } else {
 971                 /* XXX: This is for backward compatibility, will be
 972                  * removed.  Read Documentation/feature-removal-schedule.txt
 973                  * for more info.
 974                  */
 975                 if ((qc->dev->flags & ATA_DFLAG_SPUNDOWN) &&
 976                     (system_state == SYSTEM_HALT ||
 977                      system_state == SYSTEM_POWER_OFF)) {
 978                         static unsigned long warned = 0;
 979
 980                         if (!test_and_set_bit(0, &warned)) {
 981                                 ata_dev_printk(qc->dev, KERN_WARNING,
 982                                         "DISK MIGHT NOT BE SPUN DOWN PROPERLY. "
 983                                         "UPDATE SHUTDOWN UTILITY\n");
 984                                 ata_dev_printk(qc->dev, KERN_WARNING,
 985                                         "For more info, visit "
 986                                         "http://linux-ata.org/shutdown.html\n");
 987
 988                                 /* ->scsi_done is not used, use it for
 989                                  * delayed completion.
 990                                  */
 991                                 scmd->scsi_done = qc->scsidone;
 992                                 qc->scsidone = ata_delayed_done;
 993                         }
 994                         scmd->result = SAM_STAT_GOOD;
 995                         return 1;
 996                 }
 997
 998                 /* Issue ATA STANDBY IMMEDIATE command */
 999                 tf->command = ATA_CMD_STANDBYNOW1;
1000         }
1001
1002         /*
1003          * Standby and Idle condition timers could be implemented but that
1004          * would require libata to implement the Power condition mode page
1005          * and allow the user to change it. Changing mode pages requires
1006          * MODE SELECT to be implemented.
1007          */
1008
1009         return 0;
1010
1011 invalid_fld:
1012         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1013         /* "Invalid field in cbd" */
1014         return 1;
1015 }
1016
1017
1018 /**
1019  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1020  *      @qc: Storage for translated ATA taskfile
1021  *
1022  *      Sets up an ATA taskfile to issue FLUSH CACHE or
1023  *      FLUSH CACHE EXT.
1024  *
1025  *      LOCKING:
1026  *      spin_lock_irqsave(host lock)
1027  *
1028  *      RETURNS:
1029  *      Zero on success, non-zero on error.
1030  */
1031 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
1032 {
1033         struct ata_taskfile *tf = &qc->tf;
1034
1035         tf->flags |= ATA_TFLAG_DEVICE;
1036         tf->protocol = ATA_PROT_NODATA;
1037
1038         if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
1039                 tf->command = ATA_CMD_FLUSH_EXT;
1040         else
1041                 tf->command = ATA_CMD_FLUSH;
1042
1043         return 0;
1044 }
1045
1046 /**
1047  *      scsi_6_lba_len - Get LBA and transfer length
1048  *      @cdb: SCSI command to translate
1049  *
1050  *      Calculate LBA and transfer length for 6-byte commands.
1051  *
1052  *      RETURNS:
1053  *      @plba: the LBA
1054  *      @plen: the transfer length
1055  */
1056 static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1057 {
1058         u64 lba = 0;
1059         u32 len;
1060
1061         VPRINTK("six-byte command\n");
1062
1063         lba |= ((u64)(cdb[1] & 0x1f)) << 16;
1064         lba |= ((u64)cdb[2]) << 8;
1065         lba |= ((u64)cdb[3]);
1066
1067         len = cdb[4];
1068
1069         *plba = lba;
1070         *plen = len;
1071 }
1072
1073 /**
1074  *      scsi_10_lba_len - Get LBA and transfer length
1075  *      @cdb: SCSI command to translate
1076  *
1077  *      Calculate LBA and transfer length for 10-byte commands.
1078  *
1079  *      RETURNS:
1080  *      @plba: the LBA
1081  *      @plen: the transfer length
1082  */
1083 static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1084 {
1085         u64 lba = 0;
1086         u32 len = 0;
1087
1088         VPRINTK("ten-byte command\n");
1089
1090         lba |= ((u64)cdb[2]) << 24;
1091         lba |= ((u64)cdb[3]) << 16;
1092         lba |= ((u64)cdb[4]) << 8;
1093         lba |= ((u64)cdb[5]);
1094
1095         len |= ((u32)cdb[7]) << 8;
1096         len |= ((u32)cdb[8]);
1097
1098         *plba = lba;
1099         *plen = len;
1100 }
1101
1102 /**
1103  *      scsi_16_lba_len - Get LBA and transfer length
1104  *      @cdb: SCSI command to translate
1105  *
1106  *      Calculate LBA and transfer length for 16-byte commands.
1107  *
1108  *      RETURNS:
1109  *      @plba: the LBA
1110  *      @plen: the transfer length
1111  */
1112 static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1113 {
1114         u64 lba = 0;
1115         u32 len = 0;
1116
1117         VPRINTK("sixteen-byte command\n");
1118
1119         lba |= ((u64)cdb[2]) << 56;
1120         lba |= ((u64)cdb[3]) << 48;
1121         lba |= ((u64)cdb[4]) << 40;
1122         lba |= ((u64)cdb[5]) << 32;
1123         lba |= ((u64)cdb[6]) << 24;
1124         lba |= ((u64)cdb[7]) << 16;
1125         lba |= ((u64)cdb[8]) << 8;
1126         lba |= ((u64)cdb[9]);
1127
1128         len |= ((u32)cdb[10]) << 24;
1129         len |= ((u32)cdb[11]) << 16;
1130         len |= ((u32)cdb[12]) << 8;
1131         len |= ((u32)cdb[13]);
1132
1133         *plba = lba;
1134         *plen = len;
1135 }
1136
1137 /**
1138  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1139  *      @qc: Storage for translated ATA taskfile
1140  *
1141  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
1142  *
1143  *      LOCKING:
1144  *      spin_lock_irqsave(host lock)
1145  *
1146  *      RETURNS:
1147  *      Zero on success, non-zero on error.
1148  */
1149 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1150 {
1151         struct scsi_cmnd *scmd = qc->scsicmd;
1152         struct ata_taskfile *tf = &qc->tf;
1153         struct ata_device *dev = qc->dev;
1154         u64 dev_sectors = qc->dev->n_sectors;
1155         const u8 *cdb = scmd->cmnd;
1156         u64 block;
1157         u32 n_block;
1158
1159         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1160         tf->protocol = ATA_PROT_NODATA;
1161
1162         if (cdb[0] == VERIFY) {
1163                 if (scmd->cmd_len < 10)
1164                         goto invalid_fld;
1165                 scsi_10_lba_len(cdb, &block, &n_block);
1166         } else if (cdb[0] == VERIFY_16) {
1167                 if (scmd->cmd_len < 16)
1168                         goto invalid_fld;
1169                 scsi_16_lba_len(cdb, &block, &n_block);
1170         } else
1171                 goto invalid_fld;
1172
1173         if (!n_block)
1174                 goto nothing_to_do;
1175         if (block >= dev_sectors)
1176                 goto out_of_range;
1177         if ((block + n_block) > dev_sectors)
1178                 goto out_of_range;
1179
1180         if (dev->flags & ATA_DFLAG_LBA) {
1181                 tf->flags |= ATA_TFLAG_LBA;
1182
1183                 if (lba_28_ok(block, n_block)) {
1184                         /* use LBA28 */
1185                         tf->command = ATA_CMD_VERIFY;
1186                         tf->device |= (block >> 24) & 0xf;
1187                 } else if (lba_48_ok(block, n_block)) {
1188                         if (!(dev->flags & ATA_DFLAG_LBA48))
1189                                 goto out_of_range;
1190
1191                         /* use LBA48 */
1192                         tf->flags |= ATA_TFLAG_LBA48;
1193                         tf->command = ATA_CMD_VERIFY_EXT;
1194
1195                         tf->hob_nsect = (n_block >> 8) & 0xff;
1196
1197                         tf->hob_lbah = (block >> 40) & 0xff;
1198                         tf->hob_lbam = (block >> 32) & 0xff;
1199                         tf->hob_lbal = (block >> 24) & 0xff;
1200                 } else
1201                         /* request too large even for LBA48 */
1202                         goto out_of_range;
1203
1204                 tf->nsect = n_block & 0xff;
1205
1206                 tf->lbah = (block >> 16) & 0xff;
1207                 tf->lbam = (block >> 8) & 0xff;
1208                 tf->lbal = block & 0xff;
1209
1210                 tf->device |= ATA_LBA;
1211         } else {
1212                 /* CHS */
1213                 u32 sect, head, cyl, track;
1214
1215                 if (!lba_28_ok(block, n_block))
1216                         goto out_of_range;
1217
1218                 /* Convert LBA to CHS */
1219                 track = (u32)block / dev->sectors;
1220                 cyl   = track / dev->heads;
1221                 head  = track % dev->heads;
1222                 sect  = (u32)block % dev->sectors + 1;
1223
1224                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1225                         (u32)block, track, cyl, head, sect);
1226
1227                 /* Check whether the converted CHS can fit.
1228                    Cylinder: 0-65535
1229                    Head: 0-15
1230                    Sector: 1-255*/
1231                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
1232                         goto out_of_range;
1233
1234                 tf->command = ATA_CMD_VERIFY;
1235                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1236                 tf->lbal = sect;
1237                 tf->lbam = cyl;
1238                 tf->lbah = cyl >> 8;
1239                 tf->device |= head;
1240         }
1241
1242         return 0;
1243
1244 invalid_fld:
1245         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1246         /* "Invalid field in cbd" */
1247         return 1;
1248
1249 out_of_range:
1250         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1251         /* "Logical Block Address out of range" */
1252         return 1;
1253
1254 nothing_to_do:
1255         scmd->result = SAM_STAT_GOOD;
1256         return 1;
1257 }
1258
1259 /**
1260  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1261  *      @qc: Storage for translated ATA taskfile
1262  *
1263  *      Converts any of six SCSI read/write commands into the
1264  *      ATA counterpart, including starting sector (LBA),
1265  *      sector count, and taking into account the device's LBA48
1266  *      support.
1267  *
1268  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1269  *      %WRITE_16 are currently supported.
1270  *
1271  *      LOCKING:
1272  *      spin_lock_irqsave(host lock)
1273  *
1274  *      RETURNS:
1275  *      Zero on success, non-zero on error.
1276  */
1277 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1278 {
1279         struct scsi_cmnd *scmd = qc->scsicmd;
1280         const u8 *cdb = scmd->cmnd;
1281         unsigned int tf_flags = 0;
1282         u64 block;
1283         u32 n_block;
1284         int rc;
1285
1286         if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
1287                 tf_flags |= ATA_TFLAG_WRITE;
1288
1289         /* Calculate the SCSI LBA, transfer length and FUA. */
1290         switch (cdb[0]) {
1291         case READ_10:
1292         case WRITE_10:
1293                 if (unlikely(scmd->cmd_len < 10))
1294                         goto invalid_fld;
1295                 scsi_10_lba_len(cdb, &block, &n_block);
1296                 if (unlikely(cdb[1] & (1 << 3)))
1297                         tf_flags |= ATA_TFLAG_FUA;
1298                 break;
1299         case READ_6:
1300         case WRITE_6:
1301                 if (unlikely(scmd->cmd_len < 6))
1302                         goto invalid_fld;
1303                 scsi_6_lba_len(cdb, &block, &n_block);
1304
1305                 /* for 6-byte r/w commands, transfer length 0
1306                  * means 256 blocks of data, not 0 block.
1307                  */
1308                 if (!n_block)
1309                         n_block = 256;
1310                 break;
1311         case READ_16:
1312         case WRITE_16:
1313                 if (unlikely(scmd->cmd_len < 16))
1314                         goto invalid_fld;
1315                 scsi_16_lba_len(cdb, &block, &n_block);
1316                 if (unlikely(cdb[1] & (1 << 3)))
1317                         tf_flags |= ATA_TFLAG_FUA;
1318                 break;
1319         default:
1320                 DPRINTK("no-byte command\n");
1321                 goto invalid_fld;
1322         }
1323
1324         /* Check and compose ATA command */
1325         if (!n_block)
1326                 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1327                  * length 0 means transfer 0 block of data.
1328                  * However, for ATA R/W commands, sector count 0 means
1329                  * 256 or 65536 sectors, not 0 sectors as in SCSI.
1330                  *
1331                  * WARNING: one or two older ATA drives treat 0 as 0...
1332                  */
1333                 goto nothing_to_do;
1334
1335         qc->flags |= ATA_QCFLAG_IO;
1336         qc->nbytes = n_block * ATA_SECT_SIZE;
1337
1338         rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1339                              qc->tag);
1340         if (likely(rc == 0))
1341                 return 0;
1342
1343         if (rc == -ERANGE)
1344                 goto out_of_range;
1345         /* treat all other errors as -EINVAL, fall through */
1346 invalid_fld:
1347         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1348         /* "Invalid field in cbd" */
1349         return 1;
1350
1351 out_of_range:
1352         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1353         /* "Logical Block Address out of range" */
1354         return 1;
1355
1356 nothing_to_do:
1357         scmd->result = SAM_STAT_GOOD;
1358         return 1;
1359 }
1360
1361 static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1362 {
1363         struct ata_port *ap = qc->ap;
1364         struct ata_eh_info *ehi = &qc->dev->link->eh_info;
1365         struct scsi_cmnd *cmd = qc->scsicmd;
1366         u8 *cdb = cmd->cmnd;
1367         int need_sense = (qc->err_mask != 0);
1368
1369         /* We snoop the SET_FEATURES - Write Cache ON/OFF command, and
1370          * schedule EH_REVALIDATE operation to update the IDENTIFY DEVICE
1371          * cache
1372          */
1373         if (ap->ops->error_handler && !need_sense) {
1374                 switch (qc->tf.command) {
1375                 case ATA_CMD_SET_FEATURES:
1376                         if ((qc->tf.feature == SETFEATURES_WC_ON) ||
1377                             (qc->tf.feature == SETFEATURES_WC_OFF)) {
1378                                 ehi->action |= ATA_EH_REVALIDATE;
1379                                 ata_port_schedule_eh(ap);
1380                         }
1381                         break;
1382
1383                 case ATA_CMD_INIT_DEV_PARAMS: /* CHS translation changed */
1384                 case ATA_CMD_SET_MULTI: /* multi_count changed */
1385                         ehi->action |= ATA_EH_REVALIDATE;
1386                         ata_port_schedule_eh(ap);
1387                         break;
1388                 }
1389         }
1390
1391         /* For ATA pass thru (SAT) commands, generate a sense block if
1392          * user mandated it or if there's an error.  Note that if we
1393          * generate because the user forced us to, a check condition
1394          * is generated and the ATA register values are returned
1395          * whether the command completed successfully or not. If there
1396          * was no error, SK, ASC and ASCQ will all be zero.
1397          */
1398         if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1399             ((cdb[2] & 0x20) || need_sense)) {
1400                 ata_gen_passthru_sense(qc);
1401         } else {
1402                 if (!need_sense) {
1403                         cmd->result = SAM_STAT_GOOD;
1404                 } else {
1405                         /* TODO: decide which descriptor format to use
1406                          * for 48b LBA devices and call that here
1407                          * instead of the fixed desc, which is only
1408                          * good for smaller LBA (and maybe CHS?)
1409                          * devices.
1410                          */
1411                         ata_gen_ata_sense(qc);
1412                 }
1413         }
1414
1415         /* XXX: track spindown state for spindown skipping and warning */
1416         if (unlikely(qc->tf.command == ATA_CMD_STANDBY ||
1417                      qc->tf.command == ATA_CMD_STANDBYNOW1))
1418                 qc->dev->flags |= ATA_DFLAG_SPUNDOWN;
1419         else if (likely(system_state != SYSTEM_HALT &&
1420                         system_state != SYSTEM_POWER_OFF))
1421                 qc->dev->flags &= ~ATA_DFLAG_SPUNDOWN;
1422
1423         if (need_sense && !ap->ops->error_handler)
1424                 ata_dump_status(ap->print_id, &qc->result_tf);
1425
1426         qc->scsidone(cmd);
1427
1428         ata_qc_free(qc);
1429 }
1430
1431 /**
1432  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
1433  *      @dev: ATA device to which the command is addressed
1434  *      @cmd: SCSI command to execute
1435  *      @done: SCSI command completion function
1436  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
1437  *
1438  *      Our ->queuecommand() function has decided that the SCSI
1439  *      command issued can be directly translated into an ATA
1440  *      command, rather than handled internally.
1441  *
1442  *      This function sets up an ata_queued_cmd structure for the
1443  *      SCSI command, and sends that ata_queued_cmd to the hardware.
1444  *
1445  *      The xlat_func argument (actor) returns 0 if ready to execute
1446  *      ATA command, else 1 to finish translation. If 1 is returned
1447  *      then cmd->result (and possibly cmd->sense_buffer) are assumed
1448  *      to be set reflecting an error condition or clean (early)
1449  *      termination.
1450  *
1451  *      LOCKING:
1452  *      spin_lock_irqsave(host lock)
1453  *
1454  *      RETURNS:
1455  *      0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1456  *      needs to be deferred.
1457  */
1458 static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1459                               void (*done)(struct scsi_cmnd *),
1460                               ata_xlat_func_t xlat_func)
1461 {
1462         struct ata_port *ap = dev->link->ap;
1463         struct ata_queued_cmd *qc;
1464         int rc;
1465
1466         VPRINTK("ENTER\n");
1467
1468         qc = ata_scsi_qc_new(dev, cmd, done);
1469         if (!qc)
1470                 goto err_mem;
1471
1472         /* data is present; dma-map it */
1473         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1474             cmd->sc_data_direction == DMA_TO_DEVICE) {
1475                 if (unlikely(scsi_bufflen(cmd) < 1)) {
1476                         ata_dev_printk(dev, KERN_WARNING,
1477                                        "WARNING: zero len r/w req\n");
1478                         goto err_did;
1479                 }
1480
1481                 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
1482
1483                 qc->dma_dir = cmd->sc_data_direction;
1484         }
1485
1486         qc->complete_fn = ata_scsi_qc_complete;
1487
1488         if (xlat_func(qc))
1489                 goto early_finish;
1490
1491         if (ap->ops->qc_defer) {
1492                 if ((rc = ap->ops->qc_defer(qc)))
1493                         goto defer;
1494         }
1495
1496         /* select device, send command to hardware */
1497         ata_qc_issue(qc);
1498
1499         VPRINTK("EXIT\n");
1500         return 0;
1501
1502 early_finish:
1503         ata_qc_free(qc);
1504         qc->scsidone(cmd);
1505         DPRINTK("EXIT - early finish (good or error)\n");
1506         return 0;
1507
1508 err_did:
1509         ata_qc_free(qc);
1510         cmd->result = (DID_ERROR << 16);
1511         qc->scsidone(cmd);
1512 err_mem:
1513         DPRINTK("EXIT - internal\n");
1514         return 0;
1515
1516 defer:
1517         ata_qc_free(qc);
1518         DPRINTK("EXIT - defer\n");
1519         if (rc == ATA_DEFER_LINK)
1520                 return SCSI_MLQUEUE_DEVICE_BUSY;
1521         else
1522                 return SCSI_MLQUEUE_HOST_BUSY;
1523 }
1524
1525 /**
1526  *      ata_scsi_rbuf_get - Map response buffer.
1527  *      @cmd: SCSI command containing buffer to be mapped.
1528  *      @buf_out: Pointer to mapped area.
1529  *
1530  *      Maps buffer contained within SCSI command @cmd.
1531  *
1532  *      LOCKING:
1533  *      spin_lock_irqsave(host lock)
1534  *
1535  *      RETURNS:
1536  *      Length of response buffer.
1537  */
1538
1539 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1540 {
1541         u8 *buf;
1542         unsigned int buflen;
1543
1544         struct scatterlist *sg = scsi_sglist(cmd);
1545
1546         if (sg) {
1547                 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1548                 buflen = sg->length;
1549         } else {
1550                 buf = NULL;
1551                 buflen = 0;
1552         }
1553
1554         *buf_out = buf;
1555         return buflen;
1556 }
1557
1558 /**
1559  *      ata_scsi_rbuf_put - Unmap response buffer.
1560  *      @cmd: SCSI command containing buffer to be unmapped.
1561  *      @buf: buffer to unmap
1562  *
1563  *      Unmaps response buffer contained within @cmd.
1564  *
1565  *      LOCKING:
1566  *      spin_lock_irqsave(host lock)
1567  */
1568
1569 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1570 {
1571         struct scatterlist *sg = scsi_sglist(cmd);
1572         if (sg)
1573                 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1574 }
1575
1576 /**
1577  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1578  *      @args: device IDENTIFY data / SCSI command of interest.
1579  *      @actor: Callback hook for desired SCSI command simulator
1580  *
1581  *      Takes care of the hard work of simulating a SCSI command...
1582  *      Mapping the response buffer, calling the command's handler,
1583  *      and handling the handler's return value.  This return value
1584  *      indicates whether the handler wishes the SCSI command to be
1585  *      completed successfully (0), or not (in which case cmd->result
1586  *      and sense buffer are assumed to be set).
1587  *
1588  *      LOCKING:
1589  *      spin_lock_irqsave(host lock)
1590  */
1591
1592 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1593                         unsigned int (*actor) (struct ata_scsi_args *args,
1594                                            u8 *rbuf, unsigned int buflen))
1595 {
1596         u8 *rbuf;
1597         unsigned int buflen, rc;
1598         struct scsi_cmnd *cmd = args->cmd;
1599
1600         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1601         memset(rbuf, 0, buflen);
1602         rc = actor(args, rbuf, buflen);
1603         ata_scsi_rbuf_put(cmd, rbuf);
1604
1605         if (rc == 0)
1606                 cmd->result = SAM_STAT_GOOD;
1607         args->done(cmd);
1608 }
1609
1610 /**
1611  *      ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
1612  *      @idx: byte index into SCSI response buffer
1613  *      @val: value to set
1614  *
1615  *      To be used by SCSI command simulator functions.  This macros
1616  *      expects two local variables, u8 *rbuf and unsigned int buflen,
1617  *      are in scope.
1618  *
1619  *      LOCKING:
1620  *      None.
1621  */
1622 #define ATA_SCSI_RBUF_SET(idx, val) do { \
1623                 if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
1624         } while (0)
1625
1626 /**
1627  *      ata_scsiop_inq_std - Simulate INQUIRY command
1628  *      @args: device IDENTIFY data / SCSI command of interest.
1629  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1630  *      @buflen: Response buffer length.
1631  *
1632  *      Returns standard device identification data associated
1633  *      with non-VPD INQUIRY command output.
1634  *
1635  *      LOCKING:
1636  *      spin_lock_irqsave(host lock)
1637  */
1638
1639 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1640                                unsigned int buflen)
1641 {
1642         u8 hdr[] = {
1643                 TYPE_DISK,
1644                 0,
1645                 0x5,    /* claim SPC-3 version compatibility */
1646                 2,
1647                 95 - 4
1648         };
1649
1650         /* set scsi removeable (RMB) bit per ata bit */
1651         if (ata_id_removeable(args->id))
1652                 hdr[1] |= (1 << 7);
1653
1654         VPRINTK("ENTER\n");
1655
1656         memcpy(rbuf, hdr, sizeof(hdr));
1657
1658         if (buflen > 35) {
1659                 memcpy(&rbuf[8], "ATA     ", 8);
1660                 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
1661                 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
1662                 if (rbuf[32] == 0 || rbuf[32] == ' ')
1663                         memcpy(&rbuf[32], "n/a ", 4);
1664         }
1665
1666         if (buflen > 63) {
1667                 const u8 versions[] = {
1668                         0x60,   /* SAM-3 (no version claimed) */
1669
1670                         0x03,
1671                         0x20,   /* SBC-2 (no version claimed) */
1672
1673                         0x02,
1674                         0x60    /* SPC-3 (no version claimed) */
1675                 };
1676
1677                 memcpy(rbuf + 59, versions, sizeof(versions));
1678         }
1679
1680         return 0;
1681 }
1682
1683 /**
1684  *      ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
1685  *      @args: device IDENTIFY data / SCSI command of interest.
1686  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1687  *      @buflen: Response buffer length.
1688  *
1689  *      Returns list of inquiry VPD pages available.
1690  *
1691  *      LOCKING:
1692  *      spin_lock_irqsave(host lock)
1693  */
1694
1695 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1696                               unsigned int buflen)
1697 {
1698         const u8 pages[] = {
1699                 0x00,   /* page 0x00, this page */
1700                 0x80,   /* page 0x80, unit serial no page */
1701                 0x83    /* page 0x83, device ident page */
1702         };
1703         rbuf[3] = sizeof(pages);        /* number of supported VPD pages */
1704
1705         if (buflen > 6)
1706                 memcpy(rbuf + 4, pages, sizeof(pages));
1707
1708         return 0;
1709 }
1710
1711 /**
1712  *      ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
1713  *      @args: device IDENTIFY data / SCSI command of interest.
1714  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1715  *      @buflen: Response buffer length.
1716  *
1717  *      Returns ATA device serial number.
1718  *
1719  *      LOCKING:
1720  *      spin_lock_irqsave(host lock)
1721  */
1722
1723 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1724                               unsigned int buflen)
1725 {
1726         const u8 hdr[] = {
1727                 0,
1728                 0x80,                   /* this page code */
1729                 0,
1730                 ATA_ID_SERNO_LEN,       /* page len */
1731         };
1732         memcpy(rbuf, hdr, sizeof(hdr));
1733
1734         if (buflen > (ATA_ID_SERNO_LEN + 4 - 1))
1735                 ata_id_string(args->id, (unsigned char *) &rbuf[4],
1736                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1737
1738         return 0;
1739 }
1740
1741 /**
1742  *      ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
1743  *      @args: device IDENTIFY data / SCSI command of interest.
1744  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1745  *      @buflen: Response buffer length.
1746  *
1747  *      Yields two logical unit device identification designators:
1748  *       - vendor specific ASCII containing the ATA serial number
1749  *       - SAT defined "t10 vendor id based" containing ASCII vendor
1750  *         name ("ATA     "), model and serial numbers.
1751  *
1752  *      LOCKING:
1753  *      spin_lock_irqsave(host lock)
1754  */
1755
1756 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1757                               unsigned int buflen)
1758 {
1759         int num;
1760         const int sat_model_serial_desc_len = 68;
1761
1762         rbuf[1] = 0x83;                 /* this page code */
1763         num = 4;
1764
1765         if (buflen > (ATA_ID_SERNO_LEN + num + 3)) {
1766                 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
1767                 rbuf[num + 0] = 2;
1768                 rbuf[num + 3] = ATA_ID_SERNO_LEN;
1769                 num += 4;
1770                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1771                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1772                 num += ATA_ID_SERNO_LEN;
1773         }
1774         if (buflen > (sat_model_serial_desc_len + num + 3)) {
1775                 /* SAT defined lu model and serial numbers descriptor */
1776                 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
1777                 rbuf[num + 0] = 2;
1778                 rbuf[num + 1] = 1;
1779                 rbuf[num + 3] = sat_model_serial_desc_len;
1780                 num += 4;
1781                 memcpy(rbuf + num, "ATA     ", 8);
1782                 num += 8;
1783                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1784                               ATA_ID_PROD, ATA_ID_PROD_LEN);
1785                 num += ATA_ID_PROD_LEN;
1786                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1787                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1788                 num += ATA_ID_SERNO_LEN;
1789         }
1790         rbuf[3] = num - 4;    /* page len (assume less than 256 bytes) */
1791         return 0;
1792 }
1793
1794 /**
1795  *      ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
1796  *      @args: device IDENTIFY data / SCSI command of interest.
1797  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1798  *      @buflen: Response buffer length.
1799  *
1800  *      Yields SAT-specified ATA VPD page.
1801  *
1802  *      LOCKING:
1803  *      spin_lock_irqsave(host lock)
1804  */
1805
1806 unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
1807                               unsigned int buflen)
1808 {
1809         u8 pbuf[60];
1810         struct ata_taskfile tf;
1811         unsigned int i;
1812
1813         if (!buflen)
1814                 return 0;
1815
1816         memset(&pbuf, 0, sizeof(pbuf));
1817         memset(&tf, 0, sizeof(tf));
1818
1819         pbuf[1] = 0x89;                 /* our page code */
1820         pbuf[2] = (0x238 >> 8);         /* page size fixed at 238h */
1821         pbuf[3] = (0x238 & 0xff);
1822
1823         memcpy(&pbuf[8], "linux   ", 8);
1824         memcpy(&pbuf[16], "libata          ", 16);
1825         memcpy(&pbuf[32], DRV_VERSION, 4);
1826         ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
1827
1828         /* we don't store the ATA device signature, so we fake it */
1829
1830         tf.command = ATA_DRDY;          /* really, this is Status reg */
1831         tf.lbal = 0x1;
1832         tf.nsect = 0x1;
1833
1834         ata_tf_to_fis(&tf, 0, 1, &pbuf[36]);    /* TODO: PMP? */
1835         pbuf[36] = 0x34;                /* force D2H Reg FIS (34h) */
1836
1837         pbuf[56] = ATA_CMD_ID_ATA;
1838
1839         i = min(buflen, 60U);
1840         memcpy(rbuf, &pbuf[0], i);
1841         buflen -= i;
1842
1843         if (!buflen)
1844                 return 0;
1845
1846         memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
1847         return 0;
1848 }
1849
1850 /**
1851  *      ata_scsiop_noop - Command handler that simply returns success.
1852  *      @args: device IDENTIFY data / SCSI command of interest.
1853  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1854  *      @buflen: Response buffer length.
1855  *
1856  *      No operation.  Simply returns success to caller, to indicate
1857  *      that the caller should successfully complete this SCSI command.
1858  *
1859  *      LOCKING:
1860  *      spin_lock_irqsave(host lock)
1861  */
1862
1863 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1864                             unsigned int buflen)
1865 {
1866         VPRINTK("ENTER\n");
1867         return 0;
1868 }
1869
1870 /**
1871  *      ata_msense_push - Push data onto MODE SENSE data output buffer
1872  *      @ptr_io: (input/output) Location to store more output data
1873  *      @last: End of output data buffer
1874  *      @buf: Pointer to BLOB being added to output buffer
1875  *      @buflen: Length of BLOB
1876  *
1877  *      Store MODE SENSE data on an output buffer.
1878  *
1879  *      LOCKING:
1880  *      None.
1881  */
1882
1883 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1884                             const u8 *buf, unsigned int buflen)
1885 {
1886         u8 *ptr = *ptr_io;
1887
1888         if ((ptr + buflen - 1) > last)
1889                 return;
1890
1891         memcpy(ptr, buf, buflen);
1892
1893         ptr += buflen;
1894
1895         *ptr_io = ptr;
1896 }
1897
1898 /**
1899  *      ata_msense_caching - Simulate MODE SENSE caching info page
1900  *      @id: device IDENTIFY data
1901  *      @ptr_io: (input/output) Location to store more output data
1902  *      @last: End of output data buffer
1903  *
1904  *      Generate a caching info page, which conditionally indicates
1905  *      write caching to the SCSI layer, depending on device
1906  *      capabilities.
1907  *
1908  *      LOCKING:
1909  *      None.
1910  */
1911
1912 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1913                                        const u8 *last)
1914 {
1915         u8 page[CACHE_MPAGE_LEN];
1916
1917         memcpy(page, def_cache_mpage, sizeof(page));
1918         if (ata_id_wcache_enabled(id))
1919                 page[2] |= (1 << 2);    /* write cache enable */
1920         if (!ata_id_rahead_enabled(id))
1921                 page[12] |= (1 << 5);   /* disable read ahead */
1922
1923         ata_msense_push(ptr_io, last, page, sizeof(page));
1924         return sizeof(page);
1925 }
1926
1927 /**
1928  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1929  *      @dev: Device associated with this MODE SENSE command
1930  *      @ptr_io: (input/output) Location to store more output data
1931  *      @last: End of output data buffer
1932  *
1933  *      Generate a generic MODE SENSE control mode page.
1934  *
1935  *      LOCKING:
1936  *      None.
1937  */
1938
1939 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1940 {
1941         ata_msense_push(ptr_io, last, def_control_mpage,
1942                         sizeof(def_control_mpage));
1943         return sizeof(def_control_mpage);
1944 }
1945
1946 /**
1947  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1948  *      @dev: Device associated with this MODE SENSE command
1949  *      @ptr_io: (input/output) Location to store more output data
1950  *      @last: End of output data buffer
1951  *
1952  *      Generate a generic MODE SENSE r/w error recovery page.
1953  *
1954  *      LOCKING:
1955  *      None.
1956  */
1957
1958 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1959 {
1960
1961         ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
1962                         sizeof(def_rw_recovery_mpage));
1963         return sizeof(def_rw_recovery_mpage);
1964 }
1965
1966 /*
1967  * We can turn this into a real blacklist if it's needed, for now just
1968  * blacklist any Maxtor BANC1G10 revision firmware
1969  */
1970 static int ata_dev_supports_fua(u16 *id)
1971 {
1972         unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
1973
1974         if (!libata_fua)
1975                 return 0;
1976         if (!ata_id_has_fua(id))
1977                 return 0;
1978
1979         ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
1980         ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
1981
1982         if (strcmp(model, "Maxtor"))
1983                 return 1;
1984         if (strcmp(fw, "BANC1G10"))
1985                 return 1;
1986
1987         return 0; /* blacklisted */
1988 }
1989
1990 /**
1991  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1992  *      @args: device IDENTIFY data / SCSI command of interest.
1993  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1994  *      @buflen: Response buffer length.
1995  *
1996  *      Simulate MODE SENSE commands. Assume this is invoked for direct
1997  *      access devices (e.g. disks) only. There should be no block
1998  *      descriptor for other device types.
1999  *
2000  *      LOCKING:
2001  *      spin_lock_irqsave(host lock)
2002  */
2003
2004 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
2005                                   unsigned int buflen)
2006 {
2007         struct ata_device *dev = args->dev;
2008         u8 *scsicmd = args->cmd->cmnd, *p, *last;
2009         const u8 sat_blk_desc[] = {
2010                 0, 0, 0, 0,     /* number of blocks: sat unspecified */
2011                 0,
2012                 0, 0x2, 0x0     /* block length: 512 bytes */
2013         };
2014         u8 pg, spg;
2015         unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
2016         u8 dpofua;
2017
2018         VPRINTK("ENTER\n");
2019
2020         six_byte = (scsicmd[0] == MODE_SENSE);
2021         ebd = !(scsicmd[1] & 0x8);      /* dbd bit inverted == edb */
2022         /*
2023          * LLBA bit in msense(10) ignored (compliant)
2024          */
2025
2026         page_control = scsicmd[2] >> 6;
2027         switch (page_control) {
2028         case 0: /* current */
2029                 break;  /* supported */
2030         case 3: /* saved */
2031                 goto saving_not_supp;
2032         case 1: /* changeable */
2033         case 2: /* defaults */
2034         default:
2035                 goto invalid_fld;
2036         }
2037
2038         if (six_byte) {
2039                 output_len = 4 + (ebd ? 8 : 0);
2040                 alloc_len = scsicmd[4];
2041         } else {
2042                 output_len = 8 + (ebd ? 8 : 0);
2043                 alloc_len = (scsicmd[7] << 8) + scsicmd[8];
2044         }
2045         minlen = (alloc_len < buflen) ? alloc_len : buflen;
2046
2047         p = rbuf + output_len;
2048         last = rbuf + minlen - 1;
2049
2050         pg = scsicmd[2] & 0x3f;
2051         spg = scsicmd[3];
2052         /*
2053          * No mode subpages supported (yet) but asking for _all_
2054          * subpages may be valid
2055          */
2056         if (spg && (spg != ALL_SUB_MPAGES))
2057                 goto invalid_fld;
2058
2059         switch(pg) {
2060         case RW_RECOVERY_MPAGE:
2061                 output_len += ata_msense_rw_recovery(&p, last);
2062                 break;
2063
2064         case CACHE_MPAGE:
2065                 output_len += ata_msense_caching(args->id, &p, last);
2066                 break;
2067
2068         case CONTROL_MPAGE: {
2069                 output_len += ata_msense_ctl_mode(&p, last);
2070                 break;
2071                 }
2072
2073         case ALL_MPAGES:
2074                 output_len += ata_msense_rw_recovery(&p, last);
2075                 output_len += ata_msense_caching(args->id, &p, last);
2076                 output_len += ata_msense_ctl_mode(&p, last);
2077                 break;
2078
2079         default:                /* invalid page code */
2080                 goto invalid_fld;
2081         }
2082
2083         if (minlen < 1)
2084                 return 0;
2085
2086         dpofua = 0;
2087         if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
2088             (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2089                 dpofua = 1 << 4;
2090
2091         if (six_byte) {
2092                 output_len--;
2093                 rbuf[0] = output_len;
2094                 if (minlen > 2)
2095                         rbuf[2] |= dpofua;
2096                 if (ebd) {
2097                         if (minlen > 3)
2098                                 rbuf[3] = sizeof(sat_blk_desc);
2099                         if (minlen > 11)
2100                                 memcpy(rbuf + 4, sat_blk_desc,
2101                                        sizeof(sat_blk_desc));
2102                 }
2103         } else {
2104                 output_len -= 2;
2105                 rbuf[0] = output_len >> 8;
2106                 if (minlen > 1)
2107                         rbuf[1] = output_len;
2108                 if (minlen > 3)
2109                         rbuf[3] |= dpofua;
2110                 if (ebd) {
2111                         if (minlen > 7)
2112                                 rbuf[7] = sizeof(sat_blk_desc);
2113                         if (minlen > 15)
2114                                 memcpy(rbuf + 8, sat_blk_desc,
2115                                        sizeof(sat_blk_desc));
2116                 }
2117         }
2118         return 0;
2119
2120 invalid_fld:
2121         ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2122         /* "Invalid field in cbd" */
2123         return 1;
2124
2125 saving_not_supp:
2126         ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2127          /* "Saving parameters not supported" */
2128         return 1;
2129 }
2130
2131 /**
2132  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2133  *      @args: device IDENTIFY data / SCSI command of interest.
2134  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2135  *      @buflen: Response buffer length.
2136  *
2137  *      Simulate READ CAPACITY commands.
2138  *
2139  *      LOCKING:
2140  *      None.
2141  */
2142 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
2143                                 unsigned int buflen)
2144 {
2145         u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
2146
2147         VPRINTK("ENTER\n");
2148
2149         if (args->cmd->cmnd[0] == READ_CAPACITY) {
2150                 if (last_lba >= 0xffffffffULL)
2151                         last_lba = 0xffffffff;
2152
2153                 /* sector count, 32-bit */
2154                 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
2155                 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
2156                 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
2157                 ATA_SCSI_RBUF_SET(3, last_lba);
2158
2159                 /* sector size */
2160                 ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
2161                 ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
2162         } else {
2163                 /* sector count, 64-bit */
2164                 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
2165                 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
2166                 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
2167                 ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
2168                 ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
2169                 ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
2170                 ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
2171                 ATA_SCSI_RBUF_SET(7, last_lba);
2172
2173                 /* sector size */
2174                 ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
2175                 ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
2176         }
2177
2178         return 0;
2179 }
2180
2181 /**
2182  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
2183  *      @args: device IDENTIFY data / SCSI command of interest.
2184  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2185  *      @buflen: Response buffer length.
2186  *
2187  *      Simulate REPORT LUNS command.
2188  *
2189  *      LOCKING:
2190  *      spin_lock_irqsave(host lock)
2191  */
2192
2193 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
2194                                    unsigned int buflen)
2195 {
2196         VPRINTK("ENTER\n");
2197         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
2198
2199         return 0;
2200 }
2201
2202 /**
2203  *      ata_scsi_set_sense - Set SCSI sense data and status
2204  *      @cmd: SCSI request to be handled
2205  *      @sk: SCSI-defined sense key
2206  *      @asc: SCSI-defined additional sense code
2207  *      @ascq: SCSI-defined additional sense code qualifier
2208  *
2209  *      Helper function that builds a valid fixed format, current
2210  *      response code and the given sense key (sk), additional sense
2211  *      code (asc) and additional sense code qualifier (ascq) with
2212  *      a SCSI command status of %SAM_STAT_CHECK_CONDITION and
2213  *      DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
2214  *
2215  *      LOCKING:
2216  *      Not required
2217  */
2218
2219 void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
2220 {
2221         cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2222
2223         cmd->sense_buffer[0] = 0x70;    /* fixed format, current */
2224         cmd->sense_buffer[2] = sk;
2225         cmd->sense_buffer[7] = 18 - 8;  /* additional sense length */
2226         cmd->sense_buffer[12] = asc;
2227         cmd->sense_buffer[13] = ascq;
2228 }
2229
2230 /**
2231  *      ata_scsi_badcmd - End a SCSI request with an error
2232  *      @cmd: SCSI request to be handled
2233  *      @done: SCSI command completion function
2234  *      @asc: SCSI-defined additional sense code
2235  *      @ascq: SCSI-defined additional sense code qualifier
2236  *
2237  *      Helper function that completes a SCSI command with
2238  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
2239  *      and the specified additional sense codes.
2240  *
2241  *      LOCKING:
2242  *      spin_lock_irqsave(host lock)
2243  */
2244
2245 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
2246 {
2247         DPRINTK("ENTER\n");
2248         ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
2249
2250         done(cmd);
2251 }
2252
2253 static void atapi_sense_complete(struct ata_queued_cmd *qc)
2254 {
2255         if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
2256                 /* FIXME: not quite right; we don't want the
2257                  * translation of taskfile registers into
2258                  * a sense descriptors, since that's only
2259                  * correct for ATA, not ATAPI
2260                  */
2261                 ata_gen_passthru_sense(qc);
2262         }
2263
2264         qc->scsidone(qc->scsicmd);
2265         ata_qc_free(qc);
2266 }
2267
2268 /* is it pointless to prefer PIO for "safety reasons"? */
2269 static inline int ata_pio_use_silly(struct ata_port *ap)
2270 {
2271         return (ap->flags & ATA_FLAG_PIO_DMA);
2272 }
2273
2274 static void atapi_request_sense(struct ata_queued_cmd *qc)
2275 {
2276         struct ata_port *ap = qc->ap;
2277         struct scsi_cmnd *cmd = qc->scsicmd;
2278
2279         DPRINTK("ATAPI request sense\n");
2280
2281         /* FIXME: is this needed? */
2282         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2283
2284         ap->ops->tf_read(ap, &qc->tf);
2285
2286         /* fill these in, for the case where they are -not- overwritten */
2287         cmd->sense_buffer[0] = 0x70;
2288         cmd->sense_buffer[2] = qc->tf.feature >> 4;
2289
2290         ata_qc_reinit(qc);
2291
2292         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2293         qc->dma_dir = DMA_FROM_DEVICE;
2294
2295         memset(&qc->cdb, 0, qc->dev->cdb_len);
2296         qc->cdb[0] = REQUEST_SENSE;
2297         qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2298
2299         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2300         qc->tf.command = ATA_CMD_PACKET;
2301
2302         if (ata_pio_use_silly(ap)) {
2303                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2304                 qc->tf.feature |= ATAPI_PKT_DMA;
2305         } else {
2306                 qc->tf.protocol = ATA_PROT_ATAPI;
2307                 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2308                 qc->tf.lbah = 0;
2309         }
2310         qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2311
2312         qc->complete_fn = atapi_sense_complete;
2313
2314         ata_qc_issue(qc);
2315
2316         DPRINTK("EXIT\n");
2317 }
2318
2319 static void atapi_qc_complete(struct ata_queued_cmd *qc)
2320 {
2321         struct scsi_cmnd *cmd = qc->scsicmd;
2322         unsigned int err_mask = qc->err_mask;
2323
2324         VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
2325
2326         /* handle completion from new EH */
2327         if (unlikely(qc->ap->ops->error_handler &&
2328                      (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2329
2330                 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2331                         /* FIXME: not quite right; we don't want the
2332                          * translation of taskfile registers into a
2333                          * sense descriptors, since that's only
2334                          * correct for ATA, not ATAPI
2335                          */
2336                         ata_gen_passthru_sense(qc);
2337                 }
2338
2339                 /* SCSI EH automatically locks door if sdev->locked is
2340                  * set.  Sometimes door lock request continues to
2341                  * fail, for example, when no media is present.  This
2342                  * creates a loop - SCSI EH issues door lock which
2343                  * fails and gets invoked again to acquire sense data
2344                  * for the failed command.
2345                  *
2346                  * If door lock fails, always clear sdev->locked to
2347                  * avoid this infinite loop.
2348                  */
2349                 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
2350                         qc->dev->sdev->locked = 0;
2351
2352                 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2353                 qc->scsidone(cmd);
2354                 ata_qc_free(qc);
2355                 return;
2356         }
2357
2358         /* successful completion or old EH failure path */
2359         if (unlikely(err_mask & AC_ERR_DEV)) {
2360                 cmd->result = SAM_STAT_CHECK_CONDITION;
2361                 atapi_request_sense(qc);
2362                 return;
2363         } else if (unlikely(err_mask)) {
2364                 /* FIXME: not quite right; we don't want the
2365                  * translation of taskfile registers into
2366                  * a sense descriptors, since that's only
2367                  * correct for ATA, not ATAPI
2368                  */
2369                 ata_gen_passthru_sense(qc);
2370         } else {
2371                 u8 *scsicmd = cmd->cmnd;
2372
2373                 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
2374                         u8 *buf = NULL;
2375                         unsigned int buflen;
2376
2377                         buflen = ata_scsi_rbuf_get(cmd, &buf);
2378
2379         /* ATAPI devices typically report zero for their SCSI version,
2380          * and sometimes deviate from the spec WRT response data
2381          * format.  If SCSI version is reported as zero like normal,
2382          * then we make the following fixups:  1) Fake MMC-5 version,
2383          * to indicate to the Linux scsi midlayer this is a modern
2384          * device.  2) Ensure response data format / ATAPI information
2385          * are always correct.
2386          */
2387                         if (buf[2] == 0) {
2388                                 buf[2] = 0x5;
2389                                 buf[3] = 0x32;
2390                         }
2391
2392                         ata_scsi_rbuf_put(cmd, buf);
2393                 }
2394
2395                 cmd->result = SAM_STAT_GOOD;
2396         }
2397
2398         qc->scsidone(cmd);
2399         ata_qc_free(qc);
2400 }
2401 /**
2402  *      atapi_xlat - Initialize PACKET taskfile
2403  *      @qc: command structure to be initialized
2404  *
2405  *      LOCKING:
2406  *      spin_lock_irqsave(host lock)
2407  *
2408  *      RETURNS:
2409  *      Zero on success, non-zero on failure.
2410  */
2411 static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
2412 {
2413         struct scsi_cmnd *scmd = qc->scsicmd;
2414         struct ata_device *dev = qc->dev;
2415         int using_pio = (dev->flags & ATA_DFLAG_PIO);
2416         int nodata = (scmd->sc_data_direction == DMA_NONE);
2417         unsigned int nbytes;
2418
2419         memset(qc->cdb, 0, dev->cdb_len);
2420         memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
2421
2422         qc->complete_fn = atapi_qc_complete;
2423
2424         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2425         if (scmd->sc_data_direction == DMA_TO_DEVICE) {
2426                 qc->tf.flags |= ATA_TFLAG_WRITE;
2427                 DPRINTK("direction: write\n");
2428         }
2429
2430         qc->tf.command = ATA_CMD_PACKET;
2431         qc->nbytes = scsi_bufflen(scmd);
2432
2433         /* check whether ATAPI DMA is safe */
2434         if (!using_pio && ata_check_atapi_dma(qc))
2435                 using_pio = 1;
2436
2437         /* Some controller variants snoop this value for Packet transfers
2438            to do state machine and FIFO management. Thus we want to set it
2439            properly, and for DMA where it is effectively meaningless */
2440         nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
2441
2442         qc->tf.lbam = (nbytes & 0xFF);
2443         qc->tf.lbah = (nbytes >> 8);
2444
2445         if (using_pio || nodata) {
2446                 /* no data, or PIO data xfer */
2447                 if (nodata)
2448                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
2449                 else
2450                         qc->tf.protocol = ATA_PROT_ATAPI;
2451         } else {
2452                 /* DMA data xfer */
2453                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2454                 qc->tf.feature |= ATAPI_PKT_DMA;
2455
2456                 if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
2457                         /* some SATA bridges need us to indicate data xfer direction */
2458                         qc->tf.feature |= ATAPI_DMADIR;
2459         }
2460
2461
2462         /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2463            as ATAPI tape drives don't get this right otherwise */
2464         return 0;
2465 }
2466
2467 static struct ata_device * ata_find_dev(struct ata_port *ap, int devno)
2468 {
2469         if (ap->nr_pmp_links == 0) {
2470                 if (likely(devno < ata_link_max_devices(&ap->link)))
2471                         return &ap->link.device[devno];
2472         } else {
2473                 if (likely(devno < ap->nr_pmp_links))
2474                         return &ap->pmp_link[devno].device[0];
2475         }
2476
2477         return NULL;
2478 }
2479
2480 static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
2481                                         const struct scsi_device *scsidev)
2482 {
2483         int devno;
2484
2485         /* skip commands not addressed to targets we simulate */
2486         if (ap->nr_pmp_links == 0) {
2487                 if (unlikely(scsidev->channel || scsidev->lun))
2488                         return NULL;
2489                 devno = scsidev->id;
2490         } else {
2491                 if (unlikely(scsidev->id || scsidev->lun))
2492                         return NULL;
2493                 devno = scsidev->channel;
2494         }
2495
2496         return ata_find_dev(ap, devno);
2497 }
2498
2499 /**
2500  *      ata_scsi_dev_enabled - determine if device is enabled
2501  *      @dev: ATA device
2502  *
2503  *      Determine if commands should be sent to the specified device.
2504  *
2505  *      LOCKING:
2506  *      spin_lock_irqsave(host lock)
2507  *
2508  *      RETURNS:
2509  *      0 if commands are not allowed / 1 if commands are allowed
2510  */
2511
2512 static int ata_scsi_dev_enabled(struct ata_device *dev)
2513 {
2514         if (unlikely(!ata_dev_enabled(dev)))
2515                 return 0;
2516
2517         if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
2518                 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
2519                         ata_dev_printk(dev, KERN_WARNING,
2520                                        "WARNING: ATAPI is %s, device ignored.\n",
2521                                        atapi_enabled ? "not supported with this driver" : "disabled");
2522                         return 0;
2523                 }
2524         }
2525
2526         return 1;
2527 }
2528
2529 /**
2530  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2531  *      @ap: ATA port to which the device is attached
2532  *      @scsidev: SCSI device from which we derive the ATA device
2533  *
2534  *      Given various information provided in struct scsi_cmnd,
2535  *      map that onto an ATA bus, and using that mapping
2536  *      determine which ata_device is associated with the
2537  *      SCSI command to be sent.
2538  *
2539  *      LOCKING:
2540  *      spin_lock_irqsave(host lock)
2541  *
2542  *      RETURNS:
2543  *      Associated ATA device, or %NULL if not found.
2544  */
2545 static struct ata_device *
2546 ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
2547 {
2548         struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
2549
2550         if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
2551                 return NULL;
2552
2553         return dev;
2554 }
2555
2556 /*
2557  *      ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2558  *      @byte1: Byte 1 from pass-thru CDB.
2559  *
2560  *      RETURNS:
2561  *      ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2562  */
2563 static u8
2564 ata_scsi_map_proto(u8 byte1)
2565 {
2566         switch((byte1 & 0x1e) >> 1) {
2567                 case 3:         /* Non-data */
2568                         return ATA_PROT_NODATA;
2569
2570                 case 6:         /* DMA */
2571                 case 10:        /* UDMA Data-in */
2572                 case 11:        /* UDMA Data-Out */
2573                         return ATA_PROT_DMA;
2574
2575                 case 4:         /* PIO Data-in */
2576                 case 5:         /* PIO Data-out */
2577                         return ATA_PROT_PIO;
2578
2579                 case 0:         /* Hard Reset */
2580                 case 1:         /* SRST */
2581                 case 8:         /* Device Diagnostic */
2582                 case 9:         /* Device Reset */
2583                 case 7:         /* DMA Queued */
2584                 case 12:        /* FPDMA */
2585                 case 15:        /* Return Response Info */
2586                 default:        /* Reserved */
2587                         break;
2588         }
2589
2590         return ATA_PROT_UNKNOWN;
2591 }
2592
2593 /**
2594  *      ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2595  *      @qc: command structure to be initialized
2596  *
2597  *      Handles either 12 or 16-byte versions of the CDB.
2598  *
2599  *      RETURNS:
2600  *      Zero on success, non-zero on failure.
2601  */
2602 static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
2603 {
2604         struct ata_taskfile *tf = &(qc->tf);
2605         struct scsi_cmnd *scmd = qc->scsicmd;
2606         struct ata_device *dev = qc->dev;
2607         const u8 *cdb = scmd->cmnd;
2608
2609         if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
2610                 goto invalid_fld;
2611
2612         /* We may not issue DMA commands if no DMA mode is set */
2613         if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
2614                 goto invalid_fld;
2615
2616         /*
2617          * 12 and 16 byte CDBs use different offsets to
2618          * provide the various register values.
2619          */
2620         if (cdb[0] == ATA_16) {
2621                 /*
2622                  * 16-byte CDB - may contain extended commands.
2623                  *
2624                  * If that is the case, copy the upper byte register values.
2625                  */
2626                 if (cdb[1] & 0x01) {
2627                         tf->hob_feature = cdb[3];
2628                         tf->hob_nsect = cdb[5];
2629                         tf->hob_lbal = cdb[7];
2630                         tf->hob_lbam = cdb[9];
2631                         tf->hob_lbah = cdb[11];
2632                         tf->flags |= ATA_TFLAG_LBA48;
2633                 } else
2634                         tf->flags &= ~ATA_TFLAG_LBA48;
2635
2636                 /*
2637                  * Always copy low byte, device and command registers.
2638                  */
2639                 tf->feature = cdb[4];
2640                 tf->nsect = cdb[6];
2641                 tf->lbal = cdb[8];
2642                 tf->lbam = cdb[10];
2643                 tf->lbah = cdb[12];
2644                 tf->device = cdb[13];
2645                 tf->command = cdb[14];
2646         } else {
2647                 /*
2648                  * 12-byte CDB - incapable of extended commands.
2649                  */
2650                 tf->flags &= ~ATA_TFLAG_LBA48;
2651
2652                 tf->feature = cdb[3];
2653                 tf->nsect = cdb[4];
2654                 tf->lbal = cdb[5];
2655                 tf->lbam = cdb[6];
2656                 tf->lbah = cdb[7];
2657                 tf->device = cdb[8];
2658                 tf->command = cdb[9];
2659         }
2660
2661         /* enforce correct master/slave bit */
2662         tf->device = dev->devno ?
2663                 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
2664
2665         /* sanity check for pio multi commands */
2666         if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
2667                 goto invalid_fld;
2668
2669         if (is_multi_taskfile(tf)) {
2670                 unsigned int multi_count = 1 << (cdb[1] >> 5);
2671
2672                 /* compare the passed through multi_count
2673                  * with the cached multi_count of libata
2674                  */
2675                 if (multi_count != dev->multi_count)
2676                         ata_dev_printk(dev, KERN_WARNING,
2677                                        "invalid multi_count %u ignored\n",
2678                                        multi_count);
2679         }
2680
2681         /* READ/WRITE LONG use a non-standard sect_size */
2682         qc->sect_size = ATA_SECT_SIZE;
2683         switch (tf->command) {
2684         case ATA_CMD_READ_LONG:
2685         case ATA_CMD_READ_LONG_ONCE:
2686         case ATA_CMD_WRITE_LONG:
2687         case ATA_CMD_WRITE_LONG_ONCE:
2688                 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
2689                         goto invalid_fld;
2690                 qc->sect_size = scsi_bufflen(scmd);
2691         }
2692
2693         /*
2694          * Filter SET_FEATURES - XFER MODE command -- otherwise,
2695          * SET_FEATURES - XFER MODE must be preceded/succeeded
2696          * by an update to hardware-specific registers for each
2697          * controller (i.e. the reason for ->set_piomode(),
2698          * ->set_dmamode(), and ->post_set_mode() hooks).
2699          */
2700         if ((tf->command == ATA_CMD_SET_FEATURES)
2701          && (tf->feature == SETFEATURES_XFER))
2702                 goto invalid_fld;
2703
2704         /*
2705          * Set flags so that all registers will be written,
2706          * and pass on write indication (used for PIO/DMA
2707          * setup.)
2708          */
2709         tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
2710
2711         if (scmd->sc_data_direction == DMA_TO_DEVICE)
2712                 tf->flags |= ATA_TFLAG_WRITE;
2713
2714         /*
2715          * Set transfer length.
2716          *
2717          * TODO: find out if we need to do more here to
2718          *       cover scatter/gather case.
2719          */
2720         qc->nbytes = scsi_bufflen(scmd);
2721
2722         /* request result TF */
2723         qc->flags |= ATA_QCFLAG_RESULT_TF;
2724
2725         return 0;
2726
2727  invalid_fld:
2728         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
2729         /* "Invalid field in cdb" */
2730         return 1;
2731 }
2732
2733 /**
2734  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
2735  *      @dev: ATA device
2736  *      @cmd: SCSI command opcode to consider
2737  *
2738  *      Look up the SCSI command given, and determine whether the
2739  *      SCSI command is to be translated or simulated.
2740  *
2741  *      RETURNS:
2742  *      Pointer to translation function if possible, %NULL if not.
2743  */
2744
2745 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
2746 {
2747         switch (cmd) {
2748         case READ_6:
2749         case READ_10:
2750         case READ_16:
2751
2752         case WRITE_6:
2753         case WRITE_10:
2754         case WRITE_16:
2755                 return ata_scsi_rw_xlat;
2756
2757         case SYNCHRONIZE_CACHE:
2758                 if (ata_try_flush_cache(dev))
2759                         return ata_scsi_flush_xlat;
2760                 break;
2761
2762         case VERIFY:
2763         case VERIFY_16:
2764                 return ata_scsi_verify_xlat;
2765
2766         case ATA_12:
2767         case ATA_16:
2768                 return ata_scsi_pass_thru;
2769
2770         case START_STOP:
2771                 return ata_scsi_start_stop_xlat;
2772         }
2773
2774         return NULL;
2775 }
2776
2777 /**
2778  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
2779  *      @ap: ATA port to which the command was being sent
2780  *      @cmd: SCSI command to dump
2781  *
2782  *      Prints the contents of a SCSI command via printk().
2783  */
2784
2785 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
2786                                      struct scsi_cmnd *cmd)
2787 {
2788 #ifdef ATA_DEBUG
2789         struct scsi_device *scsidev = cmd->device;
2790         u8 *scsicmd = cmd->cmnd;
2791
2792         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
2793                 ap->print_id,
2794                 scsidev->channel, scsidev->id, scsidev->lun,
2795                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
2796                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
2797                 scsicmd[8]);
2798 #endif
2799 }
2800
2801 static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
2802                                       void (*done)(struct scsi_cmnd *),
2803                                       struct ata_device *dev)
2804 {
2805         u8 scsi_op = scmd->cmnd[0];
2806         ata_xlat_func_t xlat_func;
2807         int rc = 0;
2808
2809         if (dev->class == ATA_DEV_ATA) {
2810                 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
2811                         goto bad_cdb_len;
2812
2813                 xlat_func = ata_get_xlat_func(dev, scsi_op);
2814         } else {
2815                 if (unlikely(!scmd->cmd_len))
2816                         goto bad_cdb_len;
2817
2818                 xlat_func = NULL;
2819                 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
2820                         /* relay SCSI command to ATAPI device */
2821                         if (unlikely(scmd->cmd_len > dev->cdb_len))
2822                                 goto bad_cdb_len;
2823
2824                         xlat_func = atapi_xlat;
2825                 } else {
2826                         /* ATA_16 passthru, treat as an ATA command */
2827                         if (unlikely(scmd->cmd_len > 16))
2828                                 goto bad_cdb_len;
2829
2830                         xlat_func = ata_get_xlat_func(dev, scsi_op);
2831                 }
2832         }
2833
2834         if (xlat_func)
2835                 rc = ata_scsi_translate(dev, scmd, done, xlat_func);
2836         else
2837                 ata_scsi_simulate(dev, scmd, done);
2838
2839         return rc;
2840
2841  bad_cdb_len:
2842         DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
2843                 scmd->cmd_len, scsi_op, dev->cdb_len);
2844         scmd->result = DID_ERROR << 16;
2845         done(scmd);
2846         return 0;
2847 }
2848
2849 /**
2850  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
2851  *      @cmd: SCSI command to be sent
2852  *      @done: Completion function, called when command is complete
2853  *
2854  *      In some cases, this function translates SCSI commands into
2855  *      ATA taskfiles, and queues the taskfiles to be sent to
2856  *      hardware.  In other cases, this function simulates a
2857  *      SCSI device by evaluating and responding to certain
2858  *      SCSI commands.  This creates the overall effect of
2859  *      ATA and ATAPI devices appearing as SCSI devices.
2860  *
2861  *      LOCKING:
2862  *      Releases scsi-layer-held lock, and obtains host lock.
2863  *
2864  *      RETURNS:
2865  *      Return value from __ata_scsi_queuecmd() if @cmd can be queued,
2866  *      0 otherwise.
2867  */
2868 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
2869 {
2870         struct ata_port *ap;
2871         struct ata_device *dev;
2872         struct scsi_device *scsidev = cmd->device;
2873         struct Scsi_Host *shost = scsidev->host;
2874         int rc = 0;
2875
2876         ap = ata_shost_to_port(shost);
2877
2878         spin_unlock(shost->host_lock);
2879         spin_lock(ap->lock);
2880
2881         ata_scsi_dump_cdb(ap, cmd);
2882
2883         dev = ata_scsi_find_dev(ap, scsidev);
2884         if (likely(dev))
2885                 rc = __ata_scsi_queuecmd(cmd, done, dev);
2886         else {
2887                 cmd->result = (DID_BAD_TARGET << 16);
2888                 done(cmd);
2889         }
2890
2891         spin_unlock(ap->lock);
2892         spin_lock(shost->host_lock);
2893         return rc;
2894 }
2895
2896 /**
2897  *      ata_scsi_simulate - simulate SCSI command on ATA device
2898  *      @dev: the target device
2899  *      @cmd: SCSI command being sent to device.
2900  *      @done: SCSI command completion function.
2901  *
2902  *      Interprets and directly executes a select list of SCSI commands
2903  *      that can be handled internally.
2904  *
2905  *      LOCKING:
2906  *      spin_lock_irqsave(host lock)
2907  */
2908
2909 void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
2910                       void (*done)(struct scsi_cmnd *))
2911 {
2912         struct ata_scsi_args args;
2913         const u8 *scsicmd = cmd->cmnd;
2914         u8 tmp8;
2915
2916         args.dev = dev;
2917         args.id = dev->id;
2918         args.cmd = cmd;
2919         args.done = done;
2920
2921         switch(scsicmd[0]) {
2922                 /* TODO: worth improving? */
2923                 case FORMAT_UNIT:
2924                         ata_scsi_invalid_field(cmd, done);
2925                         break;
2926
2927                 case INQUIRY:
2928                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
2929                                 ata_scsi_invalid_field(cmd, done);
2930                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
2931                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2932                         else switch (scsicmd[2]) {
2933                         case 0x00:
2934                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2935                                 break;
2936                         case 0x80:
2937                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2938                                 break;
2939                         case 0x83:
2940                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2941                                 break;
2942                         case 0x89:
2943                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
2944                                 break;
2945                         default:
2946                                 ata_scsi_invalid_field(cmd, done);
2947                                 break;
2948                         }
2949                         break;
2950
2951                 case MODE_SENSE:
2952                 case MODE_SENSE_10:
2953                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
2954                         break;
2955
2956                 case MODE_SELECT:       /* unconditionally return */
2957                 case MODE_SELECT_10:    /* bad-field-in-cdb */
2958                         ata_scsi_invalid_field(cmd, done);
2959                         break;
2960
2961                 case READ_CAPACITY:
2962                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2963                         break;
2964
2965                 case SERVICE_ACTION_IN:
2966                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
2967                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2968                         else
2969                                 ata_scsi_invalid_field(cmd, done);
2970                         break;
2971
2972                 case REPORT_LUNS:
2973                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
2974                         break;
2975
2976                 case REQUEST_SENSE:
2977                         ata_scsi_set_sense(cmd, 0, 0, 0);
2978                         cmd->result = (DRIVER_SENSE << 24);
2979                         done(cmd);
2980                         break;
2981
2982                 /* if we reach this, then writeback caching is disabled,
2983                  * turning this into a no-op.
2984                  */
2985                 case SYNCHRONIZE_CACHE:
2986                         /* fall through */
2987
2988                 /* no-op's, complete with success */
2989                 case REZERO_UNIT:
2990                 case SEEK_6:
2991                 case SEEK_10:
2992                 case TEST_UNIT_READY:
2993                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
2994                         break;
2995
2996                 case SEND_DIAGNOSTIC:
2997                         tmp8 = scsicmd[1] & ~(1 << 3);
2998                         if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
2999                                 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3000                         else
3001                                 ata_scsi_invalid_field(cmd, done);
3002                         break;
3003
3004                 /* all other commands */
3005                 default:
3006                         ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
3007                         /* "Invalid command operation code" */
3008                         done(cmd);
3009                         break;
3010         }
3011 }
3012
3013 int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
3014 {
3015         int i, rc;
3016
3017         for (i = 0; i < host->n_ports; i++) {
3018                 struct ata_port *ap = host->ports[i];
3019                 struct Scsi_Host *shost;
3020
3021                 rc = -ENOMEM;
3022                 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
3023                 if (!shost)
3024                         goto err_alloc;
3025
3026                 *(struct ata_port **)&shost->hostdata[0] = ap;
3027                 ap->scsi_host = shost;
3028
3029                 shost->transportt = &ata_scsi_transport_template;
3030                 shost->unique_id = ap->print_id;
3031                 shost->max_id = 16;
3032                 shost->max_lun = 1;
3033                 shost->max_channel = 1;
3034                 shost->max_cmd_len = 16;
3035
3036                 /* Schedule policy is determined by ->qc_defer()
3037                  * callback and it needs to see every deferred qc.
3038                  * Set host_blocked to 1 to prevent SCSI midlayer from
3039                  * automatically deferring requests.
3040                  */
3041                 shost->max_host_blocked = 1;
3042
3043                 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
3044                 if (rc)
3045                         goto err_add;
3046         }
3047
3048         return 0;
3049
3050  err_add:
3051         scsi_host_put(host->ports[i]->scsi_host);
3052  err_alloc:
3053         while (--i >= 0) {
3054                 struct Scsi_Host *shost = host->ports[i]->scsi_host;
3055
3056                 scsi_remove_host(shost);
3057                 scsi_host_put(shost);
3058         }
3059         return rc;
3060 }
3061
3062 void ata_scsi_scan_host(struct ata_port *ap, int sync)
3063 {
3064         int tries = 5;
3065         struct ata_device *last_failed_dev = NULL;
3066         struct ata_link *link;
3067         struct ata_device *dev;
3068
3069         if (ap->flags & ATA_FLAG_DISABLED)
3070                 return;
3071
3072  repeat:
3073         ata_port_for_each_link(link, ap) {
3074                 ata_link_for_each_dev(dev, link) {
3075                         struct scsi_device *sdev;
3076                         int channel = 0, id = 0;
3077
3078                         if (!ata_dev_enabled(dev) || dev->sdev)
3079                                 continue;
3080
3081                         if (ata_is_host_link(link))
3082                                 id = dev->devno;
3083                         else
3084                                 channel = link->pmp;
3085
3086                         sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
3087                                                  NULL);
3088                         if (!IS_ERR(sdev)) {
3089                                 dev->sdev = sdev;
3090                                 scsi_device_put(sdev);
3091                         }
3092                 }
3093         }
3094
3095         /* If we scanned while EH was in progress or allocation
3096          * failure occurred, scan would have failed silently.  Check
3097          * whether all devices are attached.
3098          */
3099         ata_port_for_each_link(link, ap) {
3100                 ata_link_for_each_dev(dev, link) {
3101                         if (ata_dev_enabled(dev) && !dev->sdev)
3102                                 goto exit_loop;
3103                 }
3104         }
3105  exit_loop:
3106         if (!link)
3107                 return;
3108
3109         /* we're missing some SCSI devices */
3110         if (sync) {
3111                 /* If caller requested synchrnous scan && we've made
3112                  * any progress, sleep briefly and repeat.
3113                  */
3114                 if (dev != last_failed_dev) {
3115                         msleep(100);
3116                         last_failed_dev = dev;
3117                         goto repeat;
3118                 }
3119
3120                 /* We might be failing to detect boot device, give it
3121                  * a few more chances.
3122                  */
3123                 if (--tries) {
3124                         msleep(100);
3125                         goto repeat;
3126                 }
3127
3128                 ata_port_printk(ap, KERN_ERR, "WARNING: synchronous SCSI scan "
3129                                 "failed without making any progress,\n"
3130                                 "                  switching to async\n");
3131         }
3132
3133         queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
3134                            round_jiffies_relative(HZ));
3135 }
3136
3137 /**
3138  *      ata_scsi_offline_dev - offline attached SCSI device
3139  *      @dev: ATA device to offline attached SCSI device for
3140  *
3141  *      This function is called from ata_eh_hotplug() and responsible
3142  *      for taking the SCSI device attached to @dev offline.  This
3143  *      function is called with host lock which protects dev->sdev
3144  *      against clearing.
3145  *
3146  *      LOCKING:
3147  *      spin_lock_irqsave(host lock)
3148  *
3149  *      RETURNS:
3150  *      1 if attached SCSI device exists, 0 otherwise.
3151  */
3152 int ata_scsi_offline_dev(struct ata_device *dev)
3153 {
3154         if (dev->sdev) {
3155                 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
3156                 return 1;
3157         }
3158         return 0;
3159 }
3160
3161 /**
3162  *      ata_scsi_remove_dev - remove attached SCSI device
3163  *      @dev: ATA device to remove attached SCSI device for
3164  *
3165  *      This function is called from ata_eh_scsi_hotplug() and
3166  *      responsible for removing the SCSI device attached to @dev.
3167  *
3168  *      LOCKING:
3169  *      Kernel thread context (may sleep).
3170  */
3171 static void ata_scsi_remove_dev(struct ata_device *dev)
3172 {
3173         struct ata_port *ap = dev->link->ap;
3174         struct scsi_device *sdev;
3175         unsigned long flags;
3176
3177         /* Alas, we need to grab scan_mutex to ensure SCSI device
3178          * state doesn't change underneath us and thus
3179          * scsi_device_get() always succeeds.  The mutex locking can
3180          * be removed if there is __scsi_device_get() interface which
3181          * increments reference counts regardless of device state.
3182          */
3183         mutex_lock(&ap->scsi_host->scan_mutex);
3184         spin_lock_irqsave(ap->lock, flags);
3185
3186         /* clearing dev->sdev is protected by host lock */
3187         sdev = dev->sdev;
3188         dev->sdev = NULL;
3189
3190         if (sdev) {
3191                 /* If user initiated unplug races with us, sdev can go
3192                  * away underneath us after the host lock and
3193                  * scan_mutex are released.  Hold onto it.
3194                  */
3195                 if (scsi_device_get(sdev) == 0) {
3196                         /* The following ensures the attached sdev is
3197                          * offline on return from ata_scsi_offline_dev()
3198                          * regardless it wins or loses the race
3199                          * against this function.
3200                          */
3201                         scsi_device_set_state(sdev, SDEV_OFFLINE);
3202                 } else {
3203                         WARN_ON(1);
3204                         sdev = NULL;
3205                 }
3206         }
3207
3208         spin_unlock_irqrestore(ap->lock, flags);
3209         mutex_unlock(&ap->scsi_host->scan_mutex);
3210
3211         if (sdev) {
3212                 ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
3213                                sdev->sdev_gendev.bus_id);
3214
3215                 scsi_remove_device(sdev);
3216                 scsi_device_put(sdev);
3217         }
3218 }
3219
3220 static void ata_scsi_handle_link_detach(struct ata_link *link)
3221 {
3222         struct ata_port *ap = link->ap;
3223         struct ata_device *dev;
3224
3225         ata_link_for_each_dev(dev, link) {
3226                 unsigned long flags;
3227
3228                 if (!(dev->flags & ATA_DFLAG_DETACHED))
3229                         continue;
3230
3231                 spin_lock_irqsave(ap->lock, flags);
3232                 dev->flags &= ~ATA_DFLAG_DETACHED;
3233                 spin_unlock_irqrestore(ap->lock, flags);
3234
3235                 ata_scsi_remove_dev(dev);
3236         }
3237 }
3238
3239 /**
3240  *      ata_scsi_media_change_notify - send media change event
3241  *      @dev: Pointer to the disk device with media change event
3242  *
3243  *      Tell the block layer to send a media change notification
3244  *      event.
3245  *
3246  *      LOCKING:
3247  *      spin_lock_irqsave(host lock)
3248  */
3249 void ata_scsi_media_change_notify(struct ata_device *dev)
3250 {
3251 #ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
3252         if (dev->sdev)
3253                 scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
3254 #endif
3255 }
3256
3257 /**
3258  *      ata_scsi_hotplug - SCSI part of hotplug
3259  *      @work: Pointer to ATA port to perform SCSI hotplug on
3260  *
3261  *      Perform SCSI part of hotplug.  It's executed from a separate
3262  *      workqueue after EH completes.  This is necessary because SCSI
3263  *      hot plugging requires working EH and hot unplugging is
3264  *      synchronized with hot plugging with a mutex.
3265  *
3266  *      LOCKING:
3267  *      Kernel thread context (may sleep).
3268  */
3269 void ata_scsi_hotplug(struct work_struct *work)
3270 {
3271         struct ata_port *ap =
3272                 container_of(work, struct ata_port, hotplug_task.work);
3273         int i;
3274
3275         if (ap->pflags & ATA_PFLAG_UNLOADING) {
3276                 DPRINTK("ENTER/EXIT - unloading\n");
3277                 return;
3278         }
3279
3280         DPRINTK("ENTER\n");
3281
3282         /* Unplug detached devices.  We cannot use link iterator here
3283          * because PMP links have to be scanned even if PMP is
3284          * currently not attached.  Iterate manually.
3285          */
3286         ata_scsi_handle_link_detach(&ap->link);
3287         if (ap->pmp_link)
3288                 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
3289                         ata_scsi_handle_link_detach(&ap->pmp_link[i]);
3290
3291         /* scan for new ones */
3292         ata_scsi_scan_host(ap, 0);
3293
3294         DPRINTK("EXIT\n");
3295 }
3296
3297 /**
3298  *      ata_scsi_user_scan - indication for user-initiated bus scan
3299  *      @shost: SCSI host to scan
3300  *      @channel: Channel to scan
3301  *      @id: ID to scan
3302  *      @lun: LUN to scan
3303  *
3304  *      This function is called when user explicitly requests bus
3305  *      scan.  Set probe pending flag and invoke EH.
3306  *
3307  *      LOCKING:
3308  *      SCSI layer (we don't care)
3309  *
3310  *      RETURNS:
3311  *      Zero.
3312  */
3313 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
3314                               unsigned int id, unsigned int lun)
3315 {
3316         struct ata_port *ap = ata_shost_to_port(shost);
3317         unsigned long flags;
3318         int devno, rc = 0;
3319
3320         if (!ap->ops->error_handler)
3321                 return -EOPNOTSUPP;
3322
3323         if (lun != SCAN_WILD_CARD && lun)
3324                 return -EINVAL;
3325
3326         if (ap->nr_pmp_links == 0) {
3327                 if (channel != SCAN_WILD_CARD && channel)
3328                         return -EINVAL;
3329                 devno = id;
3330         } else {
3331                 if (id != SCAN_WILD_CARD && id)
3332                         return -EINVAL;
3333                 devno = channel;
3334         }
3335
3336         spin_lock_irqsave(ap->lock, flags);
3337
3338         if (devno == SCAN_WILD_CARD) {
3339                 struct ata_link *link;
3340
3341                 ata_port_for_each_link(link, ap) {
3342                         struct ata_eh_info *ehi = &link->eh_info;
3343                         ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
3344                         ehi->action |= ATA_EH_SOFTRESET;
3345                 }
3346         } else {
3347                 struct ata_device *dev = ata_find_dev(ap, devno);
3348
3349                 if (dev) {
3350                         struct ata_eh_info *ehi = &dev->link->eh_info;
3351                         ehi->probe_mask |= 1 << dev->devno;
3352                         ehi->action |= ATA_EH_SOFTRESET;
3353                         ehi->flags |= ATA_EHI_RESUME_LINK;
3354                 } else
3355                         rc = -EINVAL;
3356         }
3357
3358         if (rc == 0) {
3359                 ata_port_schedule_eh(ap);
3360                 spin_unlock_irqrestore(ap->lock, flags);
3361                 ata_port_wait_eh(ap);
3362         } else
3363                 spin_unlock_irqrestore(ap->lock, flags);
3364
3365         return rc;
3366 }
3367
3368 /**
3369  *      ata_scsi_dev_rescan - initiate scsi_rescan_device()
3370  *      @work: Pointer to ATA port to perform scsi_rescan_device()
3371  *
3372  *      After ATA pass thru (SAT) commands are executed successfully,
3373  *      libata need to propagate the changes to SCSI layer.  This
3374  *      function must be executed from ata_aux_wq such that sdev
3375  *      attach/detach don't race with rescan.
3376  *
3377  *      LOCKING:
3378  *      Kernel thread context (may sleep).
3379  */
3380 void ata_scsi_dev_rescan(struct work_struct *work)
3381 {
3382         struct ata_port *ap =
3383                 container_of(work, struct ata_port, scsi_rescan_task);
3384         struct ata_link *link;
3385         struct ata_device *dev;
3386         unsigned long flags;
3387
3388         spin_lock_irqsave(ap->lock, flags);
3389
3390         ata_port_for_each_link(link, ap) {
3391                 ata_link_for_each_dev(dev, link) {
3392                         struct scsi_device *sdev = dev->sdev;
3393
3394                         if (!ata_dev_enabled(dev) || !sdev)
3395                                 continue;
3396                         if (scsi_device_get(sdev))
3397                                 continue;
3398
3399                         spin_unlock_irqrestore(ap->lock, flags);
3400                         scsi_rescan_device(&(sdev->sdev_gendev));
3401                         scsi_device_put(sdev);
3402                         spin_lock_irqsave(ap->lock, flags);
3403                 }
3404         }
3405
3406         spin_unlock_irqrestore(ap->lock, flags);
3407 }
3408
3409 /**
3410  *      ata_sas_port_alloc - Allocate port for a SAS attached SATA device
3411  *      @host: ATA host container for all SAS ports
3412  *      @port_info: Information from low-level host driver
3413  *      @shost: SCSI host that the scsi device is attached to
3414  *
3415  *      LOCKING:
3416  *      PCI/etc. bus probe sem.
3417  *
3418  *      RETURNS:
3419  *      ata_port pointer on success / NULL on failure.
3420  */
3421
3422 struct ata_port *ata_sas_port_alloc(struct ata_host *host,
3423                                     struct ata_port_info *port_info,
3424                                     struct Scsi_Host *shost)
3425 {
3426         struct ata_port *ap;
3427
3428         ap = ata_port_alloc(host);
3429         if (!ap)
3430                 return NULL;
3431
3432         ap->port_no = 0;
3433         ap->lock = shost->host_lock;
3434         ap->pio_mask = port_info->pio_mask;
3435         ap->mwdma_mask = port_info->mwdma_mask;
3436         ap->udma_mask = port_info->udma_mask;
3437         ap->flags |= port_info->flags;
3438         ap->ops = port_info->port_ops;
3439         ap->cbl = ATA_CBL_SATA;
3440
3441         return ap;
3442 }
3443 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
3444
3445 /**
3446  *      ata_sas_port_start - Set port up for dma.
3447  *      @ap: Port to initialize
3448  *
3449  *      Called just after data structures for each port are
3450  *      initialized.  Allocates DMA pad.
3451  *
3452  *      May be used as the port_start() entry in ata_port_operations.
3453  *
3454  *      LOCKING:
3455  *      Inherited from caller.
3456  */
3457 int ata_sas_port_start(struct ata_port *ap)
3458 {
3459         return ata_pad_alloc(ap, ap->dev);
3460 }
3461 EXPORT_SYMBOL_GPL(ata_sas_port_start);
3462
3463 /**
3464  *      ata_port_stop - Undo ata_sas_port_start()
3465  *      @ap: Port to shut down
3466  *
3467  *      Frees the DMA pad.
3468  *
3469  *      May be used as the port_stop() entry in ata_port_operations.
3470  *
3471  *      LOCKING:
3472  *      Inherited from caller.
3473  */
3474
3475 void ata_sas_port_stop(struct ata_port *ap)
3476 {
3477         ata_pad_free(ap, ap->dev);
3478 }
3479 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
3480
3481 /**
3482  *      ata_sas_port_init - Initialize a SATA device
3483  *      @ap: SATA port to initialize
3484  *
3485  *      LOCKING:
3486  *      PCI/etc. bus probe sem.
3487  *
3488  *      RETURNS:
3489  *      Zero on success, non-zero on error.
3490  */
3491
3492 int ata_sas_port_init(struct ata_port *ap)
3493 {
3494         int rc = ap->ops->port_start(ap);
3495
3496         if (!rc) {
3497                 ap->print_id = ata_print_id++;
3498                 rc = ata_bus_probe(ap);
3499         }
3500
3501         return rc;
3502 }
3503 EXPORT_SYMBOL_GPL(ata_sas_port_init);
3504
3505 /**
3506  *      ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
3507  *      @ap: SATA port to destroy
3508  *
3509  */
3510
3511 void ata_sas_port_destroy(struct ata_port *ap)
3512 {
3513         if (ap->ops->port_stop)
3514                 ap->ops->port_stop(ap);
3515         kfree(ap);
3516 }
3517 EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
3518
3519 /**
3520  *      ata_sas_slave_configure - Default slave_config routine for libata devices
3521  *      @sdev: SCSI device to configure
3522  *      @ap: ATA port to which SCSI device is attached
3523  *
3524  *      RETURNS:
3525  *      Zero.
3526  */
3527
3528 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
3529 {
3530         ata_scsi_sdev_config(sdev);
3531         ata_scsi_dev_config(sdev, ap->link.device);
3532         return 0;
3533 }
3534 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
3535
3536 /**
3537  *      ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
3538  *      @cmd: SCSI command to be sent
3539  *      @done: Completion function, called when command is complete
3540  *      @ap:    ATA port to which the command is being sent
3541  *
3542  *      RETURNS:
3543  *      Return value from __ata_scsi_queuecmd() if @cmd can be queued,
3544  *      0 otherwise.
3545  */
3546
3547 int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
3548                      struct ata_port *ap)
3549 {
3550         int rc = 0;
3551
3552         ata_scsi_dump_cdb(ap, cmd);
3553
3554         if (likely(ata_scsi_dev_enabled(ap->link.device)))
3555                 rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
3556         else {
3557                 cmd->result = (DID_BAD_TARGET << 16);
3558                 done(cmd);
3559         }
3560         return rc;
3561 }
3562 EXPORT_SYMBOL_GPL(ata_sas_queuecmd);