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(size, 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 int sas_get_phy_discover(struct domain_device *dev,
1625				int phy_id, struct smp_disc_resp *disc_resp)
1626{
1627	int res;
1628	u8 *disc_req;
1629
1630	disc_req = alloc_smp_req(DISCOVER_REQ_SIZE);
1631	if (!disc_req)
1632		return -ENOMEM;
1633
1634	disc_req[1] = SMP_DISCOVER;
1635	disc_req[9] = phy_id;
1636
1637	res = smp_execute_task(dev, disc_req, DISCOVER_REQ_SIZE,
1638			       disc_resp, DISCOVER_RESP_SIZE);
1639	if (res)
1640		goto out;
1641	if (disc_resp->result != SMP_RESP_FUNC_ACC)
1642		res = disc_resp->result;
 
 
1643out:
1644	kfree(disc_req);
1645	return res;
1646}
1647
1648static int sas_get_phy_change_count(struct domain_device *dev,
1649				    int phy_id, int *pcc)
1650{
1651	int res;
1652	struct smp_disc_resp *disc_resp;
1653
1654	disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
1655	if (!disc_resp)
1656		return -ENOMEM;
1657
1658	res = sas_get_phy_discover(dev, phy_id, disc_resp);
1659	if (!res)
1660		*pcc = disc_resp->disc.change_count;
1661
1662	kfree(disc_resp);
1663	return res;
1664}
1665
1666int sas_get_phy_attached_dev(struct domain_device *dev, int phy_id,
1667			     u8 *sas_addr, enum sas_device_type *type)
1668{
1669	int res;
1670	struct smp_disc_resp *disc_resp;
 
1671
1672	disc_resp = alloc_smp_resp(DISCOVER_RESP_SIZE);
1673	if (!disc_resp)
1674		return -ENOMEM;
 
1675
1676	res = sas_get_phy_discover(dev, phy_id, disc_resp);
1677	if (res == 0) {
1678		memcpy(sas_addr, disc_resp->disc.attached_sas_addr,
1679		       SAS_ADDR_SIZE);
1680		*type = to_dev_type(&disc_resp->disc);
1681		if (*type == 0)
1682			memset(sas_addr, 0, SAS_ADDR_SIZE);
1683	}
1684	kfree(disc_resp);
1685	return res;
1686}
1687
1688static int sas_find_bcast_phy(struct domain_device *dev, int *phy_id,
1689			      int from_phy, bool update)
1690{
1691	struct expander_device *ex = &dev->ex_dev;
1692	int res = 0;
1693	int i;
1694
1695	for (i = from_phy; i < ex->num_phys; i++) {
1696		int phy_change_count = 0;
1697
1698		res = sas_get_phy_change_count(dev, i, &phy_change_count);
1699		switch (res) {
1700		case SMP_RESP_PHY_VACANT:
1701		case SMP_RESP_NO_PHY:
1702			continue;
1703		case SMP_RESP_FUNC_ACC:
1704			break;
1705		default:
1706			return res;
1707		}
1708
1709		if (phy_change_count != ex->ex_phy[i].phy_change_count) {
1710			if (update)
1711				ex->ex_phy[i].phy_change_count =
1712					phy_change_count;
1713			*phy_id = i;
1714			return 0;
1715		}
1716	}
1717	return 0;
 
1718}
1719
1720static int sas_get_ex_change_count(struct domain_device *dev, int *ecc)
1721{
1722	int res;
1723	u8  *rg_req;
1724	struct smp_rg_resp  *rg_resp;
1725
1726	rg_req = alloc_smp_req(RG_REQ_SIZE);
1727	if (!rg_req)
1728		return -ENOMEM;
1729
1730	rg_resp = alloc_smp_resp(RG_RESP_SIZE);
1731	if (!rg_resp) {
1732		kfree(rg_req);
1733		return -ENOMEM;
1734	}
1735
1736	rg_req[1] = SMP_REPORT_GENERAL;
1737
1738	res = smp_execute_task(dev, rg_req, RG_REQ_SIZE, rg_resp,
1739			       RG_RESP_SIZE);
1740	if (res)
1741		goto out;
1742	if (rg_resp->result != SMP_RESP_FUNC_ACC) {
1743		res = rg_resp->result;
1744		goto out;
1745	}
1746
1747	*ecc = be16_to_cpu(rg_resp->rg.change_count);
1748out:
1749	kfree(rg_resp);
1750	kfree(rg_req);
1751	return res;
1752}
1753/**
1754 * sas_find_bcast_dev -  find the device issue BROADCAST(CHANGE).
1755 * @dev:domain device to be detect.
1756 * @src_dev: the device which originated BROADCAST(CHANGE).
1757 *
1758 * Add self-configuration expander support. Suppose two expander cascading,
1759 * when the first level expander is self-configuring, hotplug the disks in
1760 * second level expander, BROADCAST(CHANGE) will not only be originated
1761 * in the second level expander, but also be originated in the first level
1762 * expander (see SAS protocol SAS 2r-14, 7.11 for detail), it is to say,
1763 * expander changed count in two level expanders will all increment at least
1764 * once, but the phy which chang count has changed is the source device which
1765 * we concerned.
1766 */
1767
1768static int sas_find_bcast_dev(struct domain_device *dev,
1769			      struct domain_device **src_dev)
1770{
1771	struct expander_device *ex = &dev->ex_dev;
1772	int ex_change_count = -1;
1773	int phy_id = -1;
1774	int res;
1775	struct domain_device *ch;
1776
1777	res = sas_get_ex_change_count(dev, &ex_change_count);
1778	if (res)
1779		goto out;
1780	if (ex_change_count != -1 && ex_change_count != ex->ex_change_count) {
1781		/* Just detect if this expander phys phy change count changed,
1782		* in order to determine if this expander originate BROADCAST,
1783		* and do not update phy change count field in our structure.
1784		*/
1785		res = sas_find_bcast_phy(dev, &phy_id, 0, false);
1786		if (phy_id != -1) {
1787			*src_dev = dev;
1788			ex->ex_change_count = ex_change_count;
1789			pr_info("ex %016llx phy%02d change count has changed\n",
1790				SAS_ADDR(dev->sas_addr), phy_id);
1791			return res;
1792		} else
1793			pr_info("ex %016llx phys DID NOT change\n",
1794				SAS_ADDR(dev->sas_addr));
1795	}
1796	list_for_each_entry(ch, &ex->children, siblings) {
1797		if (dev_is_expander(ch->dev_type)) {
1798			res = sas_find_bcast_dev(ch, src_dev);
1799			if (*src_dev)
1800				return res;
1801		}
1802	}
1803out:
1804	return res;
1805}
1806
1807static void sas_unregister_ex_tree(struct asd_sas_port *port, struct domain_device *dev)
1808{
1809	struct expander_device *ex = &dev->ex_dev;
1810	struct domain_device *child, *n;
1811
1812	list_for_each_entry_safe(child, n, &ex->children, siblings) {
1813		set_bit(SAS_DEV_GONE, &child->state);
1814		if (dev_is_expander(child->dev_type))
1815			sas_unregister_ex_tree(port, child);
 
1816		else
1817			sas_unregister_dev(port, child);
1818	}
1819	sas_unregister_dev(port, dev);
1820}
1821
1822static void sas_unregister_devs_sas_addr(struct domain_device *parent,
1823					 int phy_id, bool last)
1824{
1825	struct expander_device *ex_dev = &parent->ex_dev;
1826	struct ex_phy *phy = &ex_dev->ex_phy[phy_id];
1827	struct domain_device *child, *n, *found = NULL;
1828	if (last) {
1829		list_for_each_entry_safe(child, n,
1830			&ex_dev->children, siblings) {
1831			if (sas_phy_match_dev_addr(child, phy)) {
1832				set_bit(SAS_DEV_GONE, &child->state);
1833				if (dev_is_expander(child->dev_type))
1834					sas_unregister_ex_tree(parent->port, child);
 
 
1835				else
1836					sas_unregister_dev(parent->port, child);
1837				found = child;
1838				break;
1839			}
1840		}
 
1841		sas_disable_routing(parent, phy->attached_sas_addr);
1842	}
1843	memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
1844	if (phy->port) {
1845		sas_port_delete_phy(phy->port, phy->phy);
1846		sas_device_set_phy(found, phy->port);
1847		if (phy->port->num_phys == 0)
1848			list_add_tail(&phy->port->del_list,
1849				&parent->port->sas_port_del_list);
1850		phy->port = NULL;
1851	}
1852}
1853
1854static int sas_discover_bfs_by_root_level(struct domain_device *root,
1855					  const int level)
1856{
1857	struct expander_device *ex_root = &root->ex_dev;
1858	struct domain_device *child;
1859	int res = 0;
1860
1861	list_for_each_entry(child, &ex_root->children, siblings) {
1862		if (dev_is_expander(child->dev_type)) {
 
1863			struct sas_expander_device *ex =
1864				rphy_to_expander_device(child->rphy);
1865
1866			if (level > ex->level)
1867				res = sas_discover_bfs_by_root_level(child,
1868								     level);
1869			else if (level == ex->level)
1870				res = sas_ex_discover_devices(child, -1);
1871		}
1872	}
1873	return res;
1874}
1875
1876static int sas_discover_bfs_by_root(struct domain_device *dev)
1877{
1878	int res;
1879	struct sas_expander_device *ex = rphy_to_expander_device(dev->rphy);
1880	int level = ex->level+1;
1881
1882	res = sas_ex_discover_devices(dev, -1);
1883	if (res)
1884		goto out;
1885	do {
1886		res = sas_discover_bfs_by_root_level(dev, level);
1887		mb();
1888		level += 1;
1889	} while (level <= dev->port->disc.max_level);
1890out:
1891	return res;
1892}
1893
1894static int sas_discover_new(struct domain_device *dev, int phy_id)
1895{
1896	struct ex_phy *ex_phy = &dev->ex_dev.ex_phy[phy_id];
1897	struct domain_device *child;
1898	int res;
 
1899
1900	pr_debug("ex %016llx phy%02d new device attached\n",
1901		 SAS_ADDR(dev->sas_addr), phy_id);
1902	res = sas_ex_phy_discover(dev, phy_id);
1903	if (res)
1904		return res;
1905
1906	if (sas_ex_join_wide_port(dev, phy_id))
 
 
 
 
 
 
 
 
 
 
 
1907		return 0;
1908
1909	res = sas_ex_discover_devices(dev, phy_id);
1910	if (res)
1911		return res;
1912	list_for_each_entry(child, &dev->ex_dev.children, siblings) {
1913		if (sas_phy_match_dev_addr(child, ex_phy)) {
1914			if (dev_is_expander(child->dev_type))
 
 
1915				res = sas_discover_bfs_by_root(child);
1916			break;
1917		}
1918	}
 
1919	return res;
1920}
1921
1922static bool dev_type_flutter(enum sas_device_type new, enum sas_device_type old)
1923{
1924	if (old == new)
1925		return true;
1926
1927	/* treat device directed resets as flutter, if we went
1928	 * SAS_END_DEVICE to SAS_SATA_PENDING the link needs recovery
1929	 */
1930	if ((old == SAS_SATA_PENDING && new == SAS_END_DEVICE) ||
1931	    (old == SAS_END_DEVICE && new == SAS_SATA_PENDING))
1932		return true;
1933
1934	return false;
1935}
1936
1937static int sas_rediscover_dev(struct domain_device *dev, int phy_id,
1938			      bool last, int sibling)
1939{
1940	struct expander_device *ex = &dev->ex_dev;
1941	struct ex_phy *phy = &ex->ex_phy[phy_id];
1942	enum sas_device_type type = SAS_PHY_UNUSED;
1943	u8 sas_addr[SAS_ADDR_SIZE];
1944	char msg[80] = "";
1945	int res;
1946
1947	if (!last)
1948		sprintf(msg, ", part of a wide port with phy%02d", sibling);
1949
1950	pr_debug("ex %016llx rediscovering phy%02d%s\n",
1951		 SAS_ADDR(dev->sas_addr), phy_id, msg);
1952
1953	memset(sas_addr, 0, SAS_ADDR_SIZE);
1954	res = sas_get_phy_attached_dev(dev, phy_id, sas_addr, &type);
1955	switch (res) {
1956	case SMP_RESP_NO_PHY:
1957		phy->phy_state = PHY_NOT_PRESENT;
1958		sas_unregister_devs_sas_addr(dev, phy_id, last);
1959		return res;
1960	case SMP_RESP_PHY_VACANT:
1961		phy->phy_state = PHY_VACANT;
1962		sas_unregister_devs_sas_addr(dev, phy_id, last);
1963		return res;
1964	case SMP_RESP_FUNC_ACC:
1965		break;
1966	case -ECOMM:
1967		break;
1968	default:
1969		return res;
1970	}
1971
1972	if ((SAS_ADDR(sas_addr) == 0) || (res == -ECOMM)) {
1973		phy->phy_state = PHY_EMPTY;
1974		sas_unregister_devs_sas_addr(dev, phy_id, last);
1975		/*
1976		 * Even though the PHY is empty, for convenience we discover
1977		 * the PHY to update the PHY info, like negotiated linkrate.
1978		 */
1979		sas_ex_phy_discover(dev, phy_id);
1980		return res;
1981	} else if (SAS_ADDR(sas_addr) == SAS_ADDR(phy->attached_sas_addr) &&
1982		   dev_type_flutter(type, phy->attached_dev_type)) {
1983		struct domain_device *ata_dev = sas_ex_to_ata(dev, phy_id);
1984		char *action = "";
1985
1986		sas_ex_phy_discover(dev, phy_id);
1987
1988		if (ata_dev && phy->attached_dev_type == SAS_SATA_PENDING)
1989			action = ", needs recovery";
1990		pr_debug("ex %016llx phy%02d broadcast flutter%s\n",
1991			 SAS_ADDR(dev->sas_addr), phy_id, action);
1992		return res;
1993	}
1994
1995	/* we always have to delete the old device when we went here */
1996	pr_info("ex %016llx phy%02d replace %016llx\n",
1997		SAS_ADDR(dev->sas_addr), phy_id,
1998		SAS_ADDR(phy->attached_sas_addr));
1999	sas_unregister_devs_sas_addr(dev, phy_id, last);
2000
2001	return sas_discover_new(dev, phy_id);
2002}
2003
2004/**
2005 * sas_rediscover - revalidate the domain.
2006 * @dev:domain device to be detect.
2007 * @phy_id: the phy id will be detected.
2008 *
2009 * NOTE: this process _must_ quit (return) as soon as any connection
2010 * errors are encountered.  Connection recovery is done elsewhere.
2011 * Discover process only interrogates devices in order to discover the
2012 * domain.For plugging out, we un-register the device only when it is
2013 * the last phy in the port, for other phys in this port, we just delete it
2014 * from the port.For inserting, we do discovery when it is the
2015 * first phy,for other phys in this port, we add it to the port to
2016 * forming the wide-port.
2017 */
2018static int sas_rediscover(struct domain_device *dev, const int phy_id)
2019{
2020	struct expander_device *ex = &dev->ex_dev;
2021	struct ex_phy *changed_phy = &ex->ex_phy[phy_id];
2022	int res = 0;
2023	int i;
2024	bool last = true;	/* is this the last phy of the port */
2025
2026	pr_debug("ex %016llx phy%02d originated BROADCAST(CHANGE)\n",
2027		 SAS_ADDR(dev->sas_addr), phy_id);
2028
2029	if (SAS_ADDR(changed_phy->attached_sas_addr) != 0) {
2030		for (i = 0; i < ex->num_phys; i++) {
2031			struct ex_phy *phy = &ex->ex_phy[i];
2032
2033			if (i == phy_id)
2034				continue;
2035			if (sas_phy_addr_match(phy, changed_phy)) {
 
 
 
2036				last = false;
2037				break;
2038			}
2039		}
2040		res = sas_rediscover_dev(dev, phy_id, last, i);
2041	} else
2042		res = sas_discover_new(dev, phy_id);
2043	return res;
2044}
2045
2046/**
2047 * sas_ex_revalidate_domain - revalidate the domain
2048 * @port_dev: port domain device.
2049 *
2050 * NOTE: this process _must_ quit (return) as soon as any connection
2051 * errors are encountered.  Connection recovery is done elsewhere.
2052 * Discover process only interrogates devices in order to discover the
2053 * domain.
2054 */
2055int sas_ex_revalidate_domain(struct domain_device *port_dev)
2056{
2057	int res;
2058	struct domain_device *dev = NULL;
2059
2060	res = sas_find_bcast_dev(port_dev, &dev);
2061	if (res == 0 && dev) {
 
 
2062		struct expander_device *ex = &dev->ex_dev;
2063		int i = 0, phy_id;
2064
2065		do {
2066			phy_id = -1;
2067			res = sas_find_bcast_phy(dev, &phy_id, i, true);
2068			if (phy_id == -1)
2069				break;
2070			res = sas_rediscover(dev, phy_id);
2071			i = phy_id + 1;
2072		} while (i < ex->num_phys);
2073	}
 
2074	return res;
2075}
2076
2077int sas_find_attached_phy_id(struct expander_device *ex_dev,
2078			     struct domain_device *dev)
2079{
2080	struct ex_phy *phy;
2081	int phy_id;
 
2082
2083	for (phy_id = 0; phy_id < ex_dev->num_phys; phy_id++) {
2084		phy = &ex_dev->ex_phy[phy_id];
2085		if (sas_phy_match_dev_addr(dev, phy))
2086			return phy_id;
2087	}
2088
2089	return -ENODEV;
2090}
2091EXPORT_SYMBOL_GPL(sas_find_attached_phy_id);
2092
2093void sas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost,
2094		struct sas_rphy *rphy)
2095{
2096	struct domain_device *dev;
2097	unsigned int rcvlen = 0;
2098	int ret = -EINVAL;
2099
2100	/* no rphy means no smp target support (ie aic94xx host) */
2101	if (!rphy)
2102		return sas_smp_host_handler(job, shost);
2103
2104	switch (rphy->identify.device_type) {
2105	case SAS_EDGE_EXPANDER_DEVICE:
2106	case SAS_FANOUT_EXPANDER_DEVICE:
2107		break;
2108	default:
2109		pr_err("%s: can we send a smp request to a device?\n",
2110		       __func__);
2111		goto out;
2112	}
2113
2114	dev = sas_find_dev_by_rphy(rphy);
2115	if (!dev) {
2116		pr_err("%s: fail to find a domain_device?\n", __func__);
2117		goto out;
2118	}
2119
2120	/* do we need to support multiple segments? */
2121	if (job->request_payload.sg_cnt > 1 ||
2122	    job->reply_payload.sg_cnt > 1) {
2123		pr_info("%s: multiple segments req %u, rsp %u\n",
2124			__func__, job->request_payload.payload_len,
2125			job->reply_payload.payload_len);
2126		goto out;
2127	}
2128
2129	ret = smp_execute_task_sg(dev, job->request_payload.sg_list,
2130			job->reply_payload.sg_list);
2131	if (ret >= 0) {
2132		/* bsg_job_done() requires the length received  */
2133		rcvlen = job->reply_payload.payload_len - ret;
 
2134		ret = 0;
 
 
 
2135	}
2136
2137out:
2138	bsg_job_done(job, ret, rcvlen);
2139}