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