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