projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sata_nv: add suspend/resume support v3 (Resubmit)
[GitHub/mt8127/android_kernel_alcatel_ttab.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 */
7102d230
AB		 400static struct ata_queued_cmd *ata_scsi_qc_new(struct ata_device *dev,
401 struct scsi_cmnd *cmd,
402 void (*done)(struct scsi_cmnd *))
1da177e4
LT		 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 */
7102d230 438static void ata_dump_status(unsigned id, struct ata_taskfile *tf)
b095518e
JG		 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 */
7102d230
AB		 613static void ata_to_sense_error(unsigned id, u8 drv_stat, u8 drv_err, u8 *sk,
614 u8 *asc, 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 1024 tf->command = ATA_CMD_VERIFY; /* READ VERIFY */
78981a7c
RH		 1025 } else
1026 /* Issue ATA STANDBY IMMEDIATE command */
1027 tf->command = ATA_CMD_STANDBYNOW1;
1028
972dcafb
DG		 1029 /*
1030 * Standby and Idle condition timers could be implemented but that
1031 * would require libata to implement the Power condition mode page
1032 * and allow the user to change it. Changing mode pages requires
1033 * MODE SELECT to be implemented.
1034 */
1035
1036 return 0;
ae006510
DG		 1037
1038invalid_fld:
542b1444 1039 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
ae006510
DG		 1040 /* "Invalid field in cbd" */
1041 return 1;
972dcafb
DG		 1042}
1043
1044
1da177e4
LT		 1045/**
1046 * ata_scsi_flush_xlat - Translate SCSI SYNCHRONIZE CACHE command
1047 * @qc: Storage for translated ATA taskfile
1da177e4
LT		 1048 *
1049 * Sets up an ATA taskfile to issue FLUSH CACHE or
1050 * FLUSH CACHE EXT.
1051 *
1052 * LOCKING:
cca3974e 1053 * spin_lock_irqsave(host lock)
1da177e4
LT		 1054 *
1055 * RETURNS:
1056 * Zero on success, non-zero on error.
1057 */
ad706991 1058static unsigned int ata_scsi_flush_xlat(struct ata_queued_cmd *qc)
1da177e4
LT		 1059{
1060 struct ata_taskfile *tf = &qc->tf;
1061
1062 tf->flags |= ATA_TFLAG_DEVICE;
1063 tf->protocol = ATA_PROT_NODATA;
1064
6fc49adb 1065 if (qc->dev->flags & ATA_DFLAG_FLUSH_EXT)
1da177e4
LT		 1066 tf->command = ATA_CMD_FLUSH_EXT;
1067 else
1068 tf->command = ATA_CMD_FLUSH;
1069
1070 return 0;
1071}
1072
3aef5231
AL		 1073/**
1074 * scsi_6_lba_len - Get LBA and transfer length
542b1444 1075 * @cdb: SCSI command to translate
3aef5231
AL		 1076 *
1077 * Calculate LBA and transfer length for 6-byte commands.
1078 *
1079 * RETURNS:
1080 * @plba: the LBA
1081 * @plen: the transfer length
1082 */
542b1444 1083static void scsi_6_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
3aef5231
AL		 1084{
1085 u64 lba = 0;
1086 u32 len = 0;
1087
1088 VPRINTK("six-byte command\n");
1089
542b1444
TH		 1090 lba |= ((u64)cdb[2]) << 8;
1091 lba |= ((u64)cdb[3]);
3aef5231 1092
542b1444 1093 len |= ((u32)cdb[4]);
3aef5231
AL		 1094
1095 *plba = lba;
1096 *plen = len;
1097}
1098
1099/**
1100 * scsi_10_lba_len - Get LBA and transfer length
542b1444 1101 * @cdb: SCSI command to translate
3aef5231
AL		 1102 *
1103 * Calculate LBA and transfer length for 10-byte commands.
1104 *
1105 * RETURNS:
1106 * @plba: the LBA
1107 * @plen: the transfer length
1108 */
542b1444 1109static void scsi_10_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
3aef5231
AL		 1110{
1111 u64 lba = 0;
1112 u32 len = 0;
1113
1114 VPRINTK("ten-byte command\n");
1115
542b1444
TH		 1116 lba |= ((u64)cdb[2]) << 24;
1117 lba |= ((u64)cdb[3]) << 16;
1118 lba |= ((u64)cdb[4]) << 8;
1119 lba |= ((u64)cdb[5]);
3aef5231 1120
542b1444
TH		 1121 len |= ((u32)cdb[7]) << 8;
1122 len |= ((u32)cdb[8]);
3aef5231
AL		 1123
1124 *plba = lba;
1125 *plen = len;
1126}
1127
1128/**
1129 * scsi_16_lba_len - Get LBA and transfer length
542b1444 1130 * @cdb: SCSI command to translate
3aef5231
AL		 1131 *
1132 * Calculate LBA and transfer length for 16-byte commands.
1133 *
1134 * RETURNS:
1135 * @plba: the LBA
1136 * @plen: the transfer length
1137 */
542b1444 1138static void scsi_16_lba_len(const u8 *cdb, u64 *plba, u32 *plen)
3aef5231
AL		 1139{
1140 u64 lba = 0;
1141 u32 len = 0;
1142
1143 VPRINTK("sixteen-byte command\n");
1144
542b1444
TH		 1145 lba |= ((u64)cdb[2]) << 56;
1146 lba |= ((u64)cdb[3]) << 48;
1147 lba |= ((u64)cdb[4]) << 40;
1148 lba |= ((u64)cdb[5]) << 32;
1149 lba |= ((u64)cdb[6]) << 24;
1150 lba |= ((u64)cdb[7]) << 16;
1151 lba |= ((u64)cdb[8]) << 8;
1152 lba |= ((u64)cdb[9]);
3aef5231 1153
542b1444
TH		 1154 len |= ((u32)cdb[10]) << 24;
1155 len |= ((u32)cdb[11]) << 16;
1156 len |= ((u32)cdb[12]) << 8;
1157 len |= ((u32)cdb[13]);
3aef5231
AL		 1158
1159 *plba = lba;
1160 *plen = len;
1161}
1162
1da177e4
LT		 1163/**
1164 * ata_scsi_verify_xlat - Translate SCSI VERIFY command into an ATA one
1165 * @qc: Storage for translated ATA taskfile
1da177e4
LT		 1166 *
1167 * Converts SCSI VERIFY command to an ATA READ VERIFY command.
1168 *
1169 * LOCKING:
cca3974e 1170 * spin_lock_irqsave(host lock)
1da177e4
LT		 1171 *
1172 * RETURNS:
1173 * Zero on success, non-zero on error.
1174 */
ad706991 1175static unsigned int ata_scsi_verify_xlat(struct ata_queued_cmd *qc)
1da177e4 1176{
542b1444 1177 struct scsi_cmnd *scmd = qc->scsicmd;
1da177e4 1178 struct ata_taskfile *tf = &qc->tf;
8bf62ece 1179 struct ata_device *dev = qc->dev;
1da177e4 1180 u64 dev_sectors = qc->dev->n_sectors;
ad706991 1181 const u8 *cdb = scmd->cmnd;
3aef5231
AL		 1182 u64 block;
1183 u32 n_block;
1da177e4
LT		 1184
1185 tf->flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
1186 tf->protocol = ATA_PROT_NODATA;
1da177e4 1187
2e5704f6
TH		 1188 if (cdb[0] == VERIFY) {
1189 if (scmd->cmd_len < 10)
1190 goto invalid_fld;
542b1444 1191 scsi_10_lba_len(cdb, &block, &n_block);
2e5704f6
TH		 1192 } else if (cdb[0] == VERIFY_16) {
1193 if (scmd->cmd_len < 16)
1194 goto invalid_fld;
542b1444 1195 scsi_16_lba_len(cdb, &block, &n_block);
2e5704f6 1196 } else
ae006510 1197 goto invalid_fld;
1da177e4 1198
8bf62ece 1199 if (!n_block)
ae006510 1200 goto nothing_to_do;
8bf62ece 1201 if (block >= dev_sectors)
ae006510 1202 goto out_of_range;
8bf62ece 1203 if ((block + n_block) > dev_sectors)
ae006510 1204 goto out_of_range;
1da177e4 1205
07506697
AL		 1206 if (dev->flags & ATA_DFLAG_LBA) {
1207 tf->flags |= ATA_TFLAG_LBA;
1208
c6a33e24
AL		 1209 if (lba_28_ok(block, n_block)) {
1210 /* use LBA28 */
1211 tf->command = ATA_CMD_VERIFY;
1212 tf->device |= (block >> 24) & 0xf;
1213 } else if (lba_48_ok(block, n_block)) {
1214 if (!(dev->flags & ATA_DFLAG_LBA48))
1215 goto out_of_range;
07506697
AL		 1216
1217 /* use LBA48 */
1218 tf->flags |= ATA_TFLAG_LBA48;
8bf62ece 1219 tf->command = ATA_CMD_VERIFY_EXT;
1da177e4 1220
8bf62ece 1221 tf->hob_nsect = (n_block >> 8) & 0xff;
1da177e4 1222
8bf62ece
AL		 1223 tf->hob_lbah = (block >> 40) & 0xff;
1224 tf->hob_lbam = (block >> 32) & 0xff;
1225 tf->hob_lbal = (block >> 24) & 0xff;
c6a33e24
AL		 1226 } else
1227 /* request too large even for LBA48 */
1228 goto out_of_range;
8bf62ece
AL		 1229
1230 tf->nsect = n_block & 0xff;
1da177e4 1231
8bf62ece
AL		 1232 tf->lbah = (block >> 16) & 0xff;
1233 tf->lbam = (block >> 8) & 0xff;
1234 tf->lbal = block & 0xff;
1da177e4 1235
8bf62ece
AL		 1236 tf->device |= ATA_LBA;
1237 } else {
1238 /* CHS */
1239 u32 sect, head, cyl, track;
1240
c6a33e24
AL		 1241 if (!lba_28_ok(block, n_block))
1242 goto out_of_range;
07506697 1243
8bf62ece
AL		 1244 /* Convert LBA to CHS */
1245 track = (u32)block / dev->sectors;
1246 cyl = track / dev->heads;
1247 head = track % dev->heads;
1248 sect = (u32)block % dev->sectors + 1;
1249
c187c4b5
AL		 1250 DPRINTK("block %u track %u cyl %u head %u sect %u\n",
1251 (u32)block, track, cyl, head, sect);
2e9edbf8
JG		 1252
1253 /* Check whether the converted CHS can fit.
1254 Cylinder: 0-65535
8bf62ece
AL		 1255 Head: 0-15
1256 Sector: 1-255*/
2e9edbf8 1257 if ((cyl >> 16) || (head >> 4) || (sect >> 8) || (!sect))
ae006510 1258 goto out_of_range;
2e9edbf8 1259
8bf62ece
AL		 1260 tf->command = ATA_CMD_VERIFY;
1261 tf->nsect = n_block & 0xff; /* Sector count 0 means 256 sectors */
1262 tf->lbal = sect;
1263 tf->lbam = cyl;
1264 tf->lbah = cyl >> 8;
1265 tf->device |= head;
1266 }
1da177e4
LT		 1267
1268 return 0;
ae006510
DG		 1269
1270invalid_fld:
542b1444 1271 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
ae006510
DG		 1272 /* "Invalid field in cbd" */
1273 return 1;
1274
1275out_of_range:
542b1444 1276 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
ae006510
DG		 1277 /* "Logical Block Address out of range" */
1278 return 1;
1279
1280nothing_to_do:
542b1444 1281 scmd->result = SAM_STAT_GOOD;
ae006510 1282 return 1;
1da177e4
LT		 1283}
1284
1285/**
1286 * ata_scsi_rw_xlat - Translate SCSI r/w command into an ATA one
1287 * @qc: Storage for translated ATA taskfile
1da177e4
LT		 1288 *
1289 * Converts any of six SCSI read/write commands into the
1290 * ATA counterpart, including starting sector (LBA),
1291 * sector count, and taking into account the device's LBA48
1292 * support.
1293 *
1294 * Commands %READ_6, %READ_10, %READ_16, %WRITE_6, %WRITE_10, and
1295 * %WRITE_16 are currently supported.
1296 *
1297 * LOCKING:
cca3974e 1298 * spin_lock_irqsave(host lock)
1da177e4
LT		 1299 *
1300 * RETURNS:
1301 * Zero on success, non-zero on error.
1302 */
ad706991 1303static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc)
1da177e4 1304{
542b1444 1305 struct scsi_cmnd *scmd = qc->scsicmd;
ad706991 1306 const u8 *cdb = scmd->cmnd;
bd056d7e 1307 unsigned int tf_flags = 0;
3aef5231
AL		 1308 u64 block;
1309 u32 n_block;
bd056d7e 1310 int rc;
1da177e4 1311
542b1444 1312 if (cdb[0] == WRITE_10 || cdb[0] == WRITE_6 || cdb[0] == WRITE_16)
bd056d7e 1313 tf_flags |= ATA_TFLAG_WRITE;
1da177e4 1314
9a3dccc4 1315 /* Calculate the SCSI LBA, transfer length and FUA. */
542b1444 1316 switch (cdb[0]) {
3aef5231
AL		 1317 case READ_10:
1318 case WRITE_10:
2e5704f6
TH		 1319 if (unlikely(scmd->cmd_len < 10))
1320 goto invalid_fld;
542b1444
TH		 1321 scsi_10_lba_len(cdb, &block, &n_block);
1322 if (unlikely(cdb[1] & (1 << 3)))
bd056d7e 1323 tf_flags |= ATA_TFLAG_FUA;
3aef5231
AL		 1324 break;
1325 case READ_6:
1326 case WRITE_6:
2e5704f6
TH		 1327 if (unlikely(scmd->cmd_len < 6))
1328 goto invalid_fld;
542b1444 1329 scsi_6_lba_len(cdb, &block, &n_block);
c187c4b5
AL		 1330
1331 /* for 6-byte r/w commands, transfer length 0
1332 * means 256 blocks of data, not 0 block.
1333 */
76b2bf9b
JG		 1334 if (!n_block)
1335 n_block = 256;
3aef5231
AL		 1336 break;
1337 case READ_16:
1338 case WRITE_16:
2e5704f6
TH		 1339 if (unlikely(scmd->cmd_len < 16))
1340 goto invalid_fld;
542b1444
TH		 1341 scsi_16_lba_len(cdb, &block, &n_block);
1342 if (unlikely(cdb[1] & (1 << 3)))
bd056d7e 1343 tf_flags |= ATA_TFLAG_FUA;
3aef5231
AL		 1344 break;
1345 default:
8bf62ece 1346 DPRINTK("no-byte command\n");
ae006510 1347 goto invalid_fld;
1da177e4
LT		 1348 }
1349
8bf62ece
AL		 1350 /* Check and compose ATA command */
1351 if (!n_block)
c187c4b5
AL		 1352 /* For 10-byte and 16-byte SCSI R/W commands, transfer
1353 * length 0 means transfer 0 block of data.
1354 * However, for ATA R/W commands, sector count 0 means
1355 * 256 or 65536 sectors, not 0 sectors as in SCSI.
f51750d5
AC		 1356 *
1357 * WARNING: one or two older ATA drives treat 0 as 0...
c187c4b5 1358 */
ae006510 1359 goto nothing_to_do;
1da177e4 1360
bd056d7e
TH		 1361 qc->flags |= ATA_QCFLAG_IO;
1362 qc->nsect = n_block;
1da177e4 1363
bd056d7e
TH		 1364 rc = ata_build_rw_tf(&qc->tf, qc->dev, block, n_block, tf_flags,
1365 qc->tag);
1366 if (likely(rc == 0))
1367 return 0;
ae006510 1368
bd056d7e
TH		 1369 if (rc == -ERANGE)
1370 goto out_of_range;
1371 /* treat all other errors as -EINVAL, fall through */
ae006510 1372invalid_fld:
542b1444 1373 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x0);
ae006510
DG		 1374 /* "Invalid field in cbd" */
1375 return 1;
1376
1377out_of_range:
542b1444 1378 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x21, 0x0);
ae006510
DG		 1379 /* "Logical Block Address out of range" */
1380 return 1;
1381
1382nothing_to_do:
542b1444 1383 scmd->result = SAM_STAT_GOOD;
ae006510 1384 return 1;
1da177e4
LT		 1385}
1386
77853bf2 1387static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
1da177e4 1388{
c31f571d 1389 struct ata_port *ap = qc->ap;
1da177e4 1390 struct scsi_cmnd *cmd = qc->scsicmd;
a7dac447 1391 u8 *cdb = cmd->cmnd;
a22e2eb0 1392 int need_sense = (qc->err_mask != 0);
b095518e 1393
3057ac3c 1394 /* We snoop the SET_FEATURES - Write Cache ON/OFF command, and
1395 * schedule EH_REVALIDATE operation to update the IDENTIFY DEVICE
1396 * cache
1397 */
c31f571d
TH		 1398 if (ap->ops->error_handler &&
1399 !need_sense && (qc->tf.command == ATA_CMD_SET_FEATURES) &&
3057ac3c 1400 ((qc->tf.feature == SETFEATURES_WC_ON) ||
1401 (qc->tf.feature == SETFEATURES_WC_OFF))) {
c31f571d
TH		 1402 ap->eh_info.action |= ATA_EH_REVALIDATE;
1403 ata_port_schedule_eh(ap);
3057ac3c 1404 }
1405
b095518e
JG		 1406 /* For ATA pass thru (SAT) commands, generate a sense block if
1407 * user mandated it or if there's an error. Note that if we
1408 * generate because the user forced us to, a check condition
1409 * is generated and the ATA register values are returned
1410 * whether the command completed successfully or not. If there
1411 * was no error, SK, ASC and ASCQ will all be zero.
1412 */
a7dac447
JG		 1413 if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
1414 ((cdb[2] & 0x20) || need_sense)) {
750426aa 1415 ata_gen_passthru_sense(qc);
b095518e
JG		 1416 } else {
1417 if (!need_sense) {
1418 cmd->result = SAM_STAT_GOOD;
1419 } else {
1420 /* TODO: decide which descriptor format to use
1421 * for 48b LBA devices and call that here
1422 * instead of the fixed desc, which is only
1423 * good for smaller LBA (and maybe CHS?)
1424 * devices.
1425 */
750426aa 1426 ata_gen_ata_sense(qc);
b095518e
JG		 1427 }
1428 }
1da177e4 1429
c31f571d
TH		 1430 if (need_sense && !ap->ops->error_handler)
1431 ata_dump_status(ap->id, &qc->result_tf);
1da177e4
LT		 1432
1433 qc->scsidone(cmd);
1434
77853bf2 1435 ata_qc_free(qc);
1da177e4
LT		 1436}
1437
3dc1d881
TH		 1438/**
1439 * ata_scmd_need_defer - Check whether we need to defer scmd
1440 * @dev: ATA device to which the command is addressed
1441 * @is_io: Is the command IO (and thus possibly NCQ)?
1442 *
1443 * NCQ and non-NCQ commands cannot run together. As upper layer
1444 * only knows the queue depth, we are responsible for maintaining
1445 * exclusion. This function checks whether a new command can be
1446 * issued to @dev.
1447 *
1448 * LOCKING:
cca3974e 1449 * spin_lock_irqsave(host lock)
3dc1d881
TH		 1450 *
1451 * RETURNS:
1452 * 1 if deferring is needed, 0 otherwise.
1453 */
1454static int ata_scmd_need_defer(struct ata_device *dev, int is_io)
1455{
1456 struct ata_port *ap = dev->ap;
1457
1458 if (!(dev->flags & ATA_DFLAG_NCQ))
1459 return 0;
1460
1461 if (is_io) {
1462 if (!ata_tag_valid(ap->active_tag))
1463 return 0;
1464 } else {
1465 if (!ata_tag_valid(ap->active_tag) && !ap->sactive)
1466 return 0;
1467 }
1468 return 1;
1469}
1470
1da177e4
LT		 1471/**
1472 * ata_scsi_translate - Translate then issue SCSI command to ATA device
1da177e4
LT		 1473 * @dev: ATA device to which the command is addressed
1474 * @cmd: SCSI command to execute
1475 * @done: SCSI command completion function
1476 * @xlat_func: Actor which translates @cmd to an ATA taskfile
1477 *
1478 * Our ->queuecommand() function has decided that the SCSI
1479 * command issued can be directly translated into an ATA
1480 * command, rather than handled internally.
1481 *
1482 * This function sets up an ata_queued_cmd structure for the
1483 * SCSI command, and sends that ata_queued_cmd to the hardware.
1484 *
ae006510
DG		 1485 * The xlat_func argument (actor) returns 0 if ready to execute
1486 * ATA command, else 1 to finish translation. If 1 is returned
1487 * then cmd->result (and possibly cmd->sense_buffer) are assumed
1488 * to be set reflecting an error condition or clean (early)
1489 * termination.
1490 *
1da177e4 1491 * LOCKING:
cca3974e 1492 * spin_lock_irqsave(host lock)
2115ea94
TH		 1493 *
1494 * RETURNS:
1495 * 0 on success, SCSI_ML_QUEUE_DEVICE_BUSY if the command
1496 * needs to be deferred.
1da177e4 1497 */
2115ea94
TH		 1498static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
1499 void (*done)(struct scsi_cmnd *),
1500 ata_xlat_func_t xlat_func)
1da177e4
LT		 1501{
1502 struct ata_queued_cmd *qc;
3dc1d881 1503 int is_io = xlat_func == ata_scsi_rw_xlat;
1da177e4
LT		 1504
1505 VPRINTK("ENTER\n");
1506
3dc1d881
TH		 1507 if (unlikely(ata_scmd_need_defer(dev, is_io)))
1508 goto defer;
1509
3373efd8 1510 qc = ata_scsi_qc_new(dev, cmd, done);
1da177e4 1511 if (!qc)
ae006510 1512 goto err_mem;
1da177e4
LT		 1513
1514 /* data is present; dma-map it */
be7db055
CH		 1515 if (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1516 cmd->sc_data_direction == DMA_TO_DEVICE) {
1da177e4 1517 if (unlikely(cmd->request_bufflen < 1)) {
f15a1daf
TH		 1518 ata_dev_printk(dev, KERN_WARNING,
1519 "WARNING: zero len r/w req\n");
ae006510 1520 goto err_did;
1da177e4
LT		 1521 }
1522
1523 if (cmd->use_sg)
1524 ata_sg_init(qc, cmd->request_buffer, cmd->use_sg);
1525 else
1526 ata_sg_init_one(qc, cmd->request_buffer,
1527 cmd->request_bufflen);
1528
1529 qc->dma_dir = cmd->sc_data_direction;
1530 }
1531
1532 qc->complete_fn = ata_scsi_qc_complete;
1533
ad706991 1534 if (xlat_func(qc))
ae006510 1535 goto early_finish;
1da177e4
LT		 1536
1537 /* select device, send command to hardware */
8e0e694a 1538 ata_qc_issue(qc);
1da177e4
LT		 1539
1540 VPRINTK("EXIT\n");
2115ea94 1541 return 0;
1da177e4 1542
ae006510
DG		 1543early_finish:
1544 ata_qc_free(qc);
1545 done(cmd);
1546 DPRINTK("EXIT - early finish (good or error)\n");
2115ea94 1547 return 0;
ae006510
DG		 1548
1549err_did:
1da177e4 1550 ata_qc_free(qc);
ae006510
DG		 1551 cmd->result = (DID_ERROR << 16);
1552 done(cmd);
253b92ec 1553err_mem:
ae006510 1554 DPRINTK("EXIT - internal\n");
2115ea94 1555 return 0;
3dc1d881
TH		 1556
1557defer:
1558 DPRINTK("EXIT - defer\n");
1559 return SCSI_MLQUEUE_DEVICE_BUSY;
1da177e4
LT		 1560}
1561
1562/**
1563 * ata_scsi_rbuf_get - Map response buffer.
1564 * @cmd: SCSI command containing buffer to be mapped.
1565 * @buf_out: Pointer to mapped area.
1566 *
1567 * Maps buffer contained within SCSI command @cmd.
1568 *
1569 * LOCKING:
cca3974e 1570 * spin_lock_irqsave(host lock)
1da177e4
LT		 1571 *
1572 * RETURNS:
1573 * Length of response buffer.
1574 */
1575
1576static unsigned int ata_scsi_rbuf_get(struct scsi_cmnd *cmd, u8 **buf_out)
1577{
1578 u8 *buf;
1579 unsigned int buflen;
1580
1581 if (cmd->use_sg) {
1582 struct scatterlist *sg;
1583
1584 sg = (struct scatterlist *) cmd->request_buffer;
da02d2a1 1585 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1da177e4
LT		 1586 buflen = sg->length;
1587 } else {
1588 buf = cmd->request_buffer;
1589 buflen = cmd->request_bufflen;
1590 }
1591
1592 *buf_out = buf;
1593 return buflen;
1594}
1595
1596/**
1597 * ata_scsi_rbuf_put - Unmap response buffer.
1598 * @cmd: SCSI command containing buffer to be unmapped.
1599 * @buf: buffer to unmap
1600 *
1601 * Unmaps response buffer contained within @cmd.
1602 *
1603 * LOCKING:
cca3974e 1604 * spin_lock_irqsave(host lock)
1da177e4
LT		 1605 */
1606
1607static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
1608{
1609 if (cmd->use_sg) {
1610 struct scatterlist *sg;
1611
1612 sg = (struct scatterlist *) cmd->request_buffer;
da02d2a1 1613 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1da177e4
LT		 1614 }
1615}
1616
1617/**
1618 * ata_scsi_rbuf_fill - wrapper for SCSI command simulators
1619 * @args: device IDENTIFY data / SCSI command of interest.
1620 * @actor: Callback hook for desired SCSI command simulator
1621 *
1622 * Takes care of the hard work of simulating a SCSI command...
1623 * Mapping the response buffer, calling the command's handler,
1624 * and handling the handler's return value. This return value
1625 * indicates whether the handler wishes the SCSI command to be
ae006510
DG		 1626 * completed successfully (0), or not (in which case cmd->result
1627 * and sense buffer are assumed to be set).
1da177e4
LT		 1628 *
1629 * LOCKING:
cca3974e 1630 * spin_lock_irqsave(host lock)
1da177e4
LT		 1631 */
1632
1633void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
1634 unsigned int (*actor) (struct ata_scsi_args *args,
1635 u8 *rbuf, unsigned int buflen))
1636{
1637 u8 *rbuf;
1638 unsigned int buflen, rc;
1639 struct scsi_cmnd *cmd = args->cmd;
1640
1641 buflen = ata_scsi_rbuf_get(cmd, &rbuf);
1642 memset(rbuf, 0, buflen);
1643 rc = actor(args, rbuf, buflen);
1644 ata_scsi_rbuf_put(cmd, rbuf);
1645
ae006510 1646 if (rc == 0)
1da177e4 1647 cmd->result = SAM_STAT_GOOD;
ae006510 1648 args->done(cmd);
1da177e4
LT		 1649}
1650
6a36261e
TH		 1651/**
1652 * ATA_SCSI_RBUF_SET - helper to set values in SCSI response buffer
1653 * @idx: byte index into SCSI response buffer
1654 * @val: value to set
1655 *
1656 * To be used by SCSI command simulator functions. This macros
1657 * expects two local variables, u8 *rbuf and unsigned int buflen,
1658 * are in scope.
1659 *
1660 * LOCKING:
1661 * None.
1662 */
1663#define ATA_SCSI_RBUF_SET(idx, val) do { \
1664 if ((idx) < buflen) rbuf[(idx)] = (u8)(val); \
1665 } while (0)
1666
1da177e4
LT		 1667/**
1668 * ata_scsiop_inq_std - Simulate INQUIRY command
1669 * @args: device IDENTIFY data / SCSI command of interest.
1670 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1671 * @buflen: Response buffer length.
1672 *
1673 * Returns standard device identification data associated
b142eb65 1674 * with non-VPD INQUIRY command output.
1da177e4
LT		 1675 *
1676 * LOCKING:
cca3974e 1677 * spin_lock_irqsave(host lock)
1da177e4
LT		 1678 */
1679
1680unsigned int ata_scsiop_inq_std(struct ata_scsi_args *args, u8 *rbuf,
1681 unsigned int buflen)
1682{
1683 u8 hdr[] = {
1684 TYPE_DISK,
1685 0,
1686 0x5, /* claim SPC-3 version compatibility */
1687 2,
1688 95 - 4
1689 };
1690
1691 /* set scsi removeable (RMB) bit per ata bit */
1692 if (ata_id_removeable(args->id))
1693 hdr[1] |= (1 << 7);
1694
1695 VPRINTK("ENTER\n");
1696
1697 memcpy(rbuf, hdr, sizeof(hdr));
1698
1699 if (buflen > 35) {
1700 memcpy(&rbuf[8], "ATA ", 8);
6a62a04d
TH		 1701 ata_id_string(args->id, &rbuf[16], ATA_ID_PROD_OFS, 16);
1702 ata_id_string(args->id, &rbuf[32], ATA_ID_FW_REV_OFS, 4);
1da177e4
LT		 1703 if (rbuf[32] == 0 || rbuf[32] == ' ')
1704 memcpy(&rbuf[32], "n/a ", 4);
1705 }
1706
1707 if (buflen > 63) {
1708 const u8 versions[] = {
1709 0x60, /* SAM-3 (no version claimed) */
1710
1711 0x03,
1712 0x20, /* SBC-2 (no version claimed) */
1713
1714 0x02,
1715 0x60 /* SPC-3 (no version claimed) */
1716 };
1717
1718 memcpy(rbuf + 59, versions, sizeof(versions));
1719 }
1720
1721 return 0;
1722}
1723
1724/**
b142eb65 1725 * ata_scsiop_inq_00 - Simulate INQUIRY VPD page 0, list of pages
1da177e4
LT		 1726 * @args: device IDENTIFY data / SCSI command of interest.
1727 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1728 * @buflen: Response buffer length.
1729 *
b142eb65 1730 * Returns list of inquiry VPD pages available.
1da177e4
LT		 1731 *
1732 * LOCKING:
cca3974e 1733 * spin_lock_irqsave(host lock)
1da177e4
LT		 1734 */
1735
1736unsigned int ata_scsiop_inq_00(struct ata_scsi_args *args, u8 *rbuf,
1737 unsigned int buflen)
1738{
1739 const u8 pages[] = {
1740 0x00, /* page 0x00, this page */
1741 0x80, /* page 0x80, unit serial no page */
1742 0x83 /* page 0x83, device ident page */
1743 };
b142eb65 1744 rbuf[3] = sizeof(pages); /* number of supported VPD pages */
1da177e4
LT		 1745
1746 if (buflen > 6)
1747 memcpy(rbuf + 4, pages, sizeof(pages));
1748
1749 return 0;
1750}
1751
1752/**
b142eb65 1753 * ata_scsiop_inq_80 - Simulate INQUIRY VPD page 80, device serial number
1da177e4
LT		 1754 * @args: device IDENTIFY data / SCSI command of interest.
1755 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1756 * @buflen: Response buffer length.
1757 *
1758 * Returns ATA device serial number.
1759 *
1760 * LOCKING:
cca3974e 1761 * spin_lock_irqsave(host lock)
1da177e4
LT		 1762 */
1763
1764unsigned int ata_scsiop_inq_80(struct ata_scsi_args *args, u8 *rbuf,
1765 unsigned int buflen)
1766{
1767 const u8 hdr[] = {
1768 0,
1769 0x80, /* this page code */
1770 0,
1771 ATA_SERNO_LEN, /* page len */
1772 };
1773 memcpy(rbuf, hdr, sizeof(hdr));
1774
1775 if (buflen > (ATA_SERNO_LEN + 4 - 1))
6a62a04d
TH		 1776 ata_id_string(args->id, (unsigned char *) &rbuf[4],
1777 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
1da177e4
LT		 1778
1779 return 0;
1780}
1781
1da177e4 1782/**
b142eb65 1783 * ata_scsiop_inq_83 - Simulate INQUIRY VPD page 83, device identity
1da177e4
LT		 1784 * @args: device IDENTIFY data / SCSI command of interest.
1785 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1786 * @buflen: Response buffer length.
1787 *
b142eb65
JG		 1788 * Yields two logical unit device identification designators:
1789 * - vendor specific ASCII containing the ATA serial number
1790 * - SAT defined "t10 vendor id based" containing ASCII vendor
1791 * name ("ATA "), model and serial numbers.
1da177e4
LT		 1792 *
1793 * LOCKING:
cca3974e 1794 * spin_lock_irqsave(host lock)
1da177e4
LT		 1795 */
1796
1797unsigned int ata_scsiop_inq_83(struct ata_scsi_args *args, u8 *rbuf,
1798 unsigned int buflen)
1799{
b142eb65
JG		 1800 int num;
1801 const int sat_model_serial_desc_len = 68;
1802 const int ata_model_byte_len = 40;
1da177e4 1803
b142eb65
JG		 1804 rbuf[1] = 0x83; /* this page code */
1805 num = 4;
1806
1807 if (buflen > (ATA_SERNO_LEN + num + 3)) {
1808 /* piv=0, assoc=lu, code_set=ACSII, designator=vendor */
2e9edbf8 1809 rbuf[num + 0] = 2;
b142eb65
JG		 1810 rbuf[num + 3] = ATA_SERNO_LEN;
1811 num += 4;
1812 ata_id_string(args->id, (unsigned char *) rbuf + num,
1813 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
1814 num += ATA_SERNO_LEN;
1da177e4 1815 }
b142eb65
JG		 1816 if (buflen > (sat_model_serial_desc_len + num + 3)) {
1817 /* SAT defined lu model and serial numbers descriptor */
1818 /* piv=0, assoc=lu, code_set=ACSII, designator=t10 vendor id */
2e9edbf8
JG		 1819 rbuf[num + 0] = 2;
1820 rbuf[num + 1] = 1;
b142eb65
JG		 1821 rbuf[num + 3] = sat_model_serial_desc_len;
1822 num += 4;
1823 memcpy(rbuf + num, "ATA ", 8);
1824 num += 8;
1825 ata_id_string(args->id, (unsigned char *) rbuf + num,
1826 ATA_ID_PROD_OFS, ata_model_byte_len);
1827 num += ata_model_byte_len;
1828 ata_id_string(args->id, (unsigned char *) rbuf + num,
1829 ATA_ID_SERNO_OFS, ATA_SERNO_LEN);
1830 num += ATA_SERNO_LEN;
1831 }
1832 rbuf[3] = num - 4; /* page len (assume less than 256 bytes) */
1da177e4
LT		 1833 return 0;
1834}
1835
1836/**
0cba632b 1837 * ata_scsiop_noop - Command handler that simply returns success.
1da177e4
LT		 1838 * @args: device IDENTIFY data / SCSI command of interest.
1839 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1840 * @buflen: Response buffer length.
1841 *
1842 * No operation. Simply returns success to caller, to indicate
1843 * that the caller should successfully complete this SCSI command.
1844 *
1845 * LOCKING:
cca3974e 1846 * spin_lock_irqsave(host lock)
1da177e4
LT		 1847 */
1848
1849unsigned int ata_scsiop_noop(struct ata_scsi_args *args, u8 *rbuf,
1850 unsigned int buflen)
1851{
1852 VPRINTK("ENTER\n");
1853 return 0;
1854}
1855
1856/**
1857 * ata_msense_push - Push data onto MODE SENSE data output buffer
1858 * @ptr_io: (input/output) Location to store more output data
1859 * @last: End of output data buffer
1860 * @buf: Pointer to BLOB being added to output buffer
1861 * @buflen: Length of BLOB
1862 *
1863 * Store MODE SENSE data on an output buffer.
1864 *
1865 * LOCKING:
1866 * None.
1867 */
1868
1869static void ata_msense_push(u8 **ptr_io, const u8 *last,
1870 const u8 *buf, unsigned int buflen)
1871{
1872 u8 *ptr = *ptr_io;
1873
1874 if ((ptr + buflen - 1) > last)
1875 return;
1876
1877 memcpy(ptr, buf, buflen);
1878
1879 ptr += buflen;
1880
1881 *ptr_io = ptr;
1882}
1883
1884/**
1885 * ata_msense_caching - Simulate MODE SENSE caching info page
1886 * @id: device IDENTIFY data
1887 * @ptr_io: (input/output) Location to store more output data
1888 * @last: End of output data buffer
1889 *
1890 * Generate a caching info page, which conditionally indicates
1891 * write caching to the SCSI layer, depending on device
1892 * capabilities.
1893 *
1894 * LOCKING:
1895 * None.
1896 */
1897
1898static unsigned int ata_msense_caching(u16 *id, u8 **ptr_io,
1899 const u8 *last)
1900{
00ac37f5 1901 u8 page[CACHE_MPAGE_LEN];
1da177e4 1902
00ac37f5 1903 memcpy(page, def_cache_mpage, sizeof(page));
1da177e4
LT		 1904 if (ata_id_wcache_enabled(id))
1905 page[2] |= (1 << 2); /* write cache enable */
1906 if (!ata_id_rahead_enabled(id))
1907 page[12] |= (1 << 5); /* disable read ahead */
1908
1909 ata_msense_push(ptr_io, last, page, sizeof(page));
1910 return sizeof(page);
1911}
1912
1913/**
1914 * ata_msense_ctl_mode - Simulate MODE SENSE control mode page
1915 * @dev: Device associated with this MODE SENSE command
1916 * @ptr_io: (input/output) Location to store more output data
1917 * @last: End of output data buffer
1918 *
1919 * Generate a generic MODE SENSE control mode page.
1920 *
1921 * LOCKING:
1922 * None.
1923 */
1924
1925static unsigned int ata_msense_ctl_mode(u8 **ptr_io, const u8 *last)
1926{
00ac37f5
DG		 1927 ata_msense_push(ptr_io, last, def_control_mpage,
1928 sizeof(def_control_mpage));
1929 return sizeof(def_control_mpage);
1da177e4
LT		 1930}
1931
1932/**
1933 * ata_msense_rw_recovery - Simulate MODE SENSE r/w error recovery page
1934 * @dev: Device associated with this MODE SENSE command
1935 * @ptr_io: (input/output) Location to store more output data
1936 * @last: End of output data buffer
1937 *
1938 * Generate a generic MODE SENSE r/w error recovery page.
1939 *
1940 * LOCKING:
1941 * None.
1942 */
1943
1944static unsigned int ata_msense_rw_recovery(u8 **ptr_io, const u8 *last)
1945{
1da177e4 1946
00ac37f5
DG		 1947 ata_msense_push(ptr_io, last, def_rw_recovery_mpage,
1948 sizeof(def_rw_recovery_mpage));
1949 return sizeof(def_rw_recovery_mpage);
1da177e4
LT		 1950}
1951
48bdc8ec
JA		 1952/*
1953 * We can turn this into a real blacklist if it's needed, for now just
1954 * blacklist any Maxtor BANC1G10 revision firmware
1955 */
1956static int ata_dev_supports_fua(u16 *id)
1957{
1958 unsigned char model[41], fw[9];
1959
c3c013a2
JG		 1960 if (!libata_fua)
1961 return 0;
48bdc8ec
JA		 1962 if (!ata_id_has_fua(id))
1963 return 0;
1964
6a62a04d
TH		 1965 ata_id_c_string(id, model, ATA_ID_PROD_OFS, sizeof(model));
1966 ata_id_c_string(id, fw, ATA_ID_FW_REV_OFS, sizeof(fw));
48bdc8ec 1967
2e02671d 1968 if (strcmp(model, "Maxtor"))
48bdc8ec 1969 return 1;
2e02671d 1970 if (strcmp(fw, "BANC1G10"))
48bdc8ec
JA		 1971 return 1;
1972
1973 return 0; /* blacklisted */
1974}
1975
1da177e4
LT		 1976/**
1977 * ata_scsiop_mode_sense - Simulate MODE SENSE 6, 10 commands
1978 * @args: device IDENTIFY data / SCSI command of interest.
1979 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
1980 * @buflen: Response buffer length.
1981 *
00ac37f5
DG		 1982 * Simulate MODE SENSE commands. Assume this is invoked for direct
1983 * access devices (e.g. disks) only. There should be no block
1984 * descriptor for other device types.
1da177e4
LT		 1985 *
1986 * LOCKING:
cca3974e 1987 * spin_lock_irqsave(host lock)
1da177e4
LT		 1988 */
1989
1990unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf,
1991 unsigned int buflen)
1992{
9a3dccc4 1993 struct ata_device *dev = args->dev;
1da177e4 1994 u8 *scsicmd = args->cmd->cmnd, *p, *last;
00ac37f5
DG		 1995 const u8 sat_blk_desc[] = {
1996 0, 0, 0, 0, /* number of blocks: sat unspecified */
1997 0,
1998 0, 0x2, 0x0 /* block length: 512 bytes */
1999 };
2000 u8 pg, spg;
2001 unsigned int ebd, page_control, six_byte, output_len, alloc_len, minlen;
9a3dccc4 2002 u8 dpofua;
1da177e4
LT		 2003
2004 VPRINTK("ENTER\n");
2005
2006 six_byte = (scsicmd[0] == MODE_SENSE);
00ac37f5
DG		 2007 ebd = !(scsicmd[1] & 0x8); /* dbd bit inverted == edb */
2008 /*
2009 * LLBA bit in msense(10) ignored (compliant)
1da177e4 2010 */
00ac37f5 2011
1da177e4 2012 page_control = scsicmd[2] >> 6;
ae006510
DG		 2013 switch (page_control) {
2014 case 0: /* current */
2015 break; /* supported */
2016 case 3: /* saved */
2017 goto saving_not_supp;
2018 case 1: /* changeable */
2019 case 2: /* defaults */
2020 default:
2021 goto invalid_fld;
2022 }
1da177e4 2023
00ac37f5
DG		 2024 if (six_byte) {
2025 output_len = 4 + (ebd ? 8 : 0);
2026 alloc_len = scsicmd[4];
2027 } else {
2028 output_len = 8 + (ebd ? 8 : 0);
2029 alloc_len = (scsicmd[7] << 8) + scsicmd[8];
2030 }
2031 minlen = (alloc_len < buflen) ? alloc_len : buflen;
1da177e4
LT		 2032
2033 p = rbuf + output_len;
00ac37f5 2034 last = rbuf + minlen - 1;
1da177e4 2035
00ac37f5
DG		 2036 pg = scsicmd[2] & 0x3f;
2037 spg = scsicmd[3];
2038 /*
2039 * No mode subpages supported (yet) but asking for _all_
2040 * subpages may be valid
2041 */
2042 if (spg && (spg != ALL_SUB_MPAGES))
2043 goto invalid_fld;
2044
2045 switch(pg) {
2046 case RW_RECOVERY_MPAGE:
1da177e4
LT		 2047 output_len += ata_msense_rw_recovery(&p, last);
2048 break;
2049
00ac37f5 2050 case CACHE_MPAGE:
1da177e4
LT		 2051 output_len += ata_msense_caching(args->id, &p, last);
2052 break;
2053
00ac37f5 2054 case CONTROL_MPAGE: {
1da177e4
LT		 2055 output_len += ata_msense_ctl_mode(&p, last);
2056 break;
2057 }
2058
00ac37f5 2059 case ALL_MPAGES:
1da177e4
LT		 2060 output_len += ata_msense_rw_recovery(&p, last);
2061 output_len += ata_msense_caching(args->id, &p, last);
2062 output_len += ata_msense_ctl_mode(&p, last);
2063 break;
2064
2065 default: /* invalid page code */
ae006510 2066 goto invalid_fld;
1da177e4
LT		 2067 }
2068
00ac37f5
DG		 2069 if (minlen < 1)
2070 return 0;
9a3dccc4
TH		 2071
2072 dpofua = 0;
f79d409f 2073 if (ata_dev_supports_fua(args->id) && (dev->flags & ATA_DFLAG_LBA48) &&
9a3dccc4
TH		 2074 (!(dev->flags & ATA_DFLAG_PIO) || dev->multi_count))
2075 dpofua = 1 << 4;
2076
1da177e4
LT		 2077 if (six_byte) {
2078 output_len--;
2079 rbuf[0] = output_len;
9a3dccc4
TH		 2080 if (minlen > 2)
2081 rbuf[2] |= dpofua;
00ac37f5
DG		 2082 if (ebd) {
2083 if (minlen > 3)
2084 rbuf[3] = sizeof(sat_blk_desc);
2085 if (minlen > 11)
2086 memcpy(rbuf + 4, sat_blk_desc,
2087 sizeof(sat_blk_desc));
2088 }
1da177e4
LT		 2089 } else {
2090 output_len -= 2;
2091 rbuf[0] = output_len >> 8;
00ac37f5
DG		 2092 if (minlen > 1)
2093 rbuf[1] = output_len;
9a3dccc4
TH		 2094 if (minlen > 3)
2095 rbuf[3] |= dpofua;
00ac37f5
DG		 2096 if (ebd) {
2097 if (minlen > 7)
2098 rbuf[7] = sizeof(sat_blk_desc);
2099 if (minlen > 15)
2100 memcpy(rbuf + 8, sat_blk_desc,
2101 sizeof(sat_blk_desc));
2102 }
1da177e4 2103 }
1da177e4 2104 return 0;
ae006510
DG		 2105
2106invalid_fld:
2107 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x24, 0x0);
2108 /* "Invalid field in cbd" */
2109 return 1;
2110
2111saving_not_supp:
2112 ata_scsi_set_sense(args->cmd, ILLEGAL_REQUEST, 0x39, 0x0);
2113 /* "Saving parameters not supported" */
2114 return 1;
1da177e4
LT		 2115}
2116
2117/**
2118 * ata_scsiop_read_cap - Simulate READ CAPACITY[ 16] commands
2119 * @args: device IDENTIFY data / SCSI command of interest.
2120 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2121 * @buflen: Response buffer length.
2122 *
2123 * Simulate READ CAPACITY commands.
2124 *
2125 * LOCKING:
6a36261e 2126 * None.
1da177e4 2127 */
1da177e4
LT		 2128unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
2129 unsigned int buflen)
2130{
6a36261e 2131 u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
1da177e4
LT		 2132
2133 VPRINTK("ENTER\n");
2134
1da177e4 2135 if (args->cmd->cmnd[0] == READ_CAPACITY) {
6a36261e
TH		 2136 if (last_lba >= 0xffffffffULL)
2137 last_lba = 0xffffffff;
0c144d0d 2138
1da177e4 2139 /* sector count, 32-bit */
6a36261e
TH		 2140 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 3));
2141 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 2));
2142 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 1));
2143 ATA_SCSI_RBUF_SET(3, last_lba);
1da177e4
LT		 2144
2145 /* sector size */
6a36261e
TH		 2146 ATA_SCSI_RBUF_SET(6, ATA_SECT_SIZE >> 8);
2147 ATA_SCSI_RBUF_SET(7, ATA_SECT_SIZE);
1da177e4
LT		 2148 } else {
2149 /* sector count, 64-bit */
6a36261e
TH		 2150 ATA_SCSI_RBUF_SET(0, last_lba >> (8 * 7));
2151 ATA_SCSI_RBUF_SET(1, last_lba >> (8 * 6));
2152 ATA_SCSI_RBUF_SET(2, last_lba >> (8 * 5));
2153 ATA_SCSI_RBUF_SET(3, last_lba >> (8 * 4));
2154 ATA_SCSI_RBUF_SET(4, last_lba >> (8 * 3));
2155 ATA_SCSI_RBUF_SET(5, last_lba >> (8 * 2));
2156 ATA_SCSI_RBUF_SET(6, last_lba >> (8 * 1));
2157 ATA_SCSI_RBUF_SET(7, last_lba);
1da177e4
LT		 2158
2159 /* sector size */
6a36261e
TH		 2160 ATA_SCSI_RBUF_SET(10, ATA_SECT_SIZE >> 8);
2161 ATA_SCSI_RBUF_SET(11, ATA_SECT_SIZE);
1da177e4
LT		 2162 }
2163
2164 return 0;
2165}
2166
2167/**
2168 * ata_scsiop_report_luns - Simulate REPORT LUNS command
2169 * @args: device IDENTIFY data / SCSI command of interest.
2170 * @rbuf: Response buffer, to which simulated SCSI cmd output is sent.
2171 * @buflen: Response buffer length.
2172 *
2173 * Simulate REPORT LUNS command.
2174 *
2175 * LOCKING:
cca3974e 2176 * spin_lock_irqsave(host lock)
1da177e4
LT		 2177 */
2178
2179unsigned int ata_scsiop_report_luns(struct ata_scsi_args *args, u8 *rbuf,
2180 unsigned int buflen)
2181{
2182 VPRINTK("ENTER\n");
2183 rbuf[3] = 8; /* just one lun, LUN 0, size 8 bytes */
2184
2185 return 0;
2186}
2187
845c5834
DG		 2188/**
2189 * ata_scsi_set_sense - Set SCSI sense data and status
2190 * @cmd: SCSI request to be handled
2191 * @sk: SCSI-defined sense key
2192 * @asc: SCSI-defined additional sense code
2193 * @ascq: SCSI-defined additional sense code qualifier
2194 *
2195 * Helper function that builds a valid fixed format, current
2196 * response code and the given sense key (sk), additional sense
2197 * code (asc) and additional sense code qualifier (ascq) with
2198 * a SCSI command status of %SAM_STAT_CHECK_CONDITION and
2199 * DRIVER_SENSE set in the upper bits of scsi_cmnd::result .
2200 *
2201 * LOCKING:
2202 * Not required
2203 */
2204
2205void ata_scsi_set_sense(struct scsi_cmnd *cmd, u8 sk, u8 asc, u8 ascq)
2206{
2207 cmd->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION;
2208
2209 cmd->sense_buffer[0] = 0x70; /* fixed format, current */
2210 cmd->sense_buffer[2] = sk;
2211 cmd->sense_buffer[7] = 18 - 8; /* additional sense length */
2212 cmd->sense_buffer[12] = asc;
2213 cmd->sense_buffer[13] = ascq;
2214}
2215
1da177e4
LT		 2216/**
2217 * ata_scsi_badcmd - End a SCSI request with an error
2218 * @cmd: SCSI request to be handled
2219 * @done: SCSI command completion function
2220 * @asc: SCSI-defined additional sense code
2221 * @ascq: SCSI-defined additional sense code qualifier
2222 *
2223 * Helper function that completes a SCSI command with
2224 * %SAM_STAT_CHECK_CONDITION, with a sense key %ILLEGAL_REQUEST
2225 * and the specified additional sense codes.
2226 *
2227 * LOCKING:
cca3974e 2228 * spin_lock_irqsave(host lock)
1da177e4
LT		 2229 */
2230
2231void ata_scsi_badcmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *), u8 asc, u8 ascq)
2232{
2233 DPRINTK("ENTER\n");
ae006510 2234 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, asc, ascq);
1da177e4
LT		 2235
2236 done(cmd);
2237}
2238
77853bf2 2239static void atapi_sense_complete(struct ata_queued_cmd *qc)
a939c963 2240{
74e6c8c3 2241 if (qc->err_mask && ((qc->err_mask & AC_ERR_DEV) == 0)) {
c6e6e666
JG		 2242 /* FIXME: not quite right; we don't want the
2243 * translation of taskfile registers into
2244 * a sense descriptors, since that's only
2245 * correct for ATA, not ATAPI
2246 */
750426aa 2247 ata_gen_passthru_sense(qc);
74e6c8c3 2248 }
a939c963 2249
c6e6e666 2250 qc->scsidone(qc->scsicmd);
77853bf2 2251 ata_qc_free(qc);
c6e6e666 2252}
a939c963 2253
c6e6e666
JG		 2254/* is it pointless to prefer PIO for "safety reasons"? */
2255static inline int ata_pio_use_silly(struct ata_port *ap)
2256{
2257 return (ap->flags & ATA_FLAG_PIO_DMA);
2258}
2259
2260static void atapi_request_sense(struct ata_queued_cmd *qc)
2261{
2262 struct ata_port *ap = qc->ap;
2263 struct scsi_cmnd *cmd = qc->scsicmd;
2264
2265 DPRINTK("ATAPI request sense\n");
a939c963
JG		 2266
2267 /* FIXME: is this needed? */
2268 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2269
c6e6e666
JG		 2270 ap->ops->tf_read(ap, &qc->tf);
2271
2272 /* fill these in, for the case where they are -not- overwritten */
2273 cmd->sense_buffer[0] = 0x70;
2274 cmd->sense_buffer[2] = qc->tf.feature >> 4;
2275
2276 ata_qc_reinit(qc);
2277
a939c963
JG		 2278 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2279 qc->dma_dir = DMA_FROM_DEVICE;
2280
6e7846e9 2281 memset(&qc->cdb, 0, qc->dev->cdb_len);
a939c963
JG		 2282 qc->cdb[0] = REQUEST_SENSE;
2283 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2284
2285 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2286 qc->tf.command = ATA_CMD_PACKET;
2287
c6e6e666
JG		 2288 if (ata_pio_use_silly(ap)) {
2289 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2290 qc->tf.feature |= ATAPI_PKT_DMA;
2291 } else {
2292 qc->tf.protocol = ATA_PROT_ATAPI;
2293 qc->tf.lbam = (8 * 1024) & 0xff;
2294 qc->tf.lbah = (8 * 1024) >> 8;
2295 }
a939c963
JG		 2296 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2297
c6e6e666 2298 qc->complete_fn = atapi_sense_complete;
a939c963 2299
8e0e694a 2300 ata_qc_issue(qc);
a939c963
JG		 2301
2302 DPRINTK("EXIT\n");
2303}
2304
77853bf2 2305static void atapi_qc_complete(struct ata_queued_cmd *qc)
1da177e4
LT		 2306{
2307 struct scsi_cmnd *cmd = qc->scsicmd;
a22e2eb0 2308 unsigned int err_mask = qc->err_mask;
1da177e4 2309
a7dac447 2310 VPRINTK("ENTER, err_mask 0x%X\n", err_mask);
e12669e7 2311
246619da
TH		 2312 /* handle completion from new EH */
2313 if (unlikely(qc->ap->ops->error_handler &&
2314 (err_mask || qc->flags & ATA_QCFLAG_SENSE_VALID))) {
2315
2316 if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)) {
2317 /* FIXME: not quite right; we don't want the
2318 * translation of taskfile registers into a
2319 * sense descriptors, since that's only
2320 * correct for ATA, not ATAPI
2321 */
750426aa 2322 ata_gen_passthru_sense(qc);
246619da
TH		 2323 }
2324
22aac089
TH		 2325 /* SCSI EH automatically locks door if sdev->locked is
2326 * set. Sometimes door lock request continues to
2327 * fail, for example, when no media is present. This
2328 * creates a loop - SCSI EH issues door lock which
2329 * fails and gets invoked again to acquire sense data
2330 * for the failed command.
2331 *
2332 * If door lock fails, always clear sdev->locked to
2333 * avoid this infinite loop.
2334 */
2335 if (qc->cdb[0] == ALLOW_MEDIUM_REMOVAL)
2336 qc->dev->sdev->locked = 0;
2337
246619da
TH		 2338 qc->scsicmd->result = SAM_STAT_CHECK_CONDITION;
2339 qc->scsidone(cmd);
2340 ata_qc_free(qc);
2341 return;
2342 }
2343
2344 /* successful completion or old EH failure path */
a7dac447 2345 if (unlikely(err_mask & AC_ERR_DEV)) {
1da177e4 2346 cmd->result = SAM_STAT_CHECK_CONDITION;
c6e6e666 2347 atapi_request_sense(qc);
77853bf2 2348 return;
74e6c8c3 2349 } else if (unlikely(err_mask)) {
a7dac447
JG		 2350 /* FIXME: not quite right; we don't want the
2351 * translation of taskfile registers into
2352 * a sense descriptors, since that's only
2353 * correct for ATA, not ATAPI
2354 */
750426aa 2355 ata_gen_passthru_sense(qc);
74e6c8c3 2356 } else {
1da177e4
LT		 2357 u8 *scsicmd = cmd->cmnd;
2358
fd71da46 2359 if ((scsicmd[0] == INQUIRY) && ((scsicmd[1] & 0x03) == 0)) {
1da177e4
LT		 2360 u8 *buf = NULL;
2361 unsigned int buflen;
2362
2363 buflen = ata_scsi_rbuf_get(cmd, &buf);
a15dbeb4
JG		 2364
2365 /* ATAPI devices typically report zero for their SCSI version,
2366 * and sometimes deviate from the spec WRT response data
2367 * format. If SCSI version is reported as zero like normal,
2368 * then we make the following fixups: 1) Fake MMC-5 version,
2369 * to indicate to the Linux scsi midlayer this is a modern
2370 * device. 2) Ensure response data format / ATAPI information
2371 * are always correct.
a15dbeb4
JG		 2372 */
2373 if (buf[2] == 0) {
2374 buf[2] = 0x5;
2375 buf[3] = 0x32;
2376 }
2377
1da177e4
LT		 2378 ata_scsi_rbuf_put(cmd, buf);
2379 }
a15dbeb4 2380
1da177e4
LT		 2381 cmd->result = SAM_STAT_GOOD;
2382 }
2383
2384 qc->scsidone(cmd);
77853bf2 2385 ata_qc_free(qc);
1da177e4
LT		 2386}
2387/**
2388 * atapi_xlat - Initialize PACKET taskfile
2389 * @qc: command structure to be initialized
1da177e4
LT		 2390 *
2391 * LOCKING:
cca3974e 2392 * spin_lock_irqsave(host lock)
1da177e4
LT		 2393 *
2394 * RETURNS:
2395 * Zero on success, non-zero on failure.
2396 */
ad706991 2397static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
1da177e4 2398{
542b1444 2399 struct scsi_cmnd *scmd = qc->scsicmd;
1da177e4
LT		 2400 struct ata_device *dev = qc->dev;
2401 int using_pio = (dev->flags & ATA_DFLAG_PIO);
542b1444 2402 int nodata = (scmd->sc_data_direction == DMA_NONE);
1da177e4
LT		 2403
2404 if (!using_pio)
2405 /* Check whether ATAPI DMA is safe */
2406 if (ata_check_atapi_dma(qc))
2407 using_pio = 1;
2408
2e5704f6
TH		 2409 memset(qc->cdb, 0, dev->cdb_len);
2410 memcpy(qc->cdb, scmd->cmnd, scmd->cmd_len);
1da177e4
LT		 2411
2412 qc->complete_fn = atapi_qc_complete;
2413
2414 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
542b1444 2415 if (scmd->sc_data_direction == DMA_TO_DEVICE) {
1da177e4
LT		 2416 qc->tf.flags |= ATA_TFLAG_WRITE;
2417 DPRINTK("direction: write\n");
2418 }
2419
2420 qc->tf.command = ATA_CMD_PACKET;
2421
2422 /* no data, or PIO data xfer */
2423 if (using_pio || nodata) {
2424 if (nodata)
2425 qc->tf.protocol = ATA_PROT_ATAPI_NODATA;
2426 else
2427 qc->tf.protocol = ATA_PROT_ATAPI;
2428 qc->tf.lbam = (8 * 1024) & 0xff;
2429 qc->tf.lbah = (8 * 1024) >> 8;
2430 }
2431
2432 /* DMA data xfer */
2433 else {
2434 qc->tf.protocol = ATA_PROT_ATAPI_DMA;
2435 qc->tf.feature |= ATAPI_PKT_DMA;
2436
542b1444 2437 if (atapi_dmadir && (scmd->sc_data_direction != DMA_TO_DEVICE))
95de719a 2438 /* some SATA bridges need us to indicate data xfer direction */
1da177e4 2439 qc->tf.feature |= ATAPI_DMADIR;
1da177e4
LT		 2440 }
2441
542b1444 2442 qc->nbytes = scmd->request_bufflen;
1da177e4
LT		 2443
2444 return 0;
2445}
2446
ab5b3a5b
TH		 2447static struct ata_device * ata_find_dev(struct ata_port *ap, int id)
2448{
2449 if (likely(id < ATA_MAX_DEVICES))
2450 return &ap->device[id];
2451 return NULL;
2452}
2453
2454static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
2455 const struct scsi_device *scsidev)
2456{
2457 /* skip commands not addressed to targets we simulate */
2458 if (unlikely(scsidev->channel || scsidev->lun))
2459 return NULL;
2460
2461 return ata_find_dev(ap, scsidev->id);
2462}
2463
99ba9e09
BK		 2464/**
2465 * ata_scsi_dev_enabled - determine if device is enabled
2466 * @dev: ATA device
2467 *
2468 * Determine if commands should be sent to the specified device.
2469 *
2470 * LOCKING:
cca3974e 2471 * spin_lock_irqsave(host lock)
99ba9e09
BK		 2472 *
2473 * RETURNS:
2474 * 0 if commands are not allowed / 1 if commands are allowed
2475 */
2476
2477static int ata_scsi_dev_enabled(struct ata_device *dev)
2478{
2479 if (unlikely(!ata_dev_enabled(dev)))
2480 return 0;
2481
2482 if (!atapi_enabled || (dev->ap->flags & ATA_FLAG_NO_ATAPI)) {
2483 if (unlikely(dev->class == ATA_DEV_ATAPI)) {
2484 ata_dev_printk(dev, KERN_WARNING,
2485 "WARNING: ATAPI is %s, device ignored.\n",
2486 atapi_enabled ? "not supported with this driver" : "disabled");
2487 return 0;
2488 }
2489 }
2490
2491 return 1;
2492}
2493
1da177e4
LT		 2494/**
2495 * ata_scsi_find_dev - lookup ata_device from scsi_cmnd
2496 * @ap: ATA port to which the device is attached
2497 * @scsidev: SCSI device from which we derive the ATA device
2498 *
2499 * Given various information provided in struct scsi_cmnd,
2500 * map that onto an ATA bus, and using that mapping
2501 * determine which ata_device is associated with the
2502 * SCSI command to be sent.
2503 *
2504 * LOCKING:
cca3974e 2505 * spin_lock_irqsave(host lock)
1da177e4
LT		 2506 *
2507 * RETURNS:
2508 * Associated ATA device, or %NULL if not found.
2509 */
1da177e4 2510static struct ata_device *
057ace5e 2511ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev)
1da177e4 2512{
ab5b3a5b 2513 struct ata_device *dev = __ata_scsi_find_dev(ap, scsidev);
1da177e4 2514
99ba9e09 2515 if (unlikely(!dev || !ata_scsi_dev_enabled(dev)))
1da177e4
LT		 2516 return NULL;
2517
1da177e4
LT		 2518 return dev;
2519}
2520
b095518e
JG		 2521/*
2522 * ata_scsi_map_proto - Map pass-thru protocol value to taskfile value.
2523 * @byte1: Byte 1 from pass-thru CDB.
2524 *
2525 * RETURNS:
2526 * ATA_PROT_UNKNOWN if mapping failed/unimplemented, protocol otherwise.
2527 */
2528static u8
2529ata_scsi_map_proto(u8 byte1)
2530{
2531 switch((byte1 & 0x1e) >> 1) {
2532 case 3: /* Non-data */
2533 return ATA_PROT_NODATA;
2534
2535 case 6: /* DMA */
2536 return ATA_PROT_DMA;
2537
2538 case 4: /* PIO Data-in */
2539 case 5: /* PIO Data-out */
b095518e
JG		 2540 return ATA_PROT_PIO;
2541
2542 case 10: /* Device Reset */
2543 case 0: /* Hard Reset */
2544 case 1: /* SRST */
2545 case 2: /* Bus Idle */
2546 case 7: /* Packet */
2547 case 8: /* DMA Queued */
2548 case 9: /* Device Diagnostic */
2549 case 11: /* UDMA Data-in */
2550 case 12: /* UDMA Data-Out */
2551 case 13: /* FPDMA */
2552 default: /* Reserved */
2553 break;
2554 }
2555
2556 return ATA_PROT_UNKNOWN;
2557}
2558
2559/**
2560 * ata_scsi_pass_thru - convert ATA pass-thru CDB to taskfile
2561 * @qc: command structure to be initialized
b095518e
JG		 2562 *
2563 * Handles either 12 or 16-byte versions of the CDB.
2564 *
2565 * RETURNS:
2566 * Zero on success, non-zero on failure.
2567 */
ad706991 2568static unsigned int ata_scsi_pass_thru(struct ata_queued_cmd *qc)
b095518e
JG		 2569{
2570 struct ata_taskfile *tf = &(qc->tf);
542b1444 2571 struct scsi_cmnd *scmd = qc->scsicmd;
f79d409f 2572 struct ata_device *dev = qc->dev;
ad706991 2573 const u8 *cdb = scmd->cmnd;
b095518e 2574
542b1444 2575 if ((tf->protocol = ata_scsi_map_proto(cdb[1])) == ATA_PROT_UNKNOWN)
9a405257 2576 goto invalid_fld;
8190bdb9 2577
f79d409f
AC		 2578 /* We may not issue DMA commands if no DMA mode is set */
2579 if (tf->protocol == ATA_PROT_DMA && dev->dma_mode == 0)
2580 goto invalid_fld;
b095518e 2581
542b1444 2582 if (cdb[1] & 0xe0)
f59b0cf8
AL		 2583 /* PIO multi not supported yet */
2584 goto invalid_fld;
2585
b095518e
JG		 2586 /*
2587 * 12 and 16 byte CDBs use different offsets to
2588 * provide the various register values.
2589 */
542b1444 2590 if (cdb[0] == ATA_16) {
b095518e
JG		 2591 /*
2592 * 16-byte CDB - may contain extended commands.
2593 *
2594 * If that is the case, copy the upper byte register values.
2595 */
542b1444
TH		 2596 if (cdb[1] & 0x01) {
2597 tf->hob_feature = cdb[3];
2598 tf->hob_nsect = cdb[5];
2599 tf->hob_lbal = cdb[7];
2600 tf->hob_lbam = cdb[9];
2601 tf->hob_lbah = cdb[11];
b095518e
JG		 2602 tf->flags |= ATA_TFLAG_LBA48;
2603 } else
2604 tf->flags &= ~ATA_TFLAG_LBA48;
2605
2606 /*
2607 * Always copy low byte, device and command registers.
2608 */
542b1444
TH		 2609 tf->feature = cdb[4];
2610 tf->nsect = cdb[6];
2611 tf->lbal = cdb[8];
2612 tf->lbam = cdb[10];
2613 tf->lbah = cdb[12];
2614 tf->device = cdb[13];
2615 tf->command = cdb[14];
b095518e
JG		 2616 } else {
2617 /*
2618 * 12-byte CDB - incapable of extended commands.
2619 */
2620 tf->flags &= ~ATA_TFLAG_LBA48;
2621
542b1444
TH		 2622 tf->feature = cdb[3];
2623 tf->nsect = cdb[4];
2624 tf->lbal = cdb[5];
2625 tf->lbam = cdb[6];
2626 tf->lbah = cdb[7];
2627 tf->device = cdb[8];
2628 tf->command = cdb[9];
b095518e 2629 }
dcc2d1e7
ML		 2630 /*
2631 * If slave is possible, enforce correct master/slave bit
2632 */
2633 if (qc->ap->flags & ATA_FLAG_SLAVE_POSS)
2634 tf->device = qc->dev->devno ?
2635 tf->device | ATA_DEV1 : tf->device & ~ATA_DEV1;
b095518e
JG		 2636
2637 /*
2638 * Filter SET_FEATURES - XFER MODE command -- otherwise,
2639 * SET_FEATURES - XFER MODE must be preceded/succeeded
2640 * by an update to hardware-specific registers for each
2641 * controller (i.e. the reason for ->set_piomode(),
2642 * ->set_dmamode(), and ->post_set_mode() hooks).
2643 */
2644 if ((tf->command == ATA_CMD_SET_FEATURES)
2645 && (tf->feature == SETFEATURES_XFER))
9a405257 2646 goto invalid_fld;
b095518e
JG		 2647
2648 /*
2649 * Set flags so that all registers will be written,
2650 * and pass on write indication (used for PIO/DMA
2651 * setup.)
2652 */
2653 tf->flags |= (ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE);
2654
542b1444 2655 if (scmd->sc_data_direction == DMA_TO_DEVICE)
b095518e
JG		 2656 tf->flags |= ATA_TFLAG_WRITE;
2657
2658 /*
2659 * Set transfer length.
2660 *
2661 * TODO: find out if we need to do more here to
2662 * cover scatter/gather case.
2663 */
542b1444 2664 qc->nsect = scmd->request_bufflen / ATA_SECT_SIZE;
b095518e 2665
e61e0672
TH		 2666 /* request result TF */
2667 qc->flags |= ATA_QCFLAG_RESULT_TF;
2668
b095518e 2669 return 0;
9a405257
TH		 2670
2671 invalid_fld:
542b1444 2672 ata_scsi_set_sense(scmd, ILLEGAL_REQUEST, 0x24, 0x00);
9a405257
TH		 2673 /* "Invalid field in cdb" */
2674 return 1;
b095518e
JG		 2675}
2676
1da177e4
LT		 2677/**
2678 * ata_get_xlat_func - check if SCSI to ATA translation is possible
2679 * @dev: ATA device
2680 * @cmd: SCSI command opcode to consider
2681 *
2682 * Look up the SCSI command given, and determine whether the
2683 * SCSI command is to be translated or simulated.
2684 *
2685 * RETURNS:
2686 * Pointer to translation function if possible, %NULL if not.
2687 */
2688
2689static inline ata_xlat_func_t ata_get_xlat_func(struct ata_device *dev, u8 cmd)
2690{
2691 switch (cmd) {
2692 case READ_6:
2693 case READ_10:
2694 case READ_16:
2695
2696 case WRITE_6:
2697 case WRITE_10:
2698 case WRITE_16:
2699 return ata_scsi_rw_xlat;
2700
2701 case SYNCHRONIZE_CACHE:
2702 if (ata_try_flush_cache(dev))
2703 return ata_scsi_flush_xlat;
2704 break;
2705
2706 case VERIFY:
2707 case VERIFY_16:
2708 return ata_scsi_verify_xlat;
b095518e
JG		 2709
2710 case ATA_12:
2711 case ATA_16:
2712 return ata_scsi_pass_thru;
da61396d 2713
972dcafb
DG		 2714 case START_STOP:
2715 return ata_scsi_start_stop_xlat;
1da177e4
LT		 2716 }
2717
2718 return NULL;
2719}
2720
2721/**
2722 * ata_scsi_dump_cdb - dump SCSI command contents to dmesg
2723 * @ap: ATA port to which the command was being sent
2724 * @cmd: SCSI command to dump
2725 *
2726 * Prints the contents of a SCSI command via printk().
2727 */
2728
2729static inline void ata_scsi_dump_cdb(struct ata_port *ap,
2730 struct scsi_cmnd *cmd)
2731{
2732#ifdef ATA_DEBUG
2733 struct scsi_device *scsidev = cmd->device;
2734 u8 *scsicmd = cmd->cmnd;
2735
2736 DPRINTK("CDB (%u:%d,%d,%d) %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
2737 ap->id,
2738 scsidev->channel, scsidev->id, scsidev->lun,
2739 scsicmd[0], scsicmd[1], scsicmd[2], scsicmd[3],
2740 scsicmd[4], scsicmd[5], scsicmd[6], scsicmd[7],
2741 scsicmd[8]);
2742#endif
2743}
2744
542b1444 2745static inline int __ata_scsi_queuecmd(struct scsi_cmnd *scmd,
2115ea94
TH		 2746 void (*done)(struct scsi_cmnd *),
2747 struct ata_device *dev)
eb3f0f9c 2748{
2115ea94
TH		 2749 int rc = 0;
2750
2e5704f6
TH		 2751 if (unlikely(!scmd->cmd_len)) {
2752 ata_dev_printk(dev, KERN_WARNING, "WARNING: zero len CDB\n");
2753 scmd->result = DID_ERROR << 16;
2754 done(scmd);
2755 return 0;
2756 }
2757
eb3f0f9c
BK		 2758 if (dev->class == ATA_DEV_ATA) {
2759 ata_xlat_func_t xlat_func = ata_get_xlat_func(dev,
542b1444 2760 scmd->cmnd[0]);
eb3f0f9c
BK		 2761
2762 if (xlat_func)
542b1444 2763 rc = ata_scsi_translate(dev, scmd, done, xlat_func);
eb3f0f9c 2764 else
542b1444 2765 ata_scsi_simulate(dev, scmd, done);
eb3f0f9c 2766 } else
542b1444 2767 rc = ata_scsi_translate(dev, scmd, done, atapi_xlat);
2115ea94
TH		 2768
2769 return rc;
eb3f0f9c
BK		 2770}
2771
1da177e4
LT		 2772/**
2773 * ata_scsi_queuecmd - Issue SCSI cdb to libata-managed device
2774 * @cmd: SCSI command to be sent
2775 * @done: Completion function, called when command is complete
2776 *
2777 * In some cases, this function translates SCSI commands into
2778 * ATA taskfiles, and queues the taskfiles to be sent to
2779 * hardware. In other cases, this function simulates a
2780 * SCSI device by evaluating and responding to certain
2781 * SCSI commands. This creates the overall effect of
2782 * ATA and ATAPI devices appearing as SCSI devices.
2783 *
2784 * LOCKING:
cca3974e 2785 * Releases scsi-layer-held lock, and obtains host lock.
1da177e4
LT		 2786 *
2787 * RETURNS:
2115ea94
TH		 2788 * Return value from __ata_scsi_queuecmd() if @cmd can be queued,
2789 * 0 otherwise.
1da177e4 2790 */
1da177e4
LT		 2791int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
2792{
2793 struct ata_port *ap;
2794 struct ata_device *dev;
2795 struct scsi_device *scsidev = cmd->device;
005a5a06 2796 struct Scsi_Host *shost = scsidev->host;
2115ea94 2797 int rc = 0;
1da177e4 2798
35bb94b1 2799 ap = ata_shost_to_port(shost);
005a5a06
JG		 2800
2801 spin_unlock(shost->host_lock);
ba6a1308 2802 spin_lock(ap->lock);
1da177e4
LT		 2803
2804 ata_scsi_dump_cdb(ap, cmd);
2805
2806 dev = ata_scsi_find_dev(ap, scsidev);
eb3f0f9c 2807 if (likely(dev))
2115ea94 2808 rc = __ata_scsi_queuecmd(cmd, done, dev);
eb3f0f9c 2809 else {
1da177e4
LT		 2810 cmd->result = (DID_BAD_TARGET << 16);
2811 done(cmd);
1da177e4
LT		 2812 }
2813
ba6a1308 2814 spin_unlock(ap->lock);
005a5a06 2815 spin_lock(shost->host_lock);
2115ea94 2816 return rc;
1da177e4
LT		 2817}
2818
2819/**
2820 * ata_scsi_simulate - simulate SCSI command on ATA device
c893a3ae 2821 * @dev: the target device
1da177e4
LT		 2822 * @cmd: SCSI command being sent to device.
2823 * @done: SCSI command completion function.
2824 *
2825 * Interprets and directly executes a select list of SCSI commands
2826 * that can be handled internally.
2827 *
2828 * LOCKING:
cca3974e 2829 * spin_lock_irqsave(host lock)
1da177e4
LT		 2830 */
2831
3373efd8 2832void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
1da177e4
LT		 2833 void (*done)(struct scsi_cmnd *))
2834{
2835 struct ata_scsi_args args;
057ace5e 2836 const u8 *scsicmd = cmd->cmnd;
1da177e4 2837
9a3dccc4
TH		 2838 args.dev = dev;
2839 args.id = dev->id;
1da177e4
LT		 2840 args.cmd = cmd;
2841 args.done = done;
2842
2843 switch(scsicmd[0]) {
2844 /* no-op's, complete with success */
2845 case SYNCHRONIZE_CACHE:
2846 case REZERO_UNIT:
2847 case SEEK_6:
2848 case SEEK_10:
2849 case TEST_UNIT_READY:
2850 case FORMAT_UNIT: /* FIXME: correct? */
2851 case SEND_DIAGNOSTIC: /* FIXME: correct? */
2852 ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
2853 break;
2854
2855 case INQUIRY:
2856 if (scsicmd[1] & 2) /* is CmdDt set? */
ae006510 2857 ata_scsi_invalid_field(cmd, done);
1da177e4
LT		 2858 else if ((scsicmd[1] & 1) == 0) /* is EVPD clear? */
2859 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
2860 else if (scsicmd[2] == 0x00)
2861 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
2862 else if (scsicmd[2] == 0x80)
2863 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
2864 else if (scsicmd[2] == 0x83)
2865 ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
2866 else
ae006510 2867 ata_scsi_invalid_field(cmd, done);
1da177e4
LT		 2868 break;
2869
2870 case MODE_SENSE:
2871 case MODE_SENSE_10:
2872 ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
2873 break;
2874
2875 case MODE_SELECT: /* unconditionally return */
2876 case MODE_SELECT_10: /* bad-field-in-cdb */
ae006510 2877 ata_scsi_invalid_field(cmd, done);
1da177e4
LT		 2878 break;
2879
2880 case READ_CAPACITY:
2881 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2882 break;
2883
2884 case SERVICE_ACTION_IN:
2885 if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
2886 ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
2887 else
ae006510 2888 ata_scsi_invalid_field(cmd, done);
1da177e4
LT		 2889 break;
2890
2891 case REPORT_LUNS:
2892 ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
2893 break;
2894
b095518e 2895 /* mandatory commands we haven't implemented yet */
1da177e4
LT		 2896 case REQUEST_SENSE:
2897
2898 /* all other commands */
2899 default:
ae006510
DG		 2900 ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
2901 /* "Invalid command operation code" */
2902 done(cmd);
1da177e4
LT		 2903 break;
2904 }
2905}
2906
644dd0cc
JG		 2907void ata_scsi_scan_host(struct ata_port *ap)
2908{
2909 unsigned int i;
2910
198e0fed 2911 if (ap->flags & ATA_FLAG_DISABLED)
644dd0cc
JG		 2912 return;
2913
3f19ee8c 2914 for (i = 0; i < ATA_MAX_DEVICES; i++) {
3edebac4
TH		 2915 struct ata_device *dev = &ap->device[i];
2916 struct scsi_device *sdev;
2917
2918 if (!ata_dev_enabled(dev) || dev->sdev)
2919 continue;
3f19ee8c 2920
cca3974e 2921 sdev = __scsi_add_device(ap->scsi_host, 0, i, 0, NULL);
3edebac4
TH		 2922 if (!IS_ERR(sdev)) {
2923 dev->sdev = sdev;
2924 scsi_device_put(sdev);
2925 }
3f19ee8c 2926 }
644dd0cc 2927}
0ea035a3
TH		 2928
2929/**
2930 * ata_scsi_offline_dev - offline attached SCSI device
2931 * @dev: ATA device to offline attached SCSI device for
2932 *
2933 * This function is called from ata_eh_hotplug() and responsible
2934 * for taking the SCSI device attached to @dev offline. This
cca3974e 2935 * function is called with host lock which protects dev->sdev
0ea035a3
TH		 2936 * against clearing.
2937 *
2938 * LOCKING:
cca3974e 2939 * spin_lock_irqsave(host lock)
0ea035a3
TH		 2940 *
2941 * RETURNS:
2942 * 1 if attached SCSI device exists, 0 otherwise.
2943 */
2944int ata_scsi_offline_dev(struct ata_device *dev)
2945{
2946 if (dev->sdev) {
2947 scsi_device_set_state(dev->sdev, SDEV_OFFLINE);
2948 return 1;
2949 }
2950 return 0;
2951}
580b2102
TH		 2952
2953/**
2954 * ata_scsi_remove_dev - remove attached SCSI device
2955 * @dev: ATA device to remove attached SCSI device for
2956 *
2957 * This function is called from ata_eh_scsi_hotplug() and
2958 * responsible for removing the SCSI device attached to @dev.
2959 *
2960 * LOCKING:
2961 * Kernel thread context (may sleep).
2962 */
2963static void ata_scsi_remove_dev(struct ata_device *dev)
2964{
2965 struct ata_port *ap = dev->ap;
2966 struct scsi_device *sdev;
2967 unsigned long flags;
2968
2969 /* Alas, we need to grab scan_mutex to ensure SCSI device
2970 * state doesn't change underneath us and thus
2971 * scsi_device_get() always succeeds. The mutex locking can
2972 * be removed if there is __scsi_device_get() interface which
2973 * increments reference counts regardless of device state.
2974 */
cca3974e 2975 mutex_lock(&ap->scsi_host->scan_mutex);
ba6a1308 2976 spin_lock_irqsave(ap->lock, flags);
580b2102 2977
cca3974e 2978 /* clearing dev->sdev is protected by host lock */
580b2102
TH		 2979 sdev = dev->sdev;
2980 dev->sdev = NULL;
2981
2982 if (sdev) {
2983 /* If user initiated unplug races with us, sdev can go
cca3974e 2984 * away underneath us after the host lock and
580b2102
TH		 2985 * scan_mutex are released. Hold onto it.
2986 */
2987 if (scsi_device_get(sdev) == 0) {
2988 /* The following ensures the attached sdev is
2989 * offline on return from ata_scsi_offline_dev()
2990 * regardless it wins or loses the race
2991 * against this function.
2992 */
2993 scsi_device_set_state(sdev, SDEV_OFFLINE);
2994 } else {
2995 WARN_ON(1);
2996 sdev = NULL;
2997 }
2998 }
2999
ba6a1308 3000 spin_unlock_irqrestore(ap->lock, flags);
cca3974e 3001 mutex_unlock(&ap->scsi_host->scan_mutex);
580b2102
TH		 3002
3003 if (sdev) {
3004 ata_dev_printk(dev, KERN_INFO, "detaching (SCSI %s)\n",
3005 sdev->sdev_gendev.bus_id);
3006
3007 scsi_remove_device(sdev);
3008 scsi_device_put(sdev);
3009 }
3010}
3011
3012/**
3013 * ata_scsi_hotplug - SCSI part of hotplug
65f27f38 3014 * @work: Pointer to ATA port to perform SCSI hotplug on
580b2102
TH		 3015 *
3016 * Perform SCSI part of hotplug. It's executed from a separate
3017 * workqueue after EH completes. This is necessary because SCSI
3018 * hot plugging requires working EH and hot unplugging is
3019 * synchronized with hot plugging with a mutex.
3020 *
3021 * LOCKING:
3022 * Kernel thread context (may sleep).
3023 */
65f27f38 3024void ata_scsi_hotplug(struct work_struct *work)
580b2102 3025{
65f27f38
DH		 3026 struct ata_port *ap =
3027 container_of(work, struct ata_port, hotplug_task.work);
580b2102
TH		 3028 int i;
3029
b51e9e5d 3030 if (ap->pflags & ATA_PFLAG_UNLOADING) {
580b2102
TH		 3031 DPRINTK("ENTER/EXIT - unloading\n");
3032 return;
3033 }
3034
3035 DPRINTK("ENTER\n");
3036
3037 /* unplug detached devices */
3038 for (i = 0; i < ATA_MAX_DEVICES; i++) {
3039 struct ata_device *dev = &ap->device[i];
3040 unsigned long flags;
3041
3042 if (!(dev->flags & ATA_DFLAG_DETACHED))
3043 continue;
3044
ba6a1308 3045 spin_lock_irqsave(ap->lock, flags);
580b2102 3046 dev->flags &= ~ATA_DFLAG_DETACHED;
ba6a1308 3047 spin_unlock_irqrestore(ap->lock, flags);
580b2102
TH		 3048
3049 ata_scsi_remove_dev(dev);
3050 }
3051
3052 /* scan for new ones */
3053 ata_scsi_scan_host(ap);
3054
3055 /* If we scanned while EH was in progress, scan would have
3056 * failed silently. Requeue if there are enabled but
3057 * unattached devices.
3058 */
3059 for (i = 0; i < ATA_MAX_DEVICES; i++) {
3060 struct ata_device *dev = &ap->device[i];
3061 if (ata_dev_enabled(dev) && !dev->sdev) {
7a44e910
AV		 3062 queue_delayed_work(ata_aux_wq, &ap->hotplug_task,
3063 round_jiffies_relative(HZ));
580b2102
TH		 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);
kernel source for telekom puls (alcatel/mediatek)