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