1 /* 2 * Support for SATA devices on Serial Attached SCSI (SAS) controllers 3 * 4 * Copyright (C) 2006 IBM Corporation 5 * 6 * Written by: Darrick J. Wong <djwong@us.ibm.com>, IBM Corporation 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of the 11 * License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 21 * USA 22 */ 23 24 #include <linux/scatterlist.h> 25 #include <linux/slab.h> 26 27 #include <scsi/sas_ata.h> 28 #include "sas_internal.h" 29 #include <scsi/scsi_host.h> 30 #include <scsi/scsi_device.h> 31 #include <scsi/scsi_tcq.h> 32 #include <scsi/scsi.h> 33 #include <scsi/scsi_transport.h> 34 #include <scsi/scsi_transport_sas.h> 35 #include "../scsi_sas_internal.h" 36 #include "../scsi_transport_api.h" 37 #include <scsi/scsi_eh.h> 38 39 static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts) 40 { 41 /* Cheesy attempt to translate SAS errors into ATA. Hah! */ 42 43 /* transport error */ 44 if (ts->resp == SAS_TASK_UNDELIVERED) 45 return AC_ERR_ATA_BUS; 46 47 /* ts->resp == SAS_TASK_COMPLETE */ 48 /* task delivered, what happened afterwards? */ 49 switch (ts->stat) { 50 case SAS_DEV_NO_RESPONSE: 51 return AC_ERR_TIMEOUT; 52 53 case SAS_INTERRUPTED: 54 case SAS_PHY_DOWN: 55 case SAS_NAK_R_ERR: 56 return AC_ERR_ATA_BUS; 57 58 59 case SAS_DATA_UNDERRUN: 60 /* 61 * Some programs that use the taskfile interface 62 * (smartctl in particular) can cause underrun 63 * problems. Ignore these errors, perhaps at our 64 * peril. 65 */ 66 return 0; 67 68 case SAS_DATA_OVERRUN: 69 case SAS_QUEUE_FULL: 70 case SAS_DEVICE_UNKNOWN: 71 case SAS_SG_ERR: 72 return AC_ERR_INVALID; 73 74 case SAS_OPEN_TO: 75 case SAS_OPEN_REJECT: 76 SAS_DPRINTK("%s: Saw error %d. What to do?\n", 77 __func__, ts->stat); 78 return AC_ERR_OTHER; 79 80 case SAM_STAT_CHECK_CONDITION: 81 case SAS_ABORTED_TASK: 82 return AC_ERR_DEV; 83 84 case SAS_PROTO_RESPONSE: 85 /* This means the ending_fis has the error 86 * value; return 0 here to collect it */ 87 return 0; 88 default: 89 return 0; 90 } 91 } 92 93 static void sas_ata_task_done(struct sas_task *task) 94 { 95 struct ata_queued_cmd *qc = task->uldd_task; 96 struct domain_device *dev; 97 struct task_status_struct *stat = &task->task_status; 98 struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf; 99 struct sas_ha_struct *sas_ha; 100 enum ata_completion_errors ac; 101 unsigned long flags; 102 struct ata_link *link; 103 104 if (!qc) 105 goto qc_already_gone; 106 107 dev = qc->ap->private_data; 108 sas_ha = dev->port->ha; 109 link = &dev->sata_dev.ap->link; 110 111 spin_lock_irqsave(dev->sata_dev.ap->lock, flags); 112 if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD || 113 ((stat->stat == SAM_STAT_CHECK_CONDITION && 114 dev->sata_dev.command_set == ATAPI_COMMAND_SET))) { 115 ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf); 116 117 if (!link->sactive) { 118 qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command); 119 } else { 120 link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.tf.command); 121 if (unlikely(link->eh_info.err_mask)) 122 qc->flags |= ATA_QCFLAG_FAILED; 123 } 124 125 dev->sata_dev.sstatus = resp->sstatus; 126 dev->sata_dev.serror = resp->serror; 127 dev->sata_dev.scontrol = resp->scontrol; 128 } else { 129 ac = sas_to_ata_err(stat); 130 if (ac) { 131 SAS_DPRINTK("%s: SAS error %x\n", __func__, 132 stat->stat); 133 /* We saw a SAS error. Send a vague error. */ 134 if (!link->sactive) { 135 qc->err_mask = ac; 136 } else { 137 link->eh_info.err_mask |= AC_ERR_DEV; 138 qc->flags |= ATA_QCFLAG_FAILED; 139 } 140 141 dev->sata_dev.tf.feature = 0x04; /* status err */ 142 dev->sata_dev.tf.command = ATA_ERR; 143 } 144 } 145 146 qc->lldd_task = NULL; 147 if (qc->scsicmd) 148 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 149 ata_qc_complete(qc); 150 spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags); 151 152 /* 153 * If the sas_task has an ata qc, a scsi_cmnd and the aborted 154 * flag is set, then we must have come in via the libsas EH 155 * functions. When we exit this function, we need to put the 156 * scsi_cmnd on the list of finished errors. The ata_qc_complete 157 * call cleans up the libata side of things but we're protected 158 * from the scsi_cmnd going away because the scsi_cmnd is owned 159 * by the EH, making libata's call to scsi_done a NOP. 160 */ 161 spin_lock_irqsave(&task->task_state_lock, flags); 162 if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED) 163 scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q); 164 spin_unlock_irqrestore(&task->task_state_lock, flags); 165 166 qc_already_gone: 167 list_del_init(&task->list); 168 sas_free_task(task); 169 } 170 171 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc) 172 { 173 int res; 174 struct sas_task *task; 175 struct domain_device *dev = qc->ap->private_data; 176 struct sas_ha_struct *sas_ha = dev->port->ha; 177 struct Scsi_Host *host = sas_ha->core.shost; 178 struct sas_internal *i = to_sas_internal(host->transportt); 179 struct scatterlist *sg; 180 unsigned int xfer = 0; 181 unsigned int si; 182 183 /* If the device fell off, no sense in issuing commands */ 184 if (dev->gone) 185 return AC_ERR_SYSTEM; 186 187 task = sas_alloc_task(GFP_ATOMIC); 188 if (!task) 189 return AC_ERR_SYSTEM; 190 task->dev = dev; 191 task->task_proto = SAS_PROTOCOL_STP; 192 task->task_done = sas_ata_task_done; 193 194 if (qc->tf.command == ATA_CMD_FPDMA_WRITE || 195 qc->tf.command == ATA_CMD_FPDMA_READ) { 196 /* Need to zero out the tag libata assigned us */ 197 qc->tf.nsect = 0; 198 } 199 200 ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis); 201 task->uldd_task = qc; 202 if (ata_is_atapi(qc->tf.protocol)) { 203 memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len); 204 task->total_xfer_len = qc->nbytes; 205 task->num_scatter = qc->n_elem; 206 } else { 207 for_each_sg(qc->sg, sg, qc->n_elem, si) 208 xfer += sg->length; 209 210 task->total_xfer_len = xfer; 211 task->num_scatter = si; 212 } 213 214 task->data_dir = qc->dma_dir; 215 task->scatter = qc->sg; 216 task->ata_task.retry_count = 1; 217 task->task_state_flags = SAS_TASK_STATE_PENDING; 218 qc->lldd_task = task; 219 220 switch (qc->tf.protocol) { 221 case ATA_PROT_NCQ: 222 task->ata_task.use_ncq = 1; 223 /* fall through */ 224 case ATAPI_PROT_DMA: 225 case ATA_PROT_DMA: 226 task->ata_task.dma_xfer = 1; 227 break; 228 } 229 230 if (qc->scsicmd) 231 ASSIGN_SAS_TASK(qc->scsicmd, task); 232 233 if (sas_ha->lldd_max_execute_num < 2) 234 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 235 else 236 res = sas_queue_up(task); 237 238 /* Examine */ 239 if (res) { 240 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 241 242 if (qc->scsicmd) 243 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 244 sas_free_task(task); 245 return AC_ERR_SYSTEM; 246 } 247 248 return 0; 249 } 250 251 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc) 252 { 253 struct domain_device *dev = qc->ap->private_data; 254 255 memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf)); 256 return true; 257 } 258 259 static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class, 260 unsigned long deadline) 261 { 262 struct ata_port *ap = link->ap; 263 struct domain_device *dev = ap->private_data; 264 struct sas_internal *i = 265 to_sas_internal(dev->port->ha->core.shost->transportt); 266 int res = TMF_RESP_FUNC_FAILED; 267 int ret = 0; 268 269 if (i->dft->lldd_I_T_nexus_reset) 270 res = i->dft->lldd_I_T_nexus_reset(dev); 271 272 if (res != TMF_RESP_FUNC_COMPLETE) { 273 SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __func__); 274 ret = -EAGAIN; 275 } 276 277 switch (dev->sata_dev.command_set) { 278 case ATA_COMMAND_SET: 279 SAS_DPRINTK("%s: Found ATA device.\n", __func__); 280 *class = ATA_DEV_ATA; 281 break; 282 case ATAPI_COMMAND_SET: 283 SAS_DPRINTK("%s: Found ATAPI device.\n", __func__); 284 *class = ATA_DEV_ATAPI; 285 break; 286 default: 287 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n", 288 __func__, 289 dev->sata_dev.command_set); 290 *class = ATA_DEV_UNKNOWN; 291 break; 292 } 293 294 ap->cbl = ATA_CBL_SATA; 295 return ret; 296 } 297 298 static int sas_ata_soft_reset(struct ata_link *link, unsigned int *class, 299 unsigned long deadline) 300 { 301 struct ata_port *ap = link->ap; 302 struct domain_device *dev = ap->private_data; 303 struct sas_internal *i = 304 to_sas_internal(dev->port->ha->core.shost->transportt); 305 int res = TMF_RESP_FUNC_FAILED; 306 int ret = 0; 307 308 if (i->dft->lldd_ata_soft_reset) 309 res = i->dft->lldd_ata_soft_reset(dev); 310 311 if (res != TMF_RESP_FUNC_COMPLETE) { 312 SAS_DPRINTK("%s: Unable to soft reset\n", __func__); 313 ret = -EAGAIN; 314 } 315 316 switch (dev->sata_dev.command_set) { 317 case ATA_COMMAND_SET: 318 SAS_DPRINTK("%s: Found ATA device.\n", __func__); 319 *class = ATA_DEV_ATA; 320 break; 321 case ATAPI_COMMAND_SET: 322 SAS_DPRINTK("%s: Found ATAPI device.\n", __func__); 323 *class = ATA_DEV_ATAPI; 324 break; 325 default: 326 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n", 327 __func__, dev->sata_dev.command_set); 328 *class = ATA_DEV_UNKNOWN; 329 break; 330 } 331 332 ap->cbl = ATA_CBL_SATA; 333 return ret; 334 } 335 336 static void sas_ata_post_internal(struct ata_queued_cmd *qc) 337 { 338 if (qc->flags & ATA_QCFLAG_FAILED) 339 qc->err_mask |= AC_ERR_OTHER; 340 341 if (qc->err_mask) { 342 /* 343 * Find the sas_task and kill it. By this point, 344 * libata has decided to kill the qc, so we needn't 345 * bother with sas_ata_task_done. But we still 346 * ought to abort the task. 347 */ 348 struct sas_task *task = qc->lldd_task; 349 unsigned long flags; 350 351 qc->lldd_task = NULL; 352 if (task) { 353 /* Should this be a AT(API) device reset? */ 354 spin_lock_irqsave(&task->task_state_lock, flags); 355 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET; 356 spin_unlock_irqrestore(&task->task_state_lock, flags); 357 358 task->uldd_task = NULL; 359 __sas_task_abort(task); 360 } 361 } 362 } 363 364 static struct ata_port_operations sas_sata_ops = { 365 .prereset = ata_std_prereset, 366 .softreset = sas_ata_soft_reset, 367 .hardreset = sas_ata_hard_reset, 368 .postreset = ata_std_postreset, 369 .error_handler = ata_std_error_handler, 370 .post_internal_cmd = sas_ata_post_internal, 371 .qc_defer = ata_std_qc_defer, 372 .qc_prep = ata_noop_qc_prep, 373 .qc_issue = sas_ata_qc_issue, 374 .qc_fill_rtf = sas_ata_qc_fill_rtf, 375 .port_start = ata_sas_port_start, 376 .port_stop = ata_sas_port_stop, 377 }; 378 379 static struct ata_port_info sata_port_info = { 380 .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ, 381 .pio_mask = ATA_PIO4, 382 .mwdma_mask = ATA_MWDMA2, 383 .udma_mask = ATA_UDMA6, 384 .port_ops = &sas_sata_ops 385 }; 386 387 int sas_ata_init_host_and_port(struct domain_device *found_dev, 388 struct scsi_target *starget) 389 { 390 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 391 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 392 struct ata_port *ap; 393 394 ata_host_init(&found_dev->sata_dev.ata_host, 395 ha->dev, 396 sata_port_info.flags, 397 &sas_sata_ops); 398 ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host, 399 &sata_port_info, 400 shost); 401 if (!ap) { 402 SAS_DPRINTK("ata_sas_port_alloc failed.\n"); 403 return -ENODEV; 404 } 405 406 ap->private_data = found_dev; 407 ap->cbl = ATA_CBL_SATA; 408 ap->scsi_host = shost; 409 found_dev->sata_dev.ap = ap; 410 411 return 0; 412 } 413 414 void sas_ata_task_abort(struct sas_task *task) 415 { 416 struct ata_queued_cmd *qc = task->uldd_task; 417 struct completion *waiting; 418 419 /* Bounce SCSI-initiated commands to the SCSI EH */ 420 if (qc->scsicmd) { 421 struct request_queue *q = qc->scsicmd->device->request_queue; 422 unsigned long flags; 423 424 spin_lock_irqsave(q->queue_lock, flags); 425 blk_abort_request(qc->scsicmd->request); 426 spin_unlock_irqrestore(q->queue_lock, flags); 427 scsi_schedule_eh(qc->scsicmd->device->host); 428 return; 429 } 430 431 /* Internal command, fake a timeout and complete. */ 432 qc->flags &= ~ATA_QCFLAG_ACTIVE; 433 qc->flags |= ATA_QCFLAG_FAILED; 434 qc->err_mask |= AC_ERR_TIMEOUT; 435 waiting = qc->private_data; 436 complete(waiting); 437 } 438 439 static void sas_task_timedout(unsigned long _task) 440 { 441 struct sas_task *task = (void *) _task; 442 unsigned long flags; 443 444 spin_lock_irqsave(&task->task_state_lock, flags); 445 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 446 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 447 spin_unlock_irqrestore(&task->task_state_lock, flags); 448 449 complete(&task->completion); 450 } 451 452 static void sas_disc_task_done(struct sas_task *task) 453 { 454 if (!del_timer(&task->timer)) 455 return; 456 complete(&task->completion); 457 } 458 459 #define SAS_DEV_TIMEOUT 10 460 461 /** 462 * sas_execute_task -- Basic task processing for discovery 463 * @task: the task to be executed 464 * @buffer: pointer to buffer to do I/O 465 * @size: size of @buffer 466 * @dma_dir: DMA direction. DMA_xxx 467 */ 468 static int sas_execute_task(struct sas_task *task, void *buffer, int size, 469 enum dma_data_direction dma_dir) 470 { 471 int res = 0; 472 struct scatterlist *scatter = NULL; 473 struct task_status_struct *ts = &task->task_status; 474 int num_scatter = 0; 475 int retries = 0; 476 struct sas_internal *i = 477 to_sas_internal(task->dev->port->ha->core.shost->transportt); 478 479 if (dma_dir != DMA_NONE) { 480 scatter = kzalloc(sizeof(*scatter), GFP_KERNEL); 481 if (!scatter) 482 goto out; 483 484 sg_init_one(scatter, buffer, size); 485 num_scatter = 1; 486 } 487 488 task->task_proto = task->dev->tproto; 489 task->scatter = scatter; 490 task->num_scatter = num_scatter; 491 task->total_xfer_len = size; 492 task->data_dir = dma_dir; 493 task->task_done = sas_disc_task_done; 494 if (dma_dir != DMA_NONE && 495 sas_protocol_ata(task->task_proto)) { 496 task->num_scatter = dma_map_sg(task->dev->port->ha->dev, 497 task->scatter, 498 task->num_scatter, 499 task->data_dir); 500 } 501 502 for (retries = 0; retries < 5; retries++) { 503 task->task_state_flags = SAS_TASK_STATE_PENDING; 504 init_completion(&task->completion); 505 506 task->timer.data = (unsigned long) task; 507 task->timer.function = sas_task_timedout; 508 task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ; 509 add_timer(&task->timer); 510 511 res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL); 512 if (res) { 513 del_timer(&task->timer); 514 SAS_DPRINTK("executing SAS discovery task failed:%d\n", 515 res); 516 goto ex_err; 517 } 518 wait_for_completion(&task->completion); 519 res = -ECOMM; 520 if (task->task_state_flags & SAS_TASK_STATE_ABORTED) { 521 int res2; 522 SAS_DPRINTK("task aborted, flags:0x%x\n", 523 task->task_state_flags); 524 res2 = i->dft->lldd_abort_task(task); 525 SAS_DPRINTK("came back from abort task\n"); 526 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) { 527 if (res2 == TMF_RESP_FUNC_COMPLETE) 528 continue; /* Retry the task */ 529 else 530 goto ex_err; 531 } 532 } 533 if (task->task_status.stat == SAM_STAT_BUSY || 534 task->task_status.stat == SAM_STAT_TASK_SET_FULL || 535 task->task_status.stat == SAS_QUEUE_FULL) { 536 SAS_DPRINTK("task: q busy, sleeping...\n"); 537 schedule_timeout_interruptible(HZ); 538 } else if (task->task_status.stat == SAM_STAT_CHECK_CONDITION) { 539 struct scsi_sense_hdr shdr; 540 541 if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size, 542 &shdr)) { 543 SAS_DPRINTK("couldn't normalize sense\n"); 544 continue; 545 } 546 if ((shdr.sense_key == 6 && shdr.asc == 0x29) || 547 (shdr.sense_key == 2 && shdr.asc == 4 && 548 shdr.ascq == 1)) { 549 SAS_DPRINTK("device %016llx LUN: %016llx " 550 "powering up or not ready yet, " 551 "sleeping...\n", 552 SAS_ADDR(task->dev->sas_addr), 553 SAS_ADDR(task->ssp_task.LUN)); 554 555 schedule_timeout_interruptible(5*HZ); 556 } else if (shdr.sense_key == 1) { 557 res = 0; 558 break; 559 } else if (shdr.sense_key == 5) { 560 break; 561 } else { 562 SAS_DPRINTK("dev %016llx LUN: %016llx " 563 "sense key:0x%x ASC:0x%x ASCQ:0x%x" 564 "\n", 565 SAS_ADDR(task->dev->sas_addr), 566 SAS_ADDR(task->ssp_task.LUN), 567 shdr.sense_key, 568 shdr.asc, shdr.ascq); 569 } 570 } else if (task->task_status.resp != SAS_TASK_COMPLETE || 571 task->task_status.stat != SAM_STAT_GOOD) { 572 SAS_DPRINTK("task finished with resp:0x%x, " 573 "stat:0x%x\n", 574 task->task_status.resp, 575 task->task_status.stat); 576 goto ex_err; 577 } else { 578 res = 0; 579 break; 580 } 581 } 582 ex_err: 583 if (dma_dir != DMA_NONE) { 584 if (sas_protocol_ata(task->task_proto)) 585 dma_unmap_sg(task->dev->port->ha->dev, 586 task->scatter, task->num_scatter, 587 task->data_dir); 588 kfree(scatter); 589 } 590 out: 591 return res; 592 } 593 594 /* ---------- SATA ---------- */ 595 596 static void sas_get_ata_command_set(struct domain_device *dev) 597 { 598 struct dev_to_host_fis *fis = 599 (struct dev_to_host_fis *) dev->frame_rcvd; 600 601 if ((fis->sector_count == 1 && /* ATA */ 602 fis->lbal == 1 && 603 fis->lbam == 0 && 604 fis->lbah == 0 && 605 fis->device == 0) 606 || 607 (fis->sector_count == 0 && /* CE-ATA (mATA) */ 608 fis->lbal == 0 && 609 fis->lbam == 0xCE && 610 fis->lbah == 0xAA && 611 (fis->device & ~0x10) == 0)) 612 613 dev->sata_dev.command_set = ATA_COMMAND_SET; 614 615 else if ((fis->interrupt_reason == 1 && /* ATAPI */ 616 fis->lbal == 1 && 617 fis->byte_count_low == 0x14 && 618 fis->byte_count_high == 0xEB && 619 (fis->device & ~0x10) == 0)) 620 621 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 622 623 else if ((fis->sector_count == 1 && /* SEMB */ 624 fis->lbal == 1 && 625 fis->lbam == 0x3C && 626 fis->lbah == 0xC3 && 627 fis->device == 0) 628 || 629 (fis->interrupt_reason == 1 && /* SATA PM */ 630 fis->lbal == 1 && 631 fis->byte_count_low == 0x69 && 632 fis->byte_count_high == 0x96 && 633 (fis->device & ~0x10) == 0)) 634 635 /* Treat it as a superset? */ 636 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 637 } 638 639 /** 640 * sas_issue_ata_cmd -- Basic SATA command processing for discovery 641 * @dev: the device to send the command to 642 * @command: the command register 643 * @features: the features register 644 * @buffer: pointer to buffer to do I/O 645 * @size: size of @buffer 646 * @dma_dir: DMA direction. DMA_xxx 647 */ 648 static int sas_issue_ata_cmd(struct domain_device *dev, u8 command, 649 u8 features, void *buffer, int size, 650 enum dma_data_direction dma_dir) 651 { 652 int res = 0; 653 struct sas_task *task; 654 struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *) 655 &dev->frame_rcvd[0]; 656 657 res = -ENOMEM; 658 task = sas_alloc_task(GFP_KERNEL); 659 if (!task) 660 goto out; 661 662 task->dev = dev; 663 664 task->ata_task.fis.fis_type = 0x27; 665 task->ata_task.fis.command = command; 666 task->ata_task.fis.features = features; 667 task->ata_task.fis.device = d2h_fis->device; 668 task->ata_task.retry_count = 1; 669 670 res = sas_execute_task(task, buffer, size, dma_dir); 671 672 sas_free_task(task); 673 out: 674 return res; 675 } 676 677 #define ATA_IDENTIFY_DEV 0xEC 678 #define ATA_IDENTIFY_PACKET_DEV 0xA1 679 #define ATA_SET_FEATURES 0xEF 680 #define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07 681 682 /** 683 * sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV) 684 * @dev: STP/SATA device of interest (ATA/ATAPI) 685 * 686 * The LLDD has already been notified of this device, so that we can 687 * send FISes to it. Here we try to get IDENTIFY DEVICE or IDENTIFY 688 * PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its 689 * performance for this device. 690 */ 691 static int sas_discover_sata_dev(struct domain_device *dev) 692 { 693 int res; 694 __le16 *identify_x; 695 u8 command; 696 697 identify_x = kzalloc(512, GFP_KERNEL); 698 if (!identify_x) 699 return -ENOMEM; 700 701 if (dev->sata_dev.command_set == ATA_COMMAND_SET) { 702 dev->sata_dev.identify_device = identify_x; 703 command = ATA_IDENTIFY_DEV; 704 } else { 705 dev->sata_dev.identify_packet_device = identify_x; 706 command = ATA_IDENTIFY_PACKET_DEV; 707 } 708 709 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512, 710 DMA_FROM_DEVICE); 711 if (res) 712 goto out_err; 713 714 /* lives on the media? */ 715 if (le16_to_cpu(identify_x[0]) & 4) { 716 /* incomplete response */ 717 SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to " 718 "dev %llx\n", SAS_ADDR(dev->sas_addr)); 719 if (!(identify_x[83] & cpu_to_le16(1<<6))) 720 goto cont1; 721 res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES, 722 ATA_FEATURE_PUP_STBY_SPIN_UP, 723 NULL, 0, DMA_NONE); 724 if (res) 725 goto cont1; 726 727 schedule_timeout_interruptible(5*HZ); /* More time? */ 728 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512, 729 DMA_FROM_DEVICE); 730 if (res) 731 goto out_err; 732 } 733 cont1: 734 /* XXX Hint: register this SATA device with SATL. 735 When this returns, dev->sata_dev->lu is alive and 736 present. 737 sas_satl_register_dev(dev); 738 */ 739 740 sas_fill_in_rphy(dev, dev->rphy); 741 742 return 0; 743 out_err: 744 dev->sata_dev.identify_packet_device = NULL; 745 dev->sata_dev.identify_device = NULL; 746 kfree(identify_x); 747 return res; 748 } 749 750 static int sas_discover_sata_pm(struct domain_device *dev) 751 { 752 return -ENODEV; 753 } 754 755 /** 756 * sas_discover_sata -- discover an STP/SATA domain device 757 * @dev: pointer to struct domain_device of interest 758 * 759 * First we notify the LLDD of this device, so we can send frames to 760 * it. Then depending on the type of device we call the appropriate 761 * discover functions. Once device discover is done, we notify the 762 * LLDD so that it can fine-tune its parameters for the device, by 763 * removing it and then adding it. That is, the second time around, 764 * the driver would have certain fields, that it is looking at, set. 765 * Finally we initialize the kobj so that the device can be added to 766 * the system at registration time. Devices directly attached to a HA 767 * port, have no parents. All other devices do, and should have their 768 * "parent" pointer set appropriately before calling this function. 769 */ 770 int sas_discover_sata(struct domain_device *dev) 771 { 772 int res; 773 774 sas_get_ata_command_set(dev); 775 776 res = sas_notify_lldd_dev_found(dev); 777 if (res) 778 return res; 779 780 switch (dev->dev_type) { 781 case SATA_DEV: 782 res = sas_discover_sata_dev(dev); 783 break; 784 case SATA_PM: 785 res = sas_discover_sata_pm(dev); 786 break; 787 default: 788 break; 789 } 790 sas_notify_lldd_dev_gone(dev); 791 if (!res) { 792 sas_notify_lldd_dev_found(dev); 793 res = sas_rphy_add(dev->rphy); 794 } 795 796 return res; 797 } 798 799 void sas_ata_strategy_handler(struct Scsi_Host *shost) 800 { 801 struct scsi_device *sdev; 802 803 shost_for_each_device(sdev, shost) { 804 struct domain_device *ddev = sdev_to_domain_dev(sdev); 805 struct ata_port *ap = ddev->sata_dev.ap; 806 807 if (!dev_is_sata(ddev)) 808 continue; 809 810 ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata port error handler"); 811 ata_scsi_port_error_handler(shost, ap); 812 } 813 } 814 815 int sas_ata_timed_out(struct scsi_cmnd *cmd, struct sas_task *task, 816 enum blk_eh_timer_return *rtn) 817 { 818 struct domain_device *ddev = cmd_to_domain_dev(cmd); 819 820 if (!dev_is_sata(ddev) || task) 821 return 0; 822 823 /* we're a sata device with no task, so this must be a libata 824 * eh timeout. Ideally should hook into libata timeout 825 * handling, but there's no point, it just wants to activate 826 * the eh thread */ 827 *rtn = BLK_EH_NOT_HANDLED; 828 return 1; 829 } 830 831 int sas_ata_eh(struct Scsi_Host *shost, struct list_head *work_q, 832 struct list_head *done_q) 833 { 834 int rtn = 0; 835 struct scsi_cmnd *cmd, *n; 836 struct ata_port *ap; 837 838 do { 839 LIST_HEAD(sata_q); 840 841 ap = NULL; 842 843 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 844 struct domain_device *ddev = cmd_to_domain_dev(cmd); 845 846 if (!dev_is_sata(ddev) || TO_SAS_TASK(cmd)) 847 continue; 848 if (ap && ap != ddev->sata_dev.ap) 849 continue; 850 ap = ddev->sata_dev.ap; 851 rtn = 1; 852 list_move(&cmd->eh_entry, &sata_q); 853 } 854 855 if (!list_empty(&sata_q)) { 856 ata_port_printk(ap, KERN_DEBUG, "sas eh calling libata cmd error handler\n"); 857 ata_scsi_cmd_error_handler(shost, ap, &sata_q); 858 /* 859 * ata's error handler may leave the cmd on the list 860 * so make sure they don't remain on a stack list 861 * about to go out of scope. 862 * 863 * This looks strange, since the commands are 864 * now part of no list, but the next error 865 * action will be ata_port_error_handler() 866 * which takes no list and sweeps them up 867 * anyway from the ata tag array. 868 */ 869 while (!list_empty(&sata_q)) 870 list_del_init(sata_q.next); 871 } 872 } while (ap); 873 874 return rtn; 875 } 876