1 /* 2 * Serial Attached SCSI (SAS) Discover process 3 * 4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 6 * 7 * This file is licensed under GPLv2. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 22 * 23 */ 24 25 #include <linux/pci.h> 26 #include <linux/scatterlist.h> 27 #include <scsi/scsi_host.h> 28 #include <scsi/scsi_eh.h> 29 #include "sas_internal.h" 30 31 #include <scsi/scsi_transport.h> 32 #include <scsi/scsi_transport_sas.h> 33 #include "../scsi_sas_internal.h" 34 35 /* ---------- Basic task processing for discovery purposes ---------- */ 36 37 void sas_init_dev(struct domain_device *dev) 38 { 39 INIT_LIST_HEAD(&dev->siblings); 40 INIT_LIST_HEAD(&dev->dev_list_node); 41 switch (dev->dev_type) { 42 case SAS_END_DEV: 43 break; 44 case EDGE_DEV: 45 case FANOUT_DEV: 46 INIT_LIST_HEAD(&dev->ex_dev.children); 47 break; 48 case SATA_DEV: 49 case SATA_PM: 50 case SATA_PM_PORT: 51 INIT_LIST_HEAD(&dev->sata_dev.children); 52 break; 53 default: 54 break; 55 } 56 } 57 58 static void sas_task_timedout(unsigned long _task) 59 { 60 struct sas_task *task = (void *) _task; 61 unsigned long flags; 62 63 spin_lock_irqsave(&task->task_state_lock, flags); 64 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 65 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 66 spin_unlock_irqrestore(&task->task_state_lock, flags); 67 68 complete(&task->completion); 69 } 70 71 static void sas_disc_task_done(struct sas_task *task) 72 { 73 if (!del_timer(&task->timer)) 74 return; 75 complete(&task->completion); 76 } 77 78 #define SAS_DEV_TIMEOUT 10 79 80 /** 81 * sas_execute_task -- Basic task processing for discovery 82 * @task: the task to be executed 83 * @buffer: pointer to buffer to do I/O 84 * @size: size of @buffer 85 * @pci_dma_dir: PCI_DMA_... 86 */ 87 static int sas_execute_task(struct sas_task *task, void *buffer, int size, 88 int pci_dma_dir) 89 { 90 int res = 0; 91 struct scatterlist *scatter = NULL; 92 struct task_status_struct *ts = &task->task_status; 93 int num_scatter = 0; 94 int retries = 0; 95 struct sas_internal *i = 96 to_sas_internal(task->dev->port->ha->core.shost->transportt); 97 98 if (pci_dma_dir != PCI_DMA_NONE) { 99 scatter = kzalloc(sizeof(*scatter), GFP_KERNEL); 100 if (!scatter) 101 goto out; 102 103 sg_init_one(scatter, buffer, size); 104 num_scatter = 1; 105 } 106 107 task->task_proto = task->dev->tproto; 108 task->scatter = scatter; 109 task->num_scatter = num_scatter; 110 task->total_xfer_len = size; 111 task->data_dir = pci_dma_dir; 112 task->task_done = sas_disc_task_done; 113 114 for (retries = 0; retries < 5; retries++) { 115 task->task_state_flags = SAS_TASK_STATE_PENDING; 116 init_completion(&task->completion); 117 118 task->timer.data = (unsigned long) task; 119 task->timer.function = sas_task_timedout; 120 task->timer.expires = jiffies + SAS_DEV_TIMEOUT*HZ; 121 add_timer(&task->timer); 122 123 res = i->dft->lldd_execute_task(task, 1, GFP_KERNEL); 124 if (res) { 125 del_timer(&task->timer); 126 SAS_DPRINTK("executing SAS discovery task failed:%d\n", 127 res); 128 goto ex_err; 129 } 130 wait_for_completion(&task->completion); 131 res = -ETASK; 132 if (task->task_state_flags & SAS_TASK_STATE_ABORTED) { 133 int res2; 134 SAS_DPRINTK("task aborted, flags:0x%x\n", 135 task->task_state_flags); 136 res2 = i->dft->lldd_abort_task(task); 137 SAS_DPRINTK("came back from abort task\n"); 138 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) { 139 if (res2 == TMF_RESP_FUNC_COMPLETE) 140 continue; /* Retry the task */ 141 else 142 goto ex_err; 143 } 144 } 145 if (task->task_status.stat == SAM_BUSY || 146 task->task_status.stat == SAM_TASK_SET_FULL || 147 task->task_status.stat == SAS_QUEUE_FULL) { 148 SAS_DPRINTK("task: q busy, sleeping...\n"); 149 schedule_timeout_interruptible(HZ); 150 } else if (task->task_status.stat == SAM_CHECK_COND) { 151 struct scsi_sense_hdr shdr; 152 153 if (!scsi_normalize_sense(ts->buf, ts->buf_valid_size, 154 &shdr)) { 155 SAS_DPRINTK("couldn't normalize sense\n"); 156 continue; 157 } 158 if ((shdr.sense_key == 6 && shdr.asc == 0x29) || 159 (shdr.sense_key == 2 && shdr.asc == 4 && 160 shdr.ascq == 1)) { 161 SAS_DPRINTK("device %016llx LUN: %016llx " 162 "powering up or not ready yet, " 163 "sleeping...\n", 164 SAS_ADDR(task->dev->sas_addr), 165 SAS_ADDR(task->ssp_task.LUN)); 166 167 schedule_timeout_interruptible(5*HZ); 168 } else if (shdr.sense_key == 1) { 169 res = 0; 170 break; 171 } else if (shdr.sense_key == 5) { 172 break; 173 } else { 174 SAS_DPRINTK("dev %016llx LUN: %016llx " 175 "sense key:0x%x ASC:0x%x ASCQ:0x%x" 176 "\n", 177 SAS_ADDR(task->dev->sas_addr), 178 SAS_ADDR(task->ssp_task.LUN), 179 shdr.sense_key, 180 shdr.asc, shdr.ascq); 181 } 182 } else if (task->task_status.resp != SAS_TASK_COMPLETE || 183 task->task_status.stat != SAM_GOOD) { 184 SAS_DPRINTK("task finished with resp:0x%x, " 185 "stat:0x%x\n", 186 task->task_status.resp, 187 task->task_status.stat); 188 goto ex_err; 189 } else { 190 res = 0; 191 break; 192 } 193 } 194 ex_err: 195 if (pci_dma_dir != PCI_DMA_NONE) 196 kfree(scatter); 197 out: 198 return res; 199 } 200 201 /* ---------- Domain device discovery ---------- */ 202 203 /** 204 * sas_get_port_device -- Discover devices which caused port creation 205 * @port: pointer to struct sas_port of interest 206 * 207 * Devices directly attached to a HA port, have no parent. This is 208 * how we know they are (domain) "root" devices. All other devices 209 * do, and should have their "parent" pointer set appropriately as 210 * soon as a child device is discovered. 211 */ 212 static int sas_get_port_device(struct asd_sas_port *port) 213 { 214 unsigned long flags; 215 struct asd_sas_phy *phy; 216 struct sas_rphy *rphy; 217 struct domain_device *dev; 218 219 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 220 if (!dev) 221 return -ENOMEM; 222 223 spin_lock_irqsave(&port->phy_list_lock, flags); 224 if (list_empty(&port->phy_list)) { 225 spin_unlock_irqrestore(&port->phy_list_lock, flags); 226 kfree(dev); 227 return -ENODEV; 228 } 229 phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el); 230 spin_lock(&phy->frame_rcvd_lock); 231 memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd), 232 (size_t)phy->frame_rcvd_size)); 233 spin_unlock(&phy->frame_rcvd_lock); 234 spin_unlock_irqrestore(&port->phy_list_lock, flags); 235 236 if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) { 237 struct dev_to_host_fis *fis = 238 (struct dev_to_host_fis *) dev->frame_rcvd; 239 if (fis->interrupt_reason == 1 && fis->lbal == 1 && 240 fis->byte_count_low==0x69 && fis->byte_count_high == 0x96 241 && (fis->device & ~0x10) == 0) 242 dev->dev_type = SATA_PM; 243 else 244 dev->dev_type = SATA_DEV; 245 dev->tproto = SATA_PROTO; 246 } else { 247 struct sas_identify_frame *id = 248 (struct sas_identify_frame *) dev->frame_rcvd; 249 dev->dev_type = id->dev_type; 250 dev->iproto = id->initiator_bits; 251 dev->tproto = id->target_bits; 252 } 253 254 sas_init_dev(dev); 255 256 switch (dev->dev_type) { 257 case SAS_END_DEV: 258 rphy = sas_end_device_alloc(port->port); 259 break; 260 case EDGE_DEV: 261 rphy = sas_expander_alloc(port->port, 262 SAS_EDGE_EXPANDER_DEVICE); 263 break; 264 case FANOUT_DEV: 265 rphy = sas_expander_alloc(port->port, 266 SAS_FANOUT_EXPANDER_DEVICE); 267 break; 268 case SATA_DEV: 269 default: 270 printk("ERROR: Unidentified device type %d\n", dev->dev_type); 271 rphy = NULL; 272 break; 273 } 274 275 if (!rphy) { 276 kfree(dev); 277 return -ENODEV; 278 } 279 rphy->identify.phy_identifier = phy->phy->identify.phy_identifier; 280 memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE); 281 sas_fill_in_rphy(dev, rphy); 282 sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr); 283 port->port_dev = dev; 284 dev->port = port; 285 dev->linkrate = port->linkrate; 286 dev->min_linkrate = port->linkrate; 287 dev->max_linkrate = port->linkrate; 288 dev->pathways = port->num_phys; 289 memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE); 290 memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE); 291 memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE); 292 port->disc.max_level = 0; 293 294 dev->rphy = rphy; 295 spin_lock(&port->dev_list_lock); 296 list_add_tail(&dev->dev_list_node, &port->dev_list); 297 spin_unlock(&port->dev_list_lock); 298 299 return 0; 300 } 301 302 /* ---------- Discover and Revalidate ---------- */ 303 304 /* ---------- SATA ---------- */ 305 306 static void sas_get_ata_command_set(struct domain_device *dev) 307 { 308 struct dev_to_host_fis *fis = 309 (struct dev_to_host_fis *) dev->frame_rcvd; 310 311 if ((fis->sector_count == 1 && /* ATA */ 312 fis->lbal == 1 && 313 fis->lbam == 0 && 314 fis->lbah == 0 && 315 fis->device == 0) 316 || 317 (fis->sector_count == 0 && /* CE-ATA (mATA) */ 318 fis->lbal == 0 && 319 fis->lbam == 0xCE && 320 fis->lbah == 0xAA && 321 (fis->device & ~0x10) == 0)) 322 323 dev->sata_dev.command_set = ATA_COMMAND_SET; 324 325 else if ((fis->interrupt_reason == 1 && /* ATAPI */ 326 fis->lbal == 1 && 327 fis->byte_count_low == 0x14 && 328 fis->byte_count_high == 0xEB && 329 (fis->device & ~0x10) == 0)) 330 331 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 332 333 else if ((fis->sector_count == 1 && /* SEMB */ 334 fis->lbal == 1 && 335 fis->lbam == 0x3C && 336 fis->lbah == 0xC3 && 337 fis->device == 0) 338 || 339 (fis->interrupt_reason == 1 && /* SATA PM */ 340 fis->lbal == 1 && 341 fis->byte_count_low == 0x69 && 342 fis->byte_count_high == 0x96 && 343 (fis->device & ~0x10) == 0)) 344 345 /* Treat it as a superset? */ 346 dev->sata_dev.command_set = ATAPI_COMMAND_SET; 347 } 348 349 /** 350 * sas_issue_ata_cmd -- Basic SATA command processing for discovery 351 * @dev: the device to send the command to 352 * @command: the command register 353 * @features: the features register 354 * @buffer: pointer to buffer to do I/O 355 * @size: size of @buffer 356 * @pci_dma_dir: PCI_DMA_... 357 */ 358 static int sas_issue_ata_cmd(struct domain_device *dev, u8 command, 359 u8 features, void *buffer, int size, 360 int pci_dma_dir) 361 { 362 int res = 0; 363 struct sas_task *task; 364 struct dev_to_host_fis *d2h_fis = (struct dev_to_host_fis *) 365 &dev->frame_rcvd[0]; 366 367 res = -ENOMEM; 368 task = sas_alloc_task(GFP_KERNEL); 369 if (!task) 370 goto out; 371 372 task->dev = dev; 373 374 task->ata_task.fis.command = command; 375 task->ata_task.fis.features = features; 376 task->ata_task.fis.device = d2h_fis->device; 377 task->ata_task.retry_count = 1; 378 379 res = sas_execute_task(task, buffer, size, pci_dma_dir); 380 381 sas_free_task(task); 382 out: 383 return res; 384 } 385 386 static void sas_sata_propagate_sas_addr(struct domain_device *dev) 387 { 388 unsigned long flags; 389 struct asd_sas_port *port = dev->port; 390 struct asd_sas_phy *phy; 391 392 BUG_ON(dev->parent); 393 394 memcpy(port->attached_sas_addr, dev->sas_addr, SAS_ADDR_SIZE); 395 spin_lock_irqsave(&port->phy_list_lock, flags); 396 list_for_each_entry(phy, &port->phy_list, port_phy_el) 397 memcpy(phy->attached_sas_addr, dev->sas_addr, SAS_ADDR_SIZE); 398 spin_unlock_irqrestore(&port->phy_list_lock, flags); 399 } 400 401 #define ATA_IDENTIFY_DEV 0xEC 402 #define ATA_IDENTIFY_PACKET_DEV 0xA1 403 #define ATA_SET_FEATURES 0xEF 404 #define ATA_FEATURE_PUP_STBY_SPIN_UP 0x07 405 406 /** 407 * sas_discover_sata_dev -- discover a STP/SATA device (SATA_DEV) 408 * @dev: STP/SATA device of interest (ATA/ATAPI) 409 * 410 * The LLDD has already been notified of this device, so that we can 411 * send FISes to it. Here we try to get IDENTIFY DEVICE or IDENTIFY 412 * PACKET DEVICE, if ATAPI device, so that the LLDD can fine-tune its 413 * performance for this device. 414 */ 415 static int sas_discover_sata_dev(struct domain_device *dev) 416 { 417 int res; 418 __le16 *identify_x; 419 u8 command; 420 421 identify_x = kzalloc(512, GFP_KERNEL); 422 if (!identify_x) 423 return -ENOMEM; 424 425 if (dev->sata_dev.command_set == ATA_COMMAND_SET) { 426 dev->sata_dev.identify_device = identify_x; 427 command = ATA_IDENTIFY_DEV; 428 } else { 429 dev->sata_dev.identify_packet_device = identify_x; 430 command = ATA_IDENTIFY_PACKET_DEV; 431 } 432 433 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512, 434 PCI_DMA_FROMDEVICE); 435 if (res) 436 goto out_err; 437 438 /* lives on the media? */ 439 if (le16_to_cpu(identify_x[0]) & 4) { 440 /* incomplete response */ 441 SAS_DPRINTK("sending SET FEATURE/PUP_STBY_SPIN_UP to " 442 "dev %llx\n", SAS_ADDR(dev->sas_addr)); 443 if (!le16_to_cpu(identify_x[83] & (1<<6))) 444 goto cont1; 445 res = sas_issue_ata_cmd(dev, ATA_SET_FEATURES, 446 ATA_FEATURE_PUP_STBY_SPIN_UP, 447 NULL, 0, PCI_DMA_NONE); 448 if (res) 449 goto cont1; 450 451 schedule_timeout_interruptible(5*HZ); /* More time? */ 452 res = sas_issue_ata_cmd(dev, command, 0, identify_x, 512, 453 PCI_DMA_FROMDEVICE); 454 if (res) 455 goto out_err; 456 } 457 cont1: 458 /* Get WWN */ 459 if (dev->port->oob_mode != SATA_OOB_MODE) { 460 memcpy(dev->sas_addr, dev->sata_dev.rps_resp.rps.stp_sas_addr, 461 SAS_ADDR_SIZE); 462 } else if (dev->sata_dev.command_set == ATA_COMMAND_SET && 463 (le16_to_cpu(dev->sata_dev.identify_device[108]) & 0xF000) 464 == 0x5000) { 465 int i; 466 467 for (i = 0; i < 4; i++) { 468 dev->sas_addr[2*i] = 469 (le16_to_cpu(dev->sata_dev.identify_device[108+i]) & 0xFF00) >> 8; 470 dev->sas_addr[2*i+1] = 471 le16_to_cpu(dev->sata_dev.identify_device[108+i]) & 0x00FF; 472 } 473 } 474 sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr); 475 if (!dev->parent) 476 sas_sata_propagate_sas_addr(dev); 477 478 /* XXX Hint: register this SATA device with SATL. 479 When this returns, dev->sata_dev->lu is alive and 480 present. 481 sas_satl_register_dev(dev); 482 */ 483 return 0; 484 out_err: 485 dev->sata_dev.identify_packet_device = NULL; 486 dev->sata_dev.identify_device = NULL; 487 kfree(identify_x); 488 return res; 489 } 490 491 static int sas_discover_sata_pm(struct domain_device *dev) 492 { 493 return -ENODEV; 494 } 495 496 int sas_notify_lldd_dev_found(struct domain_device *dev) 497 { 498 int res = 0; 499 struct sas_ha_struct *sas_ha = dev->port->ha; 500 struct Scsi_Host *shost = sas_ha->core.shost; 501 struct sas_internal *i = to_sas_internal(shost->transportt); 502 503 if (i->dft->lldd_dev_found) { 504 res = i->dft->lldd_dev_found(dev); 505 if (res) { 506 printk("sas: driver on pcidev %s cannot handle " 507 "device %llx, error:%d\n", 508 pci_name(sas_ha->pcidev), 509 SAS_ADDR(dev->sas_addr), res); 510 } 511 } 512 return res; 513 } 514 515 516 void sas_notify_lldd_dev_gone(struct domain_device *dev) 517 { 518 struct sas_ha_struct *sas_ha = dev->port->ha; 519 struct Scsi_Host *shost = sas_ha->core.shost; 520 struct sas_internal *i = to_sas_internal(shost->transportt); 521 522 if (i->dft->lldd_dev_gone) 523 i->dft->lldd_dev_gone(dev); 524 } 525 526 /* ---------- Common/dispatchers ---------- */ 527 528 /** 529 * sas_discover_sata -- discover an STP/SATA domain device 530 * @dev: pointer to struct domain_device of interest 531 * 532 * First we notify the LLDD of this device, so we can send frames to 533 * it. Then depending on the type of device we call the appropriate 534 * discover functions. Once device discover is done, we notify the 535 * LLDD so that it can fine-tune its parameters for the device, by 536 * removing it and then adding it. That is, the second time around, 537 * the driver would have certain fields, that it is looking at, set. 538 * Finally we initialize the kobj so that the device can be added to 539 * the system at registration time. Devices directly attached to a HA 540 * port, have no parents. All other devices do, and should have their 541 * "parent" pointer set appropriately before calling this function. 542 */ 543 int sas_discover_sata(struct domain_device *dev) 544 { 545 int res; 546 547 sas_get_ata_command_set(dev); 548 549 res = sas_notify_lldd_dev_found(dev); 550 if (res) 551 goto out_err2; 552 553 switch (dev->dev_type) { 554 case SATA_DEV: 555 res = sas_discover_sata_dev(dev); 556 break; 557 case SATA_PM: 558 res = sas_discover_sata_pm(dev); 559 break; 560 default: 561 break; 562 } 563 if (res) 564 goto out_err; 565 566 sas_notify_lldd_dev_gone(dev); 567 res = sas_notify_lldd_dev_found(dev); 568 if (res) 569 goto out_err2; 570 571 res = sas_rphy_add(dev->rphy); 572 if (res) 573 goto out_err; 574 575 return res; 576 577 out_err: 578 sas_notify_lldd_dev_gone(dev); 579 out_err2: 580 return res; 581 } 582 583 /** 584 * sas_discover_end_dev -- discover an end device (SSP, etc) 585 * @end: pointer to domain device of interest 586 * 587 * See comment in sas_discover_sata(). 588 */ 589 int sas_discover_end_dev(struct domain_device *dev) 590 { 591 int res; 592 593 res = sas_notify_lldd_dev_found(dev); 594 if (res) 595 goto out_err2; 596 597 res = sas_rphy_add(dev->rphy); 598 if (res) 599 goto out_err; 600 601 return 0; 602 603 out_err: 604 sas_notify_lldd_dev_gone(dev); 605 out_err2: 606 return res; 607 } 608 609 /* ---------- Device registration and unregistration ---------- */ 610 611 static inline void sas_unregister_common_dev(struct domain_device *dev) 612 { 613 sas_notify_lldd_dev_gone(dev); 614 if (!dev->parent) 615 dev->port->port_dev = NULL; 616 else 617 list_del_init(&dev->siblings); 618 list_del_init(&dev->dev_list_node); 619 } 620 621 void sas_unregister_dev(struct domain_device *dev) 622 { 623 if (dev->rphy) { 624 sas_remove_children(&dev->rphy->dev); 625 sas_rphy_delete(dev->rphy); 626 dev->rphy = NULL; 627 } 628 if (dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV) { 629 /* remove the phys and ports, everything else should be gone */ 630 kfree(dev->ex_dev.ex_phy); 631 dev->ex_dev.ex_phy = NULL; 632 } 633 sas_unregister_common_dev(dev); 634 } 635 636 void sas_unregister_domain_devices(struct asd_sas_port *port) 637 { 638 struct domain_device *dev, *n; 639 640 list_for_each_entry_safe_reverse(dev,n,&port->dev_list,dev_list_node) 641 sas_unregister_dev(dev); 642 643 port->port->rphy = NULL; 644 645 } 646 647 /* ---------- Discovery and Revalidation ---------- */ 648 649 /** 650 * sas_discover_domain -- discover the domain 651 * @port: port to the domain of interest 652 * 653 * NOTE: this process _must_ quit (return) as soon as any connection 654 * errors are encountered. Connection recovery is done elsewhere. 655 * Discover process only interrogates devices in order to discover the 656 * domain. 657 */ 658 static void sas_discover_domain(struct work_struct *work) 659 { 660 struct domain_device *dev; 661 int error = 0; 662 struct sas_discovery_event *ev = 663 container_of(work, struct sas_discovery_event, work); 664 struct asd_sas_port *port = ev->port; 665 666 sas_begin_event(DISCE_DISCOVER_DOMAIN, &port->disc.disc_event_lock, 667 &port->disc.pending); 668 669 if (port->port_dev) 670 return; 671 672 error = sas_get_port_device(port); 673 if (error) 674 return; 675 dev = port->port_dev; 676 677 SAS_DPRINTK("DOING DISCOVERY on port %d, pid:%d\n", port->id, 678 current->pid); 679 680 switch (dev->dev_type) { 681 case SAS_END_DEV: 682 error = sas_discover_end_dev(dev); 683 break; 684 case EDGE_DEV: 685 case FANOUT_DEV: 686 error = sas_discover_root_expander(dev); 687 break; 688 case SATA_DEV: 689 case SATA_PM: 690 error = sas_discover_sata(dev); 691 break; 692 default: 693 SAS_DPRINTK("unhandled device %d\n", dev->dev_type); 694 break; 695 } 696 697 if (error) { 698 sas_rphy_free(dev->rphy); 699 dev->rphy = NULL; 700 701 spin_lock(&port->dev_list_lock); 702 list_del_init(&dev->dev_list_node); 703 spin_unlock(&port->dev_list_lock); 704 705 kfree(dev); /* not kobject_register-ed yet */ 706 port->port_dev = NULL; 707 } 708 709 SAS_DPRINTK("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id, 710 current->pid, error); 711 } 712 713 static void sas_revalidate_domain(struct work_struct *work) 714 { 715 int res = 0; 716 struct sas_discovery_event *ev = 717 container_of(work, struct sas_discovery_event, work); 718 struct asd_sas_port *port = ev->port; 719 720 sas_begin_event(DISCE_REVALIDATE_DOMAIN, &port->disc.disc_event_lock, 721 &port->disc.pending); 722 723 SAS_DPRINTK("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id, 724 current->pid); 725 if (port->port_dev) 726 res = sas_ex_revalidate_domain(port->port_dev); 727 728 SAS_DPRINTK("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n", 729 port->id, current->pid, res); 730 } 731 732 /* ---------- Events ---------- */ 733 734 int sas_discover_event(struct asd_sas_port *port, enum discover_event ev) 735 { 736 struct sas_discovery *disc; 737 738 if (!port) 739 return 0; 740 disc = &port->disc; 741 742 BUG_ON(ev >= DISC_NUM_EVENTS); 743 744 sas_queue_event(ev, &disc->disc_event_lock, &disc->pending, 745 &disc->disc_work[ev].work, port->ha); 746 747 return 0; 748 } 749 750 /** 751 * sas_init_disc -- initialize the discovery struct in the port 752 * @port: pointer to struct port 753 * 754 * Called when the ports are being initialized. 755 */ 756 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port) 757 { 758 int i; 759 760 static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = { 761 [DISCE_DISCOVER_DOMAIN] = sas_discover_domain, 762 [DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain, 763 }; 764 765 spin_lock_init(&disc->disc_event_lock); 766 disc->pending = 0; 767 for (i = 0; i < DISC_NUM_EVENTS; i++) { 768 INIT_WORK(&disc->disc_work[i].work, sas_event_fns[i]); 769 disc->disc_work[i].port = port; 770 } 771 } 772