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 37void 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 58static 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 71static 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 */ 87static 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 } 194ex_err: 195 if (pci_dma_dir != PCI_DMA_NONE) 196 kfree(scatter); 197out: 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 */ 212static 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 306static 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 */ 358static 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); 382out: 383 return res; 384} 385 386static 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 */ 415static 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 } 457cont1: 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 return 0; 479out_err: 480 dev->sata_dev.identify_packet_device = NULL; 481 dev->sata_dev.identify_device = NULL; 482 kfree(identify_x); 483 return res; 484} 485 486static int sas_discover_sata_pm(struct domain_device *dev) 487{ 488 return -ENODEV; 489} 490 491int sas_notify_lldd_dev_found(struct domain_device *dev) 492{ 493 int res = 0; 494 struct sas_ha_struct *sas_ha = dev->port->ha; 495 struct Scsi_Host *shost = sas_ha->core.shost; 496 struct sas_internal *i = to_sas_internal(shost->transportt); 497 498 if (i->dft->lldd_dev_found) { 499 res = i->dft->lldd_dev_found(dev); 500 if (res) { 501 printk("sas: driver on pcidev %s cannot handle " 502 "device %llx, error:%d\n", 503 pci_name(sas_ha->pcidev), 504 SAS_ADDR(dev->sas_addr), res); 505 } 506 } 507 return res; 508} 509 510 511void sas_notify_lldd_dev_gone(struct domain_device *dev) 512{ 513 struct sas_ha_struct *sas_ha = dev->port->ha; 514 struct Scsi_Host *shost = sas_ha->core.shost; 515 struct sas_internal *i = to_sas_internal(shost->transportt); 516 517 if (i->dft->lldd_dev_gone) 518 i->dft->lldd_dev_gone(dev); 519} 520 521/* ---------- Common/dispatchers ---------- */ 522 523/** 524 * sas_discover_sata -- discover an STP/SATA domain device 525 * @dev: pointer to struct domain_device of interest 526 * 527 * First we notify the LLDD of this device, so we can send frames to 528 * it. Then depending on the type of device we call the appropriate 529 * discover functions. Once device discover is done, we notify the 530 * LLDD so that it can fine-tune its parameters for the device, by 531 * removing it and then adding it. That is, the second time around, 532 * the driver would have certain fields, that it is looking at, set. 533 * Finally we initialize the kobj so that the device can be added to 534 * the system at registration time. Devices directly attached to a HA 535 * port, have no parents. All other devices do, and should have their 536 * "parent" pointer set appropriately before calling this function. 537 */ 538int sas_discover_sata(struct domain_device *dev) 539{ 540 int res; 541 542 sas_get_ata_command_set(dev); 543 544 res = sas_notify_lldd_dev_found(dev); 545 if (res) 546 goto out_err2; 547 548 switch (dev->dev_type) { 549 case SATA_DEV: 550 res = sas_discover_sata_dev(dev); 551 break; 552 case SATA_PM: 553 res = sas_discover_sata_pm(dev); 554 break; 555 default: 556 break; 557 } 558 if (res) 559 goto out_err; 560 561 sas_notify_lldd_dev_gone(dev); 562 res = sas_notify_lldd_dev_found(dev); 563 if (res) 564 goto out_err2; 565 566 res = sas_rphy_add(dev->rphy); 567 if (res) 568 goto out_err; 569 570 return res; 571 572out_err: 573 sas_notify_lldd_dev_gone(dev); 574out_err2: 575 return res; 576} 577 578/** 579 * sas_discover_end_dev -- discover an end device (SSP, etc) 580 * @end: pointer to domain device of interest 581 * 582 * See comment in sas_discover_sata(). 583 */ 584int sas_discover_end_dev(struct domain_device *dev) 585{ 586 int res; 587 588 res = sas_notify_lldd_dev_found(dev); 589 if (res) 590 goto out_err2; 591 592 res = sas_rphy_add(dev->rphy); 593 if (res) 594 goto out_err; 595 596 return 0; 597 598out_err: 599 sas_notify_lldd_dev_gone(dev); 600out_err2: 601 return res; 602} 603 604/* ---------- Device registration and unregistration ---------- */ 605 606static inline void sas_unregister_common_dev(struct domain_device *dev) 607{ 608 sas_notify_lldd_dev_gone(dev); 609 if (!dev->parent) 610 dev->port->port_dev = NULL; 611 else 612 list_del_init(&dev->siblings); 613 list_del_init(&dev->dev_list_node); 614} 615 616void sas_unregister_dev(struct domain_device *dev) 617{ 618 if (dev->rphy) { 619 sas_remove_children(&dev->rphy->dev); 620 sas_rphy_delete(dev->rphy); 621 dev->rphy = NULL; 622 } 623 if (dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV) { 624 /* remove the phys and ports, everything else should be gone */ 625 kfree(dev->ex_dev.ex_phy); 626 dev->ex_dev.ex_phy = NULL; 627 } 628 sas_unregister_common_dev(dev); 629} 630 631void sas_unregister_domain_devices(struct asd_sas_port *port) 632{ 633 struct domain_device *dev, *n; 634 635 list_for_each_entry_safe_reverse(dev,n,&port->dev_list,dev_list_node) 636 sas_unregister_dev(dev); 637 638 port->port->rphy = NULL; 639 640} 641 642/* ---------- Discovery and Revalidation ---------- */ 643 644/** 645 * sas_discover_domain -- discover the domain 646 * @port: port to the domain of interest 647 * 648 * NOTE: this process _must_ quit (return) as soon as any connection 649 * errors are encountered. Connection recovery is done elsewhere. 650 * Discover process only interrogates devices in order to discover the 651 * domain. 652 */ 653static void sas_discover_domain(struct work_struct *work) 654{ 655 struct domain_device *dev; 656 int error = 0; 657 struct sas_discovery_event *ev = 658 container_of(work, struct sas_discovery_event, work); 659 struct asd_sas_port *port = ev->port; 660 661 sas_begin_event(DISCE_DISCOVER_DOMAIN, &port->disc.disc_event_lock, 662 &port->disc.pending); 663 664 if (port->port_dev) 665 return; 666 667 error = sas_get_port_device(port); 668 if (error) 669 return; 670 dev = port->port_dev; 671 672 SAS_DPRINTK("DOING DISCOVERY on port %d, pid:%d\n", port->id, 673 current->pid); 674 675 switch (dev->dev_type) { 676 case SAS_END_DEV: 677 error = sas_discover_end_dev(dev); 678 break; 679 case EDGE_DEV: 680 case FANOUT_DEV: 681 error = sas_discover_root_expander(dev); 682 break; 683 case SATA_DEV: 684 case SATA_PM: 685 error = sas_discover_sata(dev); 686 break; 687 default: 688 SAS_DPRINTK("unhandled device %d\n", dev->dev_type); 689 break; 690 } 691 692 if (error) { 693 sas_rphy_free(dev->rphy); 694 dev->rphy = NULL; 695 696 spin_lock(&port->dev_list_lock); 697 list_del_init(&dev->dev_list_node); 698 spin_unlock(&port->dev_list_lock); 699 700 kfree(dev); /* not kobject_register-ed yet */ 701 port->port_dev = NULL; 702 } 703 704 SAS_DPRINTK("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id, 705 current->pid, error); 706} 707 708static void sas_revalidate_domain(struct work_struct *work) 709{ 710 int res = 0; 711 struct sas_discovery_event *ev = 712 container_of(work, struct sas_discovery_event, work); 713 struct asd_sas_port *port = ev->port; 714 715 sas_begin_event(DISCE_REVALIDATE_DOMAIN, &port->disc.disc_event_lock, 716 &port->disc.pending); 717 718 SAS_DPRINTK("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id, 719 current->pid); 720 if (port->port_dev) 721 res = sas_ex_revalidate_domain(port->port_dev); 722 723 SAS_DPRINTK("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n", 724 port->id, current->pid, res); 725} 726 727/* ---------- Events ---------- */ 728 729int sas_discover_event(struct asd_sas_port *port, enum discover_event ev) 730{ 731 struct sas_discovery *disc; 732 733 if (!port) 734 return 0; 735 disc = &port->disc; 736 737 BUG_ON(ev >= DISC_NUM_EVENTS); 738 739 sas_queue_event(ev, &disc->disc_event_lock, &disc->pending, 740 &disc->disc_work[ev].work, port->ha); 741 742 return 0; 743} 744 745/** 746 * sas_init_disc -- initialize the discovery struct in the port 747 * @port: pointer to struct port 748 * 749 * Called when the ports are being initialized. 750 */ 751void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port) 752{ 753 int i; 754 755 static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = { 756 [DISCE_DISCOVER_DOMAIN] = sas_discover_domain, 757 [DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain, 758 }; 759 760 spin_lock_init(&disc->disc_event_lock); 761 disc->pending = 0; 762 for (i = 0; i < DISC_NUM_EVENTS; i++) { 763 INIT_WORK(&disc->disc_work[i].work, sas_event_fns[i]); 764 disc->disc_work[i].port = port; 765 } 766} 767