[libata] Link power management infrastructure
[linux-2.6.git] / 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         return 0;
1112 }
1113
1114 /**
1115  *      scsi_6_lba_len - Get LBA and transfer length
1116  *      @cdb: SCSI command to translate
1117  *
1118  *      Calculate LBA and transfer length for 6-byte commands.
1119  *
1120  *      RETURNS:
1121  *      @plba: the LBA
1122  *      @plen: the transfer length
1123  */
1124 static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1125 {
1126         u64 lba = 0;
1127         u32 len;
1128
1129         VPRINTK("six-byte command\n");
1130
1131         lba |= ((u64)(cdb[1] & 0x1f)) << 16;
1132         lba |= ((u64)cdb[2]) << 8;
1133         lba |= ((u64)cdb[3]);
1134
1135         len = cdb[4];
1136
1137         *plba = lba;
1138         *plen = len;
1139 }
1140
1141 /**
1142  *      scsi_10_lba_len - Get LBA and transfer length
1143  *      @cdb: SCSI command to translate
1144  *
1145  *      Calculate LBA and transfer length for 10-byte commands.
1146  *
1147  *      RETURNS:
1148  *      @plba: the LBA
1149  *      @plen: the transfer length
1150  */
1151 static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1152 {
1153         u64 lba = 0;
1154         u32 len = 0;
1155
1156         VPRINTK("ten-byte command\n");
1157
1158         lba |= ((u64)cdb[2]) << 24;
1159         lba |= ((u64)cdb[3]) << 16;
1160         lba |= ((u64)cdb[4]) << 8;
1161         lba |= ((u64)cdb[5]);
1162
1163         len |= ((u32)cdb[7]) << 8;
1164         len |= ((u32)cdb[8]);
1165
1166         *plba = lba;
1167         *plen = len;
1168 }
1169
1170 /**
1171  *      scsi_16_lba_len - Get LBA and transfer length
1172  *      @cdb: SCSI command to translate
1173  *
1174  *      Calculate LBA and transfer length for 16-byte commands.
1175  *
1176  *      RETURNS:
1177  *      @plba: the LBA
1178  *      @plen: the transfer length
1179  */
1180 static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
1181 {
1182         u64 lba = 0;
1183         u32 len = 0;
1184
1185         VPRINTK("sixteen-byte command\n");
1186
1187         lba |= ((u64)cdb[2]) << 56;
1188         lba |= ((u64)cdb[3]) << 48;
1189         lba |= ((u64)cdb[4]) << 40;
1190         lba |= ((u64)cdb[5]) << 32;
1191         lba |= ((u64)cdb[6]) << 24;
1192         lba |= ((u64)cdb[7]) << 16;
1193         lba |= ((u64)cdb[8]) << 8;
1194         lba |= ((u64)cdb[9]);
1195
1196         len |= ((u32)cdb[10]) << 24;
1197         len |= ((u32)cdb[11]) << 16;
1198         len |= ((u32)cdb[12]) << 8;
1199         len |= ((u32)cdb[13]);
1200
1201         *plba = lba;
1202         *plen = len;
1203 }
1204
1205 /**
1206  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1207  *      @qc: Storage for translated ATA taskfile
1208  *
1209  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
1210  *
1211  *      LOCKING:
1212  *      spin_lock_irqsave(host lock)
1213  *
1214  *      RETURNS:
1215  *      Zero on success, non-zero on error.
1216  */
1217 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1218 {
1219         struct scsi_cmnd *scmd = qc->scsicmd;
1220         struct ata_taskfile *tf = &qc->tf;
1221         struct ata_device *dev = qc->dev;
1222         u64 dev_sectors = qc->dev->n_sectors;
1223         const u8 *cdb = scmd->cmnd;
1224         u64 block;
1225         u32 n_block;
1226
1227         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1228         tf->protocol = ATA_PROT_NODATA;
1229
1230         if (cdb[0] == VERIFY) {
1231                 if (scmd->cmd_len < 10)
1232                         goto invalid_fld;
1233                 scsi_10_lba_len(cdb, &block, &n_block);
1234         } else if (cdb[0] == VERIFY_16) {
1235                 if (scmd->cmd_len < 16)
1236                         goto invalid_fld;
1237                 scsi_16_lba_len(cdb, &block, &n_block);
1238         } else
1239                 goto invalid_fld;
1240
1241         if (!n_block)
1242                 goto nothing_to_do;
1243         if (block >= dev_sectors)
1244                 goto out_of_range;
1245         if ((block + n_block) > dev_sectors)
1246                 goto out_of_range;
1247
1248         if (dev->flags & ATA_DFLAG_LBA) {
1249                 tf->flags |= ATA_TFLAG_LBA;
1250
1251                 if (lba_28_ok(block, n_block)) {
1252                         /* use LBA28 */
1253                         tf->command = ATA_CMD_VERIFY;
1254                         tf->device |= (block >> 24) & 0xf;
1255                 } else if (lba_48_ok(block, n_block)) {
1256                         if (!(dev->flags & ATA_DFLAG_LBA48))
1257                                 goto out_of_range;
1258
1259                         /* use LBA48 */
1260                         tf->flags |= ATA_TFLAG_LBA48;
1261                         tf->command = ATA_CMD_VERIFY_EXT;
1262
1263                         tf->hob_nsect = (n_block >> 8) & 0xff;
1264
1265                         tf->hob_lbah = (block >> 40) & 0xff;
1266                         tf->hob_lbam = (block >> 32) & 0xff;
1267                         tf->hob_lbal = (block >> 24) & 0xff;
1268                 } else
1269                         /* request too large even for LBA48 */
1270                         goto out_of_range;
1271
1272                 tf->nsect = n_block & 0xff;
1273
1274                 tf->lbah = (block >> 16) & 0xff;
1275                 tf->lbam = (block >> 8) & 0xff;
1276                 tf->lbal = block & 0xff;
1277
1278                 tf->device |= ATA_LBA;
1279         } else {
1280                 /* CHS */
1281                 u32 sect, head, cyl, track;
1282
1283                 if (!lba_28_ok(block, n_block))
1284                         goto out_of_range;
1285
1286                 /* Convert LBA to CHS */
1287                 track = (u32)block / dev->sectors;
1288                 cyl   = track / dev->heads;
1289                 head  = track % dev->heads;
1290                 sect  = (u32)block % dev->sectors + 1;
1291
1292                 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1293                         (u32)block, track, cyl, head, sect);
1294
1295                 /* Check whether the converted CHS can fit.
1296                    Cylinder: 0-65535
1297                    Head: 0-15
1298                    Sector: 1-255*/
1299                 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
1300                         goto out_of_range;
1301
1302                 tf->command = ATA_CMD_VERIFY;
1303                 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1304                 tf->lbal = sect;
1305                 tf->lbam = cyl;
1306                 tf->lbah = cyl >> 8;
1307                 tf->device |= head;
1308         }
1309
1310         return 0;
1311
1312 invalid_fld:
1313         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1314         /* "Invalid field in cbd" */
1315         return 1;
1316
1317 out_of_range:
1318         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1319         /* "Logical Block Address out of range" */
1320         return 1;
1321
1322 nothing_to_do:
1323         scmd->result = SAM_STAT_GOOD;
1324         return 1;
1325 }
1326
1327 /**
1328  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1329  *      @qc: Storage for translated ATA taskfile
1330  *
1331  *      Converts any of six SCSI read/write commands into the
1332  *      ATA counterpart, including starting sector (LBA),
1333  *      sector count, and taking into account the device's LBA48
1334  *      support.
1335  *
1336  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1337  *      %WRITE_16 are currently supported.
1338  *
1339  *      LOCKING:
1340  *      spin_lock_irqsave(host lock)
1341  *
1342  *      RETURNS:
1343  *      Zero on success, non-zero on error.
1344  */
1345 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1346 {
1347         struct scsi_cmnd *scmd = qc->scsicmd;
1348         const u8 *cdb = scmd->cmnd;
1349         unsigned int tf_flags = 0;
1350         u64 block;
1351         u32 n_block;
1352         int rc;
1353
1354         if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
1355                 tf_flags |= ATA_TFLAG_WRITE;
1356
1357         /* Calculate the SCSI LBA, transfer length and FUA. */
1358         switch (cdb[0]) {
1359         case READ_10:
1360         case WRITE_10:
1361                 if (unlikely(scmd->cmd_len < 10))
1362                         goto invalid_fld;
1363                 scsi_10_lba_len(cdb, &block, &n_block);
1364                 if (unlikely(cdb[1] & (1 << 3)))
1365                         tf_flags |= ATA_TFLAG_FUA;
1366                 break;
1367         case READ_6:
1368         case WRITE_6:
1369                 if (unlikely(scmd->cmd_len < 6))
1370                         goto invalid_fld;
1371                 scsi_6_lba_len(cdb, &block, &n_block);
1372
1373                 /* for 6-byte r/w commands, transfer length 0
1374                  * means 256 blocks of data, not 0 block.
1375                  */
1376                 if (!n_block)
1377                         n_block = 256;
1378                 break;
1379         case READ_16:
1380         case WRITE_16:
1381                 if (unlikely(scmd->cmd_len < 16))
1382                         goto invalid_fld;
1383                 scsi_16_lba_len(cdb, &block, &n_block);
1384                 if (unlikely(cdb[1] & (1 << 3)))
1385                         tf_flags |= ATA_TFLAG_FUA;
1386                 break;
1387         default:
1388                 DPRINTK("no-byte command\n");
1389                 goto invalid_fld;
1390         }
1391
1392         /* Check and compose ATA command */
1393         if (!n_block)
1394                 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1395                  * length 0 means transfer 0 block of data.
1396                  * However, for ATA R/W commands, sector count 0 means
1397                  * 256 or 65536 sectors, not 0 sectors as in SCSI.
1398                  *
1399                  * WARNING: one or two older ATA drives treat 0 as 0...
1400                  */
1401                 goto nothing_to_do;
1402
1403         qc->flags |= ATA_QCFLAG_IO;
1404         qc->nbytes = n_block * ATA_SECT_SIZE;
1405
1406         rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1407                              qc->tag);
1408         if (likely(rc == 0))
1409                 return 0;
1410
1411         if (rc == -ERANGE)
1412                 goto out_of_range;
1413         /* treat all other errors as -EINVAL, fall through */
1414 invalid_fld:
1415         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
1416         /* "Invalid field in cbd" */
1417         return 1;
1418
1419 out_of_range:
1420         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
1421         /* "Logical Block Address out of range" */
1422         return 1;
1423
1424 nothing_to_do:
1425         scmd->result = SAM_STAT_GOOD;
1426         return 1;
1427 }
1428
1429 static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1430 {
1431         struct ata_port *ap = qc->ap;
1432         struct scsi_cmnd *cmd = qc->scsicmd;
1433         u8 *cdb = cmd->cmnd;
1434         int need_sense = (qc->err_mask != 0);
1435
1436         /* For ATA pass thru (SAT) commands, generate a sense block if
1437          * user mandated it or if there's an error.  Note that if we
1438          * generate because the user forced us to, a check condition
1439          * is generated and the ATA register values are returned
1440          * whether the command completed successfully or not. If there
1441          * was no error, SK, ASC and ASCQ will all be zero.
1442          */
1443         if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1444             ((cdb[2] & 0x20) || need_sense)) {
1445                 ata_gen_passthru_sense(qc);
1446         } else {
1447                 if (!need_sense) {
1448                         cmd->result = SAM_STAT_GOOD;
1449                 } else {
1450                         /* TODO: decide which descriptor format to use
1451                          * for 48b LBA devices and call that here
1452                          * instead of the fixed desc, which is only
1453                          * good for smaller LBA (and maybe CHS?)
1454                          * devices.
1455                          */
1456                         ata_gen_ata_sense(qc);
1457                 }
1458         }
1459
1460         /* XXX: track spindown state for spindown skipping and warning */
1461         if (unlikely(qc->tf.command == ATA_CMD_STANDBY ||
1462                      qc->tf.command == ATA_CMD_STANDBYNOW1))
1463                 qc->dev->flags |= ATA_DFLAG_SPUNDOWN;
1464         else if (likely(system_state != SYSTEM_HALT &&
1465                         system_state != SYSTEM_POWER_OFF))
1466                 qc->dev->flags &= ~ATA_DFLAG_SPUNDOWN;
1467
1468         if (need_sense && !ap->ops->error_handler)
1469                 ata_dump_status(ap->print_id, &qc->result_tf);
1470
1471         qc->scsidone(cmd);
1472
1473         ata_qc_free(qc);
1474 }
1475
1476 /**
1477  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
1478  *      @dev: ATA device to which the command is addressed
1479  *      @cmd: SCSI command to execute
1480  *      @done: SCSI command completion function
1481  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
1482  *
1483  *      Our ->queuecommand() function has decided that the SCSI
1484  *      command issued can be directly translated into an ATA
1485  *      command, rather than handled internally.
1486  *
1487  *      This function sets up an ata_queued_cmd structure for the
1488  *      SCSI command, and sends that ata_queued_cmd to the hardware.
1489  *
1490  *      The xlat_func argument (actor) returns 0 if ready to execute
1491  *      ATA command, else 1 to finish translation. If 1 is returned
1492  *      then cmd->result (and possibly cmd->sense_buffer) are assumed
1493  *      to be set reflecting an error condition or clean (early)
1494  *      termination.
1495  *
1496  *      LOCKING:
1497  *      spin_lock_irqsave(host lock)
1498  *
1499  *      RETURNS:
1500  *      0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1501  *      needs to be deferred.
1502  */
1503 static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1504                               void (*done)(struct scsi_cmnd *),
1505                               ata_xlat_func_t xlat_func)
1506 {
1507         struct ata_port *ap = dev->link->ap;
1508         struct ata_queued_cmd *qc;
1509         int rc;
1510
1511         VPRINTK("ENTER\n");
1512
1513         qc = ata_scsi_qc_new(dev, cmd, done);
1514         if (!qc)
1515                 goto err_mem;
1516
1517         /* data is present; dma-map it */
1518         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1519             cmd->sc_data_direction == DMA_TO_DEVICE) {
1520                 if (unlikely(scsi_bufflen(cmd) < 1)) {
1521                         ata_dev_printk(dev, KERN_WARNING,
1522                                        "WARNING: zero len r/w req\n");
1523                         goto err_did;
1524                 }
1525
1526                 ata_sg_init(qc, scsi_sglist(cmd), scsi_sg_count(cmd));
1527
1528                 qc->dma_dir = cmd->sc_data_direction;
1529         }
1530
1531         qc->complete_fn = ata_scsi_qc_complete;
1532
1533         if (xlat_func(qc))
1534                 goto early_finish;
1535
1536         if (ap->ops->qc_defer) {
1537                 if ((rc = ap->ops->qc_defer(qc)))
1538                         goto defer;
1539         }
1540
1541         /* select device, send command to hardware */
1542         ata_qc_issue(qc);
1543
1544         VPRINTK("EXIT\n");
1545         return 0;
1546
1547 early_finish:
1548         ata_qc_free(qc);
1549         qc->scsidone(cmd);
1550         DPRINTK("EXIT - early finish (good or error)\n");
1551         return 0;
1552
1553 err_did:
1554         ata_qc_free(qc);
1555         cmd->result = (DID_ERROR << 16);
1556         qc->scsidone(cmd);
1557 err_mem:
1558         DPRINTK("EXIT - internal\n");
1559         return 0;
1560
1561 defer:
1562         ata_qc_free(qc);
1563         DPRINTK("EXIT - defer\n");
1564         if (rc == ATA_DEFER_LINK)
1565                 return SCSI_MLQUEUE_DEVICE_BUSY;
1566         else
1567                 return SCSI_MLQUEUE_HOST_BUSY;
1568 }
1569
1570 /**
1571  *      ata_scsi_rbuf_get - Map response buffer.
1572  *      @cmd: SCSI command containing buffer to be mapped.
1573  *      @buf_out: Pointer to mapped area.
1574  *
1575  *      Maps buffer contained within SCSI command @cmd.
1576  *
1577  *      LOCKING:
1578  *      spin_lock_irqsave(host lock)
1579  *
1580  *      RETURNS:
1581  *      Length of response buffer.
1582  */
1583
1584 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1585 {
1586         u8 *buf;
1587         unsigned int buflen;
1588
1589         struct scatterlist *sg = scsi_sglist(cmd);
1590
1591         if (sg) {
1592                 buf = kmap_atomic(sg_page(sg), KM_IRQ0) + sg->offset;
1593                 buflen = sg->length;
1594         } else {
1595                 buf = NULL;
1596                 buflen = 0;
1597         }
1598
1599         *buf_out = buf;
1600         return buflen;
1601 }
1602
1603 /**
1604  *      ata_scsi_rbuf_put - Unmap response buffer.
1605  *      @cmd: SCSI command containing buffer to be unmapped.
1606  *      @buf: buffer to unmap
1607  *
1608  *      Unmaps response buffer contained within @cmd.
1609  *
1610  *      LOCKING:
1611  *      spin_lock_irqsave(host lock)
1612  */
1613
1614 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1615 {
1616         struct scatterlist *sg = scsi_sglist(cmd);
1617         if (sg)
1618                 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1619 }
1620
1621 /**
1622  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1623  *      @args: device IDENTIFY data / SCSI command of interest.
1624  *      @actor: Callback hook for desired SCSI command simulator
1625  *
1626  *      Takes care of the hard work of simulating a SCSI command...
1627  *      Mapping the response buffer, calling the command's handler,
1628  *      and handling the handler's return value.  This return value
1629  *      indicates whether the handler wishes the SCSI command to be
1630  *      completed successfully (0), or not (in which case cmd->result
1631  *      and sense buffer are assumed to be set).
1632  *
1633  *      LOCKING:
1634  *      spin_lock_irqsave(host lock)
1635  */
1636
1637 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1638                         unsigned int (*actor) (struct ata_scsi_args *args,
1639                                                u8 *rbuf, unsigned int buflen))
1640 {
1641         u8 *rbuf;
1642         unsigned int buflen, rc;
1643         struct scsi_cmnd *cmd = args->cmd;
1644
1645         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1646         memset(rbuf, 0, buflen);
1647         rc = actor(args, rbuf, buflen);
1648         ata_scsi_rbuf_put(cmd, rbuf);
1649
1650         if (rc == 0)
1651                 cmd->result = SAM_STAT_GOOD;
1652         args->done(cmd);
1653 }
1654
1655 /**
1656  *      ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
1657  *      @idx: byte index into SCSI response buffer
1658  *      @val: value to set
1659  *
1660  *      To be used by SCSI command simulator functions.  This macros
1661  *      expects two local variables, u8 *rbuf and unsigned int buflen,
1662  *      are in scope.
1663  *
1664  *      LOCKING:
1665  *      None.
1666  */
1667 #define ATA_SCSI_RBUF_SET(idx, val) do { \
1668                 if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
1669         } while (0)
1670
1671 /**
1672  *      ata_scsiop_inq_std - Simulate INQUIRY command
1673  *      @args: device IDENTIFY data / SCSI command of interest.
1674  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1675  *      @buflen: Response buffer length.
1676  *
1677  *      Returns standard device identification data associated
1678  *      with non-VPD INQUIRY command output.
1679  *
1680  *      LOCKING:
1681  *      spin_lock_irqsave(host lock)
1682  */
1683
1684 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1685                                unsigned int buflen)
1686 {
1687         u8 hdr[] = {
1688                 TYPE_DISK,
1689                 0,
1690                 0x5,    /* claim SPC-3 version compatibility */
1691                 2,
1692                 95 - 4
1693         };
1694
1695         /* set scsi removeable (RMB) bit per ata bit */
1696         if (ata_id_removeable(args->id))
1697                 hdr[1] |= (1 << 7);
1698
1699         VPRINTK("ENTER\n");
1700
1701         memcpy(rbuf, hdr, sizeof(hdr));
1702
1703         if (buflen > 35) {
1704                 memcpy(&rbuf[8], "ATA     ", 8);
1705                 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD, 16);
1706                 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV, 4);
1707                 if (rbuf[32] == 0 || rbuf[32] == ' ')
1708                         memcpy(&rbuf[32], "n/a ", 4);
1709         }
1710
1711         if (buflen > 63) {
1712                 const u8 versions[] = {
1713                         0x60,   /* SAM-3 (no version claimed) */
1714
1715                         0x03,
1716                         0x20,   /* SBC-2 (no version claimed) */
1717
1718                         0x02,
1719                         0x60    /* SPC-3 (no version claimed) */
1720                 };
1721
1722                 memcpy(rbuf + 59, versions, sizeof(versions));
1723         }
1724
1725         return 0;
1726 }
1727
1728 /**
1729  *      ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
1730  *      @args: device IDENTIFY data / SCSI command of interest.
1731  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1732  *      @buflen: Response buffer length.
1733  *
1734  *      Returns list of inquiry VPD pages available.
1735  *
1736  *      LOCKING:
1737  *      spin_lock_irqsave(host lock)
1738  */
1739
1740 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1741                               unsigned int buflen)
1742 {
1743         const u8 pages[] = {
1744                 0x00,   /* page 0x00, this page */
1745                 0x80,   /* page 0x80, unit serial no page */
1746                 0x83    /* page 0x83, device ident page */
1747         };
1748         rbuf[3] = sizeof(pages);        /* number of supported VPD pages */
1749
1750         if (buflen > 6)
1751                 memcpy(rbuf + 4, pages, sizeof(pages));
1752
1753         return 0;
1754 }
1755
1756 /**
1757  *      ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
1758  *      @args: device IDENTIFY data / SCSI command of interest.
1759  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1760  *      @buflen: Response buffer length.
1761  *
1762  *      Returns ATA device serial number.
1763  *
1764  *      LOCKING:
1765  *      spin_lock_irqsave(host lock)
1766  */
1767
1768 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1769                               unsigned int buflen)
1770 {
1771         const u8 hdr[] = {
1772                 0,
1773                 0x80,                   /* this page code */
1774                 0,
1775                 ATA_ID_SERNO_LEN,       /* page len */
1776         };
1777         memcpy(rbuf, hdr, sizeof(hdr));
1778
1779         if (buflen > (ATA_ID_SERNO_LEN + 4 - 1))
1780                 ata_id_string(args->id, (unsigned char *) &rbuf[4],
1781                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1782
1783         return 0;
1784 }
1785
1786 /**
1787  *      ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
1788  *      @args: device IDENTIFY data / SCSI command of interest.
1789  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1790  *      @buflen: Response buffer length.
1791  *
1792  *      Yields two logical unit device identification designators:
1793  *       - vendor specific ASCII containing the ATA serial number
1794  *       - SAT defined "t10 vendor id based" containing ASCII vendor
1795  *         name ("ATA     "), model and serial numbers.
1796  *
1797  *      LOCKING:
1798  *      spin_lock_irqsave(host lock)
1799  */
1800
1801 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1802                               unsigned int buflen)
1803 {
1804         int num;
1805         const int sat_model_serial_desc_len = 68;
1806
1807         rbuf[1] = 0x83;                 /* this page code */
1808         num = 4;
1809
1810         if (buflen > (ATA_ID_SERNO_LEN + num + 3)) {
1811                 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
1812                 rbuf[num + 0] = 2;
1813                 rbuf[num + 3] = ATA_ID_SERNO_LEN;
1814                 num += 4;
1815                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1816                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1817                 num += ATA_ID_SERNO_LEN;
1818         }
1819         if (buflen > (sat_model_serial_desc_len + num + 3)) {
1820                 /* SAT defined lu model and serial numbers descriptor */
1821                 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
1822                 rbuf[num + 0] = 2;
1823                 rbuf[num + 1] = 1;
1824                 rbuf[num + 3] = sat_model_serial_desc_len;
1825                 num += 4;
1826                 memcpy(rbuf + num, "ATA     ", 8);
1827                 num += 8;
1828                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1829                               ATA_ID_PROD, ATA_ID_PROD_LEN);
1830                 num += ATA_ID_PROD_LEN;
1831                 ata_id_string(args->id, (unsigned char *) rbuf + num,
1832                               ATA_ID_SERNO, ATA_ID_SERNO_LEN);
1833                 num += ATA_ID_SERNO_LEN;
1834         }
1835         rbuf[3] = num - 4;    /* page len (assume less than 256 bytes) */
1836         return 0;
1837 }
1838
1839 /**
1840  *      ata_scsiop_inq_89 - Simulate INQUIRY VPD page 89, ATA info
1841  *      @args: device IDENTIFY data / SCSI command of interest.
1842  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1843  *      @buflen: Response buffer length.
1844  *
1845  *      Yields SAT-specified ATA VPD page.
1846  *
1847  *      LOCKING:
1848  *      spin_lock_irqsave(host lock)
1849  */
1850
1851 unsigned int ata_scsiop_inq_89(struct ata_scsi_args *args, u8 *rbuf,
1852                               unsigned int buflen)
1853 {
1854         u8 pbuf[60];
1855         struct ata_taskfile tf;
1856         unsigned int i;
1857
1858         if (!buflen)
1859                 return 0;
1860
1861         memset(&pbuf, 0, sizeof(pbuf));
1862         memset(&tf, 0, sizeof(tf));
1863
1864         pbuf[1] = 0x89;                 /* our page code */
1865         pbuf[2] = (0x238 >> 8);         /* page size fixed at 238h */
1866         pbuf[3] = (0x238 & 0xff);
1867
1868         memcpy(&pbuf[8], "linux   ", 8);
1869         memcpy(&pbuf[16], "libata          ", 16);
1870         memcpy(&pbuf[32], DRV_VERSION, 4);
1871         ata_id_string(args->id, &pbuf[32], ATA_ID_FW_REV, 4);
1872
1873         /* we don't store the ATA device signature, so we fake it */
1874
1875         tf.command = ATA_DRDY;          /* really, this is Status reg */
1876         tf.lbal = 0x1;
1877         tf.nsect = 0x1;
1878
1879         ata_tf_to_fis(&tf, 0, 1, &pbuf[36]);    /* TODO: PMP? */
1880         pbuf[36] = 0x34;                /* force D2H Reg FIS (34h) */
1881
1882         pbuf[56] = ATA_CMD_ID_ATA;
1883
1884         i = min(buflen, 60U);
1885         memcpy(rbuf, &pbuf[0], i);
1886         buflen -= i;
1887
1888         if (!buflen)
1889                 return 0;
1890
1891         memcpy(&rbuf[60], &args->id[0], min(buflen, 512U));
1892         return 0;
1893 }
1894
1895 /**
1896  *      ata_scsiop_noop - Command handler that simply returns success.
1897  *      @args: device IDENTIFY data / SCSI command of interest.
1898  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1899  *      @buflen: Response buffer length.
1900  *
1901  *      No operation.  Simply returns success to caller, to indicate
1902  *      that the caller should successfully complete this SCSI command.
1903  *
1904  *      LOCKING:
1905  *      spin_lock_irqsave(host lock)
1906  */
1907
1908 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1909                             unsigned int buflen)
1910 {
1911         VPRINTK("ENTER\n");
1912         return 0;
1913 }
1914
1915 /**
1916  *      ata_msense_push - Push data onto MODE SENSE data output buffer
1917  *      @ptr_io: (input/output) Location to store more output data
1918  *      @last: End of output data buffer
1919  *      @buf: Pointer to BLOB being added to output buffer
1920  *      @buflen: Length of BLOB
1921  *
1922  *      Store MODE SENSE data on an output buffer.
1923  *
1924  *      LOCKING:
1925  *      None.
1926  */
1927
1928 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1929                             const u8 *buf, unsigned int buflen)
1930 {
1931         u8 *ptr = *ptr_io;
1932
1933         if ((ptr + buflen - 1) > last)
1934                 return;
1935
1936         memcpy(ptr, buf, buflen);
1937
1938         ptr += buflen;
1939
1940         *ptr_io = ptr;
1941 }
1942
1943 /**
1944  *      ata_msense_caching - Simulate MODE SENSE caching info page
1945  *      @id: device IDENTIFY data
1946  *      @ptr_io: (input/output) Location to store more output data
1947  *      @last: End of output data buffer
1948  *
1949  *      Generate a caching info page, which conditionally indicates
1950  *      write caching to the SCSI layer, depending on device
1951  *      capabilities.
1952  *
1953  *      LOCKING:
1954  *      None.
1955  */
1956
1957 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1958                                        const u8 *last)
1959 {
1960         u8 page[CACHE_MPAGE_LEN];
1961
1962         memcpy(page, def_cache_mpage, sizeof(page));
1963         if (ata_id_wcache_enabled(id))
1964                 page[2] |= (1 << 2);    /* write cache enable */
1965         if (!ata_id_rahead_enabled(id))
1966                 page[12] |= (1 << 5);   /* disable read ahead */
1967
1968         ata_msense_push(ptr_io, last, page, sizeof(page));
1969         return sizeof(page);
1970 }
1971
1972 /**
1973  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1974  *      @dev: Device associated with this MODE SENSE command
1975  *      @ptr_io: (input/output) Location to store more output data
1976  *      @last: End of output data buffer
1977  *
1978  *      Generate a generic MODE SENSE control mode page.
1979  *
1980  *      LOCKING:
1981  *      None.
1982  */
1983
1984 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1985 {
1986         ata_msense_push(ptr_io, last, def_control_mpage,
1987                         sizeof(def_control_mpage));
1988         return sizeof(def_control_mpage);
1989 }
1990
1991 /**
1992  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1993  *      @dev: Device associated with this MODE SENSE command
1994  *      @ptr_io: (input/output) Location to store more output data
1995  *      @last: End of output data buffer
1996  *
1997  *      Generate a generic MODE SENSE r/w error recovery page.
1998  *
1999  *      LOCKING:
2000  *      None.
2001  */
2002
2003 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
2004 {
2005
2006         ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
2007                         sizeof(def_rw_recovery_mpage));
2008         return sizeof(def_rw_recovery_mpage);
2009 }
2010
2011 /*
2012  * We can turn this into a real blacklist if it's needed, for now just
2013  * blacklist any Maxtor BANC1G10 revision firmware
2014  */
2015 static int ata_dev_supports_fua(u16 *id)
2016 {
2017         unsigned char model[ATA_ID_PROD_LEN + 1], fw[ATA_ID_FW_REV_LEN + 1];
2018
2019         if (!libata_fua)
2020                 return 0;
2021         if (!ata_id_has_fua(id))
2022                 return 0;
2023
2024         ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
2025         ata_id_c_string(id, fw, ATA_ID_FW_REV, sizeof(fw));
2026
2027         if (strcmp(model, "Maxtor"))
2028                 return 1;
2029         if (strcmp(fw, "BANC1G10"))
2030                 return 1;
2031
2032         return 0; /* blacklisted */
2033 }
2034
2035 /**
2036  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
2037  *      @args: device IDENTIFY data / SCSI command of interest.
2038  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2039  *      @buflen: Response buffer length.
2040  *
2041  *      Simulate MODE SENSE commands. Assume this is invoked for direct
2042  *      access devices (e.g. disks) only. There should be no block
2043  *      descriptor for other device types.
2044  *
2045  *      LOCKING:
2046  *      spin_lock_irqsave(host lock)
2047  */
2048
2049 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
2050                                   unsigned int buflen)
2051 {
2052         struct ata_device *dev = args->dev;
2053         u8 *scsicmd = args->cmd->cmnd, *p, *last;
2054         const u8 sat_blk_desc[] = {
2055                 0, 0, 0, 0,     /* number of blocks: sat unspecified */
2056                 0,
2057                 0, 0x2, 0x0     /* block length: 512 bytes */
2058         };
2059         u8 pg, spg;
2060         unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
2061         u8 dpofua;
2062
2063         VPRINTK("ENTER\n");
2064
2065         six_byte = (scsicmd[0] == MODE_SENSE);
2066         ebd = !(scsicmd[1] & 0x8);      /* dbd bit inverted == edb */
2067         /*
2068          * LLBA bit in msense(10) ignored (compliant)
2069          */
2070
2071         page_control = scsicmd[2] >> 6;
2072         switch (page_control) {
2073         case 0: /* current */
2074                 break;  /* supported */
2075         case 3: /* saved */
2076                 goto saving_not_supp;
2077         case 1: /* changeable */
2078         case 2: /* defaults */
2079         default:
2080                 goto invalid_fld;
2081         }
2082
2083         if (six_byte) {
2084                 output_len = 4 + (ebd ? 8 : 0);
2085                 alloc_len = scsicmd[4];
2086         } else {
2087                 output_len = 8 + (ebd ? 8 : 0);
2088                 alloc_len = (scsicmd[7] << 8) + scsicmd[8];
2089         }
2090         minlen = (alloc_len < buflen) ? alloc_len : buflen;
2091
2092         p = rbuf + output_len;
2093         last = rbuf + minlen - 1;
2094
2095         pg = scsicmd[2] & 0x3f;
2096         spg = scsicmd[3];
2097         /*
2098          * No mode subpages supported (yet) but asking for _all_
2099          * subpages may be valid
2100          */
2101         if (spg && (spg != ALL_SUB_MPAGES))
2102                 goto invalid_fld;
2103
2104         switch(pg) {
2105         case RW_RECOVERY_MPAGE:
2106                 output_len += ata_msense_rw_recovery(&p, last);
2107                 break;
2108
2109         case CACHE_MPAGE:
2110                 output_len += ata_msense_caching(args->id, &p, last);
2111                 break;
2112
2113         case CONTROL_MPAGE: {
2114                 output_len += ata_msense_ctl_mode(&p, last);
2115                 break;
2116                 }
2117
2118         case ALL_MPAGES:
2119                 output_len += ata_msense_rw_recovery(&p, last);
2120                 output_len += ata_msense_caching(args->id, &p, last);
2121                 output_len += ata_msense_ctl_mode(&p, last);
2122                 break;
2123
2124         default:                /* invalid page code */
2125                 goto invalid_fld;
2126         }
2127
2128         if (minlen < 1)
2129                 return 0;
2130
2131         dpofua = 0;
2132         if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
2133             (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2134                 dpofua = 1 << 4;
2135
2136         if (six_byte) {
2137                 output_len--;
2138                 rbuf[0] = output_len;
2139                 if (minlen > 2)
2140                         rbuf[2] |= dpofua;
2141                 if (ebd) {
2142                         if (minlen > 3)
2143                                 rbuf[3] = sizeof(sat_blk_desc);
2144                         if (minlen > 11)
2145                                 memcpy(rbuf + 4, sat_blk_desc,
2146                                        sizeof(sat_blk_desc));
2147                 }
2148         } else {
2149                 output_len -= 2;
2150                 rbuf[0] = output_len >> 8;
2151                 if (minlen > 1)
2152                         rbuf[1] = output_len;
2153                 if (minlen > 3)
2154                         rbuf[3] |= dpofua;
2155                 if (ebd) {
2156                         if (minlen > 7)
2157                                 rbuf[7] = sizeof(sat_blk_desc);
2158                         if (minlen > 15)
2159                                 memcpy(rbuf + 8, sat_blk_desc,
2160                                        sizeof(sat_blk_desc));
2161                 }
2162         }
2163         return 0;
2164
2165 invalid_fld:
2166         ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2167         /* "Invalid field in cbd" */
2168         return 1;
2169
2170 saving_not_supp:
2171         ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2172          /* "Saving parameters not supported" */
2173         return 1;
2174 }
2175
2176 /**
2177  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2178  *      @args: device IDENTIFY data / SCSI command of interest.
2179  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2180  *      @buflen: Response buffer length.
2181  *
2182  *      Simulate READ CAPACITY commands.
2183  *
2184  *      LOCKING:
2185  *      None.
2186  */
2187 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
2188                                  unsigned int buflen)
2189 {
2190         u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
2191
2192         VPRINTK("ENTER\n");
2193
2194         if (args->cmd->cmnd[0] == READ_CAPACITY) {
2195                 if (last_lba >= 0xffffffffULL)
2196                         last_lba = 0xffffffff;
2197
2198                 /* sector count, 32-bit */
2199                 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
2200                 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
2201                 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
2202                 ATA_SCSI_RBUF_SET(3, last_lba);
2203
2204                 /* sector size */
2205                 ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
2206                 ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
2207         } else {
2208                 /* sector count, 64-bit */
2209                 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
2210                 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
2211                 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
2212                 ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
2213                 ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
2214                 ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
2215                 ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
2216                 ATA_SCSI_RBUF_SET(7, last_lba);
2217
2218                 /* sector size */
2219                 ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
2220                 ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
2221         }
2222
2223         return 0;
2224 }
2225
2226 /**
2227  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
2228  *      @args: device IDENTIFY data / SCSI command of interest.
2229  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2230  *      @buflen: Response buffer length.
2231  *
2232  *      Simulate REPORT LUNS command.
2233  *
2234  *      LOCKING:
2235  *      spin_lock_irqsave(host lock)
2236  */
2237
2238 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
2239                                    unsigned int buflen)
2240 {
2241         VPRINTK("ENTER\n");
2242         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
2243
2244         return 0;
2245 }
2246
2247 /**
2248  *      ata_scsi_set_sense - Set SCSI sense data and status
2249  *      @cmd: SCSI request to be handled
2250  *      @sk: SCSI-defined sense key
2251  *      @asc: SCSI-defined additional sense code
2252  *      @ascq: SCSI-defined additional sense code qualifier
2253  *
2254  *      Helper function that builds a valid fixed format, current
2255  *      response code and the given sense key (sk), additional sense
2256  *      code (asc) and additional sense code qualifier (ascq) with
2257  *      a SCSI command status of %SAM_STAT_CHECK_CONDITION and
2258  *      DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
2259  *
2260  *      LOCKING:
2261  *      Not required
2262  */
2263
2264 void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
2265 {
2266         cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2267
2268         cmd->sense_buffer[0] = 0x70;    /* fixed format, current */
2269         cmd->sense_buffer[2] = sk;
2270         cmd->sense_buffer[7] = 18 - 8;  /* additional sense length */
2271         cmd->sense_buffer[12] = asc;
2272         cmd->sense_buffer[13] = ascq;
2273 }
2274
2275 /**
2276  *      ata_scsi_badcmd - End a SCSI request with an error
2277  *      @cmd: SCSI request to be handled
2278  *      @done: SCSI command completion function
2279  *      @asc: SCSI-defined additional sense code
2280  *      @ascq: SCSI-defined additional sense code qualifier
2281  *
2282  *      Helper function that completes a SCSI command with
2283  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
2284  *      and the specified additional sense codes.
2285  *
2286  *      LOCKING:
2287  *      spin_lock_irqsave(host lock)
2288  */
2289
2290 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
2291 {
2292         DPRINTK("ENTER\n");
2293         ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
2294
2295         done(cmd);
2296 }
2297
2298 static void atapi_sense_complete(struct ata_queued_cmd *qc)
2299 {
2300         if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
2301                 /* FIXME: not quite right; we don't want the
2302                  * translation of taskfile registers into
2303                  * a sense descriptors, since that's only
2304                  * correct for ATA, not ATAPI
2305                  */
2306                 ata_gen_passthru_sense(qc);
2307         }
2308
2309         qc->scsidone(qc->scsicmd);
2310         ata_qc_free(qc);
2311 }
2312
2313 /* is it pointless to prefer PIO for "safety reasons"? */
2314 static inline int ata_pio_use_silly(struct ata_port *ap)
2315 {
2316         return (ap->flags & ATA_FLAG_PIO_DMA);
2317 }
2318
2319 static void atapi_request_sense(struct ata_queued_cmd *qc)
2320 {
2321         struct ata_port *ap = qc->ap;
2322         struct scsi_cmnd *cmd = qc->scsicmd;
2323
2324         DPRINTK("ATAPI request sense\n");
2325
2326         /* FIXME: is this needed? */
2327         memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2328
2329         ap->ops->tf_read(ap, &qc->tf);
2330
2331         /* fill these in, for the case where they are -not- overwritten */
2332         cmd->sense_buffer[0] = 0x70;
2333         cmd->sense_buffer[2] = qc->tf.feature >> 4;
2334
2335         ata_qc_reinit(qc);
2336
2337         ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2338         qc->dma_dir = DMA_FROM_DEVICE;
2339
2340         memset(&qc->cdb, 0, qc->dev->cdb_len);
2341         qc->cdb[0] = REQUEST_SENSE;
2342         qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2343
2344         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2345         qc->tf.command = ATA_CMD_PACKET;
2346
2347         if (ata_pio_use_silly(ap)) {
2348                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2349                 qc->tf.feature |= ATAPI_PKT_DMA;
2350         } else {
2351                 qc->tf.protocol = ATA_PROT_ATAPI;
2352                 qc->tf.lbam = SCSI_SENSE_BUFFERSIZE;
2353                 qc->tf.lbah = 0;
2354         }
2355         qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2356
2357         qc->complete_fn = atapi_sense_complete;
2358
2359         ata_qc_issue(qc);
2360
2361         DPRINTK("EXIT\n");
2362 }
2363
2364 static void atapi_qc_complete(struct ata_queued_cmd *qc)
2365 {
2366         struct scsi_cmnd *cmd = qc->scsicmd;
2367         unsigned int err_mask = qc->err_mask;
2368
2369         VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
2370
2371         /* handle completion from new EH */
2372         if (unlikely(qc->ap->ops->error_handler &&
2373                      (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2374
2375                 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2376                         /* FIXME: not quite right; we don't want the
2377                          * translation of taskfile registers into a
2378                          * sense descriptors, since that's only
2379                          * correct for ATA, not ATAPI
2380                          */
2381                         ata_gen_passthru_sense(qc);
2382                 }
2383
2384                 /* SCSI EH automatically locks door if sdev->locked is
2385                  * set.  Sometimes door lock request continues to
2386                  * fail, for example, when no media is present.  This
2387                  * creates a loop - SCSI EH issues door lock which
2388                  * fails and gets invoked again to acquire sense data
2389                  * for the failed command.
2390                  *
2391                  * If door lock fails, always clear sdev->locked to
2392                  * avoid this infinite loop.
2393                  */
2394                 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
2395                         qc->dev->sdev->locked = 0;
2396
2397                 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2398                 qc->scsidone(cmd);
2399                 ata_qc_free(qc);
2400                 return;
2401         }
2402
2403         /* successful completion or old EH failure path */
2404         if (unlikely(err_mask & AC_ERR_DEV)) {
2405                 cmd->result = SAM_STAT_CHECK_CONDITION;
2406                 atapi_request_sense(qc);
2407                 return;
2408         } else if (unlikely(err_mask)) {
2409                 /* FIXME: not quite right; we don't want the
2410                  * translation of taskfile registers into
2411                  * a sense descriptors, since that's only
2412                  * correct for ATA, not ATAPI
2413                  */
2414                 ata_gen_passthru_sense(qc);
2415         } else {
2416                 u8 *scsicmd = cmd->cmnd;
2417
2418                 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
2419                         u8 *buf = NULL;
2420                         unsigned int buflen;
2421
2422                         buflen = ata_scsi_rbuf_get(cmd, &buf);
2423
2424         /* ATAPI devices typically report zero for their SCSI version,
2425          * and sometimes deviate from the spec WRT response data
2426          * format.  If SCSI version is reported as zero like normal,
2427          * then we make the following fixups:  1) Fake MMC-5 version,
2428          * to indicate to the Linux scsi midlayer this is a modern
2429          * device.  2) Ensure response data format / ATAPI information
2430          * are always correct.
2431          */
2432                         if (buf[2] == 0) {
2433                                 buf[2] = 0x5;
2434                                 buf[3] = 0x32;
2435                         }
2436
2437                         ata_scsi_rbuf_put(cmd, buf);
2438                 }
2439
2440                 cmd->result = SAM_STAT_GOOD;
2441         }
2442
2443         qc->scsidone(cmd);
2444         ata_qc_free(qc);
2445 }
2446 /**
2447  *      atapi_xlat - Initialize PACKET taskfile
2448  *      @qc: command structure to be initialized
2449  *
2450  *      LOCKING:
2451  *      spin_lock_irqsave(host lock)
2452  *
2453  *      RETURNS:
2454  *      Zero on success, non-zero on failure.
2455  */
2456 static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
2457 {
2458         struct scsi_cmnd *scmd = qc->scsicmd;
2459         struct ata_device *dev = qc->dev;
2460         int using_pio = (dev->flags & ATA_DFLAG_PIO);
2461         int nodata = (scmd->sc_data_direction == DMA_NONE);
2462         unsigned int nbytes;
2463
2464         memset(qc->cdb, 0, dev->cdb_len);
2465         memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
2466
2467         qc->complete_fn = atapi_qc_complete;
2468
2469         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2470         if (scmd->sc_data_direction == DMA_TO_DEVICE) {
2471                 qc->tf.flags |= ATA_TFLAG_WRITE;
2472                 DPRINTK("direction: write\n");
2473         }
2474
2475         qc->tf.command = ATA_CMD_PACKET;
2476         qc->nbytes = scsi_bufflen(scmd);
2477
2478         /* check whether ATAPI DMA is safe */
2479         if (!using_pio && ata_check_atapi_dma(qc))
2480                 using_pio = 1;
2481
2482         /* Some controller variants snoop this value for Packet transfers
2483            to do state machine and FIFO management. Thus we want to set it
2484            properly, and for DMA where it is effectively meaningless */
2485         nbytes = min(qc->nbytes, (unsigned int)63 * 1024);
2486
2487         qc->tf.lbam = (nbytes & 0xFF);
2488         qc->tf.lbah = (nbytes >> 8);
2489
2490         if (using_pio || nodata) {
2491                 /* no data, or PIO data xfer */
2492                 if (nodata)
2493                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
2494                 else
2495                         qc->tf.protocol = ATA_PROT_ATAPI;
2496         } else {
2497                 /* DMA data xfer */
2498                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2499                 qc->tf.feature |= ATAPI_PKT_DMA;
2500
2501                 if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
2502                         /* some SATA bridges need us to indicate data xfer direction */
2503                         qc->tf.feature |= ATAPI_DMADIR;
2504         }
2505
2506
2507         /* FIXME: We need to translate 0x05 READ_BLOCK_LIMITS to a MODE_SENSE
2508            as ATAPI tape drives don't get this right otherwise */
2509         return 0;
2510 }
2511
2512 static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
2513 {
2514         if (ap->nr_pmp_links == 0) {
2515                 if (likely(devno < ata_link_max_devices(&ap->link)))
2516                         return &ap->link.device[devno];
2517         } else {
2518                 if (likely(devno < ap->nr_pmp_links))
2519                         return &ap->pmp_link[devno].device[0];
2520         }
2521
2522         return NULL;
2523 }
2524
2525 static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
2526                                               const struct scsi_device *scsidev)
2527 {
2528         int devno;
2529
2530         /* skip commands not addressed to targets we simulate */
2531         if (ap->nr_pmp_links == 0) {
2532                 if (unlikely(scsidev->channel || scsidev->lun))
2533                         return NULL;
2534                 devno = scsidev->id;
2535         } else {
2536                 if (unlikely(scsidev->id || scsidev->lun))
2537                         return NULL;
2538                 devno = scsidev->channel;
2539         }
2540
2541         return ata_find_dev(ap, devno);
2542 }
2543
2544 /**
2545  *      ata_scsi_dev_enabled - determine if device is enabled
2546  *      @dev: ATA device
2547  *
2548  *      Determine if commands should be sent to the specified device.
2549  *
2550  *      LOCKING:
2551  *      spin_lock_irqsave(host lock)
2552  *
2553  *      RETURNS:
2554  *      0 if commands are not allowed / 1 if commands are allowed
2555  */
2556
2557 static int ata_scsi_dev_enabled(struct ata_device *dev)
2558 {
2559         if (unlikely(!ata_dev_enabled(dev)))
2560                 return 0;
2561
2562         if (!atapi_enabled || (dev->link->ap->flags & ATA_FLAG_NO_ATAPI)) {
2563                 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
2564                         ata_dev_printk(dev, KERN_WARNING,
2565                                        "WARNING: ATAPI is %s, device ignored.\n",
2566                                        atapi_enabled ? "not supported with this driver" : "disabled");
2567                         return 0;
2568                 }
2569         }
2570
2571         return 1;
2572 }
2573
2574 /**
2575  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2576  *      @ap: ATA port to which the device is attached
2577  *      @scsidev: SCSI device from which we derive the ATA device
2578  *
2579  *      Given various information provided in struct scsi_cmnd,
2580  *      map that onto an ATA bus, and using that mapping
2581  *      determine which ata_device is associated with the
2582  *      SCSI command to be sent.
2583  *
2584  *      LOCKING:
2585  *      spin_lock_irqsave(host lock)
2586  *
2587  *      RETURNS:
2588  *      Associated ATA device, or %NULL if not found.
2589  */
2590 static struct ata_device *
2591 ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
2592 {
2593         struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
2594
2595         if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
2596                 return NULL;
2597
2598         return dev;
2599 }
2600
2601 /*
2602  *      ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2603  *      @byte1: Byte 1 from pass-thru CDB.
2604  *
2605  *      RETURNS:
2606  *      ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2607  */
2608 static u8
2609 ata_scsi_map_proto(u8 byte1)
2610 {
2611         switch((byte1 & 0x1e) >> 1) {
2612         case 3:         /* Non-data */
2613                 return ATA_PROT_NODATA;
2614
2615         case 6:         /* DMA */
2616         case 10:        /* UDMA Data-in */
2617         case 11:        /* UDMA Data-Out */
2618                 return ATA_PROT_DMA;
2619
2620         case 4:         /* PIO Data-in */
2621         case 5:         /* PIO Data-out */
2622                 return ATA_PROT_PIO;
2623
2624         case 0:         /* Hard Reset */
2625         case 1:         /* SRST */
2626         case 8:         /* Device Diagnostic */
2627         case 9:         /* Device Reset */
2628         case 7:         /* DMA Queued */
2629         case 12:        /* FPDMA */
2630         case 15:        /* Return Response Info */
2631         default:        /* Reserved */
2632                 break;
2633         }
2634
2635         return ATA_PROT_UNKNOWN;
2636 }
2637
2638 /**
2639  *      ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2640  *      @qc: command structure to be initialized
2641  *
2642  *      Handles either 12 or 16-byte versions of the CDB.
2643  *
2644  *      RETURNS:
2645  *      Zero on success, non-zero on failure.
2646  */
2647 static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
2648 {
2649         struct ata_taskfile *tf = &(qc->tf);
2650         struct scsi_cmnd *scmd = qc->scsicmd;
2651         struct ata_device *dev = qc->dev;
2652         const u8 *cdb = scmd->cmnd;
2653
2654         if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
2655                 goto invalid_fld;
2656
2657         /* We may not issue DMA commands if no DMA mode is set */
2658         if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
2659                 goto invalid_fld;
2660
2661         /*
2662          * 12 and 16 byte CDBs use different offsets to
2663          * provide the various register values.
2664          */
2665         if (cdb[0] == ATA_16) {
2666                 /*
2667                  * 16-byte CDB - may contain extended commands.
2668                  *
2669                  * If that is the case, copy the upper byte register values.
2670                  */
2671                 if (cdb[1] & 0x01) {
2672                         tf->hob_feature = cdb[3];
2673                         tf->hob_nsect = cdb[5];
2674                         tf->hob_lbal = cdb[7];
2675                         tf->hob_lbam = cdb[9];
2676                         tf->hob_lbah = cdb[11];
2677                         tf->flags |= ATA_TFLAG_LBA48;
2678                 } else
2679                         tf->flags &= ~ATA_TFLAG_LBA48;
2680
2681                 /*
2682                  * Always copy low byte, device and command registers.
2683                  */
2684                 tf->feature = cdb[4];
2685                 tf->nsect = cdb[6];
2686                 tf->lbal = cdb[8];
2687                 tf->lbam = cdb[10];
2688                 tf->lbah = cdb[12];
2689                 tf->device = cdb[13];
2690                 tf->command = cdb[14];
2691         } else {
2692                 /*
2693                  * 12-byte CDB - incapable of extended commands.
2694                  */
2695                 tf->flags &= ~ATA_TFLAG_LBA48;
2696
2697                 tf->feature = cdb[3];
2698                 tf->nsect = cdb[4];
2699                 tf->lbal = cdb[5];
2700                 tf->lbam = cdb[6];
2701                 tf->lbah = cdb[7];
2702                 tf->device = cdb[8];
2703                 tf->command = cdb[9];
2704         }
2705
2706         /* enforce correct master/slave bit */
2707         tf->device = dev->devno ?
2708                 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
2709
2710         /* sanity check for pio multi commands */
2711         if ((cdb[1] & 0xe0) && !is_multi_taskfile(tf))
2712                 goto invalid_fld;
2713
2714         if (is_multi_taskfile(tf)) {
2715                 unsigned int multi_count = 1 << (cdb[1] >> 5);
2716
2717                 /* compare the passed through multi_count
2718                  * with the cached multi_count of libata
2719                  */
2720                 if (multi_count != dev->multi_count)
2721                         ata_dev_printk(dev, KERN_WARNING,
2722                                        "invalid multi_count %u ignored\n",
2723                                        multi_count);
2724         }
2725
2726         /* READ/WRITE LONG use a non-standard sect_size */
2727         qc->sect_size = ATA_SECT_SIZE;
2728         switch (tf->command) {
2729         case ATA_CMD_READ_LONG:
2730         case ATA_CMD_READ_LONG_ONCE:
2731         case ATA_CMD_WRITE_LONG:
2732         case ATA_CMD_WRITE_LONG_ONCE:
2733                 if (tf->protocol != ATA_PROT_PIO || tf->nsect != 1)
2734                         goto invalid_fld;
2735                 qc->sect_size = scsi_bufflen(scmd);
2736         }
2737
2738         /*
2739          * Filter SET_FEATURES - XFER MODE command -- otherwise,
2740          * SET_FEATURES - XFER MODE must be preceded/succeeded
2741          * by an update to hardware-specific registers for each
2742          * controller (i.e. the reason for ->set_piomode(),
2743          * ->set_dmamode(), and ->post_set_mode() hooks).
2744          */
2745         if ((tf->command == ATA_CMD_SET_FEATURES)
2746          && (tf->feature == SETFEATURES_XFER))
2747                 goto invalid_fld;
2748
2749         /*
2750          * Set flags so that all registers will be written,
2751          * and pass on write indication (used for PIO/DMA
2752          * setup.)
2753          */
2754         tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
2755
2756         if (scmd->sc_data_direction == DMA_TO_DEVICE)
2757                 tf->flags |= ATA_TFLAG_WRITE;
2758
2759         /*
2760          * Set transfer length.
2761          *
2762          * TODO: find out if we need to do more here to
2763          *       cover scatter/gather case.
2764          */
2765         qc->nbytes = scsi_bufflen(scmd);
2766
2767         /* request result TF */
2768         qc->flags |= ATA_QCFLAG_RESULT_TF;
2769
2770         return 0;
2771
2772  invalid_fld:
2773         ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
2774         /* "Invalid field in cdb" */
2775         return 1;
2776 }
2777
2778 /**
2779  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
2780  *      @dev: ATA device
2781  *      @cmd: SCSI command opcode to consider
2782  *
2783  *      Look up the SCSI command given, and determine whether the
2784  *      SCSI command is to be translated or simulated.
2785  *
2786  *      RETURNS:
2787  *      Pointer to translation function if possible, %NULL if not.
2788  */
2789
2790 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
2791 {
2792         switch (cmd) {
2793         case READ_6:
2794         case READ_10:
2795         case READ_16:
2796
2797         case WRITE_6:
2798         case WRITE_10:
2799         case WRITE_16:
2800                 return ata_scsi_rw_xlat;
2801
2802         case SYNCHRONIZE_CACHE:
2803                 if (ata_try_flush_cache(dev))
2804                         return ata_scsi_flush_xlat;
2805                 break;
2806
2807         case VERIFY:
2808         case VERIFY_16:
2809                 return ata_scsi_verify_xlat;
2810
2811         case ATA_12:
2812         case ATA_16:
2813                 return ata_scsi_pass_thru;
2814
2815         case START_STOP:
2816                 return ata_scsi_start_stop_xlat;
2817         }
2818
2819         return NULL;
2820 }
2821
2822 /**
2823  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
2824  *      @ap: ATA port to which the command was being sent
2825  *      @cmd: SCSI command to dump
2826  *
2827  *      Prints the contents of a SCSI command via printk().
2828  */
2829
2830 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
2831                                      struct scsi_cmnd *cmd)
2832 {
2833 #ifdef ATA_DEBUG
2834         struct scsi_device *scsidev = cmd->device;
2835         u8 *scsicmd = cmd->cmnd;
2836
2837         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
2838                 ap->print_id,
2839                 scsidev->channel, scsidev->id, scsidev->lun,
2840                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
2841                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
2842                 scsicmd[8]);
2843 #endif
2844 }
2845
2846 static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
2847                                       void (*done)(struct scsi_cmnd *),
2848                                       struct ata_device *dev)
2849 {
2850         u8 scsi_op = scmd->cmnd[0];
2851         ata_xlat_func_t xlat_func;
2852         int rc = 0;
2853
2854         if (dev->class == ATA_DEV_ATA) {
2855                 if (unlikely(!scmd->cmd_len || scmd->cmd_len > dev->cdb_len))
2856                         goto bad_cdb_len;
2857
2858                 xlat_func = ata_get_xlat_func(dev, scsi_op);
2859         } else {
2860                 if (unlikely(!scmd->cmd_len))
2861                         goto bad_cdb_len;
2862
2863                 xlat_func = NULL;
2864                 if (likely((scsi_op != ATA_16) || !atapi_passthru16)) {
2865                         /* relay SCSI command to ATAPI device */
2866                         if (unlikely(scmd->cmd_len > dev->cdb_len))
2867                                 goto bad_cdb_len;
2868
2869                         xlat_func = atapi_xlat;
2870                 } else {
2871                         /* ATA_16 passthru, treat as an ATA command */
2872                         if (unlikely(scmd->cmd_len > 16))
2873                                 goto bad_cdb_len;
2874
2875                         xlat_func = ata_get_xlat_func(dev, scsi_op);
2876                 }
2877         }
2878
2879         if (xlat_func)
2880                 rc = ata_scsi_translate(dev, scmd, done, xlat_func);
2881         else
2882                 ata_scsi_simulate(dev, scmd, done);
2883
2884         return rc;
2885
2886  bad_cdb_len:
2887         DPRINTK("bad CDB len=%u, scsi_op=0x%02x, max=%u\n",
2888                 scmd->cmd_len, scsi_op, dev->cdb_len);
2889         scmd->result = DID_ERROR << 16;
2890         done(scmd);
2891         return 0;
2892 }
2893
2894 /**
2895  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
2896  *      @cmd: SCSI command to be sent
2897  *      @done: Completion function, called when command is complete
2898  *
2899  *      In some cases, this function translates SCSI commands into
2900  *      ATA taskfiles, and queues the taskfiles to be sent to
2901  *      hardware.  In other cases, this function simulates a
2902  *      SCSI device by evaluating and responding to certain
2903  *      SCSI commands.  This creates the overall effect of
2904  *      ATA and ATAPI devices appearing as SCSI devices.
2905  *
2906  *      LOCKING:
2907  *      Releases scsi-layer-held lock, and obtains host lock.
2908  *
2909  *      RETURNS:
2910  *      Return value from __ata_scsi_queuecmd() if @cmd can be queued,
2911  *      0 otherwise.
2912  */
2913 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
2914 {
2915         struct ata_port *ap;
2916         struct ata_device *dev;
2917         struct scsi_device *scsidev = cmd->device;
2918         struct Scsi_Host *shost = scsidev->host;
2919         int rc = 0;
2920
2921         ap = ata_shost_to_port(shost);
2922
2923         spin_unlock(shost->host_lock);
2924         spin_lock(ap->lock);
2925
2926         ata_scsi_dump_cdb(ap, cmd);
2927
2928         dev = ata_scsi_find_dev(ap, scsidev);
2929         if (likely(dev))
2930                 rc = __ata_scsi_queuecmd(cmd, done, dev);
2931         else {
2932                 cmd->result = (DID_BAD_TARGET << 16);
2933                 done(cmd);
2934         }
2935
2936         spin_unlock(ap->lock);
2937         spin_lock(shost->host_lock);
2938         return rc;
2939 }
2940
2941 /**
2942  *      ata_scsi_simulate - simulate SCSI command on ATA device
2943  *      @dev: the target device
2944  *      @cmd: SCSI command being sent to device.
2945  *      @done: SCSI command completion function.
2946  *
2947  *      Interprets and directly executes a select list of SCSI commands
2948  *      that can be handled internally.
2949  *
2950  *      LOCKING:
2951  *      spin_lock_irqsave(host lock)
2952  */
2953
2954 void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
2955                       void (*done)(struct scsi_cmnd *))
2956 {
2957         struct ata_scsi_args args;
2958         const u8 *scsicmd = cmd->cmnd;
2959         u8 tmp8;
2960
2961         args.dev = dev;
2962         args.id = dev->id;
2963         args.cmd = cmd;
2964         args.done = done;
2965
2966         switch(scsicmd[0]) {
2967         /* TODO: worth improving? */
2968         case FORMAT_UNIT:
2969                 ata_scsi_invalid_field(cmd, done);
2970                 break;
2971
2972         case INQUIRY:
2973                 if (scsicmd[1] & 2)                /* is CmdDt set?  */
2974                         ata_scsi_invalid_field(cmd, done);
2975                 else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
2976                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2977                 else switch (scsicmd[2]) {
2978                 case 0x00:
2979                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2980                         break;
2981                 case 0x80:
2982                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2983                         break;
2984                 case 0x83:
2985                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2986                         break;
2987                 case 0x89:
2988                         ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
2989                         break;
2990                 default:
2991                         ata_scsi_invalid_field(cmd, done);
2992                         break;
2993                 }
2994                 break;
2995
2996         case MODE_SENSE:
2997         case MODE_SENSE_10:
2998                 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
2999                 break;
3000
3001         case MODE_SELECT:       /* unconditionally return */
3002         case MODE_SELECT_10:    /* bad-field-in-cdb */
3003                 ata_scsi_invalid_field(cmd, done);
3004                 break;
3005
3006         case READ_CAPACITY:
3007                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3008                 break;
3009
3010         case SERVICE_ACTION_IN:
3011                 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
3012                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
3013                 else
3014                         ata_scsi_invalid_field(cmd, done);
3015                 break;
3016
3017         case REPORT_LUNS:
3018                 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
3019                 break;
3020
3021         case REQUEST_SENSE:
3022                 ata_scsi_set_sense(cmd, 0, 0, 0);
3023                 cmd->result = (DRIVER_SENSE << 24);
3024                 done(cmd);
3025                 break;
3026
3027         /* if we reach this, then writeback caching is disabled,
3028          * turning this into a no-op.
3029          */
3030         case SYNCHRONIZE_CACHE:
3031                 /* fall through */
3032
3033         /* no-op's, complete with success */
3034         case REZERO_UNIT:
3035         case SEEK_6:
3036         case SEEK_10:
3037         case TEST_UNIT_READY:
3038                 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3039                 break;
3040
3041         case SEND_DIAGNOSTIC:
3042                 tmp8 = scsicmd[1] & ~(1 << 3);
3043                 if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
3044                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
3045                 else
3046                         ata_scsi_invalid_field(cmd, done);
3047                 break;
3048
3049         /* all other commands */
3050         default:
3051                 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
3052                 /* "Invalid command operation code" */
3053                 done(cmd);
3054                 break;
3055         }
3056 }
3057
3058 int ata_scsi_add_hosts(struct ata_host *host, struct scsi_host_template *sht)
3059 {
3060         int i, rc;
3061
3062         for (i = 0; i < host->n_ports; i++) {
3063                 struct ata_port *ap = host->ports[i];
3064                 struct Scsi_Host *shost;
3065
3066                 rc = -ENOMEM;
3067                 shost = scsi_host_alloc(sht, sizeof(struct ata_port *));
3068                 if (!shost)
3069                         goto err_alloc;
3070
3071                 *(struct ata_port **)&shost->hostdata[0] = ap;
3072                 ap->scsi_host = shost;
3073
3074                 shost->transportt = &ata_scsi_transport_template;
3075                 shost->unique_id = ap->print_id;
3076                 shost->max_id = 16;
3077                 shost->max_lun = 1;
3078                 shost->max_channel = 1;
3079                 shost->max_cmd_len = 16;
3080
3081                 /* Schedule policy is determined by ->qc_defer()
3082                  * callback and it needs to see every deferred qc.
3083                  * Set host_blocked to 1 to prevent SCSI midlayer from
3084                  * automatically deferring requests.
3085                  */
3086                 shost->max_host_blocked = 1;
3087
3088                 rc = scsi_add_host(ap->scsi_host, ap->host->dev);
3089                 if (rc)
3090                         goto err_add;
3091         }
3092
3093         return 0;
3094
3095  err_add:
3096         scsi_host_put(host->ports[i]->scsi_host);
3097  err_alloc:
3098         while (--i >= 0) {
3099                 struct Scsi_Host *shost = host->ports[i]->scsi_host;
3100
3101                 scsi_remove_host(shost);
3102                 scsi_host_put(shost);
3103         }
3104         return rc;
3105 }
3106
3107 void ata_scsi_scan_host(struct ata_port *ap, int sync)
3108 {
3109         int tries = 5;
3110         struct ata_device *last_failed_dev = NULL;
3111         struct ata_link *link;
3112         struct ata_device *dev;
3113
3114         if (ap->flags & ATA_FLAG_DISABLED)
3115                 return;
3116
3117  repeat:
3118         ata_port_for_each_link(link, ap) {
3119                 ata_link_for_each_dev(dev, link) {
3120                         struct scsi_device *sdev;
3121                         int channel = 0, id = 0;
3122
3123                         if (!ata_dev_enabled(dev) || dev->sdev)
3124                                 continue;
3125
3126                         if (ata_is_host_link(link))
3127                                 id = dev->devno;
3128                         else
3129                                 channel = link->pmp;
3130
3131                         sdev = __scsi_add_device(ap->scsi_host, channel, id, 0,
3132                                                  NULL);
3133                         if (!IS_ERR(sdev)) {
3134                                 dev->sdev = sdev;
3135                                 scsi_device_put(sdev);
3136                         }
3137                 }
3138         }
3139
3140         /* If we scanned while EH was in progress or allocation
3141          * failure occurred, scan would have failed silently.  Check
3142          * whether all devices are attached.
3143          */
3144         ata_port_for_each_link(link, ap) {
3145                 ata_link_for_each_dev(dev, link) {
3146                         if (ata_dev_enabled(dev) && !dev->sdev)
3147                                 goto exit_loop;
3148                 }
3149         }
3150  exit_loop:
3151         if (!link)
3152                 return;
3153
3154         /* we're missing some SCSI devices */
3155         if (sync) {
3156                 /* If caller requested synchrnous scan && we've made
3157                  * any progress, sleep briefly and repeat.
3158                  */
3159                 if (dev != last_failed_dev) {
3160                         msleep(100);
3161                         last_failed_dev = dev;
3162                         goto repeat;
3163                 }
3164
3165                 /* We might be failing to detect boot device, give it
3166                  * a few more chances.
3167                  */
3168                 if (--tries) {
3169                         msleep(100);
3170                         goto repeat;
3171                 }
3172
3173                 ata_port_printk(ap, KERN_ERR, "WARNING: synchronous SCSI scan "
3174                                 "failed without making any progress,\n"
3175                                 "                  switching to async\n");
3176         }
3177
3178         queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
3179                            round_jiffies_relative(HZ));
3180 }
3181
3182 /**
3183  *      ata_scsi_offline_dev - offline attached SCSI device
3184  *      @dev: ATA device to offline attached SCSI device for
3185  *
3186  *      This function is called from ata_eh_hotplug() and responsible
3187  *      for taking the SCSI device attached to @dev offline.  This
3188  *      function is called with host lock which protects dev->sdev
3189  *      against clearing.
3190  *
3191  *      LOCKING:
3192  *      spin_lock_irqsave(host lock)
3193  *
3194  *      RETURNS:
3195  *      1 if attached SCSI device exists, 0 otherwise.
3196  */
3197 int ata_scsi_offline_dev(struct ata_device *dev)
3198 {
3199         if (dev->sdev) {
3200                 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
3201                 return 1;
3202         }
3203         return 0;
3204 }
3205
3206 /**
3207  *      ata_scsi_remove_dev - remove attached SCSI device
3208  *      @dev: ATA device to remove attached SCSI device for
3209  *
3210  *      This function is called from ata_eh_scsi_hotplug() and
3211  *      responsible for removing the SCSI device attached to @dev.
3212  *
3213  *      LOCKING:
3214  *      Kernel thread context (may sleep).
3215  */
3216 static void ata_scsi_remove_dev(struct ata_device *dev)
3217 {
3218         struct ata_port *ap = dev->link->ap;
3219         struct scsi_device *sdev;
3220         unsigned long flags;
3221
3222         /* Alas, we need to grab scan_mutex to ensure SCSI device
3223          * state doesn't change underneath us and thus
3224          * scsi_device_get() always succeeds.  The mutex locking can
3225          * be removed if there is __scsi_device_get() interface which
3226          * increments reference counts regardless of device state.
3227          */
3228         mutex_lock(&ap->scsi_host->scan_mutex);
3229         spin_lock_irqsave(ap->lock, flags);
3230
3231         /* clearing dev->sdev is protected by host lock */
3232         sdev = dev->sdev;
3233         dev->sdev = NULL;
3234
3235         if (sdev) {
3236                 /* If user initiated unplug races with us, sdev can go
3237                  * away underneath us after the host lock and
3238                  * scan_mutex are released.  Hold onto it.
3239                  */
3240                 if (scsi_device_get(sdev) == 0) {
3241                         /* The following ensures the attached sdev is
3242                          * offline on return from ata_scsi_offline_dev()
3243                          * regardless it wins or loses the race
3244                          * against this function.
3245                          */
3246                         scsi_device_set_state(sdev, SDEV_OFFLINE);
3247                 } else {
3248                         WARN_ON(1);
3249                         sdev = NULL;
3250                 }
3251         }
3252
3253         spin_unlock_irqrestore(ap->lock, flags);
3254         mutex_unlock(&ap->scsi_host->scan_mutex);
3255
3256         if (sdev) {
3257                 ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
3258                                sdev->sdev_gendev.bus_id);
3259
3260                 scsi_remove_device(sdev);
3261                 scsi_device_put(sdev);
3262         }
3263 }
3264
3265 static void ata_scsi_handle_link_detach(struct ata_link *link)
3266 {
3267         struct ata_port *ap = link->ap;
3268         struct ata_device *dev;
3269
3270         ata_link_for_each_dev(dev, link) {
3271                 unsigned long flags;
3272
3273                 if (!(dev->flags & ATA_DFLAG_DETACHED))
3274                         continue;
3275
3276                 spin_lock_irqsave(ap->lock, flags);
3277                 dev->flags &= ~ATA_DFLAG_DETACHED;
3278                 spin_unlock_irqrestore(ap->lock, flags);
3279
3280                 ata_scsi_remove_dev(dev);
3281         }
3282 }
3283
3284 /**
3285  *      ata_scsi_media_change_notify - send media change event
3286  *      @dev: Pointer to the disk device with media change event
3287  *
3288  *      Tell the block layer to send a media change notification
3289  *      event.
3290  *
3291  *      LOCKING:
3292  *      spin_lock_irqsave(host lock)
3293  */
3294 void ata_scsi_media_change_notify(struct ata_device *dev)
3295 {
3296 #ifdef OTHER_AN_PATCHES_HAVE_BEEN_APPLIED
3297         if (dev->sdev)
3298                 scsi_device_event_notify(dev->sdev, SDEV_MEDIA_CHANGE);
3299 #endif
3300 }
3301
3302 /**
3303  *      ata_scsi_hotplug - SCSI part of hotplug
3304  *      @work: Pointer to ATA port to perform SCSI hotplug on
3305  *
3306  *      Perform SCSI part of hotplug.  It's executed from a separate
3307  *      workqueue after EH completes.  This is necessary because SCSI
3308  *      hot plugging requires working EH and hot unplugging is
3309  *      synchronized with hot plugging with a mutex.
3310  *
3311  *      LOCKING:
3312  *      Kernel thread context (may sleep).
3313  */
3314 void ata_scsi_hotplug(struct work_struct *work)
3315 {
3316         struct ata_port *ap =
3317                 container_of(work, struct ata_port, hotplug_task.work);
3318         int i;
3319
3320         if (ap->pflags & ATA_PFLAG_UNLOADING) {
3321                 DPRINTK("ENTER/EXIT - unloading\n");
3322                 return;
3323         }
3324
3325         DPRINTK("ENTER\n");
3326
3327         /* Unplug detached devices.  We cannot use link iterator here
3328          * because PMP links have to be scanned even if PMP is
3329          * currently not attached.  Iterate manually.
3330          */
3331         ata_scsi_handle_link_detach(&ap->link);
3332         if (ap->pmp_link)
3333                 for (i = 0; i < SATA_PMP_MAX_PORTS; i++)
3334                         ata_scsi_handle_link_detach(&ap->pmp_link[i]);
3335
3336         /* scan for new ones */
3337         ata_scsi_scan_host(ap, 0);
3338
3339         DPRINTK("EXIT\n");
3340 }
3341
3342 /**
3343  *      ata_scsi_user_scan - indication for user-initiated bus scan
3344  *      @shost: SCSI host to scan
3345  *      @channel: Channel to scan
3346  *      @id: ID to scan
3347  *      @lun: LUN to scan
3348  *
3349  *      This function is called when user explicitly requests bus
3350  *      scan.  Set probe pending flag and invoke EH.
3351  *
3352  *      LOCKING:
3353  *      SCSI layer (we don't care)
3354  *
3355  *      RETURNS:
3356  *      Zero.
3357  */
3358 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
3359                               unsigned int id, unsigned int lun)
3360 {
3361         struct ata_port *ap = ata_shost_to_port(shost);
3362         unsigned long flags;
3363         int devno, rc = 0;
3364
3365         if (!ap->ops->error_handler)
3366                 return -EOPNOTSUPP;
3367
3368         if (lun != SCAN_WILD_CARD && lun)
3369                 return -EINVAL;
3370
3371         if (ap->nr_pmp_links == 0) {
3372                 if (channel != SCAN_WILD_CARD && channel)
3373                         return -EINVAL;
3374                 devno = id;
3375         } else {
3376                 if (id != SCAN_WILD_CARD && id)
3377                         return -EINVAL;
3378                 devno = channel;
3379         }
3380
3381         spin_lock_irqsave(ap->lock, flags);
3382
3383         if (devno == SCAN_WILD_CARD) {
3384                 struct ata_link *link;
3385
3386                 ata_port_for_each_link(link, ap) {
3387                         struct ata_eh_info *ehi = &link->eh_info;
3388                         ehi->probe_mask |= (1 << ata_link_max_devices(link)) - 1;
3389                         ehi->action |= ATA_EH_SOFTRESET;
3390                 }
3391         } else {
3392                 struct ata_device *dev = ata_find_dev(ap, devno);
3393
3394                 if (dev) {
3395                         struct ata_eh_info *ehi = &dev->link->eh_info;
3396                         ehi->probe_mask |= 1 << dev->devno;
3397                         ehi->action |= ATA_EH_SOFTRESET;
3398                         ehi->flags |= ATA_EHI_RESUME_LINK;
3399                 } else
3400                         rc = -EINVAL;
3401         }
3402
3403         if (rc == 0) {
3404                 ata_port_schedule_eh(ap);
3405                 spin_unlock_irqrestore(ap->lock, flags);
3406                 ata_port_wait_eh(ap);
3407         } else
3408                 spin_unlock_irqrestore(ap->lock, flags);
3409
3410         return rc;
3411 }
3412
3413 /**
3414  *      ata_scsi_dev_rescan - initiate scsi_rescan_device()
3415  *      @work: Pointer to ATA port to perform scsi_rescan_device()
3416  *
3417  *      After ATA pass thru (SAT) commands are executed successfully,
3418  *      libata need to propagate the changes to SCSI layer.  This
3419  *      function must be executed from ata_aux_wq such that sdev
3420  *      attach/detach don't race with rescan.
3421  *
3422  *      LOCKING:
3423  *      Kernel thread context (may sleep).
3424  */
3425 void ata_scsi_dev_rescan(struct work_struct *work)
3426 {
3427         struct ata_port *ap =
3428                 container_of(work, struct ata_port, scsi_rescan_task);
3429         struct ata_link *link;
3430         struct ata_device *dev;
3431         unsigned long flags;
3432
3433         spin_lock_irqsave(ap->lock, flags);
3434
3435         ata_port_for_each_link(link, ap) {
3436                 ata_link_for_each_dev(dev, link) {
3437                         struct scsi_device *sdev = dev->sdev;
3438
3439                         if (!ata_dev_enabled(dev) || !sdev)
3440                                 continue;
3441                         if (scsi_device_get(sdev))
3442                                 continue;
3443
3444                         spin_unlock_irqrestore(ap->lock, flags);
3445                         scsi_rescan_device(&(sdev->sdev_gendev));
3446                         scsi_device_put(sdev);
3447                         spin_lock_irqsave(ap->lock, flags);
3448                 }
3449         }
3450
3451         spin_unlock_irqrestore(ap->lock, flags);
3452 }
3453
3454 /**
3455  *      ata_sas_port_alloc - Allocate port for a SAS attached SATA device
3456  *      @host: ATA host container for all SAS ports
3457  *      @port_info: Information from low-level host driver
3458  *      @shost: SCSI host that the scsi device is attached to
3459  *
3460  *      LOCKING:
3461  *      PCI/etc. bus probe sem.
3462  *
3463  *      RETURNS:
3464  *      ata_port pointer on success / NULL on failure.
3465  */
3466
3467 struct ata_port *ata_sas_port_alloc(struct ata_host *host,
3468                                     struct ata_port_info *port_info,
3469                                     struct Scsi_Host *shost)
3470 {
3471         struct ata_port *ap;
3472
3473         ap = ata_port_alloc(host);
3474         if (!ap)
3475                 return NULL;
3476
3477         ap->port_no = 0;
3478         ap->lock = shost->host_lock;
3479         ap->pio_mask = port_info->pio_mask;
3480         ap->mwdma_mask = port_info->mwdma_mask;
3481         ap->udma_mask = port_info->udma_mask;
3482         ap->flags |= port_info->flags;
3483         ap->ops = port_info->port_ops;
3484         ap->cbl = ATA_CBL_SATA;
3485
3486         return ap;
3487 }
3488 EXPORT_SYMBOL_GPL(ata_sas_port_alloc);
3489
3490 /**
3491  *      ata_sas_port_start - Set port up for dma.
3492  *      @ap: Port to initialize
3493  *
3494  *      Called just after data structures for each port are
3495  *      initialized.  Allocates DMA pad.
3496  *
3497  *      May be used as the port_start() entry in ata_port_operations.
3498  *
3499  *      LOCKING:
3500  *      Inherited from caller.
3501  */
3502 int ata_sas_port_start(struct ata_port *ap)
3503 {
3504         return ata_pad_alloc(ap, ap->dev);
3505 }
3506 EXPORT_SYMBOL_GPL(ata_sas_port_start);
3507
3508 /**
3509  *      ata_port_stop - Undo ata_sas_port_start()
3510  *      @ap: Port to shut down
3511  *
3512  *      Frees the DMA pad.
3513  *
3514  *      May be used as the port_stop() entry in ata_port_operations.
3515  *
3516  *      LOCKING:
3517  *      Inherited from caller.
3518  */
3519
3520 void ata_sas_port_stop(struct ata_port *ap)
3521 {
3522         ata_pad_free(ap, ap->dev);
3523 }
3524 EXPORT_SYMBOL_GPL(ata_sas_port_stop);
3525
3526 /**
3527  *      ata_sas_port_init - Initialize a SATA device
3528  *      @ap: SATA port to initialize
3529  *
3530  *      LOCKING:
3531  *      PCI/etc. bus probe sem.
3532  *
3533  *      RETURNS:
3534  *      Zero on success, non-zero on error.
3535  */
3536
3537 int ata_sas_port_init(struct ata_port *ap)
3538 {
3539         int rc = ap->ops->port_start(ap);
3540
3541         if (!rc) {
3542                 ap->print_id = ata_print_id++;
3543                 rc = ata_bus_probe(ap);
3544         }
3545
3546         return rc;
3547 }
3548 EXPORT_SYMBOL_GPL(ata_sas_port_init);
3549
3550 /**
3551  *      ata_sas_port_destroy - Destroy a SATA port allocated by ata_sas_port_alloc
3552  *      @ap: SATA port to destroy
3553  *
3554  */
3555
3556 void ata_sas_port_destroy(struct ata_port *ap)
3557 {
3558         if (ap->ops->port_stop)
3559                 ap->ops->port_stop(ap);
3560         kfree(ap);
3561 }
3562 EXPORT_SYMBOL_GPL(ata_sas_port_destroy);
3563
3564 /**
3565  *      ata_sas_slave_configure - Default slave_config routine for libata devices
3566  *      @sdev: SCSI device to configure
3567  *      @ap: ATA port to which SCSI device is attached
3568  *
3569  *      RETURNS:
3570  *      Zero.
3571  */
3572
3573 int ata_sas_slave_configure(struct scsi_device *sdev, struct ata_port *ap)
3574 {
3575         ata_scsi_sdev_config(sdev);
3576         ata_scsi_dev_config(sdev, ap->link.device);
3577         return 0;
3578 }
3579 EXPORT_SYMBOL_GPL(ata_sas_slave_configure);
3580
3581 /**
3582  *      ata_sas_queuecmd - Issue SCSI cdb to libata-managed device
3583  *      @cmd: SCSI command to be sent
3584  *      @done: Completion function, called when command is complete
3585  *      @ap:    ATA port to which the command is being sent
3586  *
3587  *      RETURNS:
3588  *      Return value from __ata_scsi_queuecmd() if @cmd can be queued,
3589  *      0 otherwise.
3590  */
3591
3592 int ata_sas_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *),
3593                      struct ata_port *ap)
3594 {
3595         int rc = 0;
3596
3597         ata_scsi_dump_cdb(ap, cmd);
3598
3599         if (likely(ata_scsi_dev_enabled(ap->link.device)))
3600                 rc = __ata_scsi_queuecmd(cmd, done, ap->link.device);
3601         else {
3602                 cmd->result = (DID_BAD_TARGET << 16);
3603                 done(cmd);
3604         }
3605         return rc;
3606 }
3607 EXPORT_SYMBOL_GPL(ata_sas_queuecmd);