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 26 #include <scsi/sas_ata.h> 27 #include "sas_internal.h" 28 #include <scsi/scsi_host.h> 29 #include <scsi/scsi_device.h> 30 #include <scsi/scsi_tcq.h> 31 #include <scsi/scsi.h> 32 #include <scsi/scsi_transport.h> 33 #include <scsi/scsi_transport_sas.h> 34 #include "../scsi_sas_internal.h" 35 #include "../scsi_transport_api.h" 36 #include <scsi/scsi_eh.h> 37 38 static enum ata_completion_errors sas_to_ata_err(struct task_status_struct *ts) 39 { 40 /* Cheesy attempt to translate SAS errors into ATA. Hah! */ 41 42 /* transport error */ 43 if (ts->resp == SAS_TASK_UNDELIVERED) 44 return AC_ERR_ATA_BUS; 45 46 /* ts->resp == SAS_TASK_COMPLETE */ 47 /* task delivered, what happened afterwards? */ 48 switch (ts->stat) { 49 case SAS_DEV_NO_RESPONSE: 50 return AC_ERR_TIMEOUT; 51 52 case SAS_INTERRUPTED: 53 case SAS_PHY_DOWN: 54 case SAS_NAK_R_ERR: 55 return AC_ERR_ATA_BUS; 56 57 58 case SAS_DATA_UNDERRUN: 59 /* 60 * Some programs that use the taskfile interface 61 * (smartctl in particular) can cause underrun 62 * problems. Ignore these errors, perhaps at our 63 * peril. 64 */ 65 return 0; 66 67 case SAS_DATA_OVERRUN: 68 case SAS_QUEUE_FULL: 69 case SAS_DEVICE_UNKNOWN: 70 case SAS_SG_ERR: 71 return AC_ERR_INVALID; 72 73 case SAM_CHECK_COND: 74 case SAS_OPEN_TO: 75 case SAS_OPEN_REJECT: 76 SAS_DPRINTK("%s: Saw error %d. What to do?\n", 77 __FUNCTION__, ts->stat); 78 return AC_ERR_OTHER; 79 80 case SAS_ABORTED_TASK: 81 return AC_ERR_DEV; 82 83 case SAS_PROTO_RESPONSE: 84 /* This means the ending_fis has the error 85 * value; return 0 here to collect it */ 86 return 0; 87 default: 88 return 0; 89 } 90 } 91 92 static void sas_ata_task_done(struct sas_task *task) 93 { 94 struct ata_queued_cmd *qc = task->uldd_task; 95 struct domain_device *dev; 96 struct task_status_struct *stat = &task->task_status; 97 struct ata_task_resp *resp = (struct ata_task_resp *)stat->buf; 98 struct sas_ha_struct *sas_ha; 99 enum ata_completion_errors ac; 100 unsigned long flags; 101 102 if (!qc) 103 goto qc_already_gone; 104 105 dev = qc->ap->private_data; 106 sas_ha = dev->port->ha; 107 108 spin_lock_irqsave(dev->sata_dev.ap->lock, flags); 109 if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_GOOD) { 110 ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf); 111 qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command); 112 dev->sata_dev.sstatus = resp->sstatus; 113 dev->sata_dev.serror = resp->serror; 114 dev->sata_dev.scontrol = resp->scontrol; 115 } else if (stat->stat != SAM_STAT_GOOD) { 116 ac = sas_to_ata_err(stat); 117 if (ac) { 118 SAS_DPRINTK("%s: SAS error %x\n", __FUNCTION__, 119 stat->stat); 120 /* We saw a SAS error. Send a vague error. */ 121 qc->err_mask = ac; 122 dev->sata_dev.tf.feature = 0x04; /* status err */ 123 dev->sata_dev.tf.command = ATA_ERR; 124 } 125 } 126 127 qc->lldd_task = NULL; 128 if (qc->scsicmd) 129 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 130 ata_qc_complete(qc); 131 spin_unlock_irqrestore(dev->sata_dev.ap->lock, flags); 132 133 /* 134 * If the sas_task has an ata qc, a scsi_cmnd and the aborted 135 * flag is set, then we must have come in via the libsas EH 136 * functions. When we exit this function, we need to put the 137 * scsi_cmnd on the list of finished errors. The ata_qc_complete 138 * call cleans up the libata side of things but we're protected 139 * from the scsi_cmnd going away because the scsi_cmnd is owned 140 * by the EH, making libata's call to scsi_done a NOP. 141 */ 142 spin_lock_irqsave(&task->task_state_lock, flags); 143 if (qc->scsicmd && task->task_state_flags & SAS_TASK_STATE_ABORTED) 144 scsi_eh_finish_cmd(qc->scsicmd, &sas_ha->eh_done_q); 145 spin_unlock_irqrestore(&task->task_state_lock, flags); 146 147 qc_already_gone: 148 list_del_init(&task->list); 149 sas_free_task(task); 150 } 151 152 static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc) 153 { 154 int res; 155 struct sas_task *task; 156 struct domain_device *dev = qc->ap->private_data; 157 struct sas_ha_struct *sas_ha = dev->port->ha; 158 struct Scsi_Host *host = sas_ha->core.shost; 159 struct sas_internal *i = to_sas_internal(host->transportt); 160 struct scatterlist *sg; 161 unsigned int num = 0; 162 unsigned int xfer = 0; 163 164 task = sas_alloc_task(GFP_ATOMIC); 165 if (!task) 166 return AC_ERR_SYSTEM; 167 task->dev = dev; 168 task->task_proto = SAS_PROTOCOL_STP; 169 task->task_done = sas_ata_task_done; 170 171 if (qc->tf.command == ATA_CMD_FPDMA_WRITE || 172 qc->tf.command == ATA_CMD_FPDMA_READ) { 173 /* Need to zero out the tag libata assigned us */ 174 qc->tf.nsect = 0; 175 } 176 177 ata_tf_to_fis(&qc->tf, 1, 0, (u8*)&task->ata_task.fis); 178 task->uldd_task = qc; 179 if (is_atapi_taskfile(&qc->tf)) { 180 memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len); 181 task->total_xfer_len = qc->nbytes + qc->pad_len; 182 task->num_scatter = qc->pad_len ? qc->n_elem + 1 : qc->n_elem; 183 } else { 184 ata_for_each_sg(sg, qc) { 185 num++; 186 xfer += sg->length; 187 } 188 189 task->total_xfer_len = xfer; 190 task->num_scatter = num; 191 } 192 193 task->data_dir = qc->dma_dir; 194 task->scatter = qc->__sg; 195 task->ata_task.retry_count = 1; 196 task->task_state_flags = SAS_TASK_STATE_PENDING; 197 qc->lldd_task = task; 198 199 switch (qc->tf.protocol) { 200 case ATA_PROT_NCQ: 201 task->ata_task.use_ncq = 1; 202 /* fall through */ 203 case ATA_PROT_ATAPI_DMA: 204 case ATA_PROT_DMA: 205 task->ata_task.dma_xfer = 1; 206 break; 207 } 208 209 if (qc->scsicmd) 210 ASSIGN_SAS_TASK(qc->scsicmd, task); 211 212 if (sas_ha->lldd_max_execute_num < 2) 213 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 214 else 215 res = sas_queue_up(task); 216 217 /* Examine */ 218 if (res) { 219 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 220 221 if (qc->scsicmd) 222 ASSIGN_SAS_TASK(qc->scsicmd, NULL); 223 sas_free_task(task); 224 return AC_ERR_SYSTEM; 225 } 226 227 return 0; 228 } 229 230 static u8 sas_ata_check_status(struct ata_port *ap) 231 { 232 struct domain_device *dev = ap->private_data; 233 return dev->sata_dev.tf.command; 234 } 235 236 static void sas_ata_phy_reset(struct ata_port *ap) 237 { 238 struct domain_device *dev = ap->private_data; 239 struct sas_internal *i = 240 to_sas_internal(dev->port->ha->core.shost->transportt); 241 int res = 0; 242 243 if (i->dft->lldd_I_T_nexus_reset) 244 res = i->dft->lldd_I_T_nexus_reset(dev); 245 246 if (res) 247 SAS_DPRINTK("%s: Unable to reset I T nexus?\n", __FUNCTION__); 248 249 switch (dev->sata_dev.command_set) { 250 case ATA_COMMAND_SET: 251 SAS_DPRINTK("%s: Found ATA device.\n", __FUNCTION__); 252 ap->device[0].class = ATA_DEV_ATA; 253 break; 254 case ATAPI_COMMAND_SET: 255 SAS_DPRINTK("%s: Found ATAPI device.\n", __FUNCTION__); 256 ap->device[0].class = ATA_DEV_ATAPI; 257 break; 258 default: 259 SAS_DPRINTK("%s: Unknown SATA command set: %d.\n", 260 __FUNCTION__, 261 dev->sata_dev.command_set); 262 ap->device[0].class = ATA_DEV_UNKNOWN; 263 break; 264 } 265 266 ap->cbl = ATA_CBL_SATA; 267 } 268 269 static void sas_ata_post_internal(struct ata_queued_cmd *qc) 270 { 271 if (qc->flags & ATA_QCFLAG_FAILED) 272 qc->err_mask |= AC_ERR_OTHER; 273 274 if (qc->err_mask) { 275 /* 276 * Find the sas_task and kill it. By this point, 277 * libata has decided to kill the qc, so we needn't 278 * bother with sas_ata_task_done. But we still 279 * ought to abort the task. 280 */ 281 struct sas_task *task = qc->lldd_task; 282 unsigned long flags; 283 284 qc->lldd_task = NULL; 285 if (task) { 286 /* Should this be a AT(API) device reset? */ 287 spin_lock_irqsave(&task->task_state_lock, flags); 288 task->task_state_flags |= SAS_TASK_NEED_DEV_RESET; 289 spin_unlock_irqrestore(&task->task_state_lock, flags); 290 291 task->uldd_task = NULL; 292 __sas_task_abort(task); 293 } 294 } 295 } 296 297 static void sas_ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf) 298 { 299 struct domain_device *dev = ap->private_data; 300 memcpy(tf, &dev->sata_dev.tf, sizeof (*tf)); 301 } 302 303 static int sas_ata_scr_write(struct ata_port *ap, unsigned int sc_reg_in, 304 u32 val) 305 { 306 struct domain_device *dev = ap->private_data; 307 308 SAS_DPRINTK("STUB %s\n", __FUNCTION__); 309 switch (sc_reg_in) { 310 case SCR_STATUS: 311 dev->sata_dev.sstatus = val; 312 break; 313 case SCR_CONTROL: 314 dev->sata_dev.scontrol = val; 315 break; 316 case SCR_ERROR: 317 dev->sata_dev.serror = val; 318 break; 319 case SCR_ACTIVE: 320 dev->sata_dev.ap->sactive = val; 321 break; 322 default: 323 return -EINVAL; 324 } 325 return 0; 326 } 327 328 static int sas_ata_scr_read(struct ata_port *ap, unsigned int sc_reg_in, 329 u32 *val) 330 { 331 struct domain_device *dev = ap->private_data; 332 333 SAS_DPRINTK("STUB %s\n", __FUNCTION__); 334 switch (sc_reg_in) { 335 case SCR_STATUS: 336 *val = dev->sata_dev.sstatus; 337 return 0; 338 case SCR_CONTROL: 339 *val = dev->sata_dev.scontrol; 340 return 0; 341 case SCR_ERROR: 342 *val = dev->sata_dev.serror; 343 return 0; 344 case SCR_ACTIVE: 345 *val = dev->sata_dev.ap->sactive; 346 return 0; 347 default: 348 return -EINVAL; 349 } 350 } 351 352 static struct ata_port_operations sas_sata_ops = { 353 .port_disable = ata_port_disable, 354 .check_status = sas_ata_check_status, 355 .check_altstatus = sas_ata_check_status, 356 .dev_select = ata_noop_dev_select, 357 .phy_reset = sas_ata_phy_reset, 358 .post_internal_cmd = sas_ata_post_internal, 359 .tf_read = sas_ata_tf_read, 360 .qc_prep = ata_noop_qc_prep, 361 .qc_issue = sas_ata_qc_issue, 362 .port_start = ata_sas_port_start, 363 .port_stop = ata_sas_port_stop, 364 .scr_read = sas_ata_scr_read, 365 .scr_write = sas_ata_scr_write 366 }; 367 368 static struct ata_port_info sata_port_info = { 369 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | ATA_FLAG_SATA_RESET | 370 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ, 371 .pio_mask = 0x1f, /* PIO0-4 */ 372 .mwdma_mask = 0x07, /* MWDMA0-2 */ 373 .udma_mask = ATA_UDMA6, 374 .port_ops = &sas_sata_ops 375 }; 376 377 int sas_ata_init_host_and_port(struct domain_device *found_dev, 378 struct scsi_target *starget) 379 { 380 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 381 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 382 struct ata_port *ap; 383 384 ata_host_init(&found_dev->sata_dev.ata_host, 385 ha->dev, 386 sata_port_info.flags, 387 &sas_sata_ops); 388 ap = ata_sas_port_alloc(&found_dev->sata_dev.ata_host, 389 &sata_port_info, 390 shost); 391 if (!ap) { 392 SAS_DPRINTK("ata_sas_port_alloc failed.\n"); 393 return -ENODEV; 394 } 395 396 ap->private_data = found_dev; 397 ap->cbl = ATA_CBL_SATA; 398 ap->scsi_host = shost; 399 found_dev->sata_dev.ap = ap; 400 401 return 0; 402 } 403 404 void sas_ata_task_abort(struct sas_task *task) 405 { 406 struct ata_queued_cmd *qc = task->uldd_task; 407 struct completion *waiting; 408 409 /* Bounce SCSI-initiated commands to the SCSI EH */ 410 if (qc->scsicmd) { 411 scsi_req_abort_cmd(qc->scsicmd); 412 scsi_schedule_eh(qc->scsicmd->device->host); 413 return; 414 } 415 416 /* Internal command, fake a timeout and complete. */ 417 qc->flags &= ~ATA_QCFLAG_ACTIVE; 418 qc->flags |= ATA_QCFLAG_FAILED; 419 qc->err_mask |= AC_ERR_TIMEOUT; 420 waiting = qc->private_data; 421 complete(waiting); 422 } 423 424 static void sas_task_timedout(unsigned long _task) 425 { 426 struct sas_task *task = (void *) _task; 427 unsigned long flags; 428 429 spin_lock_irqsave(&task->task_state_lock, flags); 430 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 431 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 432 spin_unlock_irqrestore(&task->task_state_lock, flags); 433 434 complete(&task->completion); 435 } 436 437 static void sas_disc_task_done(struct sas_task *task) 438 { 439 if (!del_timer(&task->timer)) 440 return; 441 complete(&task->completion); 442 } 443 444 #define SAS_DEV_TIMEOUT 10 445 446 /** 447 * sas_execute_task -- Basic task processing for discovery 448 * @task: the task to be executed 449 * @buffer: pointer to buffer to do I/O 450 * @size: size of @buffer 451 * @dma_dir: DMA direction. DMA_xxx 452 */ 453 static int sas_execute_task(struct sas_task *task, void *buffer, int size, 454 enum dma_data_direction dma_dir) 455 { 456 int res = 0; 457 struct scatterlist *scatter = NULL; 458 struct task_status_struct *ts = &task->task_status; 459 int num_scatter = 0; 460 int retries = 0; 461 struct sas_internal *i = 462 to_sas_internal(task->dev->port->ha->core.shost->transportt); 463 464 if (dma_dir != DMA_NONE) { 465 scatter = kzalloc(sizeof(*scatter), GFP_KERNEL); 466 if (!scatter) 467 goto out; 468 469 sg_init_one(scatter, buffer, size); 470 num_scatter = 1; 471 } 472 473 task->task_proto = task->dev->tproto; 474 task->scatter = scatter; 475 task->num_scatter = num_scatter; 476 task->total_xfer_len = size; 477 task->data_dir = dma_dir; 478 task->task_done = sas_disc_task_done; 479 if (dma_dir != DMA_NONE && 480 sas_protocol_ata(task->task_proto)) { 481 task->num_scatter = dma_map_sg(task->dev->port->ha->dev, 482 task->scatter, 483 task->num_scatter, 484 task->data_dir); 485 } 486 487 for (retries = 0; retries < 5; retries++) { 488 task->task_state_flags = SAS_TASK_STATE_PENDING; 489 init_completion(&task->completion); 490 491 task->timer.data = (unsigned long) task; 492 task->timer.function = sas_task_timedout; 493 task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ; 494 add_timer(&task->timer); 495 496 res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL); 497 if (res) { 498 del_timer(&task->timer); 499 SAS_DPRINTK("executing SAS discovery task failed:%d\n", 500 res); 501 goto ex_err; 502 } 503 wait_for_completion(&task->completion); 504 res = -ETASK; 505 if (task->task_state_flags & SAS_TASK_STATE_ABORTED) { 506 int res2; 507 SAS_DPRINTK("task aborted, flags:0x%x\n", 508 task->task_state_flags); 509 res2 = i->dft->lldd_abort_task(task); 510 SAS_DPRINTK("came back from abort task\n"); 511 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) { 512 if (res2 == TMF_RESP_FUNC_COMPLETE) 513 continue; /* Retry the task */ 514 else 515 goto ex_err; 516 } 517 } 518 if (task->task_status.stat == SAM_BUSY || 519 task->task_status.stat == SAM_TASK_SET_FULL || 520 task->task_status.stat == SAS_QUEUE_FULL) { 521 SAS_DPRINTK("task: q busy, sleeping...\n"); 522 schedule_timeout_interruptible(HZ); 523 } else if (task->task_status.stat == SAM_CHECK_COND) { 524 struct scsi_sense_hdr shdr; 525 526 if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size, 527 &shdr)) { 528 SAS_DPRINTK("couldn't normalize sense\n"); 529 continue; 530 } 531 if ((shdr.sense_key == 6 && shdr.asc == 0x29) || 532 (shdr.sense_key == 2 && shdr.asc == 4 && 533 shdr.ascq == 1)) { 534 SAS_DPRINTK("device %016llx LUN: %016llx " 535 "powering up or not ready yet, " 536 "sleeping...\n", 537 SAS_ADDR(task->dev->sas_addr), 538 SAS_ADDR(task->ssp_task.LUN)); 539 540 schedule_timeout_interruptible(5*HZ); 541 } else if (shdr.sense_key == 1) { 542 res = 0; 543 break; 544 } else if (shdr.sense_key == 5) { 545 break; 546 } else { 547 SAS_DPRINTK("dev %016llx LUN: %016llx " 548 "sense key:0x%x ASC:0x%x ASCQ:0x%x" 549 "\n", 550 SAS_ADDR(task->dev->sas_addr), 551 SAS_ADDR(task->ssp_task.LUN), 552 shdr.sense_key, 553 shdr.asc, shdr.ascq); 554 } 555 } else if (task->task_status.resp != SAS_TASK_COMPLETE || 556 task->task_status.stat != SAM_GOOD) { 557 SAS_DPRINTK("task finished with resp:0x%x, " 558 "stat:0x%x\n", 559 task->task_status.resp, 560 task->task_status.stat); 561 goto ex_err; 562 } else { 563 res = 0; 564 break; 565 } 566 } 567 ex_err: 568 if (dma_dir != DMA_NONE) { 569 if (sas_protocol_ata(task->task_proto)) 570 dma_unmap_sg(task->dev->port->ha->dev, 571 task->scatter, task->num_scatter, 572 task->data_dir); 573 kfree(scatter); 574 } 575 out: 576 return res; 577 } 578 579 /* ---------- SATA ---------- */ 580 581 static void sas_get_ata_command_set(struct domain_device *dev) 582 { 583 struct dev_to_host_fis *fis = 584 (struct dev_to_host_fis *) dev->frame_rcvd; 585 586 if ((fis->sector_count == 1 && /* ATA */ 587 fis->lbal == 1 && 588 fis->lbam == 0 && 589 fis->lbah == 0 && 590 fis->device == 0) 591 || 592 (fis->sector_count == 0 && /* CE-ATA (mATA) */ 593 fis->lbal == 0 && 594 fis->lbam == 0xCE && 595 fis->lbah == 0xAA && 596 (fis->device & ~0x10) == 0)) 597 598 dev->sata_dev.command_set = ATA_COMMAND_SET; 599 600 else if ((fis->interrupt_reason == 1 && /* ATAPI */ 601 fis->lbal == 1 && 602 fis->byte_count_low == 0x14 && 603 fis->byte_count_high == 0xEB && 604 (fis->device & ~0x10) == 0)) 605 606 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 607 608 else if ((fis->sector_count == 1 && /* SEMB */ 609 fis->lbal == 1 && 610 fis->lbam == 0x3C && 611 fis->lbah == 0xC3 && 612 fis->device == 0) 613 || 614 (fis->interrupt_reason == 1 && /* SATA PM */ 615 fis->lbal == 1 && 616 fis->byte_count_low == 0x69 && 617 fis->byte_count_high == 0x96 && 618 (fis->device & ~0x10) == 0)) 619 620 /* Treat it as a superset? */ 621 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 622 } 623 624 /** 625 * sas_issue_ata_cmd -- Basic SATA command processing for discovery 626 * @dev: the device to send the command to 627 * @command: the command register 628 * @features: the features register 629 * @buffer: pointer to buffer to do I/O 630 * @size: size of @buffer 631 * @dma_dir: DMA direction. DMA_xxx 632 */ 633 static int sas_issue_ata_cmd(struct domain_device *dev, u8 command, 634 u8 features, void *buffer, int size, 635 enum dma_data_direction dma_dir) 636 { 637 int res = 0; 638 struct sas_task *task; 639 struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *) 640 &dev->frame_rcvd[0]; 641 642 res = -ENOMEM; 643 task = sas_alloc_task(GFP_KERNEL); 644 if (!task) 645 goto out; 646 647 task->dev = dev; 648 649 task->ata_task.fis.fis_type = 0x27; 650 task->ata_task.fis.command = command; 651 task->ata_task.fis.features = features; 652 task->ata_task.fis.device = d2h_fis->device; 653 task->ata_task.retry_count = 1; 654 655 res = sas_execute_task(task, buffer, size, dma_dir); 656 657 sas_free_task(task); 658 out: 659 return res; 660 } 661 662 static void sas_sata_propagate_sas_addr(struct domain_device *dev) 663 { 664 unsigned long flags; 665 struct asd_sas_port *port = dev->port; 666 struct asd_sas_phy *phy; 667 668 BUG_ON(dev->parent); 669 670 memcpy(port->attached_sas_addr, dev->sas_addr, SAS_ADDR_SIZE); 671 spin_lock_irqsave(&port->phy_list_lock, flags); 672 list_for_each_entry(phy, &port->phy_list, port_phy_el) 673 memcpy(phy->attached_sas_addr, dev->sas_addr, SAS_ADDR_SIZE); 674 spin_unlock_irqrestore(&port->phy_list_lock, flags); 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 (!le16_to_cpu(identify_x[83] & (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 /* Get WWN */ 735 if (dev->port->oob_mode != SATA_OOB_MODE) { 736 memcpy(dev->sas_addr, dev->sata_dev.rps_resp.rps.stp_sas_addr, 737 SAS_ADDR_SIZE); 738 } else if (dev->sata_dev.command_set == ATA_COMMAND_SET && 739 (le16_to_cpu(dev->sata_dev.identify_device[108]) & 0xF000) 740 == 0x5000) { 741 int i; 742 743 for (i = 0; i < 4; i++) { 744 dev->sas_addr[2*i] = 745 (le16_to_cpu(dev->sata_dev.identify_device[108+i]) & 0xFF00) >> 8; 746 dev->sas_addr[2*i+1] = 747 le16_to_cpu(dev->sata_dev.identify_device[108+i]) & 0x00FF; 748 } 749 } 750 sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr); 751 if (!dev->parent) 752 sas_sata_propagate_sas_addr(dev); 753 754 /* XXX Hint: register this SATA device with SATL. 755 When this returns, dev->sata_dev->lu is alive and 756 present. 757 sas_satl_register_dev(dev); 758 */ 759 760 sas_fill_in_rphy(dev, dev->rphy); 761 762 return 0; 763 out_err: 764 dev->sata_dev.identify_packet_device = NULL; 765 dev->sata_dev.identify_device = NULL; 766 kfree(identify_x); 767 return res; 768 } 769 770 static int sas_discover_sata_pm(struct domain_device *dev) 771 { 772 return -ENODEV; 773 } 774 775 /** 776 * sas_discover_sata -- discover an STP/SATA domain device 777 * @dev: pointer to struct domain_device of interest 778 * 779 * First we notify the LLDD of this device, so we can send frames to 780 * it. Then depending on the type of device we call the appropriate 781 * discover functions. Once device discover is done, we notify the 782 * LLDD so that it can fine-tune its parameters for the device, by 783 * removing it and then adding it. That is, the second time around, 784 * the driver would have certain fields, that it is looking at, set. 785 * Finally we initialize the kobj so that the device can be added to 786 * the system at registration time. Devices directly attached to a HA 787 * port, have no parents. All other devices do, and should have their 788 * "parent" pointer set appropriately before calling this function. 789 */ 790 int sas_discover_sata(struct domain_device *dev) 791 { 792 int res; 793 794 sas_get_ata_command_set(dev); 795 796 res = sas_notify_lldd_dev_found(dev); 797 if (res) 798 return res; 799 800 switch (dev->dev_type) { 801 case SATA_DEV: 802 res = sas_discover_sata_dev(dev); 803 break; 804 case SATA_PM: 805 res = sas_discover_sata_pm(dev); 806 break; 807 default: 808 break; 809 } 810 sas_notify_lldd_dev_gone(dev); 811 if (!res) { 812 sas_notify_lldd_dev_found(dev); 813 res = sas_rphy_add(dev->rphy); 814 } 815 816 return res; 817 } 818