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