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