1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Serial Attached SCSI (SAS) Discover process 4 * 5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 7 */ 8 9 #include <linux/scatterlist.h> 10 #include <linux/slab.h> 11 #include <linux/async.h> 12 #include <scsi/scsi_host.h> 13 #include <scsi/scsi_eh.h> 14 #include "sas_internal.h" 15 16 #include <scsi/scsi_transport.h> 17 #include <scsi/scsi_transport_sas.h> 18 #include <scsi/sas_ata.h> 19 #include "scsi_sas_internal.h" 20 21 /* ---------- Basic task processing for discovery purposes ---------- */ 22 23 void sas_init_dev(struct domain_device *dev) 24 { 25 switch (dev->dev_type) { 26 case SAS_END_DEVICE: 27 INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node); 28 break; 29 case SAS_EDGE_EXPANDER_DEVICE: 30 case SAS_FANOUT_EXPANDER_DEVICE: 31 INIT_LIST_HEAD(&dev->ex_dev.children); 32 mutex_init(&dev->ex_dev.cmd_mutex); 33 break; 34 default: 35 break; 36 } 37 } 38 39 /* ---------- Domain device discovery ---------- */ 40 41 /** 42 * sas_get_port_device - Discover devices which caused port creation 43 * @port: pointer to struct sas_port of interest 44 * 45 * Devices directly attached to a HA port, have no parent. This is 46 * how we know they are (domain) "root" devices. All other devices 47 * do, and should have their "parent" pointer set appropriately as 48 * soon as a child device is discovered. 49 */ 50 static int sas_get_port_device(struct asd_sas_port *port) 51 { 52 struct asd_sas_phy *phy; 53 struct sas_rphy *rphy; 54 struct domain_device *dev; 55 int rc = -ENODEV; 56 57 dev = sas_alloc_device(); 58 if (!dev) 59 return -ENOMEM; 60 61 spin_lock_irq(&port->phy_list_lock); 62 if (list_empty(&port->phy_list)) { 63 spin_unlock_irq(&port->phy_list_lock); 64 sas_put_device(dev); 65 return -ENODEV; 66 } 67 phy = container_of(port->phy_list.next, struct asd_sas_phy, port_phy_el); 68 spin_lock(&phy->frame_rcvd_lock); 69 memcpy(dev->frame_rcvd, phy->frame_rcvd, min(sizeof(dev->frame_rcvd), 70 (size_t)phy->frame_rcvd_size)); 71 spin_unlock(&phy->frame_rcvd_lock); 72 spin_unlock_irq(&port->phy_list_lock); 73 74 if (dev->frame_rcvd[0] == 0x34 && port->oob_mode == SATA_OOB_MODE) { 75 struct dev_to_host_fis *fis = 76 (struct dev_to_host_fis *) dev->frame_rcvd; 77 if (fis->interrupt_reason == 1 && fis->lbal == 1 && 78 fis->byte_count_low == 0x69 && fis->byte_count_high == 0x96 79 && (fis->device & ~0x10) == 0) 80 dev->dev_type = SAS_SATA_PM; 81 else 82 dev->dev_type = SAS_SATA_DEV; 83 dev->tproto = SAS_PROTOCOL_SATA; 84 } else if (port->oob_mode == SAS_OOB_MODE) { 85 struct sas_identify_frame *id = 86 (struct sas_identify_frame *) dev->frame_rcvd; 87 dev->dev_type = id->dev_type; 88 dev->iproto = id->initiator_bits; 89 dev->tproto = id->target_bits; 90 } else { 91 /* If the oob mode is OOB_NOT_CONNECTED, the port is 92 * disconnected due to race with PHY down. We cannot 93 * continue to discover this port 94 */ 95 sas_put_device(dev); 96 pr_warn("Port %016llx is disconnected when discovering\n", 97 SAS_ADDR(port->attached_sas_addr)); 98 return -ENODEV; 99 } 100 101 sas_init_dev(dev); 102 103 dev->port = port; 104 switch (dev->dev_type) { 105 case SAS_SATA_DEV: 106 rc = sas_ata_init(dev); 107 if (rc) { 108 rphy = NULL; 109 break; 110 } 111 fallthrough; 112 case SAS_END_DEVICE: 113 rphy = sas_end_device_alloc(port->port); 114 break; 115 case SAS_EDGE_EXPANDER_DEVICE: 116 rphy = sas_expander_alloc(port->port, 117 SAS_EDGE_EXPANDER_DEVICE); 118 break; 119 case SAS_FANOUT_EXPANDER_DEVICE: 120 rphy = sas_expander_alloc(port->port, 121 SAS_FANOUT_EXPANDER_DEVICE); 122 break; 123 default: 124 pr_warn("ERROR: Unidentified device type %d\n", dev->dev_type); 125 rphy = NULL; 126 break; 127 } 128 129 if (!rphy) { 130 sas_put_device(dev); 131 return rc; 132 } 133 134 rphy->identify.phy_identifier = phy->phy->identify.phy_identifier; 135 memcpy(dev->sas_addr, port->attached_sas_addr, SAS_ADDR_SIZE); 136 sas_fill_in_rphy(dev, rphy); 137 sas_hash_addr(dev->hashed_sas_addr, dev->sas_addr); 138 port->port_dev = dev; 139 dev->linkrate = port->linkrate; 140 dev->min_linkrate = port->linkrate; 141 dev->max_linkrate = port->linkrate; 142 dev->pathways = port->num_phys; 143 memset(port->disc.fanout_sas_addr, 0, SAS_ADDR_SIZE); 144 memset(port->disc.eeds_a, 0, SAS_ADDR_SIZE); 145 memset(port->disc.eeds_b, 0, SAS_ADDR_SIZE); 146 port->disc.max_level = 0; 147 sas_device_set_phy(dev, port->port); 148 149 dev->rphy = rphy; 150 get_device(&dev->rphy->dev); 151 152 if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEVICE) 153 list_add_tail(&dev->disco_list_node, &port->disco_list); 154 else { 155 spin_lock_irq(&port->dev_list_lock); 156 list_add_tail(&dev->dev_list_node, &port->dev_list); 157 spin_unlock_irq(&port->dev_list_lock); 158 } 159 160 spin_lock_irq(&port->phy_list_lock); 161 list_for_each_entry(phy, &port->phy_list, port_phy_el) 162 sas_phy_set_target(phy, dev); 163 spin_unlock_irq(&port->phy_list_lock); 164 165 return 0; 166 } 167 168 /* ---------- Discover and Revalidate ---------- */ 169 170 int sas_notify_lldd_dev_found(struct domain_device *dev) 171 { 172 int res = 0; 173 struct sas_ha_struct *sas_ha = dev->port->ha; 174 struct Scsi_Host *shost = sas_ha->core.shost; 175 struct sas_internal *i = to_sas_internal(shost->transportt); 176 177 if (!i->dft->lldd_dev_found) 178 return 0; 179 180 res = i->dft->lldd_dev_found(dev); 181 if (res) { 182 pr_warn("driver on host %s cannot handle device %016llx, error:%d\n", 183 dev_name(sas_ha->dev), 184 SAS_ADDR(dev->sas_addr), res); 185 return res; 186 } 187 set_bit(SAS_DEV_FOUND, &dev->state); 188 kref_get(&dev->kref); 189 return 0; 190 } 191 192 193 void sas_notify_lldd_dev_gone(struct domain_device *dev) 194 { 195 struct sas_ha_struct *sas_ha = dev->port->ha; 196 struct Scsi_Host *shost = sas_ha->core.shost; 197 struct sas_internal *i = to_sas_internal(shost->transportt); 198 199 if (!i->dft->lldd_dev_gone) 200 return; 201 202 if (test_and_clear_bit(SAS_DEV_FOUND, &dev->state)) { 203 i->dft->lldd_dev_gone(dev); 204 sas_put_device(dev); 205 } 206 } 207 208 static void sas_probe_devices(struct asd_sas_port *port) 209 { 210 struct domain_device *dev, *n; 211 212 /* devices must be domain members before link recovery and probe */ 213 list_for_each_entry(dev, &port->disco_list, disco_list_node) { 214 spin_lock_irq(&port->dev_list_lock); 215 list_add_tail(&dev->dev_list_node, &port->dev_list); 216 spin_unlock_irq(&port->dev_list_lock); 217 } 218 219 sas_probe_sata(port); 220 221 list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) { 222 int err; 223 224 err = sas_rphy_add(dev->rphy); 225 if (err) 226 sas_fail_probe(dev, __func__, err); 227 else 228 list_del_init(&dev->disco_list_node); 229 } 230 } 231 232 static void sas_suspend_devices(struct work_struct *work) 233 { 234 struct asd_sas_phy *phy; 235 struct domain_device *dev; 236 struct sas_discovery_event *ev = to_sas_discovery_event(work); 237 struct asd_sas_port *port = ev->port; 238 struct Scsi_Host *shost = port->ha->core.shost; 239 struct sas_internal *si = to_sas_internal(shost->transportt); 240 241 clear_bit(DISCE_SUSPEND, &port->disc.pending); 242 243 sas_suspend_sata(port); 244 245 /* lldd is free to forget the domain_device across the 246 * suspension, we force the issue here to keep the reference 247 * counts aligned 248 */ 249 list_for_each_entry(dev, &port->dev_list, dev_list_node) 250 sas_notify_lldd_dev_gone(dev); 251 252 /* we are suspending, so we know events are disabled and 253 * phy_list is not being mutated 254 */ 255 list_for_each_entry(phy, &port->phy_list, port_phy_el) { 256 if (si->dft->lldd_port_deformed) 257 si->dft->lldd_port_deformed(phy); 258 phy->suspended = 1; 259 port->suspended = 1; 260 } 261 } 262 263 static void sas_resume_devices(struct work_struct *work) 264 { 265 struct sas_discovery_event *ev = to_sas_discovery_event(work); 266 struct asd_sas_port *port = ev->port; 267 268 clear_bit(DISCE_RESUME, &port->disc.pending); 269 270 sas_resume_sata(port); 271 } 272 273 /** 274 * sas_discover_end_dev - discover an end device (SSP, etc) 275 * @dev: pointer to domain device of interest 276 * 277 * See comment in sas_discover_sata(). 278 */ 279 int sas_discover_end_dev(struct domain_device *dev) 280 { 281 return sas_notify_lldd_dev_found(dev); 282 } 283 284 /* ---------- Device registration and unregistration ---------- */ 285 286 void sas_free_device(struct kref *kref) 287 { 288 struct domain_device *dev = container_of(kref, typeof(*dev), kref); 289 290 put_device(&dev->rphy->dev); 291 dev->rphy = NULL; 292 293 if (dev->parent) 294 sas_put_device(dev->parent); 295 296 sas_port_put_phy(dev->phy); 297 dev->phy = NULL; 298 299 /* remove the phys and ports, everything else should be gone */ 300 if (dev_is_expander(dev->dev_type)) 301 kfree(dev->ex_dev.ex_phy); 302 303 if (dev_is_sata(dev) && dev->sata_dev.ap) { 304 ata_sas_tport_delete(dev->sata_dev.ap); 305 ata_sas_port_destroy(dev->sata_dev.ap); 306 ata_host_put(dev->sata_dev.ata_host); 307 dev->sata_dev.ata_host = NULL; 308 dev->sata_dev.ap = NULL; 309 } 310 311 kfree(dev); 312 } 313 314 static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_device *dev) 315 { 316 struct sas_ha_struct *ha = port->ha; 317 318 sas_notify_lldd_dev_gone(dev); 319 if (!dev->parent) 320 dev->port->port_dev = NULL; 321 else 322 list_del_init(&dev->siblings); 323 324 spin_lock_irq(&port->dev_list_lock); 325 list_del_init(&dev->dev_list_node); 326 if (dev_is_sata(dev)) 327 sas_ata_end_eh(dev->sata_dev.ap); 328 spin_unlock_irq(&port->dev_list_lock); 329 330 spin_lock_irq(&ha->lock); 331 if (dev->dev_type == SAS_END_DEVICE && 332 !list_empty(&dev->ssp_dev.eh_list_node)) { 333 list_del_init(&dev->ssp_dev.eh_list_node); 334 ha->eh_active--; 335 } 336 spin_unlock_irq(&ha->lock); 337 338 sas_put_device(dev); 339 } 340 341 void sas_destruct_devices(struct asd_sas_port *port) 342 { 343 struct domain_device *dev, *n; 344 345 list_for_each_entry_safe(dev, n, &port->destroy_list, disco_list_node) { 346 list_del_init(&dev->disco_list_node); 347 348 sas_remove_children(&dev->rphy->dev); 349 sas_rphy_delete(dev->rphy); 350 sas_unregister_common_dev(port, dev); 351 } 352 } 353 354 static void sas_destruct_ports(struct asd_sas_port *port) 355 { 356 struct sas_port *sas_port, *p; 357 358 list_for_each_entry_safe(sas_port, p, &port->sas_port_del_list, del_list) { 359 list_del_init(&sas_port->del_list); 360 sas_port_delete(sas_port); 361 } 362 } 363 364 void sas_unregister_dev(struct asd_sas_port *port, struct domain_device *dev) 365 { 366 if (!test_bit(SAS_DEV_DESTROY, &dev->state) && 367 !list_empty(&dev->disco_list_node)) { 368 /* this rphy never saw sas_rphy_add */ 369 list_del_init(&dev->disco_list_node); 370 sas_rphy_free(dev->rphy); 371 sas_unregister_common_dev(port, dev); 372 return; 373 } 374 375 if (!test_and_set_bit(SAS_DEV_DESTROY, &dev->state)) { 376 sas_rphy_unlink(dev->rphy); 377 list_move_tail(&dev->disco_list_node, &port->destroy_list); 378 } 379 } 380 381 void sas_unregister_domain_devices(struct asd_sas_port *port, int gone) 382 { 383 struct domain_device *dev, *n; 384 385 list_for_each_entry_safe_reverse(dev, n, &port->dev_list, dev_list_node) { 386 if (gone) 387 set_bit(SAS_DEV_GONE, &dev->state); 388 sas_unregister_dev(port, dev); 389 } 390 391 list_for_each_entry_safe(dev, n, &port->disco_list, disco_list_node) 392 sas_unregister_dev(port, dev); 393 394 port->port->rphy = NULL; 395 396 } 397 398 void sas_device_set_phy(struct domain_device *dev, struct sas_port *port) 399 { 400 struct sas_ha_struct *ha; 401 struct sas_phy *new_phy; 402 403 if (!dev) 404 return; 405 406 ha = dev->port->ha; 407 new_phy = sas_port_get_phy(port); 408 409 /* pin and record last seen phy */ 410 spin_lock_irq(&ha->phy_port_lock); 411 if (new_phy) { 412 sas_port_put_phy(dev->phy); 413 dev->phy = new_phy; 414 } 415 spin_unlock_irq(&ha->phy_port_lock); 416 } 417 418 /* ---------- Discovery and Revalidation ---------- */ 419 420 /** 421 * sas_discover_domain - discover the domain 422 * @work: work structure embedded in port domain device. 423 * 424 * NOTE: this process _must_ quit (return) as soon as any connection 425 * errors are encountered. Connection recovery is done elsewhere. 426 * Discover process only interrogates devices in order to discover the 427 * domain. 428 */ 429 static void sas_discover_domain(struct work_struct *work) 430 { 431 struct domain_device *dev; 432 int error = 0; 433 struct sas_discovery_event *ev = to_sas_discovery_event(work); 434 struct asd_sas_port *port = ev->port; 435 436 clear_bit(DISCE_DISCOVER_DOMAIN, &port->disc.pending); 437 438 if (port->port_dev) 439 return; 440 441 error = sas_get_port_device(port); 442 if (error) 443 return; 444 dev = port->port_dev; 445 446 pr_debug("DOING DISCOVERY on port %d, pid:%d\n", port->id, 447 task_pid_nr(current)); 448 449 switch (dev->dev_type) { 450 case SAS_END_DEVICE: 451 error = sas_discover_end_dev(dev); 452 break; 453 case SAS_EDGE_EXPANDER_DEVICE: 454 case SAS_FANOUT_EXPANDER_DEVICE: 455 error = sas_discover_root_expander(dev); 456 break; 457 case SAS_SATA_DEV: 458 case SAS_SATA_PM: 459 #ifdef CONFIG_SCSI_SAS_ATA 460 error = sas_discover_sata(dev); 461 break; 462 #else 463 pr_notice("ATA device seen but CONFIG_SCSI_SAS_ATA=N so cannot attach\n"); 464 fallthrough; 465 #endif 466 /* Fall through - only for the #else condition above. */ 467 default: 468 error = -ENXIO; 469 pr_err("unhandled device %d\n", dev->dev_type); 470 break; 471 } 472 473 if (error) { 474 sas_rphy_free(dev->rphy); 475 list_del_init(&dev->disco_list_node); 476 spin_lock_irq(&port->dev_list_lock); 477 list_del_init(&dev->dev_list_node); 478 spin_unlock_irq(&port->dev_list_lock); 479 480 sas_put_device(dev); 481 port->port_dev = NULL; 482 } 483 484 sas_probe_devices(port); 485 486 pr_debug("DONE DISCOVERY on port %d, pid:%d, result:%d\n", port->id, 487 task_pid_nr(current), error); 488 } 489 490 static void sas_revalidate_domain(struct work_struct *work) 491 { 492 int res = 0; 493 struct sas_discovery_event *ev = to_sas_discovery_event(work); 494 struct asd_sas_port *port = ev->port; 495 struct sas_ha_struct *ha = port->ha; 496 struct domain_device *ddev = port->port_dev; 497 498 /* prevent revalidation from finding sata links in recovery */ 499 mutex_lock(&ha->disco_mutex); 500 if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) { 501 pr_debug("REVALIDATION DEFERRED on port %d, pid:%d\n", 502 port->id, task_pid_nr(current)); 503 goto out; 504 } 505 506 clear_bit(DISCE_REVALIDATE_DOMAIN, &port->disc.pending); 507 508 pr_debug("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id, 509 task_pid_nr(current)); 510 511 if (ddev && dev_is_expander(ddev->dev_type)) 512 res = sas_ex_revalidate_domain(ddev); 513 514 pr_debug("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n", 515 port->id, task_pid_nr(current), res); 516 out: 517 mutex_unlock(&ha->disco_mutex); 518 519 sas_destruct_devices(port); 520 sas_destruct_ports(port); 521 sas_probe_devices(port); 522 } 523 524 /* ---------- Events ---------- */ 525 526 static void sas_chain_work(struct sas_ha_struct *ha, struct sas_work *sw) 527 { 528 /* chained work is not subject to SA_HA_DRAINING or 529 * SAS_HA_REGISTERED, because it is either submitted in the 530 * workqueue, or known to be submitted from a context that is 531 * not racing against draining 532 */ 533 queue_work(ha->disco_q, &sw->work); 534 } 535 536 static void sas_chain_event(int event, unsigned long *pending, 537 struct sas_work *sw, 538 struct sas_ha_struct *ha) 539 { 540 if (!test_and_set_bit(event, pending)) { 541 unsigned long flags; 542 543 spin_lock_irqsave(&ha->lock, flags); 544 sas_chain_work(ha, sw); 545 spin_unlock_irqrestore(&ha->lock, flags); 546 } 547 } 548 549 int sas_discover_event(struct asd_sas_port *port, enum discover_event ev) 550 { 551 struct sas_discovery *disc; 552 553 if (!port) 554 return 0; 555 disc = &port->disc; 556 557 BUG_ON(ev >= DISC_NUM_EVENTS); 558 559 sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha); 560 561 return 0; 562 } 563 564 /** 565 * sas_init_disc - initialize the discovery struct in the port 566 * @disc: port discovery structure 567 * @port: pointer to struct port 568 * 569 * Called when the ports are being initialized. 570 */ 571 void sas_init_disc(struct sas_discovery *disc, struct asd_sas_port *port) 572 { 573 int i; 574 575 static const work_func_t sas_event_fns[DISC_NUM_EVENTS] = { 576 [DISCE_DISCOVER_DOMAIN] = sas_discover_domain, 577 [DISCE_REVALIDATE_DOMAIN] = sas_revalidate_domain, 578 [DISCE_SUSPEND] = sas_suspend_devices, 579 [DISCE_RESUME] = sas_resume_devices, 580 }; 581 582 disc->pending = 0; 583 for (i = 0; i < DISC_NUM_EVENTS; i++) { 584 INIT_SAS_WORK(&disc->disc_work[i].work, sas_event_fns[i]); 585 disc->disc_work[i].port = port; 586 } 587 } 588