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