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