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