[libata scsi] fix read/write translation edge cases
[linux-2.6.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_start_stop_xlat - Translate SCSI START STOP UNIT command
396  *      @qc: Storage for translated ATA taskfile
397  *      @scsicmd: SCSI command to translate
398  *
399  *      Sets up an ATA taskfile to issue STANDBY (to stop) or READ VERIFY
400  *      (to start). Perhaps these commands should be preceded by
401  *      CHECK POWER MODE to see what power mode the device is already in.
402  *      [See SAT revision 5 at www.t10.org]
403  *
404  *      LOCKING:
405  *      spin_lock_irqsave(host_set lock)
406  *
407  *      RETURNS:
408  *      Zero on success, non-zero on error.
409  */
410
411 static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc,
412                                              u8 *scsicmd)
413 {
414         struct ata_taskfile *tf = &qc->tf;
415
416         tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR;
417         tf->protocol = ATA_PROT_NODATA;
418         if (scsicmd[1] & 0x1) {
419                 ;       /* ignore IMMED bit, violates sat-r05 */
420         }
421         if (scsicmd[4] & 0x2)
422                 return 1;       /* LOEJ bit set not supported */
423         if (((scsicmd[4] >> 4) & 0xf) != 0)
424                 return 1;       /* power conditions not supported */
425         if (scsicmd[4] & 0x1) {
426                 tf->nsect = 1;  /* 1 sector, lba=0 */
427                 tf->lbah = 0x0;
428                 tf->lbam = 0x0;
429                 tf->lbal = 0x0;
430                 tf->device |= ATA_LBA;
431                 tf->command = ATA_CMD_VERIFY;   /* READ VERIFY */
432         } else {
433                 tf->nsect = 0;  /* time period value (0 implies now) */
434                 tf->command = ATA_CMD_STANDBY;
435                 /* Consider: ATA STANDBY IMMEDIATE command */
436         }
437         /*
438          * Standby and Idle condition timers could be implemented but that
439          * would require libata to implement the Power condition mode page
440          * and allow the user to change it. Changing mode pages requires
441          * MODE SELECT to be implemented.
442          */
443
444         return 0;
445 }
446
447
448 /**
449  *      ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
450  *      @qc: Storage for translated ATA taskfile
451  *      @scsicmd: SCSI command to translate (ignored)
452  *
453  *      Sets up an ATA taskfile to issue FLUSH CACHE or
454  *      FLUSH CACHE EXT.
455  *
456  *      LOCKING:
457  *      spin_lock_irqsave(host_set lock)
458  *
459  *      RETURNS:
460  *      Zero on success, non-zero on error.
461  */
462
463 static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
464 {
465         struct ata_taskfile *tf = &qc->tf;
466
467         tf->flags |= ATA_TFLAG_DEVICE;
468         tf->protocol = ATA_PROT_NODATA;
469
470         if ((tf->flags & ATA_TFLAG_LBA48) &&
471             (ata_id_has_flush_ext(qc->dev->id)))
472                 tf->command = ATA_CMD_FLUSH_EXT;
473         else
474                 tf->command = ATA_CMD_FLUSH;
475
476         return 0;
477 }
478
479 /**
480  *      ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
481  *      @qc: Storage for translated ATA taskfile
482  *      @scsicmd: SCSI command to translate
483  *
484  *      Converts SCSI VERIFY command to an ATA READ VERIFY command.
485  *
486  *      LOCKING:
487  *      spin_lock_irqsave(host_set lock)
488  *
489  *      RETURNS:
490  *      Zero on success, non-zero on error.
491  */
492
493 static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
494 {
495         struct ata_taskfile *tf = &qc->tf;
496         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
497         u64 dev_sectors = qc->dev->n_sectors;
498         u64 sect = 0;
499         u32 n_sect = 0;
500
501         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
502         tf->protocol = ATA_PROT_NODATA;
503         tf->device |= ATA_LBA;
504
505         if (scsicmd[0] == VERIFY) {
506                 sect |= ((u64)scsicmd[2]) << 24;
507                 sect |= ((u64)scsicmd[3]) << 16;
508                 sect |= ((u64)scsicmd[4]) << 8;
509                 sect |= ((u64)scsicmd[5]);
510
511                 n_sect |= ((u32)scsicmd[7]) << 8;
512                 n_sect |= ((u32)scsicmd[8]);
513         }
514
515         else if (scsicmd[0] == VERIFY_16) {
516                 sect |= ((u64)scsicmd[2]) << 56;
517                 sect |= ((u64)scsicmd[3]) << 48;
518                 sect |= ((u64)scsicmd[4]) << 40;
519                 sect |= ((u64)scsicmd[5]) << 32;
520                 sect |= ((u64)scsicmd[6]) << 24;
521                 sect |= ((u64)scsicmd[7]) << 16;
522                 sect |= ((u64)scsicmd[8]) << 8;
523                 sect |= ((u64)scsicmd[9]);
524
525                 n_sect |= ((u32)scsicmd[10]) << 24;
526                 n_sect |= ((u32)scsicmd[11]) << 16;
527                 n_sect |= ((u32)scsicmd[12]) << 8;
528                 n_sect |= ((u32)scsicmd[13]);
529         }
530
531         else
532                 return 1;
533
534         if (!n_sect)
535                 return 1;
536         if (sect >= dev_sectors)
537                 return 1;
538         if ((sect + n_sect) > dev_sectors)
539                 return 1;
540         if (lba48) {
541                 if (n_sect > (64 * 1024))
542                         return 1;
543         } else {
544                 if (n_sect > 256)
545                         return 1;
546         }
547
548         if (lba48) {
549                 tf->command = ATA_CMD_VERIFY_EXT;
550
551                 tf->hob_nsect = (n_sect >> 8) & 0xff;
552
553                 tf->hob_lbah = (sect >> 40) & 0xff;
554                 tf->hob_lbam = (sect >> 32) & 0xff;
555                 tf->hob_lbal = (sect >> 24) & 0xff;
556         } else {
557                 tf->command = ATA_CMD_VERIFY;
558
559                 tf->device |= (sect >> 24) & 0xf;
560         }
561
562         tf->nsect = n_sect & 0xff;
563
564         tf->lbah = (sect >> 16) & 0xff;
565         tf->lbam = (sect >> 8) & 0xff;
566         tf->lbal = sect & 0xff;
567
568         return 0;
569 }
570
571 /**
572  *      ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
573  *      @qc: Storage for translated ATA taskfile
574  *      @scsicmd: SCSI command to translate
575  *
576  *      Converts any of six SCSI read/write commands into the
577  *      ATA counterpart, including starting sector (LBA),
578  *      sector count, and taking into account the device's LBA48
579  *      support.
580  *
581  *      Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
582  *      %WRITE_16 are currently supported.
583  *
584  *      LOCKING:
585  *      spin_lock_irqsave(host_set lock)
586  *
587  *      RETURNS:
588  *      Zero on success, non-zero on error.
589  */
590
591 static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
592 {
593         struct ata_taskfile *tf = &qc->tf;
594         unsigned int lba48 = tf->flags & ATA_TFLAG_LBA48;
595
596         tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
597         tf->protocol = qc->dev->xfer_protocol;
598         tf->device |= ATA_LBA;
599
600         if (scsicmd[0] == READ_10 || scsicmd[0] == READ_6 ||
601             scsicmd[0] == READ_16) {
602                 tf->command = qc->dev->read_cmd;
603         } else {
604                 tf->command = qc->dev->write_cmd;
605                 tf->flags |= ATA_TFLAG_WRITE;
606         }
607
608         if (scsicmd[0] == READ_10 || scsicmd[0] == WRITE_10) {
609                 if (lba48) {
610                         tf->hob_nsect = scsicmd[7];
611                         tf->hob_lbal = scsicmd[2];
612
613                         qc->nsect = ((unsigned int)scsicmd[7] << 8) |
614                                         scsicmd[8];
615                 } else {
616                         /* if we don't support LBA48 addressing, the request
617                          * -may- be too large. */
618                         if ((scsicmd[2] & 0xf0) || scsicmd[7])
619                                 return 1;
620
621                         /* stores LBA27:24 in lower 4 bits of device reg */
622                         tf->device |= scsicmd[2];
623
624                         qc->nsect = scsicmd[8];
625                 }
626
627                 tf->nsect = scsicmd[8];
628                 tf->lbal = scsicmd[5];
629                 tf->lbam = scsicmd[4];
630                 tf->lbah = scsicmd[3];
631
632                 VPRINTK("ten-byte command\n");
633                 if (qc->nsect == 0) /* we don't support length==0 cmds */
634                         return 1;
635                 return 0;
636         }
637
638         if (scsicmd[0] == READ_6 || scsicmd[0] == WRITE_6) {
639                 qc->nsect = tf->nsect = scsicmd[4];
640                 if (!qc->nsect) {
641                         qc->nsect = 256;
642                         if (lba48)
643                                 tf->hob_nsect = 1;
644                 }
645
646                 tf->lbal = scsicmd[3];
647                 tf->lbam = scsicmd[2];
648                 tf->lbah = scsicmd[1] & 0x1f; /* mask out reserved bits */
649
650                 VPRINTK("six-byte command\n");
651                 return 0;
652         }
653
654         if (scsicmd[0] == READ_16 || scsicmd[0] == WRITE_16) {
655                 /* rule out impossible LBAs and sector counts */
656                 if (scsicmd[2] || scsicmd[3] || scsicmd[10] || scsicmd[11])
657                         return 1;
658
659                 if (lba48) {
660                         tf->hob_nsect = scsicmd[12];
661                         tf->hob_lbal = scsicmd[6];
662                         tf->hob_lbam = scsicmd[5];
663                         tf->hob_lbah = scsicmd[4];
664
665                         qc->nsect = ((unsigned int)scsicmd[12] << 8) |
666                                         scsicmd[13];
667                 } else {
668                         /* once again, filter out impossible non-zero values */
669                         if (scsicmd[4] || scsicmd[5] || scsicmd[12] ||
670                             (scsicmd[6] & 0xf0))
671                                 return 1;
672
673                         /* stores LBA27:24 in lower 4 bits of device reg */
674                         tf->device |= scsicmd[6];
675
676                         qc->nsect = scsicmd[13];
677                 }
678
679                 tf->nsect = scsicmd[13];
680                 tf->lbal = scsicmd[9];
681                 tf->lbam = scsicmd[8];
682                 tf->lbah = scsicmd[7];
683
684                 VPRINTK("sixteen-byte command\n");
685                 if (qc->nsect == 0) /* we don't support length==0 cmds */
686                         return 1;
687                 return 0;
688         }
689
690         DPRINTK("no-byte command\n");
691         return 1;
692 }
693
694 static int ata_scsi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
695 {
696         struct scsi_cmnd *cmd = qc->scsicmd;
697
698         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ)))
699                 ata_to_sense_error(qc, drv_stat);
700         else
701                 cmd->result = SAM_STAT_GOOD;
702
703         qc->scsidone(cmd);
704
705         return 0;
706 }
707
708 /**
709  *      ata_scsi_translate - Translate then issue SCSI command to ATA device
710  *      @ap: ATA port to which the command is addressed
711  *      @dev: ATA device to which the command is addressed
712  *      @cmd: SCSI command to execute
713  *      @done: SCSI command completion function
714  *      @xlat_func: Actor which translates @cmd to an ATA taskfile
715  *
716  *      Our ->queuecommand() function has decided that the SCSI
717  *      command issued can be directly translated into an ATA
718  *      command, rather than handled internally.
719  *
720  *      This function sets up an ata_queued_cmd structure for the
721  *      SCSI command, and sends that ata_queued_cmd to the hardware.
722  *
723  *      LOCKING:
724  *      spin_lock_irqsave(host_set lock)
725  */
726
727 static void ata_scsi_translate(struct ata_port *ap, struct ata_device *dev,
728                               struct scsi_cmnd *cmd,
729                               void (*done)(struct scsi_cmnd *),
730                               ata_xlat_func_t xlat_func)
731 {
732         struct ata_queued_cmd *qc;
733         u8 *scsicmd = cmd->cmnd;
734
735         VPRINTK("ENTER\n");
736
737         qc = ata_scsi_qc_new(ap, dev, cmd, done);
738         if (!qc)
739                 return;
740
741         /* data is present; dma-map it */
742         if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
743             cmd->sc_data_direction == DMA_TO_DEVICE) {
744                 if (unlikely(cmd->request_bufflen < 1)) {
745                         printk(KERN_WARNING "ata%u(%u): WARNING: zero len r/w req\n",
746                                ap->id, dev->devno);
747                         goto err_out;
748                 }
749
750                 if (cmd->use_sg)
751                         ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
752                 else
753                         ata_sg_init_one(qc, cmd->request_buffer,
754                                         cmd->request_bufflen);
755
756                 qc->dma_dir = cmd->sc_data_direction;
757         }
758
759         qc->complete_fn = ata_scsi_qc_complete;
760
761         if (xlat_func(qc, scsicmd))
762                 goto err_out;
763
764         /* select device, send command to hardware */
765         if (ata_qc_issue(qc))
766                 goto err_out;
767
768         VPRINTK("EXIT\n");
769         return;
770
771 err_out:
772         ata_qc_free(qc);
773         ata_bad_cdb(cmd, done);
774         DPRINTK("EXIT - badcmd\n");
775 }
776
777 /**
778  *      ata_scsi_rbuf_get - Map response buffer.
779  *      @cmd: SCSI command containing buffer to be mapped.
780  *      @buf_out: Pointer to mapped area.
781  *
782  *      Maps buffer contained within SCSI command @cmd.
783  *
784  *      LOCKING:
785  *      spin_lock_irqsave(host_set lock)
786  *
787  *      RETURNS:
788  *      Length of response buffer.
789  */
790
791 static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
792 {
793         u8 *buf;
794         unsigned int buflen;
795
796         if (cmd->use_sg) {
797                 struct scatterlist *sg;
798
799                 sg = (struct scatterlist *) cmd->request_buffer;
800                 buf = kmap_atomic(sg->page, KM_USER0) + sg->offset;
801                 buflen = sg->length;
802         } else {
803                 buf = cmd->request_buffer;
804                 buflen = cmd->request_bufflen;
805         }
806
807         *buf_out = buf;
808         return buflen;
809 }
810
811 /**
812  *      ata_scsi_rbuf_put - Unmap response buffer.
813  *      @cmd: SCSI command containing buffer to be unmapped.
814  *      @buf: buffer to unmap
815  *
816  *      Unmaps response buffer contained within @cmd.
817  *
818  *      LOCKING:
819  *      spin_lock_irqsave(host_set lock)
820  */
821
822 static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
823 {
824         if (cmd->use_sg) {
825                 struct scatterlist *sg;
826
827                 sg = (struct scatterlist *) cmd->request_buffer;
828                 kunmap_atomic(buf - sg->offset, KM_USER0);
829         }
830 }
831
832 /**
833  *      ata_scsi_rbuf_fill - wrapper for SCSI command simulators
834  *      @args: device IDENTIFY data / SCSI command of interest.
835  *      @actor: Callback hook for desired SCSI command simulator
836  *
837  *      Takes care of the hard work of simulating a SCSI command...
838  *      Mapping the response buffer, calling the command's handler,
839  *      and handling the handler's return value.  This return value
840  *      indicates whether the handler wishes the SCSI command to be
841  *      completed successfully, or not.
842  *
843  *      LOCKING:
844  *      spin_lock_irqsave(host_set lock)
845  */
846
847 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
848                         unsigned int (*actor) (struct ata_scsi_args *args,
849                                            u8 *rbuf, unsigned int buflen))
850 {
851         u8 *rbuf;
852         unsigned int buflen, rc;
853         struct scsi_cmnd *cmd = args->cmd;
854
855         buflen = ata_scsi_rbuf_get(cmd, &rbuf);
856         memset(rbuf, 0, buflen);
857         rc = actor(args, rbuf, buflen);
858         ata_scsi_rbuf_put(cmd, rbuf);
859
860         if (rc)
861                 ata_bad_cdb(cmd, args->done);
862         else {
863                 cmd->result = SAM_STAT_GOOD;
864                 args->done(cmd);
865         }
866 }
867
868 /**
869  *      ata_scsiop_inq_std - Simulate INQUIRY command
870  *      @args: device IDENTIFY data / SCSI command of interest.
871  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
872  *      @buflen: Response buffer length.
873  *
874  *      Returns standard device identification data associated
875  *      with non-EVPD INQUIRY command output.
876  *
877  *      LOCKING:
878  *      spin_lock_irqsave(host_set lock)
879  */
880
881 unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
882                                unsigned int buflen)
883 {
884         u8 hdr[] = {
885                 TYPE_DISK,
886                 0,
887                 0x5,    /* claim SPC-3 version compatibility */
888                 2,
889                 95 - 4
890         };
891
892         /* set scsi removeable (RMB) bit per ata bit */
893         if (ata_id_removeable(args->id))
894                 hdr[1] |= (1 << 7);
895
896         VPRINTK("ENTER\n");
897
898         memcpy(rbuf, hdr, sizeof(hdr));
899
900         if (buflen > 35) {
901                 memcpy(&rbuf[8], "ATA     ", 8);
902                 ata_dev_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
903                 ata_dev_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
904                 if (rbuf[32] == 0 || rbuf[32] == ' ')
905                         memcpy(&rbuf[32], "n/a ", 4);
906         }
907
908         if (buflen > 63) {
909                 const u8 versions[] = {
910                         0x60,   /* SAM-3 (no version claimed) */
911
912                         0x03,
913                         0x20,   /* SBC-2 (no version claimed) */
914
915                         0x02,
916                         0x60    /* SPC-3 (no version claimed) */
917                 };
918
919                 memcpy(rbuf + 59, versions, sizeof(versions));
920         }
921
922         return 0;
923 }
924
925 /**
926  *      ata_scsiop_inq_00 - Simulate INQUIRY EVPD page 0, list of pages
927  *      @args: device IDENTIFY data / SCSI command of interest.
928  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
929  *      @buflen: Response buffer length.
930  *
931  *      Returns list of inquiry EVPD pages available.
932  *
933  *      LOCKING:
934  *      spin_lock_irqsave(host_set lock)
935  */
936
937 unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
938                               unsigned int buflen)
939 {
940         const u8 pages[] = {
941                 0x00,   /* page 0x00, this page */
942                 0x80,   /* page 0x80, unit serial no page */
943                 0x83    /* page 0x83, device ident page */
944         };
945         rbuf[3] = sizeof(pages);        /* number of supported EVPD pages */
946
947         if (buflen > 6)
948                 memcpy(rbuf + 4, pages, sizeof(pages));
949
950         return 0;
951 }
952
953 /**
954  *      ata_scsiop_inq_80 - Simulate INQUIRY EVPD page 80, device serial number
955  *      @args: device IDENTIFY data / SCSI command of interest.
956  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
957  *      @buflen: Response buffer length.
958  *
959  *      Returns ATA device serial number.
960  *
961  *      LOCKING:
962  *      spin_lock_irqsave(host_set lock)
963  */
964
965 unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
966                               unsigned int buflen)
967 {
968         const u8 hdr[] = {
969                 0,
970                 0x80,                   /* this page code */
971                 0,
972                 ATA_SERNO_LEN,          /* page len */
973         };
974         memcpy(rbuf, hdr, sizeof(hdr));
975
976         if (buflen > (ATA_SERNO_LEN + 4 - 1))
977                 ata_dev_id_string(args->id, (unsigned char *) &rbuf[4],
978                                   ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
979
980         return 0;
981 }
982
983 static const char *inq_83_str = "Linux ATA-SCSI simulator";
984
985 /**
986  *      ata_scsiop_inq_83 - Simulate INQUIRY EVPD page 83, device identity
987  *      @args: device IDENTIFY data / SCSI command of interest.
988  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
989  *      @buflen: Response buffer length.
990  *
991  *      Returns device identification.  Currently hardcoded to
992  *      return "Linux ATA-SCSI simulator".
993  *
994  *      LOCKING:
995  *      spin_lock_irqsave(host_set lock)
996  */
997
998 unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
999                               unsigned int buflen)
1000 {
1001         rbuf[1] = 0x83;                 /* this page code */
1002         rbuf[3] = 4 + strlen(inq_83_str);       /* page len */
1003
1004         /* our one and only identification descriptor (vendor-specific) */
1005         if (buflen > (strlen(inq_83_str) + 4 + 4 - 1)) {
1006                 rbuf[4 + 0] = 2;        /* code set: ASCII */
1007                 rbuf[4 + 3] = strlen(inq_83_str);
1008                 memcpy(rbuf + 4 + 4, inq_83_str, strlen(inq_83_str));
1009         }
1010
1011         return 0;
1012 }
1013
1014 /**
1015  *      ata_scsiop_noop - Command handler that simply returns success.
1016  *      @args: device IDENTIFY data / SCSI command of interest.
1017  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1018  *      @buflen: Response buffer length.
1019  *
1020  *      No operation.  Simply returns success to caller, to indicate
1021  *      that the caller should successfully complete this SCSI command.
1022  *
1023  *      LOCKING:
1024  *      spin_lock_irqsave(host_set lock)
1025  */
1026
1027 unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1028                             unsigned int buflen)
1029 {
1030         VPRINTK("ENTER\n");
1031         return 0;
1032 }
1033
1034 /**
1035  *      ata_msense_push - Push data onto MODE SENSE data output buffer
1036  *      @ptr_io: (input/output) Location to store more output data
1037  *      @last: End of output data buffer
1038  *      @buf: Pointer to BLOB being added to output buffer
1039  *      @buflen: Length of BLOB
1040  *
1041  *      Store MODE SENSE data on an output buffer.
1042  *
1043  *      LOCKING:
1044  *      None.
1045  */
1046
1047 static void ata_msense_push(u8 **ptr_io, const u8 *last,
1048                             const u8 *buf, unsigned int buflen)
1049 {
1050         u8 *ptr = *ptr_io;
1051
1052         if ((ptr + buflen - 1) > last)
1053                 return;
1054
1055         memcpy(ptr, buf, buflen);
1056
1057         ptr += buflen;
1058
1059         *ptr_io = ptr;
1060 }
1061
1062 /**
1063  *      ata_msense_caching - Simulate MODE SENSE caching info page
1064  *      @id: device IDENTIFY data
1065  *      @ptr_io: (input/output) Location to store more output data
1066  *      @last: End of output data buffer
1067  *
1068  *      Generate a caching info page, which conditionally indicates
1069  *      write caching to the SCSI layer, depending on device
1070  *      capabilities.
1071  *
1072  *      LOCKING:
1073  *      None.
1074  */
1075
1076 static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1077                                        const u8 *last)
1078 {
1079         u8 page[] = {
1080                 0x8,                            /* page code */
1081                 0x12,                           /* page length */
1082                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 10 zeroes */
1083                 0, 0, 0, 0, 0, 0, 0, 0          /* 8 zeroes */
1084         };
1085
1086         if (ata_id_wcache_enabled(id))
1087                 page[2] |= (1 << 2);    /* write cache enable */
1088         if (!ata_id_rahead_enabled(id))
1089                 page[12] |= (1 << 5);   /* disable read ahead */
1090
1091         ata_msense_push(ptr_io, last, page, sizeof(page));
1092         return sizeof(page);
1093 }
1094
1095 /**
1096  *      ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1097  *      @dev: Device associated with this MODE SENSE command
1098  *      @ptr_io: (input/output) Location to store more output data
1099  *      @last: End of output data buffer
1100  *
1101  *      Generate a generic MODE SENSE control mode page.
1102  *
1103  *      LOCKING:
1104  *      None.
1105  */
1106
1107 static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1108 {
1109         const u8 page[] = {0xa, 0xa, 6, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 30};
1110
1111         /* byte 2: set the descriptor format sense data bit (bit 2)
1112          * since we need to support returning this format for SAT
1113          * commands and any SCSI commands against a 48b LBA device.
1114          */
1115
1116         ata_msense_push(ptr_io, last, page, sizeof(page));
1117         return sizeof(page);
1118 }
1119
1120 /**
1121  *      ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1122  *      @dev: Device associated with this MODE SENSE command
1123  *      @ptr_io: (input/output) Location to store more output data
1124  *      @last: End of output data buffer
1125  *
1126  *      Generate a generic MODE SENSE r/w error recovery page.
1127  *
1128  *      LOCKING:
1129  *      None.
1130  */
1131
1132 static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1133 {
1134         const u8 page[] = {
1135                 0x1,                      /* page code */
1136                 0xa,                      /* page length */
1137                 (1 << 7) | (1 << 6),      /* note auto r/w reallocation */
1138                 0, 0, 0, 0, 0, 0, 0, 0, 0 /* 9 zeroes */
1139         };
1140
1141         ata_msense_push(ptr_io, last, page, sizeof(page));
1142         return sizeof(page);
1143 }
1144
1145 /**
1146  *      ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1147  *      @args: device IDENTIFY data / SCSI command of interest.
1148  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1149  *      @buflen: Response buffer length.
1150  *
1151  *      Simulate MODE SENSE commands.
1152  *
1153  *      LOCKING:
1154  *      spin_lock_irqsave(host_set lock)
1155  */
1156
1157 unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1158                                   unsigned int buflen)
1159 {
1160         u8 *scsicmd = args->cmd->cmnd, *p, *last;
1161         unsigned int page_control, six_byte, output_len;
1162
1163         VPRINTK("ENTER\n");
1164
1165         six_byte = (scsicmd[0] == MODE_SENSE);
1166
1167         /* we only support saved and current values (which we treat
1168          * in the same manner)
1169          */
1170         page_control = scsicmd[2] >> 6;
1171         if ((page_control != 0) && (page_control != 3))
1172                 return 1;
1173
1174         if (six_byte)
1175                 output_len = 4;
1176         else
1177                 output_len = 8;
1178
1179         p = rbuf + output_len;
1180         last = rbuf + buflen - 1;
1181
1182         switch(scsicmd[2] & 0x3f) {
1183         case 0x01:              /* r/w error recovery */
1184                 output_len += ata_msense_rw_recovery(&p, last);
1185                 break;
1186
1187         case 0x08:              /* caching */
1188                 output_len += ata_msense_caching(args->id, &p, last);
1189                 break;
1190
1191         case 0x0a: {            /* control mode */
1192                 output_len += ata_msense_ctl_mode(&p, last);
1193                 break;
1194                 }
1195
1196         case 0x3f:              /* all pages */
1197                 output_len += ata_msense_rw_recovery(&p, last);
1198                 output_len += ata_msense_caching(args->id, &p, last);
1199                 output_len += ata_msense_ctl_mode(&p, last);
1200                 break;
1201
1202         default:                /* invalid page code */
1203                 return 1;
1204         }
1205
1206         if (six_byte) {
1207                 output_len--;
1208                 rbuf[0] = output_len;
1209         } else {
1210                 output_len -= 2;
1211                 rbuf[0] = output_len >> 8;
1212                 rbuf[1] = output_len;
1213         }
1214
1215         return 0;
1216 }
1217
1218 /**
1219  *      ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
1220  *      @args: device IDENTIFY data / SCSI command of interest.
1221  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1222  *      @buflen: Response buffer length.
1223  *
1224  *      Simulate READ CAPACITY commands.
1225  *
1226  *      LOCKING:
1227  *      spin_lock_irqsave(host_set lock)
1228  */
1229
1230 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
1231                                 unsigned int buflen)
1232 {
1233         u64 n_sectors;
1234         u32 tmp;
1235
1236         VPRINTK("ENTER\n");
1237
1238         if (ata_id_has_lba48(args->id))
1239                 n_sectors = ata_id_u64(args->id, 100);
1240         else
1241                 n_sectors = ata_id_u32(args->id, 60);
1242         n_sectors--;            /* ATA TotalUserSectors - 1 */
1243
1244         if (args->cmd->cmnd[0] == READ_CAPACITY) {
1245                 if( n_sectors >= 0xffffffffULL )
1246                         tmp = 0xffffffff ;  /* Return max count on overflow */
1247                 else
1248                         tmp = n_sectors ;
1249
1250                 /* sector count, 32-bit */
1251                 rbuf[0] = tmp >> (8 * 3);
1252                 rbuf[1] = tmp >> (8 * 2);
1253                 rbuf[2] = tmp >> (8 * 1);
1254                 rbuf[3] = tmp;
1255
1256                 /* sector size */
1257                 tmp = ATA_SECT_SIZE;
1258                 rbuf[6] = tmp >> 8;
1259                 rbuf[7] = tmp;
1260
1261         } else {
1262                 /* sector count, 64-bit */
1263                 tmp = n_sectors >> (8 * 4);
1264                 rbuf[2] = tmp >> (8 * 3);
1265                 rbuf[3] = tmp >> (8 * 2);
1266                 rbuf[4] = tmp >> (8 * 1);
1267                 rbuf[5] = tmp;
1268                 tmp = n_sectors;
1269                 rbuf[6] = tmp >> (8 * 3);
1270                 rbuf[7] = tmp >> (8 * 2);
1271                 rbuf[8] = tmp >> (8 * 1);
1272                 rbuf[9] = tmp;
1273
1274                 /* sector size */
1275                 tmp = ATA_SECT_SIZE;
1276                 rbuf[12] = tmp >> 8;
1277                 rbuf[13] = tmp;
1278         }
1279
1280         return 0;
1281 }
1282
1283 /**
1284  *      ata_scsiop_report_luns - Simulate REPORT LUNS command
1285  *      @args: device IDENTIFY data / SCSI command of interest.
1286  *      @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1287  *      @buflen: Response buffer length.
1288  *
1289  *      Simulate REPORT LUNS command.
1290  *
1291  *      LOCKING:
1292  *      spin_lock_irqsave(host_set lock)
1293  */
1294
1295 unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
1296                                    unsigned int buflen)
1297 {
1298         VPRINTK("ENTER\n");
1299         rbuf[3] = 8;    /* just one lun, LUN 0, size 8 bytes */
1300
1301         return 0;
1302 }
1303
1304 /**
1305  *      ata_scsi_badcmd - End a SCSI request with an error
1306  *      @cmd: SCSI request to be handled
1307  *      @done: SCSI command completion function
1308  *      @asc: SCSI-defined additional sense code
1309  *      @ascq: SCSI-defined additional sense code qualifier
1310  *
1311  *      Helper function that completes a SCSI command with
1312  *      %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
1313  *      and the specified additional sense codes.
1314  *
1315  *      LOCKING:
1316  *      spin_lock_irqsave(host_set lock)
1317  */
1318
1319 void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
1320 {
1321         DPRINTK("ENTER\n");
1322         cmd->result = SAM_STAT_CHECK_CONDITION;
1323
1324         cmd->sense_buffer[0] = 0x70;
1325         cmd->sense_buffer[2] = ILLEGAL_REQUEST;
1326         cmd->sense_buffer[7] = 14 - 8;  /* addnl. sense len. FIXME: correct? */
1327         cmd->sense_buffer[12] = asc;
1328         cmd->sense_buffer[13] = ascq;
1329
1330         done(cmd);
1331 }
1332
1333 static int atapi_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
1334 {
1335         struct scsi_cmnd *cmd = qc->scsicmd;
1336
1337         if (unlikely(drv_stat & (ATA_ERR | ATA_BUSY | ATA_DRQ))) {
1338                 DPRINTK("request check condition\n");
1339
1340                 cmd->result = SAM_STAT_CHECK_CONDITION;
1341
1342                 qc->scsidone(cmd);
1343
1344                 return 1;
1345         } else {
1346                 u8 *scsicmd = cmd->cmnd;
1347
1348                 if (scsicmd[0] == INQUIRY) {
1349                         u8 *buf = NULL;
1350                         unsigned int buflen;
1351
1352                         buflen = ata_scsi_rbuf_get(cmd, &buf);
1353                         buf[2] = 0x5;
1354                         buf[3] = (buf[3] & 0xf0) | 2;
1355                         ata_scsi_rbuf_put(cmd, buf);
1356                 }
1357                 cmd->result = SAM_STAT_GOOD;
1358         }
1359
1360         qc->scsidone(cmd);
1361
1362         return 0;
1363 }
1364 /**
1365  *      atapi_xlat - Initialize PACKET taskfile
1366  *      @qc: command structure to be initialized
1367  *      @scsicmd: SCSI CDB associated with this PACKET command
1368  *
1369  *      LOCKING:
1370  *      spin_lock_irqsave(host_set lock)
1371  *
1372  *      RETURNS:
1373  *      Zero on success, non-zero on failure.
1374  */
1375
1376 static unsigned int atapi_xlat(struct ata_queued_cmd *qc, u8 *scsicmd)
1377 {
1378         struct scsi_cmnd *cmd = qc->scsicmd;
1379         struct ata_device *dev = qc->dev;
1380         int using_pio = (dev->flags & ATA_DFLAG_PIO);
1381         int nodata = (cmd->sc_data_direction == DMA_NONE);
1382
1383         if (!using_pio)
1384                 /* Check whether ATAPI DMA is safe */
1385                 if (ata_check_atapi_dma(qc))
1386                         using_pio = 1;
1387
1388         memcpy(&qc->cdb, scsicmd, qc->ap->cdb_len);
1389
1390         qc->complete_fn = atapi_qc_complete;
1391
1392         qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1393         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
1394                 qc->tf.flags |= ATA_TFLAG_WRITE;
1395                 DPRINTK("direction: write\n");
1396         }
1397
1398         qc->tf.command = ATA_CMD_PACKET;
1399
1400         /* no data, or PIO data xfer */
1401         if (using_pio || nodata) {
1402                 if (nodata)
1403                         qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
1404                 else
1405                         qc->tf.protocol = ATA_PROT_ATAPI;
1406                 qc->tf.lbam = (8 * 1024) & 0xff;
1407                 qc->tf.lbah = (8 * 1024) >> 8;
1408         }
1409
1410         /* DMA data xfer */
1411         else {
1412                 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
1413                 qc->tf.feature |= ATAPI_PKT_DMA;
1414
1415 #ifdef ATAPI_ENABLE_DMADIR
1416                 /* some SATA bridges need us to indicate data xfer direction */
1417                 if (cmd->sc_data_direction != DMA_TO_DEVICE)
1418                         qc->tf.feature |= ATAPI_DMADIR;
1419 #endif
1420         }
1421
1422         qc->nbytes = cmd->bufflen;
1423
1424         return 0;
1425 }
1426
1427 /**
1428  *      ata_scsi_find_dev - lookup ata_device from scsi_cmnd
1429  *      @ap: ATA port to which the device is attached
1430  *      @scsidev: SCSI device from which we derive the ATA device
1431  *
1432  *      Given various information provided in struct scsi_cmnd,
1433  *      map that onto an ATA bus, and using that mapping
1434  *      determine which ata_device is associated with the
1435  *      SCSI command to be sent.
1436  *
1437  *      LOCKING:
1438  *      spin_lock_irqsave(host_set lock)
1439  *
1440  *      RETURNS:
1441  *      Associated ATA device, or %NULL if not found.
1442  */
1443
1444 static struct ata_device *
1445 ata_scsi_find_dev(struct ata_port *ap, struct scsi_device *scsidev)
1446 {
1447         struct ata_device *dev;
1448
1449         /* skip commands not addressed to targets we simulate */
1450         if (likely(scsidev->id < ATA_MAX_DEVICES))
1451                 dev = &ap->device[scsidev->id];
1452         else
1453                 return NULL;
1454
1455         if (unlikely((scsidev->channel != 0) ||
1456                      (scsidev->lun != 0)))
1457                 return NULL;
1458
1459         if (unlikely(!ata_dev_present(dev)))
1460                 return NULL;
1461
1462 #ifndef ATA_ENABLE_ATAPI
1463         if (unlikely(dev->class == ATA_DEV_ATAPI))
1464                 return NULL;
1465 #endif
1466
1467         return dev;
1468 }
1469
1470 /**
1471  *      ata_get_xlat_func - check if SCSI to ATA translation is possible
1472  *      @dev: ATA device
1473  *      @cmd: SCSI command opcode to consider
1474  *
1475  *      Look up the SCSI command given, and determine whether the
1476  *      SCSI command is to be translated or simulated.
1477  *
1478  *      RETURNS:
1479  *      Pointer to translation function if possible, %NULL if not.
1480  */
1481
1482 static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
1483 {
1484         switch (cmd) {
1485         case READ_6:
1486         case READ_10:
1487         case READ_16:
1488
1489         case WRITE_6:
1490         case WRITE_10:
1491         case WRITE_16:
1492                 return ata_scsi_rw_xlat;
1493
1494         case SYNCHRONIZE_CACHE:
1495                 if (ata_try_flush_cache(dev))
1496                         return ata_scsi_flush_xlat;
1497                 break;
1498
1499         case VERIFY:
1500         case VERIFY_16:
1501                 return ata_scsi_verify_xlat;
1502         case START_STOP:
1503                 return ata_scsi_start_stop_xlat;
1504         }
1505
1506         return NULL;
1507 }
1508
1509 /**
1510  *      ata_scsi_dump_cdb - dump SCSI command contents to dmesg
1511  *      @ap: ATA port to which the command was being sent
1512  *      @cmd: SCSI command to dump
1513  *
1514  *      Prints the contents of a SCSI command via printk().
1515  */
1516
1517 static inline void ata_scsi_dump_cdb(struct ata_port *ap,
1518                                      struct scsi_cmnd *cmd)
1519 {
1520 #ifdef ATA_DEBUG
1521         struct scsi_device *scsidev = cmd->device;
1522         u8 *scsicmd = cmd->cmnd;
1523
1524         DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
1525                 ap->id,
1526                 scsidev->channel, scsidev->id, scsidev->lun,
1527                 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
1528                 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
1529                 scsicmd[8]);
1530 #endif
1531 }
1532
1533 /**
1534  *      ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
1535  *      @cmd: SCSI command to be sent
1536  *      @done: Completion function, called when command is complete
1537  *
1538  *      In some cases, this function translates SCSI commands into
1539  *      ATA taskfiles, and queues the taskfiles to be sent to
1540  *      hardware.  In other cases, this function simulates a
1541  *      SCSI device by evaluating and responding to certain
1542  *      SCSI commands.  This creates the overall effect of
1543  *      ATA and ATAPI devices appearing as SCSI devices.
1544  *
1545  *      LOCKING:
1546  *      Releases scsi-layer-held lock, and obtains host_set lock.
1547  *
1548  *      RETURNS:
1549  *      Zero.
1550  */
1551
1552 int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
1553 {
1554         struct ata_port *ap;
1555         struct ata_device *dev;
1556         struct scsi_device *scsidev = cmd->device;
1557
1558         ap = (struct ata_port *) &scsidev->host->hostdata[0];
1559
1560         ata_scsi_dump_cdb(ap, cmd);
1561
1562         dev = ata_scsi_find_dev(ap, scsidev);
1563         if (unlikely(!dev)) {
1564                 cmd->result = (DID_BAD_TARGET << 16);
1565                 done(cmd);
1566                 goto out_unlock;
1567         }
1568
1569         if (dev->class == ATA_DEV_ATA) {
1570                 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
1571                                                               cmd->cmnd[0]);
1572
1573                 if (xlat_func)
1574                         ata_scsi_translate(ap, dev, cmd, done, xlat_func);
1575                 else
1576                         ata_scsi_simulate(dev->id, cmd, done);
1577         } else
1578                 ata_scsi_translate(ap, dev, cmd, done, atapi_xlat);
1579
1580 out_unlock:
1581         return 0;
1582 }
1583
1584 /**
1585  *      ata_scsi_simulate - simulate SCSI command on ATA device
1586  *      @id: current IDENTIFY data for target device.
1587  *      @cmd: SCSI command being sent to device.
1588  *      @done: SCSI command completion function.
1589  *
1590  *      Interprets and directly executes a select list of SCSI commands
1591  *      that can be handled internally.
1592  *
1593  *      LOCKING:
1594  *      spin_lock_irqsave(host_set lock)
1595  */
1596
1597 void ata_scsi_simulate(u16 *id,
1598                       struct scsi_cmnd *cmd,
1599                       void (*done)(struct scsi_cmnd *))
1600 {
1601         struct ata_scsi_args args;
1602         u8 *scsicmd = cmd->cmnd;
1603
1604         args.id = id;
1605         args.cmd = cmd;
1606         args.done = done;
1607
1608         switch(scsicmd[0]) {
1609                 /* no-op's, complete with success */
1610                 case SYNCHRONIZE_CACHE:
1611                 case REZERO_UNIT:
1612                 case SEEK_6:
1613                 case SEEK_10:
1614                 case TEST_UNIT_READY:
1615                 case FORMAT_UNIT:               /* FIXME: correct? */
1616                 case SEND_DIAGNOSTIC:           /* FIXME: correct? */
1617                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
1618                         break;
1619
1620                 case INQUIRY:
1621                         if (scsicmd[1] & 2)                /* is CmdDt set?  */
1622                                 ata_bad_cdb(cmd, done);
1623                         else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
1624                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
1625                         else if (scsicmd[2] == 0x00)
1626                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
1627                         else if (scsicmd[2] == 0x80)
1628                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
1629                         else if (scsicmd[2] == 0x83)
1630                                 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
1631                         else
1632                                 ata_bad_cdb(cmd, done);
1633                         break;
1634
1635                 case MODE_SENSE:
1636                 case MODE_SENSE_10:
1637                         ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
1638                         break;
1639
1640                 case MODE_SELECT:       /* unconditionally return */
1641                 case MODE_SELECT_10:    /* bad-field-in-cdb */
1642                         ata_bad_cdb(cmd, done);
1643                         break;
1644
1645                 case READ_CAPACITY:
1646                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1647                         break;
1648
1649                 case SERVICE_ACTION_IN:
1650                         if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
1651                                 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
1652                         else
1653                                 ata_bad_cdb(cmd, done);
1654                         break;
1655
1656                 case REPORT_LUNS:
1657                         ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
1658                         break;
1659
1660                 /* mandantory commands we haven't implemented yet */
1661                 case REQUEST_SENSE:
1662
1663                 /* all other commands */
1664                 default:
1665                         ata_bad_scsiop(cmd, done);
1666                         break;
1667         }
1668 }
1669