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