[PATCH] libata handle the case when device returns/needs extra data
[linux-3.10.git] / drivers / scsi / libata-scsi.c
1 /*
2    libata-scsi.c - helper library for ATA
3
4    Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
5    Copyright 2003-2004 Jeff Garzik
6
7    The contents of this file are subject to the Open
8    Software License version 1.1 that can be found at
9    http://www.opensource.org/licenses/osl-1.1.txt and is included herein
10    by reference.
11
12    Alternatively, the contents of this file may be used under the terms
13    of the GNU General Public License version 2 (the "GPL") as distributed
14    in the kernel source COPYING file, in which case the provisions of
15    the GPL are applicable instead of the above.  If you wish to allow
16    the use of your version of this file only under the terms of the
17    GPL and not to allow others to use your version of this file under
18    the OSL, indicate your decision by deleting the provisions above and
19    replace them with the notice and other provisions required by the GPL.
20    If you do not delete the provisions above, a recipient may use your
21    version of this file under either the OSL or the GPL.
22
23  */
24
25 #include <linux/kernel.h>
26 #include <linux/blkdev.h>
27 #include <linux/spinlock.h>
28 #include <scsi/scsi.h>
29 #include "scsi.h"
30 #include <scsi/scsi_host.h>
31 #include <linux/libata.h>
32 #include <asm/uaccess.h>
33
34 #include "libata.h"
35
36 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc, u8 *scsicmd);
37 static struct ata_device *
38 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev);
39
40
41 /**
42  *      ata_std_bios_param - generic bios head/sector/cylinder calculator used by sd.
43  *      @sdev: SCSI device for which BIOS geometry is to be determined
44  *      @bdev: block device associated with @sdev
45  *      @capacity: capacity of SCSI device
46  *      @geom: location to which geometry will be output
47  *
48  *      Generic bios head/sector/cylinder calculator
49  *      used by sd. Most BIOSes nowadays expect a XXX/255/16  (CHS)
50  *      mapping. Some situations may arise where the disk is not
51  *      bootable if this is not used.
52  *
53  *      LOCKING:
54  *      Defined by the SCSI layer.  We don't really care.
55  *
56  *      RETURNS:
57  *      Zero.
58  */
59 int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
60                        sector_t capacity, int geom[])
61 {
62         geom[0] = 255;
63         geom[1] = 63;
64         sector_div(capacity, 255*63);
65         geom[2] = capacity;
66
67         return 0;
68 }
69
70 int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
71 {
72         struct ata_port *ap;
73         struct ata_device *dev;
74         int val = -EINVAL, rc = -EINVAL;
75
76         ap = (struct ata_port *) &scsidev->host->hostdata[0];
77         if (!ap)
78                 goto out;
79
80         dev = ata_scsi_find_dev(ap, scsidev);
81         if (!dev) {
82                 rc = -ENODEV;
83                 goto out;
84         }
85
86         switch (cmd) {
87         case ATA_IOC_GET_IO32:
88                 val = 0;
89                 if (copy_to_user(arg, &val, 1))
90                         return -EFAULT;
91                 return 0;
92
93         case ATA_IOC_SET_IO32:
94                 val = (unsigned long) arg;
95                 if (val != 0)
96                         return -EINVAL;
97                 return 0;
98
99         default:
100                 rc = -ENOTTY;
101                 break;
102         }
103
104 out:
105         return rc;
106 }
107
108 /**
109  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
110  *      @ap: ATA port to which the new command is attached
111  *      @dev: ATA device to which the new command is attached
112  *      @cmd: SCSI command that originated this ATA command
113  *      @done: SCSI command completion function
114  *
115  *      Obtain a reference to an unused ata_queued_cmd structure,
116  *      which is the basic libata structure representing a single
117  *      ATA command sent to the hardware.
118  *
119  *      If a command was available, fill in the SCSI-specific
120  *      portions of the structure with information on the
121  *      current command.
122  *
123  *      LOCKING:
124  *      spin_lock_irqsave(host_set lock)
125  *
126  *      RETURNS:
127  *      Command allocated, or %NULL if none available.
128  */
129 struct ata_queued_cmd *ata_scsi_qc_new(struct ata_port *ap,
130                                        struct ata_device *dev,
131                                        struct scsi_cmnd *cmd,
132                                        void (*done)(struct scsi_cmnd *))
133 {
134         struct ata_queued_cmd *qc;
135
136         qc = ata_qc_new_init(ap, dev);
137         if (qc) {
138                 qc->scsicmd = cmd;
139                 qc->scsidone = done;
140
141                 if (cmd->use_sg) {
142                         qc->sg = (struct scatterlist *) cmd->request_buffer;
143                         qc->n_elem = cmd->use_sg;
144                 } else {
145                         qc->sg = &qc->sgent;
146                         qc->n_elem = 1;
147                 }
148         } else {
149                 cmd->result = (DID_OK << 16) | (QUEUE_FULL << 1);
150                 done(cmd);
151         }
152
153         return qc;
154 }
155
156 /**
157  *      ata_to_sense_error - convert ATA error to SCSI error
158  *      @qc: Command that we are erroring out
159  *      @drv_stat: value contained in ATA status register
160  *
161  *      Converts an ATA error into a SCSI error. While we are at it
162  *      we decode and dump the ATA error for the user so that they
163  *      have some idea what really happened at the non make-believe
164  *      layer.
165  *
166  *      LOCKING:
167  *      spin_lock_irqsave(host_set lock)
168  */
169
170 void ata_to_sense_error(struct ata_queued_cmd *qc, u8 drv_stat)
171 {
172         struct scsi_cmnd *cmd = qc->scsicmd;
173         u8 err = 0;
174         unsigned char *sb = cmd->sense_buffer;
175         /* Based on the 3ware driver translation table */
176         static unsigned char sense_table[][4] = {
177                 /* BBD|ECC|ID|MAR */
178                 {0xd1,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
179                 /* BBD|ECC|ID */
180                 {0xd0,          ABORTED_COMMAND, 0x00, 0x00},   // Device busy                  Aborted command
181                 /* ECC|MC|MARK */
182                 {0x61,          HARDWARE_ERROR, 0x00, 0x00},    // Device fault                 Hardware error
183                 /* ICRC|ABRT */         /* NB: ICRC & !ABRT is BBD */
184                 {0x84,          ABORTED_COMMAND, 0x47, 0x00},   // Data CRC error               SCSI parity error
185                 /* MC|ID|ABRT|TRK0|MARK */
186                 {0x37,          NOT_READY, 0x04, 0x00},         // Unit offline                 Not ready
187                 /* MCR|MARK */
188                 {0x09,          NOT_READY, 0x04, 0x00},         // Unrecovered disk error       Not ready
189                 /*  Bad address mark */
190                 {0x01,          MEDIUM_ERROR, 0x13, 0x00},      // Address mark not found       Address mark not found for data field
191                 /* TRK0 */
192                 {0x02,          HARDWARE_ERROR, 0x00, 0x00},    // Track 0 not found              Hardware error
193                 /* Abort & !ICRC */
194                 {0x04,          ABORTED_COMMAND, 0x00, 0x00},   // Aborted command              Aborted command
195                 /* Media change request */
196                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change request   FIXME: faking offline
197                 /* SRV */
198                 {0x10,          ABORTED_COMMAND, 0x14, 0x00},   // ID not found                 Recorded entity not found
199                 /* Media change */
200                 {0x08,          NOT_READY, 0x04, 0x00},         // Media change           FIXME: faking offline
201                 /* ECC */
202                 {0x40,          MEDIUM_ERROR, 0x11, 0x04},      // Uncorrectable ECC error      Unrecovered read error
203                 /* BBD - block marked bad */
204                 {0x80,          MEDIUM_ERROR, 0x11, 0x04},      // Block marked bad               Medium error, unrecovered read error
205                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
206         };
207         static unsigned char stat_table[][4] = {
208                 /* Must be first because BUSY means no other bits valid */
209                 {0x80,          ABORTED_COMMAND, 0x47, 0x00},   // Busy, fake parity for now
210                 {0x20,          HARDWARE_ERROR,  0x00, 0x00},   // Device fault
211                 {0x08,          ABORTED_COMMAND, 0x47, 0x00},   // Timed out in xfer, fake parity for now
212                 {0x04,          RECOVERED_ERROR, 0x11, 0x00},   // Recovered ECC error    Medium error, recovered
213                 {0xFF, 0xFF, 0xFF, 0xFF}, // END mark
214         };
215         int i = 0;
216
217         cmd->result = SAM_STAT_CHECK_CONDITION;
218
219         /*
220          *      Is this an error we can process/parse
221          */
222
223         if(drv_stat & ATA_ERR)
224                 /* Read the err bits */
225                 err = ata_chk_err(qc->ap);
226
227         /* Display the ATA level error info */
228
229         printk(KERN_WARNING "ata%u: status=0x%02x { ", qc->ap->id, drv_stat);
230         if(drv_stat & 0x80)
231         {
232                 printk("Busy ");
233                 err = 0;        /* Data is not valid in this case */
234         }
235         else {
236                 if(drv_stat & 0x40)     printk("DriveReady ");
237                 if(drv_stat & 0x20)     printk("DeviceFault ");
238                 if(drv_stat & 0x10)     printk("SeekComplete ");
239                 if(drv_stat & 0x08)     printk("DataRequest ");
240                 if(drv_stat & 0x04)     printk("CorrectedError ");
241                 if(drv_stat & 0x02)     printk("Index ");
242                 if(drv_stat & 0x01)     printk("Error ");
243         }
244         printk("}\n");
245
246         if(err)
247         {
248                 printk(KERN_WARNING "ata%u: error=0x%02x { ", qc->ap->id, err);
249                 if(err & 0x04)          printk("DriveStatusError ");
250                 if(err & 0x80)
251                 {
252                         if(err & 0x04)
253                                 printk("BadCRC ");
254                         else
255                                 printk("Sector ");
256                 }
257                 if(err & 0x40)          printk("UncorrectableError ");
258                 if(err & 0x10)          printk("SectorIdNotFound ");
259                 if(err & 0x02)          printk("TrackZeroNotFound ");
260                 if(err & 0x01)          printk("AddrMarkNotFound ");
261                 printk("}\n");
262
263                 /* Should we dump sector info here too ?? */
264         }
265
266
267         /* Look for err */
268         while(sense_table[i][0] != 0xFF)
269         {
270                 /* Look for best matches first */
271                 if((sense_table[i][0] & err) == sense_table[i][0])
272                 {
273                         sb[0] = 0x70;
274                         sb[2] = sense_table[i][1];
275                         sb[7] = 0x0a;
276                         sb[12] = sense_table[i][2];
277                         sb[13] = sense_table[i][3];
278                         return;
279                 }
280                 i++;
281         }
282         /* No immediate match */
283         if(err)
284                 printk(KERN_DEBUG "ata%u: no sense translation for 0x%02x\n", qc->ap->id, err);
285
286         i = 0;
287         /* Fall back to interpreting status bits */
288         while(stat_table[i][0] != 0xFF)
289         {
290                 if(stat_table[i][0] & drv_stat)
291                 {
292                         sb[0] = 0x70;
293                         sb[2] = stat_table[i][1];
294                         sb[7] = 0x0a;
295                         sb[12] = stat_table[i][2];
296                         sb[13] = stat_table[i][3];
297                         return;
298                 }
299                 i++;
300         }
301         /* No error ?? */
302         printk(KERN_ERR "ata%u: called with no error (%02X)!\n", qc->ap->id, drv_stat);
303         /* additional-sense-code[-qualifier] */
304
305         sb[0] = 0x70;
306         sb[2] = MEDIUM_ERROR;
307         sb[7] = 0x0A;
308         if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
309                 sb[12] = 0x11; /* "unrecovered read error" */
310                 sb[13] = 0x04;
311         } else {
312                 sb[12] = 0x0C; /* "write error -             */
313                 sb[13] = 0x02; /*  auto-reallocation failed" */
314         }
315 }
316
317 /**
318  *      ata_scsi_slave_config - Set SCSI device attributes
319  *      @sdev: SCSI device to examine
320  *
321  *      This is called before we actually start reading
322  *      and writing to the device, to configure certain
323  *      SCSI mid-layer behaviors.
324  *
325  *      LOCKING:
326  *      Defined by SCSI layer.  We don't really care.
327  */
328
329 int ata_scsi_slave_config(struct scsi_device *sdev)
330 {
331         sdev->use_10_for_rw = 1;
332         sdev->use_10_for_ms = 1;
333
334         blk_queue_max_phys_segments(sdev->request_queue, LIBATA_MAX_PRD);
335
336         if (sdev->id < ATA_MAX_DEVICES) {
337                 struct ata_port *ap;
338                 struct ata_device *dev;
339
340                 ap = (struct ata_port *) &sdev->host->hostdata[0];
341                 dev = &ap->device[sdev->id];
342
343                 /* TODO: 1024 is an arbitrary number, not the
344                  * hardware maximum.  This should be increased to
345                  * 65534 when Jens Axboe's patch for dynamically
346                  * determining max_sectors is merged.
347                  */
348                 if ((dev->flags & ATA_DFLAG_LBA48) &&
349                     ((dev->flags & ATA_DFLAG_LOCK_SECTORS) == 0)) {
350                         /*
351                          * do not overwrite sdev->host->max_sectors, since
352                          * other drives on this host may not support LBA48
353                          */
354                         blk_queue_max_sectors(sdev->request_queue, 2048);
355                 }
356         }
357
358         return 0;       /* scsi layer doesn't check return value, sigh */
359 }
360
361 /**
362  *      ata_scsi_error - SCSI layer error handler callback
363  *      @host: SCSI host on which error occurred
364  *
365  *      Handles SCSI-layer-thrown error events.
366  *
367  *      LOCKING:
368  *      Inherited from SCSI layer (none, can sleep)
369  *
370  *      RETURNS:
371  *      Zero.
372  */
373
374 int ata_scsi_error(struct Scsi_Host *host)
375 {
376         struct ata_port *ap;
377
378         DPRINTK("ENTER\n");
379
380         ap = (struct ata_port *) &host->hostdata[0];
381         ap->ops->eng_timeout(ap);
382
383         /* TODO: this is per-command; when queueing is supported
384          * this code will either change or move to a more
385          * appropriate place
386          */
387         host->host_failed--;
388         INIT_LIST_HEAD(&host->eh_cmd_q);
389
390         DPRINTK("EXIT\n");
391         return 0;
392 }
393
394 /**
395  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
396  *      @qc: Storage for translated ATA taskfile
397  *      @scsicmd: SCSI command to translate (ignored)
398  *
399  *      Sets up an ATA taskfile to issue FLUSH CACHE or
400  *      FLUSH CACHE EXT.
401  *
402  *      LOCKING:
403  *      spin_lock_irqsave(host_set lock)
404  *
405  *      RETURNS:
406  *      Zero on success, non-zero on error.
407  */
408
409 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
410 {
411         struct ata_taskfile *tf = &qc->tf;
412
413         tf->flags |= ATA_TFLAG_DEVICE;
414         tf->protocol = ATA_PROT_NODATA;
415
416         if ((tf->flags & ATA_TFLAG_LBA48) &&
417             (ata_id_has_flush_ext(qc->dev->id)))
418                 tf->command = ATA_CMD_FLUSH_EXT;
419         else
420                 tf->command = ATA_CMD_FLUSH;
421
422         return 0;
423 }
424
425 /**
426  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
427  *      @qc: Storage for translated ATA taskfile
428  *      @scsicmd: SCSI command to translate
429  *
430  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
431  *
432  *      LOCKING:
433  *      spin_lock_irqsave(host_set lock)
434  *
435  *      RETURNS:
436  *      Zero on success, non-zero on error.
437  */
438
439 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
440 {
441         struct ata_taskfile *tf = &qc->tf;
442         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
443         u64 dev_sectors = qc->dev->n_sectors;
444         u64 sect = 0;
445         u32 n_sect = 0;
446
447         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
448         tf->protocol = ATA_PROT_NODATA;
449         tf->device |= ATA_LBA;
450
451         if (scsicmd[0] == VERIFY) {
452                 sect |= ((u64)scsicmd[2]) << 24;
453                 sect |= ((u64)scsicmd[3]) << 16;
454                 sect |= ((u64)scsicmd[4]) << 8;
455                 sect |= ((u64)scsicmd[5]);
456
457                 n_sect |= ((u32)scsicmd[7]) << 8;
458                 n_sect |= ((u32)scsicmd[8]);
459         }
460
461         else if (scsicmd[0] == VERIFY_16) {
462                 sect |= ((u64)scsicmd[2]) << 56;
463                 sect |= ((u64)scsicmd[3]) << 48;
464                 sect |= ((u64)scsicmd[4]) << 40;
465                 sect |= ((u64)scsicmd[5]) << 32;
466                 sect |= ((u64)scsicmd[6]) << 24;
467                 sect |= ((u64)scsicmd[7]) << 16;
468                 sect |= ((u64)scsicmd[8]) << 8;
469                 sect |= ((u64)scsicmd[9]);
470
471                 n_sect |= ((u32)scsicmd[10]) << 24;
472                 n_sect |= ((u32)scsicmd[11]) << 16;
473                 n_sect |= ((u32)scsicmd[12]) << 8;
474                 n_sect |= ((u32)scsicmd[13]);
475         }
476
477         else
478                 return 1;
479
480         if (!n_sect)
481                 return 1;
482         if (sect >= dev_sectors)
483                 return 1;
484         if ((sect + n_sect) > dev_sectors)
485                 return 1;
486         if (lba48) {
487                 if (n_sect > (64 * 1024))
488                         return 1;
489         } else {
490                 if (n_sect > 256)
491                         return 1;
492         }
493
494         if (lba48) {
495                 tf->command = ATA_CMD_VERIFY_EXT;
496
497                 tf->hob_nsect = (n_sect >> 8) & 0xff;
498
499                 tf->hob_lbah = (sect >> 40) & 0xff;
500                 tf->hob_lbam = (sect >> 32) & 0xff;
501                 tf->hob_lbal = (sect >> 24) & 0xff;
502         } else {
503                 tf->command = ATA_CMD_VERIFY;
504
505                 tf->device |= (sect >> 24) & 0xf;
506         }
507
508         tf->nsect = n_sect & 0xff;
509
510         tf->lbah = (sect >> 16) & 0xff;
511         tf->lbam = (sect >> 8) & 0xff;
512         tf->lbal = sect & 0xff;
513
514         return 0;
515 }
516
517 /**
518  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
519  *      @qc: Storage for translated ATA taskfile
520  *      @scsicmd: SCSI command to translate
521  *
522  *      Converts any of six SCSI read/write commands into the
523  *      ATA counterpart, including starting sector (LBA),
524  *      sector count, and taking into account the device's LBA48
525  *      support.
526  *
527  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
528  *      %WRITE_16 are currently supported.
529  *
530  *      LOCKING:
531  *      spin_lock_irqsave(host_set lock)
532  *
533  *      RETURNS:
534  *      Zero on success, non-zero on error.
535  */
536
537 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
538 {
539         struct ata_taskfile *tf = &qc->tf;
540         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
541
542         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
543         tf->protocol = qc->dev->xfer_protocol;
544         tf->device |= ATA_LBA;
545
546         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
547             scsicmd[0] == READ_16) {
548                 tf->command = qc->dev->read_cmd;
549         } else {
550                 tf->command = qc->dev->write_cmd;
551                 tf->flags |= ATA_TFLAG_WRITE;
552         }
553
554         if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
555                 if (lba48) {
556                         tf->hob_nsect = scsicmd[7];
557                         tf->hob_lbal = scsicmd[2];
558
559                         qc->nsect = ((unsigned int)scsicmd[7] << 8) |
560                                         scsicmd[8];
561                 } else {
562                         /* if we don't support LBA48 addressing, the request
563                          * -may- be too large. */
564                         if ((scsicmd[2] & 0xf0) || scsicmd[7])
565                                 return 1;
566
567                         /* stores LBA27:24 in lower 4 bits of device reg */
568                         tf->device |= scsicmd[2];
569
570                         qc->nsect = scsicmd[8];
571                 }
572
573                 tf->nsect = scsicmd[8];
574                 tf->lbal = scsicmd[5];
575                 tf->lbam = scsicmd[4];
576                 tf->lbah = scsicmd[3];
577
578                 VPRINTK("ten-byte command\n");
579                 return 0;
580         }
581
582         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
583                 qc->nsect = tf->nsect = scsicmd[4];
584                 tf->lbal = scsicmd[3];
585                 tf->lbam = scsicmd[2];
586                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
587
588                 VPRINTK("six-byte command\n");
589                 return 0;
590         }
591
592         if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
593                 /* rule out impossible LBAs and sector counts */
594                 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
595                         return 1;
596
597                 if (lba48) {
598                         tf->hob_nsect = scsicmd[12];
599                         tf->hob_lbal = scsicmd[6];
600                         tf->hob_lbam = scsicmd[5];
601                         tf->hob_lbah = scsicmd[4];
602
603                         qc->nsect = ((unsigned int)scsicmd[12] << 8) |
604                                         scsicmd[13];
605                 } else {
606                         /* once again, filter out impossible non-zero values */
607                         if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
608                             (scsicmd[6] & 0xf0))
609                                 return 1;
610
611                         /* stores LBA27:24 in lower 4 bits of device reg */
612                         tf->device |= scsicmd[6];
613
614                         qc->nsect = scsicmd[13];
615                 }
616
617                 tf->nsect = scsicmd[13];
618                 tf->lbal = scsicmd[9];
619                 tf->lbam = scsicmd[8];
620                 tf->lbah = scsicmd[7];
621
622                 VPRINTK("sixteen-byte command\n");
623                 return 0;
624         }
625
626         DPRINTK("no-byte command\n");
627         return 1;
628 }
629
630 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
631 {
632         struct scsi_cmnd *cmd = qc->scsicmd;
633
634         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
635                 ata_to_sense_error(qc, drv_stat);
636         else
637                 cmd->result = SAM_STAT_GOOD;
638
639         qc->scsidone(cmd);
640
641         return 0;
642 }
643
644 /**
645  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
646  *      @ap: ATA port to which the command is addressed
647  *      @dev: ATA device to which the command is addressed
648  *      @cmd: SCSI command to execute
649  *      @done: SCSI command completion function
650  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
651  *
652  *      Our ->queuecommand() function has decided that the SCSI
653  *      command issued can be directly translated into an ATA
654  *      command, rather than handled internally.
655  *
656  *      This function sets up an ata_queued_cmd structure for the
657  *      SCSI command, and sends that ata_queued_cmd to the hardware.
658  *
659  *      LOCKING:
660  *      spin_lock_irqsave(host_set lock)
661  */
662
663 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
664                               struct scsi_cmnd *cmd,
665                               void (*done)(struct scsi_cmnd *),
666                               ata_xlat_func_t xlat_func)
667 {
668         struct ata_queued_cmd *qc;
669         u8 *scsicmd = cmd->cmnd;
670
671         VPRINTK("ENTER\n");
672
673         qc = ata_scsi_qc_new(ap, dev, cmd, done);
674         if (!qc)
675                 return;
676
677         /* data is present; dma-map it */
678         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
679             cmd->sc_data_direction == DMA_TO_DEVICE) {
680                 if (unlikely(cmd->request_bufflen < 1)) {
681                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
682                                ap->id, dev->devno);
683                         goto err_out;
684                 }
685
686                 if (cmd->use_sg)
687                         ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
688                 else
689                         ata_sg_init_one(qc, cmd->request_buffer,
690                                         cmd->request_bufflen);
691
692                 qc->dma_dir = cmd->sc_data_direction;
693         }
694
695         qc->complete_fn = ata_scsi_qc_complete;
696
697         if (xlat_func(qc, scsicmd))
698                 goto err_out;
699
700         /* select device, send command to hardware */
701         if (ata_qc_issue(qc))
702                 goto err_out;
703
704         VPRINTK("EXIT\n");
705         return;
706
707 err_out:
708         ata_qc_free(qc);
709         ata_bad_cdb(cmd, done);
710         DPRINTK("EXIT - badcmd\n");
711 }
712
713 /**
714  *      ata_scsi_rbuf_get - Map response buffer.
715  *      @cmd: SCSI command containing buffer to be mapped.
716  *      @buf_out: Pointer to mapped area.
717  *
718  *      Maps buffer contained within SCSI command @cmd.
719  *
720  *      LOCKING:
721  *      spin_lock_irqsave(host_set lock)
722  *
723  *      RETURNS:
724  *      Length of response buffer.
725  */
726
727 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
728 {
729         u8 *buf;
730         unsigned int buflen;
731
732         if (cmd->use_sg) {
733                 struct scatterlist *sg;
734
735                 sg = (struct scatterlist *) cmd->request_buffer;
736                 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
737                 buflen = sg->length;
738         } else {
739                 buf = cmd->request_buffer;
740                 buflen = cmd->request_bufflen;
741         }
742
743         *buf_out = buf;
744         return buflen;
745 }
746
747 /**
748  *      ata_scsi_rbuf_put - Unmap response buffer.
749  *      @cmd: SCSI command containing buffer to be unmapped.
750  *      @buf: buffer to unmap
751  *
752  *      Unmaps response buffer contained within @cmd.
753  *
754  *      LOCKING:
755  *      spin_lock_irqsave(host_set lock)
756  */
757
758 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
759 {
760         if (cmd->use_sg) {
761                 struct scatterlist *sg;
762
763                 sg = (struct scatterlist *) cmd->request_buffer;
764                 kunmap_atomic(buf - sg->offset, KM_USER0);
765         }
766 }
767
768 /**
769  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
770  *      @args: device IDENTIFY data / SCSI command of interest.
771  *      @actor: Callback hook for desired SCSI command simulator
772  *
773  *      Takes care of the hard work of simulating a SCSI command...
774  *      Mapping the response buffer, calling the command's handler,
775  *      and handling the handler's return value.  This return value
776  *      indicates whether the handler wishes the SCSI command to be
777  *      completed successfully, or not.
778  *
779  *      LOCKING:
780  *      spin_lock_irqsave(host_set lock)
781  */
782
783 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
784                         unsigned int (*actor) (struct ata_scsi_args *args,
785                                            u8 *rbuf, unsigned int buflen))
786 {
787         u8 *rbuf;
788         unsigned int buflen, rc;
789         struct scsi_cmnd *cmd = args->cmd;
790
791         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
792         memset(rbuf, 0, buflen);
793         rc = actor(args, rbuf, buflen);
794         ata_scsi_rbuf_put(cmd, rbuf);
795
796         if (rc)
797                 ata_bad_cdb(cmd, args->done);
798         else {
799                 cmd->result = SAM_STAT_GOOD;
800                 args->done(cmd);
801         }
802 }
803
804 /**
805  *      ata_scsiop_inq_std - Simulate INQUIRY command
806  *      @args: device IDENTIFY data / SCSI command of interest.
807  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
808  *      @buflen: Response buffer length.
809  *
810  *      Returns standard device identification data associated
811  *      with non-EVPD INQUIRY command output.
812  *
813  *      LOCKING:
814  *      spin_lock_irqsave(host_set lock)
815  */
816
817 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
818                                unsigned int buflen)
819 {
820         u8 hdr[] = {
821                 TYPE_DISK,
822                 0,
823                 0x5,    /* claim SPC-3 version compatibility */
824                 2,
825                 95 - 4
826         };
827
828         /* set scsi removeable (RMB) bit per ata bit */
829         if (ata_id_removeable(args->id))
830                 hdr[1] |= (1 << 7);
831
832         VPRINTK("ENTER\n");
833
834         memcpy(rbuf, hdr, sizeof(hdr));
835
836         if (buflen > 35) {
837                 memcpy(&rbuf[8], "ATA     ", 8);
838                 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
839                 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
840                 if (rbuf[32] == 0 || rbuf[32] == ' ')
841                         memcpy(&rbuf[32], "n/a ", 4);
842         }
843
844         if (buflen > 63) {
845                 const u8 versions[] = {
846                         0x60,   /* SAM-3 (no version claimed) */
847
848                         0x03,
849                         0x20,   /* SBC-2 (no version claimed) */
850
851                         0x02,
852                         0x60    /* SPC-3 (no version claimed) */
853                 };
854
855                 memcpy(rbuf + 59, versions, sizeof(versions));
856         }
857
858         return 0;
859 }
860
861 /**
862  *      ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
863  *      @args: device IDENTIFY data / SCSI command of interest.
864  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
865  *      @buflen: Response buffer length.
866  *
867  *      Returns list of inquiry EVPD pages available.
868  *
869  *      LOCKING:
870  *      spin_lock_irqsave(host_set lock)
871  */
872
873 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
874                               unsigned int buflen)
875 {
876         const u8 pages[] = {
877                 0x00,   /* page 0x00, this page */
878                 0x80,   /* page 0x80, unit serial no page */
879                 0x83    /* page 0x83, device ident page */
880         };
881         rbuf[3] = sizeof(pages);        /* number of supported EVPD pages */
882
883         if (buflen > 6)
884                 memcpy(rbuf + 4, pages, sizeof(pages));
885
886         return 0;
887 }
888
889 /**
890  *      ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
891  *      @args: device IDENTIFY data / SCSI command of interest.
892  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
893  *      @buflen: Response buffer length.
894  *
895  *      Returns ATA device serial number.
896  *
897  *      LOCKING:
898  *      spin_lock_irqsave(host_set lock)
899  */
900
901 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
902                               unsigned int buflen)
903 {
904         const u8 hdr[] = {
905                 0,
906                 0x80,                   /* this page code */
907                 0,
908                 ATA_SERNO_LEN,          /* page len */
909         };
910         memcpy(rbuf, hdr, sizeof(hdr));
911
912         if (buflen > (ATA_SERNO_LEN + 4 - 1))
913                 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
914                                   ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
915
916         return 0;
917 }
918
919 static const char *inq_83_str = "Linux ATA-SCSI simulator";
920
921 /**
922  *      ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
923  *      @args: device IDENTIFY data / SCSI command of interest.
924  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
925  *      @buflen: Response buffer length.
926  *
927  *      Returns device identification.  Currently hardcoded to
928  *      return "Linux ATA-SCSI simulator".
929  *
930  *      LOCKING:
931  *      spin_lock_irqsave(host_set lock)
932  */
933
934 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
935                               unsigned int buflen)
936 {
937         rbuf[1] = 0x83;                 /* this page code */
938         rbuf[3] = 4 + strlen(inq_83_str);       /* page len */
939
940         /* our one and only identification descriptor (vendor-specific) */
941         if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
942                 rbuf[4 + 0] = 2;        /* code set: ASCII */
943                 rbuf[4 + 3] = strlen(inq_83_str);
944                 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
945         }
946
947         return 0;
948 }
949
950 /**
951  *      ata_scsiop_noop - Command handler that simply returns success.
952  *      @args: device IDENTIFY data / SCSI command of interest.
953  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
954  *      @buflen: Response buffer length.
955  *
956  *      No operation.  Simply returns success to caller, to indicate
957  *      that the caller should successfully complete this SCSI command.
958  *
959  *      LOCKING:
960  *      spin_lock_irqsave(host_set lock)
961  */
962
963 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
964                             unsigned int buflen)
965 {
966         VPRINTK("ENTER\n");
967         return 0;
968 }
969
970 /**
971  *      ata_msense_push - Push data onto MODE SENSE data output buffer
972  *      @ptr_io: (input/output) Location to store more output data
973  *      @last: End of output data buffer
974  *      @buf: Pointer to BLOB being added to output buffer
975  *      @buflen: Length of BLOB
976  *
977  *      Store MODE SENSE data on an output buffer.
978  *
979  *      LOCKING:
980  *      None.
981  */
982
983 static void ata_msense_push(u8 **ptr_io, const u8 *last,
984                             const u8 *buf, unsigned int buflen)
985 {
986         u8 *ptr = *ptr_io;
987
988         if ((ptr + buflen - 1) > last)
989                 return;
990
991         memcpy(ptr, buf, buflen);
992
993         ptr += buflen;
994
995         *ptr_io = ptr;
996 }
997
998 /**
999  *      ata_msense_caching - Simulate MODE SENSE caching info page
1000  *      @id: device IDENTIFY data
1001  *      @ptr_io: (input/output) Location to store more output data
1002  *      @last: End of output data buffer
1003  *
1004  *      Generate a caching info page, which conditionally indicates
1005  *      write caching to the SCSI layer, depending on device
1006  *      capabilities.
1007  *
1008  *      LOCKING:
1009  *      None.
1010  */
1011
1012 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1013                                        const u8 *last)
1014 {
1015         u8 page[] = {
1016                 0x8,                            /* page code */
1017                 0x12,                           /* page length */
1018                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
1019                 0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
1020         };
1021
1022         if (ata_id_wcache_enabled(id))
1023                 page[2] |= (1 << 2);    /* write cache enable */
1024         if (!ata_id_rahead_enabled(id))
1025                 page[12] |= (1 << 5);   /* disable read ahead */
1026
1027         ata_msense_push(ptr_io, last, page, sizeof(page));
1028         return sizeof(page);
1029 }
1030
1031 /**
1032  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1033  *      @dev: Device associated with this MODE SENSE command
1034  *      @ptr_io: (input/output) Location to store more output data
1035  *      @last: End of output data buffer
1036  *
1037  *      Generate a generic MODE SENSE control mode page.
1038  *
1039  *      LOCKING:
1040  *      None.
1041  */
1042
1043 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1044 {
1045         const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1046
1047         /* byte 2: set the descriptor format sense data bit (bit 2)
1048          * since we need to support returning this format for SAT
1049          * commands and any SCSI commands against a 48b LBA device.
1050          */
1051
1052         ata_msense_push(ptr_io, last, page, sizeof(page));
1053         return sizeof(page);
1054 }
1055
1056 /**
1057  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1058  *      @dev: Device associated with this MODE SENSE command
1059  *      @ptr_io: (input/output) Location to store more output data
1060  *      @last: End of output data buffer
1061  *
1062  *      Generate a generic MODE SENSE r/w error recovery page.
1063  *
1064  *      LOCKING:
1065  *      None.
1066  */
1067
1068 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1069 {
1070         const u8 page[] = {
1071                 0x1,                      /* page code */
1072                 0xa,                      /* page length */
1073                 (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
1074                 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1075         };
1076
1077         ata_msense_push(ptr_io, last, page, sizeof(page));
1078         return sizeof(page);
1079 }
1080
1081 /**
1082  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1083  *      @args: device IDENTIFY data / SCSI command of interest.
1084  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1085  *      @buflen: Response buffer length.
1086  *
1087  *      Simulate MODE SENSE commands.
1088  *
1089  *      LOCKING:
1090  *      spin_lock_irqsave(host_set lock)
1091  */
1092
1093 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1094                                   unsigned int buflen)
1095 {
1096         u8 *scsicmd = args->cmd->cmnd, *p, *last;
1097         unsigned int page_control, six_byte, output_len;
1098
1099         VPRINTK("ENTER\n");
1100
1101         six_byte = (scsicmd[0] == MODE_SENSE);
1102
1103         /* we only support saved and current values (which we treat
1104          * in the same manner)
1105          */
1106         page_control = scsicmd[2] >> 6;
1107         if ((page_control != 0) && (page_control != 3))
1108                 return 1;
1109
1110         if (six_byte)
1111                 output_len = 4;
1112         else
1113                 output_len = 8;
1114
1115         p = rbuf + output_len;
1116         last = rbuf + buflen - 1;
1117
1118         switch(scsicmd[2] & 0x3f) {
1119         case 0x01:              /* r/w error recovery */
1120                 output_len += ata_msense_rw_recovery(&p, last);
1121                 break;
1122
1123         case 0x08:              /* caching */
1124                 output_len += ata_msense_caching(args->id, &p, last);
1125                 break;
1126
1127         case 0x0a: {            /* control mode */
1128                 output_len += ata_msense_ctl_mode(&p, last);
1129                 break;
1130                 }
1131
1132         case 0x3f:              /* all pages */
1133                 output_len += ata_msense_rw_recovery(&p, last);
1134                 output_len += ata_msense_caching(args->id, &p, last);
1135                 output_len += ata_msense_ctl_mode(&p, last);
1136                 break;
1137
1138         default:                /* invalid page code */
1139                 return 1;
1140         }
1141
1142         if (six_byte) {
1143                 output_len--;
1144                 rbuf[0] = output_len;
1145         } else {
1146                 output_len -= 2;
1147                 rbuf[0] = output_len >> 8;
1148                 rbuf[1] = output_len;
1149         }
1150
1151         return 0;
1152 }
1153
1154 /**
1155  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1156  *      @args: device IDENTIFY data / SCSI command of interest.
1157  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1158  *      @buflen: Response buffer length.
1159  *
1160  *      Simulate READ CAPACITY commands.
1161  *
1162  *      LOCKING:
1163  *      spin_lock_irqsave(host_set lock)
1164  */
1165
1166 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1167                                 unsigned int buflen)
1168 {
1169         u64 n_sectors;
1170         u32 tmp;
1171
1172         VPRINTK("ENTER\n");
1173
1174         if (ata_id_has_lba48(args->id))
1175                 n_sectors = ata_id_u64(args->id, 100);
1176         else
1177                 n_sectors = ata_id_u32(args->id, 60);
1178         n_sectors--;            /* ATA TotalUserSectors - 1 */
1179
1180         if (args->cmd->cmnd[0] == READ_CAPACITY) {
1181                 if( n_sectors >= 0xffffffffULL )
1182                         tmp = 0xffffffff ;  /* Return max count on overflow */
1183                 else
1184                         tmp = n_sectors ;
1185
1186                 /* sector count, 32-bit */
1187                 rbuf[0] = tmp >> (8 * 3);
1188                 rbuf[1] = tmp >> (8 * 2);
1189                 rbuf[2] = tmp >> (8 * 1);
1190                 rbuf[3] = tmp;
1191
1192                 /* sector size */
1193                 tmp = ATA_SECT_SIZE;
1194                 rbuf[6] = tmp >> 8;
1195                 rbuf[7] = tmp;
1196
1197         } else {
1198                 /* sector count, 64-bit */
1199                 tmp = n_sectors >> (8 * 4);
1200                 rbuf[2] = tmp >> (8 * 3);
1201                 rbuf[3] = tmp >> (8 * 2);
1202                 rbuf[4] = tmp >> (8 * 1);
1203                 rbuf[5] = tmp;
1204                 tmp = n_sectors;
1205                 rbuf[6] = tmp >> (8 * 3);
1206                 rbuf[7] = tmp >> (8 * 2);
1207                 rbuf[8] = tmp >> (8 * 1);
1208                 rbuf[9] = tmp;
1209
1210                 /* sector size */
1211                 tmp = ATA_SECT_SIZE;
1212                 rbuf[12] = tmp >> 8;
1213                 rbuf[13] = tmp;
1214         }
1215
1216         return 0;
1217 }
1218
1219 /**
1220  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
1221  *      @args: device IDENTIFY data / SCSI command of interest.
1222  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1223  *      @buflen: Response buffer length.
1224  *
1225  *      Simulate REPORT LUNS command.
1226  *
1227  *      LOCKING:
1228  *      spin_lock_irqsave(host_set lock)
1229  */
1230
1231 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1232                                    unsigned int buflen)
1233 {
1234         VPRINTK("ENTER\n");
1235         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
1236
1237         return 0;
1238 }
1239
1240 /**
1241  *      ata_scsi_badcmd - End a SCSI request with an error
1242  *      @cmd: SCSI request to be handled
1243  *      @done: SCSI command completion function
1244  *      @asc: SCSI-defined additional sense code
1245  *      @ascq: SCSI-defined additional sense code qualifier
1246  *
1247  *      Helper function that completes a SCSI command with
1248  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1249  *      and the specified additional sense codes.
1250  *
1251  *      LOCKING:
1252  *      spin_lock_irqsave(host_set lock)
1253  */
1254
1255 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1256 {
1257         DPRINTK("ENTER\n");
1258         cmd->result = SAM_STAT_CHECK_CONDITION;
1259
1260         cmd->sense_buffer[0] = 0x70;
1261         cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1262         cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
1263         cmd->sense_buffer[12] = asc;
1264         cmd->sense_buffer[13] = ascq;
1265
1266         done(cmd);
1267 }
1268
1269 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1270 {
1271         struct scsi_cmnd *cmd = qc->scsicmd;
1272
1273         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1274                 DPRINTK("request check condition\n");
1275
1276                 cmd->result = SAM_STAT_CHECK_CONDITION;
1277
1278                 qc->scsidone(cmd);
1279
1280                 return 1;
1281         } else {
1282                 u8 *scsicmd = cmd->cmnd;
1283
1284                 if (scsicmd[0] == INQUIRY) {
1285                         u8 *buf = NULL;
1286                         unsigned int buflen;
1287
1288                         buflen = ata_scsi_rbuf_get(cmd, &buf);
1289                         buf[2] = 0x5;
1290                         buf[3] = (buf[3] & 0xf0) | 2;
1291                         ata_scsi_rbuf_put(cmd, buf);
1292                 }
1293                 cmd->result = SAM_STAT_GOOD;
1294         }
1295
1296         qc->scsidone(cmd);
1297
1298         return 0;
1299 }
1300 /**
1301  *      atapi_xlat - Initialize PACKET taskfile
1302  *      @qc: command structure to be initialized
1303  *      @scsicmd: SCSI CDB associated with this PACKET command
1304  *
1305  *      LOCKING:
1306  *      spin_lock_irqsave(host_set lock)
1307  *
1308  *      RETURNS:
1309  *      Zero on success, non-zero on failure.
1310  */
1311
1312 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1313 {
1314         struct scsi_cmnd *cmd = qc->scsicmd;
1315         struct ata_device *dev = qc->dev;
1316         int using_pio = (dev->flags & ATA_DFLAG_PIO);
1317         int nodata = (cmd->sc_data_direction == DMA_NONE);
1318
1319         if (!using_pio)
1320                 /* Check whether ATAPI DMA is safe */
1321                 if (ata_check_atapi_dma(qc))
1322                         using_pio = 1;
1323
1324         memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1325
1326         qc->complete_fn = atapi_qc_complete;
1327
1328         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1329         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1330                 qc->tf.flags |= ATA_TFLAG_WRITE;
1331                 DPRINTK("direction: write\n");
1332         }
1333
1334         qc->tf.command = ATA_CMD_PACKET;
1335
1336         /* no data, or PIO data xfer */
1337         if (using_pio || nodata) {
1338                 if (nodata)
1339                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1340                 else
1341                         qc->tf.protocol = ATA_PROT_ATAPI;
1342                 qc->tf.lbam = (8 * 1024) & 0xff;
1343                 qc->tf.lbah = (8 * 1024) >> 8;
1344         }
1345
1346         /* DMA data xfer */
1347         else {
1348                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1349                 qc->tf.feature |= ATAPI_PKT_DMA;
1350
1351 #ifdef ATAPI_ENABLE_DMADIR
1352                 /* some SATA bridges need us to indicate data xfer direction */
1353                 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1354                         qc->tf.feature |= ATAPI_DMADIR;
1355 #endif
1356         }
1357
1358         qc->nbytes = cmd->bufflen;
1359
1360         return 0;
1361 }
1362
1363 /**
1364  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1365  *      @ap: ATA port to which the device is attached
1366  *      @scsidev: SCSI device from which we derive the ATA device
1367  *
1368  *      Given various information provided in struct scsi_cmnd,
1369  *      map that onto an ATA bus, and using that mapping
1370  *      determine which ata_device is associated with the
1371  *      SCSI command to be sent.
1372  *
1373  *      LOCKING:
1374  *      spin_lock_irqsave(host_set lock)
1375  *
1376  *      RETURNS:
1377  *      Associated ATA device, or %NULL if not found.
1378  */
1379
1380 static struct ata_device *
1381 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1382 {
1383         struct ata_device *dev;
1384
1385         /* skip commands not addressed to targets we simulate */
1386         if (likely(scsidev->id < ATA_MAX_DEVICES))
1387                 dev = &ap->device[scsidev->id];
1388         else
1389                 return NULL;
1390
1391         if (unlikely((scsidev->channel != 0) ||
1392                      (scsidev->lun != 0)))
1393                 return NULL;
1394
1395         if (unlikely(!ata_dev_present(dev)))
1396                 return NULL;
1397
1398 #ifndef ATA_ENABLE_ATAPI
1399         if (unlikely(dev->class == ATA_DEV_ATAPI))
1400                 return NULL;
1401 #endif
1402
1403         return dev;
1404 }
1405
1406 /**
1407  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
1408  *      @dev: ATA device
1409  *      @cmd: SCSI command opcode to consider
1410  *
1411  *      Look up the SCSI command given, and determine whether the
1412  *      SCSI command is to be translated or simulated.
1413  *
1414  *      RETURNS:
1415  *      Pointer to translation function if possible, %NULL if not.
1416  */
1417
1418 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1419 {
1420         switch (cmd) {
1421         case READ_6:
1422         case READ_10:
1423         case READ_16:
1424
1425         case WRITE_6:
1426         case WRITE_10:
1427         case WRITE_16:
1428                 return ata_scsi_rw_xlat;
1429
1430         case SYNCHRONIZE_CACHE:
1431                 if (ata_try_flush_cache(dev))
1432                         return ata_scsi_flush_xlat;
1433                 break;
1434
1435         case VERIFY:
1436         case VERIFY_16:
1437                 return ata_scsi_verify_xlat;
1438         }
1439
1440         return NULL;
1441 }
1442
1443 /**
1444  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1445  *      @ap: ATA port to which the command was being sent
1446  *      @cmd: SCSI command to dump
1447  *
1448  *      Prints the contents of a SCSI command via printk().
1449  */
1450
1451 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1452                                      struct scsi_cmnd *cmd)
1453 {
1454 #ifdef ATA_DEBUG
1455         struct scsi_device *scsidev = cmd->device;
1456         u8 *scsicmd = cmd->cmnd;
1457
1458         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1459                 ap->id,
1460                 scsidev->channel, scsidev->id, scsidev->lun,
1461                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1462                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1463                 scsicmd[8]);
1464 #endif
1465 }
1466
1467 /**
1468  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1469  *      @cmd: SCSI command to be sent
1470  *      @done: Completion function, called when command is complete
1471  *
1472  *      In some cases, this function translates SCSI commands into
1473  *      ATA taskfiles, and queues the taskfiles to be sent to
1474  *      hardware.  In other cases, this function simulates a
1475  *      SCSI device by evaluating and responding to certain
1476  *      SCSI commands.  This creates the overall effect of
1477  *      ATA and ATAPI devices appearing as SCSI devices.
1478  *
1479  *      LOCKING:
1480  *      Releases scsi-layer-held lock, and obtains host_set lock.
1481  *
1482  *      RETURNS:
1483  *      Zero.
1484  */
1485
1486 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1487 {
1488         struct ata_port *ap;
1489         struct ata_device *dev;
1490         struct scsi_device *scsidev = cmd->device;
1491
1492         ap = (struct ata_port *) &scsidev->host->hostdata[0];
1493
1494         ata_scsi_dump_cdb(ap, cmd);
1495
1496         dev = ata_scsi_find_dev(ap, scsidev);
1497         if (unlikely(!dev)) {
1498                 cmd->result = (DID_BAD_TARGET << 16);
1499                 done(cmd);
1500                 goto out_unlock;
1501         }
1502
1503         if (dev->class == ATA_DEV_ATA) {
1504                 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1505                                                               cmd->cmnd[0]);
1506
1507                 if (xlat_func)
1508                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1509                 else
1510                         ata_scsi_simulate(dev->id, cmd, done);
1511         } else
1512                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1513
1514 out_unlock:
1515         return 0;
1516 }
1517
1518 /**
1519  *      ata_scsi_simulate - simulate SCSI command on ATA device
1520  *      @id: current IDENTIFY data for target device.
1521  *      @cmd: SCSI command being sent to device.
1522  *      @done: SCSI command completion function.
1523  *
1524  *      Interprets and directly executes a select list of SCSI commands
1525  *      that can be handled internally.
1526  *
1527  *      LOCKING:
1528  *      spin_lock_irqsave(host_set lock)
1529  */
1530
1531 void ata_scsi_simulate(u16 *id,
1532                       struct scsi_cmnd *cmd,
1533                       void (*done)(struct scsi_cmnd *))
1534 {
1535         struct ata_scsi_args args;
1536         u8 *scsicmd = cmd->cmnd;
1537
1538         args.id = id;
1539         args.cmd = cmd;
1540         args.done = done;
1541
1542         switch(scsicmd[0]) {
1543                 /* no-op's, complete with success */
1544                 case SYNCHRONIZE_CACHE:
1545                 case REZERO_UNIT:
1546                 case SEEK_6:
1547                 case SEEK_10:
1548                 case TEST_UNIT_READY:
1549                 case FORMAT_UNIT:               /* FIXME: correct? */
1550                 case SEND_DIAGNOSTIC:           /* FIXME: correct? */
1551                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1552                         break;
1553
1554                 case INQUIRY:
1555                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
1556                                 ata_bad_cdb(cmd, done);
1557                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
1558                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1559                         else if (scsicmd[2] == 0x00)
1560                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1561                         else if (scsicmd[2] == 0x80)
1562                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1563                         else if (scsicmd[2] == 0x83)
1564                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1565                         else
1566                                 ata_bad_cdb(cmd, done);
1567                         break;
1568
1569                 case MODE_SENSE:
1570                 case MODE_SENSE_10:
1571                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1572                         break;
1573
1574                 case MODE_SELECT:       /* unconditionally return */
1575                 case MODE_SELECT_10:    /* bad-field-in-cdb */
1576                         ata_bad_cdb(cmd, done);
1577                         break;
1578
1579                 case READ_CAPACITY:
1580                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1581                         break;
1582
1583                 case SERVICE_ACTION_IN:
1584                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1585                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1586                         else
1587                                 ata_bad_cdb(cmd, done);
1588                         break;
1589
1590                 case REPORT_LUNS:
1591                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1592                         break;
1593
1594                 /* mandantory commands we haven't implemented yet */
1595                 case REQUEST_SENSE:
1596
1597                 /* all other commands */
1598                 default:
1599                         ata_bad_scsiop(cmd, done);
1600                         break;
1601         }
1602 }
1603