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