1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Serial Attached SCSI (SAS) Expander discovery and configuration 4 * 5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 7 * 8 * This file is licensed under GPLv2. 9 */ 10 11#include <linux/scatterlist.h> 12#include <linux/blkdev.h> 13#include <linux/slab.h> 14#include <asm/unaligned.h> 15 16#include "sas_internal.h" 17 18#include <scsi/sas_ata.h> 19#include <scsi/scsi_transport.h> 20#include <scsi/scsi_transport_sas.h> 21#include "scsi_sas_internal.h" 22 23static int sas_discover_expander(struct domain_device *dev); 24static int sas_configure_routing(struct domain_device *dev, u8 *sas_addr); 25static int sas_configure_phy(struct domain_device *dev, int phy_id, 26 u8 *sas_addr, int include); 27static int sas_disable_routing(struct domain_device *dev, u8 *sas_addr); 28 29/* ---------- SMP task management ---------- */ 30 31/* Give it some long enough timeout. In seconds. */ 32#define SMP_TIMEOUT 10 33 34static int smp_execute_task_sg(struct domain_device *dev, 35 struct scatterlist *req, struct scatterlist *resp) 36{ 37 int res, retry; 38 struct sas_task *task = NULL; 39 struct sas_internal *i = 40 to_sas_internal(dev->port->ha->shost->transportt); 41 struct sas_ha_struct *ha = dev->port->ha; 42 43 pm_runtime_get_sync(ha->dev); 44 mutex_lock(&dev->ex_dev.cmd_mutex); 45 for (retry = 0; retry < 3; retry++) { 46 if (test_bit(SAS_DEV_GONE, &dev->state)) { 47 res = -ECOMM; 48 break; 49 } 50 51 task = sas_alloc_slow_task(GFP_KERNEL); 52 if (!task) { 53 res = -ENOMEM; 54 break; 55 } 56 task->dev = dev; 57 task->task_proto = dev->tproto; 58 task->smp_task.smp_req = *req; 59 task->smp_task.smp_resp = *resp; 60 61 task->task_done = sas_task_internal_done; 62 63 task->slow_task->timer.function = sas_task_internal_timedout; 64 task->slow_task->timer.expires = jiffies + SMP_TIMEOUT*HZ; 65 add_timer(&task->slow_task->timer); 66 67 res = i->dft->lldd_execute_task(task, GFP_KERNEL); 68 69 if (res) { 70 del_timer_sync(&task->slow_task->timer); 71 pr_notice("executing SMP task failed:%d\n", res); 72 break; 73 } 74 75 wait_for_completion(&task->slow_task->completion); 76 res = -ECOMM; 77 if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) { 78 pr_notice("smp task timed out or aborted\n"); 79 i->dft->lldd_abort_task(task); 80 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) { 81 pr_notice("SMP task aborted and not done\n"); 82 break; 83 } 84 } 85 if (task->task_status.resp == SAS_TASK_COMPLETE && 86 task->task_status.stat == SAS_SAM_STAT_GOOD) { 87 res = 0; 88 break; 89 } 90 if (task->task_status.resp == SAS_TASK_COMPLETE && 91 task->task_status.stat == SAS_DATA_UNDERRUN) { 92 /* no error, but return the number of bytes of 93 * underrun */ 94 res = task->task_status.residual; 95 break; 96 } 97 if (task->task_status.resp == SAS_TASK_COMPLETE && 98 task->task_status.stat == SAS_DATA_OVERRUN) { 99 res = -EMSGSIZE; 100 break; 101 } 102 if (task->task_status.resp == SAS_TASK_UNDELIVERED && 103 task->task_status.stat == SAS_DEVICE_UNKNOWN) 104 break; 105 else { 106 pr_notice("%s: task to dev %016llx response: 0x%x status 0x%x\n", 107 __func__, 108 SAS_ADDR(dev->sas_addr), 109 task->task_status.resp, 110 task->task_status.stat); 111 sas_free_task(task); 112 task = NULL; 113 } 114 } 115 mutex_unlock(&dev->ex_dev.cmd_mutex); 116 pm_runtime_put_sync(ha->dev); 117 118 BUG_ON(retry == 3 && task != NULL); 119 sas_free_task(task); 120 return res; 121} 122 123static int smp_execute_task(struct domain_device *dev, void *req, int req_size, 124 void *resp, int resp_size) 125{ 126 struct scatterlist req_sg; 127 struct scatterlist resp_sg; 128 129 sg_init_one(&req_sg, req, req_size); 130 sg_init_one(&resp_sg, resp, resp_size); 131 return smp_execute_task_sg(dev, &req_sg, &resp_sg); 132} 133 134/* ---------- Allocations ---------- */ 135 136static inline void *alloc_smp_req(int size) 137{ 138 u8 *p = kzalloc(ALIGN(size, ARCH_DMA_MINALIGN), GFP_KERNEL); 139 if (p) 140 p[0] = SMP_REQUEST; 141 return p; 142} 143 144static inline void *alloc_smp_resp(int size) 145{ 146 return kzalloc(size, GFP_KERNEL); 147} 148 149static char sas_route_char(struct domain_device *dev, struct ex_phy *phy) 150{ 151 switch (phy->routing_attr) { 152 case TABLE_ROUTING: 153 if (dev->ex_dev.t2t_supp) 154 return 'U'; 155 else 156 return 'T'; 157 case DIRECT_ROUTING: 158 return 'D'; 159 case SUBTRACTIVE_ROUTING: 160 return 'S'; 161 default: 162 return '?'; 163 } 164} 165 166static enum sas_device_type to_dev_type(struct discover_resp *dr) 167{ 168 /* This is detecting a failure to transmit initial dev to host 169 * FIS as described in section J.5 of sas-2 r16 170 */ 171 if (dr->attached_dev_type == SAS_PHY_UNUSED && dr->attached_sata_dev && 172 dr->linkrate >= SAS_LINK_RATE_1_5_GBPS) 173 return SAS_SATA_PENDING; 174 else 175 return dr->attached_dev_type; 176} 177 178static void sas_set_ex_phy(struct domain_device *dev, int phy_id, 179 struct smp_disc_resp *disc_resp) 180{ 181 enum sas_device_type dev_type; 182 enum sas_linkrate linkrate; 183 u8 sas_addr[SAS_ADDR_SIZE]; 184 struct discover_resp *dr = &disc_resp->disc; 185 struct sas_ha_struct *ha = dev->port->ha; 186 struct expander_device *ex = &dev->ex_dev; 187 struct ex_phy *phy = &ex->ex_phy[phy_id]; 188 struct sas_rphy *rphy = dev->rphy; 189 bool new_phy = !phy->phy; 190 char *type; 191 192 if (new_phy) { 193 if (WARN_ON_ONCE(test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state))) 194 return; 195 phy->phy = sas_phy_alloc(&rphy->dev, phy_id); 196 197 /* FIXME: error_handling */ 198 BUG_ON(!phy->phy); 199 } 200 201 switch (disc_resp->result) { 202 case SMP_RESP_PHY_VACANT: 203 phy->phy_state = PHY_VACANT; 204 break; 205 default: 206 phy->phy_state = PHY_NOT_PRESENT; 207 break; 208 case SMP_RESP_FUNC_ACC: 209 phy->phy_state = PHY_EMPTY; /* do not know yet */ 210 break; 211 } 212 213 /* check if anything important changed to squelch debug */ 214 dev_type = phy->attached_dev_type; 215 linkrate = phy->linkrate; 216 memcpy(sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE); 217 218 /* Handle vacant phy - rest of dr data is not valid so skip it */ 219 if (phy->phy_state == PHY_VACANT) { 220 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 221 phy->attached_dev_type = SAS_PHY_UNUSED; 222 if (!test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) { 223 phy->phy_id = phy_id; 224 goto skip; 225 } else 226 goto out; 227 } 228 229 phy->attached_dev_type = to_dev_type(dr); 230 if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) 231 goto out; 232 phy->phy_id = phy_id; 233 phy->linkrate = dr->linkrate; 234 phy->attached_sata_host = dr->attached_sata_host; 235 phy->attached_sata_dev = dr->attached_sata_dev; 236 phy->attached_sata_ps = dr->attached_sata_ps; 237 phy->attached_iproto = dr->iproto << 1; 238 phy->attached_tproto = dr->tproto << 1; 239 /* help some expanders that fail to zero sas_address in the 'no 240 * device' case 241 */ 242 if (phy->attached_dev_type == SAS_PHY_UNUSED || 243 phy->linkrate < SAS_LINK_RATE_1_5_GBPS) 244 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 245 else 246 memcpy(phy->attached_sas_addr, dr->attached_sas_addr, SAS_ADDR_SIZE); 247 phy->attached_phy_id = dr->attached_phy_id; 248 phy->phy_change_count = dr->change_count; 249 phy->routing_attr = dr->routing_attr; 250 phy->virtual = dr->virtual; 251 phy->last_da_index = -1; 252 253 phy->phy->identify.sas_address = SAS_ADDR(phy->attached_sas_addr); 254 phy->phy->identify.device_type = dr->attached_dev_type; 255 phy->phy->identify.initiator_port_protocols = phy->attached_iproto; 256 phy->phy->identify.target_port_protocols = phy->attached_tproto; 257 if (!phy->attached_tproto && dr->attached_sata_dev) 258 phy->phy->identify.target_port_protocols = SAS_PROTOCOL_SATA; 259 phy->phy->identify.phy_identifier = phy_id; 260 phy->phy->minimum_linkrate_hw = dr->hmin_linkrate; 261 phy->phy->maximum_linkrate_hw = dr->hmax_linkrate; 262 phy->phy->minimum_linkrate = dr->pmin_linkrate; 263 phy->phy->maximum_linkrate = dr->pmax_linkrate; 264 phy->phy->negotiated_linkrate = phy->linkrate; 265 phy->phy->enabled = (phy->linkrate != SAS_PHY_DISABLED); 266 267 skip: 268 if (new_phy) 269 if (sas_phy_add(phy->phy)) { 270 sas_phy_free(phy->phy); 271 return; 272 } 273 274 out: 275 switch (phy->attached_dev_type) { 276 case SAS_SATA_PENDING: 277 type = "stp pending"; 278 break; 279 case SAS_PHY_UNUSED: 280 type = "no device"; 281 break; 282 case SAS_END_DEVICE: 283 if (phy->attached_iproto) { 284 if (phy->attached_tproto) 285 type = "host+target"; 286 else 287 type = "host"; 288 } else { 289 if (dr->attached_sata_dev) 290 type = "stp"; 291 else 292 type = "ssp"; 293 } 294 break; 295 case SAS_EDGE_EXPANDER_DEVICE: 296 case SAS_FANOUT_EXPANDER_DEVICE: 297 type = "smp"; 298 break; 299 default: 300 type = "unknown"; 301 } 302 303 /* this routine is polled by libata error recovery so filter 304 * unimportant messages 305 */ 306 if (new_phy || phy->attached_dev_type != dev_type || 307 phy->linkrate != linkrate || 308 SAS_ADDR(phy->attached_sas_addr) != SAS_ADDR(sas_addr)) 309 /* pass */; 310 else 311 return; 312 313 /* if the attached device type changed and ata_eh is active, 314 * make sure we run revalidation when eh completes (see: 315 * sas_enable_revalidation) 316 */ 317 if (test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) 318 set_bit(DISCE_REVALIDATE_DOMAIN, &dev->port->disc.pending); 319 320 pr_debug("%sex %016llx phy%02d:%c:%X attached: %016llx (%s)\n", 321 test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state) ? "ata: " : "", 322 SAS_ADDR(dev->sas_addr), phy->phy_id, 323 sas_route_char(dev, phy), phy->linkrate, 324 SAS_ADDR(phy->attached_sas_addr), type); 325} 326 327/* check if we have an existing attached ata device on this expander phy */ 328struct domain_device *sas_ex_to_ata(struct domain_device *ex_dev, int phy_id) 329{ 330 struct ex_phy *ex_phy = &ex_dev->ex_dev.ex_phy[phy_id]; 331 struct domain_device *dev; 332 struct sas_rphy *rphy; 333 334 if (!ex_phy->port) 335 return NULL; 336 337 rphy = ex_phy->port->rphy; 338 if (!rphy) 339 return NULL; 340 341 dev = sas_find_dev_by_rphy(rphy); 342 343 if (dev && dev_is_sata(dev)) 344 return dev; 345 346 return NULL; 347} 348 349#define DISCOVER_REQ_SIZE 16 350#define DISCOVER_RESP_SIZE sizeof(struct smp_disc_resp) 351 352static int sas_ex_phy_discover_helper(struct domain_device *dev, u8 *disc_req, 353 struct smp_disc_resp *disc_resp, 354 int single) 355{ 356 struct discover_resp *dr = &disc_resp->disc; 357 int res; 358 359 disc_req[9] = single; 360 361 res = smp_execute_task(dev, disc_req, DISCOVER_REQ_SIZE, 362 disc_resp, DISCOVER_RESP_SIZE); 363 if (res) 364 return res; 365 if (memcmp(dev->sas_addr, dr->attached_sas_addr, SAS_ADDR_SIZE) == 0) { 366 pr_notice("Found loopback topology, just ignore it!\n"); 367 return 0; 368 } 369 sas_set_ex_phy(dev, single, disc_resp); 370 return 0; 371} 372 373int sas_ex_phy_discover(struct domain_device *dev, int single) 374{ 375 struct expander_device *ex = &dev->ex_dev; 376 int res = 0; 377 u8 *disc_req; 378 struct smp_disc_resp *disc_resp; 379 380 disc_req = alloc_smp_req(DISCOVER_REQ_SIZE); 381 if (!disc_req) 382 return -ENOMEM; 383 384 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE); 385 if (!disc_resp) { 386 kfree(disc_req); 387 return -ENOMEM; 388 } 389 390 disc_req[1] = SMP_DISCOVER; 391 392 if (0 <= single && single < ex->num_phys) { 393 res = sas_ex_phy_discover_helper(dev, disc_req, disc_resp, single); 394 } else { 395 int i; 396 397 for (i = 0; i < ex->num_phys; i++) { 398 res = sas_ex_phy_discover_helper(dev, disc_req, 399 disc_resp, i); 400 if (res) 401 goto out_err; 402 } 403 } 404out_err: 405 kfree(disc_resp); 406 kfree(disc_req); 407 return res; 408} 409 410static int sas_expander_discover(struct domain_device *dev) 411{ 412 struct expander_device *ex = &dev->ex_dev; 413 int res; 414 415 ex->ex_phy = kcalloc(ex->num_phys, sizeof(*ex->ex_phy), GFP_KERNEL); 416 if (!ex->ex_phy) 417 return -ENOMEM; 418 419 res = sas_ex_phy_discover(dev, -1); 420 if (res) 421 goto out_err; 422 423 return 0; 424 out_err: 425 kfree(ex->ex_phy); 426 ex->ex_phy = NULL; 427 return res; 428} 429 430#define MAX_EXPANDER_PHYS 128 431 432#define RG_REQ_SIZE 8 433#define RG_RESP_SIZE sizeof(struct smp_rg_resp) 434 435static int sas_ex_general(struct domain_device *dev) 436{ 437 u8 *rg_req; 438 struct smp_rg_resp *rg_resp; 439 struct report_general_resp *rg; 440 int res; 441 int i; 442 443 rg_req = alloc_smp_req(RG_REQ_SIZE); 444 if (!rg_req) 445 return -ENOMEM; 446 447 rg_resp = alloc_smp_resp(RG_RESP_SIZE); 448 if (!rg_resp) { 449 kfree(rg_req); 450 return -ENOMEM; 451 } 452 453 rg_req[1] = SMP_REPORT_GENERAL; 454 455 for (i = 0; i < 5; i++) { 456 res = smp_execute_task(dev, rg_req, RG_REQ_SIZE, rg_resp, 457 RG_RESP_SIZE); 458 459 if (res) { 460 pr_notice("RG to ex %016llx failed:0x%x\n", 461 SAS_ADDR(dev->sas_addr), res); 462 goto out; 463 } else if (rg_resp->result != SMP_RESP_FUNC_ACC) { 464 pr_debug("RG:ex %016llx returned SMP result:0x%x\n", 465 SAS_ADDR(dev->sas_addr), rg_resp->result); 466 res = rg_resp->result; 467 goto out; 468 } 469 470 rg = &rg_resp->rg; 471 dev->ex_dev.ex_change_count = be16_to_cpu(rg->change_count); 472 dev->ex_dev.max_route_indexes = be16_to_cpu(rg->route_indexes); 473 dev->ex_dev.num_phys = min(rg->num_phys, (u8)MAX_EXPANDER_PHYS); 474 dev->ex_dev.t2t_supp = rg->t2t_supp; 475 dev->ex_dev.conf_route_table = rg->conf_route_table; 476 dev->ex_dev.configuring = rg->configuring; 477 memcpy(dev->ex_dev.enclosure_logical_id, 478 rg->enclosure_logical_id, 8); 479 480 if (dev->ex_dev.configuring) { 481 pr_debug("RG: ex %016llx self-configuring...\n", 482 SAS_ADDR(dev->sas_addr)); 483 schedule_timeout_interruptible(5*HZ); 484 } else 485 break; 486 } 487out: 488 kfree(rg_req); 489 kfree(rg_resp); 490 return res; 491} 492 493static void ex_assign_manuf_info(struct domain_device *dev, void 494 *_mi_resp) 495{ 496 u8 *mi_resp = _mi_resp; 497 struct sas_rphy *rphy = dev->rphy; 498 struct sas_expander_device *edev = rphy_to_expander_device(rphy); 499 500 memcpy(edev->vendor_id, mi_resp + 12, SAS_EXPANDER_VENDOR_ID_LEN); 501 memcpy(edev->product_id, mi_resp + 20, SAS_EXPANDER_PRODUCT_ID_LEN); 502 memcpy(edev->product_rev, mi_resp + 36, 503 SAS_EXPANDER_PRODUCT_REV_LEN); 504 505 if (mi_resp[8] & 1) { 506 memcpy(edev->component_vendor_id, mi_resp + 40, 507 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN); 508 edev->component_id = mi_resp[48] << 8 | mi_resp[49]; 509 edev->component_revision_id = mi_resp[50]; 510 } 511} 512 513#define MI_REQ_SIZE 8 514#define MI_RESP_SIZE 64 515 516static int sas_ex_manuf_info(struct domain_device *dev) 517{ 518 u8 *mi_req; 519 u8 *mi_resp; 520 int res; 521 522 mi_req = alloc_smp_req(MI_REQ_SIZE); 523 if (!mi_req) 524 return -ENOMEM; 525 526 mi_resp = alloc_smp_resp(MI_RESP_SIZE); 527 if (!mi_resp) { 528 kfree(mi_req); 529 return -ENOMEM; 530 } 531 532 mi_req[1] = SMP_REPORT_MANUF_INFO; 533 534 res = smp_execute_task(dev, mi_req, MI_REQ_SIZE, mi_resp, MI_RESP_SIZE); 535 if (res) { 536 pr_notice("MI: ex %016llx failed:0x%x\n", 537 SAS_ADDR(dev->sas_addr), res); 538 goto out; 539 } else if (mi_resp[2] != SMP_RESP_FUNC_ACC) { 540 pr_debug("MI ex %016llx returned SMP result:0x%x\n", 541 SAS_ADDR(dev->sas_addr), mi_resp[2]); 542 goto out; 543 } 544 545 ex_assign_manuf_info(dev, mi_resp); 546out: 547 kfree(mi_req); 548 kfree(mi_resp); 549 return res; 550} 551 552#define PC_REQ_SIZE 44 553#define PC_RESP_SIZE 8 554 555int sas_smp_phy_control(struct domain_device *dev, int phy_id, 556 enum phy_func phy_func, 557 struct sas_phy_linkrates *rates) 558{ 559 u8 *pc_req; 560 u8 *pc_resp; 561 int res; 562 563 pc_req = alloc_smp_req(PC_REQ_SIZE); 564 if (!pc_req) 565 return -ENOMEM; 566 567 pc_resp = alloc_smp_resp(PC_RESP_SIZE); 568 if (!pc_resp) { 569 kfree(pc_req); 570 return -ENOMEM; 571 } 572 573 pc_req[1] = SMP_PHY_CONTROL; 574 pc_req[9] = phy_id; 575 pc_req[10] = phy_func; 576 if (rates) { 577 pc_req[32] = rates->minimum_linkrate << 4; 578 pc_req[33] = rates->maximum_linkrate << 4; 579 } 580 581 res = smp_execute_task(dev, pc_req, PC_REQ_SIZE, pc_resp, PC_RESP_SIZE); 582 if (res) { 583 pr_err("ex %016llx phy%02d PHY control failed: %d\n", 584 SAS_ADDR(dev->sas_addr), phy_id, res); 585 } else if (pc_resp[2] != SMP_RESP_FUNC_ACC) { 586 pr_err("ex %016llx phy%02d PHY control failed: function result 0x%x\n", 587 SAS_ADDR(dev->sas_addr), phy_id, pc_resp[2]); 588 res = pc_resp[2]; 589 } 590 kfree(pc_resp); 591 kfree(pc_req); 592 return res; 593} 594 595static void sas_ex_disable_phy(struct domain_device *dev, int phy_id) 596{ 597 struct expander_device *ex = &dev->ex_dev; 598 struct ex_phy *phy = &ex->ex_phy[phy_id]; 599 600 sas_smp_phy_control(dev, phy_id, PHY_FUNC_DISABLE, NULL); 601 phy->linkrate = SAS_PHY_DISABLED; 602} 603 604static void sas_ex_disable_port(struct domain_device *dev, u8 *sas_addr) 605{ 606 struct expander_device *ex = &dev->ex_dev; 607 int i; 608 609 for (i = 0; i < ex->num_phys; i++) { 610 struct ex_phy *phy = &ex->ex_phy[i]; 611 612 if (phy->phy_state == PHY_VACANT || 613 phy->phy_state == PHY_NOT_PRESENT) 614 continue; 615 616 if (SAS_ADDR(phy->attached_sas_addr) == SAS_ADDR(sas_addr)) 617 sas_ex_disable_phy(dev, i); 618 } 619} 620 621static int sas_dev_present_in_domain(struct asd_sas_port *port, 622 u8 *sas_addr) 623{ 624 struct domain_device *dev; 625 626 if (SAS_ADDR(port->sas_addr) == SAS_ADDR(sas_addr)) 627 return 1; 628 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 629 if (SAS_ADDR(dev->sas_addr) == SAS_ADDR(sas_addr)) 630 return 1; 631 } 632 return 0; 633} 634 635#define RPEL_REQ_SIZE 16 636#define RPEL_RESP_SIZE 32 637int sas_smp_get_phy_events(struct sas_phy *phy) 638{ 639 int res; 640 u8 *req; 641 u8 *resp; 642 struct sas_rphy *rphy = dev_to_rphy(phy->dev.parent); 643 struct domain_device *dev = sas_find_dev_by_rphy(rphy); 644 645 req = alloc_smp_req(RPEL_REQ_SIZE); 646 if (!req) 647 return -ENOMEM; 648 649 resp = alloc_smp_resp(RPEL_RESP_SIZE); 650 if (!resp) { 651 kfree(req); 652 return -ENOMEM; 653 } 654 655 req[1] = SMP_REPORT_PHY_ERR_LOG; 656 req[9] = phy->number; 657 658 res = smp_execute_task(dev, req, RPEL_REQ_SIZE, 659 resp, RPEL_RESP_SIZE); 660 661 if (res) 662 goto out; 663 664 phy->invalid_dword_count = get_unaligned_be32(&resp[12]); 665 phy->running_disparity_error_count = get_unaligned_be32(&resp[16]); 666 phy->loss_of_dword_sync_count = get_unaligned_be32(&resp[20]); 667 phy->phy_reset_problem_count = get_unaligned_be32(&resp[24]); 668 669 out: 670 kfree(req); 671 kfree(resp); 672 return res; 673 674} 675 676#ifdef CONFIG_SCSI_SAS_ATA 677 678#define RPS_REQ_SIZE 16 679#define RPS_RESP_SIZE sizeof(struct smp_rps_resp) 680 681int sas_get_report_phy_sata(struct domain_device *dev, int phy_id, 682 struct smp_rps_resp *rps_resp) 683{ 684 int res; 685 u8 *rps_req = alloc_smp_req(RPS_REQ_SIZE); 686 u8 *resp = (u8 *)rps_resp; 687 688 if (!rps_req) 689 return -ENOMEM; 690 691 rps_req[1] = SMP_REPORT_PHY_SATA; 692 rps_req[9] = phy_id; 693 694 res = smp_execute_task(dev, rps_req, RPS_REQ_SIZE, 695 rps_resp, RPS_RESP_SIZE); 696 697 /* 0x34 is the FIS type for the D2H fis. There's a potential 698 * standards cockup here. sas-2 explicitly specifies the FIS 699 * should be encoded so that FIS type is in resp[24]. 700 * However, some expanders endian reverse this. Undo the 701 * reversal here */ 702 if (!res && resp[27] == 0x34 && resp[24] != 0x34) { 703 int i; 704 705 for (i = 0; i < 5; i++) { 706 int j = 24 + (i*4); 707 u8 a, b; 708 a = resp[j + 0]; 709 b = resp[j + 1]; 710 resp[j + 0] = resp[j + 3]; 711 resp[j + 1] = resp[j + 2]; 712 resp[j + 2] = b; 713 resp[j + 3] = a; 714 } 715 } 716 717 kfree(rps_req); 718 return res; 719} 720#endif 721 722static void sas_ex_get_linkrate(struct domain_device *parent, 723 struct domain_device *child, 724 struct ex_phy *parent_phy) 725{ 726 struct expander_device *parent_ex = &parent->ex_dev; 727 struct sas_port *port; 728 int i; 729 730 child->pathways = 0; 731 732 port = parent_phy->port; 733 734 for (i = 0; i < parent_ex->num_phys; i++) { 735 struct ex_phy *phy = &parent_ex->ex_phy[i]; 736 737 if (phy->phy_state == PHY_VACANT || 738 phy->phy_state == PHY_NOT_PRESENT) 739 continue; 740 741 if (sas_phy_match_dev_addr(child, phy)) { 742 child->min_linkrate = min(parent->min_linkrate, 743 phy->linkrate); 744 child->max_linkrate = max(parent->max_linkrate, 745 phy->linkrate); 746 child->pathways++; 747 sas_port_add_phy(port, phy->phy); 748 } 749 } 750 child->linkrate = min(parent_phy->linkrate, child->max_linkrate); 751 child->pathways = min(child->pathways, parent->pathways); 752} 753 754static int sas_ex_add_dev(struct domain_device *parent, struct ex_phy *phy, 755 struct domain_device *child, int phy_id) 756{ 757 struct sas_rphy *rphy; 758 int res; 759 760 child->dev_type = SAS_END_DEVICE; 761 rphy = sas_end_device_alloc(phy->port); 762 if (!rphy) 763 return -ENOMEM; 764 765 child->tproto = phy->attached_tproto; 766 sas_init_dev(child); 767 768 child->rphy = rphy; 769 get_device(&rphy->dev); 770 rphy->identify.phy_identifier = phy_id; 771 sas_fill_in_rphy(child, rphy); 772 773 list_add_tail(&child->disco_list_node, &parent->port->disco_list); 774 775 res = sas_notify_lldd_dev_found(child); 776 if (res) { 777 pr_notice("notify lldd for device %016llx at %016llx:%02d returned 0x%x\n", 778 SAS_ADDR(child->sas_addr), 779 SAS_ADDR(parent->sas_addr), phy_id, res); 780 sas_rphy_free(child->rphy); 781 list_del(&child->disco_list_node); 782 return res; 783 } 784 785 return 0; 786} 787 788static struct domain_device *sas_ex_discover_end_dev( 789 struct domain_device *parent, int phy_id) 790{ 791 struct expander_device *parent_ex = &parent->ex_dev; 792 struct ex_phy *phy = &parent_ex->ex_phy[phy_id]; 793 struct domain_device *child = NULL; 794 int res; 795 796 if (phy->attached_sata_host || phy->attached_sata_ps) 797 return NULL; 798 799 child = sas_alloc_device(); 800 if (!child) 801 return NULL; 802 803 kref_get(&parent->kref); 804 child->parent = parent; 805 child->port = parent->port; 806 child->iproto = phy->attached_iproto; 807 memcpy(child->sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE); 808 sas_hash_addr(child->hashed_sas_addr, child->sas_addr); 809 if (!phy->port) { 810 phy->port = sas_port_alloc(&parent->rphy->dev, phy_id); 811 if (unlikely(!phy->port)) 812 goto out_err; 813 if (unlikely(sas_port_add(phy->port) != 0)) { 814 sas_port_free(phy->port); 815 goto out_err; 816 } 817 } 818 sas_ex_get_linkrate(parent, child, phy); 819 sas_device_set_phy(child, phy->port); 820 821 if ((phy->attached_tproto & SAS_PROTOCOL_STP) || phy->attached_sata_dev) { 822 res = sas_ata_add_dev(parent, phy, child, phy_id); 823 } else if (phy->attached_tproto & SAS_PROTOCOL_SSP) { 824 res = sas_ex_add_dev(parent, phy, child, phy_id); 825 } else { 826 pr_notice("target proto 0x%x at %016llx:0x%x not handled\n", 827 phy->attached_tproto, SAS_ADDR(parent->sas_addr), 828 phy_id); 829 res = -ENODEV; 830 } 831 832 if (res) 833 goto out_free; 834 835 list_add_tail(&child->siblings, &parent_ex->children); 836 return child; 837 838 out_free: 839 sas_port_delete(phy->port); 840 out_err: 841 phy->port = NULL; 842 sas_put_device(child); 843 return NULL; 844} 845 846/* See if this phy is part of a wide port */ 847static bool sas_ex_join_wide_port(struct domain_device *parent, int phy_id) 848{ 849 struct ex_phy *phy = &parent->ex_dev.ex_phy[phy_id]; 850 int i; 851 852 for (i = 0; i < parent->ex_dev.num_phys; i++) { 853 struct ex_phy *ephy = &parent->ex_dev.ex_phy[i]; 854 855 if (ephy == phy) 856 continue; 857 858 if (!memcmp(phy->attached_sas_addr, ephy->attached_sas_addr, 859 SAS_ADDR_SIZE) && ephy->port) { 860 sas_port_add_phy(ephy->port, phy->phy); 861 phy->port = ephy->port; 862 phy->phy_state = PHY_DEVICE_DISCOVERED; 863 return true; 864 } 865 } 866 867 return false; 868} 869 870static struct domain_device *sas_ex_discover_expander( 871 struct domain_device *parent, int phy_id) 872{ 873 struct sas_expander_device *parent_ex = rphy_to_expander_device(parent->rphy); 874 struct ex_phy *phy = &parent->ex_dev.ex_phy[phy_id]; 875 struct domain_device *child = NULL; 876 struct sas_rphy *rphy; 877 struct sas_expander_device *edev; 878 struct asd_sas_port *port; 879 int res; 880 881 if (phy->routing_attr == DIRECT_ROUTING) { 882 pr_warn("ex %016llx:%02d:D <--> ex %016llx:0x%x is not allowed\n", 883 SAS_ADDR(parent->sas_addr), phy_id, 884 SAS_ADDR(phy->attached_sas_addr), 885 phy->attached_phy_id); 886 return NULL; 887 } 888 child = sas_alloc_device(); 889 if (!child) 890 return NULL; 891 892 phy->port = sas_port_alloc(&parent->rphy->dev, phy_id); 893 /* FIXME: better error handling */ 894 BUG_ON(sas_port_add(phy->port) != 0); 895 896 897 switch (phy->attached_dev_type) { 898 case SAS_EDGE_EXPANDER_DEVICE: 899 rphy = sas_expander_alloc(phy->port, 900 SAS_EDGE_EXPANDER_DEVICE); 901 break; 902 case SAS_FANOUT_EXPANDER_DEVICE: 903 rphy = sas_expander_alloc(phy->port, 904 SAS_FANOUT_EXPANDER_DEVICE); 905 break; 906 default: 907 rphy = NULL; /* shut gcc up */ 908 BUG(); 909 } 910 port = parent->port; 911 child->rphy = rphy; 912 get_device(&rphy->dev); 913 edev = rphy_to_expander_device(rphy); 914 child->dev_type = phy->attached_dev_type; 915 kref_get(&parent->kref); 916 child->parent = parent; 917 child->port = port; 918 child->iproto = phy->attached_iproto; 919 child->tproto = phy->attached_tproto; 920 memcpy(child->sas_addr, phy->attached_sas_addr, SAS_ADDR_SIZE); 921 sas_hash_addr(child->hashed_sas_addr, child->sas_addr); 922 sas_ex_get_linkrate(parent, child, phy); 923 edev->level = parent_ex->level + 1; 924 parent->port->disc.max_level = max(parent->port->disc.max_level, 925 edev->level); 926 sas_init_dev(child); 927 sas_fill_in_rphy(child, rphy); 928 sas_rphy_add(rphy); 929 930 spin_lock_irq(&parent->port->dev_list_lock); 931 list_add_tail(&child->dev_list_node, &parent->port->dev_list); 932 spin_unlock_irq(&parent->port->dev_list_lock); 933 934 res = sas_discover_expander(child); 935 if (res) { 936 sas_rphy_delete(rphy); 937 spin_lock_irq(&parent->port->dev_list_lock); 938 list_del(&child->dev_list_node); 939 spin_unlock_irq(&parent->port->dev_list_lock); 940 sas_put_device(child); 941 sas_port_delete(phy->port); 942 phy->port = NULL; 943 return NULL; 944 } 945 list_add_tail(&child->siblings, &parent->ex_dev.children); 946 return child; 947} 948 949static int sas_ex_discover_dev(struct domain_device *dev, int phy_id) 950{ 951 struct expander_device *ex = &dev->ex_dev; 952 struct ex_phy *ex_phy = &ex->ex_phy[phy_id]; 953 struct domain_device *child = NULL; 954 int res = 0; 955 956 /* Phy state */ 957 if (ex_phy->linkrate == SAS_SATA_SPINUP_HOLD) { 958 if (!sas_smp_phy_control(dev, phy_id, PHY_FUNC_LINK_RESET, NULL)) 959 res = sas_ex_phy_discover(dev, phy_id); 960 if (res) 961 return res; 962 } 963 964 /* Parent and domain coherency */ 965 if (!dev->parent && sas_phy_match_port_addr(dev->port, ex_phy)) { 966 sas_add_parent_port(dev, phy_id); 967 return 0; 968 } 969 if (dev->parent && sas_phy_match_dev_addr(dev->parent, ex_phy)) { 970 sas_add_parent_port(dev, phy_id); 971 if (ex_phy->routing_attr == TABLE_ROUTING) 972 sas_configure_phy(dev, phy_id, dev->port->sas_addr, 1); 973 return 0; 974 } 975 976 if (sas_dev_present_in_domain(dev->port, ex_phy->attached_sas_addr)) 977 sas_ex_disable_port(dev, ex_phy->attached_sas_addr); 978 979 if (ex_phy->attached_dev_type == SAS_PHY_UNUSED) { 980 if (ex_phy->routing_attr == DIRECT_ROUTING) { 981 memset(ex_phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 982 sas_configure_routing(dev, ex_phy->attached_sas_addr); 983 } 984 return 0; 985 } else if (ex_phy->linkrate == SAS_LINK_RATE_UNKNOWN) 986 return 0; 987 988 if (ex_phy->attached_dev_type != SAS_END_DEVICE && 989 ex_phy->attached_dev_type != SAS_FANOUT_EXPANDER_DEVICE && 990 ex_phy->attached_dev_type != SAS_EDGE_EXPANDER_DEVICE && 991 ex_phy->attached_dev_type != SAS_SATA_PENDING) { 992 pr_warn("unknown device type(0x%x) attached to ex %016llx phy%02d\n", 993 ex_phy->attached_dev_type, 994 SAS_ADDR(dev->sas_addr), 995 phy_id); 996 return 0; 997 } 998 999 res = sas_configure_routing(dev, ex_phy->attached_sas_addr); 1000 if (res) { 1001 pr_notice("configure routing for dev %016llx reported 0x%x. Forgotten\n", 1002 SAS_ADDR(ex_phy->attached_sas_addr), res); 1003 sas_disable_routing(dev, ex_phy->attached_sas_addr); 1004 return res; 1005 } 1006 1007 if (sas_ex_join_wide_port(dev, phy_id)) { 1008 pr_debug("Attaching ex phy%02d to wide port %016llx\n", 1009 phy_id, SAS_ADDR(ex_phy->attached_sas_addr)); 1010 return res; 1011 } 1012 1013 switch (ex_phy->attached_dev_type) { 1014 case SAS_END_DEVICE: 1015 case SAS_SATA_PENDING: 1016 child = sas_ex_discover_end_dev(dev, phy_id); 1017 break; 1018 case SAS_FANOUT_EXPANDER_DEVICE: 1019 if (SAS_ADDR(dev->port->disc.fanout_sas_addr)) { 1020 pr_debug("second fanout expander %016llx phy%02d attached to ex %016llx phy%02d\n", 1021 SAS_ADDR(ex_phy->attached_sas_addr), 1022 ex_phy->attached_phy_id, 1023 SAS_ADDR(dev->sas_addr), 1024 phy_id); 1025 sas_ex_disable_phy(dev, phy_id); 1026 return res; 1027 } else 1028 memcpy(dev->port->disc.fanout_sas_addr, 1029 ex_phy->attached_sas_addr, SAS_ADDR_SIZE); 1030 fallthrough; 1031 case SAS_EDGE_EXPANDER_DEVICE: 1032 child = sas_ex_discover_expander(dev, phy_id); 1033 break; 1034 default: 1035 break; 1036 } 1037 1038 if (!child) 1039 pr_notice("ex %016llx phy%02d failed to discover\n", 1040 SAS_ADDR(dev->sas_addr), phy_id); 1041 return res; 1042} 1043 1044static int sas_find_sub_addr(struct domain_device *dev, u8 *sub_addr) 1045{ 1046 struct expander_device *ex = &dev->ex_dev; 1047 int i; 1048 1049 for (i = 0; i < ex->num_phys; i++) { 1050 struct ex_phy *phy = &ex->ex_phy[i]; 1051 1052 if (phy->phy_state == PHY_VACANT || 1053 phy->phy_state == PHY_NOT_PRESENT) 1054 continue; 1055 1056 if (dev_is_expander(phy->attached_dev_type) && 1057 phy->routing_attr == SUBTRACTIVE_ROUTING) { 1058 1059 memcpy(sub_addr, phy->attached_sas_addr, SAS_ADDR_SIZE); 1060 1061 return 1; 1062 } 1063 } 1064 return 0; 1065} 1066 1067static int sas_check_level_subtractive_boundary(struct domain_device *dev) 1068{ 1069 struct expander_device *ex = &dev->ex_dev; 1070 struct domain_device *child; 1071 u8 sub_addr[SAS_ADDR_SIZE] = {0, }; 1072 1073 list_for_each_entry(child, &ex->children, siblings) { 1074 if (!dev_is_expander(child->dev_type)) 1075 continue; 1076 if (sub_addr[0] == 0) { 1077 sas_find_sub_addr(child, sub_addr); 1078 continue; 1079 } else { 1080 u8 s2[SAS_ADDR_SIZE]; 1081 1082 if (sas_find_sub_addr(child, s2) && 1083 (SAS_ADDR(sub_addr) != SAS_ADDR(s2))) { 1084 1085 pr_notice("ex %016llx->%016llx-?->%016llx diverges from subtractive boundary %016llx\n", 1086 SAS_ADDR(dev->sas_addr), 1087 SAS_ADDR(child->sas_addr), 1088 SAS_ADDR(s2), 1089 SAS_ADDR(sub_addr)); 1090 1091 sas_ex_disable_port(child, s2); 1092 } 1093 } 1094 } 1095 return 0; 1096} 1097/** 1098 * sas_ex_discover_devices - discover devices attached to this expander 1099 * @dev: pointer to the expander domain device 1100 * @single: if you want to do a single phy, else set to -1; 1101 * 1102 * Configure this expander for use with its devices and register the 1103 * devices of this expander. 1104 */ 1105static int sas_ex_discover_devices(struct domain_device *dev, int single) 1106{ 1107 struct expander_device *ex = &dev->ex_dev; 1108 int i = 0, end = ex->num_phys; 1109 int res = 0; 1110 1111 if (0 <= single && single < end) { 1112 i = single; 1113 end = i+1; 1114 } 1115 1116 for ( ; i < end; i++) { 1117 struct ex_phy *ex_phy = &ex->ex_phy[i]; 1118 1119 if (ex_phy->phy_state == PHY_VACANT || 1120 ex_phy->phy_state == PHY_NOT_PRESENT || 1121 ex_phy->phy_state == PHY_DEVICE_DISCOVERED) 1122 continue; 1123 1124 switch (ex_phy->linkrate) { 1125 case SAS_PHY_DISABLED: 1126 case SAS_PHY_RESET_PROBLEM: 1127 case SAS_SATA_PORT_SELECTOR: 1128 continue; 1129 default: 1130 res = sas_ex_discover_dev(dev, i); 1131 if (res) 1132 break; 1133 continue; 1134 } 1135 } 1136 1137 if (!res) 1138 sas_check_level_subtractive_boundary(dev); 1139 1140 return res; 1141} 1142 1143static int sas_check_ex_subtractive_boundary(struct domain_device *dev) 1144{ 1145 struct expander_device *ex = &dev->ex_dev; 1146 int i; 1147 u8 *sub_sas_addr = NULL; 1148 1149 if (dev->dev_type != SAS_EDGE_EXPANDER_DEVICE) 1150 return 0; 1151 1152 for (i = 0; i < ex->num_phys; i++) { 1153 struct ex_phy *phy = &ex->ex_phy[i]; 1154 1155 if (phy->phy_state == PHY_VACANT || 1156 phy->phy_state == PHY_NOT_PRESENT) 1157 continue; 1158 1159 if (dev_is_expander(phy->attached_dev_type) && 1160 phy->routing_attr == SUBTRACTIVE_ROUTING) { 1161 1162 if (!sub_sas_addr) 1163 sub_sas_addr = &phy->attached_sas_addr[0]; 1164 else if (SAS_ADDR(sub_sas_addr) != 1165 SAS_ADDR(phy->attached_sas_addr)) { 1166 1167 pr_notice("ex %016llx phy%02d diverges(%016llx) on subtractive boundary(%016llx). Disabled\n", 1168 SAS_ADDR(dev->sas_addr), i, 1169 SAS_ADDR(phy->attached_sas_addr), 1170 SAS_ADDR(sub_sas_addr)); 1171 sas_ex_disable_phy(dev, i); 1172 } 1173 } 1174 } 1175 return 0; 1176} 1177 1178static void sas_print_parent_topology_bug(struct domain_device *child, 1179 struct ex_phy *parent_phy, 1180 struct ex_phy *child_phy) 1181{ 1182 static const char *ex_type[] = { 1183 [SAS_EDGE_EXPANDER_DEVICE] = "edge", 1184 [SAS_FANOUT_EXPANDER_DEVICE] = "fanout", 1185 }; 1186 struct domain_device *parent = child->parent; 1187 1188 pr_notice("%s ex %016llx phy%02d <--> %s ex %016llx phy%02d has %c:%c routing link!\n", 1189 ex_type[parent->dev_type], 1190 SAS_ADDR(parent->sas_addr), 1191 parent_phy->phy_id, 1192 1193 ex_type[child->dev_type], 1194 SAS_ADDR(child->sas_addr), 1195 child_phy->phy_id, 1196 1197 sas_route_char(parent, parent_phy), 1198 sas_route_char(child, child_phy)); 1199} 1200 1201static bool sas_eeds_valid(struct domain_device *parent, 1202 struct domain_device *child) 1203{ 1204 struct sas_discovery *disc = &parent->port->disc; 1205 1206 return (SAS_ADDR(disc->eeds_a) == SAS_ADDR(parent->sas_addr) || 1207 SAS_ADDR(disc->eeds_a) == SAS_ADDR(child->sas_addr)) && 1208 (SAS_ADDR(disc->eeds_b) == SAS_ADDR(parent->sas_addr) || 1209 SAS_ADDR(disc->eeds_b) == SAS_ADDR(child->sas_addr)); 1210} 1211 1212static int sas_check_eeds(struct domain_device *child, 1213 struct ex_phy *parent_phy, 1214 struct ex_phy *child_phy) 1215{ 1216 int res = 0; 1217 struct domain_device *parent = child->parent; 1218 struct sas_discovery *disc = &parent->port->disc; 1219 1220 if (SAS_ADDR(disc->fanout_sas_addr) != 0) { 1221 res = -ENODEV; 1222 pr_warn("edge ex %016llx phy S:%02d <--> edge ex %016llx phy S:%02d, while there is a fanout ex %016llx\n", 1223 SAS_ADDR(parent->sas_addr), 1224 parent_phy->phy_id, 1225 SAS_ADDR(child->sas_addr), 1226 child_phy->phy_id, 1227 SAS_ADDR(disc->fanout_sas_addr)); 1228 } else if (SAS_ADDR(disc->eeds_a) == 0) { 1229 memcpy(disc->eeds_a, parent->sas_addr, SAS_ADDR_SIZE); 1230 memcpy(disc->eeds_b, child->sas_addr, SAS_ADDR_SIZE); 1231 } else if (!sas_eeds_valid(parent, child)) { 1232 res = -ENODEV; 1233 pr_warn("edge ex %016llx phy%02d <--> edge ex %016llx phy%02d link forms a third EEDS!\n", 1234 SAS_ADDR(parent->sas_addr), 1235 parent_phy->phy_id, 1236 SAS_ADDR(child->sas_addr), 1237 child_phy->phy_id); 1238 } 1239 1240 return res; 1241} 1242 1243static int sas_check_edge_expander_topo(struct domain_device *child, 1244 struct ex_phy *parent_phy) 1245{ 1246 struct expander_device *child_ex = &child->ex_dev; 1247 struct expander_device *parent_ex = &child->parent->ex_dev; 1248 struct ex_phy *child_phy; 1249 1250 child_phy = &child_ex->ex_phy[parent_phy->attached_phy_id]; 1251 1252 if (child->dev_type == SAS_FANOUT_EXPANDER_DEVICE) { 1253 if (parent_phy->routing_attr != SUBTRACTIVE_ROUTING || 1254 child_phy->routing_attr != TABLE_ROUTING) 1255 goto error; 1256 } else if (parent_phy->routing_attr == SUBTRACTIVE_ROUTING) { 1257 if (child_phy->routing_attr == SUBTRACTIVE_ROUTING) 1258 return sas_check_eeds(child, parent_phy, child_phy); 1259 else if (child_phy->routing_attr != TABLE_ROUTING) 1260 goto error; 1261 } else if (parent_phy->routing_attr == TABLE_ROUTING) { 1262 if (child_phy->routing_attr != SUBTRACTIVE_ROUTING && 1263 (child_phy->routing_attr != TABLE_ROUTING || 1264 !child_ex->t2t_supp || !parent_ex->t2t_supp)) 1265 goto error; 1266 } 1267 1268 return 0; 1269error: 1270 sas_print_parent_topology_bug(child, parent_phy, child_phy); 1271 return -ENODEV; 1272} 1273 1274static int sas_check_fanout_expander_topo(struct domain_device *child, 1275 struct ex_phy *parent_phy) 1276{ 1277 struct expander_device *child_ex = &child->ex_dev; 1278 struct ex_phy *child_phy; 1279 1280 child_phy = &child_ex->ex_phy[parent_phy->attached_phy_id]; 1281 1282 if (parent_phy->routing_attr == TABLE_ROUTING && 1283 child_phy->routing_attr == SUBTRACTIVE_ROUTING) 1284 return 0; 1285 1286 sas_print_parent_topology_bug(child, parent_phy, child_phy); 1287 1288 return -ENODEV; 1289} 1290 1291static int sas_check_parent_topology(struct domain_device *child) 1292{ 1293 struct expander_device *parent_ex; 1294 int i; 1295 int res = 0; 1296 1297 if (!child->parent) 1298 return 0; 1299 1300 if (!dev_is_expander(child->parent->dev_type)) 1301 return 0; 1302 1303 parent_ex = &child->parent->ex_dev; 1304 1305 for (i = 0; i < parent_ex->num_phys; i++) { 1306 struct ex_phy *parent_phy = &parent_ex->ex_phy[i]; 1307 1308 if (parent_phy->phy_state == PHY_VACANT || 1309 parent_phy->phy_state == PHY_NOT_PRESENT) 1310 continue; 1311 1312 if (!sas_phy_match_dev_addr(child, parent_phy)) 1313 continue; 1314 1315 switch (child->parent->dev_type) { 1316 case SAS_EDGE_EXPANDER_DEVICE: 1317 if (sas_check_edge_expander_topo(child, parent_phy)) 1318 res = -ENODEV; 1319 break; 1320 case SAS_FANOUT_EXPANDER_DEVICE: 1321 if (sas_check_fanout_expander_topo(child, parent_phy)) 1322 res = -ENODEV; 1323 break; 1324 default: 1325 break; 1326 } 1327 } 1328 1329 return res; 1330} 1331 1332#define RRI_REQ_SIZE 16 1333#define RRI_RESP_SIZE 44 1334 1335static int sas_configure_present(struct domain_device *dev, int phy_id, 1336 u8 *sas_addr, int *index, int *present) 1337{ 1338 int i, res = 0; 1339 struct expander_device *ex = &dev->ex_dev; 1340 struct ex_phy *phy = &ex->ex_phy[phy_id]; 1341 u8 *rri_req; 1342 u8 *rri_resp; 1343 1344 *present = 0; 1345 *index = 0; 1346 1347 rri_req = alloc_smp_req(RRI_REQ_SIZE); 1348 if (!rri_req) 1349 return -ENOMEM; 1350 1351 rri_resp = alloc_smp_resp(RRI_RESP_SIZE); 1352 if (!rri_resp) { 1353 kfree(rri_req); 1354 return -ENOMEM; 1355 } 1356 1357 rri_req[1] = SMP_REPORT_ROUTE_INFO; 1358 rri_req[9] = phy_id; 1359 1360 for (i = 0; i < ex->max_route_indexes ; i++) { 1361 *(__be16 *)(rri_req+6) = cpu_to_be16(i); 1362 res = smp_execute_task(dev, rri_req, RRI_REQ_SIZE, rri_resp, 1363 RRI_RESP_SIZE); 1364 if (res) 1365 goto out; 1366 res = rri_resp[2]; 1367 if (res == SMP_RESP_NO_INDEX) { 1368 pr_warn("overflow of indexes: dev %016llx phy%02d index 0x%x\n", 1369 SAS_ADDR(dev->sas_addr), phy_id, i); 1370 goto out; 1371 } else if (res != SMP_RESP_FUNC_ACC) { 1372 pr_notice("%s: dev %016llx phy%02d index 0x%x result 0x%x\n", 1373 __func__, SAS_ADDR(dev->sas_addr), phy_id, 1374 i, res); 1375 goto out; 1376 } 1377 if (SAS_ADDR(sas_addr) != 0) { 1378 if (SAS_ADDR(rri_resp+16) == SAS_ADDR(sas_addr)) { 1379 *index = i; 1380 if ((rri_resp[12] & 0x80) == 0x80) 1381 *present = 0; 1382 else 1383 *present = 1; 1384 goto out; 1385 } else if (SAS_ADDR(rri_resp+16) == 0) { 1386 *index = i; 1387 *present = 0; 1388 goto out; 1389 } 1390 } else if (SAS_ADDR(rri_resp+16) == 0 && 1391 phy->last_da_index < i) { 1392 phy->last_da_index = i; 1393 *index = i; 1394 *present = 0; 1395 goto out; 1396 } 1397 } 1398 res = -1; 1399out: 1400 kfree(rri_req); 1401 kfree(rri_resp); 1402 return res; 1403} 1404 1405#define CRI_REQ_SIZE 44 1406#define CRI_RESP_SIZE 8 1407 1408static int sas_configure_set(struct domain_device *dev, int phy_id, 1409 u8 *sas_addr, int index, int include) 1410{ 1411 int res; 1412 u8 *cri_req; 1413 u8 *cri_resp; 1414 1415 cri_req = alloc_smp_req(CRI_REQ_SIZE); 1416 if (!cri_req) 1417 return -ENOMEM; 1418 1419 cri_resp = alloc_smp_resp(CRI_RESP_SIZE); 1420 if (!cri_resp) { 1421 kfree(cri_req); 1422 return -ENOMEM; 1423 } 1424 1425 cri_req[1] = SMP_CONF_ROUTE_INFO; 1426 *(__be16 *)(cri_req+6) = cpu_to_be16(index); 1427 cri_req[9] = phy_id; 1428 if (SAS_ADDR(sas_addr) == 0 || !include) 1429 cri_req[12] |= 0x80; 1430 memcpy(cri_req+16, sas_addr, SAS_ADDR_SIZE); 1431 1432 res = smp_execute_task(dev, cri_req, CRI_REQ_SIZE, cri_resp, 1433 CRI_RESP_SIZE); 1434 if (res) 1435 goto out; 1436 res = cri_resp[2]; 1437 if (res == SMP_RESP_NO_INDEX) { 1438 pr_warn("overflow of indexes: dev %016llx phy%02d index 0x%x\n", 1439 SAS_ADDR(dev->sas_addr), phy_id, index); 1440 } 1441out: 1442 kfree(cri_req); 1443 kfree(cri_resp); 1444 return res; 1445} 1446 1447static int sas_configure_phy(struct domain_device *dev, int phy_id, 1448 u8 *sas_addr, int include) 1449{ 1450 int index; 1451 int present; 1452 int res; 1453 1454 res = sas_configure_present(dev, phy_id, sas_addr, &index, &present); 1455 if (res) 1456 return res; 1457 if (include ^ present) 1458 return sas_configure_set(dev, phy_id, sas_addr, index, 1459 include); 1460 1461 return res; 1462} 1463 1464/** 1465 * sas_configure_parent - configure routing table of parent 1466 * @parent: parent expander 1467 * @child: child expander 1468 * @sas_addr: SAS port identifier of device directly attached to child 1469 * @include: whether or not to include @child in the expander routing table 1470 */ 1471static int sas_configure_parent(struct domain_device *parent, 1472 struct domain_device *child, 1473 u8 *sas_addr, int include) 1474{ 1475 struct expander_device *ex_parent = &parent->ex_dev; 1476 int res = 0; 1477 int i; 1478 1479 if (parent->parent) { 1480 res = sas_configure_parent(parent->parent, parent, sas_addr, 1481 include); 1482 if (res) 1483 return res; 1484 } 1485 1486 if (ex_parent->conf_route_table == 0) { 1487 pr_debug("ex %016llx has self-configuring routing table\n", 1488 SAS_ADDR(parent->sas_addr)); 1489 return 0; 1490 } 1491 1492 for (i = 0; i < ex_parent->num_phys; i++) { 1493 struct ex_phy *phy = &ex_parent->ex_phy[i]; 1494 1495 if ((phy->routing_attr == TABLE_ROUTING) && 1496 sas_phy_match_dev_addr(child, phy)) { 1497 res = sas_configure_phy(parent, i, sas_addr, include); 1498 if (res) 1499 return res; 1500 } 1501 } 1502 1503 return res; 1504} 1505 1506/** 1507 * sas_configure_routing - configure routing 1508 * @dev: expander device 1509 * @sas_addr: port identifier of device directly attached to the expander device 1510 */ 1511static int sas_configure_routing(struct domain_device *dev, u8 *sas_addr) 1512{ 1513 if (dev->parent) 1514 return sas_configure_parent(dev->parent, dev, sas_addr, 1); 1515 return 0; 1516} 1517 1518static int sas_disable_routing(struct domain_device *dev, u8 *sas_addr) 1519{ 1520 if (dev->parent) 1521 return sas_configure_parent(dev->parent, dev, sas_addr, 0); 1522 return 0; 1523} 1524 1525/** 1526 * sas_discover_expander - expander discovery 1527 * @dev: pointer to expander domain device 1528 * 1529 * See comment in sas_discover_sata(). 1530 */ 1531static int sas_discover_expander(struct domain_device *dev) 1532{ 1533 int res; 1534 1535 res = sas_notify_lldd_dev_found(dev); 1536 if (res) 1537 return res; 1538 1539 res = sas_ex_general(dev); 1540 if (res) 1541 goto out_err; 1542 res = sas_ex_manuf_info(dev); 1543 if (res) 1544 goto out_err; 1545 1546 res = sas_expander_discover(dev); 1547 if (res) { 1548 pr_warn("expander %016llx discovery failed(0x%x)\n", 1549 SAS_ADDR(dev->sas_addr), res); 1550 goto out_err; 1551 } 1552 1553 sas_check_ex_subtractive_boundary(dev); 1554 res = sas_check_parent_topology(dev); 1555 if (res) 1556 goto out_err; 1557 return 0; 1558out_err: 1559 sas_notify_lldd_dev_gone(dev); 1560 return res; 1561} 1562 1563static int sas_ex_level_discovery(struct asd_sas_port *port, const int level) 1564{ 1565 int res = 0; 1566 struct domain_device *dev; 1567 1568 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 1569 if (dev_is_expander(dev->dev_type)) { 1570 struct sas_expander_device *ex = 1571 rphy_to_expander_device(dev->rphy); 1572 1573 if (level == ex->level) 1574 res = sas_ex_discover_devices(dev, -1); 1575 else if (level > 0) 1576 res = sas_ex_discover_devices(port->port_dev, -1); 1577 1578 } 1579 } 1580 1581 return res; 1582} 1583 1584static int sas_ex_bfs_disc(struct asd_sas_port *port) 1585{ 1586 int res; 1587 int level; 1588 1589 do { 1590 level = port->disc.max_level; 1591 res = sas_ex_level_discovery(port, level); 1592 mb(); 1593 } while (level < port->disc.max_level); 1594 1595 return res; 1596} 1597 1598int sas_discover_root_expander(struct domain_device *dev) 1599{ 1600 int res; 1601 struct sas_expander_device *ex = rphy_to_expander_device(dev->rphy); 1602 1603 res = sas_rphy_add(dev->rphy); 1604 if (res) 1605 goto out_err; 1606 1607 ex->level = dev->port->disc.max_level; /* 0 */ 1608 res = sas_discover_expander(dev); 1609 if (res) 1610 goto out_err2; 1611 1612 sas_ex_bfs_disc(dev->port); 1613 1614 return res; 1615 1616out_err2: 1617 sas_rphy_remove(dev->rphy); 1618out_err: 1619 return res; 1620} 1621 1622/* ---------- Domain revalidation ---------- */ 1623 1624static void sas_get_sas_addr_and_dev_type(struct smp_disc_resp *disc_resp, 1625 u8 *sas_addr, 1626 enum sas_device_type *type) 1627{ 1628 memcpy(sas_addr, disc_resp->disc.attached_sas_addr, SAS_ADDR_SIZE); 1629 *type = to_dev_type(&disc_resp->disc); 1630 if (*type == SAS_PHY_UNUSED) 1631 memset(sas_addr, 0, SAS_ADDR_SIZE); 1632} 1633 1634static int sas_get_phy_discover(struct domain_device *dev, 1635 int phy_id, struct smp_disc_resp *disc_resp) 1636{ 1637 int res; 1638 u8 *disc_req; 1639 1640 disc_req = alloc_smp_req(DISCOVER_REQ_SIZE); 1641 if (!disc_req) 1642 return -ENOMEM; 1643 1644 disc_req[1] = SMP_DISCOVER; 1645 disc_req[9] = phy_id; 1646 1647 res = smp_execute_task(dev, disc_req, DISCOVER_REQ_SIZE, 1648 disc_resp, DISCOVER_RESP_SIZE); 1649 if (res) 1650 goto out; 1651 if (disc_resp->result != SMP_RESP_FUNC_ACC) 1652 res = disc_resp->result; 1653out: 1654 kfree(disc_req); 1655 return res; 1656} 1657 1658static int sas_get_phy_change_count(struct domain_device *dev, 1659 int phy_id, int *pcc) 1660{ 1661 int res; 1662 struct smp_disc_resp *disc_resp; 1663 1664 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE); 1665 if (!disc_resp) 1666 return -ENOMEM; 1667 1668 res = sas_get_phy_discover(dev, phy_id, disc_resp); 1669 if (!res) 1670 *pcc = disc_resp->disc.change_count; 1671 1672 kfree(disc_resp); 1673 return res; 1674} 1675 1676int sas_get_phy_attached_dev(struct domain_device *dev, int phy_id, 1677 u8 *sas_addr, enum sas_device_type *type) 1678{ 1679 int res; 1680 struct smp_disc_resp *disc_resp; 1681 1682 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE); 1683 if (!disc_resp) 1684 return -ENOMEM; 1685 1686 res = sas_get_phy_discover(dev, phy_id, disc_resp); 1687 if (res == 0) 1688 sas_get_sas_addr_and_dev_type(disc_resp, sas_addr, type); 1689 kfree(disc_resp); 1690 return res; 1691} 1692 1693static int sas_find_bcast_phy(struct domain_device *dev, int *phy_id, 1694 int from_phy, bool update) 1695{ 1696 struct expander_device *ex = &dev->ex_dev; 1697 int res = 0; 1698 int i; 1699 1700 for (i = from_phy; i < ex->num_phys; i++) { 1701 int phy_change_count = 0; 1702 1703 res = sas_get_phy_change_count(dev, i, &phy_change_count); 1704 switch (res) { 1705 case SMP_RESP_PHY_VACANT: 1706 case SMP_RESP_NO_PHY: 1707 continue; 1708 case SMP_RESP_FUNC_ACC: 1709 break; 1710 default: 1711 return res; 1712 } 1713 1714 if (phy_change_count != ex->ex_phy[i].phy_change_count) { 1715 if (update) 1716 ex->ex_phy[i].phy_change_count = 1717 phy_change_count; 1718 *phy_id = i; 1719 return 0; 1720 } 1721 } 1722 return 0; 1723} 1724 1725static int sas_get_ex_change_count(struct domain_device *dev, int *ecc) 1726{ 1727 int res; 1728 u8 *rg_req; 1729 struct smp_rg_resp *rg_resp; 1730 1731 rg_req = alloc_smp_req(RG_REQ_SIZE); 1732 if (!rg_req) 1733 return -ENOMEM; 1734 1735 rg_resp = alloc_smp_resp(RG_RESP_SIZE); 1736 if (!rg_resp) { 1737 kfree(rg_req); 1738 return -ENOMEM; 1739 } 1740 1741 rg_req[1] = SMP_REPORT_GENERAL; 1742 1743 res = smp_execute_task(dev, rg_req, RG_REQ_SIZE, rg_resp, 1744 RG_RESP_SIZE); 1745 if (res) 1746 goto out; 1747 if (rg_resp->result != SMP_RESP_FUNC_ACC) { 1748 res = rg_resp->result; 1749 goto out; 1750 } 1751 1752 *ecc = be16_to_cpu(rg_resp->rg.change_count); 1753out: 1754 kfree(rg_resp); 1755 kfree(rg_req); 1756 return res; 1757} 1758/** 1759 * sas_find_bcast_dev - find the device issue BROADCAST(CHANGE). 1760 * @dev:domain device to be detect. 1761 * @src_dev: the device which originated BROADCAST(CHANGE). 1762 * 1763 * Add self-configuration expander support. Suppose two expander cascading, 1764 * when the first level expander is self-configuring, hotplug the disks in 1765 * second level expander, BROADCAST(CHANGE) will not only be originated 1766 * in the second level expander, but also be originated in the first level 1767 * expander (see SAS protocol SAS 2r-14, 7.11 for detail), it is to say, 1768 * expander changed count in two level expanders will all increment at least 1769 * once, but the phy which chang count has changed is the source device which 1770 * we concerned. 1771 */ 1772 1773static int sas_find_bcast_dev(struct domain_device *dev, 1774 struct domain_device **src_dev) 1775{ 1776 struct expander_device *ex = &dev->ex_dev; 1777 int ex_change_count = -1; 1778 int phy_id = -1; 1779 int res; 1780 struct domain_device *ch; 1781 1782 res = sas_get_ex_change_count(dev, &ex_change_count); 1783 if (res) 1784 goto out; 1785 if (ex_change_count != -1 && ex_change_count != ex->ex_change_count) { 1786 /* Just detect if this expander phys phy change count changed, 1787 * in order to determine if this expander originate BROADCAST, 1788 * and do not update phy change count field in our structure. 1789 */ 1790 res = sas_find_bcast_phy(dev, &phy_id, 0, false); 1791 if (phy_id != -1) { 1792 *src_dev = dev; 1793 ex->ex_change_count = ex_change_count; 1794 pr_info("ex %016llx phy%02d change count has changed\n", 1795 SAS_ADDR(dev->sas_addr), phy_id); 1796 return res; 1797 } else 1798 pr_info("ex %016llx phys DID NOT change\n", 1799 SAS_ADDR(dev->sas_addr)); 1800 } 1801 list_for_each_entry(ch, &ex->children, siblings) { 1802 if (dev_is_expander(ch->dev_type)) { 1803 res = sas_find_bcast_dev(ch, src_dev); 1804 if (*src_dev) 1805 return res; 1806 } 1807 } 1808out: 1809 return res; 1810} 1811 1812static void sas_unregister_ex_tree(struct asd_sas_port *port, struct domain_device *dev) 1813{ 1814 struct expander_device *ex = &dev->ex_dev; 1815 struct domain_device *child, *n; 1816 1817 list_for_each_entry_safe(child, n, &ex->children, siblings) { 1818 set_bit(SAS_DEV_GONE, &child->state); 1819 if (dev_is_expander(child->dev_type)) 1820 sas_unregister_ex_tree(port, child); 1821 else 1822 sas_unregister_dev(port, child); 1823 } 1824 sas_unregister_dev(port, dev); 1825} 1826 1827static void sas_unregister_devs_sas_addr(struct domain_device *parent, 1828 int phy_id, bool last) 1829{ 1830 struct expander_device *ex_dev = &parent->ex_dev; 1831 struct ex_phy *phy = &ex_dev->ex_phy[phy_id]; 1832 struct domain_device *child, *n, *found = NULL; 1833 if (last) { 1834 list_for_each_entry_safe(child, n, 1835 &ex_dev->children, siblings) { 1836 if (sas_phy_match_dev_addr(child, phy)) { 1837 set_bit(SAS_DEV_GONE, &child->state); 1838 if (dev_is_expander(child->dev_type)) 1839 sas_unregister_ex_tree(parent->port, child); 1840 else 1841 sas_unregister_dev(parent->port, child); 1842 found = child; 1843 break; 1844 } 1845 } 1846 sas_disable_routing(parent, phy->attached_sas_addr); 1847 } 1848 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE); 1849 if (phy->port) { 1850 sas_port_delete_phy(phy->port, phy->phy); 1851 sas_device_set_phy(found, phy->port); 1852 if (phy->port->num_phys == 0) 1853 list_add_tail(&phy->port->del_list, 1854 &parent->port->sas_port_del_list); 1855 phy->port = NULL; 1856 } 1857} 1858 1859static int sas_discover_bfs_by_root_level(struct domain_device *root, 1860 const int level) 1861{ 1862 struct expander_device *ex_root = &root->ex_dev; 1863 struct domain_device *child; 1864 int res = 0; 1865 1866 list_for_each_entry(child, &ex_root->children, siblings) { 1867 if (dev_is_expander(child->dev_type)) { 1868 struct sas_expander_device *ex = 1869 rphy_to_expander_device(child->rphy); 1870 1871 if (level > ex->level) 1872 res = sas_discover_bfs_by_root_level(child, 1873 level); 1874 else if (level == ex->level) 1875 res = sas_ex_discover_devices(child, -1); 1876 } 1877 } 1878 return res; 1879} 1880 1881static int sas_discover_bfs_by_root(struct domain_device *dev) 1882{ 1883 int res; 1884 struct sas_expander_device *ex = rphy_to_expander_device(dev->rphy); 1885 int level = ex->level+1; 1886 1887 res = sas_ex_discover_devices(dev, -1); 1888 if (res) 1889 goto out; 1890 do { 1891 res = sas_discover_bfs_by_root_level(dev, level); 1892 mb(); 1893 level += 1; 1894 } while (level <= dev->port->disc.max_level); 1895out: 1896 return res; 1897} 1898 1899static int sas_discover_new(struct domain_device *dev, int phy_id) 1900{ 1901 struct ex_phy *ex_phy = &dev->ex_dev.ex_phy[phy_id]; 1902 struct domain_device *child; 1903 int res; 1904 1905 pr_debug("ex %016llx phy%02d new device attached\n", 1906 SAS_ADDR(dev->sas_addr), phy_id); 1907 res = sas_ex_phy_discover(dev, phy_id); 1908 if (res) 1909 return res; 1910 1911 if (sas_ex_join_wide_port(dev, phy_id)) 1912 return 0; 1913 1914 res = sas_ex_discover_devices(dev, phy_id); 1915 if (res) 1916 return res; 1917 list_for_each_entry(child, &dev->ex_dev.children, siblings) { 1918 if (sas_phy_match_dev_addr(child, ex_phy)) { 1919 if (dev_is_expander(child->dev_type)) 1920 res = sas_discover_bfs_by_root(child); 1921 break; 1922 } 1923 } 1924 return res; 1925} 1926 1927static bool dev_type_flutter(enum sas_device_type new, enum sas_device_type old) 1928{ 1929 if (old == new) 1930 return true; 1931 1932 /* treat device directed resets as flutter, if we went 1933 * SAS_END_DEVICE to SAS_SATA_PENDING the link needs recovery 1934 */ 1935 if ((old == SAS_SATA_PENDING && new == SAS_END_DEVICE) || 1936 (old == SAS_END_DEVICE && new == SAS_SATA_PENDING)) 1937 return true; 1938 1939 return false; 1940} 1941 1942static int sas_rediscover_dev(struct domain_device *dev, int phy_id, 1943 bool last, int sibling) 1944{ 1945 struct expander_device *ex = &dev->ex_dev; 1946 struct ex_phy *phy = &ex->ex_phy[phy_id]; 1947 enum sas_device_type type = SAS_PHY_UNUSED; 1948 struct smp_disc_resp *disc_resp; 1949 u8 sas_addr[SAS_ADDR_SIZE]; 1950 char msg[80] = ""; 1951 int res; 1952 1953 if (!last) 1954 sprintf(msg, ", part of a wide port with phy%02d", sibling); 1955 1956 pr_debug("ex %016llx rediscovering phy%02d%s\n", 1957 SAS_ADDR(dev->sas_addr), phy_id, msg); 1958 1959 memset(sas_addr, 0, SAS_ADDR_SIZE); 1960 disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE); 1961 if (!disc_resp) 1962 return -ENOMEM; 1963 1964 res = sas_get_phy_discover(dev, phy_id, disc_resp); 1965 switch (res) { 1966 case SMP_RESP_NO_PHY: 1967 phy->phy_state = PHY_NOT_PRESENT; 1968 sas_unregister_devs_sas_addr(dev, phy_id, last); 1969 goto out_free_resp; 1970 case SMP_RESP_PHY_VACANT: 1971 phy->phy_state = PHY_VACANT; 1972 sas_unregister_devs_sas_addr(dev, phy_id, last); 1973 goto out_free_resp; 1974 case SMP_RESP_FUNC_ACC: 1975 break; 1976 case -ECOMM: 1977 break; 1978 default: 1979 goto out_free_resp; 1980 } 1981 1982 if (res == 0) 1983 sas_get_sas_addr_and_dev_type(disc_resp, sas_addr, &type); 1984 1985 if ((SAS_ADDR(sas_addr) == 0) || (res == -ECOMM)) { 1986 phy->phy_state = PHY_EMPTY; 1987 sas_unregister_devs_sas_addr(dev, phy_id, last); 1988 /* 1989 * Even though the PHY is empty, for convenience we update 1990 * the PHY info, like negotiated linkrate. 1991 */ 1992 if (res == 0) 1993 sas_set_ex_phy(dev, phy_id, disc_resp); 1994 goto out_free_resp; 1995 } else if (SAS_ADDR(sas_addr) == SAS_ADDR(phy->attached_sas_addr) && 1996 dev_type_flutter(type, phy->attached_dev_type)) { 1997 struct domain_device *ata_dev = sas_ex_to_ata(dev, phy_id); 1998 char *action = ""; 1999 2000 sas_ex_phy_discover(dev, phy_id); 2001 2002 if (ata_dev && phy->attached_dev_type == SAS_SATA_PENDING) 2003 action = ", needs recovery"; 2004 pr_debug("ex %016llx phy%02d broadcast flutter%s\n", 2005 SAS_ADDR(dev->sas_addr), phy_id, action); 2006 goto out_free_resp; 2007 } 2008 2009 /* we always have to delete the old device when we went here */ 2010 pr_info("ex %016llx phy%02d replace %016llx\n", 2011 SAS_ADDR(dev->sas_addr), phy_id, 2012 SAS_ADDR(phy->attached_sas_addr)); 2013 sas_unregister_devs_sas_addr(dev, phy_id, last); 2014 2015 res = sas_discover_new(dev, phy_id); 2016out_free_resp: 2017 kfree(disc_resp); 2018 return res; 2019} 2020 2021/** 2022 * sas_rediscover - revalidate the domain. 2023 * @dev:domain device to be detect. 2024 * @phy_id: the phy id will be detected. 2025 * 2026 * NOTE: this process _must_ quit (return) as soon as any connection 2027 * errors are encountered. Connection recovery is done elsewhere. 2028 * Discover process only interrogates devices in order to discover the 2029 * domain.For plugging out, we un-register the device only when it is 2030 * the last phy in the port, for other phys in this port, we just delete it 2031 * from the port.For inserting, we do discovery when it is the 2032 * first phy,for other phys in this port, we add it to the port to 2033 * forming the wide-port. 2034 */ 2035static int sas_rediscover(struct domain_device *dev, const int phy_id) 2036{ 2037 struct expander_device *ex = &dev->ex_dev; 2038 struct ex_phy *changed_phy = &ex->ex_phy[phy_id]; 2039 int res = 0; 2040 int i; 2041 bool last = true; /* is this the last phy of the port */ 2042 2043 pr_debug("ex %016llx phy%02d originated BROADCAST(CHANGE)\n", 2044 SAS_ADDR(dev->sas_addr), phy_id); 2045 2046 if (SAS_ADDR(changed_phy->attached_sas_addr) != 0) { 2047 for (i = 0; i < ex->num_phys; i++) { 2048 struct ex_phy *phy = &ex->ex_phy[i]; 2049 2050 if (i == phy_id) 2051 continue; 2052 if (sas_phy_addr_match(phy, changed_phy)) { 2053 last = false; 2054 break; 2055 } 2056 } 2057 res = sas_rediscover_dev(dev, phy_id, last, i); 2058 } else 2059 res = sas_discover_new(dev, phy_id); 2060 return res; 2061} 2062 2063/** 2064 * sas_ex_revalidate_domain - revalidate the domain 2065 * @port_dev: port domain device. 2066 * 2067 * NOTE: this process _must_ quit (return) as soon as any connection 2068 * errors are encountered. Connection recovery is done elsewhere. 2069 * Discover process only interrogates devices in order to discover the 2070 * domain. 2071 */ 2072int sas_ex_revalidate_domain(struct domain_device *port_dev) 2073{ 2074 int res; 2075 struct domain_device *dev = NULL; 2076 2077 res = sas_find_bcast_dev(port_dev, &dev); 2078 if (res == 0 && dev) { 2079 struct expander_device *ex = &dev->ex_dev; 2080 int i = 0, phy_id; 2081 2082 do { 2083 phy_id = -1; 2084 res = sas_find_bcast_phy(dev, &phy_id, i, true); 2085 if (phy_id == -1) 2086 break; 2087 res = sas_rediscover(dev, phy_id); 2088 i = phy_id + 1; 2089 } while (i < ex->num_phys); 2090 } 2091 return res; 2092} 2093 2094int sas_find_attached_phy_id(struct expander_device *ex_dev, 2095 struct domain_device *dev) 2096{ 2097 struct ex_phy *phy; 2098 int phy_id; 2099 2100 for (phy_id = 0; phy_id < ex_dev->num_phys; phy_id++) { 2101 phy = &ex_dev->ex_phy[phy_id]; 2102 if (sas_phy_match_dev_addr(dev, phy)) 2103 return phy_id; 2104 } 2105 2106 return -ENODEV; 2107} 2108EXPORT_SYMBOL_GPL(sas_find_attached_phy_id); 2109 2110void sas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost, 2111 struct sas_rphy *rphy) 2112{ 2113 struct domain_device *dev; 2114 unsigned int rcvlen = 0; 2115 int ret = -EINVAL; 2116 2117 /* no rphy means no smp target support (ie aic94xx host) */ 2118 if (!rphy) 2119 return sas_smp_host_handler(job, shost); 2120 2121 switch (rphy->identify.device_type) { 2122 case SAS_EDGE_EXPANDER_DEVICE: 2123 case SAS_FANOUT_EXPANDER_DEVICE: 2124 break; 2125 default: 2126 pr_err("%s: can we send a smp request to a device?\n", 2127 __func__); 2128 goto out; 2129 } 2130 2131 dev = sas_find_dev_by_rphy(rphy); 2132 if (!dev) { 2133 pr_err("%s: fail to find a domain_device?\n", __func__); 2134 goto out; 2135 } 2136 2137 /* do we need to support multiple segments? */ 2138 if (job->request_payload.sg_cnt > 1 || 2139 job->reply_payload.sg_cnt > 1) { 2140 pr_info("%s: multiple segments req %u, rsp %u\n", 2141 __func__, job->request_payload.payload_len, 2142 job->reply_payload.payload_len); 2143 goto out; 2144 } 2145 2146 ret = smp_execute_task_sg(dev, job->request_payload.sg_list, 2147 job->reply_payload.sg_list); 2148 if (ret >= 0) { 2149 /* bsg_job_done() requires the length received */ 2150 rcvlen = job->reply_payload.payload_len - ret; 2151 ret = 0; 2152 } 2153 2154out: 2155 bsg_job_done(job, ret, rcvlen); 2156} 2157