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 SAM_STAT_CHECK_CONDITION: 75 case SAS_OPEN_TO: 76 case SAS_OPEN_REJECT: 77 SAS_DPRINTK("%s: Saw error %d. What to do?\n", 78 __func__, ts->stat); 79 return AC_ERR_OTHER; 80 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 103 if (!qc) 104 goto qc_already_gone; 105 106 dev = qc->ap->private_data; 107 sas_ha = dev->port->ha; 108 109 spin_lock_irqsave(dev->sata_dev.ap->lock, flags); 110 if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD) { 111 ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf); 112 qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command); 113 dev->sata_dev.sstatus = resp->sstatus; 114 dev->sata_dev.serror = resp->serror; 115 dev->sata_dev.scontrol = resp->scontrol; 116 } else if (stat->stat != SAM_STAT_GOOD) { 117 ac = sas_to_ata_err(stat); 118 if (ac) { 119 SAS_DPRINTK("%s: SAS error %x\n", __func__, 120 stat->stat); 121 /* We saw a SAS error. Send a vague error. */ 122 qc->err_mask = ac; 123 dev->sata_dev.tf.feature = 0x04; /* status err */ 124 dev->sata_dev.tf.command = ATA_ERR; 125 } 126 } 127 128 qc->lldd_task = NULL; 129 if (qc->scsicmd) 130 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 131 ata_qc_complete(qc); 132 spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags); 133 134 /* 135 * If the sas_task has an ata qc, a scsi_cmnd and the aborted 136 * flag is set, then we must have come in via the libsas EH 137 * functions. When we exit this function, we need to put the 138 * scsi_cmnd on the list of finished errors. The ata_qc_complete 139 * call cleans up the libata side of things but we're protected 140 * from the scsi_cmnd going away because the scsi_cmnd is owned 141 * by the EH, making libata's call to scsi_done a NOP. 142 */ 143 spin_lock_irqsave(&task->task_state_lock, flags); 144 if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED) 145 scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q); 146 spin_unlock_irqrestore(&task->task_state_lock, flags); 147 148 qc_already_gone: 149 list_del_init(&task->list); 150 sas_free_task(task); 151 } 152 153 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc) 154 { 155 int res; 156 struct sas_task *task; 157 struct domain_device *dev = qc->ap->private_data; 158 struct sas_ha_struct *sas_ha = dev->port->ha; 159 struct Scsi_Host *host = sas_ha->core.shost; 160 struct sas_internal *i = to_sas_internal(host->transportt); 161 struct scatterlist *sg; 162 unsigned int xfer = 0; 163 unsigned int si; 164 165 task = sas_alloc_task(GFP_ATOMIC); 166 if (!task) 167 return AC_ERR_SYSTEM; 168 task->dev = dev; 169 task->task_proto = SAS_PROTOCOL_STP; 170 task->task_done = sas_ata_task_done; 171 172 if (qc->tf.command == ATA_CMD_FPDMA_WRITE || 173 qc->tf.command == ATA_CMD_FPDMA_READ) { 174 /* Need to zero out the tag libata assigned us */ 175 qc->tf.nsect = 0; 176 } 177 178 ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis); 179 task->uldd_task = qc; 180 if (ata_is_atapi(qc->tf.protocol)) { 181 memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len); 182 task->total_xfer_len = qc->nbytes; 183 task->num_scatter = qc->n_elem; 184 } else { 185 for_each_sg(qc->sg, sg, qc->n_elem, si) 186 xfer += sg->length; 187 188 task->total_xfer_len = xfer; 189 task->num_scatter = si; 190 } 191 192 task->data_dir = qc->dma_dir; 193 task->scatter = qc->sg; 194 task->ata_task.retry_count = 1; 195 task->task_state_flags = SAS_TASK_STATE_PENDING; 196 qc->lldd_task = task; 197 198 switch (qc->tf.protocol) { 199 case ATA_PROT_NCQ: 200 task->ata_task.use_ncq = 1; 201 /* fall through */ 202 case ATAPI_PROT_DMA: 203 case ATA_PROT_DMA: 204 task->ata_task.dma_xfer = 1; 205 break; 206 } 207 208 if (qc->scsicmd) 209 ASSIGN_SAS_TASK(qc->scsicmd, task); 210 211 if (sas_ha->lldd_max_execute_num < 2) 212 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 213 else 214 res = sas_queue_up(task); 215 216 /* Examine */ 217 if (res) { 218 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 219 220 if (qc->scsicmd) 221 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 222 sas_free_task(task); 223 return AC_ERR_SYSTEM; 224 } 225 226 return 0; 227 } 228 229 static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc) 230 { 231 struct domain_device *dev = qc->ap->private_data; 232 233 memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf)); 234 return true; 235 } 236 237 static void sas_ata_phy_reset(struct ata_port *ap) 238 { 239 struct domain_device *dev = ap->private_data; 240 struct sas_internal *i = 241 to_sas_internal(dev->port->ha->core.shost->transportt); 242 int res = TMF_RESP_FUNC_FAILED; 243 244 if (i->dft->lldd_I_T_nexus_reset) 245 res = i->dft->lldd_I_T_nexus_reset(dev); 246 247 if (res != TMF_RESP_FUNC_COMPLETE) 248 SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __func__); 249 250 switch (dev->sata_dev.command_set) { 251 case ATA_COMMAND_SET: 252 SAS_DPRINTK("%s: Found ATA device.\n", __func__); 253 ap->link.device[0].class = ATA_DEV_ATA; 254 break; 255 case ATAPI_COMMAND_SET: 256 SAS_DPRINTK("%s: Found ATAPI device.\n", __func__); 257 ap->link.device[0].class = ATA_DEV_ATAPI; 258 break; 259 default: 260 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n", 261 __func__, 262 dev->sata_dev.command_set); 263 ap->link.device[0].class = ATA_DEV_UNKNOWN; 264 break; 265 } 266 267 ap->cbl = ATA_CBL_SATA; 268 } 269 270 static void sas_ata_post_internal(struct ata_queued_cmd *qc) 271 { 272 if (qc->flags & ATA_QCFLAG_FAILED) 273 qc->err_mask |= AC_ERR_OTHER; 274 275 if (qc->err_mask) { 276 /* 277 * Find the sas_task and kill it. By this point, 278 * libata has decided to kill the qc, so we needn't 279 * bother with sas_ata_task_done. But we still 280 * ought to abort the task. 281 */ 282 struct sas_task *task = qc->lldd_task; 283 unsigned long flags; 284 285 qc->lldd_task = NULL; 286 if (task) { 287 /* Should this be a AT(API) device reset? */ 288 spin_lock_irqsave(&task->task_state_lock, flags); 289 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET; 290 spin_unlock_irqrestore(&task->task_state_lock, flags); 291 292 task->uldd_task = NULL; 293 __sas_task_abort(task); 294 } 295 } 296 } 297 298 static int sas_ata_scr_write(struct ata_link *link, unsigned int sc_reg_in, 299 u32 val) 300 { 301 struct domain_device *dev = link->ap->private_data; 302 303 SAS_DPRINTK("STUB %s\n", __func__); 304 switch (sc_reg_in) { 305 case SCR_STATUS: 306 dev->sata_dev.sstatus = val; 307 break; 308 case SCR_CONTROL: 309 dev->sata_dev.scontrol = val; 310 break; 311 case SCR_ERROR: 312 dev->sata_dev.serror = val; 313 break; 314 case SCR_ACTIVE: 315 dev->sata_dev.ap->link.sactive = val; 316 break; 317 default: 318 return -EINVAL; 319 } 320 return 0; 321 } 322 323 static int sas_ata_scr_read(struct ata_link *link, unsigned int sc_reg_in, 324 u32 *val) 325 { 326 struct domain_device *dev = link->ap->private_data; 327 328 SAS_DPRINTK("STUB %s\n", __func__); 329 switch (sc_reg_in) { 330 case SCR_STATUS: 331 *val = dev->sata_dev.sstatus; 332 return 0; 333 case SCR_CONTROL: 334 *val = dev->sata_dev.scontrol; 335 return 0; 336 case SCR_ERROR: 337 *val = dev->sata_dev.serror; 338 return 0; 339 case SCR_ACTIVE: 340 *val = dev->sata_dev.ap->link.sactive; 341 return 0; 342 default: 343 return -EINVAL; 344 } 345 } 346 347 static struct ata_port_operations sas_sata_ops = { 348 .phy_reset = sas_ata_phy_reset, 349 .post_internal_cmd = sas_ata_post_internal, 350 .qc_prep = ata_noop_qc_prep, 351 .qc_issue = sas_ata_qc_issue, 352 .qc_fill_rtf = sas_ata_qc_fill_rtf, 353 .port_start = ata_sas_port_start, 354 .port_stop = ata_sas_port_stop, 355 .scr_read = sas_ata_scr_read, 356 .scr_write = sas_ata_scr_write 357 }; 358 359 static struct ata_port_info sata_port_info = { 360 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | ATA_FLAG_SATA_RESET | 361 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ, 362 .pio_mask = 0x1f, /* PIO0-4 */ 363 .mwdma_mask = 0x07, /* MWDMA0-2 */ 364 .udma_mask = ATA_UDMA6, 365 .port_ops = &sas_sata_ops 366 }; 367 368 int sas_ata_init_host_and_port(struct domain_device *found_dev, 369 struct scsi_target *starget) 370 { 371 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 372 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 373 struct ata_port *ap; 374 375 ata_host_init(&found_dev->sata_dev.ata_host, 376 ha->dev, 377 sata_port_info.flags, 378 &sas_sata_ops); 379 ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host, 380 &sata_port_info, 381 shost); 382 if (!ap) { 383 SAS_DPRINTK("ata_sas_port_alloc failed.\n"); 384 return -ENODEV; 385 } 386 387 ap->private_data = found_dev; 388 ap->cbl = ATA_CBL_SATA; 389 ap->scsi_host = shost; 390 found_dev->sata_dev.ap = ap; 391 392 return 0; 393 } 394 395 void sas_ata_task_abort(struct sas_task *task) 396 { 397 struct ata_queued_cmd *qc = task->uldd_task; 398 struct completion *waiting; 399 400 /* Bounce SCSI-initiated commands to the SCSI EH */ 401 if (qc->scsicmd) { 402 struct request_queue *q = qc->scsicmd->device->request_queue; 403 unsigned long flags; 404 405 spin_lock_irqsave(q->queue_lock, flags); 406 blk_abort_request(qc->scsicmd->request); 407 spin_unlock_irqrestore(q->queue_lock, flags); 408 scsi_schedule_eh(qc->scsicmd->device->host); 409 return; 410 } 411 412 /* Internal command, fake a timeout and complete. */ 413 qc->flags &= ~ATA_QCFLAG_ACTIVE; 414 qc->flags |= ATA_QCFLAG_FAILED; 415 qc->err_mask |= AC_ERR_TIMEOUT; 416 waiting = qc->private_data; 417 complete(waiting); 418 } 419 420 static void sas_task_timedout(unsigned long _task) 421 { 422 struct sas_task *task = (void *) _task; 423 unsigned long flags; 424 425 spin_lock_irqsave(&task->task_state_lock, flags); 426 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 427 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 428 spin_unlock_irqrestore(&task->task_state_lock, flags); 429 430 complete(&task->completion); 431 } 432 433 static void sas_disc_task_done(struct sas_task *task) 434 { 435 if (!del_timer(&task->timer)) 436 return; 437 complete(&task->completion); 438 } 439 440 #define SAS_DEV_TIMEOUT 10 441 442 /** 443 * sas_execute_task -- Basic task processing for discovery 444 * @task: the task to be executed 445 * @buffer: pointer to buffer to do I/O 446 * @size: size of @buffer 447 * @dma_dir: DMA direction. DMA_xxx 448 */ 449 static int sas_execute_task(struct sas_task *task, void *buffer, int size, 450 enum dma_data_direction dma_dir) 451 { 452 int res = 0; 453 struct scatterlist *scatter = NULL; 454 struct task_status_struct *ts = &task->task_status; 455 int num_scatter = 0; 456 int retries = 0; 457 struct sas_internal *i = 458 to_sas_internal(task->dev->port->ha->core.shost->transportt); 459 460 if (dma_dir != DMA_NONE) { 461 scatter = kzalloc(sizeof(*scatter), GFP_KERNEL); 462 if (!scatter) 463 goto out; 464 465 sg_init_one(scatter, buffer, size); 466 num_scatter = 1; 467 } 468 469 task->task_proto = task->dev->tproto; 470 task->scatter = scatter; 471 task->num_scatter = num_scatter; 472 task->total_xfer_len = size; 473 task->data_dir = dma_dir; 474 task->task_done = sas_disc_task_done; 475 if (dma_dir != DMA_NONE && 476 sas_protocol_ata(task->task_proto)) { 477 task->num_scatter = dma_map_sg(task->dev->port->ha->dev, 478 task->scatter, 479 task->num_scatter, 480 task->data_dir); 481 } 482 483 for (retries = 0; retries < 5; retries++) { 484 task->task_state_flags = SAS_TASK_STATE_PENDING; 485 init_completion(&task->completion); 486 487 task->timer.data = (unsigned long) task; 488 task->timer.function = sas_task_timedout; 489 task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ; 490 add_timer(&task->timer); 491 492 res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL); 493 if (res) { 494 del_timer(&task->timer); 495 SAS_DPRINTK("executing SAS discovery task failed:%d\n", 496 res); 497 goto ex_err; 498 } 499 wait_for_completion(&task->completion); 500 res = -ECOMM; 501 if (task->task_state_flags & SAS_TASK_STATE_ABORTED) { 502 int res2; 503 SAS_DPRINTK("task aborted, flags:0x%x\n", 504 task->task_state_flags); 505 res2 = i->dft->lldd_abort_task(task); 506 SAS_DPRINTK("came back from abort task\n"); 507 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) { 508 if (res2 == TMF_RESP_FUNC_COMPLETE) 509 continue; /* Retry the task */ 510 else 511 goto ex_err; 512 } 513 } 514 if (task->task_status.stat == SAM_STAT_BUSY || 515 task->task_status.stat == SAM_STAT_TASK_SET_FULL || 516 task->task_status.stat == SAS_QUEUE_FULL) { 517 SAS_DPRINTK("task: q busy, sleeping...\n"); 518 schedule_timeout_interruptible(HZ); 519 } else if (task->task_status.stat == SAM_STAT_CHECK_CONDITION) { 520 struct scsi_sense_hdr shdr; 521 522 if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size, 523 &shdr)) { 524 SAS_DPRINTK("couldn't normalize sense\n"); 525 continue; 526 } 527 if ((shdr.sense_key == 6 && shdr.asc == 0x29) || 528 (shdr.sense_key == 2 && shdr.asc == 4 && 529 shdr.ascq == 1)) { 530 SAS_DPRINTK("device %016llx LUN: %016llx " 531 "powering up or not ready yet, " 532 "sleeping...\n", 533 SAS_ADDR(task->dev->sas_addr), 534 SAS_ADDR(task->ssp_task.LUN)); 535 536 schedule_timeout_interruptible(5*HZ); 537 } else if (shdr.sense_key == 1) { 538 res = 0; 539 break; 540 } else if (shdr.sense_key == 5) { 541 break; 542 } else { 543 SAS_DPRINTK("dev %016llx LUN: %016llx " 544 "sense key:0x%x ASC:0x%x ASCQ:0x%x" 545 "\n", 546 SAS_ADDR(task->dev->sas_addr), 547 SAS_ADDR(task->ssp_task.LUN), 548 shdr.sense_key, 549 shdr.asc, shdr.ascq); 550 } 551 } else if (task->task_status.resp != SAS_TASK_COMPLETE || 552 task->task_status.stat != SAM_STAT_GOOD) { 553 SAS_DPRINTK("task finished with resp:0x%x, " 554 "stat:0x%x\n", 555 task->task_status.resp, 556 task->task_status.stat); 557 goto ex_err; 558 } else { 559 res = 0; 560 break; 561 } 562 } 563 ex_err: 564 if (dma_dir != DMA_NONE) { 565 if (sas_protocol_ata(task->task_proto)) 566 dma_unmap_sg(task->dev->port->ha->dev, 567 task->scatter, task->num_scatter, 568 task->data_dir); 569 kfree(scatter); 570 } 571 out: 572 return res; 573 } 574 575 /* ---------- SATA ---------- */ 576 577 static void sas_get_ata_command_set(struct domain_device *dev) 578 { 579 struct dev_to_host_fis *fis = 580 (struct dev_to_host_fis *) dev->frame_rcvd; 581 582 if ((fis->sector_count == 1 && /* ATA */ 583 fis->lbal == 1 && 584 fis->lbam == 0 && 585 fis->lbah == 0 && 586 fis->device == 0) 587 || 588 (fis->sector_count == 0 && /* CE-ATA (mATA) */ 589 fis->lbal == 0 && 590 fis->lbam == 0xCE && 591 fis->lbah == 0xAA && 592 (fis->device & ~0x10) == 0)) 593 594 dev->sata_dev.command_set = ATA_COMMAND_SET; 595 596 else if ((fis->interrupt_reason == 1 && /* ATAPI */ 597 fis->lbal == 1 && 598 fis->byte_count_low == 0x14 && 599 fis->byte_count_high == 0xEB && 600 (fis->device & ~0x10) == 0)) 601 602 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 603 604 else if ((fis->sector_count == 1 && /* SEMB */ 605 fis->lbal == 1 && 606 fis->lbam == 0x3C && 607 fis->lbah == 0xC3 && 608 fis->device == 0) 609 || 610 (fis->interrupt_reason == 1 && /* SATA PM */ 611 fis->lbal == 1 && 612 fis->byte_count_low == 0x69 && 613 fis->byte_count_high == 0x96 && 614 (fis->device & ~0x10) == 0)) 615 616 /* Treat it as a superset? */ 617 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 618 } 619 620 /** 621 * sas_issue_ata_cmd -- Basic SATA command processing for discovery 622 * @dev: the device to send the command to 623 * @command: the command register 624 * @features: the features register 625 * @buffer: pointer to buffer to do I/O 626 * @size: size of @buffer 627 * @dma_dir: DMA direction. DMA_xxx 628 */ 629 static int sas_issue_ata_cmd(struct domain_device *dev, u8 command, 630 u8 features, void *buffer, int size, 631 enum dma_data_direction dma_dir) 632 { 633 int res = 0; 634 struct sas_task *task; 635 struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *) 636 &dev->frame_rcvd[0]; 637 638 res = -ENOMEM; 639 task = sas_alloc_task(GFP_KERNEL); 640 if (!task) 641 goto out; 642 643 task->dev = dev; 644 645 task->ata_task.fis.fis_type = 0x27; 646 task->ata_task.fis.command = command; 647 task->ata_task.fis.features = features; 648 task->ata_task.fis.device = d2h_fis->device; 649 task->ata_task.retry_count = 1; 650 651 res = sas_execute_task(task, buffer, size, dma_dir); 652 653 sas_free_task(task); 654 out: 655 return res; 656 } 657 658 #define ATA_IDENTIFY_DEV 0xEC 659 #define ATA_IDENTIFY_PACKET_DEV 0xA1 660 #define ATA_SET_FEATURES 0xEF 661 #define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07 662 663 /** 664 * sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV) 665 * @dev: STP/SATA device of interest (ATA/ATAPI) 666 * 667 * The LLDD has already been notified of this device, so that we can 668 * send FISes to it. Here we try to get IDENTIFY DEVICE or IDENTIFY 669 * PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its 670 * performance for this device. 671 */ 672 static int sas_discover_sata_dev(struct domain_device *dev) 673 { 674 int res; 675 __le16 *identify_x; 676 u8 command; 677 678 identify_x = kzalloc(512, GFP_KERNEL); 679 if (!identify_x) 680 return -ENOMEM; 681 682 if (dev->sata_dev.command_set == ATA_COMMAND_SET) { 683 dev->sata_dev.identify_device = identify_x; 684 command = ATA_IDENTIFY_DEV; 685 } else { 686 dev->sata_dev.identify_packet_device = identify_x; 687 command = ATA_IDENTIFY_PACKET_DEV; 688 } 689 690 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512, 691 DMA_FROM_DEVICE); 692 if (res) 693 goto out_err; 694 695 /* lives on the media? */ 696 if (le16_to_cpu(identify_x[0]) & 4) { 697 /* incomplete response */ 698 SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to " 699 "dev %llx\n", SAS_ADDR(dev->sas_addr)); 700 if (!(identify_x[83] & cpu_to_le16(1<<6))) 701 goto cont1; 702 res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES, 703 ATA_FEATURE_PUP_STBY_SPIN_UP, 704 NULL, 0, DMA_NONE); 705 if (res) 706 goto cont1; 707 708 schedule_timeout_interruptible(5*HZ); /* More time? */ 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 cont1: 715 /* XXX Hint: register this SATA device with SATL. 716 When this returns, dev->sata_dev->lu is alive and 717 present. 718 sas_satl_register_dev(dev); 719 */ 720 721 sas_fill_in_rphy(dev, dev->rphy); 722 723 return 0; 724 out_err: 725 dev->sata_dev.identify_packet_device = NULL; 726 dev->sata_dev.identify_device = NULL; 727 kfree(identify_x); 728 return res; 729 } 730 731 static int sas_discover_sata_pm(struct domain_device *dev) 732 { 733 return -ENODEV; 734 } 735 736 /** 737 * sas_discover_sata -- discover an STP/SATA domain device 738 * @dev: pointer to struct domain_device of interest 739 * 740 * First we notify the LLDD of this device, so we can send frames to 741 * it. Then depending on the type of device we call the appropriate 742 * discover functions. Once device discover is done, we notify the 743 * LLDD so that it can fine-tune its parameters for the device, by 744 * removing it and then adding it. That is, the second time around, 745 * the driver would have certain fields, that it is looking at, set. 746 * Finally we initialize the kobj so that the device can be added to 747 * the system at registration time. Devices directly attached to a HA 748 * port, have no parents. All other devices do, and should have their 749 * "parent" pointer set appropriately before calling this function. 750 */ 751 int sas_discover_sata(struct domain_device *dev) 752 { 753 int res; 754 755 sas_get_ata_command_set(dev); 756 757 res = sas_notify_lldd_dev_found(dev); 758 if (res) 759 return res; 760 761 switch (dev->dev_type) { 762 case SATA_DEV: 763 res = sas_discover_sata_dev(dev); 764 break; 765 case SATA_PM: 766 res = sas_discover_sata_pm(dev); 767 break; 768 default: 769 break; 770 } 771 sas_notify_lldd_dev_gone(dev); 772 if (!res) { 773 sas_notify_lldd_dev_found(dev); 774 res = sas_rphy_add(dev->rphy); 775 } 776 777 return res; 778 } 779