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