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